Beads had two implementations of most issue verbs: one for the direct route
(the CLI talking to a store it opened itself) and one for the proxied-server
route (the CLI talking through a unit of work over a running Dolt server).
They drifted — different commit messages, different transaction boundaries,
different refusals, occasionally different answers.
Seven role interfaces now live in the leaf package issueops: Lifecycle,
Reader, ReadyClaimer, BatchCloser, DependencyEditor, Commenter and Relations.
Each is reached only through a store accessor, never a constructor, because
the accessor is where the hook and telemetry decorators add their layers.
Three implementations back every role — dolt, embeddeddolt, and the
unit-of-work provider the proxied route uses. Both routes call the same role
for close, dep add/remove/list, comment, ready --claim and update.
A depguard rule (httpapi-domain-boundary) denies internal/storage/domain from
internal/httpapi, so a handler cannot reach uw.IssueUseCase() past the roles
and open a second front door one lint-clean commit at a time.
Behaviour users will notice, all in the CHANGELOG:
- bd close a b c is one Dolt commit, not three, and --claim-next moved
inside that transaction so it fires only when something landed
- the open-children guard moved into the transaction and its hand-rolled
cmd/bd copy is gone, removing a read-then-write window that made
bd close <child> <parent> depend on argument order
- bd dep add --file honours deferred version commit
- embedded bd comment writes the role's message and author
- dep verb commit messages are the role's on the direct route
Wisp-sourced dependency edges are restored. Moving bd dep add onto the role
had pinned an edge's SOURCE to the issues plane, and the two routes did not
even fail alike: direct refused with "issue <id> not found", proxied threw an
fk_dep_issue violation. The comment justifying the pin claimed the issues
plane was "the only one its unit-of-work sibling can reach" — that was false;
domain.DependencyUseCase declared a full set of wisp twins with no production
caller. All three implementations now route per edge by the edge's own
source. A mixed request stays one transaction: parent-child-first ordering
and the whole-graph cycle gate span both planes, and a refusal rolls back
both. Behind the role, three bulk add verbs collapsed into one source-routed
AddDependencies, so no plane-pinned variant is left to reach for by mistake.
Six Provenance fields with no production caller were deleted rather than
wired — CloseRequest, CloseBatchRequest, ClaimNextRequest, AddCommentRequest,
AddDependenciesRequest, RemoveDependencyRequest. Each role already composes an
id-bearing message, so a caller could only restate the default and make it
unreachable from production. Two are not caller-settable even in principle:
CloseBatchCommitMessage names what LANDED and ClaimNextCommitMessage names the
id the claim WON. UpdateRequest and ReopenRequest keep theirs; commit messages
users see are unchanged.
Verified: build, vet and gofmt clean; golangci-lint 0 issues; protocol corpus
byte-identical under BEADS_PROTOCOL_REQUIRE_DOLT=1; all twelve
DependencyEditor conformance wirings green (four contract functions against
each implementation); TestEmbeddedDepAddWispSource runs bd dep add <wisp-id>
at the front door and was demonstrated RED against the pinned routing first.
Three internal/storage/dolt failures reproduce on pristine origin/main.
Known gaps are enumerated in the PR description rather than left to be found:
comment listing is on no role, bd dep tree and bd dep cycles have no role,
bd create and bd reopen are on Lifecycle only on the direct route, per-edge
line attribution is lost in bd dep add --file, multi-store bd close
--claim-next rides only the first store's batch, and the is_blocked staging gap
(bd-2y9ke, predates this change). Seven of the eight role interfaces now have a
shared conformance contract in backend/conformance, run at all three
implementations; main's Claimer, added in parallel by #5334, is the eighth and
has none yet.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
746 lines
27 KiB
Go
746 lines
27 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/spf13/cobra"
|
|
"github.com/steveyegge/beads/internal/audit"
|
|
"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/validation"
|
|
"github.com/steveyegge/beads/issueops"
|
|
)
|
|
|
|
var closeCmd = &cobra.Command{
|
|
Use: "close [id...]",
|
|
Aliases: []string{"done"},
|
|
GroupID: "issues",
|
|
Short: "Close one or more issues",
|
|
Long: `Close one or more issues.
|
|
|
|
If no issue ID is provided, closes the last touched issue (from most recent
|
|
create, update, show, or close operation).
|
|
|
|
When closing multiple issues, provide one --reason for all IDs or repeat
|
|
--reason once per ID. Reasons map positionally: the first --reason applies
|
|
to the first ID, the second --reason to the second ID, regardless of where
|
|
the flags appear in the command line.`,
|
|
Args: cobra.MinimumNArgs(0),
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
CheckReadonly("close")
|
|
|
|
evt := metrics.NewCommandEvent("close")
|
|
defer func() {
|
|
if c := metrics.Global(); c != nil {
|
|
c.CloseEventAndAdd(evt)
|
|
}
|
|
}()
|
|
|
|
if usesProxiedServer() {
|
|
return runCloseProxiedServer(cmd, rootCtx, args)
|
|
}
|
|
|
|
// If no IDs provided, use last touched issue
|
|
if len(args) == 0 {
|
|
lastTouched := GetLastTouchedID()
|
|
if lastTouched == "" {
|
|
return HandleErrorRespectJSON("no issue ID provided and no last touched issue")
|
|
}
|
|
args = []string{lastTouched}
|
|
}
|
|
reasons, updatedArgs, err := resolveCloseReasons(cmd, args)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
args = updatedArgs
|
|
|
|
if err := validateCloseReasons(reasons); err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
|
|
force, _ := cmd.Flags().GetBool("force")
|
|
continueFlag, _ := cmd.Flags().GetBool("continue")
|
|
noAuto, _ := cmd.Flags().GetBool("no-auto")
|
|
suggestNext, _ := cmd.Flags().GetBool("suggest-next")
|
|
|
|
claimNext, _ := cmd.Flags().GetBool("claim-next")
|
|
|
|
session, _ := cmd.Flags().GetString("session")
|
|
if session == "" {
|
|
session = os.Getenv("CLAUDE_SESSION_ID")
|
|
}
|
|
|
|
ctx := rootCtx
|
|
opsCtx, err := issueOpsContext(ctx)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
|
|
if continueFlag && len(args) > 1 {
|
|
return HandleErrorRespectJSON("--continue only works when closing a single issue")
|
|
}
|
|
|
|
if suggestNext && len(args) > 1 {
|
|
return HandleErrorRespectJSON("--suggest-next only works when closing a single issue")
|
|
}
|
|
|
|
results, cleanup, resolveErr := resolveCloseTargets(ctx, store, args)
|
|
defer cleanup()
|
|
if resolveErr != nil {
|
|
return HandleErrorRespectJSON("%v", resolveErr)
|
|
}
|
|
resolvedIDs := make([]string, 0, len(results))
|
|
for _, r := range results {
|
|
resolvedIDs = append(resolvedIDs, r.ResolvedID)
|
|
}
|
|
|
|
// Track which stores were mutated so routed closes can commit before
|
|
// cleanup closes the routed handle. Deduped by pointer.
|
|
mutatedStores := map[storage.DoltStorage][]string{}
|
|
|
|
// Pick a store for post-close work (--suggest-next, --continue, --claim-next).
|
|
// All three flags are documented as single-issue paths; for the multi-id case
|
|
// we use the first resolved ID's store, which matches the common case where
|
|
// every ID routes to the same place.
|
|
postCloseStore := store
|
|
if len(results) > 0 && results[0].Store != nil {
|
|
postCloseStore = results[0].Store
|
|
}
|
|
|
|
// THE BATCH. The CLI's own close policy runs first and read-only, then
|
|
// every id it passed goes to the BatchCloser role as one request per
|
|
// store: one transaction, one Dolt commit over N ids, and an id the
|
|
// batch refuses skipped while the survivors commit. --claim-next rides
|
|
// inside that transaction, and the engine's own is_blocked guard runs
|
|
// there too (GH#962), so there is no read-then-write TOCTOU window
|
|
// between the check and the close.
|
|
plan := closeDirectPreflight(results, resolvedIDs, reasons, force)
|
|
outcomes, claimedNext := closeDirectRun(opsCtx, closeDirectBatches(plan.items), len(resolvedIDs),
|
|
session, force, postCloseStore, closeClaimNextRequest(claimNext, continueFlag))
|
|
|
|
// Report and follow up on every argument, in the order it was typed.
|
|
closedIssues := []*types.Issue{}
|
|
closedCount := 0
|
|
alreadyClosed := 0
|
|
firstSettledID := ""
|
|
|
|
for i, id := range resolvedIDs {
|
|
res := outcomes[i]
|
|
if res == nil {
|
|
// The CLI's own close policy refused this argument, so the
|
|
// batch never saw it.
|
|
fmt.Fprintln(os.Stderr, plan.refusals[i])
|
|
continue
|
|
}
|
|
if res.Err != nil {
|
|
fmt.Fprintln(os.Stderr, closeDirectRefusal(id, res.Err))
|
|
continue
|
|
}
|
|
|
|
// Open children only survive to here when --force waived the
|
|
// engine's refusal. Say so, so orphaned children are never silent.
|
|
if res.OpenChildren > 0 {
|
|
fmt.Fprintf(os.Stderr, "warning: closing %s with %d open child issue(s) still active\n", id, res.OpenChildren)
|
|
}
|
|
|
|
activeStore := results[i].Store
|
|
reason := reasonForCloseIndex(reasons, i)
|
|
// Pre-close snapshot, for the audit entry's old status and the
|
|
// success line's title.
|
|
issue := results[i].Issue
|
|
|
|
if !res.Changed {
|
|
// Already closed: an idempotent no-op on the step's stored state. The
|
|
// old CloseIssue path also returned nil here and still reported the
|
|
// (already-closed) issue, so keep OUTPUT parity via the shared display
|
|
// block below — the issue stays in --json output and the text report
|
|
// exactly as before. Suppress the step's own real-state-change side
|
|
// effects (the audit entry, so no spurious closed→closed; the
|
|
// closedCount bump; step-level pending-commit tracking, since the step
|
|
// write itself is a no-op), but still count the command as a successful
|
|
// close for its retry-safe post-close contracts (last-touched,
|
|
// --continue, --suggest-next, --claim-next) via alreadyClosed below.
|
|
// Exit stays 0.
|
|
alreadyClosed++
|
|
|
|
// Molecule auto-close is itself a retry-safe, fully state-derived
|
|
// post-close contract, so it must replay on an already-closed re-close
|
|
// just like the contracts above. If the final step's real close
|
|
// persisted but its molecule auto-close did not (a crash between the two
|
|
// commits, or the root CloseIssue failing with only a warning), this
|
|
// idempotent re-close is the ONLY thing that re-drives it — otherwise the
|
|
// molecule root is stranded open forever. autoCloseCompletedMolecule
|
|
// early-returns unless the root is genuinely open, auto-close-eligible,
|
|
// and complete, so it heals only that case and reintroduces none of the
|
|
// suppressed real-close side effects (no audit, no closed→closed on the
|
|
// step). Register the store when it actually closed the root so the
|
|
// pending-commit sweep persists it — closedCount==0 would not commit.
|
|
if molID := autoCloseCompletedMolecule(ctx, activeStore, id, actor, session); molID != "" {
|
|
mutatedStores[activeStore] = append(mutatedStores[activeStore], molID)
|
|
}
|
|
} else {
|
|
mutatedStores[activeStore] = append(mutatedStores[activeStore], id)
|
|
|
|
// Audit log the close (survives Dolt GC flatten)
|
|
oldStatus := "open"
|
|
if issue != nil {
|
|
oldStatus = string(issue.Status)
|
|
}
|
|
audit.LogFieldChange(id, "status", oldStatus, "closed", actor, reason)
|
|
|
|
closedCount++
|
|
|
|
// Auto-close parent molecule if all steps are now complete.
|
|
// Runs against the same store the step was closed in.
|
|
autoCloseCompletedMolecule(ctx, activeStore, id, actor, session)
|
|
}
|
|
|
|
// First id this command settled as closed — a real close or an
|
|
// already-closed no-op both "touch" it. Drives the retry-safe last-touched
|
|
// contract below so a re-close still points default-target commands at it.
|
|
if firstSettledID == "" {
|
|
firstSettledID = id
|
|
}
|
|
|
|
// The operation's own post-state snapshot is what gets reported. A
|
|
// real close and an idempotent no-op both report the closed issue
|
|
// here, matching the historical output shape. Dependency records are
|
|
// dropped from it because `bd close` has never printed them: the
|
|
// re-read this replaced did not hydrate them either.
|
|
closedIssue := res.Issue
|
|
if closedIssue != nil {
|
|
closedIssue.Dependencies = nil
|
|
}
|
|
|
|
if jsonOutput {
|
|
if closedIssue != nil {
|
|
closedIssues = append(closedIssues, closedIssue)
|
|
}
|
|
} else {
|
|
debug.PrintNormal("%s Closed %s: %s\n", ui.RenderPass("✓"), formatFeedbackID(id, issueTitleOrEmpty(issue)), reason)
|
|
}
|
|
}
|
|
|
|
// A close command "succeeds" for its user-facing, retry-safe contracts when it
|
|
// settled the target as closed — whether it performed the real state change
|
|
// (closedCount) or confirmed an already-closed idempotent no-op
|
|
// (alreadyClosed). last-touched, --continue, --suggest-next, and --claim-next
|
|
// all re-derive their result from current state, so they must replay on an
|
|
// already-closed retry; `bd close --continue` in particular is a workflow-
|
|
// advancement trigger a crash/retry has to be able to re-drive. The real
|
|
// close-mutation side effects (audit, event, molecule auto-close) stay
|
|
// suppressed for an already-closed no-op via the `else` branch above; the
|
|
// pending-commit sweep is gated on mutatedStores, which a post-close claim
|
|
// also populates.
|
|
closedForCommand := closedCount > 0 || alreadyClosed > 0
|
|
|
|
// Record the closed issue as last-touched so `bd close` honors its own
|
|
// documented contract (the "last touched issue ... from create, update,
|
|
// show, or close" behavior) and downstream write-marker consumers see the
|
|
// close (GH#3965). Mirrors bd update's firstUpdatedID pattern. A later
|
|
// --claim-next overwrites this with the claimed issue (the newer touch).
|
|
if closedForCommand {
|
|
SetLastTouchedID(firstSettledID)
|
|
}
|
|
|
|
if suggestNext && len(resolvedIDs) == 1 && closedForCommand {
|
|
unblocked, err := postCloseStore.GetNewlyUnblockedByClose(ctx, resolvedIDs[0])
|
|
if err == nil && len(unblocked) > 0 {
|
|
if jsonOutput {
|
|
return outputJSON(map[string]interface{}{
|
|
"closed": closedIssues,
|
|
"unblocked": unblocked,
|
|
})
|
|
}
|
|
fmt.Printf("\nNewly unblocked:\n")
|
|
for _, issue := range unblocked {
|
|
fmt.Printf(" • %s (P%d)\n", formatFeedbackID(issue.ID, issue.Title), issue.Priority)
|
|
}
|
|
}
|
|
}
|
|
|
|
if continueFlag && len(resolvedIDs) == 1 && closedForCommand {
|
|
autoClaim := !noAuto
|
|
result, err := AdvanceToNextStep(ctx, newStandaloneStoreMolWriter(postCloseStore), resolvedIDs[0], autoClaim, actor)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Warning: could not advance to next step: %v\n", err)
|
|
} else if result != nil {
|
|
// Mirror --claim-next: when AdvanceToNextStep auto-claims the
|
|
// next step, update .beads/last-touched so subsequent default-
|
|
// target commands (e.g. bare `bd update`, `bd close`) target
|
|
// it. Without this, last-touched stays pointed at the just-
|
|
// closed step. See gastownhall/beads#3769.
|
|
if result.AutoAdvanced && result.NextStep != nil {
|
|
SetLastTouchedID(result.NextStep.ID)
|
|
// The auto-claim mutated postCloseStore's working set. Register it
|
|
// so the pending-commit sweep below persists the advance — parity
|
|
// with --claim-next, and required when the close itself was an
|
|
// already-closed no-op (closedCount==0 wouldn't otherwise commit).
|
|
// Same-pointer key dedupes with the closed store on a real close.
|
|
mutatedStores[postCloseStore] = append(mutatedStores[postCloseStore], result.NextStep.ID)
|
|
}
|
|
if jsonOutput {
|
|
return outputJSON(map[string]interface{}{
|
|
"closed": closedIssues,
|
|
"continue": result,
|
|
})
|
|
}
|
|
PrintContinueResult(result)
|
|
}
|
|
}
|
|
|
|
// Report --claim-next. The claim itself already happened, inside the
|
|
// batch's own transaction and only when something landed, so what is
|
|
// left here is the report and the last-touched hand-off. Register the
|
|
// claimed store anyway: the batch committed the claim, but the sweep
|
|
// below still has to name it if a molecule auto-close made the store
|
|
// dirty again.
|
|
var claimedNextIssue *types.Issue
|
|
if claimNext && closedForCommand && !continueFlag {
|
|
if claimedNext != nil {
|
|
claimedNextIssue = claimedNext.Issue
|
|
mutatedStores[postCloseStore] = append(mutatedStores[postCloseStore], claimedNextIssue.ID)
|
|
if !jsonOutput {
|
|
debug.PrintNormal("%s Auto-claimed next ready issue: %s (P%d)\n", ui.RenderPass("✓"), formatFeedbackID(claimedNextIssue.ID, claimedNextIssue.Title), claimedNextIssue.Priority)
|
|
}
|
|
SetLastTouchedID(claimedNextIssue.ID)
|
|
} else if !jsonOutput {
|
|
debug.PrintNormal("\n%s No ready issues available to claim.\n", ui.RenderWarn("✨"))
|
|
}
|
|
}
|
|
|
|
if jsonOutput && len(closedIssues) > 0 {
|
|
if claimedNextIssue != nil {
|
|
if err := outputJSON(map[string]interface{}{
|
|
"closed": closedIssues,
|
|
"claimed": claimedNextIssue,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if err := outputJSON(closedIssues); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
// Commit whenever a store was actually mutated — a real close, an auto-claimed
|
|
// --continue advance, or a --claim-next claim. Gating on mutatedStores rather
|
|
// than closedCount matters for an already-closed re-close that still advanced
|
|
// or claimed via a retry-safe post-close flag: the mutation lives in the
|
|
// working set and must be persisted, not left for a later write to sweep. For
|
|
// existing paths this is equivalent to closedCount>0 (only real closes and
|
|
// post-close claims populate mutatedStores). Commit is a no-op if there is
|
|
// genuinely nothing pending.
|
|
if len(mutatedStores) > 0 {
|
|
for s, ids := range mutatedStores {
|
|
if s == nil {
|
|
continue
|
|
}
|
|
if err := commitPendingIfEmbedded(ctx, s, actor, doltAutoCommitParams{
|
|
Command: "close",
|
|
IssueIDs: ids,
|
|
}); err != nil {
|
|
return HandleErrorRespectJSON("failed to commit: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
totalAttempted := len(resolvedIDs)
|
|
if totalAttempted > 0 && closedCount == 0 && alreadyClosed == 0 {
|
|
return SilentExit()
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
registerCloseReasonFlag(closeCmd)
|
|
closeCmd.Flags().String("resolution", "", "Alias for --reason (Jira CLI convention)")
|
|
_ = closeCmd.Flags().MarkHidden("resolution") // Hidden alias for agent/CLI ergonomics
|
|
closeCmd.Flags().StringP("message", "m", "", "Alias for --reason (git commit convention)")
|
|
_ = closeCmd.Flags().MarkHidden("message") // Hidden alias for agent/CLI ergonomics
|
|
closeCmd.Flags().String("comment", "", "Alias for --reason")
|
|
_ = closeCmd.Flags().MarkHidden("comment") // Hidden alias for agent/CLI ergonomics
|
|
closeCmd.Flags().String("reason-file", "", "Read close reason from file (use - for stdin)")
|
|
closeCmd.Flags().BoolP("force", "f", false, "Force close pinned issues or unsatisfied gates")
|
|
closeCmd.Flags().Bool("continue", false, "Auto-advance to next step in molecule")
|
|
closeCmd.Flags().Bool("no-auto", false, "With --continue, show next step but don't claim it")
|
|
closeCmd.Flags().Bool("suggest-next", false, "Show newly unblocked issues after closing")
|
|
closeCmd.Flags().Bool("claim-next", false, "Automatically claim the next highest priority available issue")
|
|
closeCmd.Flags().String("session", "", "Claude Code session ID (or set CLAUDE_SESSION_ID env var)")
|
|
closeCmd.ValidArgsFunction = issueIDCompletion
|
|
rootCmd.AddCommand(closeCmd)
|
|
}
|
|
|
|
type closeReasonFlagValue struct {
|
|
values []string
|
|
}
|
|
|
|
func registerCloseReasonFlag(cmd *cobra.Command) {
|
|
cmd.Flags().VarP(&closeReasonFlagValue{}, "reason", "r", "Reason for closing")
|
|
}
|
|
|
|
func (v *closeReasonFlagValue) Set(s string) error {
|
|
v.values = append(v.values, s)
|
|
return nil
|
|
}
|
|
|
|
func (v *closeReasonFlagValue) String() string {
|
|
if len(v.values) == 0 {
|
|
return ""
|
|
}
|
|
return v.values[len(v.values)-1]
|
|
}
|
|
|
|
func (v *closeReasonFlagValue) Type() string {
|
|
return "string"
|
|
}
|
|
|
|
func (v *closeReasonFlagValue) Values() []string {
|
|
out := make([]string, len(v.values))
|
|
copy(out, v.values)
|
|
return out
|
|
}
|
|
|
|
func resolveCloseReasons(cmd *cobra.Command, args []string) ([]string, []string, error) {
|
|
reasons, err := collectCloseReasonFlags(cmd)
|
|
if err != nil {
|
|
return nil, args, err
|
|
}
|
|
|
|
if fileReason, ok, err := resolveReasonFile(cmd, len(reasons) > 0); err != nil {
|
|
return nil, args, err
|
|
} else if ok {
|
|
reasons = []string{fileReason}
|
|
}
|
|
|
|
// Desire-path: "bd done <id> <message>" treats last positional arg as reason
|
|
// when no reason flag was explicitly provided (hq-pe8ce)
|
|
if len(reasons) == 0 && cmd.CalledAs() == "done" && len(args) >= 2 {
|
|
reasons = []string{args[len(args)-1]}
|
|
args = args[:len(args)-1]
|
|
}
|
|
|
|
if len(reasons) == 0 {
|
|
reasons = []string{"Closed"}
|
|
}
|
|
if len(reasons) > 1 && len(reasons) != len(args) {
|
|
return nil, args, fmt.Errorf("got %d close reasons for %d issue IDs; provide exactly one shared reason or one reason per issue", len(reasons), len(args))
|
|
}
|
|
return reasons, args, nil
|
|
}
|
|
|
|
func collectCloseReasonFlags(cmd *cobra.Command) ([]string, error) {
|
|
if flag := cmd.Flags().Lookup("reason"); flag != nil {
|
|
if v, ok := flag.Value.(interface{ Values() []string }); ok {
|
|
if reasons := nonEmptyCloseReasons(v.Values()); len(reasons) > 0 {
|
|
return reasons, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, name := range []string{"resolution", "message", "comment"} {
|
|
reason, err := cmd.Flags().GetString(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if reason != "" {
|
|
return []string{reason}, nil
|
|
}
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func nonEmptyCloseReasons(reasons []string) []string {
|
|
out := make([]string, 0, len(reasons))
|
|
for _, reason := range reasons {
|
|
if reason != "" {
|
|
out = append(out, reason)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func reasonForCloseIndex(reasons []string, i int) string {
|
|
if len(reasons) == 1 {
|
|
return reasons[0]
|
|
}
|
|
return reasons[i]
|
|
}
|
|
|
|
// closeClaimNextRequest is --claim-next as the batch expresses it. BOTH of
|
|
// `bd close`'s routes build it here, so the claim asks one question no matter
|
|
// which door it came through.
|
|
//
|
|
// The role runs it inside the closes' transaction and only when at least one
|
|
// item landed, which is the rule each route used to enforce by hand; --continue
|
|
// still wins, because the two flags have always been mutually exclusive here.
|
|
//
|
|
// It asks for priority order and no limit. The old two-step read the single top
|
|
// ready row and warned if that one row happened to be taken; the role's claim
|
|
// walks the ready order and takes the first row it can win, so a race with
|
|
// another agent now claims the next candidate instead of claiming nothing.
|
|
func closeClaimNextRequest(claimNext, continueOn bool) *issueops.ReadyRequest {
|
|
if !claimNext || continueOn {
|
|
return nil
|
|
}
|
|
return &issueops.ReadyRequest{Sort: string(types.SortPolicyPriority)}
|
|
}
|
|
|
|
func validateCloseReasons(reasons []string) error {
|
|
closeValidation := config.GetString("validation.on-close")
|
|
if closeValidation != "error" && closeValidation != "warn" {
|
|
return nil
|
|
}
|
|
|
|
for _, reason := range reasons {
|
|
if err := validation.ValidateCloseReason(reason); err != nil {
|
|
if closeValidation == "error" {
|
|
return err
|
|
}
|
|
// warn mode: print warning but proceed
|
|
fmt.Fprintf(os.Stderr, "%s %v\n", ui.RenderWarn("⚠"), err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// isMachineCheckableGate returns true if the issue is a gate with a machine-checkable await type.
|
|
func isMachineCheckableGate(issue *types.Issue) bool {
|
|
if issue == nil || issue.IssueType != "gate" {
|
|
return false
|
|
}
|
|
switch {
|
|
case strings.HasPrefix(issue.AwaitType, "gh:pr"):
|
|
return true
|
|
case strings.HasPrefix(issue.AwaitType, "gh:run"):
|
|
return true
|
|
case issue.AwaitType == "timer":
|
|
return true
|
|
case issue.AwaitType == "bead":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// checkGateSatisfaction checks whether a gate issue's condition is satisfied.
|
|
// Returns nil if the gate is satisfied (or not a machine-checkable gate), or an error describing why it cannot be closed.
|
|
func checkGateSatisfaction(issue *types.Issue) error {
|
|
if !isMachineCheckableGate(issue) {
|
|
return nil
|
|
}
|
|
|
|
var resolved bool
|
|
var escalated bool
|
|
var reason string
|
|
var err error
|
|
|
|
switch {
|
|
case strings.HasPrefix(issue.AwaitType, "gh:run"):
|
|
resolved, escalated, reason, err = checkGHRun(issue, func(gateID, runID string) error { return updateGateAwaitIDFunc(nil, gateID, runID) })
|
|
case strings.HasPrefix(issue.AwaitType, "gh:pr"):
|
|
resolved, escalated, reason, err = checkGHPR(issue)
|
|
case issue.AwaitType == "timer":
|
|
resolved, escalated, reason, err = checkTimer(issue, time.Now())
|
|
case issue.AwaitType == "bead":
|
|
resolved, reason = checkBeadGate(rootCtx, store, issue.AwaitID)
|
|
if resolved {
|
|
return nil
|
|
}
|
|
return fmt.Errorf("gate condition not satisfied: %s (use --force to override)", reason)
|
|
}
|
|
|
|
if err != nil {
|
|
// If we can't check the condition, allow close with a warning
|
|
fmt.Fprintf(os.Stderr, "Warning: could not evaluate gate condition: %v\n", err)
|
|
return nil
|
|
}
|
|
|
|
if resolved {
|
|
return nil
|
|
}
|
|
|
|
if escalated {
|
|
return fmt.Errorf("gate condition not satisfied: %s (use --force to override)", reason)
|
|
}
|
|
|
|
return fmt.Errorf("gate condition not satisfied: %s (use --force to override)", reason)
|
|
}
|
|
|
|
// autoCloseCompletedMolecule checks if closing a step completed an auto-closing
|
|
// parent molecule, and if so, closes the molecule root. Ordinary epics remain
|
|
// open when all children finish so they can become explicitly close-eligible
|
|
// instead of being closed as a side effect of the final child close. It returns
|
|
// the molecule root ID when it actually closed the root (and "" otherwise) so a
|
|
// caller that did not otherwise mutate the store — an already-closed re-close in
|
|
// particular — can register the store for the pending-commit sweep. The check is
|
|
// fully state-derived and idempotent: it early-returns unless the root is open,
|
|
// auto-close-eligible, and has all steps complete, so re-invoking it never
|
|
// double-closes or reintroduces side effects.
|
|
func autoCloseCompletedMolecule(ctx context.Context, s storage.DoltStorage, closedStepID, actorName, session string) string {
|
|
moleculeID := findParentMolecule(ctx, s, closedStepID)
|
|
if moleculeID == "" {
|
|
return "" // Not part of a molecule
|
|
}
|
|
|
|
// Check if molecule root is already closed
|
|
root, err := s.GetIssue(ctx, moleculeID)
|
|
if err != nil || root == nil || root.Status == types.StatusClosed || !shouldAutoCloseCompletedRoot(root) {
|
|
return ""
|
|
}
|
|
|
|
// Load progress to check completion
|
|
progress, err := getMoleculeProgress(ctx, s, moleculeID)
|
|
if err != nil {
|
|
return "" // Best effort — don't fail the close
|
|
}
|
|
|
|
if progress.Completed < progress.Total {
|
|
return "" // Not all steps complete yet
|
|
}
|
|
|
|
// All steps complete — auto-close the molecule root
|
|
if err := s.CloseIssue(ctx, moleculeID, "all steps complete", actorName, session); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Warning: could not auto-close completed molecule %s: %v\n", moleculeID, err)
|
|
return ""
|
|
}
|
|
|
|
if !jsonOutput {
|
|
debug.PrintNormal("%s Auto-closed completed molecule %s\n", ui.RenderPass("✓"), formatFeedbackID(moleculeID, root.Title))
|
|
}
|
|
return moleculeID
|
|
}
|
|
|
|
// shouldAutoCloseCompletedRoot returns true for molecule roots that should
|
|
// auto-close when their final step closes. Regular epics stay open and become
|
|
// explicit close-eligible work, while ephemeral wisps, template-driven
|
|
// molecules, and molecule-type coordination roots keep their cleanup behavior.
|
|
func shouldAutoCloseCompletedRoot(root *types.Issue) bool {
|
|
if root == nil {
|
|
return false
|
|
}
|
|
|
|
if root.IssueType == types.TypeMolecule || root.Ephemeral {
|
|
return true
|
|
}
|
|
|
|
if root.IssueType != types.TypeEpic {
|
|
return false
|
|
}
|
|
|
|
for _, label := range root.Labels {
|
|
if label == BeadsTemplateLabel {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// resolveReasonFile resolves the --reason-file flag for `bd close`.
|
|
// Returns (content, true, nil) when --reason-file was set and read successfully.
|
|
// Returns (_, false, nil) when --reason-file was not set.
|
|
// Returns an error on conflict with an existing reason, file read failure, or empty content.
|
|
// Mirrors the --body-file pattern from `bd create` so agents can pass structured close
|
|
// templates without shell-escaping hell.
|
|
func resolveReasonFile(cmd *cobra.Command, hasExistingReason bool) (string, bool, error) {
|
|
if !cmd.Flags().Changed("reason-file") {
|
|
return "", false, nil
|
|
}
|
|
if hasExistingReason {
|
|
return "", false, fmt.Errorf("cannot specify both --reason-file and --reason/--resolution/--message/--comment")
|
|
}
|
|
path, _ := cmd.Flags().GetString("reason-file")
|
|
content, err := readBodyFile(path)
|
|
if err != nil {
|
|
return "", false, fmt.Errorf("reading reason file %q: %w", path, err)
|
|
}
|
|
if strings.TrimSpace(content) == "" {
|
|
return "", false, fmt.Errorf("--reason-file %q is empty; close reason is required", path)
|
|
}
|
|
return content, true, nil
|
|
}
|
|
|
|
// resolveCloseTargets resolves a batch of partial issue IDs for `bd close`,
|
|
// preserving input order. For each ID it tries the local store first, then
|
|
// explicit prefix routing via routes.jsonl, then a shared contributor-routed
|
|
// store. This matches resolveAndGetIssueWithRouting's routing precedence.
|
|
//
|
|
// The contributor-routed handle is shared across the batch so bulk close does
|
|
// not repeatedly open the same planning store and every result has a clear store
|
|
// owner for subsequent close-time checks and writes.
|
|
//
|
|
// Each returned RoutedResult.Store points to whichever store actually owns the
|
|
// issue. The caller invokes cleanup() once when done; per-result Close() is a
|
|
// no-op for routed-via-shared-handle entries because they don't own the handle.
|
|
func resolveCloseTargets(ctx context.Context, localStore storage.DoltStorage, ids []string) ([]*RoutedResult, func(), error) {
|
|
results := make([]*RoutedResult, 0, len(ids))
|
|
var sharedRouted storage.DoltStorage
|
|
var sharedRoutedTried bool
|
|
cleanup := func() {
|
|
for _, r := range results {
|
|
r.Close()
|
|
}
|
|
if sharedRouted != nil {
|
|
_ = sharedRouted.Close()
|
|
}
|
|
}
|
|
ensureShared := func() (storage.DoltStorage, error) {
|
|
if sharedRouted != nil {
|
|
return sharedRouted, nil
|
|
}
|
|
if sharedRoutedTried {
|
|
return nil, fmt.Errorf("no auto-routed store available")
|
|
}
|
|
sharedRoutedTried = true
|
|
rs, routed, _, err := openRoutedReadStore(ctx, localStore)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !routed {
|
|
return nil, fmt.Errorf("no auto-routed store available")
|
|
}
|
|
sharedRouted = rs
|
|
return rs, nil
|
|
}
|
|
for _, id := range ids {
|
|
// Local first.
|
|
if r, err := resolveAndGetFromStore(ctx, localStore, id, false); err == nil {
|
|
results = append(results, r)
|
|
continue
|
|
} else if !isNotFoundErr(err) {
|
|
cleanup()
|
|
return nil, func() {}, fmt.Errorf("resolving ID %s: %w", id, err)
|
|
}
|
|
// Write-intent: a prefix-routed target opens writable so the close
|
|
// commits on the target head (#4141). Contributor auto-routing below
|
|
// stays read-only: it hydrates foreign projects that must not be mutated.
|
|
if r, err := resolveViaPrefixRoutingWithAccess(ctx, id, true); err == nil {
|
|
results = append(results, r)
|
|
continue
|
|
}
|
|
// Contributor auto-routing uses one shared store for the whole batch.
|
|
if rs, rerr := ensureShared(); rerr == nil {
|
|
if r, err := resolveAndGetFromStore(ctx, rs, id, true); err == nil {
|
|
// Per-id RoutedResult does not own the shared handle; cleanup() does.
|
|
results = append(results, r)
|
|
continue
|
|
}
|
|
}
|
|
cleanup()
|
|
return nil, func() {}, fmt.Errorf("resolving ID %s: no issue found matching %q", id, id)
|
|
}
|
|
return results, cleanup, nil
|
|
}
|