* feat(roles): BatchGetter role and issues:batchGet route (S7)
Adds BatchGetter.GetMany(ids) -> {Issues, Missing}, a one-snapshot,
order-preserving, deduped, 1000-id-capped batch read, wired through all
three library legs (dolt, embedded dolt, uow) behind the existing
hook/telemetry decorator chain, plus the POST /v0/beads/issues:batchGet
HTTP route (spec, apigen, wire-shape golden, issues.batchGet capability
token). Conformance contract (RunBatchGetter*, 12 cases) passes on all
three legs against real backends. No HTTP client leg yet (waits on the
generator / PR #7247); left as a documented seam on BatchGetter's doc
comment.
CLI GetIssuesByIDs call sites are left unmigrated this slice and marked
with TODO(batchgetter) comments: every call site reads an unbounded id
list today, and GetMany's 1000-id cap has no chunking/fallback in any
caller yet, so swapping them in now would add a new, unhandled failure
mode to already-shipped CLI paths (export, import, molecule port,
ready-explain, wisp sweep).
Verified via three live-mutate guards against
internal/storage/issueops/batchget.go (disabling the cap check, dropping
the Missing append, and replacing ordered iteration with map iteration):
each turns the embedded-dolt contract red, confirming the cap, Missing
reporting, and order-preservation assertions actually catch a break.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
* fix(roles): close S7 review gaps — revision on wire, BUILD sync, handler tests
Addresses the S7 Opus review's FIX-FIRST items on BatchGetter/issues:batchGet:
HIGH
- batchGetResponse now projects apigen.BatchGetIssue (types.BatchGetIssue +
NewBatchGetIssue), carrying `revision` per issue the way IssueDetails does;
spec, apigen and the wire-shape golden regenerated (additive, no
wire_revision bump).
- make bazel-sync: the 12 files missing from BUILD.bazel srcs are back in
sync across 9 BUILD.bazel files.
- New internal/httpapi/batch_get_test.go: success incl. revision, missing
ids, empty arrays not null, unknown member refused, missing/null ids
refused, query parameter refused, 1001 ids refused with the full request
reaching the role, 1000 ids accepted.
MED
- RunBatchGetterAcceptsExactlyTheCap pins the cap boundary (> vs >=).
- RunBatchGetterHydratesLabels pins Labels survive projection.
- RunBatchGetterReadsOneSnapshot renamed to
RunBatchGetterSharesOneReadStructurally with a doc that no longer
overclaims atomicity; a real interleaving test needs a hook on the frozen
roleFixtureKit, out of scope here.
- Doc comments across ExecuteGetMany, GetManyResult.Issues and the
BatchGetter interface now say hydration is labels only.
LOW
- failBatchGetErr's doc no longer claims blank entries are "already caught".
- PR #7247 references kept.
Re-ran build/vet/gofmt/lint, make api-check, make bazel-sync(-check), the
full internal/httpapi suite, and all three conformance legs (dolt via the
pinned local server, embeddeddolt, uow) plus targeted cmd/bd serve tests —
all green. Live-mutate-guard reverified: cap >=, dropping Missing from the
response, and clearing Labels each now fail the relevant test.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
* fix(roles): sync client vocabulary and repo gates with issues:batchGet
The S7 route landed on the server without the sibling tables that hold
the rest of the tree set-equal with the server's surface, so five
tests and two manifest gates went red on the PR head:
- httpclient/wire: mirror batchGetIssues into the client vocabulary,
CLASSIFIED, not wired, the way the wire wave and #7250's
issues.count.scope landed: OpBatchGetIssues, its issues.batchGet
token on opCapability, its identity row, and the first-slice skew
dimension 35 -> 36 (TestCapabilityTableMatchesTheServerRouteTable).
- httpclient/wire: BatchGetIssue is the first golden.json schema with
a `revision` member that needs no legacy-integer tolerance — the
route postdates #6053 and types.BatchGetIssue declares Revision a
string, and a pre-#6053 server never advertises issues.batchGet, so
Preflight refuses before any body is decoded. Exempt it with that
reason in a new revisionSchemaExempt table rather than adding an
issues[] rewrite no legacy server can reach; the gate refuses an
entry that is both covered and exempt, a stale exemption, and an
empty reason.
- httpclient/encode: give the oracle's role set a BatchGetter stub —
httpapi.Listen requires the whole set, so all three oracle tests
failed to bind.
- storage/uow: exempt IssueUseCase.GetMany from the notifying-parity
partition as a read, the reason hook_batch_getter.go gives.
- shard manifest: place TestBatchGetterContract in the 15-shard
embedded storage block (generator --write, incremental).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(roles): pin the BatchGetter pure tier and the spec ids caps
Review fixes, iteration 1. The review approved with no blocker or major
finding and three minors, and this commit takes all three. It changes
tests and one comment only, and every new assertion was mutation-probed
with go test -overlay.
- storage/issueops: add batchget_test.go, the database-free tier that
FinishGetMany's doc already claimed ("pinned without a database") but
that no test supplied. It pins:
- the cap is checked before the blank scan (an over-cap request with
a blank at position 0 answers *TooManyIDsError);
- the bound is inclusive;
- dedupe keeps the first mention, does not trim, and never writes
through the caller's slice;
- Issues and Missing both follow request order;
- both slices are never nil;
- ExecuteGetMany refuses one id repeated past the cap before any
query (a sqlmock with no expectations).
Ten mutants were each killed by exactly their intended test, with the
rest of the package green: last-mention, sort, trim, in-place dedupe,
blank-before-cap, >=, nil Missing, nil Issues, dedupe-before-validate
and validate-after-query.
- httpapi: TestSpecDefaultsMatchSharedConstants now checks ids.maxItems
against the enforced bound on the two request bodies that carry an
`ids` list: batchGetIssues against issueops.MaxGetManyIDs, and
deleteIssues against maxDeleteIDs. Each body is reached through its
operation's own requestBody $ref. Setting either constant to 999 turns
only this test red. The spec's other list caps (batch
create/close/apply items, dependency edge lists) stay ungated, as
before.
- cmd/bd/serve.go: the batchGetter field comment said its accessor
"does NOT recurse through the hook decorator". HookFiringStore.
BatchGetter does recurse to the inner getter; it just doesn't wrap
the result. The comment now says that.
Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Julian Knutsen
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
810 lines
29 KiB
Go
810 lines
29 KiB
Go
package main
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"os"
|
||
"strings"
|
||
|
||
"github.com/spf13/cobra"
|
||
"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"
|
||
"github.com/steveyegge/beads/internal/workapi"
|
||
"github.com/steveyegge/beads/issueops"
|
||
)
|
||
|
||
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)
|
||
}
|
||
}()
|
||
|
||
claimReady, _ := cmd.Flags().GetBool("claim")
|
||
|
||
// ABOVE THE MODE DISPATCH, and above the proxied branch, so it is the
|
||
// one place a --brief conflict is decided for this command on either
|
||
// route. The branches below return before gatherReadyInput runs, so a
|
||
// check written into each of them would be three untested copies; this
|
||
// is one call into the body the gatherer also uses.
|
||
if err := briefModeConflictFromFlags(cmd); err != nil {
|
||
return err
|
||
}
|
||
|
||
if usesProxiedServer() {
|
||
// The proxied ready role cannot enforce a row cap, including on
|
||
// --claim. Refuse any positive cap rather than silently dropping
|
||
// this safety limit; malformed values remain usage errors. The
|
||
// pre-provider front door refuses the same cap first, so this is
|
||
// its backstop — both raise proxy.max_rows.unsupported.
|
||
//
|
||
// --gated is skipped here as well as at the front door, and it has
|
||
// to be skipped in both places: this backstop calls
|
||
// AssertProxyCapability with an empty command, so it always
|
||
// resolves the mode-wide refusal and cannot honor the
|
||
// command-specific allow the front door's path-keyed assert reads.
|
||
// Exempting only the front door would move the split from one
|
||
// refusal site to the other, not close it.
|
||
if err := rejectReadyMaxRowsUnderProxiedServer(cmd); err != nil {
|
||
return err
|
||
}
|
||
return runReadyProxiedServer(cmd, rootCtx)
|
||
}
|
||
|
||
if offset, _ := cmd.Flags().GetInt("offset"); offset > 0 {
|
||
return HandleErrorRespectJSON("--offset is only supported under --proxied-server")
|
||
}
|
||
|
||
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)
|
||
}
|
||
|
||
// The row cap is meaningful on this route alone - the proxied one
|
||
// rejects a live cap outright - so this is the only caller that hands
|
||
// the gatherer a resolver for it.
|
||
in, err := gatherReadyInput(cmd, resolveMaxRows)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
filter := in.filter
|
||
|
||
ctx := rootCtx
|
||
|
||
activeStore := store
|
||
if claimReady {
|
||
CheckReadonly("ready --claim")
|
||
} else {
|
||
routedStore, routed, routingRule, err := openRoutedReadStore(ctx, activeStore)
|
||
if err != nil {
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
if routed {
|
||
defer func() { _ = routedStore.Close() }()
|
||
printContributorRoutingNotice(ctx, activeStore, routingRule)
|
||
activeStore = routedStore
|
||
}
|
||
}
|
||
|
||
if claimReady {
|
||
// The claim is on the ReadyClaimer role, through the store's own
|
||
// accessor, so selection, the compare-and-set and the hydration
|
||
// that feeds --json all share one transaction. The listing below
|
||
// is not on a role and still builds the filter, for the reasons
|
||
// issueops.Reader's doc comment gives.
|
||
claimer, err := activeStore.ReadyClaimer()
|
||
if err != nil {
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
res, err := claimer.ClaimNext(ctx, claimNextRequest(in))
|
||
if err != nil {
|
||
// No handleMaxRowsError here, unlike the listing below: the
|
||
// request carries no cap, so ErrTooManyRows cannot come back.
|
||
// See claimNextRequest for why the cap never applied.
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
if res.Claimed == nil {
|
||
if jsonOutput {
|
||
return outputJSON([]*types.IssueWithCounts{})
|
||
}
|
||
fmt.Printf("\n%s No ready work to claim\n\n", ui.RenderWarn("○"))
|
||
return nil
|
||
}
|
||
claimed := res.Claimed
|
||
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([]*types.IssueWithCounts{claimed})
|
||
}
|
||
fmt.Printf("%s Claimed issue: %s\n", ui.RenderPass("✓"), formatFeedbackID(claimed.ID, claimed.Title))
|
||
return nil
|
||
}
|
||
|
||
if jsonOutput {
|
||
// The page and the size of the whole ready set come back from ONE
|
||
// read transaction: the total rides the page's own ID query, so a
|
||
// capped listing no longer pays for a second counting pass (and a
|
||
// second defer-wake sweep) just to print "Showing N of M". Against
|
||
// a remote SQL server each of that pass's statements was a
|
||
// sequential round trip. The total is the same number the
|
||
// ReadyCounter role answers (storage.DoltStorage documents the
|
||
// identity), taken over the listing's own filter.
|
||
results, total, err := activeStore.GetReadyWorkWithCountsAndTotal(ctx, filter)
|
||
if err != nil {
|
||
if capErr := handleMaxRowsError(err); capErr != nil {
|
||
return capErr
|
||
}
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
totalReady := len(results)
|
||
truncated := false
|
||
if filter.Limit > 0 && len(results) == filter.Limit && total > len(results) {
|
||
totalReady = total
|
||
truncated = true
|
||
}
|
||
if results == nil {
|
||
results = []*types.IssueWithCounts{}
|
||
}
|
||
var pag *PaginationMeta
|
||
if truncated {
|
||
pag = &PaginationMeta{
|
||
Returned: len(results),
|
||
Total: totalReady,
|
||
Truncated: true,
|
||
}
|
||
}
|
||
if jerr := outputJSONWithPagination(results, pag); 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 {
|
||
if capErr := handleMaxRowsError(err); capErr != nil {
|
||
return capErr
|
||
}
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
|
||
totalReady := len(issues)
|
||
truncated := false
|
||
if filter.Limit > 0 && len(issues) == filter.Limit {
|
||
// The same question the --json branch answers in-band, asked here
|
||
// of the ReadyCounter role, whose answer is the same identity, so
|
||
// the "Showing X of N" a human reads and the total a script parses
|
||
// are one number.
|
||
if n, countErr := readyTotal(ctx, activeStore, in); countErr == nil && n > len(issues) {
|
||
totalReady = n
|
||
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 := in.plainFormat || !in.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
|
||
},
|
||
}
|
||
|
||
// readyGatedArm reports whether this `bd ready` invocation dispatches to the
|
||
// gate-resume arm — the same scan `bd mol ready --gated` runs, and the reason
|
||
// the row cap does not apply to it. Both proxied refusal sites call this, so
|
||
// the exemption cannot land on one and miss the other.
|
||
//
|
||
// The arm lists molecules whose gate closed, never ready rows: on the direct
|
||
// route --gated reaches runMolReadyGatedCore above any cap resolution, and on
|
||
// the proxied route runReadyProxiedGated discards its readyInput and calls the
|
||
// same findGateReadyMolecules as runMolReadyGatedProxiedServer. `mol ready`,
|
||
// the documented alias, carries a notApplicable() cap row for exactly that
|
||
// reason; keying the refusal on `bd ready` alone split one documented command
|
||
// line across its two spellings.
|
||
//
|
||
// --claim is excluded deliberately. `--claim --gated` is a usage error
|
||
// (gatherReadyInput), not a gated run, so the claim arm keeps the refusal it is
|
||
// owed on every code path and this exemption cannot reopen it.
|
||
func readyGatedArm(cmd *cobra.Command) bool {
|
||
if cmd == nil {
|
||
return false
|
||
}
|
||
if gated, _ := cmd.Flags().GetBool("gated"); !gated {
|
||
return false
|
||
}
|
||
claim, _ := cmd.Flags().GetBool("claim")
|
||
return !claim
|
||
}
|
||
|
||
// rejectReadyMaxRowsUnderProxiedServer is `bd ready`'s in-RunE backstop for the
|
||
// row cap the proxied ready role cannot enforce. It exists as a named function
|
||
// rather than an inline `if` so the exemption is reachable from a unit test:
|
||
// the front door's half runs against the real command tree in
|
||
// TestProxyCapabilityFrontDoorAllowsSupportedCommands, but this half sits
|
||
// behind usesProxiedServer() and would otherwise be pinned only by the
|
||
// env-gated proxied e2e lane.
|
||
//
|
||
// Call it in place of rejectMaxRowsUnderProxiedServer on this command; every
|
||
// other capped command wants the unconditional form.
|
||
func rejectReadyMaxRowsUnderProxiedServer(cmd *cobra.Command) error {
|
||
if readyGatedArm(cmd) {
|
||
return nil
|
||
}
|
||
return rejectMaxRowsUnderProxiedServer(cmd)
|
||
}
|
||
|
||
// blockedFilterFromFlags builds the blocked-issue filter from blockedCmd's
|
||
// flags. Both the direct and the proxied-server path call it, so the two
|
||
// cannot drift as filtering flags are added.
|
||
func blockedFilterFromFlags(cmd *cobra.Command) types.WorkFilter {
|
||
var filter types.WorkFilter
|
||
if parentID, _ := cmd.Flags().GetString("parent"); parentID != "" {
|
||
filter.ParentID = &parentID
|
||
}
|
||
// Normalize as every other label filter does (list_input.go:293-295,
|
||
// search.go:106, orphans.go:56, workapi/ready.go:56-58). These clauses
|
||
// match a label EXACTLY, so an untrimmed value silently under-reports:
|
||
// pflag's CSV split leaves the leading space in the everyday
|
||
// `--label 'a, b'` form, and `--label 'a,,b'` would AND in a `label = ''`
|
||
// clause that matches nothing at all. Without this, `--label` would not
|
||
// mean the same thing here as on the commands next to it -- which is the
|
||
// promise LabelSetClauses is documented to keep.
|
||
labels, _ := cmd.Flags().GetStringSlice("label")
|
||
labelsAny, _ := cmd.Flags().GetStringSlice("label-any")
|
||
excludeLabels, _ := cmd.Flags().GetStringSlice("exclude-label")
|
||
filter.Labels = utils.NormalizeLabels(labels)
|
||
filter.LabelsAny = utils.NormalizeLabels(labelsAny)
|
||
filter.ExcludeLabels = utils.NormalizeLabels(excludeLabels)
|
||
return filter
|
||
}
|
||
|
||
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
|
||
blockedFilter := blockedFilterFromFlags(cmd)
|
||
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
|
||
},
|
||
}
|
||
|
||
// readyTotal sizes the whole ready set for the request `bd ready` just listed
|
||
// a page of, through the store's own ReadyCounter accessor.
|
||
//
|
||
// THE TEXT OUTPUT CALLS IT, and only when the page came back full, which is
|
||
// the one situation where the answer can differ from what is already on
|
||
// screen. The --json listing does not: it takes its total in-band from
|
||
// GetReadyWorkWithCountsAndTotal, in the page's own transaction.
|
||
//
|
||
// The role has no --max-rows field to honor and needs none: the cap bounds a
|
||
// page this machine materializes, and a count materializes no rows.
|
||
//
|
||
// A failed count is not a failed command — the page is already correct; all
|
||
// that is lost is the "of N" beside it.
|
||
func readyTotal(ctx context.Context, activeStore storage.DoltStorage, in readyInput) (int, error) {
|
||
counter, err := activeStore.ReadyCounter()
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
result, err := counter.CountReady(ctx, readyRoleRequest(in))
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return int(result.Total), 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")
|
||
fmt.Println("Priority: P0–P4 (label only; not a status icon)")
|
||
}
|
||
|
||
// readyExplainFilter is the filter both --explain routes run, derived from the
|
||
// same builder the listing uses so the set `bd ready --explain` explains cannot
|
||
// drift from the set `bd ready` shows (bd-3fs.3).
|
||
//
|
||
// --explain takes no listing flags: it is a whole-graph diagnostic, and the
|
||
// direct route reaches it before the flags are even gathered. The limit is
|
||
// therefore pinned to unlimited rather than left to workapi.DefaultReadyLimit,
|
||
// which would silently truncate the explanation at 100 rows.
|
||
func readyExplainFilter() (types.WorkFilter, error) {
|
||
unlimited := 0
|
||
return workapi.BuildReadyFilter(issueops.ReadyRequest{
|
||
Sort: string(types.SortPolicyPriority),
|
||
Limit: &unlimited,
|
||
})
|
||
}
|
||
|
||
func runReadyExplain(_ *cobra.Command) error {
|
||
ctx := rootCtx
|
||
|
||
activeStore := store
|
||
|
||
filter, err := readyExplainFilter()
|
||
if err != nil {
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
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
|
||
// TODO(batchgetter): unbounded id list; see issueops.BatchGetter's doc and
|
||
// the importIssueLookup TODO in import_shared.go for why this is not yet
|
||
// routed through the role.
|
||
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", workapi.DefaultReadyLimit, "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().String("label-pattern", "", "Filter by label glob pattern (e.g., 'tech-*' matches tech-debt, tech-legacy)")
|
||
readyCmd.Flags().String("label-regex", "", "Filter by label regex pattern (e.g., 'tech-(debt|legacy)')")
|
||
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("flat", false, "Alias for --plain, spelled the way bd list spells it")
|
||
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")
|
||
// Projection toggle, the same one `bd list --brief` sets. Refused with
|
||
// --claim, which returns one whole row by contract; see gatherReadyInput.
|
||
readyCmd.Flags().Bool("brief", false,
|
||
"Omit the free-form text (description, design, acceptance criteria, notes, "+
|
||
"payload, waiters) from each row. Filters that read those fields still "+
|
||
"select on them. An omitted field is indistinguishable from an empty "+
|
||
"one; fetch a whole issue with bd show. Requires --json, and cannot be "+
|
||
"combined with --claim, --gated, --mol or --explain.")
|
||
// 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")
|
||
// Defensive row cap (be-x42v): exits 2 on overage, default disabled.
|
||
addMaxRowsFlag(readyCmd)
|
||
rootCmd.AddCommand(readyCmd)
|
||
blockedCmd.Flags().String("parent", "", "Filter to descendants of this bead/epic")
|
||
blockedCmd.Flags().StringSliceP("label", "l", []string{}, "Filter by labels (AND: must have ALL). Can combine with --label-any")
|
||
blockedCmd.Flags().StringSlice("label-any", []string{}, "Filter by labels (OR: must have AT LEAST ONE). Can combine with --label")
|
||
blockedCmd.Flags().StringSlice("exclude-label", []string{}, "Exclude issues that have ANY of these labels")
|
||
rootCmd.AddCommand(blockedCmd)
|
||
}
|