beads/cmd/bd/ready.go
Julian Knutsen fb527d034a
perf(ready): page-push ready-work counts and size the total with cheap COUNT(*)s (#4679)
`bd ready --json` had two O(N) hotspots on main. The counts mega-query's
reverse-blocker `rc` subquery keys on COALESCE(depends_on_issue_id, …), an
expression the pure-Go GMS analyzer cannot auto-index, so it re-scanned its
whole materialization once per candidate — O(candidates × blockers). And the
"Showing X of N" total re-ran that entire mega-query UNBOUNDED just to size N.

Changes:
- Generalize one counts builder: sqlbuild.SearchCountsSQL now takes an optional
  `ids []string`. Empty ids = the predicate form (unchanged callers); non-empty
  ids = the page-pushed form that constrains the driver and every count
  subquery to the page, bounding rc by the page instead of the full graph.
  Removes the drifted SearchCountsSQL/SearchCountsByIDsSQL duplication; the
  projection order is defined once and DepTargetExpr is used throughout.
- issueops.runReadyCountsInTx resolves the ready-ID page with the cheap indexed
  ID query, then hydrates counts constrained to those IDs, CHUNKED by
  sqlbuild.QueryBatchSize so large pages stay within backend placeholder limits
  (no quadratic fallback, no wasted ID pass). The page order is restored so the
  result is byte-identical to the unbounded ORDER BY … LIMIT.
- issueops.CountReadyWorkInTx sizes N with indexed COUNT(*)s over the ready
  predicate for the issues AND wisps families, minus the wisp-wins overlap —
  identical to len(GetReadyWorkWithCounts(Limit=0)) even when wisps exist, with
  no mega-query fallback.
- Add ReadyWorkCounter to internal/storage beside the other optional
  capabilities; DoltStore and EmbeddedDoltStore implement CountReadyWork.
  cmd/bd/ready.go zeroes the limit at the call site and unwraps to the
  capability via storage.UnwrapStore, falling back to the unbounded query only
  when a store predates it.
- Extract the shared scan/dedupe loop (scanCountsRowsInTx).
- Conformance tests: page counts byte-identical to unbounded, and
  CountReadyWork == len(unbounded), with fixtures for wisps and a page that
  spans the chunk boundary.

Co-authored-by: Test User <test@test.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-08 18:07:41 -07:00

775 lines
25 KiB
Go

package main
import (
"context"
"fmt"
"os"
"strings"
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/debug"
"github.com/steveyegge/beads/internal/metrics"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/internal/ui"
"github.com/steveyegge/beads/internal/utils"
)
var readyCmd = &cobra.Command{
Use: "ready",
Short: "Show ready work (open, no active blockers)",
Long: `Show ready work (open issues with no active blockers).
Excludes in_progress, blocked, deferred, and hooked issues. This uses the
GetReadyWork API which applies blocker-aware semantics to find truly claimable work.
Note: 'bd list --ready' uses the same blocker-aware ready-work semantics.
Use --mol to filter to a specific molecule's steps:
bd ready --mol bd-patrol # Show ready steps within molecule
Use --gated to find molecules ready for gate-resume dispatch:
bd ready --gated # Find molecules where a gate closed
Use --claim to atomically claim the first ready issue matching the filters:
bd ready --claim --json
This is useful for agents executing molecules to see which steps can run next.`,
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
evt := metrics.NewCommandEvent("ready")
defer func() {
if c := metrics.Global(); c != nil {
c.CloseEventAndAdd(evt)
}
}()
if usesProxiedServer() {
return runReadyProxiedServer(cmd, rootCtx)
}
if offset, _ := cmd.Flags().GetInt("offset"); offset > 0 {
return HandleErrorRespectJSON("--offset is only supported under --proxied-server")
}
claimReady, _ := cmd.Flags().GetBool("claim")
gated, _ := cmd.Flags().GetBool("gated")
if gated {
if claimReady {
return HandleErrorRespectJSON("--claim cannot be combined with --gated")
}
// Delegate to the non-emitting core so `bd ready --gated` records
// exactly one cli_command event ("ready"), not also "mol-ready-gated".
return runMolReadyGatedCore(cmd, args)
}
molID, _ := cmd.Flags().GetString("mol")
if molID != "" {
if claimReady {
return HandleErrorRespectJSON("--claim cannot be combined with --mol")
}
return runMoleculeReady(cmd, molID)
}
explain, _ := cmd.Flags().GetBool("explain")
if explain {
if claimReady {
return HandleErrorRespectJSON("--claim cannot be combined with --explain")
}
return runReadyExplain(cmd)
}
limit, _ := cmd.Flags().GetInt("limit")
assignee, _ := cmd.Flags().GetString("assignee")
unassigned, _ := cmd.Flags().GetBool("unassigned")
sortPolicy, _ := cmd.Flags().GetString("sort")
labels, _ := cmd.Flags().GetStringSlice("label")
labelsAny, _ := cmd.Flags().GetStringSlice("label-any")
excludeLabels, _ := cmd.Flags().GetStringSlice("exclude-label")
issueType, _ := cmd.Flags().GetString("type")
issueType = utils.NormalizeIssueType(issueType) // Expand aliases (mr→merge-request, etc.)
parentID, _ := cmd.Flags().GetString("parent")
molTypeStr, _ := cmd.Flags().GetString("mol-type")
prettyFormat, _ := cmd.Flags().GetBool("pretty")
plainFormat, _ := cmd.Flags().GetBool("plain")
includeDeferred, _ := cmd.Flags().GetBool("include-deferred")
includeEphemeral, _ := cmd.Flags().GetBool("include-ephemeral")
excludeTypeStrs, _ := cmd.Flags().GetStringSlice("exclude-type")
var molType *types.MolType
if molTypeStr != "" {
mt := types.MolType(molTypeStr)
if !mt.IsValid() {
return HandleErrorRespectJSON("invalid mol-type %q (must be swarm, patrol, or work)", molTypeStr)
}
molType = &mt
}
if claimReady && assignee != "" {
return HandleErrorRespectJSON("--claim cannot be combined with --assignee")
}
// Normalize labels: trim, dedupe, remove empty
labels = utils.NormalizeLabels(labels)
labelsAny = utils.NormalizeLabels(labelsAny)
excludeLabels = utils.NormalizeLabels(excludeLabels)
// 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
}
}
// Normalize --exclude-type values.
var excludeTypes []types.IssueType
for _, raw := range excludeTypeStrs {
for _, t := range strings.Split(raw, ",") {
t = strings.TrimSpace(t)
if t != "" {
excludeTypes = append(excludeTypes, types.IssueType(utils.NormalizeIssueType(t)))
}
}
}
filter := types.WorkFilter{
Status: "open", // Only show open issues, not in_progress (matches bd list --ready)
Type: issueType,
Limit: limit,
Unassigned: unassigned,
SortPolicy: types.SortPolicy(sortPolicy),
Labels: labels,
LabelsAny: labelsAny,
ExcludeLabels: excludeLabels,
IncludeDeferred: includeDeferred, // GH#820: respect --include-deferred flag
IncludeEphemeral: includeEphemeral, // bd-i5k5x: allow ephemeral issues (e.g., merge-requests)
ExcludeTypes: excludeTypes,
}
// Use Changed() to properly handle P0 (priority=0)
if cmd.Flags().Changed("priority") {
priority, _ := cmd.Flags().GetInt("priority")
filter.Priority = &priority
}
if assignee != "" && !unassigned {
filter.Assignee = &assignee
}
if parentID != "" {
filter.ParentID = &parentID
}
if molType != nil {
filter.MolType = molType
}
// 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 == "" {
return HandleErrorRespectJSON("invalid --metadata-field: expected key=value, got %q", mf)
}
if err := storage.ValidateMetadataKey(k); err != nil {
return HandleErrorRespectJSON("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 {
return HandleErrorRespectJSON("invalid --has-metadata-key: %v", err)
}
filter.HasMetadataKey = hasMetadataKey
}
if !filter.SortPolicy.IsValid() {
return HandleErrorRespectJSON("invalid sort policy '%s'. Valid values: hybrid, priority, oldest", sortPolicy)
}
ctx := rootCtx
activeStore := store
if claimReady {
CheckReadonly("ready --claim")
} else {
routedStore, routed, err := openRoutedReadStore(ctx, activeStore)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
if routed {
defer func() { _ = routedStore.Close() }()
activeStore = routedStore
}
}
if claimReady {
claimed, err := activeStore.ClaimReadyIssue(ctx, filter, actor)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
if claimed == nil {
if jsonOutput {
return outputJSON([]*types.IssueWithCounts{})
}
fmt.Printf("\n%s No ready work to claim\n\n", ui.RenderWarn("○"))
return nil
}
if err := commitPendingIfEmbedded(ctx, activeStore, actor, doltAutoCommitParams{
Command: "ready",
IssueIDs: []string{claimed.ID},
}); err != nil {
return HandleErrorRespectJSON("failed to commit: %v", err)
}
SetLastTouchedID(claimed.ID)
if jsonOutput {
return outputJSON(buildReadyIssueOutput(ctx, activeStore, []*types.Issue{claimed}))
}
fmt.Printf("%s Claimed issue: %s\n", ui.RenderPass("✓"), formatFeedbackID(claimed.ID, claimed.Title))
return nil
}
if jsonOutput {
results, err := activeStore.GetReadyWorkWithCounts(ctx, filter)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
totalReady := len(results)
truncated := false
if filter.Limit > 0 && len(results) == filter.Limit {
// The page is full, so there may be more ready work. Size the true
// total N over the same ready predicate, zeroing the limit so the
// count is the full ready set (byte-identical to
// len(GetReadyWorkWithCounts(Limit=0))). Prefer the cheap COUNT(*)
// capability; unwrap past decorators (e.g. HookFiringStore) so the
// assertion reaches the concrete store. Fall back to the unbounded
// mega-query only when a store predates ReadyWorkCounter.
countFilter := filter
countFilter.Limit = 0
if counter, ok := storage.UnwrapStore(activeStore).(storage.ReadyWorkCounter); ok {
if n, countErr := counter.CountReadyWork(ctx, countFilter); countErr == nil && n > len(results) {
totalReady = n
truncated = true
}
} else {
all, countErr := activeStore.GetReadyWorkWithCounts(ctx, countFilter)
if countErr == nil && len(all) > len(results) {
totalReady = len(all)
truncated = true
}
}
}
if results == nil {
results = []*types.IssueWithCounts{}
}
if jerr := outputJSON(results); jerr != nil {
return jerr
}
if truncated {
fmt.Fprintf(os.Stderr, "Showing %d of %d ready issues. Use --limit 0 for all, or --limit N to raise the cap.\n", len(results), totalReady)
}
return nil
}
issues, err := activeStore.GetReadyWork(ctx, filter)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
totalReady := len(issues)
truncated := false
if !jsonOutput && filter.Limit > 0 && len(issues) == filter.Limit {
countFilter := filter
countFilter.Limit = 0
allIssues, countErr := activeStore.GetReadyWork(ctx, countFilter)
if countErr == nil && len(allIssues) > len(issues) {
totalReady = len(allIssues)
truncated = true
}
}
maybeShowUpgradeNotification()
if len(issues) == 0 {
hasOpenIssues := false
if stats, statsErr := activeStore.GetStatistics(ctx); statsErr == nil {
hasOpenIssues = stats.OpenIssues > 0 || stats.InProgressIssues > 0
}
if hasOpenIssues {
fmt.Printf("\n%s No ready work found (all issues have blocking dependencies)\n\n",
ui.RenderWarn("✨"))
} else {
fmt.Printf("\n%s No open issues\n\n", ui.RenderPass("✨"))
}
maybeShowTip(store)
return nil
}
parentEpicMap := buildParentEpicMap(ctx, activeStore, issues)
usePlain := plainFormat || !prettyFormat
if usePlain {
fmt.Printf("\n%s Ready work (%d issues with no active blockers):\n\n", ui.RenderAccent("📋"), len(issues))
for i, issue := range issues {
fmt.Printf("%d. [%s] [%s] %s: %s\n", i+1,
ui.RenderPriority(issue.Priority),
ui.RenderType(string(issue.IssueType)),
ui.RenderID(issue.ID), issue.Title)
if issue.EstimatedMinutes != nil {
fmt.Printf(" Estimate: %d min\n", *issue.EstimatedMinutes)
}
if issue.Assignee != "" {
fmt.Printf(" Assignee: %s\n", issue.Assignee)
}
}
fmt.Println()
} else {
displayReadyList(issues, parentEpicMap)
}
if truncated {
fmt.Printf("%s\n\n", ui.RenderMuted(fmt.Sprintf("Showing %d of %d ready issues. Use -n to show more.", len(issues), totalReady)))
}
maybeShowTip(store)
return nil
},
}
var blockedCmd = &cobra.Command{
Use: "blocked",
Short: "Show blocked issues",
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
evt := metrics.NewCommandEvent("blocked")
defer func() {
if c := metrics.Global(); c != nil {
c.CloseEventAndAdd(evt)
}
}()
if usesProxiedServer() {
return runBlockedProxiedServer(cmd, rootCtx)
}
// Use global jsonOutput set by PersistentPreRun (respects config.yaml + env vars)
// Use factory to respect backend configuration (bd-m2jr: SQLite fallback fix)
ctx := rootCtx
parentID, _ := cmd.Flags().GetString("parent")
var blockedFilter types.WorkFilter
if parentID != "" {
blockedFilter.ParentID = &parentID
}
blocked, err := store.GetBlockedIssues(ctx, blockedFilter)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
if jsonOutput {
if blocked == nil {
blocked = []*types.BlockedIssue{}
}
return outputJSON(blocked)
}
if len(blocked) == 0 {
fmt.Printf("\n%s No blocked issues\n\n", ui.RenderPass("✨"))
return nil
}
fmt.Printf("\n%s Blocked issues (%d):\n\n", ui.RenderFail("🚫"), len(blocked))
for _, issue := range blocked {
fmt.Printf("[%s] %s: %s\n",
ui.RenderPriority(issue.Priority),
ui.RenderID(issue.ID), issue.Title)
blockedBy := issue.BlockedBy
if blockedBy == nil {
blockedBy = []string{}
}
fmt.Printf(" Blocked by %d open dependencies: %v\n",
issue.BlockedByCount, blockedBy)
fmt.Println()
}
return nil
},
}
// buildParentEpicMap builds a map from child issue ID to parent epic title.
// Only includes parents that are epics.
func buildParentEpicMap(ctx context.Context, s storage.DoltStorage, issues []*types.Issue) map[string]string {
if len(issues) == 0 {
return nil
}
issueIDs := make([]string, len(issues))
for i, issue := range issues {
issueIDs[i] = issue.ID
}
allDeps, err := s.GetDependencyRecordsForIssues(ctx, issueIDs)
if err != nil {
return nil
}
// Find parent-child deps where the issue is the child
parentIDs := make(map[string]bool)
childToParent := make(map[string]string) // childID -> parentID
for issueID, deps := range allDeps {
for _, dep := range deps {
if dep.Type == types.DepParentChild {
parentIDs[dep.DependsOnID] = true
childToParent[issueID] = dep.DependsOnID
}
}
}
if len(parentIDs) == 0 {
return nil
}
// Fetch parent issues and filter to epics
epicTitles := make(map[string]string) // parentID -> title
for parentID := range parentIDs {
parent, err := s.GetIssue(ctx, parentID)
if err != nil || parent == nil {
continue
}
if parent.IssueType == "epic" {
epicTitles[parentID] = parent.Title
}
}
// Build final map: childID -> epic title
result := make(map[string]string)
for childID, parentID := range childToParent {
if title, ok := epicTitles[parentID]; ok {
result[childID] = title
}
}
return result
}
// displayReadyList displays ready issues in pretty format with optional parent epic context
func displayReadyList(issues []*types.Issue, parentEpicMap map[string]string) {
for _, issue := range issues {
epicTitle := ""
if parentEpicMap != nil {
epicTitle = parentEpicMap[issue.ID]
}
fmt.Println(formatPrettyIssueWithContext(issue, epicTitle))
}
// Summary footer
fmt.Println()
fmt.Println(strings.Repeat("-", 80))
fmt.Printf("Ready: %d issues with no active blockers\n", len(issues))
fmt.Println()
fmt.Println("Status: ○ open ◐ in_progress ● blocked ✓ closed ❄ deferred")
}
func buildReadyIssueOutput(ctx context.Context, s storage.DoltStorage, issues []*types.Issue) []*types.IssueWithCounts {
if issues == nil {
issues = []*types.Issue{}
}
issueIDs := make([]string, len(issues))
for i, issue := range issues {
issueIDs[i] = issue.ID
}
depCounts, _ := s.GetDependencyCounts(ctx, issueIDs)
allDeps, _ := s.GetDependencyRecordsForIssues(ctx, issueIDs)
commentCounts, _ := s.GetCommentCounts(ctx, issueIDs)
for _, issue := range issues {
issue.Dependencies = allDeps[issue.ID]
}
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}
}
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,
}
}
return issuesWithCounts
}
func runReadyExplain(_ *cobra.Command) error {
ctx := rootCtx
activeStore := store
filter := types.WorkFilter{
Status: types.StatusOpen,
SortPolicy: types.SortPolicyPriority,
}
readyIssues, err := activeStore.GetReadyWork(ctx, filter)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
blockedIssues, err := activeStore.GetBlockedIssues(ctx, types.WorkFilter{})
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
// Get dependency records for ready issues to find resolved blockers
readyIDs := make([]string, len(readyIssues))
for i, issue := range readyIssues {
readyIDs[i] = issue.ID
}
depCounts, err := activeStore.GetDependencyCounts(ctx, readyIDs)
if err != nil {
debug.Logf("warning: failed to get dependency counts: %v", err)
}
allDeps, err := activeStore.GetDependencyRecordsForIssues(ctx, readyIDs)
if err != nil {
debug.Logf("warning: failed to get dependency records: %v", err)
}
// Detect cycles
cycles, err := activeStore.DetectCycles(ctx)
if err != nil {
debug.Logf("warning: failed to detect cycles: %v", err)
}
// Collect all blocker IDs to batch-fetch blocker details
allBlockerIDs := make(map[string]bool)
for _, bi := range blockedIssues {
for _, blockerID := range bi.BlockedBy {
allBlockerIDs[blockerID] = true
}
}
blockerIDList := make([]string, 0, len(allBlockerIDs))
for id := range allBlockerIDs {
blockerIDList = append(blockerIDList, id)
}
// Build ready items with explanations
blockerIssues, err := activeStore.GetIssuesByIDs(ctx, blockerIDList)
if err != nil {
debug.Logf("warning: failed to get blocker issues: %v", err)
}
blockerMap := make(map[string]*types.Issue, len(blockerIssues))
for _, issue := range blockerIssues {
blockerMap[issue.ID] = issue
}
explanation := types.BuildReadyExplanation(readyIssues, blockedIssues, depCounts, allDeps, blockerMap, cycles)
if jsonOutput {
return outputJSON(explanation)
}
fmt.Printf("\n%s Ready Work Explanation\n\n", ui.RenderAccent("📊"))
// Ready section
if len(explanation.Ready) > 0 {
fmt.Printf("%s Ready (%d issues):\n\n", ui.RenderPass("●"), len(explanation.Ready))
for _, item := range explanation.Ready {
fmt.Printf(" %s [%s] %s\n",
ui.RenderID(item.ID),
ui.RenderPriority(item.Priority),
item.Title)
fmt.Printf(" Reason: %s\n", item.Reason)
if len(item.ResolvedBlockers) > 0 {
fmt.Printf(" Resolved blockers: %s\n", strings.Join(item.ResolvedBlockers, ", "))
}
if item.DependentCount > 0 {
fmt.Printf(" Unblocks: %d issue(s)\n", item.DependentCount)
}
fmt.Println()
}
} else {
fmt.Printf("%s No ready work\n\n", ui.RenderWarn("○"))
}
// Blocked section
if len(explanation.Blocked) > 0 {
fmt.Printf("%s Blocked (%d issues):\n\n", ui.RenderFail("●"), len(explanation.Blocked))
for _, item := range explanation.Blocked {
fmt.Printf(" %s [%s] %s\n",
ui.RenderID(item.ID),
ui.RenderPriority(item.Priority),
item.Title)
for _, blocker := range item.BlockedBy {
fmt.Printf(" ← blocked by %s: %s [%s]\n",
ui.RenderID(blocker.ID), blocker.Title, blocker.Status)
}
fmt.Println()
}
}
// Cycles section
if len(explanation.Cycles) > 0 {
fmt.Printf("%s Cycles detected (%d):\n\n", ui.RenderFail("⚠"), len(explanation.Cycles))
for _, cycle := range explanation.Cycles {
fmt.Printf(" %s → %s\n", strings.Join(cycle, " → "), cycle[0])
}
fmt.Println()
}
// Summary
fmt.Printf("%s Summary: %d ready, %d blocked",
ui.RenderMuted("─"),
explanation.Summary.TotalReady,
explanation.Summary.TotalBlocked)
if explanation.Summary.CycleCount > 0 {
fmt.Printf(", %d cycle(s)", explanation.Summary.CycleCount)
}
fmt.Printf("\n\n")
return nil
}
func runMoleculeReady(_ *cobra.Command, molIDArg string) error {
ctx := rootCtx
if store == nil {
return HandleErrorRespectJSON("no database connection")
}
moleculeID, err := utils.ResolvePartialID(ctx, store, molIDArg)
if err != nil {
return HandleErrorRespectJSON("molecule '%s' not found", molIDArg)
}
subgraph, err := loadTemplateSubgraph(ctx, store, moleculeID)
if err != nil {
return HandleErrorRespectJSON("loading molecule: %v", err)
}
// Get parallel analysis to find ready steps
analysis := analyzeMoleculeParallel(subgraph)
// Collect ready steps
var readySteps []*MoleculeReadyStep
for _, issue := range subgraph.Issues {
info := analysis.Steps[issue.ID]
if info != nil && info.IsReady {
readySteps = append(readySteps, &MoleculeReadyStep{
Issue: issue,
ParallelInfo: info,
ParallelGroup: info.ParallelGroup,
})
}
}
if jsonOutput {
return outputJSON(MoleculeReadyOutput{
MoleculeID: moleculeID,
MoleculeTitle: subgraph.Root.Title,
TotalSteps: analysis.TotalSteps,
ReadySteps: len(readySteps),
Steps: readySteps,
ParallelGroups: analysis.ParallelGroups,
})
}
fmt.Printf("\n%s Ready steps in molecule: %s\n", ui.RenderAccent("🧪"), subgraph.Root.Title)
fmt.Printf(" ID: %s\n", moleculeID)
fmt.Printf(" Total: %d steps, %d ready\n", analysis.TotalSteps, len(readySteps))
if len(readySteps) == 0 {
fmt.Printf("\n%s No ready steps (all blocked or completed)\n\n", ui.RenderWarn("✨"))
return nil
}
// Show parallel groups if any
if len(analysis.ParallelGroups) > 0 {
fmt.Printf("\n%s Parallel Groups:\n", ui.RenderPass("⚡"))
for groupName, members := range analysis.ParallelGroups {
// Check if any members are ready
readyInGroup := 0
for _, id := range members {
if info := analysis.Steps[id]; info != nil && info.IsReady {
readyInGroup++
}
}
if readyInGroup > 0 {
fmt.Printf(" %s: %d ready\n", groupName, readyInGroup)
}
}
}
fmt.Printf("\n%s Ready steps:\n\n", ui.RenderPass("📋"))
for i, step := range readySteps {
// Show parallel group if in one
groupAnnotation := ""
if step.ParallelGroup != "" {
groupAnnotation = fmt.Sprintf(" [%s]", ui.RenderAccent(step.ParallelGroup))
}
fmt.Printf("%d. [%s] [%s] %s: %s%s\n", i+1,
ui.RenderPriority(step.Issue.Priority),
ui.RenderType(string(step.Issue.IssueType)),
ui.RenderID(step.Issue.ID),
step.Issue.Title,
groupAnnotation)
if len(step.ParallelInfo.CanParallel) > 0 {
readyParallel := []string{}
for _, pID := range step.ParallelInfo.CanParallel {
if pInfo := analysis.Steps[pID]; pInfo != nil && pInfo.IsReady {
readyParallel = append(readyParallel, pID)
}
}
if len(readyParallel) > 0 {
fmt.Printf(" Can run with: %v\n", readyParallel)
}
}
}
fmt.Println()
return nil
}
// MoleculeReadyStep holds a ready step with its parallel info
type MoleculeReadyStep struct {
Issue *types.Issue `json:"issue"`
ParallelInfo *ParallelInfo `json:"parallel_info"`
ParallelGroup string `json:"parallel_group,omitempty"`
}
// MoleculeReadyOutput is the JSON output for bd ready --mol
type MoleculeReadyOutput struct {
MoleculeID string `json:"molecule_id"`
MoleculeTitle string `json:"molecule_title"`
TotalSteps int `json:"total_steps"`
ReadySteps int `json:"ready_steps"`
Steps []*MoleculeReadyStep `json:"steps"`
ParallelGroups map[string][]string `json:"parallel_groups"`
}
func init() {
readyCmd.Flags().IntP("limit", "n", 100, "Maximum issues to show (use 0 for unlimited)")
readyCmd.Flags().Int("offset", 0, "Skip the first N matching results (0-based). Only supported under --proxied-server.")
readyCmd.Flags().IntP("priority", "p", 0, "Filter by priority")
readyCmd.Flags().StringP("assignee", "a", "", "Filter by assignee")
readyCmd.Flags().BoolP("unassigned", "u", false, "Show only unassigned issues")
readyCmd.Flags().StringP("sort", "s", "priority", "Sort policy: priority (default), hybrid, oldest")
readyCmd.Flags().StringSliceP("label", "l", []string{}, "Filter by labels (AND: must have ALL). Can combine with --label-any")
readyCmd.Flags().StringSlice("label-any", []string{}, "Filter by labels (OR: must have AT LEAST ONE). Can combine with --label")
readyCmd.Flags().StringSlice("exclude-label", []string{}, "Exclude issues that have ANY of these labels")
readyCmd.Flags().StringP("type", "t", "", "Filter by issue type (task, bug, feature, epic, decision, merge-request). Aliases: mr→merge-request, feat→feature, mol→molecule, dec/adr→decision")
readyCmd.Flags().String("mol", "", "Filter to steps within a specific molecule")
readyCmd.Flags().String("parent", "", "Filter to descendants of this bead/epic")
readyCmd.Flags().String("mol-type", "", "Filter by molecule type: swarm, patrol, or work")
readyCmd.Flags().Bool("pretty", true, "Display issues in a tree format with status/priority symbols")
readyCmd.Flags().Bool("plain", false, "Display issues as a plain numbered list")
readyCmd.Flags().Bool("include-deferred", false, "Include issues with future defer_until timestamps")
readyCmd.Flags().Bool("include-ephemeral", false, "Include ephemeral issues (wisps) in results")
readyCmd.Flags().Bool("gated", false, "Find molecules ready for gate-resume dispatch")
readyCmd.Flags().StringSlice("exclude-type", nil, "Exclude issue types from results (comma-separated or repeatable, e.g., --exclude-type=convoy,epic)")
readyCmd.Flags().Bool("explain", false, "Show dependency-aware reasoning for why issues are ready or blocked")
readyCmd.Flags().Bool("claim", false, "Atomically claim the first ready issue matching the filters")
// Metadata filtering (GH#1406)
readyCmd.Flags().StringArray("metadata-field", nil, "Filter by metadata field (key=value, repeatable)")
readyCmd.Flags().String("has-metadata-key", "", "Filter issues that have this metadata key set")
rootCmd.AddCommand(readyCmd)
blockedCmd.Flags().String("parent", "", "Filter to descendants of this bead/epic")
rootCmd.AddCommand(blockedCmd)
}