refactor(lint): reduce cyclomatic/cognitive complexity in tools, workflow, webui

Extracts focused helpers out of applyEdits, grepFallback/grepDirFallback,
serveReadContent, handleChatStream, TDD, runFindGoFallback,
makeGrepExecutor and makeShellExecutor to bring them under the
project's cyclop/gocognit/funlen thresholds. Behavior-preserving.

Partial pass on archie-core-agui: richblocks.go (gocognit),
gateway.go dispatchLocal (gocyclo), and a couple of remaining
gocognit/nestif findings are left for a follow-up.
This commit is contained in:
sam committed 2026-08-31 21:26:22 +10:00
1 parent b236e8a256
commit fdb8d2269f
7 files changed
+527 -392

No files matched your search

+119 -107
View File
@@ -23,126 +23,138 @@ func TDD() Workflow {
StagePrepareWorktree(),
StageRepoStages(),
StageBaselineGate(),
AgentStage{
Name: "analyse",
Role: "planner",
ReadOnly: true,
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Analyse this %s for the repository %s and determine the problem surface.\n\n"+
"%s\n\n"+
"Explore the code read-only and call finish with status \"passed\" and a summary "+
"containing: the root cause (file and function), the exact conditions that trigger it, "+
"the expected vs actual behaviour, and which test cases would prove the bug. "+
"Call finish with status \"blocked\" if you cannot locate a plausible cause.",
taskKind(tc.Task), tc.Repo.FullName(), taskPromptBlock(tc.Task),
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
tc.Task.Plan = res.Summary
return nil
},
}.Stage(),
AgentStage{
Name: "repro-tests",
Role: "builder",
// The inverted gate: code-quality commands must still
// pass, but the test command (last in repo.Gate) MUST
// fail -- proof the repro captures the bug.
Gate: func(tc *TaskContext) agentexec.Gate {
return tddReproGate(tc.Repo, tc.Cfg.Budgets)
},
Mission: func(tc *TaskContext) string {
cmd := testCommand(tc.Repo)
return fmt.Sprintf(
"Write tests that REPRODUCE this bug in the repository %s. Do NOT fix the bug yet.\n\n"+
"%s\n\n<analysis>\n%s\n</analysis>\n\n"+
"Add tests that pass once the bug is fixed but FAIL today because of it. The gate is "+
"inverted for this stage: it requires the full gate to pass EXCEPT %s which is required "+
"to FAIL. Do not touch non-test files. Call finish with status \"passed\" once the failing "+
"repro is in place, summarising which tests capture the bug.",
tc.Repo.FullName(), taskPromptBlock(tc.Task), tc.Task.Plan, cmd,
)
},
}.Stage(),
// Capture the failing test run -- the proof the repro
// reproduces the bug, posted on the PR later.
{Name: "capture-proof", Run: func(ctx context.Context, tc *TaskContext) error {
argv := testCommandArgv(tc.Repo)
if len(argv) == 0 {
return fmt.Errorf("tdd: repo %s has no gate configured -- cannot capture repro proof (add at least one [[repos.gate]] command, with the test runner last)", tc.Repo.FullName())
}
cmd := exec.CommandContext(ctx, argv[0], argv[1:]...)
cmd.Dir = tc.Dir
out, err := cmd.CombinedOutput()
if err == nil {
return fmt.Errorf("repro tests unexpectedly pass after commit -- the bug is not captured")
}
tc.ReproProof = clip(string(out), 4000)
return nil
}},
tddAnalyseStage(),
tddReproTestsStage(),
tddCaptureProofStage(),
StageCommit("commit-repro", func(tc *TaskContext) string {
return "test: failing repro" + commitIssueReference("Refs", tc.Task)
}),
AgentStage{
Name: "fix",
Role: "builder",
Gate: func(tc *TaskContext) agentexec.Gate {
return GateFromRepo(tc.Repo, tc.Cfg.Budgets)
},
// Environmental, not advisory: the fix stage cannot touch
// test files at all -- the committed repro is the spec.
ProtectGlobs: func(tc *TaskContext) []string {
glob := tc.Repo.ResolvedTestGlob()
if glob == "" {
return nil
}
return []string{glob}
},
ExtraRules: "The repro tests written in the previous stage are the bug's specification. " +
"Test files are write-protected in this stage -- make them pass by fixing the code they exercise.",
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Fix the bug in the repository %s. Failing repro tests are already committed; make them pass.\n\n"+
"%s\n\n<analysis>\n%s\n</analysis>\n\n"+
"The full quality gate (including 'go test ./...') must pass. Make the smallest fix "+
"that makes the repro tests pass without changing them. Call finish with status "+
"\"passed\" and a summary for the PR reviewer: root cause, the fix, and verification.",
tc.Repo.FullName(), taskPromptBlock(tc.Task), tc.Task.Plan,
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
tc.BuildSummary = res.Summary
return nil
},
}.Stage(),
tddFixStage(),
StageCommitPush(func(tc *TaskContext) string {
return fmt.Sprintf("fix: %s (archie)", tc.Task.Title) +
commitIssueReference("Fixes", tc.Task)
}),
StageYaegiGate(),
StageDiffCap(),
// Open the PR, then post the captured failing-test output as
// evidence the bug was reproduced before the fix.
{Name: "open-pr", Run: func(ctx context.Context, tc *TaskContext) error {
body := fmt.Sprintf("%s\n\n---\n*workflow: tdd (failing repro committed first) · %d iterations · %d tokens*",
tc.BuildSummary, tc.Task.Iterations, tc.Task.TokensUsed)
if err := OpenPR(ctx, tc, body); err != nil {
return err
}
return nil
}},
tddOpenPRStage(),
},
}
}
// tddAnalyseStage explores the bug read-only and records the root cause and
// reproduction plan on tc.Task.Plan.
func tddAnalyseStage() Stage {
return AgentStage{
Name: "analyse",
Role: "planner",
ReadOnly: true,
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Analyse this %s for the repository %s and determine the problem surface.\n\n"+
"%s\n\n"+
"Explore the code read-only and call finish with status \"passed\" and a summary "+
"containing: the root cause (file and function), the exact conditions that trigger it, "+
"the expected vs actual behaviour, and which test cases would prove the bug. "+
"Call finish with status \"blocked\" if you cannot locate a plausible cause.",
taskKind(tc.Task), tc.Repo.FullName(), taskPromptBlock(tc.Task),
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
tc.Task.Plan = res.Summary
return nil
},
}.Stage()
}
// tddReproTestsStage writes tests that reproduce the bug, under the
// inverted gate: code-quality commands must still pass, but the test
// command (last in repo.Gate) MUST fail -- proof the repro captures the bug.
func tddReproTestsStage() Stage {
return AgentStage{
Name: "repro-tests",
Role: "builder",
Gate: func(tc *TaskContext) agentexec.Gate {
return tddReproGate(tc.Repo, tc.Cfg.Budgets)
},
Mission: func(tc *TaskContext) string {
cmd := testCommand(tc.Repo)
return fmt.Sprintf(
"Write tests that REPRODUCE this bug in the repository %s. Do NOT fix the bug yet.\n\n"+
"%s\n\n<analysis>\n%s\n</analysis>\n\n"+
"Add tests that pass once the bug is fixed but FAIL today because of it. The gate is "+
"inverted for this stage: it requires the full gate to pass EXCEPT %s which is required "+
"to FAIL. Do not touch non-test files. Call finish with status \"passed\" once the failing "+
"repro is in place, summarising which tests capture the bug.",
tc.Repo.FullName(), taskPromptBlock(tc.Task), tc.Task.Plan, cmd,
)
},
}.Stage()
}
// tddCaptureProofStage captures the failing test run -- the proof the repro
// reproduces the bug, posted on the PR later.
func tddCaptureProofStage() Stage {
return Stage{Name: "capture-proof", Run: func(ctx context.Context, tc *TaskContext) error {
argv := testCommandArgv(tc.Repo)
if len(argv) == 0 {
return fmt.Errorf("tdd: repo %s has no gate configured -- cannot capture repro proof (add at least one [[repos.gate]] command, with the test runner last)", tc.Repo.FullName())
}
cmd := exec.CommandContext(ctx, argv[0], argv[1:]...)
cmd.Dir = tc.Dir
out, err := cmd.CombinedOutput()
if err == nil {
return fmt.Errorf("repro tests unexpectedly pass after commit -- the bug is not captured")
}
tc.ReproProof = clip(string(out), 4000)
return nil
}}
}
// tddFixStage fixes the bug. Test files are write-protected: the committed
// repro is the spec, and the fix stage cannot touch it.
func tddFixStage() Stage {
return AgentStage{
Name: "fix",
Role: "builder",
Gate: func(tc *TaskContext) agentexec.Gate {
return GateFromRepo(tc.Repo, tc.Cfg.Budgets)
},
ProtectGlobs: func(tc *TaskContext) []string {
glob := tc.Repo.ResolvedTestGlob()
if glob == "" {
return nil
}
return []string{glob}
},
ExtraRules: "The repro tests written in the previous stage are the bug's specification. " +
"Test files are write-protected in this stage -- make them pass by fixing the code they exercise.",
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Fix the bug in the repository %s. Failing repro tests are already committed; make them pass.\n\n"+
"%s\n\n<analysis>\n%s\n</analysis>\n\n"+
"The full quality gate (including 'go test ./...') must pass. Make the smallest fix "+
"that makes the repro tests pass without changing them. Call finish with status "+
"\"passed\" and a summary for the PR reviewer: root cause, the fix, and verification.",
tc.Repo.FullName(), taskPromptBlock(tc.Task), tc.Task.Plan,
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
tc.BuildSummary = res.Summary
return nil
},
}.Stage()
}
// tddOpenPRStage opens the PR, then posts the captured failing-test output
// as evidence the bug was reproduced before the fix.
func tddOpenPRStage() Stage {
return Stage{Name: "open-pr", Run: func(ctx context.Context, tc *TaskContext) error {
body := fmt.Sprintf("%s\n\n---\n*workflow: tdd (failing repro committed first) · %d iterations · %d tokens*",
tc.BuildSummary, tc.Task.Iterations, tc.Task.TokensUsed)
return OpenPR(ctx, tc, body)
}}
}
// tddReproGate builds the inverted gate for the repro-tests stage:
// every command from repo.Gate runs normally except the last one (the
// test runner, by convention), which gets ExpectFailure -- the repro
+60 -32
View File
@@ -234,50 +234,78 @@ func applyEdits(content string, edits []EditAction) (string, error) {
return "", fmt.Errorf("edit %d: old_text and new_text are identical", i+1)
}
matches := indexAll(content, edit.OldText)
if edit.ReplaceAll {
if len(matches) == 0 {
matches = fuzzyIndexAll(content, edit.OldText)
}
if len(matches) == 0 {
return "", editNotFoundError(i, content, edit.OldText)
}
for _, m := range matches {
spans = append(spans, editSpan{start: m[0], end: m[1], repl: edit.NewText, editIdx: i})
}
continue
}
switch len(matches) {
case 1:
spans = append(spans, editSpan{start: matches[0][0], end: matches[0][1], repl: edit.NewText, editIdx: i})
case 0:
fuzzy := fuzzyIndexAll(content, edit.OldText)
switch len(fuzzy) {
case 1:
spans = append(spans, editSpan{start: fuzzy[0][0], end: fuzzy[0][1], repl: edit.NewText, editIdx: i})
case 0:
return "", editNotFoundError(i, content, edit.OldText)
default:
return "", editAmbiguousError(i, len(fuzzy))
}
default:
return "", editAmbiguousError(i, len(matches))
editSpans, err := resolveEditSpans(content, edit, i)
if err != nil {
return "", err
}
spans = append(spans, editSpans...)
}
if err := checkSpansOverlap(spans); err != nil {
return "", err
}
return renderSpans(content, spans), nil
}
// resolveEditSpans resolves one edit against the original content into the
// span(s) it applies. Matching is exact first; if old_text is not found, a
// fuzzy pass retries the match with trailing whitespace stripped from every
// line of both the content and old_text, which recovers the most common
// exact-match failure.
func resolveEditSpans(content string, edit EditAction, i int) ([]editSpan, error) {
matches := indexAll(content, edit.OldText)
if edit.ReplaceAll {
if len(matches) == 0 {
matches = fuzzyIndexAll(content, edit.OldText)
}
if len(matches) == 0 {
return nil, editNotFoundError(i, content, edit.OldText)
}
spans := make([]editSpan, 0, len(matches))
for _, m := range matches {
spans = append(spans, editSpan{start: m[0], end: m[1], repl: edit.NewText, editIdx: i})
}
return spans, nil
}
switch len(matches) {
case 1:
return []editSpan{{start: matches[0][0], end: matches[0][1], repl: edit.NewText, editIdx: i}}, nil
case 0:
fuzzy := fuzzyIndexAll(content, edit.OldText)
switch len(fuzzy) {
case 1:
return []editSpan{{start: fuzzy[0][0], end: fuzzy[0][1], repl: edit.NewText, editIdx: i}}, nil
case 0:
return nil, editNotFoundError(i, content, edit.OldText)
default:
return nil, editAmbiguousError(i, len(fuzzy))
}
default:
return nil, editAmbiguousError(i, len(matches))
}
}
// checkSpansOverlap sorts spans by start offset and rejects any that overlap.
func checkSpansOverlap(spans []editSpan) error {
sort.Slice(spans, func(a, b int) bool { return spans[a].start < spans[b].start })
for i := 1; i < len(spans); i++ {
if spans[i].start < spans[i-1].end {
return "", fmt.Errorf(
return fmt.Errorf(
"edits %d and %d overlap in the file; merge them into a single edit",
spans[i-1].editIdx+1, spans[i].editIdx+1,
)
}
}
return nil
}
// renderSpans applies non-overlapping spans (already sorted by start) to
// content in one pass.
func renderSpans(content string, spans []editSpan) string {
var b strings.Builder
cursor := 0
for _, s := range spans {
@@ -286,7 +314,7 @@ func applyEdits(content string, edits []EditAction) (string, error) {
cursor = s.end
}
b.WriteString(content[cursor:])
return b.String(), nil
return b.String()
}
func editNotFoundError(idx int, content, oldText string) error {
+51 -33
View File
@@ -6,6 +6,8 @@
// internal/tools package holding the registry these are registered into).
// - discovery is confined to the active workspace. Module-cache and other
// absolute paths are rejected so find cannot list home or pkg/mod trees.
// - runFindGoFallback split into compileFindFilter and findWalkVisitor to
// satisfy golangci-lint's gocognit limit. No behavioural change.
//
// Refresh by diffing against that path at a newer tau commit. Do not
// edit without recording the change above.
@@ -16,6 +18,7 @@ import (
"context"
"encoding/json"
"fmt"
"io/fs"
"os"
"os/exec"
"path/filepath"
@@ -146,27 +149,57 @@ func runFindGoFallback(ctx context.Context, cwd, searchPath string, p FindParams
var matches []string
var patternRe *regexp.Regexp
if p.Pattern != "" {
reStr := globToRegex(p.Pattern)
var err error
patternRe, err = regexp.Compile("^(?:" + reStr + ")$")
if err != nil {
return Result{Content: fmt.Sprintf("invalid pattern: %v", err), IsError: true}, nil
}
patternRe, err := compileFindFilter(p.Pattern, true)
if err != nil {
return Result{Content: fmt.Sprintf("invalid pattern: %v", err), IsError: true}, nil
}
excludeRe, err := compileFindFilter(p.Exclude, false)
if err != nil {
return Result{Content: fmt.Sprintf("invalid exclude: %v", err), IsError: true}, nil
}
var excludeRe *regexp.Regexp
if p.Exclude != "" {
reStr := globToRegex(p.Exclude)
var err error
excludeRe, err = regexp.Compile("(?:" + reStr + ")")
if err != nil {
return Result{Content: fmt.Sprintf("invalid exclude: %v", err), IsError: true}, nil
}
visit := findWalkVisitor(ctx, cwd, searchPath, p, patternRe, excludeRe, &matches)
err = filepath.WalkDir(searchPath, visit)
if err != nil {
return Result{Content: fmt.Sprintf("find error: %v", err), IsError: true}, nil
}
if ctxErr := ctx.Err(); ctxErr != nil {
return Result{Content: fmt.Sprintf("find error: search did not complete: %v", ctxErr), IsError: true}, nil
}
err = filepath.WalkDir(searchPath, func(walkPath string, d os.DirEntry, err error) error {
if len(matches) == 0 {
return Result{Content: "no matches found"}, nil
}
sort.Strings(matches)
output := strings.Join(matches, "\n")
tr := TruncateHead(output, DefaultMaxLines, DefaultMaxBytes)
return Result{Content: tr.Content, Truncated: tr.Truncated, ResultBytes: tr.OriginalSize}, nil
}
// compileFindFilter compiles a glob filter into a regexp. anchored wraps the
// translated pattern in ^(?:...)$ (whole-name match, used for the include
// pattern); unanchored leaves it as (?:...) (substring match, used for
// exclude). Returns a nil regexp and nil error for an empty glob.
func compileFindFilter(glob string, anchored bool) (*regexp.Regexp, error) {
if glob == "" {
return nil, nil
}
reStr := globToRegex(glob)
if anchored {
return regexp.Compile("^(?:" + reStr + ")$")
}
return regexp.Compile("(?:" + reStr + ")")
}
// findWalkVisitor returns the filepath.WalkDir callback for
// runFindGoFallback: it enforces max depth, skips hidden entries and
// exclude matches, applies the type and pattern filters, and appends
// surviving paths (relative to cwd) to matches.
func findWalkVisitor(
ctx context.Context, cwd, searchPath string, p FindParams, patternRe, excludeRe *regexp.Regexp, matches *[]string,
) fs.WalkDirFunc {
return func(walkPath string, d os.DirEntry, err error) error {
if err != nil {
return nil //nolint:nilerr // intentionally skip inaccessible entries
}
@@ -236,24 +269,9 @@ func runFindGoFallback(ctx context.Context, cwd, searchPath string, p FindParams
if err != nil {
outputPath = walkPath
}
matches = append(matches, filepath.ToSlash(outputPath))
*matches = append(*matches, filepath.ToSlash(outputPath))
return nil
})
if err != nil {
return Result{Content: fmt.Sprintf("find error: %v", err), IsError: true}, nil
}
if ctxErr := ctx.Err(); ctxErr != nil {
return Result{Content: fmt.Sprintf("find error: search did not complete: %v", ctxErr), IsError: true}, nil
}
if len(matches) == 0 {
return Result{Content: "no matches found"}, nil
}
sort.Strings(matches)
output := strings.Join(matches, "\n")
tr := TruncateHead(output, DefaultMaxLines, DefaultMaxBytes)
return Result{Content: tr.Content, Truncated: tr.Truncated, ResultBytes: tr.OriginalSize}, nil
}
func isFdBinary(binary string) bool {
+134 -97
View File
@@ -10,6 +10,10 @@
// and the existing pure-Go grepFallback covers its absence.
// - discovery is confined to the active workspace. Module-cache and other
// absolute paths are rejected so grep cannot search home or pkg/mod trees.
// - makeGrepExecutor, grepFallback, and grepDirFallback were split into
// smaller helpers (resolveGrepTargets, runGrepBinary, grepExplicitTargets,
// setGrepResultsRelPath, grepWalkVisitor) to satisfy golangci-lint
// cyclop/gocognit limits. No behavioural change.
//
// Refresh by diffing against that path at a newer tau commit. Do not
// edit without recording the change above.
@@ -21,6 +25,7 @@ import (
"encoding/json"
"errors"
"fmt"
"io/fs"
"os"
"os/exec"
"path/filepath"
@@ -150,27 +155,7 @@ func makeGrepExecutor(cwd string, workspaceIndex GrepIndex) Executor {
return Result{Content: "error: path escapes working directory", IsError: true, ErrorKind: "sandbox_escape"}, nil
}
args := buildGrepArgs(p)
searchTargets := []string{searchPath}
searchBackend := "direct"
// The index is workspace-wide, so it can serve any search scoped at or
// below cwd once its candidates are narrowed to the requested subtree.
// Requiring searchPath == cwd meant subdirectory searches silently fell
// back to a full walk, which is why the index served only 5% of
// searches across analysed sessions.
if workspaceIndex != nil && isConfined(cwd, searchPath) {
if candidates, ok := workspaceIndex.Candidates(ctx, p.Pattern, p.Literal, p.CaseSensitive); ok {
if scoped := filterUnder(searchPath, candidates); len(scoped) > 0 {
searchTargets = scoped
searchBackend = "codesearch"
}
// An empty scoped set is NOT evidence of no matches: the index
// may simply be cold or stale for this subtree, so fall through
// to the authoritative direct walk rather than reporting "no
// matches found" from an empty candidate list.
}
}
args = append(args, searchTargets...)
searchTargets, searchBackend := resolveGrepTargets(ctx, workspaceIndex, p, cwd, searchPath)
limit := p.Limit
if limit <= 0 {
@@ -191,49 +176,85 @@ func makeGrepExecutor(cwd string, workspaceIndex GrepIndex) Executor {
return grepBackendResult(capGrepResult(output, limit), searchBackend, clamped), nil
}
cmd := exec.CommandContext(ctx, binary, args...)
cmd.Dir = cwd
result, backend := runGrepBinary(ctx, binary, cwd, p, searchPath, searchTargets, searchBackend, limit)
return grepBackendResult(result, backend, clamped), nil
}
}
var stdout, stderr bytes.Buffer
// resolveGrepTargets picks the search targets and backend label: the
// workspace index's narrowed candidates when it can serve the request, or a
// direct walk of searchPath otherwise.
//
// The index is workspace-wide, so it can serve any search scoped at or below
// cwd once its candidates are narrowed to the requested subtree. Requiring
// searchPath == cwd meant subdirectory searches silently fell back to a full
// walk, which is why the index served only 5% of searches across analysed
// sessions.
func resolveGrepTargets(ctx context.Context, workspaceIndex GrepIndex, p GrepParams, cwd, searchPath string) ([]string, string) {
if workspaceIndex != nil && isConfined(cwd, searchPath) {
if candidates, ok := workspaceIndex.Candidates(ctx, p.Pattern, p.Literal, p.CaseSensitive); ok {
if scoped := filterUnder(searchPath, candidates); len(scoped) > 0 {
return scoped, "codesearch"
}
// An empty scoped set is NOT evidence of no matches: the index
// may simply be cold or stale for this subtree, so fall through
// to the authoritative direct walk rather than reporting "no
// matches found" from an empty candidate list.
}
}
return []string{searchPath}, "direct"
}
// runGrepBinary runs the external rg binary against searchTargets, retrying
// against the authoritative searchPath if a codesearch-backed run fails, and
// returns a Result plus the backend that actually produced it.
func runGrepBinary(
ctx context.Context, binary, cwd string, p GrepParams,
searchPath string, searchTargets []string, searchBackend string, limit int,
) (Result, string) {
args := append(buildGrepArgs(p), searchTargets...)
cmd := exec.CommandContext(ctx, binary, args...)
cmd.Dir = cwd
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
output := stdout.String()
if searchBackend == "codesearch" && err != nil {
// Snapshot candidates can disappear, or an unusually large candidate
// argv can fail to spawn. Retry the authoritative workspace path.
searchBackend = "direct"
args = append(buildGrepArgs(p), searchPath)
cmd = exec.CommandContext(ctx, binary, args...)
cmd.Dir = cwd
stdout.Reset()
stderr.Reset()
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
output := stdout.String()
if searchBackend == "codesearch" && err != nil {
// Snapshot candidates can disappear, or an unusually large candidate
// argv can fail to spawn. Retry the authoritative workspace path.
searchBackend = "direct"
args = append(buildGrepArgs(p), searchPath)
cmd = exec.CommandContext(ctx, binary, args...)
cmd.Dir = cwd
stdout.Reset()
stderr.Reset()
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
output = stdout.String()
}
if output == "" && err != nil {
// Exit 1 means "no matches"; exit 2 means a real failure (bad
// pattern, unreadable path). Reporting the latter as an empty
// result would have the model state a file contains nothing when
// the search never ran, so the code must be checked, not just the
// error type.
var exitErr *exec.ExitError
if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 {
return grepBackendResult(Result{Content: "no matches found"}, searchBackend, clamped), nil
}
errMsg := stderr.String()
if errMsg == "" {
errMsg = err.Error()
}
return grepBackendResult(Result{Content: fmt.Sprintf("grep error: %s", errMsg), IsError: true}, searchBackend, clamped), nil
}
return grepBackendResult(capGrepResult(output, limit), searchBackend, clamped), nil
output = stdout.String()
}
if output == "" && err != nil {
// Exit 1 means "no matches"; exit 2 means a real failure (bad
// pattern, unreadable path). Reporting the latter as an empty
// result would have the model state a file contains nothing when
// the search never ran, so the code must be checked, not just the
// error type.
var exitErr *exec.ExitError
if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 {
return Result{Content: "no matches found"}, searchBackend
}
errMsg := stderr.String()
if errMsg == "" {
errMsg = err.Error()
}
return Result{Content: fmt.Sprintf("grep error: %s", errMsg), IsError: true}, searchBackend
}
return capGrepResult(output, limit), searchBackend
}
// filterUnder returns the candidates at or below root. Paths are compared
@@ -335,32 +356,16 @@ func grepFallback(ctx context.Context, p GrepParams, searchPath, cwd string, tar
return "", err
}
var results []grepResult
// When explicit files are provided (index candidates), search only those.
if len(targets) > 0 && targets[0] != searchPath {
for _, path := range targets {
select {
case <-ctx.Done():
return "", ctx.Err()
default:
}
res, fErr := grepFile(ctx, path, matcher, p.ContextBefore, p.ContextAfter)
if fErr != nil {
continue
}
for i := range res {
res[i].relPath, _ = filepath.Rel(cwd, path)
res[i].relPath = filepath.ToSlash(res[i].relPath)
if res[i].relPath == "" || res[i].relPath == "." {
res[i].relPath = filepath.ToSlash(filepath.Base(path))
}
}
results = append(results, res...)
results, err := grepExplicitTargets(ctx, targets, cwd, matcher, p)
if err != nil {
return "", err
}
return formatGrepResults(results), nil
}
var results []grepResult
info, err := os.Stat(searchPath)
if err != nil {
return "", err
@@ -371,12 +376,7 @@ func grepFallback(ctx context.Context, p GrepParams, searchPath, cwd string, tar
if err != nil {
return "", err
}
for i := range res {
res[i].relPath, _ = filepath.Rel(cwd, searchPath)
if res[i].relPath == "" || res[i].relPath == "." {
res[i].relPath = filepath.Base(searchPath)
}
}
setGrepResultsRelPath(res, cwd, searchPath)
results = append(results, res...)
} else if err := grepDirFallback(ctx, searchPath, cwd, p, matcher, &results); err != nil {
return "", err
@@ -385,11 +385,58 @@ func grepFallback(ctx context.Context, p GrepParams, searchPath, cwd string, tar
return formatGrepResults(results), nil
}
// grepExplicitTargets searches only the given files (index candidates),
// skipping any that fail to read.
func grepExplicitTargets(ctx context.Context, targets []string, cwd string, matcher func(string) bool, p GrepParams) ([]grepResult, error) {
var results []grepResult
for _, path := range targets {
select {
case <-ctx.Done():
return nil, ctx.Err()
default:
}
res, fErr := grepFile(ctx, path, matcher, p.ContextBefore, p.ContextAfter)
if fErr != nil {
continue
}
setGrepResultsRelPath(res, cwd, path)
results = append(results, res...)
}
return results, nil
}
// setGrepResultsRelPath fills in each result's relPath relative to cwd,
// falling back to the file's base name when the relative path collapses to
// "" or ".".
func setGrepResultsRelPath(res []grepResult, cwd, path string) {
for i := range res {
res[i].relPath, _ = filepath.Rel(cwd, path)
res[i].relPath = filepath.ToSlash(res[i].relPath)
if res[i].relPath == "" || res[i].relPath == "." {
res[i].relPath = filepath.ToSlash(filepath.Base(path))
}
}
}
// grepDirFallback walks searchPath and appends every readable, non-hidden file
// matching the include filter to results. It skips hidden directories and
// unreadable files without failing the whole search.
func grepDirFallback(ctx context.Context, searchPath, cwd string, p GrepParams, matcher func(string) bool, results *[]grepResult) error {
err := filepath.WalkDir(searchPath, func(walkPath string, d os.DirEntry, err error) error {
visit := grepWalkVisitor(ctx, searchPath, cwd, p, matcher, results)
err := filepath.WalkDir(searchPath, visit)
if err != nil && !errors.Is(err, ctx.Err()) {
return err
}
return nil
}
// grepWalkVisitor returns the filepath.WalkDir callback for grepDirFallback:
// it skips hidden directories/files, applies the include filter, greps each
// remaining file, and appends its (relPath-normalised) matches to results.
func grepWalkVisitor(
ctx context.Context, searchPath, cwd string, p GrepParams, matcher func(string) bool, results *[]grepResult,
) fs.WalkDirFunc {
return func(walkPath string, d os.DirEntry, err error) error {
if err != nil {
return nil //nolint:nilerr // intentionally skip inaccessible entries
}
@@ -424,20 +471,10 @@ func grepDirFallback(ctx context.Context, searchPath, cwd string, p GrepParams,
if err != nil {
return nil //nolint:nilerr // intentionally skip files we can't read
}
for i := range res {
res[i].relPath, _ = filepath.Rel(cwd, walkPath)
res[i].relPath = filepath.ToSlash(res[i].relPath)
if res[i].relPath == "" || res[i].relPath == "." {
res[i].relPath = filepath.ToSlash(filepath.Base(walkPath))
}
}
setGrepResultsRelPath(res, cwd, walkPath)
*results = append(*results, res...)
return nil
})
if err != nil && !errors.Is(err, ctx.Err()) {
return err
}
return nil
}
// buildMatcher returns a line matcher based on grep parameters.
+34 -16
View File
@@ -4,6 +4,9 @@
// Mutations from upstream:
// - package renamed tools -> builtin (archie-core already has an
// internal/tools package holding the registry these are registered into).
// - serveReadContent split into readOffsetLimitWindow and
// readTrailingNotice to satisfy golangci-lint's cyclop limit. No
// behavioural change.
//
// Refresh by diffing against that path at a newer tau commit. Do not
// edit without recording the change above.
@@ -339,21 +342,11 @@ func serveReadContent(cwd, path string, p readParams, info os.FileInfo, state *r
}
}
// Apply offset (1-based).
startLine := 1
if p.Offset > 0 {
startLine = p.Offset
}
startLine, endLine := readOffsetLimitWindow(p, totalLines)
if startLine > totalLines {
return Result{Content: fmt.Sprintf("offset %d exceeds file length (%d lines)", startLine, totalLines), IsError: true}
}
// Apply limit.
endLine := totalLines
if p.Limit > 0 && startLine+p.Limit-1 < endLine {
endLine = startLine + p.Limit - 1
}
// Skip lines this session has already been shown from an unchanged
// file. Repeated reads were 23.6% of all tool result tokens across
// analysed sessions - one file was read 58 times in a single session.
@@ -382,28 +375,53 @@ func serveReadContent(cwd, path string, p readParams, info os.FileInfo, state *r
) + output
}
output += readTrailingNotice(p, tr, lines, startLine, endLine, totalLines)
return Result{Content: output, Truncated: tr.Truncated || endLine < totalLines, ResultBytes: tr.OriginalSize}
}
// readOffsetLimitWindow resolves the requested 1-based [startLine, endLine]
// window from the offset/limit parameters and the file's total line count.
func readOffsetLimitWindow(p readParams, totalLines int) (startLine, endLine int) {
startLine = 1
if p.Offset > 0 {
startLine = p.Offset
}
endLine = totalLines
if p.Limit > 0 && startLine+p.Limit-1 < endLine {
endLine = startLine + p.Limit - 1
}
return startLine, endLine
}
// readTrailingNotice returns the suffix appended to the served content: a
// shell-fallback hint when the first requested line alone exceeded the byte
// limit, a continuation hint when the byte limit truncated mid-range, or a
// continuation hint when a user-specified limit stopped before EOF. Returns
// "" when none apply.
func readTrailingNotice(p readParams, tr TruncationResult, lines []string, startLine, endLine, totalLines int) string {
switch {
case tr.Truncated && tr.OutputLines == 0:
// The first requested line alone exceeds the byte limit. Point the
// model at a shell fallback that can slice within the line.
lineSize := FormatSize(len(lines[startLine-1]))
output = fmt.Sprintf(
return fmt.Sprintf(
"[line %d is %s, exceeding the %s output limit. Use shell: sed -n '%dp' %s | head -c %d]",
startLine, lineSize, FormatSize(DefaultMaxBytes), startLine, p.Path, DefaultMaxBytes,
)
case tr.Truncated:
shownEnd := startLine + tr.OutputLines - 1
output += fmt.Sprintf(
return fmt.Sprintf(
"\n\n[showing lines %d-%d of %d. Use offset=%d to continue.]",
startLine, shownEnd, totalLines, shownEnd+1,
)
case endLine < totalLines:
// A user-specified limit stopped early, but the file has more content.
output += fmt.Sprintf(
return fmt.Sprintf(
"\n\n[%d more lines in file. Use offset=%d to continue.]",
totalLines-endLine, endLine+1,
)
}
return Result{Content: output, Truncated: tr.Truncated || endLine < totalLines, ResultBytes: tr.OriginalSize}
return ""
}
+76 -64
View File
@@ -11,6 +11,9 @@
// cancels the turn context, so without this the command it was aimed
// at would keep going. tau applies the same treatment to spawned
// agents in agent.go; this extends it to the shell tool.
// - makeShellExecutor split into buildShellCmd, formatShellOutput, and
// shellErrorResult to satisfy golangci-lint's gocognit limit. No
// behavioural change.
//
// Refresh by diffing against that path at a newer tau commit. Do not
// edit without recording the change above.
@@ -121,53 +124,10 @@ func makeShellExecutor(cwd string, mq *MutationQueue) Executor {
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
shell, args := shellCommand(p.Command)
cmd := exec.CommandContext(ctx, shell, args...)
if cwd != "" {
cmd.Dir = cwd
}
// Run the command as its own process group and, on cancellation,
// signal the group rather than the shell alone.
//
// exec.CommandContext's default kills only the process it started.
// A shell's real work is almost always a child of that shell, so
// the default leaves the actual command running: cancelling
// `go test ./...` reaps the shell and lets the test binary carry
// on, and anything backgrounded with & or nohup is never touched.
// /stop cancels this context, so that gap is the difference
// between stopping a command and only appearing to.
setProcessGroup(cmd)
cmd.Cancel = func() error { return signalProcessGroup(cmd, syscall.SIGKILL) }
// Stop waiting on inherited pipes shortly after the kill. A
// grandchild holding stdout open would otherwise keep Wait
// blocked long after the group was signalled.
cmd.WaitDelay = shellWaitDelay
var stdout, stderr bytes.Buffer
bw := &bridgeWriter{bridge: bridge}
cmd.Stdout = io.MultiWriter(&stdout, bw)
cmd.Stderr = io.MultiWriter(&stderr, bw)
cmd, stdout, stderr := buildShellCmd(ctx, cwd, p.Command, bridge)
err := cmd.Run()
var b strings.Builder
if stdout.Len() > 0 {
b.WriteString(stdout.String())
}
if stderr.Len() > 0 {
if b.Len() > 0 {
b.WriteString("\n")
}
b.WriteString("[stderr]\n")
b.WriteString(stderr.String())
}
output := b.String()
if output == "" {
output = "(no output)"
}
output := formatShellOutput(stdout, stderr)
// Collapse before truncation, so a long passing test run is reduced to
// its summaries rather than tail-truncated into a partial log.
output, _ = collapseGoTestOutput(p.Command, output, err == nil)
@@ -183,31 +143,83 @@ func makeShellExecutor(cwd string, mq *MutationQueue) Executor {
}
if err != nil {
// Check context cancellation first - a process may exit with
// a non-zero code after the deadline, and we want to report
// timeout rather than a misleading exit code.
if ctx.Err() != nil {
return Result{
Content: fmt.Sprintf("[timeout after: %s]\n%s", timeout, content), IsError: true,
ErrorKind: "timeout", Truncated: tr.Truncated, ResultBytes: len(output),
}, nil
}
exitErr := &exec.ExitError{}
if errors.As(err, &exitErr) {
return Result{
Content: fmt.Sprintf("[exit code: %d]\n%s", exitErr.ExitCode(), content), IsError: true,
ErrorKind: "command_exit", Truncated: tr.Truncated, ResultBytes: len(output),
}, nil
}
return Result{Content: fmt.Sprintf("error executing command: %v", err), IsError: true}, nil
return shellErrorResult(ctx, err, timeout, content, tr, output), nil
}
return Result{Content: content, Truncated: tr.Truncated, ResultBytes: len(output)}, nil
}
}
// buildShellCmd constructs the shell command to run: its own process group,
// killed as a group on cancellation (see the package-level comment for why),
// with stdout/stderr tee'd to both an in-memory buffer and the UI bridge.
func buildShellCmd(ctx context.Context, cwd, command string, bridge UIBridge) (cmd *exec.Cmd, stdout, stderr *bytes.Buffer) {
shell, args := shellCommand(command)
cmd = exec.CommandContext(ctx, shell, args...)
if cwd != "" {
cmd.Dir = cwd
}
setProcessGroup(cmd)
cmd.Cancel = func() error { return signalProcessGroup(cmd, syscall.SIGKILL) }
// Stop waiting on inherited pipes shortly after the kill. A
// grandchild holding stdout open would otherwise keep Wait
// blocked long after the group was signalled.
cmd.WaitDelay = shellWaitDelay
stdout, stderr = &bytes.Buffer{}, &bytes.Buffer{}
bw := &bridgeWriter{bridge: bridge}
cmd.Stdout = io.MultiWriter(stdout, bw)
cmd.Stderr = io.MultiWriter(stderr, bw)
return cmd, stdout, stderr
}
// formatShellOutput joins stdout and stderr, labelling stderr when both are
// present, and substitutes a placeholder when the command produced nothing.
func formatShellOutput(stdout, stderr *bytes.Buffer) string {
var b strings.Builder
if stdout.Len() > 0 {
b.WriteString(stdout.String())
}
if stderr.Len() > 0 {
if b.Len() > 0 {
b.WriteString("\n")
}
b.WriteString("[stderr]\n")
b.WriteString(stderr.String())
}
output := b.String()
if output == "" {
output = "(no output)"
}
return output
}
// shellErrorResult classifies a command's run error into a timeout, a
// nonzero exit, or a raw execution failure, and builds the matching Result.
func shellErrorResult(ctx context.Context, err error, timeout time.Duration, content string, tr TruncationResult, output string) Result {
// Check context cancellation first - a process may exit with
// a non-zero code after the deadline, and we want to report
// timeout rather than a misleading exit code.
if ctx.Err() != nil {
return Result{
Content: fmt.Sprintf("[timeout after: %s]\n%s", timeout, content), IsError: true,
ErrorKind: "timeout", Truncated: tr.Truncated, ResultBytes: len(output),
}
}
exitErr := &exec.ExitError{}
if errors.As(err, &exitErr) {
return Result{
Content: fmt.Sprintf("[exit code: %d]\n%s", exitErr.ExitCode(), content), IsError: true,
ErrorKind: "command_exit", Truncated: tr.Truncated, ResultBytes: len(output),
}
}
return Result{Content: fmt.Sprintf("error executing command: %v", err), IsError: true}
}
// goTestSummaryRe matches cmd/go's per-package result lines: "ok", "FAIL" and
// "?" (no test files). Note it must NOT match "---", which prefixes per-test
// result lines ("--- PASS: TestX") - exactly the noise being collapsed. A
+53 -43
View File
@@ -418,50 +418,11 @@ func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) {
},
})
} else {
type turnResult struct {
reply string
err error
var cancelled bool
reply, err, cancelled = s.runQueuedChatTurn(r, chat, sessionID, msg, showToolCalls, writeChatEvent)
if cancelled {
return
}
// One channel carries both text and tool events, because the
// order between them is the point: a tool line that overtakes
// the sentence it interrupted describes a turn that never
// happened.
events := make(chan chatStreamEvent, 32)
result := make(chan turnResult, 1)
chat.Turns.Submit(r.Context(), sessionID, func(turnCtx context.Context) {
turnReply, turnErr := chat.Router.RouteStream(turnCtx, msg, chatStreamSink{
showToolCalls: showToolCalls,
write: func(event chatStreamEvent) {
select {
case events <- event:
case <-r.Context().Done():
}
},
})
result <- turnResult{reply: turnReply, err: turnErr}
})
for {
select {
case event := <-events:
writeChatEvent(event, sessionID)
case turn := <-result:
for {
select {
case event := <-events:
writeChatEvent(event, sessionID)
default:
goto drained
}
}
drained:
reply, err = turn.reply, turn.err
goto turnDone
case <-r.Context().Done():
chat.Turns.Stop(sessionID)
return
}
}
turnDone:
}
if err != nil {
writeChatEvent(chatStreamEvent{Type: "error", Text: err.Error()}, sessionID)
@@ -473,6 +434,55 @@ func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) {
writeChatEvent(chatStreamEvent{Type: "done", Text: reply}, sessionID)
}
// runQueuedChatTurn submits msg to the session's turn queue and streams its
// text/tool events as they arrive, in order, via writeChatEvent. One channel
// carries both text and tool events, because the order between them is the
// point: a tool line that overtakes the sentence it interrupted describes a
// turn that never happened. Returns cancelled=true when the request context
// was cancelled before the turn finished, in which case the caller must not
// write any further response.
func (s *Server) runQueuedChatTurn(
r *http.Request, chat *ChatService, sessionID string, msg gateway.Message, showToolCalls bool,
writeChatEvent func(chatStreamEvent, string),
) (reply string, err error, cancelled bool) {
type turnResult struct {
reply string
err error
}
events := make(chan chatStreamEvent, 32)
result := make(chan turnResult, 1)
chat.Turns.Submit(r.Context(), sessionID, func(turnCtx context.Context) {
turnReply, turnErr := chat.Router.RouteStream(turnCtx, msg, chatStreamSink{
showToolCalls: showToolCalls,
write: func(event chatStreamEvent) {
select {
case events <- event:
case <-r.Context().Done():
}
},
})
result <- turnResult{reply: turnReply, err: turnErr}
})
for {
select {
case event := <-events:
writeChatEvent(event, sessionID)
case turn := <-result:
for {
select {
case event := <-events:
writeChatEvent(event, sessionID)
default:
return turn.reply, turn.err, false
}
}
case <-r.Context().Done():
chat.Turns.Stop(sessionID)
return "", nil, true
}
}
}
func (s *Server) handleChatCancel(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {