* feat(http): bd blocked over bd serve (blocked.list) through issueops.BlockedLister
`bd blocked` refused against an HTTP workspace: it called the legacy
GetBlockedIssues, which the HTTP backend stubs as unsupported. It now runs
one role on every route, and bd serve publishes that role.
- Role: issueops.BlockedLister.ListBlocked(BlockedRequest{ParentID, Labels,
LabelsAny, ExcludeLabels}) -> BlockedResult{Items}. One body,
internal/storage/issueops.ExecuteListBlockedInTx over the unchanged
GetBlockedIssuesInTx; labels normalized in the role (BlockedFilter);
Items never nil and in a total order (priority, created_at desc, id).
- Legs: DoltStore (read tx), EmbeddedDoltStore (read conn), uow (read unit
of work through the use case's GetBlockedIssues, so the
external-dependency uow decorator applies). Census: storage.DoltStorage
gains BlockedLister(); HookFiringStore passes it through (a read),
telemetry wraps it, uow.notifyingProvider, externaldeps.uowProvider and
httpapi.timedProvider build it.
- externaldeps.Store.BlockedLister is built over its own GetBlockedIssues,
so local `bd blocked` output is unchanged. Over a remote store it takes
the server's listing when the server advertises
policy.external_dependencies, else decorates the server's listing here
through EdgeReader and BatchGetter (decorateBlocked, factored out of
GetBlockedIssues).
- Wire: GET /v0/beads/blocked (listBlockedIssues; parent, label,
label_any, exclude_label) answering BlockedPage {items, has_more} with
the new x-go-type-pinned BlockedIssue schema, behind the new
blocked.list token. apigen and the wire-shape golden regenerated; the
golden diff is additive only, so wire_revision stays 2.
Config.BlockedLister is a required role, wired in bd serve.
- Client: httpclient.Store.BlockedLister dials through Store.dispatch, so
an older server is refused BEFORE the dial with *wire.CapabilityError
naming blocked.list. The legacy Store.GetBlockedIssues rides the role
(page and row cap applied to its answer) and leaves the unsupported
shell. Divergence ledger row F-blocked retired.
- CLI: `bd blocked` takes BlockedLister() from the store on the direct
routes and from the provider's BlockedListerSource on the proxied route;
runBlockedProxiedServer is deleted. --json output is the same rows in
the same order, [] when empty.
Tests: backend/conformance RunBlockedLister (10 cases: direct blocker,
child attributed to its blocked parent, closed blocker, wisp plane, pinned
status, parent filter, label filters with normalization, order, empty
slice, request not mutated) on dolt, embedded, uow and the served HTTP
client; httpapi handler tests (mapping, unknown/repeated params,
projection, capability); httpclient stub tests (pre-dial refusal naming
the token, encoding, projection, legacy door paging); skew and vocabulary
counts; TestE2E_BlockedOverHTTP (served `bd blocked --json` equals the
local command's after mapping ids and timestamps, member order included,
external blocker named, older-server refusal with no dial); corpus
gc-blocked re-marked and gc-blocked-parent added, both pending until the
reference server advertises blocked.list.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* fix(blocked): pin server-side external decoration, refuse has_more, serve the legacy door over http
Review fixes for the blocked.list slice.
- Server-side external decoration is now pinned on the compositions bd
serve answers from. TestWrapUOWProviderBlockedListerNamesExternalBlockers
lists through the wrapped unit-of-work provider's own BlockedLister
accessor (the bd serve provider path) and requires an external-only row
and a mixed row to carry their external: refs; building that lister over
the inner provider fails it. TestServedBlockedListerCarriesExternalRefs-
WhenTheServerEnforces serves the store-shaped composition
(externaldeps.Store.BlockedLister, policy advertised) and requires the
operation's own answer, through the undecorated client role, to carry the
refs, and the client's decorated chain to return it unchanged; serving
the inner store's lister fails it.
- The client refuses an answer reporting has_more with the new typed
httpclient.TruncatedListingError instead of returning a short listing:
the operation has no cursor, and a caller reads a missing row as
unblocked. The legacy door inherits it.
- externaldeps.Store.GetBlockedIssues over an http store reads the extra
sources through the served roles (EdgeReader, BatchGetter) instead of the
raw GetIssuesByIDs / GetDependencyRecordsForIssues the http backend
refuses, and the decoration skips the source read when there is nothing
to load. The legacy door on the CLI chain (bd mol stale, the wisp
commands) now answers over http in both policy modes;
TestServedLegacyGetBlockedIssuesThroughTheDecorator pins it, paging
included. bd ready --explain still refuses on its other raw reads; the
CHANGELOG says so.
- Docs: the spec and the retired F-blocked ledger row state that the
listing is unpaged, bounded by the client's 32 MiB response limit
(refused, never read in part), and that has_more is refused.
- Contract: new cases for waits-for and conditional-blocks blockers, no
type exclusions (gate, epic), and a stale flag with no nameable blocker
(on the legs that can write the column: dolt, embedded; skipped
elsewhere with the reason). Order seeds explicit created_at values with
five rows tied on priority and created_at, two of them wisps, so only the
id tiebreak orders them; dropping the tiebreak now fails every run.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* feat(blocked): bd blocked --flags, the blocked flag per id from stdin
`bd blocked --flags [--json]` reads ids from stdin, one per line (blank
lines and repeats ignored), and prints the blocked flag bd holds for each:
with --json, [{"id","is_blocked"}] in the order the ids were first given,
omitting an id that names no row on either plane, [] for no input. It is
the readiness column a consumer otherwise had to read with `bd sql`, so no
such consumer needs a local-only command.
It is the FLAG, not the listing: `bd blocked` narrows the stored flag to
rows it can name a blocker for, and --flags does not, so a row whose flag
is set with no nameable blocker reads true here and is absent from the
listing. Where the external-dependency policy applies, an unsatisfied
external: blocker sets the flag, as it keeps the row out of `bd ready`.
One library entry on every route: issueops.BlockedFlags over the route's
BlockingAnnotator (the store's accessor on dolt, embedded and HTTP, the
provider's on the proxied route). Over HTTP that is listBlockingAnnotations
with is_blocked behind dependencies.blocking.isBlocked; a server without
that token is refused before the dial, naming it. No wire change. The
listing's filter flags are refused with --flags rather than ignored.
Tests: TestE2E_BlockedFlagsOverHTTP (served JSON equals the local command's
after mapping ids to titles, unknown id omitted, repeat collapsed, [] on
empty stdin, filters refused; a stale-flagged row with no blocker reads
true and is absent from `bd blocked --json`, which fails if --flags is
derived from the listing; an older server's handshake refused naming the
token with no dial); TestProxiedServerBlocked/flags_reads_ids_from_stdin on
the proxied route; corpus gc-blocked-flags, pending until the reference
server advertises the token. CHANGELOG entry.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* feat(blocked): bd blocked --flags --raw, the stored is_blocked column
`bd blocked --flags --raw [--json]` answers the stored is_blocked column
for each id read from stdin, exactly what reading is_blocked from the issues
and wisps tables returns, without the external-dependency policy: a row
blocked only by an unsatisfied external: ref reads false (the policy-aware
--flags reads true), and a stale flag reads true either way. Same output
shape as --flags. This lets a consumer move off a `bd sql` read of the
column with no change in what it reads. The default --flags is unchanged.
The role is taken from beneath every decorator: storage.UnwrapStore on the
direct routes, uow.UnwrapProvider on the proxied route. Over HTTP the
innermost store is the http client, whose annotation read is the server's
answer: against a server that does not advertise
policy.external_dependencies that answer is the column, and --raw is
served. A server that advertises it decorates the flag it answers, the v0
wire has no member asking it for the column, and the decorated flag cannot
be turned back into the column client-side, so --raw against such a server
is refused before the annotation read, naming the token, rather than
answered with the decorated flag. --raw without --flags is refused.
Tests: TestE2E_BlockedFlagsOverHTTP/raw_is_the_stored_column (served --raw
equals local --raw; the externally-blocked-only row reads true with --flags
and false with --raw on both; locally blocked rows agree; a stale-flagged
row reads true in both modes; --raw without --flags exits 1; a server
advertising the policy refuses --raw with no annotation request);
TestProxiedServerBlocked/flags_raw_is_the_stored_column; corpus
gc-blocked-flags-raw (pending until the reference server advertises
dependencies.blocking.isBlocked). Routing --raw through the decorated
annotator fails the e2e. CHANGELOG entry.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* docs(changelog): bd blocked --flags --raw is for the local and proxied routes
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* test(blocked): give the e2e gate-kid its own priority; document --flags answers closed ids
TestE2E_BlockedOverHTTP seeded gate-parent and gate-kid at one priority, so
when both landed in the same second their order fell to the generated ids,
which differ between the local and the served workspace: the comparison
failed intermittently. gate-kid now has its own priority. Ten runs on the
embedded lane pass.
bd blocked --flags answers a closed id too, with its stored flag; a SQL read
of the column filtered on status <> 'closed' leaves it out. Said in the
command's doc and the CHANGELOG.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* fix(blocked): apply label filters to external-only blocked rows
The external-dependency policy appends a row blocked only by an
unsatisfied external: ref after the label query has run, so --label,
--label-any and --exclude-label never judged it: bd blocked and
GET /v0/beads/blocked listed it whatever its labels, on every route.
Both decorators now filter those rows by the request's labels. The uow
decorator reads them through GetMany, chunked at MaxGetManyIDs, so their
labels are hydrated; GetIssuesByIDs left them empty, which also printed
them unlabelled on the proxied route.
Review fixes (adopt-pr apply-fixes, iteration 1):
- major #1: label filters on external-only rows in the store and uow
decorators, with absence-asserting arms in the unit, served httpclient
(server- and client-enforced policy), e2e and proxied tiers; the spec
and the role doc say such rows are narrowed like every other row.
- minor #2: the policy.external_dependencies token prose names the
blocked listing (spec, routes.go, regenerated types.gen.go).
- minor #6: SERVE_RUNBOOK and the allowUnlimited comment record the
blocked listing's unbounded whole-set answer and why.
- minor #10: BlockedLister telemetry-outermost and typed-unsupported pins
beside the ReadyCounter pair, plus the externaldeps wrap pin.
- nit #9: F-blocked names --flags --raw's refusal against a server that
applies the policy (ledger.go and the regenerated ledger doc).
- nit #11: the remote BlockedLister no longer builds a local lister it
then discards.
Review fixes (adopt-pr apply-fixes, iteration 2; the review approved at
940 with one minor and two nits, none gating):
- minor (the --flags refusal list was unpinned): the new
TestBlockedFlagsRefusesEveryListingFilter pins blockedFlagFilterFlags
to the flags blockedCmd registers, in both directions. Every
registered flag except --flags and --raw must be refused, and every
entry must name a registered flag. The test walks Flags() rather than
LocalFlags(), so it does not merge the root's persistent flags into
blockedCmd, and it skips inherited root flags and cobra's --help.
Mutants:
- four fail it: a new filter flag left off the list, a dropped
entry, a misspelled entry, and --raw added to the list;
- a simulated earlier in-process run (merged root flags plus --help)
stays green, and fails once either skip is removed.
- nit (the remote branch's span): the remote BlockedLister comment now
says why that lister is not wrapped again. The inner lister already
carries telemetry's span, so wrapping would nest a second span of the
same name. The comment also says what runs outside that span.
- nit (duplicated order comparator): left as is. finishBlockedIssues
predates this PR, so merging the two sorts would refactor existing
code with no review pass left after this one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Gas City Adopt-PR
---------
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Co-authored-by: Eddie the Engineer <338826946+gascity-eddie[bot]@users.noreply.github.com>
872 lines
32 KiB
Go
872 lines
32 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")
|
||
}
|
||
if store == nil {
|
||
return HandleErrorRespectJSON("no database connection")
|
||
}
|
||
resolve := func(ctx context.Context, arg string) (string, error) {
|
||
return utils.ResolvePartialID(ctx, store, arg)
|
||
}
|
||
return runMoleculeReady(rootCtx, store, resolve, 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, currentActor(), 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)
|
||
}
|
||
|
||
// blockedRequestFromFlags builds the blocked listing's request from
|
||
// blockedCmd's flags. Every route calls it, so the routes cannot drift as
|
||
// filtering flags are added.
|
||
//
|
||
// The labels go to the role as written: the role normalizes them, as every
|
||
// other label filter is normalized (list_input.go, search.go, orphans.go,
|
||
// workapi/ready.go). These clauses match a label EXACTLY, so an untrimmed
|
||
// value would silently under-report: pflag's CSV split leaves the leading
|
||
// space in the everyday `--label 'a, b'` form, and `--label 'a,,b'` would AND
|
||
// in an empty-label clause that matches nothing at all. Normalizing in the
|
||
// role rather than here is what makes a served listing normalize the same way
|
||
// for every client.
|
||
func blockedRequestFromFlags(cmd *cobra.Command) issueops.BlockedRequest {
|
||
parentID, _ := cmd.Flags().GetString("parent")
|
||
labels, _ := cmd.Flags().GetStringSlice("label")
|
||
labelsAny, _ := cmd.Flags().GetStringSlice("label-any")
|
||
excludeLabels, _ := cmd.Flags().GetStringSlice("exclude-label")
|
||
return issueops.BlockedRequest{
|
||
ParentID: parentID,
|
||
Labels: labels,
|
||
LabelsAny: labelsAny,
|
||
ExcludeLabels: excludeLabels,
|
||
}
|
||
}
|
||
|
||
// blockedLister is the blocked-listing role for the route this invocation
|
||
// runs: the store's own BlockedLister accessor on the direct routes (dolt,
|
||
// embedded dolt, and a registered HTTP backend, where it dials blocked.list
|
||
// and an older server is refused before the dial naming the token), and the
|
||
// proxied-server provider's on the proxied one.
|
||
func blockedLister() (issueops.BlockedLister, error) {
|
||
if usesProxiedServer() {
|
||
return proxiedBlockedLister()
|
||
}
|
||
if store == nil {
|
||
return nil, fmt.Errorf("no storage available")
|
||
}
|
||
return store.BlockedLister()
|
||
}
|
||
|
||
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)
|
||
}
|
||
}()
|
||
|
||
// One role on every route (blockedLister). Use global jsonOutput set
|
||
// by PersistentPreRun (respects config.yaml + env vars).
|
||
ctx := rootCtx
|
||
if flagsMode, _ := cmd.Flags().GetBool("flags"); flagsMode {
|
||
return runBlockedFlags(cmd, ctx, cmd.InOrStdin())
|
||
}
|
||
if cmd.Flags().Changed("raw") {
|
||
return HandleErrorRespectJSON("--raw qualifies --flags (the stored blocked column per id); it has no meaning for the listing")
|
||
}
|
||
lister, err := blockedLister()
|
||
if err != nil {
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
result, err := lister.ListBlocked(ctx, blockedRequestFromFlags(cmd))
|
||
if err != nil {
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
blocked := result.Items
|
||
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: the blockers
|
||
// of blocked issues, plus the blocking-dependency targets of the ready
|
||
// issues, whose status decides whether --explain reports each as
|
||
// resolved, pinned or open.
|
||
blockerIDList := explainBlockerIDs(blockedIssues, readyIssues, allDeps)
|
||
|
||
// 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)
|
||
printReadyItemDependencies(item)
|
||
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
|
||
}
|
||
|
||
// runMoleculeReady is `bd ready --mol` on every route. The molecule's nodes,
|
||
// their readiness, the ready list and parallel groups are the library's one
|
||
// derivation (issueops.ViewMolecule, shared with `mol current`); what is here
|
||
// is presentation.
|
||
func runMoleculeReady(ctx context.Context, s storage.DoltStorage, resolve func(context.Context, string) (string, error), molIDArg string) error {
|
||
moleculeID, err := resolve(ctx, molIDArg)
|
||
if err != nil {
|
||
return moleculeNotResolved(molIDArg, err)
|
||
}
|
||
roles, err := currentMoleculeRoles(s)
|
||
if err != nil {
|
||
return HandleErrorRespectJSON("%v", err)
|
||
}
|
||
view, err := issueops.ViewMolecule(ctx, roles.molecule, moleculeID)
|
||
if err != nil {
|
||
return HandleErrorRespectJSON("loading molecule: %v", err)
|
||
}
|
||
subgraph, analysis := view.Graph, view.Analysis
|
||
var readySteps []*MoleculeReadyStep
|
||
for _, issue := range view.Ready {
|
||
info := analysis.Steps[issue.ID]
|
||
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")
|
||
blockedCmd.Flags().Bool("raw", false, "With --flags: the stored blocked column itself, without the external-dependency policy (an unsatisfied external: blocker does not set it)")
|
||
blockedCmd.Flags().Bool("flags", false, "Print the blocked flag for each id read from stdin (one per line) instead of the listing; with --json, [{\"id\",\"is_blocked\"}]")
|
||
rootCmd.AddCommand(blockedCmd)
|
||
}
|
||
|
||
// explainBlockerIDs collects, once each, the ids whose status --explain
|
||
// needs: every blocker of a blocked issue, and the target of every blocking
|
||
// dependency (blocks, conditional-blocks, waits-for) of a ready issue. The
|
||
// ready targets matter because the ready query admits an issue whose blocking
|
||
// targets are closed OR pinned, and only the target's status tells the
|
||
// explanation which of the two it saw.
|
||
func explainBlockerIDs(blockedIssues []*types.BlockedIssue, readyIssues []*types.Issue, allDeps map[string][]*types.Dependency) []string {
|
||
seen := make(map[string]bool)
|
||
var ids []string
|
||
add := func(id string) {
|
||
if id == "" || seen[id] {
|
||
return
|
||
}
|
||
seen[id] = true
|
||
ids = append(ids, id)
|
||
}
|
||
for _, bi := range blockedIssues {
|
||
for _, blockerID := range bi.BlockedBy {
|
||
add(blockerID)
|
||
}
|
||
}
|
||
for _, issue := range readyIssues {
|
||
for _, dep := range allDeps[issue.ID] {
|
||
if dep.Type == types.DepBlocks || dep.Type == types.DepConditionalBlocks || dep.Type == types.DepWaitsFor {
|
||
add(dep.DependsOnID)
|
||
}
|
||
}
|
||
}
|
||
return ids
|
||
}
|
||
|
||
// printReadyItemDependencies prints the three dependency lines of a ready
|
||
// item in --explain's text form, each only when non-empty.
|
||
func printReadyItemDependencies(item types.ReadyItem) {
|
||
if len(item.ResolvedBlockers) > 0 {
|
||
fmt.Printf(" Resolved blockers: %s\n", strings.Join(item.ResolvedBlockers, ", "))
|
||
}
|
||
if len(item.PinnedDependencies) > 0 {
|
||
fmt.Printf(" Pinned dependencies (never block): %s\n", strings.Join(item.PinnedDependencies, ", "))
|
||
}
|
||
if len(item.OpenDependencies) > 0 {
|
||
fmt.Printf(" Open dependencies (not blocking): %s\n", strings.Join(item.OpenDependencies, ", "))
|
||
}
|
||
}
|