beads/cmd/bd/list_output.go
matt wilkie 7ada7900d8
fix(list): emit informative truncation hint in all output modes (GH#3212) (#3243)
* fix(list): show informative truncation hint and emit in JSON mode (GH#3212)

bd list silently truncated at --limit (default 50) with no reliable signal
that results were hidden. The existing hint fired when len==limit, which
both gave false positives (exact match count) and no warning for JSON
consumers.

Fetch one extra row (effectiveLimit+1) to detect truncation accurately,
then emit a clearer one-line hint to stderr in all output modes —
including --json, --format, pretty/tree, and agent mode — so downstream
agents and scripts don't mistake a partial view for a complete one.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* test(list): capture stdout/stderr separately; cover truncation hint

TestEmbeddedList/limit used CombinedOutput() to parse JSON, so it choked
on the new stderr hint landing after the JSON array. Split stdout/stderr
in bdListJSON, add bdListCapture helper, and add a limit_truncation_hint
subtest covering GH#3212:
- hint appears on stderr when --limit truncates
- hint never leaks into stdout (JSON consumers)
- no hint with --limit 0 or when results fit under the cap

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(list): trim +1 overflow row in --watch mode (review feedback)

The truncation-detection change fetches effectiveLimit+1 rows, but the
watch loop re-ran SearchIssues with the bumped filter and never trimmed,
so every refresh rendered one extra issue (e.g. 21 rows under --limit 20).

Pass effectiveLimit to watchIssues and trim both the initial render and
each refresh; also surface the truncation hint in watch mode so persistent
watchers don't quietly show a partial view.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-13 13:10:21 -07:00

159 lines
4.2 KiB
Go

package main
import (
"bytes"
"context"
"fmt"
"os"
"text/template"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/types"
)
// printTruncationHint emits a one-line notice to stderr when the list output
// was truncated by --limit, so users and agents can't mistake a partial view
// for a complete one (GH#3212, GH#788).
func printTruncationHint(truncated bool, effectiveLimit int) {
if !truncated || effectiveLimit <= 0 {
return
}
fmt.Fprintf(os.Stderr, "\nShowing %d issues; more results matched but were hidden by --limit. Use --limit 0 for all, or --limit N to raise the cap.\n", effectiveLimit)
}
// outputDotFormat outputs issues in Graphviz DOT format
func outputDotFormat(ctx context.Context, store storage.DoltStorage, issues []*types.Issue) error {
fmt.Println("digraph dependencies {")
fmt.Println(" rankdir=TB;")
fmt.Println(" node [shape=box, style=rounded];")
fmt.Println()
// Build map of all issues for quick lookup
issueMap := make(map[string]*types.Issue)
for _, issue := range issues {
issueMap[issue.ID] = issue
}
// Output nodes with labels including ID, type, priority, and status
for _, issue := range issues {
// Build label with ID, type, priority, and title (using actual newlines)
label := fmt.Sprintf("%s\n[%s P%d]\n%s\n(%s)",
issue.ID,
issue.IssueType,
issue.Priority,
issue.Title,
issue.Status)
// Color by status only - keep it simple
fillColor := "white"
fontColor := "black"
switch issue.Status {
case "closed":
fillColor = "lightgray"
fontColor = "dimgray"
case "in_progress":
fillColor = "lightyellow"
case "blocked":
fillColor = "lightcoral"
}
fmt.Printf(" %q [label=%q, style=\"rounded,filled\", fillcolor=%q, fontcolor=%q];\n",
issue.ID, label, fillColor, fontColor)
}
fmt.Println()
// Output edges with labels for dependency type
for _, issue := range issues {
deps, err := store.GetDependencyRecords(ctx, issue.ID)
if err != nil {
continue
}
for _, dep := range deps {
// Only output edges where both nodes are in the filtered list
if issueMap[dep.DependsOnID] != nil {
// Color code by dependency type
color := "black"
style := "solid"
switch dep.Type {
case "blocks":
color = "red"
style = "bold"
case "parent-child":
color = "blue"
case "discovered-from":
color = "green"
style = "dashed"
case "related":
color = "gray"
style = "dashed"
}
fmt.Printf(" %q -> %q [label=%q, color=%s, style=%s];\n",
issue.ID, dep.DependsOnID, dep.Type, color, style)
}
}
}
fmt.Println("}")
return nil
}
// outputFormattedList outputs issues in a custom format (preset or Go template)
func outputFormattedList(ctx context.Context, store storage.DoltStorage, issues []*types.Issue, formatStr string) error {
// Handle special 'dot' format (Graphviz output)
if formatStr == "dot" {
return outputDotFormat(ctx, store, issues)
}
// Built-in format presets
presets := map[string]string{
"digraph": "{{.IssueID}} {{.DependsOnID}}",
}
// Check if it's a preset
templateStr, isPreset := presets[formatStr]
if !isPreset {
templateStr = formatStr
}
// Parse template
tmpl, err := template.New("format").Parse(templateStr)
if err != nil {
return fmt.Errorf("invalid format template: %w", err)
}
// Build map of all issues for quick lookup
issueMap := make(map[string]bool)
for _, issue := range issues {
issueMap[issue.ID] = true
}
// For each issue, output its dependencies using the template
for _, issue := range issues {
deps, err := store.GetDependencyRecords(ctx, issue.ID)
if err != nil {
continue
}
for _, dep := range deps {
// Only output edges where both nodes are in the filtered list
if issueMap[dep.DependsOnID] {
// Template data includes both issue and dependency info
data := map[string]interface{}{
"IssueID": issue.ID,
"DependsOnID": dep.DependsOnID,
"Type": dep.Type,
"Issue": issue,
"Dependency": dep,
}
var buf bytes.Buffer
if err := tmpl.Execute(&buf, data); err != nil {
return fmt.Errorf("template execution error: %w", err)
}
fmt.Println(buf.String())
}
}
}
return nil
}