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"); }); });