The tree path in getHierarchicalChildren unconditionally seeded the parent into the result set, making it impossible for the "has no children" message at line 876 to ever trigger. Text output always showed at least 1 result (the parent), disagreeing with --json and --flat which correctly returned empty. Fix: only include the parent in the tree result when actual descendants exist. When descendants are empty, return nil so the caller prints the existing "has no children" message. This aligns text, JSON, and flat output semantics. Co-authored-by: kev <kglynn@pryoninc.com>
1110 lines
38 KiB
Go
1110 lines
38 KiB
Go
package main
|
|
|
|
import (
|
|
"cmp"
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"os/signal"
|
|
"slices"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/spf13/cobra"
|
|
"github.com/steveyegge/beads/internal/config"
|
|
"github.com/steveyegge/beads/internal/storage"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
"github.com/steveyegge/beads/internal/ui"
|
|
"github.com/steveyegge/beads/internal/utils"
|
|
"github.com/steveyegge/beads/internal/validation"
|
|
)
|
|
|
|
// storageExecutor handles operations that need a store connection
|
|
type storageExecutor func(store storage.DoltStorage) error
|
|
|
|
// withStorage executes an operation with either the direct store or a read-only store
|
|
func withStorage(ctx context.Context, store storage.DoltStorage, dbPath string, fn storageExecutor) error {
|
|
if store != nil {
|
|
return fn(store)
|
|
} else if dbPath != "" {
|
|
// Open read-only connection using repo metadata when available so
|
|
// helper paths keep the correct Dolt database and server endpoint.
|
|
roStore, err := openReadOnlyStoreForDBPath(ctx, dbPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = roStore.Close() }() // Best effort cleanup
|
|
return fn(roStore)
|
|
}
|
|
return fmt.Errorf("no storage available")
|
|
}
|
|
|
|
// getHierarchicalChildren handles the --tree --parent combination logic
|
|
func getHierarchicalChildren(ctx context.Context, store storage.DoltStorage, dbPath string, parentID string) ([]*types.Issue, error) {
|
|
// First verify that the parent issue exists
|
|
var parentIssue *types.Issue
|
|
err := withStorage(ctx, store, dbPath, func(s storage.DoltStorage) error {
|
|
var err error
|
|
parentIssue, err = s.GetIssue(ctx, parentID)
|
|
return err
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error checking parent issue: %v", err)
|
|
}
|
|
if parentIssue == nil {
|
|
return nil, fmt.Errorf("parent issue '%s' not found", parentID)
|
|
}
|
|
|
|
// Use recursive search to find all descendants using the same logic as --parent filter.
|
|
// The parent itself is NOT included in the result set — only actual children and
|
|
// their descendants. This matches the behavior of --json and --flat (GH#3349).
|
|
allDescendants := make(map[string]*types.Issue)
|
|
|
|
err = findAllDescendants(ctx, store, dbPath, parentID, allDescendants, 0, 10) // max depth 10
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error finding descendants: %v", err)
|
|
}
|
|
|
|
if len(allDescendants) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
// Include the parent as the tree root only when descendants exist,
|
|
// so the tree renderer can draw the hierarchy with the parent at the top.
|
|
allDescendants[parentID] = parentIssue
|
|
|
|
treeIssues := make([]*types.Issue, 0, len(allDescendants))
|
|
for _, issue := range allDescendants {
|
|
treeIssues = append(treeIssues, issue)
|
|
}
|
|
|
|
return treeIssues, nil
|
|
}
|
|
|
|
// findAllDescendants recursively finds all descendants using parent filtering
|
|
func findAllDescendants(ctx context.Context, store storage.DoltStorage, dbPath string, parentID string, result map[string]*types.Issue, currentDepth, maxDepth int) error {
|
|
if currentDepth >= maxDepth {
|
|
return nil // Prevent infinite recursion
|
|
}
|
|
|
|
// Get direct children using the same filter logic as regular --parent
|
|
var children []*types.Issue
|
|
err := withStorage(ctx, store, dbPath, func(s storage.DoltStorage) error {
|
|
filter := types.IssueFilter{
|
|
ParentID: &parentID,
|
|
}
|
|
var err error
|
|
children, err = s.SearchIssues(ctx, "", filter)
|
|
return err
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Add children and recursively find their descendants
|
|
for _, child := range children {
|
|
if _, exists := result[child.ID]; !exists {
|
|
result[child.ID] = child
|
|
// Recursively find this child's descendants
|
|
err = findAllDescendants(ctx, store, dbPath, child.ID, result, currentDepth+1, maxDepth)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// watchIssues polls for changes and re-displays (GH#654)
|
|
// Uses polling instead of fsnotify because Dolt stores data in a server-side
|
|
// database, not files — file watchers never fire.
|
|
type watchListDependencyStore interface {
|
|
GetAllDependencyRecords(ctx context.Context) (map[string][]*types.Dependency, error)
|
|
}
|
|
|
|
func loadWatchedIssues(ctx context.Context, store storage.DoltStorage, filter types.IssueFilter, parentID string, sortBy string, reverse bool) ([]*types.Issue, error) {
|
|
if parentID != "" {
|
|
issues, err := getHierarchicalChildren(ctx, store, "", parentID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// getHierarchicalChildren builds its result from a map, so normalize the
|
|
// slice before snapshot comparison to avoid spurious redraws.
|
|
sortIssues(issues, "id", false)
|
|
return issues, nil
|
|
}
|
|
|
|
issues, err := store.SearchIssues(ctx, "", filter)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sortIssues(issues, sortBy, reverse)
|
|
return issues, nil
|
|
}
|
|
|
|
func displayWatchedIssueList(ctx context.Context, store watchListDependencyStore, issues []*types.Issue) {
|
|
var allDeps map[string][]*types.Dependency
|
|
if store != nil {
|
|
deps, err := store.GetAllDependencyRecords(ctx)
|
|
if err == nil {
|
|
allDeps = deps
|
|
}
|
|
}
|
|
displayPrettyListWithDeps(issues, true, allDeps)
|
|
}
|
|
|
|
func watchIssues(ctx context.Context, store storage.DoltStorage, filter types.IssueFilter, parentID string, sortBy string, reverse bool, effectiveLimit int) {
|
|
// Initial display
|
|
issues, err := loadWatchedIssues(ctx, store, filter, parentID, sortBy, reverse)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error querying issues: %v\n", err)
|
|
return
|
|
}
|
|
truncated := effectiveLimit > 0 && len(issues) > effectiveLimit
|
|
if truncated {
|
|
issues = issues[:effectiveLimit]
|
|
}
|
|
displayWatchedIssueList(ctx, store, issues)
|
|
printTruncationHint(truncated, effectiveLimit)
|
|
lastSnapshot := issueSnapshot(issues)
|
|
|
|
fmt.Fprintf(os.Stderr, "\nWatching for changes... (Press Ctrl+C to exit)\n")
|
|
|
|
// Handle Ctrl+C — deferred Stop prevents signal handler leak
|
|
sigChan := make(chan os.Signal, 1)
|
|
signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
|
|
defer signal.Stop(sigChan)
|
|
|
|
pollInterval := 2 * time.Second
|
|
ticker := time.NewTicker(pollInterval)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-sigChan:
|
|
fmt.Fprintf(os.Stderr, "\nStopped watching.\n")
|
|
return
|
|
case <-ticker.C:
|
|
issues, err := loadWatchedIssues(ctx, store, filter, parentID, sortBy, reverse)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error refreshing issues: %v\n", err)
|
|
continue
|
|
}
|
|
truncated := effectiveLimit > 0 && len(issues) > effectiveLimit
|
|
if truncated {
|
|
issues = issues[:effectiveLimit]
|
|
}
|
|
snap := issueSnapshot(issues)
|
|
if snap != lastSnapshot {
|
|
lastSnapshot = snap
|
|
displayWatchedIssueList(ctx, store, issues)
|
|
printTruncationHint(truncated, effectiveLimit)
|
|
fmt.Fprintf(os.Stderr, "\nWatching for changes... (Press Ctrl+C to exit)\n")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// issueSnapshot builds a comparable string from issue IDs, statuses, and
|
|
// update times so we can detect when the result set has changed.
|
|
func issueSnapshot(issues []*types.Issue) string {
|
|
var b strings.Builder
|
|
for _, issue := range issues {
|
|
fmt.Fprintf(&b, "%s:%s:%d;", issue.ID, issue.Status, issue.UpdatedAt.UnixNano())
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
// sortIssues sorts a slice of issues by the specified field and direction
|
|
func sortIssues(issues []*types.Issue, sortBy string, reverse bool) {
|
|
if sortBy == "" {
|
|
return
|
|
}
|
|
|
|
slices.SortFunc(issues, func(a, b *types.Issue) int {
|
|
var result int
|
|
|
|
switch sortBy {
|
|
case "priority":
|
|
// Lower priority numbers come first (P0 > P1 > P2 > P3 > P4)
|
|
result = cmp.Compare(a.Priority, b.Priority)
|
|
case "created":
|
|
// Default: newest first (descending)
|
|
result = b.CreatedAt.Compare(a.CreatedAt)
|
|
case "updated":
|
|
// Default: newest first (descending)
|
|
result = b.UpdatedAt.Compare(a.UpdatedAt)
|
|
case "closed":
|
|
// Default: newest first (descending)
|
|
// Handle nil ClosedAt values
|
|
if a.ClosedAt == nil && b.ClosedAt == nil {
|
|
result = 0
|
|
} else if a.ClosedAt == nil {
|
|
result = 1 // nil sorts last
|
|
} else if b.ClosedAt == nil {
|
|
result = -1 // non-nil sorts before nil
|
|
} else {
|
|
result = b.ClosedAt.Compare(*a.ClosedAt)
|
|
}
|
|
case "status":
|
|
result = cmp.Compare(a.Status, b.Status)
|
|
case "id":
|
|
result = cmp.Compare(a.ID, b.ID)
|
|
case "title":
|
|
result = cmp.Compare(strings.ToLower(a.Title), strings.ToLower(b.Title))
|
|
case "type":
|
|
result = cmp.Compare(a.IssueType, b.IssueType)
|
|
case "assignee":
|
|
result = cmp.Compare(a.Assignee, b.Assignee)
|
|
default:
|
|
// Unknown sort field, no sorting
|
|
result = 0
|
|
}
|
|
|
|
if reverse {
|
|
return -result
|
|
}
|
|
return result
|
|
})
|
|
}
|
|
|
|
// knownListFlags maps bare words that users might pass as positional args
|
|
// but are actually flag names. Each maps to a hint for the error message.
|
|
var knownListFlags = map[string]string{
|
|
"ready": "--ready",
|
|
"tree": "--tree",
|
|
"flat": "--flat",
|
|
"all": "--all",
|
|
"long": "--long",
|
|
"watch": "--watch",
|
|
"pretty": "--pretty",
|
|
"pinned": "--pinned",
|
|
"overdue": "--overdue",
|
|
}
|
|
|
|
var listCmd = &cobra.Command{
|
|
Use: "list",
|
|
GroupID: "issues",
|
|
Short: "List issues",
|
|
Args: func(cmd *cobra.Command, args []string) error {
|
|
if len(args) == 0 {
|
|
return nil
|
|
}
|
|
for _, arg := range args {
|
|
if hint, ok := knownListFlags[arg]; ok {
|
|
return fmt.Errorf("unknown argument %q; did you mean %q or 'bd %s'?", arg, hint, arg)
|
|
}
|
|
}
|
|
return fmt.Errorf("bd list does not accept positional arguments; use flags instead (see bd list --help)")
|
|
},
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
status, _ := cmd.Flags().GetString("status")
|
|
// --state is alias for --status (desire path: bd-9h3w)
|
|
if status == "" {
|
|
status, _ = cmd.Flags().GetString("state")
|
|
}
|
|
assignee, _ := cmd.Flags().GetString("assignee")
|
|
issueType, _ := cmd.Flags().GetString("type")
|
|
issueType = utils.NormalizeIssueType(issueType) // Expand aliases (mr→merge-request, etc.)
|
|
limit, _ := cmd.Flags().GetInt("limit")
|
|
allFlag, _ := cmd.Flags().GetBool("all")
|
|
formatStr, _ := cmd.Flags().GetString("format")
|
|
// Handle --format json: the local --format flag shadows the hidden
|
|
// persistent --format on rootCmd, so "json" arrives here instead of
|
|
// setting jsonOutput via PersistentPreRun. Route it explicitly.
|
|
if strings.EqualFold(formatStr, "json") {
|
|
jsonOutput = true
|
|
formatStr = ""
|
|
}
|
|
labels, _ := cmd.Flags().GetStringSlice("label")
|
|
labelsAny, _ := cmd.Flags().GetStringSlice("label-any")
|
|
labelPattern, _ := cmd.Flags().GetString("label-pattern")
|
|
labelRegex, _ := cmd.Flags().GetString("label-regex")
|
|
titleSearch, _ := cmd.Flags().GetString("title")
|
|
specPrefix, _ := cmd.Flags().GetString("spec")
|
|
idFilter, _ := cmd.Flags().GetString("id")
|
|
longFormat, _ := cmd.Flags().GetBool("long")
|
|
sortBy, _ := cmd.Flags().GetString("sort")
|
|
reverse, _ := cmd.Flags().GetBool("reverse")
|
|
|
|
// Pattern matching flags
|
|
titleContains, _ := cmd.Flags().GetString("title-contains")
|
|
descContains, _ := cmd.Flags().GetString("desc-contains")
|
|
notesContains, _ := cmd.Flags().GetString("notes-contains")
|
|
|
|
// Date range flags
|
|
createdAfter, _ := cmd.Flags().GetString("created-after")
|
|
createdBefore, _ := cmd.Flags().GetString("created-before")
|
|
updatedAfter, _ := cmd.Flags().GetString("updated-after")
|
|
updatedBefore, _ := cmd.Flags().GetString("updated-before")
|
|
closedAfter, _ := cmd.Flags().GetString("closed-after")
|
|
closedBefore, _ := cmd.Flags().GetString("closed-before")
|
|
|
|
// Empty/null check flags
|
|
emptyDesc, _ := cmd.Flags().GetBool("empty-description")
|
|
noAssignee, _ := cmd.Flags().GetBool("no-assignee")
|
|
noLabels, _ := cmd.Flags().GetBool("no-labels")
|
|
|
|
// Priority range flags
|
|
priorityMinStr, _ := cmd.Flags().GetString("priority-min")
|
|
priorityMaxStr, _ := cmd.Flags().GetString("priority-max")
|
|
|
|
// Pinned filtering flags
|
|
pinnedFlag, _ := cmd.Flags().GetBool("pinned")
|
|
noPinnedFlag, _ := cmd.Flags().GetBool("no-pinned")
|
|
|
|
// Template filtering
|
|
includeTemplates, _ := cmd.Flags().GetBool("include-templates")
|
|
|
|
// Gate filtering (bd-7zka.2)
|
|
includeGates, _ := cmd.Flags().GetBool("include-gates")
|
|
|
|
// Infra type filtering: exclude agent/rig/role/message by default
|
|
includeInfra, _ := cmd.Flags().GetBool("include-infra")
|
|
|
|
// Explicit type exclusion (--exclude-type)
|
|
excludeTypeStrs, _ := cmd.Flags().GetStringSlice("exclude-type")
|
|
|
|
// Parent filtering (--filter-parent is alias for --parent)
|
|
parentID, _ := cmd.Flags().GetString("parent")
|
|
if parentID == "" {
|
|
// Flag registered; GetString only errors if flag doesn't exist
|
|
parentID, _ = cmd.Flags().GetString("filter-parent")
|
|
}
|
|
noParent, _ := cmd.Flags().GetBool("no-parent")
|
|
|
|
// Molecule type filtering
|
|
molTypeStr, _ := cmd.Flags().GetString("mol-type")
|
|
var molType *types.MolType
|
|
if molTypeStr != "" {
|
|
mt := types.MolType(molTypeStr)
|
|
if !mt.IsValid() {
|
|
FatalError("invalid mol-type %q (must be swarm, patrol, or work)", molTypeStr)
|
|
}
|
|
molType = &mt
|
|
}
|
|
|
|
// Wisp type filtering (TTL-based compaction classification)
|
|
wispTypeStr, _ := cmd.Flags().GetString("wisp-type")
|
|
var wispType *types.WispType
|
|
if wispTypeStr != "" {
|
|
wt := types.WispType(wispTypeStr)
|
|
if !wt.IsValid() {
|
|
FatalError("invalid wisp-type %q (must be heartbeat, ping, patrol, gc_report, recovery, error, or escalation)", wispTypeStr)
|
|
}
|
|
wispType = &wt
|
|
}
|
|
|
|
// Time-based scheduling filters (GH#820)
|
|
deferredFlag, _ := cmd.Flags().GetBool("deferred")
|
|
deferAfter, _ := cmd.Flags().GetString("defer-after")
|
|
deferBefore, _ := cmd.Flags().GetString("defer-before")
|
|
dueAfter, _ := cmd.Flags().GetString("due-after")
|
|
dueBefore, _ := cmd.Flags().GetString("due-before")
|
|
overdueFlag, _ := cmd.Flags().GetBool("overdue")
|
|
|
|
// Pretty and watch flags (GH#654)
|
|
prettyFormat, _ := cmd.Flags().GetBool("pretty")
|
|
treeFormat, _ := cmd.Flags().GetBool("tree")
|
|
flatFormat, _ := cmd.Flags().GetBool("flat")
|
|
if flatFormat {
|
|
treeFormat = false
|
|
}
|
|
// --tree is alias for --pretty; JSON and explicit --format win
|
|
prettyFormat = (prettyFormat || treeFormat) && !jsonOutput && formatStr == ""
|
|
watchMode, _ := cmd.Flags().GetBool("watch")
|
|
|
|
// Pager control (bd-jdz3)
|
|
noPager, _ := cmd.Flags().GetBool("no-pager")
|
|
|
|
// Ready filter (bd-ihu31)
|
|
readyFlag, _ := cmd.Flags().GetBool("ready")
|
|
|
|
// Watch mode implies pretty format
|
|
if watchMode {
|
|
prettyFormat = true
|
|
}
|
|
|
|
// Use global jsonOutput set by PersistentPreRun
|
|
|
|
// Normalize labels: trim, dedupe, remove empty
|
|
labels = utils.NormalizeLabels(labels)
|
|
labelsAny = utils.NormalizeLabels(labelsAny)
|
|
|
|
// Apply directory-aware label scoping if no labels explicitly provided (GH#541)
|
|
if len(labels) == 0 && len(labelsAny) == 0 {
|
|
if dirLabels := config.GetDirectoryLabels(); len(dirLabels) > 0 {
|
|
labelsAny = dirLabels
|
|
}
|
|
}
|
|
|
|
// Resolve effective limit. Priority order:
|
|
// 1. Explicit --limit always wins (user intent is clear)
|
|
// 2. --all implies unlimited when --limit is not set (GH#1840)
|
|
// 3. Agent mode uses a lower default for context efficiency
|
|
// 4. Default limit (50) otherwise
|
|
limitChanged := cmd.Flags().Changed("limit")
|
|
effectiveLimit := limit
|
|
switch {
|
|
case limitChanged:
|
|
effectiveLimit = limit // Explicit value (including --limit 0 for unlimited)
|
|
case allFlag:
|
|
effectiveLimit = 0 // --all implies unlimited regardless of other flags
|
|
case ui.IsAgentMode():
|
|
effectiveLimit = 20 // Agent mode default
|
|
}
|
|
|
|
// Validate --sort field (bd-ttno)
|
|
if sortBy != "" {
|
|
validSortFields := map[string]bool{
|
|
"priority": true, "created": true, "updated": true, "closed": true,
|
|
"status": true, "id": true, "title": true, "type": true, "assignee": true,
|
|
}
|
|
if !validSortFields[sortBy] {
|
|
FatalError("invalid sort field %q (valid: priority, created, updated, closed, status, id, title, type, assignee)", sortBy)
|
|
}
|
|
}
|
|
|
|
// When --sort is specified, don't pass Limit to SQL — the hardcoded
|
|
// ORDER BY would truncate before Go-side sorting (GH#1237).
|
|
// Instead, apply limit in Go after sortIssues().
|
|
sqlLimit := effectiveLimit
|
|
if sortBy != "" {
|
|
sqlLimit = 0
|
|
}
|
|
|
|
// Fetch one extra row so we can distinguish "exactly N matches" from
|
|
// "N+ matches truncated" without running a second count query (GH#3212).
|
|
if sqlLimit > 0 {
|
|
sqlLimit++
|
|
}
|
|
|
|
filter := types.IssueFilter{
|
|
Limit: sqlLimit,
|
|
}
|
|
|
|
// --ready flag: show only open issues (excludes hooked/in_progress/blocked/deferred) (bd-ihu31)
|
|
if readyFlag {
|
|
s := types.StatusOpen
|
|
filter.Status = &s
|
|
} else if status != "" && status != "all" {
|
|
// Support comma-separated status values (GH#2846)
|
|
statusParts := strings.Split(status, ",")
|
|
var customStatuses []string
|
|
if store != nil {
|
|
cs, err := store.GetCustomStatuses(rootCtx)
|
|
if err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "%s Could not load custom statuses from database: %v (falling back to config)\n", ui.RenderWarn("!"), err)
|
|
}
|
|
} else {
|
|
customStatuses = cs
|
|
}
|
|
}
|
|
if len(statusParts) == 1 {
|
|
s := types.Status(strings.TrimSpace(statusParts[0]))
|
|
if !s.IsValidWithCustom(customStatuses) {
|
|
validList := "open, in_progress, blocked, deferred, closed, pinned, hooked"
|
|
if len(customStatuses) > 0 {
|
|
validList += ", " + strings.Join(customStatuses, ", ")
|
|
}
|
|
FatalError("invalid status %q (valid: %s)", status, validList)
|
|
}
|
|
filter.Status = &s
|
|
} else {
|
|
for _, part := range statusParts {
|
|
s := types.Status(strings.TrimSpace(part))
|
|
if !s.IsValidWithCustom(customStatuses) {
|
|
validList := "open, in_progress, blocked, deferred, closed, pinned, hooked"
|
|
if len(customStatuses) > 0 {
|
|
validList += ", " + strings.Join(customStatuses, ", ")
|
|
}
|
|
FatalError("invalid status %q in multi-status filter (valid: %s)", strings.TrimSpace(part), validList)
|
|
}
|
|
filter.Statuses = append(filter.Statuses, s)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Default to non-closed/non-pinned issues unless --all, --pinned, or explicit --status (GH#788, bd-uhcg)
|
|
// Also exclude custom statuses in done/frozen categories
|
|
if status == "" && !allFlag && !readyFlag && !pinnedFlag {
|
|
excludeStatuses := []types.Status{types.StatusClosed, types.StatusPinned}
|
|
if store != nil {
|
|
if detailed, err := store.GetCustomStatusesDetailed(rootCtx); err == nil {
|
|
for _, cs := range detailed {
|
|
if cs.Category == types.CategoryDone || cs.Category == types.CategoryFrozen {
|
|
excludeStatuses = append(excludeStatuses, types.Status(cs.Name))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
filter.ExcludeStatus = excludeStatuses
|
|
}
|
|
// Use Changed() to properly handle P0 (priority=0)
|
|
if cmd.Flags().Changed("priority") {
|
|
priorityStr, _ := cmd.Flags().GetString("priority")
|
|
priority, err := validation.ValidatePriority(priorityStr)
|
|
if err != nil {
|
|
FatalError("%v", err)
|
|
}
|
|
filter.Priority = &priority
|
|
}
|
|
if assignee != "" {
|
|
filter.Assignee = &assignee
|
|
}
|
|
if issueType != "" {
|
|
t := types.IssueType(issueType)
|
|
// Validate --type value (bd-ttno)
|
|
var customTypes []string
|
|
if store != nil {
|
|
ct, _ := store.GetCustomTypes(rootCtx)
|
|
customTypes = ct
|
|
}
|
|
if len(customTypes) == 0 {
|
|
customTypes = config.GetCustomTypesFromYAML()
|
|
}
|
|
if !t.IsValidWithCustom(customTypes) {
|
|
validTypes := "bug, feature, task, epic, chore, decision"
|
|
if len(customTypes) > 0 {
|
|
validTypes += ", " + joinStrings(customTypes, ", ")
|
|
}
|
|
FatalError("invalid issue type %q (valid: %s)", issueType, validTypes)
|
|
}
|
|
filter.IssueType = &t
|
|
}
|
|
if len(labels) > 0 {
|
|
filter.Labels = labels
|
|
}
|
|
if len(labelsAny) > 0 {
|
|
filter.LabelsAny = labelsAny
|
|
}
|
|
if labelPattern != "" {
|
|
filter.LabelPattern = labelPattern
|
|
}
|
|
if labelRegex != "" {
|
|
filter.LabelRegex = labelRegex
|
|
}
|
|
if titleSearch != "" {
|
|
filter.TitleSearch = titleSearch
|
|
}
|
|
if idFilter != "" {
|
|
ids := utils.NormalizeLabels(strings.Split(idFilter, ","))
|
|
if len(ids) > 0 {
|
|
filter.IDs = ids
|
|
}
|
|
}
|
|
if specPrefix != "" {
|
|
filter.SpecIDPrefix = specPrefix
|
|
}
|
|
|
|
// Pattern matching
|
|
if titleContains != "" {
|
|
filter.TitleContains = titleContains
|
|
}
|
|
if descContains != "" {
|
|
filter.DescriptionContains = descContains
|
|
}
|
|
if notesContains != "" {
|
|
filter.NotesContains = notesContains
|
|
}
|
|
|
|
// Date ranges
|
|
if createdAfter != "" {
|
|
t, err := parseTimeFlag(createdAfter)
|
|
if err != nil {
|
|
FatalError("parsing --created-after: %v", err)
|
|
}
|
|
filter.CreatedAfter = &t
|
|
}
|
|
if createdBefore != "" {
|
|
t, err := parseTimeFlag(createdBefore)
|
|
if err != nil {
|
|
FatalError("parsing --created-before: %v", err)
|
|
}
|
|
filter.CreatedBefore = &t
|
|
}
|
|
if updatedAfter != "" {
|
|
t, err := parseTimeFlag(updatedAfter)
|
|
if err != nil {
|
|
FatalError("parsing --updated-after: %v", err)
|
|
}
|
|
filter.UpdatedAfter = &t
|
|
}
|
|
if updatedBefore != "" {
|
|
t, err := parseTimeFlag(updatedBefore)
|
|
if err != nil {
|
|
FatalError("parsing --updated-before: %v", err)
|
|
}
|
|
filter.UpdatedBefore = &t
|
|
}
|
|
if closedAfter != "" {
|
|
t, err := parseTimeFlag(closedAfter)
|
|
if err != nil {
|
|
FatalError("parsing --closed-after: %v", err)
|
|
}
|
|
filter.ClosedAfter = &t
|
|
}
|
|
if closedBefore != "" {
|
|
t, err := parseTimeFlag(closedBefore)
|
|
if err != nil {
|
|
FatalError("parsing --closed-before: %v", err)
|
|
}
|
|
filter.ClosedBefore = &t
|
|
}
|
|
|
|
// Empty/null checks
|
|
if emptyDesc {
|
|
filter.EmptyDescription = true
|
|
}
|
|
if noAssignee {
|
|
filter.NoAssignee = true
|
|
}
|
|
if noLabels {
|
|
filter.NoLabels = true
|
|
}
|
|
|
|
// Priority ranges
|
|
if cmd.Flags().Changed("priority-min") {
|
|
priorityMin, err := validation.ValidatePriority(priorityMinStr)
|
|
if err != nil {
|
|
FatalError("parsing --priority-min: %v", err)
|
|
}
|
|
filter.PriorityMin = &priorityMin
|
|
}
|
|
if cmd.Flags().Changed("priority-max") {
|
|
priorityMax, err := validation.ValidatePriority(priorityMaxStr)
|
|
if err != nil {
|
|
FatalError("parsing --priority-max: %v", err)
|
|
}
|
|
filter.PriorityMax = &priorityMax
|
|
}
|
|
|
|
// Pinned filtering: --pinned and --no-pinned are mutually exclusive
|
|
if pinnedFlag && noPinnedFlag {
|
|
FatalError("--pinned and --no-pinned are mutually exclusive")
|
|
}
|
|
if pinnedFlag {
|
|
pinned := true
|
|
filter.Pinned = &pinned
|
|
} else if noPinnedFlag || (status != "pinned" && status != "hooked" && !allFlag) {
|
|
// Exclude pinned beads by default — they are permanent references,
|
|
// not actionable work items. Use --pinned or --all to see them. (bd-uhcg)
|
|
// Also skip exclusion for --status=hooked: beads transitioning from
|
|
// pinned to hooked retain the legacy pinned=1 column, and excluding
|
|
// them breaks gt hook status detection (bd-pr-sheriff bug).
|
|
pinned := false
|
|
filter.Pinned = &pinned
|
|
}
|
|
|
|
// Template filtering: exclude templates by default
|
|
// Use --include-templates to show all issues including templates
|
|
if !includeTemplates {
|
|
isTemplate := false
|
|
filter.IsTemplate = &isTemplate
|
|
}
|
|
|
|
// Gate filtering: exclude gate issues by default (bd-7zka.2)
|
|
// Use --include-gates or --type gate to show gate issues
|
|
if !includeGates && issueType != "gate" {
|
|
filter.ExcludeTypes = append(filter.ExcludeTypes, "gate")
|
|
}
|
|
|
|
// Infra type filtering: exclude configured infra types by default.
|
|
// These types live in the wisps table after migration 007.
|
|
// Use --include-infra or --type=agent to show infra beads.
|
|
infraTypes := storage.DefaultInfraTypes()
|
|
if store != nil {
|
|
infraSet := store.GetInfraTypes(rootCtx)
|
|
infraTypes = make([]string, 0, len(infraSet))
|
|
for t := range infraSet {
|
|
infraTypes = append(infraTypes, t)
|
|
}
|
|
}
|
|
isInfra := func(t string) bool {
|
|
if store != nil {
|
|
return store.IsInfraTypeCtx(rootCtx, types.IssueType(t))
|
|
}
|
|
return storage.IsInfraType(types.IssueType(t))
|
|
}
|
|
if !includeInfra && !isInfra(issueType) {
|
|
for _, t := range infraTypes {
|
|
filter.ExcludeTypes = append(filter.ExcludeTypes, types.IssueType(t))
|
|
}
|
|
}
|
|
|
|
// Explicit type exclusion from --exclude-type flag.
|
|
for _, raw := range excludeTypeStrs {
|
|
for _, t := range strings.Split(raw, ",") {
|
|
t = strings.TrimSpace(t)
|
|
if t != "" {
|
|
filter.ExcludeTypes = append(filter.ExcludeTypes, types.IssueType(utils.NormalizeIssueType(t)))
|
|
}
|
|
}
|
|
}
|
|
|
|
// When explicitly requesting an infra type, search the wisps table
|
|
// (where infra beads live after migration 007).
|
|
if isInfra(issueType) {
|
|
ephemeral := true
|
|
filter.Ephemeral = &ephemeral
|
|
}
|
|
|
|
// Parent filtering: filter children by parent issue
|
|
if parentID != "" && noParent {
|
|
FatalError("--parent and --no-parent are mutually exclusive")
|
|
}
|
|
if parentID != "" {
|
|
filter.ParentID = &parentID
|
|
}
|
|
if noParent {
|
|
filter.NoParent = true
|
|
}
|
|
|
|
// Molecule type filtering
|
|
if molType != nil {
|
|
filter.MolType = molType
|
|
}
|
|
|
|
// Wisp type filtering
|
|
if wispType != nil {
|
|
filter.WispType = wispType
|
|
}
|
|
|
|
// Time-based scheduling filters (GH#820)
|
|
if deferredFlag {
|
|
filter.Deferred = true
|
|
}
|
|
if deferAfter != "" {
|
|
t, err := parseTimeFlag(deferAfter)
|
|
if err != nil {
|
|
FatalError("parsing --defer-after: %v", err)
|
|
}
|
|
filter.DeferAfter = &t
|
|
}
|
|
if deferBefore != "" {
|
|
t, err := parseTimeFlag(deferBefore)
|
|
if err != nil {
|
|
FatalError("parsing --defer-before: %v", err)
|
|
}
|
|
filter.DeferBefore = &t
|
|
}
|
|
if dueAfter != "" {
|
|
t, err := parseTimeFlag(dueAfter)
|
|
if err != nil {
|
|
FatalError("parsing --due-after: %v", err)
|
|
}
|
|
filter.DueAfter = &t
|
|
}
|
|
if dueBefore != "" {
|
|
t, err := parseTimeFlag(dueBefore)
|
|
if err != nil {
|
|
FatalError("parsing --due-before: %v", err)
|
|
}
|
|
filter.DueBefore = &t
|
|
}
|
|
if overdueFlag {
|
|
filter.Overdue = true
|
|
}
|
|
|
|
// Metadata filters (GH#1406)
|
|
metadataFieldFlags, _ := cmd.Flags().GetStringArray("metadata-field")
|
|
if len(metadataFieldFlags) > 0 {
|
|
filter.MetadataFields = make(map[string]string, len(metadataFieldFlags))
|
|
for _, mf := range metadataFieldFlags {
|
|
k, v, ok := strings.Cut(mf, "=")
|
|
if !ok || k == "" {
|
|
FatalErrorRespectJSON("invalid --metadata-field: expected key=value, got %q", mf)
|
|
}
|
|
if err := storage.ValidateMetadataKey(k); err != nil {
|
|
FatalErrorRespectJSON("invalid --metadata-field key: %v", err)
|
|
}
|
|
filter.MetadataFields[k] = v
|
|
}
|
|
}
|
|
hasMetadataKey, _ := cmd.Flags().GetString("has-metadata-key")
|
|
if hasMetadataKey != "" {
|
|
if err := storage.ValidateMetadataKey(hasMetadataKey); err != nil {
|
|
FatalErrorRespectJSON("invalid --has-metadata-key: %v", err)
|
|
}
|
|
filter.HasMetadataKey = hasMetadataKey
|
|
}
|
|
|
|
ctx := rootCtx
|
|
|
|
activeStore := store
|
|
// Contributor auto-routing: read from the same target repo as bd create.
|
|
routedStore, routed, err := openRoutedReadStore(ctx, activeStore)
|
|
if err != nil {
|
|
FatalError("%v", err)
|
|
}
|
|
if routed {
|
|
defer func() { _ = routedStore.Close() }()
|
|
activeStore = routedStore
|
|
}
|
|
|
|
// Direct mode
|
|
issues, err := activeStore.SearchIssues(ctx, "", filter)
|
|
if err != nil {
|
|
FatalError("%v", err)
|
|
}
|
|
|
|
// Apply sorting
|
|
sortIssues(issues, sortBy, reverse)
|
|
|
|
// Detect truncation (GH#3212). We fetched effectiveLimit+1 above, so any
|
|
// overflow means more matches exist than we're displaying.
|
|
truncated := effectiveLimit > 0 && len(issues) > effectiveLimit
|
|
if truncated {
|
|
issues = issues[:effectiveLimit]
|
|
}
|
|
|
|
// Handle watch mode (GH#654) - must be before other output modes
|
|
if watchMode {
|
|
watchIssues(ctx, activeStore, filter, parentID, sortBy, reverse, effectiveLimit)
|
|
return
|
|
}
|
|
|
|
// Handle pretty format (GH#654)
|
|
// JSON output takes priority over pretty/tree format (bd-list-json-fix, bd-03r)
|
|
if prettyFormat && !jsonOutput {
|
|
// Special handling for --tree --parent combination (hierarchical descendants)
|
|
if parentID != "" {
|
|
treeIssues, err := getHierarchicalChildren(ctx, activeStore, "", parentID)
|
|
if err != nil {
|
|
FatalError("%v", err)
|
|
}
|
|
|
|
if len(treeIssues) == 0 {
|
|
fmt.Printf("Issue '%s' has no children\n", parentID)
|
|
return
|
|
}
|
|
|
|
// Load dependencies for tree structure
|
|
// Best effort: display gracefully degrades with empty data
|
|
allDeps, _ := activeStore.GetAllDependencyRecords(ctx)
|
|
displayPrettyListWithDeps(treeIssues, false, allDeps)
|
|
return
|
|
}
|
|
|
|
// Regular tree display (no parent filter)
|
|
// Load dependencies for tree structure
|
|
// Best effort: display gracefully degrades with empty data
|
|
allDeps, _ := activeStore.GetAllDependencyRecords(ctx)
|
|
displayPrettyListWithDeps(issues, false, allDeps)
|
|
printTruncationHint(truncated, effectiveLimit)
|
|
return
|
|
}
|
|
|
|
// Handle format flag (non-json presets handled here; json handled earlier)
|
|
if formatStr != "" {
|
|
if err := outputFormattedList(ctx, activeStore, issues, formatStr); err != nil {
|
|
FatalError("%v", err)
|
|
}
|
|
printTruncationHint(truncated, effectiveLimit)
|
|
return
|
|
}
|
|
|
|
if jsonOutput {
|
|
// Get labels and dependency counts in bulk (single query instead of N queries)
|
|
issueIDs := make([]string, len(issues))
|
|
for i, issue := range issues {
|
|
issueIDs[i] = issue.ID
|
|
}
|
|
// Best effort: display gracefully degrades with empty data
|
|
labelsMap, _ := activeStore.GetLabelsForIssues(ctx, issueIDs)
|
|
depCounts, _ := activeStore.GetDependencyCounts(ctx, issueIDs)
|
|
allDeps, _ := activeStore.GetDependencyRecordsForIssues(ctx, issueIDs)
|
|
commentCounts, _ := activeStore.GetCommentCounts(ctx, issueIDs)
|
|
|
|
// Populate labels and dependencies for JSON output
|
|
for _, issue := range issues {
|
|
issue.Labels = labelsMap[issue.ID]
|
|
issue.Dependencies = allDeps[issue.ID]
|
|
}
|
|
|
|
// Build response with counts + computed parent (bd-ym8c)
|
|
issuesWithCounts := make([]*types.IssueWithCounts, len(issues))
|
|
for i, issue := range issues {
|
|
counts := depCounts[issue.ID]
|
|
if counts == nil {
|
|
counts = &types.DependencyCounts{DependencyCount: 0, DependentCount: 0}
|
|
}
|
|
// Compute parent from dependency records
|
|
var parent *string
|
|
for _, dep := range allDeps[issue.ID] {
|
|
if dep.Type == types.DepParentChild {
|
|
parent = &dep.DependsOnID
|
|
break
|
|
}
|
|
}
|
|
issuesWithCounts[i] = &types.IssueWithCounts{
|
|
Issue: issue,
|
|
DependencyCount: counts.DependencyCount,
|
|
DependentCount: counts.DependentCount,
|
|
CommentCount: commentCounts[issue.ID],
|
|
Parent: parent,
|
|
}
|
|
}
|
|
outputJSON(issuesWithCounts)
|
|
printTruncationHint(truncated, effectiveLimit)
|
|
return
|
|
}
|
|
|
|
// Show upgrade notification if needed
|
|
maybeShowUpgradeNotification()
|
|
|
|
// Load labels in bulk for display
|
|
issueIDs := make([]string, len(issues))
|
|
for i, issue := range issues {
|
|
issueIDs[i] = issue.ID
|
|
}
|
|
// Best effort: display gracefully degrades with empty data
|
|
labelsMap, _ := activeStore.GetLabelsForIssues(ctx, issueIDs)
|
|
|
|
// Load blocking info for displayed issues only (bd-7di).
|
|
// Previously loaded ALL dependency records which was O(total_issues) and took 2-4s.
|
|
// Now scoped to only the displayed issues, making it O(displayed_issues).
|
|
// Best effort: display gracefully degrades with empty data
|
|
blockedByMap, blocksMap, parentMap, _ := activeStore.GetBlockingInfoForIssues(ctx, issueIDs)
|
|
|
|
// Build output in buffer for pager support (bd-jdz3)
|
|
var buf strings.Builder
|
|
if ui.IsAgentMode() {
|
|
// Agent mode: ultra-compact, no colors, no pager
|
|
for _, issue := range issues {
|
|
formatAgentIssue(&buf, issue, blockedByMap[issue.ID], blocksMap[issue.ID], parentMap[issue.ID])
|
|
}
|
|
fmt.Print(buf.String())
|
|
printTruncationHint(truncated, effectiveLimit)
|
|
return
|
|
} else if longFormat {
|
|
// Long format: multi-line with details
|
|
buf.WriteString(fmt.Sprintf("\nFound %d issues:\n\n", len(issues)))
|
|
for _, issue := range issues {
|
|
labels := labelsMap[issue.ID]
|
|
formatIssueLong(&buf, issue, labels)
|
|
}
|
|
} else {
|
|
// Compact format: one line per issue
|
|
for _, issue := range issues {
|
|
labels := labelsMap[issue.ID]
|
|
formatIssueCompact(&buf, issue, labels, blockedByMap[issue.ID], blocksMap[issue.ID], parentMap[issue.ID])
|
|
}
|
|
}
|
|
|
|
// Output with pager support
|
|
if err := ui.ToPager(buf.String(), ui.PagerOptions{NoPager: noPager}); err != nil {
|
|
if _, writeErr := fmt.Fprint(os.Stdout, buf.String()); writeErr != nil {
|
|
fmt.Fprintf(os.Stderr, "Error writing output: %v\n", writeErr)
|
|
}
|
|
}
|
|
|
|
printTruncationHint(truncated, effectiveLimit)
|
|
|
|
// Show tip after successful list (direct mode only)
|
|
maybeShowTip(store)
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
listCmd.Flags().StringP("status", "s", "", "Filter by stored status (open, in_progress, blocked, deferred, closed). Comma-separated for multiple: --status open,in_progress")
|
|
listCmd.Flags().String("state", "", "Alias for --status")
|
|
_ = listCmd.Flags().MarkHidden("state")
|
|
registerPriorityFlag(listCmd, "")
|
|
listCmd.Flags().StringP("assignee", "a", "", "Filter by assignee")
|
|
listCmd.Flags().StringP("type", "t", "", "Filter by type (bug, feature, task, epic, chore, decision, merge-request, molecule, gate, convoy). Aliases: mr→merge-request, feat→feature, mol→molecule, dec/adr→decision")
|
|
listCmd.Flags().StringSliceP("label", "l", []string{}, "Filter by labels (AND: must have ALL). Can combine with --label-any")
|
|
listCmd.Flags().StringSlice("label-any", []string{}, "Filter by labels (OR: must have AT LEAST ONE). Can combine with --label")
|
|
listCmd.Flags().String("label-pattern", "", "Filter by label glob pattern (e.g., 'tech-*' matches tech-debt, tech-legacy)")
|
|
listCmd.Flags().String("label-regex", "", "Filter by label regex pattern (e.g., 'tech-(debt|legacy)')")
|
|
listCmd.Flags().String("title", "", "Filter by title text (case-insensitive substring match)")
|
|
listCmd.Flags().String("spec", "", "Filter by spec_id prefix")
|
|
listCmd.Flags().String("id", "", "Filter by specific issue IDs (comma-separated, e.g., bd-1,bd-5,bd-10)")
|
|
listCmd.Flags().IntP("limit", "n", 50, "Limit results (default 50, use 0 for unlimited)")
|
|
listCmd.Flags().String("format", "", "Output format: 'digraph' (for golang.org/x/tools/cmd/digraph), 'dot' (Graphviz), or Go template")
|
|
listCmd.Flags().Bool("all", false, "Show all issues including closed (overrides default filter)")
|
|
listCmd.Flags().Bool("long", false, "Show detailed multi-line output for each issue")
|
|
listCmd.Flags().String("sort", "", "Sort by field: priority, created, updated, closed, status, id, title, type, assignee")
|
|
listCmd.Flags().BoolP("reverse", "r", false, "Reverse sort order")
|
|
|
|
// Pattern matching
|
|
listCmd.Flags().String("title-contains", "", "Filter by title substring (case-insensitive)")
|
|
listCmd.Flags().String("desc-contains", "", "Filter by description substring (case-insensitive)")
|
|
listCmd.Flags().String("notes-contains", "", "Filter by notes substring (case-insensitive)")
|
|
|
|
// Date ranges
|
|
listCmd.Flags().String("created-after", "", "Filter issues created after date (YYYY-MM-DD or RFC3339)")
|
|
listCmd.Flags().String("created-before", "", "Filter issues created before date (YYYY-MM-DD or RFC3339)")
|
|
listCmd.Flags().String("updated-after", "", "Filter issues updated after date (YYYY-MM-DD or RFC3339)")
|
|
listCmd.Flags().String("updated-before", "", "Filter issues updated before date (YYYY-MM-DD or RFC3339)")
|
|
listCmd.Flags().String("closed-after", "", "Filter issues closed after date (YYYY-MM-DD or RFC3339)")
|
|
listCmd.Flags().String("closed-before", "", "Filter issues closed before date (YYYY-MM-DD or RFC3339)")
|
|
|
|
// Empty/null checks
|
|
listCmd.Flags().Bool("empty-description", false, "Filter issues with empty or missing description")
|
|
listCmd.Flags().Bool("no-assignee", false, "Filter issues with no assignee")
|
|
listCmd.Flags().Bool("no-labels", false, "Filter issues with no labels")
|
|
|
|
// Priority ranges
|
|
listCmd.Flags().String("priority-min", "", "Filter by minimum priority (inclusive, 0-4 or P0-P4)")
|
|
listCmd.Flags().String("priority-max", "", "Filter by maximum priority (inclusive, 0-4 or P0-P4)")
|
|
|
|
// Pinned filtering
|
|
listCmd.Flags().Bool("pinned", false, "Show only pinned issues")
|
|
listCmd.Flags().Bool("no-pinned", false, "Exclude pinned issues")
|
|
|
|
// Template filtering: exclude templates by default
|
|
listCmd.Flags().Bool("include-templates", false, "Include template molecules in output")
|
|
|
|
// Gate filtering: exclude gate issues by default (bd-7zka.2)
|
|
listCmd.Flags().Bool("include-gates", false, "Include gate issues in output (normally hidden)")
|
|
|
|
// Infra type filtering: exclude agent/rig/role/message by default
|
|
listCmd.Flags().Bool("include-infra", false, "Include infrastructure beads (agent/rig/role/message) in output")
|
|
|
|
// Explicit type exclusion
|
|
listCmd.Flags().StringSlice("exclude-type", nil, "Exclude issue types from results (comma-separated or repeatable, e.g., --exclude-type=convoy,epic)")
|
|
|
|
// Parent filtering: filter children by parent issue
|
|
listCmd.Flags().String("parent", "", "Filter by parent issue ID (shows children of specified issue)")
|
|
listCmd.Flags().String("filter-parent", "", "Alias for --parent")
|
|
_ = listCmd.Flags().MarkHidden("filter-parent") // Only fails if flag missing (caught in tests)
|
|
listCmd.Flags().Bool("no-parent", false, "Exclude child issues (show only top-level issues)")
|
|
|
|
// Molecule type filtering
|
|
listCmd.Flags().String("mol-type", "", "Filter by molecule type: swarm, patrol, or work")
|
|
|
|
// Wisp type filtering (TTL-based compaction classification)
|
|
listCmd.Flags().String("wisp-type", "", "Filter by wisp type: heartbeat, ping, patrol, gc_report, recovery, error, escalation")
|
|
|
|
// Time-based scheduling filters (GH#820)
|
|
listCmd.Flags().Bool("deferred", false, "Show only issues with defer_until set")
|
|
listCmd.Flags().String("defer-after", "", "Filter issues deferred after date (supports relative: +6h, tomorrow)")
|
|
listCmd.Flags().String("defer-before", "", "Filter issues deferred before date (supports relative: +6h, tomorrow)")
|
|
listCmd.Flags().String("due-after", "", "Filter issues due after date (supports relative: +6h, tomorrow)")
|
|
listCmd.Flags().String("due-before", "", "Filter issues due before date (supports relative: +6h, tomorrow)")
|
|
listCmd.Flags().Bool("overdue", false, "Show only issues with due_at in the past (not closed)")
|
|
|
|
// Pretty and watch flags (GH#654)
|
|
listCmd.Flags().Bool("pretty", false, "Display issues in a tree format with status/priority symbols")
|
|
listCmd.Flags().Bool("tree", true, "Hierarchical tree format (default: true; use --flat to disable)")
|
|
listCmd.Flags().Bool("flat", false, "Disable tree format and use legacy flat list output")
|
|
listCmd.Flags().BoolP("watch", "w", false, "Watch for changes and auto-update display (implies --pretty)")
|
|
|
|
// Metadata filtering (GH#1406)
|
|
listCmd.Flags().StringArray("metadata-field", nil, "Filter by metadata field (key=value, repeatable)")
|
|
listCmd.Flags().String("has-metadata-key", "", "Filter issues that have this metadata key set")
|
|
|
|
// Pager control (bd-jdz3)
|
|
listCmd.Flags().Bool("no-pager", false, "Disable pager output")
|
|
|
|
// Ready filter: show only issues ready to be worked on (bd-ihu31)
|
|
listCmd.Flags().Bool("ready", false, "Show only ready issues (status=open, excludes hooked/in_progress/blocked/deferred)")
|
|
|
|
// Note: --json flag is defined as a persistent flag in main.go, not here
|
|
rootCmd.AddCommand(listCmd)
|
|
}
|