From 5ff258516cb0c082abe91702e3f80bcd4d4e7f23 Mon Sep 17 00:00:00 2001 From: shin-core <153108882+shin-core@users.noreply.github.com> Date: Tue, 21 Jul 2026 16:05:09 +1000 Subject: [PATCH] feat(miner): add a dry-run full-execution mode to the cross-repo evaluation harness The cross-repo harness (#4788) is readiness-only: it proves the miner can FORM a plan for a benchmark repo, not that the plan produces working code. Add a --full-execution mode to the existing CLI that runs the real discover -> plan -> code -> test loop, still dry-run: each repo that passes readiness is copied into a discardable scratch workspace, the coding agent (resolved from MINER_CODING_AGENT_PROVIDER, failing closed to a categorized agent_run_failed when unconfigured) works the harness's synthetic issue inside that copy, and the repo's own inferred build and test commands validate the generated diff there. No PR submission, no forge APIs, no writes to the benchmark clone; the scratch tree is removed in every outcome. Build/test commands are tokenized and exec'd directly (never via a shell), so nothing in a benchmark repo's manifest can smuggle shell metacharacters into an interpreted command line. Execution failures extend the existing taxonomy -- agent_run_failed, noop_diff (agent succeeded but changed nothing), build_failed (diff didn't compile), test_failed (repo's own suite failed) -- and flow through the existing summary/report format unchanged, since both are data-driven over category strings. A repo whose stack infers no test command fails with the existing execution_gap: an unvalidatable diff is not a pass. The scratch copy inherits the ACCEPTANCE_CRITERIA.md the readiness pass wrote into the clone, and writeAcceptanceCriteriaFile opens O_EXCL, so the inherited file is cleared from the copy before the spec is re-composed there. Closes #7634 --- .../docs/cross-repo-evaluation.md | 42 +- .../lib/cross-repo-evaluation.d.ts | 84 ++++ .../lib/cross-repo-evaluation.js | 249 +++++++++- .../lib/cross-repo-evaluation.ts | 393 +++++++++++++++- .../scripts/cross-repo-evaluation.d.mts | 9 +- .../scripts/cross-repo-evaluation.mjs | 28 +- test/unit/miner-cross-repo-evaluation.test.ts | 445 +++++++++++++++++- 7 files changed, 1206 insertions(+), 44 deletions(-) diff --git a/packages/loopover-miner/docs/cross-repo-evaluation.md b/packages/loopover-miner/docs/cross-repo-evaluation.md index cc36444b74..675e79a129 100644 --- a/packages/loopover-miner/docs/cross-repo-evaluation.md +++ b/packages/loopover-miner/docs/cross-repo-evaluation.md @@ -61,18 +61,52 @@ fleet run-manifest). - `--manifest path/to/manifest.json` — alternate benchmark set (e.g. a fixture manifest in tests) - `--require-majority` — exit `1` unless a strict majority of repos pass (for CI-style gating) +## Full-execution mode (#7634) + +`--full-execution` extends the readiness check into the real **discover → plan → code → test** loop, still +**dry-run only**: no live PR submission, no forge API calls, no write access to the third-party repos. Each repo +that passes readiness is copied into a **discardable scratch workspace** (the benchmark clone is never mutated); +the coding agent runs against a synthetic benchmark issue inside that copy, and the repo's own inferred build and +test commands are executed there. The scratch tree is removed afterward in every outcome — execute-locally-and-discard. + +```bash +node packages/loopover-miner/scripts/cross-repo-evaluation.mjs --full-execution +``` + +Prerequisites beyond the readiness mode: a configured coding-agent provider (`MINER_CODING_AGENT_PROVIDER`, see +[`docs/coding-agent-driver.md`](coding-agent-driver.md)). Without one, each repo reports `agent_run_failed` +("No runnable coding-agent driver") rather than silently skipping. + +Execution failures extend — never replace — the readiness taxonomy, in the same report format: + +| Category | Meaning | +| --- | --- | +| `agent_run_failed` | No runnable driver was configured, or the coding agent errored / did not finish | +| `noop_diff` | The agent reported success but the generated diff changed no files | +| `build_failed` | A diff was generated but the stack's inferred build command failed (didn't compile) | +| `test_failed` | The build was fine but the repo's own test suite failed against the diff | + +A repo that passes readiness but has **no inferred test command** fails with the existing `execution_gap` +category — a generated diff that nothing can validate is not a pass. Per-command wall-clock is capped +(`DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS`, 10 minutes each for build and test); the agent's turn budget +defaults to `DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS` (24). + ## Library API Pure functions live in [`lib/cross-repo-evaluation.js`](../lib/cross-repo-evaluation.js): - `parseCrossRepoEvaluationManifest(content)` - `evaluateRepoReadiness(entry, options)` — inject `existsSync`, `detectRepoStack`, etc. for unit tests -- `runCrossRepoEvaluation(parsed, options)` +- `evaluateRepoExecution(entry, options)` — full-execution mode for one repo (#7634); inject `driver`, + `prepareExecutionWorkspace`, `runCommand`, etc. for unit tests +- `runCrossRepoEvaluation(parsed, options)` / `runCrossRepoFullExecution(parsed, options)` - `summarizeCrossRepoEvaluation(results)` - `formatCrossRepoEvaluationReport(results, summary)` ## Wiring -This harness is **readiness-only**: it does not run the coding agent, open PRs, or call forge APIs. A green report -means the miner’s repo-agnostic stack-detection and coding-task-spec path is prepared for the benchmark repo; a live -attempt still needs credentials, governor policy, and queue state as documented in [`DEPLOYMENT.md`](../DEPLOYMENT.md). +The default mode is **readiness-only**: it does not run the coding agent, open PRs, or call forge APIs. A green +readiness report means the miner’s repo-agnostic stack-detection and coding-task-spec path is prepared for the +benchmark repo. `--full-execution` (#7634) additionally runs the agent and the repo's own test suite locally in a +discarded scratch copy — it still never opens a PR or touches any forge API; a live attempt still needs +credentials, governor policy, and queue state as documented in [`DEPLOYMENT.md`](../DEPLOYMENT.md). diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts index af8e928558..7e843e635a 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts @@ -65,6 +65,7 @@ type EvaluateRepoReadinessOptions = { ready: boolean; verdict?: string; instructions?: string; + acceptanceCriteriaPath?: string; }; }; /** Canonical `owner/repo` with exactly one slash and safe segments; anything else → null. */ @@ -100,4 +101,87 @@ export declare function summarizeCrossRepoEvaluation(results: CrossRepoEvaluatio * Human-readable pass/fail report for one evaluation run (#4788). */ export declare function formatCrossRepoEvaluationReport(results: CrossRepoEvaluationResult[], summary?: CrossRepoEvaluationSummary): string; +/** Execution-specific failure taxonomy (#7634), extending — not replacing — CROSS_REPO_FAILURE_CATEGORY. */ +export declare const CROSS_REPO_EXECUTION_FAILURE_CATEGORY: Readonly<{ + AGENT_RUN: "agent_run_failed"; + NOOP_DIFF: "noop_diff"; + BUILD: "build_failed"; + TEST: "test_failed"; +}>; +/** A benchmark attempt works a small synthetic issue, so a modest turn cap keeps dry-runs bounded without + * starving a real agent; callers tune via options.maxTurns. */ +export declare const DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS: number; +/** Per-command (build, then test) wall-clock cap — generous enough for a cold dependency install on the larger + * benchmark repos, small enough that a hung suite cannot wedge the whole run. */ +export declare const DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS: number; +export type CrossRepoExecutionCommandResult = { + code: number | null; + stdout: string; + stderr: string; + timedOut: boolean; +}; +export type CrossRepoExecutionRunCommandFn = (command: string, options: { + cwd: string; + timeoutMs: number; +}) => Promise; +export type CrossRepoExecutionWorkspace = { + path: string; + cleanup: () => void; +}; +/** Structural mirror of the engine's CodingAgentDriver contract — kept local so this module only loads the real + * driver construction (and its engine dependency) lazily, on the one path that actually runs an agent. */ +export type CrossRepoExecutionDriver = { + run(task: { + attemptId: string; + workingDirectory: string; + acceptanceCriteriaPath: string; + instructions: string; + maxTurns: number; + }): Promise<{ + ok: boolean; + changedFiles: readonly string[]; + summary: string; + error?: string | undefined; + }>; +}; +export type CrossRepoExecutionDetails = { + attempted: boolean; + changedFileCount: number | null; + buildRan: boolean; + testRan: boolean; +}; +export type CrossRepoExecutionEvaluationResult = CrossRepoEvaluationResult & { + execution: CrossRepoExecutionDetails | null; +}; +export type EvaluateRepoExecutionOptions = EvaluateRepoReadinessOptions & { + driver?: CrossRepoExecutionDriver; + prepareExecutionWorkspace?: (repoPath: string) => CrossRepoExecutionWorkspace; + runCommand?: CrossRepoExecutionRunCommandFn; + maxTurns?: number; + commandTimeoutMs?: number; +}; +/** Copy the benchmark clone into a discardable temp tree — the agent and the repo's test suite only ever touch + * the copy, so the clone stays pristine and cleanup is a single recursive remove. */ +export declare function defaultPrepareExecutionWorkspace(repoPath: string): CrossRepoExecutionWorkspace; +/** Command runner for the stack's inferred build/test commands. detectRepoStack only ever emits simple + * `tool subcommand` forms ("npm test", "cargo build", "npm run build"), so the command is tokenized on + * whitespace and exec'd DIRECTLY -- deliberately no `shell: true`, so nothing in a benchmark repo's manifest + * can smuggle shell metacharacters into an interpreted shell line. Mirrors coding-agent-construction's + * createRealCliSubprocessSpawn otherwise: capture both streams and RESOLVE (never reject) on timeout or spawn + * error, so partial output stays diagnosable. Promise resolution is idempotent, so a `close` firing after the + * timeout already resolved needs no guard. */ +export declare function createDefaultCrossRepoExecutionRunCommand(): CrossRepoExecutionRunCommandFn; +/** + * Run the full discover -> plan -> code -> test loop for one benchmark repo, dry-run (#7634). Readiness gates + * first (its failures pass through unchanged); execution then happens entirely inside a scratch copy that is + * discarded in every outcome. + */ +export declare function evaluateRepoExecution(entry: CrossRepoEvaluationManifestRepo, options?: EvaluateRepoExecutionOptions): Promise; +/** + * Run full-execution mode across every repo in a parsed manifest (#7634), sequentially — agent runs and test + * suites are heavyweight, so no parallel fan-out. + */ +export declare function runCrossRepoFullExecution(parsed: ParsedCrossRepoEvaluationManifest, options?: { + repoFilter?: string; +} & EvaluateRepoExecutionOptions): Promise; export {}; diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.js b/packages/loopover-miner/lib/cross-repo-evaluation.js index 995ae19eba..0327062a89 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.js +++ b/packages/loopover-miner/lib/cross-repo-evaluation.js @@ -3,7 +3,12 @@ // evaluated through the same stack-detection + coding-task-spec path a real attempt uses (detectRepoStack, // resolveMinerGoalSpec, buildCodingTaskSpec) and failures are categorized as stack-detection gaps, execution // readiness gaps, leaked loopover assumptions in agent instructions, clone/setup problems, or other. -import { existsSync } from "node:fs"; +import { spawn as nodeSpawn } from "node:child_process"; +import { cpSync, existsSync, mkdtempSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +// Already a transitive dependency via coding-task-spec.js's own engine imports -- this adds no load weight. +import { ACCEPTANCE_CRITERIA_FILENAME } from "@loopover/engine"; import { buildCodingTaskSpec } from "./coding-task-spec.js"; import { resolveMinerGoalSpec } from "./miner-goal-spec.js"; import { isValidRepoSegment, resolveRepoCloneDir } from "./repo-clone.js"; @@ -180,6 +185,10 @@ export function scanPositiveLoopoverAssumptions(text) { } return findings; } +/** One shared thrown-value formatter so every catch in both harness modes carries the same two branches. */ +function describeError(error) { + return error instanceof Error ? error.message : String(error); +} function buildFailure(repoFullName, category, reason, extra = {}) { return { repoFullName, @@ -216,6 +225,24 @@ function resolveEvaluationRepoPath(entry, options = {}) { function defaultClaimLedger(repoFullName) { return { listClaims: () => [] }; } +/** The synthetic-issue spec input both harness modes hand to buildCodingTaskSpec — readiness composes it against + * the benchmark clone, full-execution mode against the scratch workspace copy (#7634), so the acceptance-criteria + * file buildCodingTaskSpec writes lands inside whichever tree the caller is actually working in. */ +function buildHarnessSpecInput(repoFullName, workingDirectory, detectImpl) { + return { + repoFullName, + issue: { + number: 1, + title: "Cross-repo evaluation harness smoke issue", + body: "Synthetic issue used only by the cross-repo evaluation harness.", + labels: ["bug"], + }, + context: { issues: [{ number: 1 }], pullRequests: [] }, + claimLedger: defaultClaimLedger(repoFullName), + workingDirectory, + detectRepoStack: detectImpl, + }; +} /** * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). */ @@ -244,23 +271,10 @@ export function evaluateRepoReadiness(entry, options = {}) { } let specResult; try { - specResult = buildSpecImpl({ - repoFullName, - issue: { - number: 1, - title: "Cross-repo evaluation harness smoke issue", - body: "Synthetic issue used only by the cross-repo evaluation harness.", - labels: ["bug"], - }, - context: { issues: [{ number: 1 }], pullRequests: [] }, - claimLedger: defaultClaimLedger(repoFullName), - workingDirectory: repoPath, - detectRepoStack: detectImpl, - }); + specResult = buildSpecImpl(buildHarnessSpecInput(repoFullName, repoPath, detectImpl)); } catch (error) { - const message = error instanceof Error ? error.message : String(error); - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, message, { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), { stackDetected: true, usedDefaultGoalSpec, stack, @@ -343,4 +357,205 @@ export function formatCrossRepoEvaluationReport(results, summary = summarizeCros } return lines.join("\n"); } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cross-repo-evaluation.js","sourceRoot":"","sources":["cross-repo-evaluation.ts"],"names":[],"mappings":"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"} \ No newline at end of file +// --------------------------------------------------------------------------------------------------------------- +// Full-execution mode (#7634): past readiness, actually run the discover -> plan -> code -> test loop against a +// benchmark repo — dry-run only. The attempt runs inside a scratch COPY of the local clone that is discarded +// afterward: no live PR submission, no forge API calls, and the benchmark clone itself is never mutated by the +// agent or the test run. Same taxonomy extension point as the readiness categories above — summarize/format are +// data-driven over category strings, so these flow through the existing report unchanged. +/** Execution-specific failure taxonomy (#7634), extending — not replacing — CROSS_REPO_FAILURE_CATEGORY. */ +export const CROSS_REPO_EXECUTION_FAILURE_CATEGORY = Object.freeze({ + AGENT_RUN: "agent_run_failed", + NOOP_DIFF: "noop_diff", + BUILD: "build_failed", + TEST: "test_failed", +}); +/** A benchmark attempt works a small synthetic issue, so a modest turn cap keeps dry-runs bounded without + * starving a real agent; callers tune via options.maxTurns. */ +export const DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS = 24; +/** Per-command (build, then test) wall-clock cap — generous enough for a cold dependency install on the larger + * benchmark repos, small enough that a hung suite cannot wedge the whole run. */ +export const DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS = 600_000; +/** Copy the benchmark clone into a discardable temp tree — the agent and the repo's test suite only ever touch + * the copy, so the clone stays pristine and cleanup is a single recursive remove. */ +export function defaultPrepareExecutionWorkspace(repoPath) { + const scratchRoot = mkdtempSync(join(tmpdir(), "loopover-cross-repo-exec-")); + const path = join(scratchRoot, "repo"); + cpSync(repoPath, path, { recursive: true }); + return { + path, + cleanup: () => { + rmSync(scratchRoot, { recursive: true, force: true }); + }, + }; +} +/** Command runner for the stack's inferred build/test commands. detectRepoStack only ever emits simple + * `tool subcommand` forms ("npm test", "cargo build", "npm run build"), so the command is tokenized on + * whitespace and exec'd DIRECTLY -- deliberately no `shell: true`, so nothing in a benchmark repo's manifest + * can smuggle shell metacharacters into an interpreted shell line. Mirrors coding-agent-construction's + * createRealCliSubprocessSpawn otherwise: capture both streams and RESOLVE (never reject) on timeout or spawn + * error, so partial output stays diagnosable. Promise resolution is idempotent, so a `close` firing after the + * timeout already resolved needs no guard. */ +export function createDefaultCrossRepoExecutionRunCommand() { + return (command, options) => new Promise((resolve) => { + const [executable, ...args] = command.split(/\s+/).filter(Boolean); + if (!executable) { + resolve({ stdout: "", stderr: "empty_command", code: null, timedOut: false }); + return; + } + const child = nodeSpawn(executable, args, { + cwd: options.cwd, + stdio: ["ignore", "pipe", "pipe"], + }); + let stdout = ""; + let stderr = ""; + const timer = setTimeout(() => { + child.kill("SIGKILL"); + resolve({ stdout, stderr, code: null, timedOut: true }); + }, options.timeoutMs); + // stdio is always ["ignore","pipe","pipe"] above, so both streams exist — assert instead of branching. + child.stdout.on("data", (chunk) => { + stdout += chunk.toString("utf8"); + }); + child.stderr.on("data", (chunk) => { + stderr += chunk.toString("utf8"); + }); + child.on("error", (err) => { + clearTimeout(timer); + resolve({ stdout, stderr: err.message, code: null, timedOut: false }); + }); + child.on("close", (code) => { + clearTimeout(timer); + resolve({ stdout, stderr, code, timedOut: false }); + }); + }); +} +function buildExecutionFailure(repoFullName, category, reason, base, execution) { + return { ...buildFailure(repoFullName, category, reason, base), execution }; +} +/** + * Run the full discover -> plan -> code -> test loop for one benchmark repo, dry-run (#7634). Readiness gates + * first (its failures pass through unchanged); execution then happens entirely inside a scratch copy that is + * discarded in every outcome. + */ +export async function evaluateRepoExecution(entry, options = {}) { + const readiness = evaluateRepoReadiness(entry, options); + if (!readiness.passed) + return { ...readiness, execution: null }; + const prepareWorkspace = options.prepareExecutionWorkspace ?? defaultPrepareExecutionWorkspace; + let workspace; + try { + workspace = prepareWorkspace(resolveEvaluationRepoPath(entry, options)); + } + catch (error) { + const reason = `Failed to prepare a scratch execution workspace: ${describeError(error)}`; + // A passed readiness result always carries its detected stack (buildPass is invoked with it). + const base = { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack: readiness.stack }; + return buildExecutionFailure(readiness.repoFullName, CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP, reason, base, null); + } + try { + return await runExecutionPhases(readiness, workspace, options); + } + finally { + try { + workspace.cleanup(); + } + catch { + // Best-effort discard — a cleanup failure must never mask the evaluation outcome itself. + } + } +} +async function runExecutionPhases(readiness, workspace, options) { + const repoFullName = readiness.repoFullName; + // Readiness passed, so the stack is present and detected — narrow once instead of re-branching on it. + const stack = readiness.stack; + const usedDefaultGoalSpec = readiness.usedDefaultGoalSpec; + const failureBase = { stackDetected: true, usedDefaultGoalSpec, stack }; + const detectImpl = options.detectRepoStack ?? detectRepoStack; + const buildSpecImpl = options.buildCodingTaskSpec ?? + buildCodingTaskSpec; + // Re-compose the coding-task spec INSIDE the scratch copy: buildCodingTaskSpec writes the acceptance-criteria + // document into its workingDirectory, and the agent must find it (and work) in the tree it is allowed to touch. + // The readiness pass already wrote that document into the clone (pre-existing #4788 behavior), so the copy + // inherits it -- and writeAcceptanceCriteriaFile opens O_EXCL (never overwrites), so clear the inherited file + // first. The scratch tree is ours to mutate; the clone itself stays untouched. + rmSync(join(workspace.path, ACCEPTANCE_CRITERIA_FILENAME), { force: true }); + let specResult; + try { + specResult = buildSpecImpl(buildHarnessSpecInput(repoFullName, workspace.path, detectImpl)); + } + catch (error) { + return buildExecutionFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, `Coding task spec failed inside the scratch workspace: ${describeError(error)}`, failureBase, null); + } + if (specResult?.ready !== true) { + return buildExecutionFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION, `Coding task spec is not ready inside the scratch workspace (verdict: ${specResult?.verdict ?? "unknown"}).`, failureBase, null); + } + let driver = options.driver; + if (!driver) { + try { + // Lazy so the readiness-only path (and its consumers) never load the engine-backed driver construction. + const { constructProductionCodingAgentDriver } = await import("./coding-agent-construction.js"); + driver = constructProductionCodingAgentDriver(options.env ?? process.env); + } + catch (error) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN, `No runnable coding-agent driver: ${describeError(error)}`, failureBase, { attempted: false, changedFileCount: null, buildRan: false, testRan: false }); + } + } + const task = { + attemptId: `cross-repo-eval-${repoFullName.replace("/", "-")}`, + workingDirectory: workspace.path, + acceptanceCriteriaPath: specResult.acceptanceCriteriaPath ?? join(workspace.path, "ACCEPTANCE_CRITERIA.md"), + instructions: specResult.instructions ?? "", + maxTurns: options.maxTurns ?? DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS, + }; + let agentResult; + try { + agentResult = await driver.run(task); + } + catch (error) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN, `Coding agent run threw: ${describeError(error)}`, failureBase, { attempted: true, changedFileCount: null, buildRan: false, testRan: false }); + } + if (agentResult?.ok !== true) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN, `Coding agent run did not succeed: ${agentResult?.error ?? agentResult?.summary ?? "no failure detail reported"}`, failureBase, { attempted: true, changedFileCount: null, buildRan: false, testRan: false }); + } + const changedFileCount = Array.isArray(agentResult.changedFiles) ? agentResult.changedFiles.length : 0; + if (changedFileCount === 0) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_FAILURE_CATEGORY.NOOP_DIFF, "Coding agent reported success but the generated diff is a no-op (no files changed).", failureBase, { attempted: true, changedFileCount: 0, buildRan: false, testRan: false }); + } + const runCommand = options.runCommand ?? createDefaultCrossRepoExecutionRunCommand(); + const commandTimeoutMs = options.commandTimeoutMs ?? DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS; + let buildRan = false; + if (stack.buildCommand) { + buildRan = true; + const buildResult = await runCommand(stack.buildCommand, { cwd: workspace.path, timeoutMs: commandTimeoutMs }); + if (buildResult.timedOut || buildResult.code !== 0) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_FAILURE_CATEGORY.BUILD, `Diff generated but the build ${buildResult.timedOut ? "timed out" : `failed (exit ${buildResult.code})`}: ${stack.buildCommand}`, failureBase, { attempted: true, changedFileCount, buildRan: true, testRan: false }); + } + } + if (!stack.testCommand) { + return buildExecutionFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION, "Stack detection inferred no test command, so the generated diff cannot be validated in execution mode.", failureBase, { attempted: true, changedFileCount, buildRan, testRan: false }); + } + const testResult = await runCommand(stack.testCommand, { cwd: workspace.path, timeoutMs: commandTimeoutMs }); + if (testResult.timedOut || testResult.code !== 0) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_FAILURE_CATEGORY.TEST, `Diff generated but the repo's own test suite ${testResult.timedOut ? "timed out" : `failed (exit ${testResult.code})`}: ${stack.testCommand}`, failureBase, { attempted: true, changedFileCount, buildRan, testRan: true }); + } + return { + ...buildPass(repoFullName, { usedDefaultGoalSpec, stack }), + execution: { attempted: true, changedFileCount, buildRan, testRan: true }, + }; +} +/** + * Run full-execution mode across every repo in a parsed manifest (#7634), sequentially — agent runs and test + * suites are heavyweight, so no parallel fan-out. + */ +export async function runCrossRepoFullExecution(parsed, options = {}) { + const repos = parsed?.manifest?.repos ?? []; + const results = []; + for (const entry of repos) { + if (options.repoFilter && entry.repoFullName !== options.repoFilter) + continue; + results.push(await evaluateRepoExecution(entry, options)); + } + return results; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cross-repo-evaluation.js","sourceRoot":"","sources":["cross-repo-evaluation.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.ts b/packages/loopover-miner/lib/cross-repo-evaluation.ts index f579b18aef..61fdf68c6d 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.ts @@ -4,13 +4,17 @@ // resolveMinerGoalSpec, buildCodingTaskSpec) and failures are categorized as stack-detection gaps, execution // readiness gaps, leaked loopover assumptions in agent instructions, clone/setup problems, or other. -import { existsSync } from "node:fs"; +import { spawn as nodeSpawn } from "node:child_process"; +import { cpSync, existsSync, mkdtempSync, rmSync } from "node:fs"; +import { tmpdir } from "node:os"; import { join } from "node:path"; +// Already a transitive dependency via coding-task-spec.js's own engine imports -- this adds no load weight. +import { ACCEPTANCE_CRITERIA_FILENAME } from "@loopover/engine"; import { buildCodingTaskSpec } from "./coding-task-spec.js"; import { resolveMinerGoalSpec } from "./miner-goal-spec.js"; import { isValidRepoSegment, resolveRepoCloneDir } from "./repo-clone.js"; import { detectRepoStack } from "./stack-detection.js"; -import type { RepoStackResult } from "./stack-detection.js"; +import type { DetectedRepoStack, RepoStackResult } from "./stack-detection.js"; /** Failure taxonomy surfaced in per-repo reports (#4788). */ export const CROSS_REPO_FAILURE_CATEGORY: Readonly<{ @@ -84,6 +88,7 @@ type EvaluateRepoReadinessOptions = { ready: boolean; verdict?: string; instructions?: string; + acceptanceCriteriaPath?: string; }; }; @@ -231,6 +236,11 @@ export function scanPositiveLoopoverAssumptions(text: string): Array<{ id: strin return findings; } +/** One shared thrown-value formatter so every catch in both harness modes carries the same two branches. */ +function describeError(error: unknown): string { + return error instanceof Error ? error.message : String(error); +} + function buildFailure( repoFullName: string, category: string, @@ -276,6 +286,29 @@ function defaultClaimLedger(repoFullName: string): { listClaims: () => never[] } return { listClaims: () => [] }; } +/** The synthetic-issue spec input both harness modes hand to buildCodingTaskSpec — readiness composes it against + * the benchmark clone, full-execution mode against the scratch workspace copy (#7634), so the acceptance-criteria + * file buildCodingTaskSpec writes lands inside whichever tree the caller is actually working in. */ +function buildHarnessSpecInput( + repoFullName: string, + workingDirectory: string, + detectImpl: (repoPath: string) => RepoStackResult, +): Record { + return { + repoFullName, + issue: { + number: 1, + title: "Cross-repo evaluation harness smoke issue", + body: "Synthetic issue used only by the cross-repo evaluation harness.", + labels: ["bug"], + }, + context: { issues: [{ number: 1 }], pullRequests: [] }, + claimLedger: defaultClaimLedger(repoFullName), + workingDirectory, + detectRepoStack: detectImpl, + }; +} + /** * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). */ @@ -332,22 +365,9 @@ export function evaluateRepoReadiness( let specResult; try { - specResult = buildSpecImpl({ - repoFullName, - issue: { - number: 1, - title: "Cross-repo evaluation harness smoke issue", - body: "Synthetic issue used only by the cross-repo evaluation harness.", - labels: ["bug"], - }, - context: { issues: [{ number: 1 }], pullRequests: [] }, - claimLedger: defaultClaimLedger(repoFullName), - workingDirectory: repoPath, - detectRepoStack: detectImpl, - }); + specResult = buildSpecImpl(buildHarnessSpecInput(repoFullName, repoPath, detectImpl)); } catch (error) { - const message = error instanceof Error ? error.message : String(error); - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, message, { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), { stackDetected: true, usedDefaultGoalSpec, stack, @@ -454,3 +474,342 @@ export function formatCrossRepoEvaluationReport( } return lines.join("\n"); } + +// --------------------------------------------------------------------------------------------------------------- +// Full-execution mode (#7634): past readiness, actually run the discover -> plan -> code -> test loop against a +// benchmark repo — dry-run only. The attempt runs inside a scratch COPY of the local clone that is discarded +// afterward: no live PR submission, no forge API calls, and the benchmark clone itself is never mutated by the +// agent or the test run. Same taxonomy extension point as the readiness categories above — summarize/format are +// data-driven over category strings, so these flow through the existing report unchanged. + +/** Execution-specific failure taxonomy (#7634), extending — not replacing — CROSS_REPO_FAILURE_CATEGORY. */ +export const CROSS_REPO_EXECUTION_FAILURE_CATEGORY: Readonly<{ + AGENT_RUN: "agent_run_failed"; + NOOP_DIFF: "noop_diff"; + BUILD: "build_failed"; + TEST: "test_failed"; +}> = Object.freeze({ + AGENT_RUN: "agent_run_failed", + NOOP_DIFF: "noop_diff", + BUILD: "build_failed", + TEST: "test_failed", +}); + +/** A benchmark attempt works a small synthetic issue, so a modest turn cap keeps dry-runs bounded without + * starving a real agent; callers tune via options.maxTurns. */ +export const DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS: number = 24; +/** Per-command (build, then test) wall-clock cap — generous enough for a cold dependency install on the larger + * benchmark repos, small enough that a hung suite cannot wedge the whole run. */ +export const DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS: number = 600_000; + +export type CrossRepoExecutionCommandResult = { + code: number | null; + stdout: string; + stderr: string; + timedOut: boolean; +}; + +export type CrossRepoExecutionRunCommandFn = ( + command: string, + options: { cwd: string; timeoutMs: number }, +) => Promise; + +export type CrossRepoExecutionWorkspace = { path: string; cleanup: () => void }; + +/** Structural mirror of the engine's CodingAgentDriver contract — kept local so this module only loads the real + * driver construction (and its engine dependency) lazily, on the one path that actually runs an agent. */ +export type CrossRepoExecutionDriver = { + run(task: { + attemptId: string; + workingDirectory: string; + acceptanceCriteriaPath: string; + instructions: string; + maxTurns: number; + }): Promise<{ + ok: boolean; + changedFiles: readonly string[]; + summary: string; + error?: string | undefined; + }>; +}; + +export type CrossRepoExecutionDetails = { + attempted: boolean; + changedFileCount: number | null; + buildRan: boolean; + testRan: boolean; +}; + +export type CrossRepoExecutionEvaluationResult = CrossRepoEvaluationResult & { + execution: CrossRepoExecutionDetails | null; +}; + +export type EvaluateRepoExecutionOptions = EvaluateRepoReadinessOptions & { + driver?: CrossRepoExecutionDriver; + prepareExecutionWorkspace?: (repoPath: string) => CrossRepoExecutionWorkspace; + runCommand?: CrossRepoExecutionRunCommandFn; + maxTurns?: number; + commandTimeoutMs?: number; +}; + +/** Copy the benchmark clone into a discardable temp tree — the agent and the repo's test suite only ever touch + * the copy, so the clone stays pristine and cleanup is a single recursive remove. */ +export function defaultPrepareExecutionWorkspace(repoPath: string): CrossRepoExecutionWorkspace { + const scratchRoot = mkdtempSync(join(tmpdir(), "loopover-cross-repo-exec-")); + const path = join(scratchRoot, "repo"); + cpSync(repoPath, path, { recursive: true }); + return { + path, + cleanup: () => { + rmSync(scratchRoot, { recursive: true, force: true }); + }, + }; +} + +/** Command runner for the stack's inferred build/test commands. detectRepoStack only ever emits simple + * `tool subcommand` forms ("npm test", "cargo build", "npm run build"), so the command is tokenized on + * whitespace and exec'd DIRECTLY -- deliberately no `shell: true`, so nothing in a benchmark repo's manifest + * can smuggle shell metacharacters into an interpreted shell line. Mirrors coding-agent-construction's + * createRealCliSubprocessSpawn otherwise: capture both streams and RESOLVE (never reject) on timeout or spawn + * error, so partial output stays diagnosable. Promise resolution is idempotent, so a `close` firing after the + * timeout already resolved needs no guard. */ +export function createDefaultCrossRepoExecutionRunCommand(): CrossRepoExecutionRunCommandFn { + return (command, options) => + new Promise((resolve) => { + const [executable, ...args] = command.split(/\s+/).filter(Boolean); + if (!executable) { + resolve({ stdout: "", stderr: "empty_command", code: null, timedOut: false }); + return; + } + const child = nodeSpawn(executable, args, { + cwd: options.cwd, + stdio: ["ignore", "pipe", "pipe"], + }); + let stdout = ""; + let stderr = ""; + const timer = setTimeout(() => { + child.kill("SIGKILL"); + resolve({ stdout, stderr, code: null, timedOut: true }); + }, options.timeoutMs); + // stdio is always ["ignore","pipe","pipe"] above, so both streams exist — assert instead of branching. + child.stdout!.on("data", (chunk: Buffer | string) => { + stdout += chunk.toString("utf8"); + }); + child.stderr!.on("data", (chunk: Buffer | string) => { + stderr += chunk.toString("utf8"); + }); + child.on("error", (err: Error) => { + clearTimeout(timer); + resolve({ stdout, stderr: err.message, code: null, timedOut: false }); + }); + child.on("close", (code: number | null) => { + clearTimeout(timer); + resolve({ stdout, stderr, code, timedOut: false }); + }); + }); +} + +function buildExecutionFailure( + repoFullName: string, + category: string, + reason: string, + base: Partial, + execution: CrossRepoExecutionDetails | null, +): CrossRepoExecutionEvaluationResult { + return { ...buildFailure(repoFullName, category, reason, base), execution }; +} + +/** + * Run the full discover -> plan -> code -> test loop for one benchmark repo, dry-run (#7634). Readiness gates + * first (its failures pass through unchanged); execution then happens entirely inside a scratch copy that is + * discarded in every outcome. + */ +export async function evaluateRepoExecution( + entry: CrossRepoEvaluationManifestRepo, + options: EvaluateRepoExecutionOptions = {}, +): Promise { + const readiness = evaluateRepoReadiness(entry, options); + if (!readiness.passed) return { ...readiness, execution: null }; + + const prepareWorkspace = options.prepareExecutionWorkspace ?? defaultPrepareExecutionWorkspace; + let workspace: CrossRepoExecutionWorkspace; + try { + workspace = prepareWorkspace(resolveEvaluationRepoPath(entry, options)); + } catch (error) { + const reason = `Failed to prepare a scratch execution workspace: ${describeError(error)}`; + // A passed readiness result always carries its detected stack (buildPass is invoked with it). + const base = { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack: readiness.stack! }; + return buildExecutionFailure(readiness.repoFullName, CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP, reason, base, null); + } + try { + return await runExecutionPhases(readiness, workspace, options); + } finally { + try { + workspace.cleanup(); + } catch { + // Best-effort discard — a cleanup failure must never mask the evaluation outcome itself. + } + } +} + +async function runExecutionPhases( + readiness: CrossRepoEvaluationResult, + workspace: CrossRepoExecutionWorkspace, + options: EvaluateRepoExecutionOptions, +): Promise { + const repoFullName = readiness.repoFullName; + // Readiness passed, so the stack is present and detected — narrow once instead of re-branching on it. + const stack = readiness.stack as DetectedRepoStack; + const usedDefaultGoalSpec = readiness.usedDefaultGoalSpec; + const failureBase = { stackDetected: true, usedDefaultGoalSpec, stack }; + + const detectImpl = options.detectRepoStack ?? detectRepoStack; + const buildSpecImpl: NonNullable = + options.buildCodingTaskSpec ?? + (buildCodingTaskSpec as unknown as NonNullable); + + // Re-compose the coding-task spec INSIDE the scratch copy: buildCodingTaskSpec writes the acceptance-criteria + // document into its workingDirectory, and the agent must find it (and work) in the tree it is allowed to touch. + // The readiness pass already wrote that document into the clone (pre-existing #4788 behavior), so the copy + // inherits it -- and writeAcceptanceCriteriaFile opens O_EXCL (never overwrites), so clear the inherited file + // first. The scratch tree is ours to mutate; the clone itself stays untouched. + rmSync(join(workspace.path, ACCEPTANCE_CRITERIA_FILENAME), { force: true }); + let specResult; + try { + specResult = buildSpecImpl(buildHarnessSpecInput(repoFullName, workspace.path, detectImpl)); + } catch (error) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.OTHER, + `Coding task spec failed inside the scratch workspace: ${describeError(error)}`, + failureBase, + null, + ); + } + if (specResult?.ready !== true) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION, + `Coding task spec is not ready inside the scratch workspace (verdict: ${specResult?.verdict ?? "unknown"}).`, + failureBase, + null, + ); + } + + let driver = options.driver; + if (!driver) { + try { + // Lazy so the readiness-only path (and its consumers) never load the engine-backed driver construction. + const { constructProductionCodingAgentDriver } = await import("./coding-agent-construction.js"); + driver = constructProductionCodingAgentDriver(options.env ?? process.env); + } catch (error) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN, + `No runnable coding-agent driver: ${describeError(error)}`, + failureBase, + { attempted: false, changedFileCount: null, buildRan: false, testRan: false }, + ); + } + } + + const task = { + attemptId: `cross-repo-eval-${repoFullName.replace("/", "-")}`, + workingDirectory: workspace.path, + acceptanceCriteriaPath: specResult.acceptanceCriteriaPath ?? join(workspace.path, "ACCEPTANCE_CRITERIA.md"), + instructions: specResult.instructions ?? "", + maxTurns: options.maxTurns ?? DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS, + }; + let agentResult; + try { + agentResult = await driver.run(task); + } catch (error) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN, + `Coding agent run threw: ${describeError(error)}`, + failureBase, + { attempted: true, changedFileCount: null, buildRan: false, testRan: false }, + ); + } + if (agentResult?.ok !== true) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN, + `Coding agent run did not succeed: ${agentResult?.error ?? agentResult?.summary ?? "no failure detail reported"}`, + failureBase, + { attempted: true, changedFileCount: null, buildRan: false, testRan: false }, + ); + } + + const changedFileCount = Array.isArray(agentResult.changedFiles) ? agentResult.changedFiles.length : 0; + if (changedFileCount === 0) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_FAILURE_CATEGORY.NOOP_DIFF, + "Coding agent reported success but the generated diff is a no-op (no files changed).", + failureBase, + { attempted: true, changedFileCount: 0, buildRan: false, testRan: false }, + ); + } + + const runCommand = options.runCommand ?? createDefaultCrossRepoExecutionRunCommand(); + const commandTimeoutMs = options.commandTimeoutMs ?? DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS; + + let buildRan = false; + if (stack.buildCommand) { + buildRan = true; + const buildResult = await runCommand(stack.buildCommand, { cwd: workspace.path, timeoutMs: commandTimeoutMs }); + if (buildResult.timedOut || buildResult.code !== 0) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_FAILURE_CATEGORY.BUILD, + `Diff generated but the build ${buildResult.timedOut ? "timed out" : `failed (exit ${buildResult.code})`}: ${stack.buildCommand}`, + failureBase, + { attempted: true, changedFileCount, buildRan: true, testRan: false }, + ); + } + } + + if (!stack.testCommand) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION, + "Stack detection inferred no test command, so the generated diff cannot be validated in execution mode.", + failureBase, + { attempted: true, changedFileCount, buildRan, testRan: false }, + ); + } + const testResult = await runCommand(stack.testCommand, { cwd: workspace.path, timeoutMs: commandTimeoutMs }); + if (testResult.timedOut || testResult.code !== 0) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_FAILURE_CATEGORY.TEST, + `Diff generated but the repo's own test suite ${testResult.timedOut ? "timed out" : `failed (exit ${testResult.code})`}: ${stack.testCommand}`, + failureBase, + { attempted: true, changedFileCount, buildRan, testRan: true }, + ); + } + + return { + ...buildPass(repoFullName, { usedDefaultGoalSpec, stack }), + execution: { attempted: true, changedFileCount, buildRan, testRan: true }, + }; +} + +/** + * Run full-execution mode across every repo in a parsed manifest (#7634), sequentially — agent runs and test + * suites are heavyweight, so no parallel fan-out. + */ +export async function runCrossRepoFullExecution( + parsed: ParsedCrossRepoEvaluationManifest, + options: { repoFilter?: string } & EvaluateRepoExecutionOptions = {}, +): Promise { + const repos = parsed?.manifest?.repos ?? []; + const results: CrossRepoExecutionEvaluationResult[] = []; + for (const entry of repos) { + if (options.repoFilter && entry.repoFullName !== options.repoFilter) continue; + results.push(await evaluateRepoExecution(entry, options)); + } + return results; +} diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts index c263aa2347..263810db73 100644 --- a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts +++ b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts @@ -1,11 +1,12 @@ import type { CrossRepoEvaluationResult, CrossRepoEvaluationSummary, + CrossRepoExecutionEvaluationResult, ParsedCrossRepoEvaluationManifest, } from "../lib/cross-repo-evaluation.js"; export type CrossRepoEvaluationCliArgs = - | { manifestPath: string; json: boolean; repoFilter: string | null; requireMajority: boolean } + | { manifestPath: string; json: boolean; repoFilter: string | null; requireMajority: boolean; fullExecution: boolean } | { error: string } | { help: true }; @@ -26,3 +27,9 @@ export declare function runCrossRepoEvaluationCli(options?: CrossRepoEvaluationC results: CrossRepoEvaluationResult[]; summary: CrossRepoEvaluationSummary; }; + +export declare function runCrossRepoFullExecutionCli(options?: CrossRepoEvaluationCliOptions): Promise<{ + parsed: ParsedCrossRepoEvaluationManifest; + results: CrossRepoExecutionEvaluationResult[]; + summary: CrossRepoEvaluationSummary; +}>; diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.mjs b/packages/loopover-miner/scripts/cross-repo-evaluation.mjs index 04de1d9fa4..bfe8e4c4d5 100644 --- a/packages/loopover-miner/scripts/cross-repo-evaluation.mjs +++ b/packages/loopover-miner/scripts/cross-repo-evaluation.mjs @@ -7,6 +7,7 @@ import { formatCrossRepoEvaluationReport, parseCrossRepoEvaluationManifest, runCrossRepoEvaluation, + runCrossRepoFullExecution, summarizeCrossRepoEvaluation, } from "../lib/cross-repo-evaluation.js"; @@ -22,6 +23,7 @@ export function parseCrossRepoEvaluationArgs(argv) { let json = false; let repoFilter = null; let requireMajority = false; + let fullExecution = false; for (let i = 0; i < args.length; i += 1) { const token = args[i]; if (token === "--json") { @@ -32,6 +34,10 @@ export function parseCrossRepoEvaluationArgs(argv) { requireMajority = true; continue; } + if (token === "--full-execution") { + fullExecution = true; + continue; + } if (token === "--manifest") { const value = args[i + 1]; if (!value) return { error: "Missing value for --manifest." }; @@ -51,7 +57,7 @@ export function parseCrossRepoEvaluationArgs(argv) { } return { error: `Unknown argument: ${token}` }; } - return { manifestPath, json, repoFilter, requireMajority }; + return { manifestPath, json, repoFilter, requireMajority, fullExecution }; } export function loadCrossRepoEvaluationManifest(manifestPath) { @@ -66,6 +72,15 @@ export function runCrossRepoEvaluationCli(options = {}) { return { parsed, results, summary }; } +/** Full-execution counterpart of runCrossRepoEvaluationCli (#7634) — same shape, async because agent runs and + * the benchmark repos' own test suites are. Dry-run: see runCrossRepoFullExecution. */ +export async function runCrossRepoFullExecutionCli(options = {}) { + const parsed = options.parsed ?? loadCrossRepoEvaluationManifest(options.manifestPath ?? resolveDefaultManifestPath()); + const results = await runCrossRepoFullExecution(parsed, { repoFilter: options.repoFilter ?? null }); + const summary = summarizeCrossRepoEvaluation(results); + return { parsed, results, summary }; +} + function printHelp() { console.log( [ @@ -77,6 +92,9 @@ function printHelp() { "Options:", " --manifest Benchmark manifest (default: benchmarks/cross-repo/manifest.json)", " --repo Evaluate a single benchmark entry", + " --full-execution Past readiness, run the coding agent + the repo's own test suite in a", + " discardable scratch copy (dry-run: no PRs, no writes to the clone).", + " Requires MINER_CODING_AGENT_PROVIDER to be configured.", " --json Emit machine-readable JSON on stdout", " --require-majority Exit 1 unless a strict majority of repos pass", " -h, --help Show this help", @@ -86,7 +104,7 @@ function printHelp() { ); } -function main() { +async function main() { const parsedArgs = parseCrossRepoEvaluationArgs(); if (parsedArgs.help) { printHelp(); @@ -97,7 +115,9 @@ function main() { return 2; } - const { parsed, results, summary } = runCrossRepoEvaluationCli(parsedArgs); + const { parsed, results, summary } = parsedArgs.fullExecution + ? await runCrossRepoFullExecutionCli(parsedArgs) + : runCrossRepoEvaluationCli(parsedArgs); if (parsedArgs.json) { console.log(JSON.stringify({ warnings: parsed.warnings, results, summary }, null, 2)); } else { @@ -112,5 +132,5 @@ function main() { } if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) { - process.exitCode = main(); + process.exitCode = await main(); } diff --git a/test/unit/miner-cross-repo-evaluation.test.ts b/test/unit/miner-cross-repo-evaluation.test.ts index 1f1de6a21d..91f1ab8825 100644 --- a/test/unit/miner-cross-repo-evaluation.test.ts +++ b/test/unit/miner-cross-repo-evaluation.test.ts @@ -1,4 +1,4 @@ -import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, describe, expect, it, vi } from "vitest"; @@ -8,23 +8,35 @@ vi.mock("@loopover/engine", async () => { }); import { + CROSS_REPO_EXECUTION_FAILURE_CATEGORY, CROSS_REPO_FAILURE_CATEGORY, + DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS, + DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS, DEFAULT_CROSS_REPO_MANIFEST_RELATIVE_PATH, MAX_CROSS_REPO_MANIFEST_BYTES, + createDefaultCrossRepoExecutionRunCommand, + defaultPrepareExecutionWorkspace, + evaluateRepoExecution, formatCrossRepoEvaluationReport, evaluateRepoReadiness, normalizeCrossRepoFullName, parseCrossRepoEvaluationManifest, runCrossRepoEvaluation, + runCrossRepoFullExecution, scanPositiveLoopoverAssumptions, summarizeCrossRepoEvaluation, } from "../../packages/loopover-miner/lib/cross-repo-evaluation.js"; +import type { + CrossRepoExecutionCommandResult, + CrossRepoExecutionDriver, +} from "../../packages/loopover-miner/lib/cross-repo-evaluation.js"; import type { RepoStackResult } from "../../packages/loopover-miner/lib/stack-detection.js"; import { loadCrossRepoEvaluationManifest, parseCrossRepoEvaluationArgs, resolveDefaultManifestPath, runCrossRepoEvaluationCli, + runCrossRepoFullExecutionCli, } from "../../packages/loopover-miner/scripts/cross-repo-evaluation.mjs"; const roots: string[] = []; @@ -495,7 +507,9 @@ describe("cross-repo evaluation harness (#4788)", () => { json: true, repoFilter: "acme/widgets", requireMajority: true, + fullExecution: false, }); + expect(parseCrossRepoEvaluationArgs(["--full-execution"])).toMatchObject({ fullExecution: true }); expect(parseCrossRepoEvaluationArgs(["--manifest"])).toEqual({ error: "Missing value for --manifest." }); expect(parseCrossRepoEvaluationArgs(["--nope"])).toEqual({ error: "Unknown argument: --nope" }); expect(parseCrossRepoEvaluationArgs(["--help"])).toEqual({ help: true }); @@ -528,11 +542,440 @@ describe("cross-repo evaluation harness (#4788)", () => { }); }); + describe("full-execution mode (#7634)", () => { + /** A minimal Node fixture the real detector/spec-builder both handle. */ + function nodeFixture(scripts: Record = { test: "node --test" }) { + return tempRepo({ "package.json": pkg({ name: "exec-fixture", version: "0.0.0", scripts }) }); + } + + function entryFor(repoPath: string, name = "acme/exec") { + return { repoFullName: name, fixturePath: repoPath, requireTestCommand: false }; + } + + /** Recording driver — returns `result` (or the queue of results) and captures every task it was handed. */ + function recordingDriver(result: unknown = { ok: true, changedFiles: ["src/x.js"], summary: "done" }) { + const tasks: Array> = []; + const driver = { + run: async (task: Record) => { + tasks.push(task); + return result; + }, + } as unknown as CrossRepoExecutionDriver; + return { tasks, driver }; + } + + /** Sequential fake runCommand — shifts scripted results, recording each (command, options) call. */ + function scriptedRunCommand(script: Array>) { + const calls: Array<{ command: string; cwd: string; timeoutMs: number }> = []; + const runCommand = async (command: string, options: { cwd: string; timeoutMs: number }) => { + calls.push({ command, cwd: options.cwd, timeoutMs: options.timeoutMs }); + return { code: 0, stdout: "", stderr: "", timedOut: false, ...script.shift() }; + }; + return { calls, runCommand }; + } + + /** Reuse the fixture itself as the "scratch" tree so real detect/spec impls work inside it. */ + function inPlaceWorkspace(cleanup: () => void = () => {}) { + return (repoPath: string) => ({ path: repoPath, cleanup }); + } + + it("passes readiness failures through with execution:null and never touches the agent", async () => { + const { tasks, driver } = recordingDriver(); + const result = await evaluateRepoExecution({ repoFullName: "not-a-repo", requireTestCommand: false }, { driver }); + expect(result.passed).toBe(false); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.OTHER); + expect(result.execution).toBeNull(); + expect(tasks).toHaveLength(0); + }); + + it("fails clone_setup when the scratch workspace cannot be prepared (Error and non-Error throws)", async () => { + // Fresh fixture per call: the real spec builder writes ACCEPTANCE_CRITERIA.md (O_EXCL) during readiness, + // so re-evaluating the same tree would fail readiness instead of reaching the phase under test. + const errorRepo = nodeFixture(); + const viaError = await evaluateRepoExecution(entryFor(errorRepo), { + repoPath: errorRepo, + existsSync: () => true, + driver: recordingDriver().driver, + prepareExecutionWorkspace: () => { + throw new Error("no space left"); + }, + }); + expect(viaError.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP); + expect(viaError.reason).toContain("scratch execution workspace"); + expect(viaError.reason).toContain("no space left"); + expect(viaError.execution).toBeNull(); + + const stringRepo = nodeFixture(); + const viaString = await evaluateRepoExecution(entryFor(stringRepo), { + repoPath: stringRepo, + existsSync: () => true, + driver: recordingDriver().driver, + prepareExecutionWorkspace: () => { + throw "disk-full-string"; + }, + }); + expect(viaString.reason).toContain("disk-full-string"); + }); + + it("always discards the workspace, even when cleanup itself throws, without masking the outcome", async () => { + const repoPath = nodeFixture(); + const cleanup = vi.fn(() => { + throw new Error("cleanup-fail"); + }); + const { runCommand } = scriptedRunCommand([{ code: 0 }]); + const result = await evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(cleanup), + driver: recordingDriver().driver, + runCommand, + }); + expect(result.passed).toBe(true); + expect(result.execution).toEqual({ attempted: true, changedFileCount: 1, buildRan: false, testRan: true }); + expect(cleanup).toHaveBeenCalledTimes(1); + }); + + it("categorizes a spec failure inside the scratch workspace as other / execution_gap with verdict fallback", async () => { + const repoPath = nodeFixture(); + const optionsFor = (secondCall: () => unknown) => { + let calls = 0; + return { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + driver: recordingDriver().driver, + buildCodingTaskSpec: () => { + calls += 1; + if (calls === 1) return { ready: true, instructions: "fine" }; + return secondCall() as never; + }, + }; + }; + const thrown = await evaluateRepoExecution( + entryFor(repoPath), + optionsFor(() => { + throw new Error("spec-workspace-boom"); + }), + ); + expect(thrown.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.OTHER); + expect(thrown.reason).toContain("scratch workspace"); + expect(thrown.reason).toContain("spec-workspace-boom"); + expect(thrown.execution).toBeNull(); + + const nullish = await evaluateRepoExecution( + entryFor(repoPath), + optionsFor(() => null), + ); + expect(nullish.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION); + expect(nullish.reason).toContain("unknown"); + + const unready = await evaluateRepoExecution( + entryFor(repoPath), + optionsFor(() => ({ ready: false, verdict: "held" })), + ); + expect(unready.reason).toContain("held"); + }); + + it("fails agent_run_failed via the default driver construction when no provider is configured", async () => { + const injectedEnvRepo = nodeFixture(); + const viaInjectedEnv = await evaluateRepoExecution(entryFor(injectedEnvRepo), { + repoPath: injectedEnvRepo, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + env: {} as NodeJS.ProcessEnv, + }); + expect(viaInjectedEnv.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN); + expect(viaInjectedEnv.reason).toContain("No runnable coding-agent driver"); + expect(viaInjectedEnv.reason).toContain("unconfigured_coding_agent_driver"); + expect(viaInjectedEnv.execution).toEqual({ + attempted: false, + changedFileCount: null, + buildRan: false, + testRan: false, + }); + + // Same failure through the `?? process.env` default — pinned empty so the test never launches a real agent. + const processEnvRepo = nodeFixture(); + vi.stubEnv("MINER_CODING_AGENT_PROVIDER", ""); + try { + const viaProcessEnv = await evaluateRepoExecution(entryFor(processEnvRepo), { + repoPath: processEnvRepo, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + }); + expect(viaProcessEnv.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN); + expect(viaProcessEnv.reason).toContain("unconfigured_coding_agent_driver"); + } finally { + vi.unstubAllEnvs(); + } + }); + + /** Fresh fixture + options per driver scenario — see the clone_setup test's O_EXCL note. */ + async function evaluateWithDriver(driver: CrossRepoExecutionDriver) { + const repoPath = nodeFixture(); + return evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + driver, + }); + } + + it("fails agent_run_failed when the driver throws, with detail fallbacks when it reports badly", async () => { + const threw = await evaluateWithDriver({ + run: async () => { + throw new Error("agent exploded"); + }, + } as never); + expect(threw.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN); + expect(threw.reason).toContain("Coding agent run threw"); + expect(threw.reason).toContain("agent exploded"); + expect(threw.execution).toEqual({ attempted: true, changedFileCount: null, buildRan: false, testRan: false }); + + const nullResult = await evaluateWithDriver(recordingDriver(null).driver); + expect(nullResult.reason).toContain("no failure detail reported"); + + const withError = await evaluateWithDriver( + recordingDriver({ ok: false, changedFiles: [], summary: "s", error: "exploded mid-run" }).driver, + ); + expect(withError.reason).toContain("exploded mid-run"); + + const withSummaryOnly = await evaluateWithDriver( + recordingDriver({ ok: false, changedFiles: [], summary: "gave up early" }).driver, + ); + expect(withSummaryOnly.reason).toContain("gave up early"); + }); + + it("fails noop_diff when the agent succeeds without changing any file (empty or missing changedFiles)", async () => { + const emptyDiff = await evaluateWithDriver( + recordingDriver({ ok: true, changedFiles: [], summary: "did nothing" }).driver, + ); + expect(emptyDiff.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.NOOP_DIFF); + expect(emptyDiff.execution).toEqual({ attempted: true, changedFileCount: 0, buildRan: false, testRan: false }); + + const missingDiff = await evaluateWithDriver(recordingDriver({ ok: true, summary: "malformed result" }).driver); + expect(missingDiff.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.NOOP_DIFF); + }); + + /** Fresh build+test fixture per command scenario — see the clone_setup test's O_EXCL note. */ + async function evaluateWithRunCommand( + runCommand: (command: string, options: { cwd: string; timeoutMs: number }) => Promise, + scripts: Record = { test: "node --test" }, + ) { + const repoPath = nodeFixture(scripts); + return evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + driver: recordingDriver().driver, + runCommand, + }); + } + + it("runs the inferred build command first and fails build_failed on a non-zero exit or a timeout", async () => { + const buildScripts = { build: "node -e ok", test: "node --test" }; + const exited = scriptedRunCommand([{ code: 2 }]); + const buildFailed = await evaluateWithRunCommand(exited.runCommand, buildScripts); + expect(buildFailed.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.BUILD); + expect(buildFailed.reason).toContain("failed (exit 2)"); + expect(buildFailed.reason).toContain("npm run build"); + expect(buildFailed.execution).toEqual({ attempted: true, changedFileCount: 1, buildRan: true, testRan: false }); + expect(exited.calls[0]?.command).toBe("npm run build"); + + const timedOut = scriptedRunCommand([{ code: null, timedOut: true }]); + const buildTimeout = await evaluateWithRunCommand(timedOut.runCommand, buildScripts); + expect(buildTimeout.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.BUILD); + expect(buildTimeout.reason).toContain("timed out"); + }); + + it("passes end-to-end with build + test green, using the default command timeout", async () => { + const repoPath = nodeFixture({ build: "node -e ok", test: "node --test" }); + const { calls, runCommand } = scriptedRunCommand([{ code: 0 }, { code: 0 }]); + const result = await evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + driver: recordingDriver().driver, + runCommand, + }); + expect(result.passed).toBe(true); + expect(result.execution).toEqual({ attempted: true, changedFileCount: 1, buildRan: true, testRan: true }); + expect(calls.map((call) => call.command)).toEqual(["npm run build", "npm test"]); + expect(calls[0]?.timeoutMs).toBe(DEFAULT_CROSS_REPO_EXECUTION_COMMAND_TIMEOUT_MS); + expect(calls[0]?.cwd).toBe(repoPath); + }); + + it("honors options.commandTimeoutMs and options.maxTurns", async () => { + const repoPath = nodeFixture(); + const { calls, runCommand } = scriptedRunCommand([{ code: 0 }]); + const { tasks, driver } = recordingDriver(); + const result = await evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + driver, + runCommand, + commandTimeoutMs: 12_345, + maxTurns: 7, + }); + expect(result.passed).toBe(true); + expect(calls[0]?.timeoutMs).toBe(12_345); + expect(tasks[0]?.maxTurns).toBe(7); + }); + + it("fails execution_gap when no test command was inferred to validate the diff", async () => { + const repoPath = nodeFixture({}); + const result = await evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + driver: recordingDriver().driver, + buildCodingTaskSpec: () => ({ ready: true, instructions: "fine" }), + }); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION); + expect(result.reason).toContain("cannot be validated"); + expect(result.execution).toEqual({ attempted: true, changedFileCount: 1, buildRan: false, testRan: false }); + }); + + it("fails test_failed when the repo's own test suite exits non-zero or times out", async () => { + const exited = await evaluateWithRunCommand(scriptedRunCommand([{ code: 3 }]).runCommand); + expect(exited.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.TEST); + expect(exited.reason).toContain("failed (exit 3)"); + expect(exited.reason).toContain("npm test"); + expect(exited.execution).toEqual({ attempted: true, changedFileCount: 1, buildRan: false, testRan: true }); + + const timedOut = await evaluateWithRunCommand(scriptedRunCommand([{ code: null, timedOut: true }]).runCommand); + expect(timedOut.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.TEST); + expect(timedOut.reason).toContain("timed out"); + }); + + it("hands the agent a task rooted in a REAL discardable scratch copy, then removes it (dry-run posture)", async () => { + const repoPath = nodeFixture(); + const { tasks, driver } = recordingDriver(); + const { runCommand } = scriptedRunCommand([{ code: 0 }]); + const result = await evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync, + driver, + runCommand, + }); + expect(result.passed).toBe(true); + const task = tasks[0]!; + // The agent worked in the scratch copy, not the benchmark clone… + expect(task.workingDirectory).not.toBe(repoPath); + expect(String(task.workingDirectory)).toContain("loopover-cross-repo-exec-"); + // …the acceptance-criteria document was written INSIDE that copy… + expect(String(task.acceptanceCriteriaPath).startsWith(String(task.workingDirectory))).toBe(true); + expect(String(task.instructions)).not.toBe(""); + expect(task.maxTurns).toBe(DEFAULT_CROSS_REPO_EXECUTION_MAX_TURNS); + // …and the whole scratch tree is discarded afterward while the clone survives untouched. + expect(existsSync(String(task.workingDirectory))).toBe(false); + expect(existsSync(join(repoPath, "package.json"))).toBe(true); + }); + + it("falls back to empty instructions and a workspace-local acceptance path when a spec omits them", async () => { + const repoPath = nodeFixture(); + let calls = 0; + const { tasks, driver } = recordingDriver(); + const result = await evaluateRepoExecution(entryFor(repoPath), { + repoPath, + existsSync: () => true, + prepareExecutionWorkspace: inPlaceWorkspace(), + driver, + runCommand: scriptedRunCommand([{ code: 0 }]).runCommand, + buildCodingTaskSpec: () => { + calls += 1; + return calls === 1 ? { ready: true, instructions: "readiness pass" } : { ready: true }; + }, + }); + expect(result.passed).toBe(true); + expect(tasks[0]?.instructions).toBe(""); + expect(String(tasks[0]?.acceptanceCriteriaPath).endsWith("ACCEPTANCE_CRITERIA.md")).toBe(true); + }); + + it("runCrossRepoFullExecution mirrors the readiness runner's manifest and filter handling", async () => { + expect(await runCrossRepoFullExecution(undefined as never)).toEqual([]); + + const parsed = parseCrossRepoEvaluationManifest(JSON.stringify({ repos: ["acme/a", "acme/b"] })); + const all = await runCrossRepoFullExecution(parsed, { existsSync: () => false }); + expect(all).toHaveLength(2); + expect(all[0]?.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP); + expect(all[0]?.execution).toBeNull(); + + const filtered = await runCrossRepoFullExecution(parsed, { repoFilter: "acme/b", existsSync: () => false }); + expect(filtered).toHaveLength(1); + expect(filtered[0]?.repoFullName).toBe("acme/b"); + }); + + it("defaultPrepareExecutionWorkspace copies the repo and cleanup removes the whole scratch tree", () => { + const repoPath = nodeFixture(); + const workspace = defaultPrepareExecutionWorkspace(repoPath); + expect(workspace.path).not.toBe(repoPath); + expect(existsSync(join(workspace.path, "package.json"))).toBe(true); + workspace.cleanup(); + expect(existsSync(workspace.path)).toBe(false); + }); + + it("createDefaultCrossRepoExecutionRunCommand reports exit codes, output, timeouts, and spawn errors", async () => { + // The runner tokenizes on whitespace and execs directly (no shell), so every command here is a plain + // `tool arg...` form — the only shape detectRepoStack ever emits. + const runCommand = createDefaultCrossRepoExecutionRunCommand(); + const cwd = tempRepo(); + + const ok = await runCommand("node -p 40+2", { cwd, timeoutMs: 30_000 }); + expect(ok).toMatchObject({ code: 0, timedOut: false }); + expect(ok.stdout).toContain("42"); + + const failing = await runCommand("node --definitely-not-a-real-flag", { cwd, timeoutMs: 30_000 }); + expect(failing.code).not.toBe(0); + expect(failing.code).not.toBeNull(); + expect(failing.stderr).toContain("bad option"); + + const hung = await runCommand("node -e setTimeout(function(){},10000)", { cwd, timeoutMs: 300 }); + expect(hung.timedOut).toBe(true); + expect(hung.code).toBeNull(); + + const spawnError = await runCommand("node -v", { cwd: join(cwd, "definitely-missing-subdir"), timeoutMs: 5_000 }); + expect(spawnError.code).toBeNull(); + expect(spawnError.timedOut).toBe(false); + expect(spawnError.stderr).not.toBe(""); + + const empty = await runCommand(" ", { cwd, timeoutMs: 5_000 }); + expect(empty).toEqual({ stdout: "", stderr: "empty_command", code: null, timedOut: false }); + }); + + it("runCrossRepoFullExecutionCli reports the new categories through the existing summary + report format", async () => { + const repoPath = nodeFixture(); + const manifestDir = tempRepo(); + writeFileSync( + join(manifestDir, "manifest.json"), + JSON.stringify({ repos: [{ repoFullName: "acme/exec-cli", fixturePath: repoPath }] }), + "utf8", + ); + // Pin the provider empty so the CLI's default driver path fails closed instead of launching a real agent. + vi.stubEnv("MINER_CODING_AGENT_PROVIDER", ""); + try { + const { results, summary } = await runCrossRepoFullExecutionCli({ + manifestPath: join(manifestDir, "manifest.json"), + }); + expect(results[0]?.failureCategory).toBe(CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN); + expect(summary.failuresByCategory[CROSS_REPO_EXECUTION_FAILURE_CATEGORY.AGENT_RUN]).toBe(1); + expect(formatCrossRepoEvaluationReport(results, summary)).toContain("- agent_run_failed: 1"); + } finally { + vi.unstubAllEnvs(); + } + }); + }); + it("documents the harness in packages/loopover-miner/docs/cross-repo-evaluation.md", () => { const doc = readFileSync(join(process.cwd(), "packages/loopover-miner/docs/cross-repo-evaluation.md"), "utf8"); expect(doc).toContain("#4788"); expect(doc).toContain("stack_detection_gap"); expect(doc).toContain("cross-repo-evaluation.mjs"); expect(doc).toContain("benchmarks/cross-repo/manifest.json"); + // #7634: the full-execution mode and its execution-specific failure categories are documented too. + expect(doc).toContain("--full-execution"); + expect(doc).toContain("noop_diff"); + expect(doc).toContain("dry-run"); }); });