* perf(ready): skip the countReadyWork request when bd ready --json prints no total Over a remote backend, bd ready --json sent GET /v0/beads/ready and then, whenever the page came back with has_more, GET /v0/beads/ready:count, only to put "of N" into the stderr hint. Without BD_JSON_ENVELOPE nothing else prints the total, so that second request (about 120 ms at a 52 ms RTT) bought a number no caller reads. On a remote backend without the envelope, bd ready --json now lists one row past the limit and says whether more exist without saying how many, in the wording the proxied route already uses. A local store keeps the in-band total it takes in the page's own transaction, and the envelope keeps pagination.total. A --max-rows cap at or below the limit keeps the counted listing, so the extra row never trips the cap. Agent-Signature: claude-code-claude-opus-5-5-unknown-reasoning on behalf of gascity-agent Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * fix(ready): say "1 ready issue", not "1 ready issues", in the no-total hint Review follow-up. The hint the remote --json path shares with the proxied route now agrees in number; both routes take it from readyHiddenHint, so they stay one wording. Agent-Signature: claude-code-claude-opus-5-5-unknown-reasoning on behalf of gascity-agent Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
425 lines
14 KiB
Go
425 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/steveyegge/beads/internal/debug"
|
|
"github.com/steveyegge/beads/internal/storage/uow"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
"github.com/steveyegge/beads/internal/ui"
|
|
"github.com/steveyegge/beads/internal/workapi"
|
|
"github.com/steveyegge/beads/issueops"
|
|
)
|
|
|
|
func runReadyProxiedServer(cmd *cobra.Command, ctx context.Context) error {
|
|
// --offset is supported here and nowhere else, so this is where a negative
|
|
// value is rejected. It stays out of the shared gatherer because the direct
|
|
// route reaches that gatherer too, and `bd ready --offset -1` has always
|
|
// been a no-op there rather than an error. HandleError, not the RespectJSON
|
|
// variant, for the same reason: this message is the proxied route's alone,
|
|
// and it has always gone to stderr as plain text.
|
|
if offset, _ := cmd.Flags().GetInt("offset"); offset < 0 {
|
|
return HandleError("--offset must be >= 0")
|
|
}
|
|
|
|
// No cap resolver: --max-rows / BEADS_MAX_ROWS has already been resolved
|
|
// twice before this route runs — once at the proxied front door and once
|
|
// in the RunE that routed here — and any positive cap was refused by both,
|
|
// on --claim as much as on a bulk read. Resolving it a third time would
|
|
// repeat the malformed-value warning and stamp a cap this route cannot
|
|
// enforce.
|
|
in, err := gatherReadyInput(cmd, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if uowProvider == nil {
|
|
return HandleError("proxied-server UOW provider not initialized")
|
|
}
|
|
|
|
if in.claim {
|
|
return runReadyProxiedClaim(ctx, in)
|
|
}
|
|
|
|
// Wake expired dated defers before the read below. The unit of work this
|
|
// route opens is read-only-by-ending (Close rolls back), so the sweep runs
|
|
// in a committing UOW of its own first; the claim route above gets the
|
|
// same sweep from its role (uow.readyClaimer.ClaimNext).
|
|
uow.WakeExpiredDefersAdvisory(ctx, uowProvider)
|
|
|
|
// --mol reads through the provider's roles, each in a unit of work of its
|
|
// own, so it runs before this route opens the one it holds below.
|
|
if in.molID != "" {
|
|
return runMoleculeReady(ctx, nil, proxiedResolvePartialID, in.molID)
|
|
}
|
|
|
|
uw, err := uowProvider.NewUOW(ctx)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("open unit of work: %v", err)
|
|
}
|
|
defer uw.Close(ctx)
|
|
|
|
switch {
|
|
case in.gated:
|
|
return runReadyProxiedGated(ctx, uw, in)
|
|
case in.explain:
|
|
return runReadyProxiedExplain(ctx, uw, in)
|
|
default:
|
|
return runReadyProxiedList(ctx, uw, in)
|
|
}
|
|
}
|
|
|
|
// proxiedBlockedLister hands back the blocked-listing surface for the
|
|
// proxied-server provider, through the provider's OWN capability accessor:
|
|
// the accessor is where each layer (the external-dependency decoration among
|
|
// them) is added.
|
|
func proxiedBlockedLister() (issueops.BlockedLister, error) {
|
|
if uowProvider == nil {
|
|
return nil, errors.New("proxied-server UOW provider not initialized")
|
|
}
|
|
src, ok := uowProvider.(uow.BlockedListerSource)
|
|
if !ok {
|
|
return nil, fmt.Errorf("proxied-server provider %T does not offer the blocked-listing surface", uowProvider)
|
|
}
|
|
return src.BlockedLister()
|
|
}
|
|
|
|
func runReadyProxiedList(ctx context.Context, uw uow.UnitOfWork, in readyInput) error {
|
|
if in.jsonOut {
|
|
page, err := uw.IssueUseCase().GetReadyWorkWithCounts(ctx, in.filter)
|
|
if err != nil {
|
|
return HandleError("%v", err)
|
|
}
|
|
// The same epilogue issueops.Reader.Ready runs, through the same
|
|
// function: this seam reports a has-more natively and ready has no
|
|
// display order, so the trim is a no-op and the verdict is the seam's
|
|
// — but it is reached the one way, not restated here.
|
|
results, truncated := workapi.FinishPage(page.Items, "", false, in.filter.Limit, page.HasMore)
|
|
truncated = truncated && in.filter.Limit > 0
|
|
// Parity with the direct route: the pagination key is emitted only
|
|
// when truncated, and it now carries the same Total, from the same
|
|
// role. This route published no total at all until ReadyCounter
|
|
// existed, so a script that read `pagination.total` got one number
|
|
// under a direct-mode workspace and no key at all under a proxied one.
|
|
//
|
|
// The guard is the direct route's guard: the two queries are not one
|
|
// snapshot (issueops.ReadyCounter.CountReady), so a close landing
|
|
// between them must not publish a total smaller than the page beside
|
|
// it.
|
|
var pag *PaginationMeta
|
|
if truncated {
|
|
pag = &PaginationMeta{
|
|
Returned: len(results),
|
|
Truncated: true,
|
|
}
|
|
if n, countErr := proxiedReadyTotal(ctx, in); countErr == nil && n > len(results) {
|
|
pag.Total = n
|
|
}
|
|
}
|
|
_ = outputJSONWithPagination(results, pag)
|
|
if truncated {
|
|
fmt.Fprintf(os.Stderr, "%s Use --limit 0 for all, or --limit N to raise the cap.\n", readyHiddenHint(len(results)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
page, err := uw.IssueUseCase().GetReadyWork(ctx, in.filter)
|
|
if err != nil {
|
|
return HandleError("%v", err)
|
|
}
|
|
issues, truncated := workapi.FinishPage(page.Items, "", false, in.filter.Limit, page.HasMore)
|
|
truncated = truncated && in.filter.Limit > 0
|
|
|
|
maybeShowUpgradeNotification()
|
|
|
|
if len(issues) == 0 {
|
|
hasOpenIssues := false
|
|
if stats, statsErr := uw.IssueUseCase().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("✨"))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
parentEpicMap := buildParentEpicMapProxied(ctx, uw, 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(readyHiddenHint(len(issues))+" Use --limit 0 for all, or --limit N to raise the cap."))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// runReadyProxiedClaim is the proxied route of `bd ready --claim`, on the same
|
|
// ReadyClaimer role the direct route reaches through the store's accessor.
|
|
// Both build their request in claimNextRequest, so the two doors ask one
|
|
// question — and neither opens a unit of work of its own: the role's request
|
|
// IS the transaction, which is what lets the selection, the compare-and-set
|
|
// and the hydration this route prints share it.
|
|
func runReadyProxiedClaim(ctx context.Context, in readyInput) error {
|
|
CheckReadonly("ready --claim")
|
|
|
|
claimer, err := proxiedReadyClaimer()
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
res, err := claimer.ClaimNext(ctx, claimNextRequest(in))
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
|
|
if res.Claimed == nil {
|
|
if in.jsonOut {
|
|
_ = outputJSON([]*types.IssueWithCounts{})
|
|
} else {
|
|
fmt.Printf("\n%s No ready work to claim\n\n", ui.RenderWarn("○"))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
SetLastTouchedID(res.Claimed.ID)
|
|
|
|
if in.jsonOut {
|
|
_ = outputJSON([]*types.IssueWithCounts{res.Claimed})
|
|
} else {
|
|
fmt.Printf("%s Claimed issue: %s\n", ui.RenderPass("✓"), formatFeedbackID(res.Claimed.ID, res.Claimed.Title))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// proxiedReadyTotal sizes the whole ready set through the provider's own
|
|
// ReadyCounter accessor — the same role the direct route reaches through the
|
|
// store's accessor, over the request both build in readyRoleRequest.
|
|
//
|
|
// It opens NO unit of work of its own: the role's request IS the transaction,
|
|
// so the count runs in its own read-only unit of work rather than the one the
|
|
// page came from, which is why the two are not one snapshot.
|
|
func proxiedReadyTotal(ctx context.Context, in readyInput) (int, error) {
|
|
if uowProvider == nil {
|
|
return 0, errors.New("proxied-server UOW provider not initialized")
|
|
}
|
|
src, ok := uowProvider.(uow.ReadyCounterSource)
|
|
if !ok {
|
|
return 0, fmt.Errorf("proxied-server provider %T does not offer the ready-count surface", uowProvider)
|
|
}
|
|
counter, err := src.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
|
|
}
|
|
|
|
// proxiedReadyClaimer hands back the guarded claim surface for the
|
|
// proxied-server provider, through the provider's OWN capability accessor —
|
|
// the same two-step proxiedIssueReader performs, and for the same reason: the
|
|
// accessor is where a decorator adds its layer.
|
|
func proxiedReadyClaimer() (issueops.ReadyClaimer, error) {
|
|
if uowProvider == nil {
|
|
return nil, errors.New("proxied-server UOW provider not initialized")
|
|
}
|
|
src, ok := uowProvider.(uow.ReadyClaimerSource)
|
|
if !ok {
|
|
return nil, fmt.Errorf("proxied-server provider %T does not offer the ready-claim surface", uowProvider)
|
|
}
|
|
return src.ReadyClaimer()
|
|
}
|
|
|
|
func runReadyProxiedExplain(ctx context.Context, uw uow.UnitOfWork, _ readyInput) error {
|
|
filter, err := readyExplainFilter()
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
readyPage, err := uw.IssueUseCase().GetReadyWork(ctx, filter)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
readyIssues := readyPage.Items
|
|
|
|
blockedIssues, err := uw.IssueUseCase().GetBlockedIssues(ctx, types.WorkFilter{})
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
|
|
readyIDs := make([]string, len(readyIssues))
|
|
for i, issue := range readyIssues {
|
|
readyIDs[i] = issue.ID
|
|
}
|
|
depCountsMap, err := uw.DependencyUseCase().CountsByIssueIDs(ctx, readyIDs)
|
|
if err != nil {
|
|
debug.Logf("warning: failed to get dependency counts: %v", err)
|
|
}
|
|
depCounts := make(map[string]*types.DependencyCounts, len(depCountsMap))
|
|
for k, v := range depCountsMap {
|
|
depCounts[k] = v
|
|
}
|
|
allDeps, err := uw.DependencyUseCase().GetForIssueIDs(ctx, readyIDs)
|
|
if err != nil {
|
|
debug.Logf("warning: failed to get dependency records: %v", err)
|
|
}
|
|
|
|
cycles, err := uw.DependencyUseCase().DetectCycles(ctx)
|
|
if err != nil {
|
|
debug.Logf("warning: failed to detect cycles: %v", err)
|
|
}
|
|
|
|
blockerIDList := explainBlockerIDs(blockedIssues, readyIssues, allDeps)
|
|
// 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 GetMany.
|
|
blockerIssues, err := uw.IssueUseCase().GetIssuesByIDs(ctx, blockerIDList)
|
|
if err != nil {
|
|
debug.Logf("warning: failed to get blocker issues: %v", err)
|
|
}
|
|
blockerWisps, err := uw.IssueUseCase().GetWispsByIDs(ctx, blockerIDList)
|
|
if err != nil {
|
|
debug.Logf("warning: failed to get blocker wisps: %v", err)
|
|
}
|
|
blockerMap := make(map[string]*types.Issue, len(blockerIssues)+len(blockerWisps))
|
|
for _, issue := range blockerIssues {
|
|
blockerMap[issue.ID] = issue
|
|
}
|
|
for _, wisp := range blockerWisps {
|
|
blockerMap[wisp.ID] = wisp
|
|
}
|
|
|
|
explanation := types.BuildReadyExplanation(readyIssues, blockedIssues, depCounts, allDeps, blockerMap, cycles)
|
|
|
|
if jsonOutput {
|
|
_ = outputJSON(explanation)
|
|
return nil
|
|
}
|
|
|
|
fmt.Printf("\n%s Ready Work Explanation\n\n", ui.RenderAccent("📊"))
|
|
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("○"))
|
|
}
|
|
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()
|
|
}
|
|
}
|
|
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()
|
|
}
|
|
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 runReadyProxiedGated(ctx context.Context, uw uow.UnitOfWork, _ readyInput) error {
|
|
molecules, err := findGateReadyMolecules(ctx, uowMolReader{uw: uw})
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
return renderGatedReadyMolecules(molecules)
|
|
}
|
|
|
|
func buildParentEpicMapProxied(ctx context.Context, uw uow.UnitOfWork, issues []*types.Issue) map[string]string {
|
|
if len(issues) == 0 {
|
|
return nil
|
|
}
|
|
ids := make([]string, len(issues))
|
|
for i, issue := range issues {
|
|
ids[i] = issue.ID
|
|
}
|
|
allDeps, err := uw.DependencyUseCase().GetForIssueIDs(ctx, ids)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
parentIDs := make(map[string]bool)
|
|
childToParent := make(map[string]string)
|
|
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
|
|
}
|
|
epicTitles := make(map[string]string)
|
|
for parentID := range parentIDs {
|
|
parent, err := uw.IssueUseCase().GetIssue(ctx, parentID)
|
|
if err != nil || parent == nil {
|
|
continue
|
|
}
|
|
if parent.IssueType == "epic" {
|
|
epicTitles[parentID] = parent.Title
|
|
}
|
|
}
|
|
result := make(map[string]string)
|
|
for childID, parentID := range childToParent {
|
|
if title, ok := epicTitles[parentID]; ok {
|
|
result[childID] = title
|
|
}
|
|
}
|
|
return result
|
|
}
|