Ten agents over 216 files, one directory-balanced group each, working to a rubric that named what to cut (duplication narration, restatement of the next line, the governing rule echoed in every command file, throat-clearing) and what to keep (traps, invariants, security, tracker ids, behaviour changes, and the "why a naive simplification destroys this assertion" rationale). Net 1,523 lines. Density against this repo's own per-directory norm on main: cmd/bd 33.6% -> 27.3% (main 10.7%) internal/storage 26.1% -> 23.1% (main 14.1%) backend/conformance 34.0% -> 29.6% (main 22.8%) internal/httpapi 30.9% -> 27.8% (main 30.6%, now below) overall 34.7% -> 31.6% Every agent landed at 18-25% rather than the 30% asked for, and every one gave the same reason independently: what remained was on the keep list. Ten separate judgements agreeing is the most useful result here — the prose is dense, but it is mostly load-bearing, and the shortfall is the honest answer rather than a failure to try. TWO REVERTS, both to protect something worth more than the lines. issueops/ is back to its pre-trim state, giving up 610 lines. The conformance contracts cite the leaf docs BY LINE — "pins treewalker.go:52-66" — 155 times. Trimming the cited files silently repointed those at whatever text moved into those numbers, across agent boundaries so no agent could see it. A semantic remapper recovered 141 of them, but 23 needed judgement and several landed on struct fields. The leaf docs are the spec the contracts are written against; they are the one place in this change where dense prose IS the deliverable, and keeping them stable is worth more than the 610 lines. tree_walker_contract.go and version_reconciler_contract.go went back for the same reason: an agent had deleted a paragraph containing a citation, so positional restoration could not align them. After the reverts, exactly 5 citations point into a still-trimmed file and 2 of those are weak — both in cmd/bd/config_guard_test.go, which this series never touched and whose citations were already wrong on main (init.go:361 pointed at a closing brace; the guard it names is at init.go:1499). VERIFICATION. A guard strips every comment and all whitespace from each of the 193 modified files at HEAD and in the worktree and requires the two to be byte-identical, so a code change cannot hide in a comment diff. It handles `//` inside string and raw-string literals, and was tested against a deliberate code change before being trusted. gofmt clean, go build, go vet, golangci-lint 0 issues, and the two AST-based tests that PARSE trimmed files — the timed provider binding pin over claim.go and the serve database-source gate over serve.go — both pass. One real defect found while trimming: checkDatabaseSource's doc block ran into `// sourceRoles is ...` with no blank line, so godoc attached thirty-one lines of the wrong prose to func sourceRoles and left checkDatabaseSource undocumented. Fixed by separating them.
89 lines
3.3 KiB
Go
89 lines
3.3 KiB
Go
package issueops
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
|
|
"github.com/steveyegge/beads/internal/storage"
|
|
publicops "github.com/steveyegge/beads/issueops"
|
|
)
|
|
|
|
// ValidateBlockingRequest applies the one request rule every BlockingAnnotator
|
|
// implementation shares: an empty id entry is refused rather than answered
|
|
// with a nameless annotation. An empty ID SLICE asks about nothing and gets
|
|
// nothing back rather than being an error.
|
|
func ValidateBlockingRequest(request publicops.BlockingRequest) error {
|
|
for i, id := range request.IDs {
|
|
if id == "" {
|
|
return fmt.Errorf("%w: annotate blocking id %d is empty", storage.ErrValidation, i)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// FinishBlockingAnnotation assembles the per-id answer from the three maps every
|
|
// implementation produces.
|
|
//
|
|
// It is one function rather than two copies for the reason FinishEdgeRead is:
|
|
// the entry-per-id shape, the pinned order and the collapse of repeats are the
|
|
// whole observable contract of this role, and two implementations applying them
|
|
// separately will eventually disagree. Both bodies below it answer with maps
|
|
// whose slice values arrive in query order and can carry the same id twice —
|
|
// once from each dependency tier.
|
|
//
|
|
// The maps are read, never written: the store body's caller owns them.
|
|
func FinishBlockingAnnotation(
|
|
anchors []string,
|
|
blockedBy map[string][]string,
|
|
blocks map[string][]string,
|
|
parent map[string]string,
|
|
) publicops.BlockingResult {
|
|
out := publicops.BlockingResult{Items: make([]publicops.IssueBlocking, 0, len(anchors))}
|
|
for _, id := range anchors {
|
|
out.Items = append(out.Items, publicops.IssueBlocking{
|
|
ID: id,
|
|
BlockedBy: sortedDistinctIDs(blockedBy[id]),
|
|
Blocks: sortedDistinctIDs(blocks[id]),
|
|
Parent: parent[id],
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
// sortedDistinctIDs is the pinned order: ascending, repeats collapsed, never
|
|
// nil. It copies rather than sorting in place, because the slices it is handed
|
|
// belong to the maps a body just built and a caller may still read them.
|
|
func sortedDistinctIDs(ids []string) []string {
|
|
out := make([]string, 0, len(ids))
|
|
seen := make(map[string]struct{}, len(ids))
|
|
for _, id := range ids {
|
|
if _, dup := seen[id]; dup {
|
|
continue
|
|
}
|
|
seen[id] = struct{}{}
|
|
out = append(out, id)
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|
|
|
|
// ExecuteBlockingAnnotation returns each id's blocking decoration in tx. It is
|
|
// the store-backed body behind the BlockingAnnotator accessor; the unit-of-work
|
|
// provider has its own, which reaches the same three maps through its use case.
|
|
//
|
|
// The outbound read, the inbound read and the status lookups that decide which
|
|
// edges are live all run in ONE transaction, which is what lets the answer mean
|
|
// what it says: a blocker read as open by one statement and closed by the next
|
|
// would produce a row reported both blocked and blocking in a single response.
|
|
func ExecuteBlockingAnnotation(ctx context.Context, tx DBTX, request publicops.BlockingRequest) (publicops.BlockingResult, error) {
|
|
anchors := EdgeReadAnchors(request.IDs)
|
|
if len(anchors) == 0 {
|
|
return publicops.BlockingResult{Items: []publicops.IssueBlocking{}}, nil
|
|
}
|
|
blockedBy, blocks, parent, err := GetBlockingInfoForIssuesInTx(ctx, tx, anchors)
|
|
if err != nil {
|
|
return publicops.BlockingResult{}, err
|
|
}
|
|
return FinishBlockingAnnotation(anchors, blockedBy, blocks, parent), nil
|
|
}
|