diff --git a/packages/loopover-miner/docs/cross-repo-evaluation.md b/packages/loopover-miner/docs/cross-repo-evaluation.md index cc36444b74..a063e99fd1 100644 --- a/packages/loopover-miner/docs/cross-repo-evaluation.md +++ b/packages/loopover-miner/docs/cross-repo-evaluation.md @@ -60,6 +60,35 @@ fleet run-manifest). - `--repo owner/repo` — evaluate a single manifest entry - `--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` — **dry-run** execution mode (#7634): clone each repo, run the + discover→plan→code→test loop locally, and run the target repo's own tests. See below. + +## Full execution mode (dry-run) (#7634) + +`--full-execution` opts into a **dry-run** that goes one step past readiness: for every repo that already passes the +readiness gate above, it actually runs the discover→plan→code→test loop **locally** and reports pass/fail with +execution-specific categories. It is strictly **read/execute-locally-and-discard**: + +1. **Clone / checkout** the repo locally (via `ensureRepoCloned`; a read-only local clone — never a write-back) +2. **Plan** — recompose the same (leak-free) coding-task spec used by readiness +3. **Code** — run the coding agent to produce a diff (the default is a **non-spawning shadow** that produces no + diff and uses no credentials; inject `runCodingAgent` to drive a real/fake agent) +4. **Test** — run the **target repo's own** inferred test command locally against the produced change + +The execution-specific failure categories extend (never replace) the readiness taxonomy: + +| Category | Meaning | +| --- | --- | +| `exec_setup_gap` | Clone / checkout of the target repo failed before the loop could start | +| `plan_compile_gap` | Plan formed but the code phase did not produce a compiling change | +| `test_failure` | Change compiled but the target repo's own tests failed (or timed out) | +| `no_op_diff` | Tests passed but the coding agent produced an empty (no-op) diff | + +The report gains one line, `dry-run full-execution: N/total entered the code+test loop`, and the readiness format is +otherwise unchanged. **Dry-run safety is structural:** there is no PR-open / forge-write / credential path anywhere +in the execution loop — the clone, coding-agent, and test-run steps are all injectable seams (`cloneRepo`, +`runCodingAgent`, `runTests`) that unit tests replace with fakes for zero real IO. No `gh pr create`, no forge API, +no third-party write ever runs. ## Library API @@ -68,11 +97,17 @@ Pure functions live in [`lib/cross-repo-evaluation.js`](../lib/cross-repo-evalua - `parseCrossRepoEvaluationManifest(content)` - `evaluateRepoReadiness(entry, options)` — inject `existsSync`, `detectRepoStack`, etc. for unit tests - `runCrossRepoEvaluation(parsed, options)` +- `evaluateRepoExecution(entry, options)` — dry-run full-execution (#7634); inject `cloneRepo`, `runCodingAgent`, + `runTests` for unit tests +- `runCrossRepoExecution(parsed, options)` — full-execution across a parsed manifest - `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). +By default 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. `--full-execution` opts into a live-ish **dry-run** that additionally clones, runs the coding agent, and runs +the target repo's own tests locally — but still **never opens a PR or writes to the third-party repo**; a real +attempt that submits a PR 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..d7aaa313d9 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts @@ -1,11 +1,19 @@ import type { RepoStackResult } from "./stack-detection.js"; -/** Failure taxonomy surfaced in per-repo reports (#4788). */ +/** Failure taxonomy surfaced in per-repo reports (#4788). The first five members are the offline + * readiness taxonomy; the four `EXEC_*`/plan/test/no-op members are the dry-run full-execution taxonomy + * (#7634) surfaced only when the `--full-execution` loop actually clones, runs the agent, and runs the + * target repo's own tests. New members are appended in the same frozen literal so existing members are + * never removed. */ export declare const CROSS_REPO_FAILURE_CATEGORY: Readonly<{ STACK_DETECTION: "stack_detection_gap"; EXECUTION: "execution_gap"; GITTENSOR_ASSUMPTION: "loopover_assumption"; CLONE_SETUP: "clone_setup"; OTHER: "other"; + EXEC_SETUP: "exec_setup_gap"; + PLAN_COMPILE: "plan_compile_gap"; + TEST_FAILURE: "test_failure"; + NO_OP_DIFF: "no_op_diff"; }>; /** Instruction substrings that indicate a POSITIVE loopover/LoopOver CI assumption leaked into the agent prompt. * Lines that explicitly tell the agent *not* to assume these are filtered out before scanning. */ @@ -41,6 +49,11 @@ export type CrossRepoEvaluationResult = { line: string; }>; stack?: RepoStackResult; + /** Full-execution (dry-run) fields (#7634); absent on readiness-only results. */ + executed?: boolean; + changedFiles?: string[]; + testCommand?: string | null; + testExitCode?: number | null; }; export type CrossRepoEvaluationSummary = { total: number; @@ -48,8 +61,38 @@ export type CrossRepoEvaluationSummary = { failed: number; majorityPassed: boolean; withoutLoopoverConfig: number; + /** Repos that entered the dry-run clone+agent+test loop (#7634); 0 for a readiness-only run. */ + executedCount: number; failuresByCategory: Record; }; +/** Result of the dry-run clone/checkout seam (#7634). Mirrors repo-clone's EnsureRepoClonedResult. */ +export type CrossRepoExecutionCloneResult = { + ok: boolean; + repoPath?: string; + error?: string; +}; +/** Context handed to the dry-run coding-agent seam (#7634). */ +export type CrossRepoExecutionAgentContext = { + repoFullName: string; + repoPath: string; + instructions: string; + stack: RepoStackResult; + entry: CrossRepoEvaluationManifestRepo; +}; +/** Result of the dry-run coding-agent seam (#7634): the produced (canned/real) diff surface. */ +export type CrossRepoExecutionAgentResult = { + ok: boolean; + changedFiles?: readonly string[]; + summary?: string; + error?: string; +}; +/** Result of the dry-run target-repo test seam (#7634). Mirrors the executeLocalWrite subprocess shape. */ +export type CrossRepoExecutionTestResult = { + code: number | null; + stdout?: string; + stderr?: string; + timedOut?: boolean; +}; type EvaluateRepoReadinessOptions = { repoPath?: string; resolveRepoPath?: (entry: { @@ -66,6 +109,11 @@ type EvaluateRepoReadinessOptions = { verdict?: string; instructions?: string; }; + fullExecution?: boolean; + testTimeoutMs?: number; + cloneRepo?: (entry: CrossRepoEvaluationManifestRepo, options: EvaluateRepoReadinessOptions) => CrossRepoExecutionCloneResult | Promise; + runCodingAgent?: (context: CrossRepoExecutionAgentContext) => CrossRepoExecutionAgentResult | Promise; + runTests?: (command: string, cwd: string, timeoutMs: number) => CrossRepoExecutionTestResult | Promise; }; /** Canonical `owner/repo` with exactly one slash and safe segments; anything else → null. */ export declare function normalizeCrossRepoFullName(value: unknown): string | null; @@ -86,12 +134,37 @@ export declare function scanPositiveLoopoverAssumptions(text: string): Array<{ * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). */ export declare function evaluateRepoReadiness(entry: CrossRepoEvaluationManifestRepo, options?: EvaluateRepoReadinessOptions): CrossRepoEvaluationResult; +/** 10-minute cap on a target repo's own test suite when the caller does not override `testTimeoutMs` (#7634). */ +export declare const DEFAULT_EXECUTION_TEST_TIMEOUT_MS: number; +/** + * DRY-RUN full-execution evaluation of one benchmark repo (#7634). Reuses the readiness gate unchanged, then -- + * only for a repo that already passes readiness -- runs the discover->plan->code->test loop LOCALLY: + * + * 1. clone/checkout the repo (setup) -> EXEC_SETUP on failure + * 2. reuse the readiness-composed spec (plan) -- no second (side-effecting) buildCodingTaskSpec call + * 3. run the coding agent to produce a diff -> PLAN_COMPILE when the code phase does not converge + * 4. run the target repo's own tests locally -> TEST_FAILURE when the suite is red + * 5. no-op guard -> NO_OP_DIFF when tests pass but the diff is empty + * + * Every side-effecting step (clone, agent, tests) is behind an injectable `options.*` seam so unit tests drive + * the whole loop with fakes and zero real IO. There is deliberately NO PR-open / forge-write / credential path: + * the harness clones and executes locally, then discards. Readiness-mode behavior is untouched. + */ +export declare function evaluateRepoExecution(entry: CrossRepoEvaluationManifestRepo, options?: EvaluateRepoReadinessOptions): Promise; /** * Run the harness across every repo in a parsed manifest (#4788). */ export declare function runCrossRepoEvaluation(parsed: ParsedCrossRepoEvaluationManifest, options?: { repoFilter?: string; } & EvaluateRepoReadinessOptions): CrossRepoEvaluationResult[]; +/** + * DRY-RUN full-execution run across every repo in a parsed manifest (#7634). Sequential (one clone+agent+test + * loop at a time) so the local machine is never hammered. Same options-injection surface as the readiness run, + * plus the clone/agent/test seams. Repos are read/executed-locally-and-discarded; no PR is ever opened. + */ +export declare function runCrossRepoExecution(parsed: ParsedCrossRepoEvaluationManifest, options?: { + repoFilter?: string; +} & EvaluateRepoReadinessOptions): Promise; /** * Reduce per-repo results to pass/fail counts and whether a strict majority passed (#4788). */ diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.js b/packages/loopover-miner/lib/cross-repo-evaluation.js index 995ae19eba..52d92dda62 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.js +++ b/packages/loopover-miner/lib/cross-repo-evaluation.js @@ -3,18 +3,28 @@ // 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 { spawn } from "node:child_process"; import { existsSync } from "node:fs"; import { buildCodingTaskSpec } from "./coding-task-spec.js"; import { resolveMinerGoalSpec } from "./miner-goal-spec.js"; -import { isValidRepoSegment, resolveRepoCloneDir } from "./repo-clone.js"; +import { ensureRepoCloned, isValidRepoSegment, resolveRepoCloneDir } from "./repo-clone.js"; import { detectRepoStack } from "./stack-detection.js"; -/** Failure taxonomy surfaced in per-repo reports (#4788). */ +/** Failure taxonomy surfaced in per-repo reports (#4788). The first five members are the offline + * readiness taxonomy; the four `EXEC_*`/plan/test/no-op members are the dry-run full-execution taxonomy + * (#7634) surfaced only when the `--full-execution` loop actually clones, runs the agent, and runs the + * target repo's own tests. New members are appended in the same frozen literal so existing members are + * never removed. */ export const CROSS_REPO_FAILURE_CATEGORY = Object.freeze({ STACK_DETECTION: "stack_detection_gap", EXECUTION: "execution_gap", GITTENSOR_ASSUMPTION: "loopover_assumption", CLONE_SETUP: "clone_setup", OTHER: "other", + // Dry-run full-execution taxonomy (#7634): + EXEC_SETUP: "exec_setup_gap", // clone / checkout of the target repo failed before the loop could start + PLAN_COMPILE: "plan_compile_gap", // plan formed but the code phase did not produce a compiling change + TEST_FAILURE: "test_failure", // change compiled but the target repo's own tests failed + NO_OP_DIFF: "no_op_diff", // tests passed but the coding agent produced an empty (no-op) diff }); /** Instruction substrings that indicate a POSITIVE loopover/LoopOver CI assumption leaked into the agent prompt. * Lines that explicitly tell the agent *not* to assume these are filtered out before scanning. */ @@ -216,13 +226,42 @@ function resolveEvaluationRepoPath(entry, options = {}) { function defaultClaimLedger(repoFullName) { return { listClaims: () => [] }; } +function describeError(error) { + return error instanceof Error ? error.message : String(error); +} /** - * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). + * Compose the synthetic coding-task spec both the readiness gate and the full-execution loop use (#4788 / #7634). + * Shared so the "plan" (spec instructions) is derived identically in both modes -- readiness validates it is + * leak-free; full-execution reuses it as the agent's plan. */ -export function evaluateRepoReadiness(entry, options = {}) { +function composeCrossRepoEvaluationSpec(repoFullName, repoPath, buildSpecImpl, detectImpl) { + return 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, + }); +} +/** + * Readiness core (#4788 / #7634). Identical logic to {@link evaluateRepoReadiness} but also returns the plan + * instructions from the SINGLE `buildCodingTaskSpec` call, so the full-execution loop never re-invokes that + * (production `buildCodingTaskSpec` is side-effecting -- it writes acceptance-criteria.json -- and not idempotent). + */ +function evaluateRepoReadinessCore(entry, options = {}) { const repoFullName = entry?.repoFullName; if (typeof repoFullName !== "string" || !normalizeCrossRepoFullName(repoFullName)) { - return buildFailure(typeof repoFullName === "string" ? repoFullName : "(invalid)", CROSS_REPO_FAILURE_CATEGORY.OTHER, "Benchmark entry is missing a valid owner/repo name."); + return { + result: buildFailure(typeof repoFullName === "string" ? repoFullName : "(invalid)", CROSS_REPO_FAILURE_CATEGORY.OTHER, "Benchmark entry is missing a valid owner/repo name."), + instructions: "", + repoPath: "", + }; } const existsImpl = options.existsSync ?? existsSync; const detectImpl = options.detectRepoStack ?? detectRepoStack; @@ -231,49 +270,248 @@ export function evaluateRepoReadiness(entry, options = {}) { buildCodingTaskSpec; const repoPath = resolveEvaluationRepoPath(entry, options); if (!existsImpl(repoPath)) { - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP, `Repository path does not exist: ${repoPath}. Clone the repo or set LOOPOVER_MINER_REPO_CLONE_DIR.`); + return { + result: buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP, `Repository path does not exist: ${repoPath}. Clone the repo or set LOOPOVER_MINER_REPO_CLONE_DIR.`), + instructions: "", + repoPath, + }; } const goalSpec = goalSpecImpl(repoPath); const usedDefaultGoalSpec = goalSpec?.present !== true; const stack = detectImpl(repoPath); if (stack?.detected !== true) { - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.STACK_DETECTION, stack?.reason ?? "Stack auto-detection did not recognize this repository.", { stackDetected: false, usedDefaultGoalSpec }); + return { + result: buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.STACK_DETECTION, stack?.reason ?? "Stack auto-detection did not recognize this repository.", { stackDetected: false, usedDefaultGoalSpec }), + instructions: "", + repoPath, + }; } if (entry.requireTestCommand === true && !stack.testCommand) { - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION, "Stack detection succeeded but no test command was inferred while requireTestCommand is set.", { stackDetected: true, usedDefaultGoalSpec, stack }); + return { + result: buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION, "Stack detection succeeded but no test command was inferred while requireTestCommand is set.", { stackDetected: true, usedDefaultGoalSpec, stack }), + instructions: "", + repoPath, + }; } 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 = composeCrossRepoEvaluationSpec(repoFullName, repoPath, buildSpecImpl, detectImpl); } catch (error) { - const message = error instanceof Error ? error.message : String(error); - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, message, { - stackDetected: true, - usedDefaultGoalSpec, - stack, - }); + return { + result: buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), { + stackDetected: true, + usedDefaultGoalSpec, + stack, + }), + instructions: "", + repoPath, + }; } if (specResult?.ready !== true) { - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION, `Coding task spec is not ready (verdict: ${specResult?.verdict ?? "unknown"}).`, { stackDetected: true, usedDefaultGoalSpec, stack }); + return { + result: buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION, `Coding task spec is not ready (verdict: ${specResult?.verdict ?? "unknown"}).`, { stackDetected: true, usedDefaultGoalSpec, stack }), + instructions: "", + repoPath, + }; } const assumptionFindings = scanPositiveLoopoverAssumptions(specResult.instructions ?? ""); if (assumptionFindings.length > 0) { - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.GITTENSOR_ASSUMPTION, `Agent instructions leak loopover-specific assumptions (${assumptionFindings.map((f) => f.id).join(", ")}).`, { stackDetected: true, usedDefaultGoalSpec, stack, assumptionFindings }); + return { + result: buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.GITTENSOR_ASSUMPTION, `Agent instructions leak loopover-specific assumptions (${assumptionFindings.map((f) => f.id).join(", ")}).`, { stackDetected: true, usedDefaultGoalSpec, stack, assumptionFindings }), + instructions: "", + repoPath, + }; } - return buildPass(repoFullName, { usedDefaultGoalSpec, stack }); + return { + result: buildPass(repoFullName, { usedDefaultGoalSpec, stack }), + instructions: specResult.instructions ?? "", + repoPath, + }; +} +/** + * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). + */ +export function evaluateRepoReadiness(entry, options = {}) { + return evaluateRepoReadinessCore(entry, options).result; +} +/** 10-minute cap on a target repo's own test suite when the caller does not override `testTimeoutMs` (#7634). */ +export const DEFAULT_EXECUTION_TEST_TIMEOUT_MS = 600_000; +/** + * Default clone seam (#7634): a read-only local clone/checkout. When the working copy is already on disk (the + * normal case -- readiness resolves the same path via entry.fixturePath / options.repoPath / the clone cache and + * has already gated its existence), it is reused directly with NO network. Otherwise it falls back to repo-clone's + * ensureRepoCloned. Either way it never writes back to the third-party repo and never opens a PR -- it is the + * "local clone" the dry-run permits. + */ +async function defaultCloneRepo(entry, options) { + const existsImpl = options.existsSync ?? existsSync; + const localPath = resolveEvaluationRepoPath(entry, options); + if (localPath && existsImpl(localPath)) { + return { ok: true, repoPath: localPath }; + } + const result = await ensureRepoCloned(entry.repoFullName, { + env: (options.env ?? process.env), + }); + const out = { ok: result.ok, repoPath: result.repoPath }; + if (result.error !== undefined) + out.error = result.error; + return out; +} +/** + * Default coding-agent seam (#7634): a DRY-RUN SHADOW that never spawns a coding agent, never forwards + * credentials, and produces no diff. A real diff is produced only when a caller injects options.runCodingAgent + * (unit tests inject a fake CodingAgentDriver-shaped runner; a future live mode would inject the real driver). + */ +function defaultRunCodingAgent(_context) { + return { + ok: true, + changedFiles: [], + summary: "dry-run: coding agent not executed (shadow); inject options.runCodingAgent to produce a diff.", + }; +} +/** + * Default test seam (#7634): run the TARGET repo's own inferred test command locally via `sh -c`, mirroring the + * executeLocalWrite subprocess wrapper (resolve-not-reject; SIGKILL on timeout). Purely local; no network. + */ +function defaultRunTests(command, cwd, timeoutMs) { + return new Promise((resolve) => { + let stdout = ""; + let stderr = ""; + let timedOut = false; + let child; + try { + child = spawn("sh", ["-c", command], { cwd }); + } + catch (error) { + resolve({ code: null, stdout, stderr: describeError(error), timedOut }); + return; + } + const timer = setTimeout(() => { + timedOut = true; + child.kill("SIGKILL"); + }, timeoutMs); + child.stdout?.on("data", (chunk) => { + stdout += String(chunk); + }); + child.stderr?.on("data", (chunk) => { + stderr += String(chunk); + }); + child.on("error", (error) => { + clearTimeout(timer); + resolve({ code: null, stdout, stderr: `${stderr}${describeError(error)}`, timedOut }); + }); + child.on("close", (code) => { + clearTimeout(timer); + resolve({ code, stdout, stderr, timedOut }); + }); + }); +} +/** + * DRY-RUN full-execution evaluation of one benchmark repo (#7634). Reuses the readiness gate unchanged, then -- + * only for a repo that already passes readiness -- runs the discover->plan->code->test loop LOCALLY: + * + * 1. clone/checkout the repo (setup) -> EXEC_SETUP on failure + * 2. reuse the readiness-composed spec (plan) -- no second (side-effecting) buildCodingTaskSpec call + * 3. run the coding agent to produce a diff -> PLAN_COMPILE when the code phase does not converge + * 4. run the target repo's own tests locally -> TEST_FAILURE when the suite is red + * 5. no-op guard -> NO_OP_DIFF when tests pass but the diff is empty + * + * Every side-effecting step (clone, agent, tests) is behind an injectable `options.*` seam so unit tests drive + * the whole loop with fakes and zero real IO. There is deliberately NO PR-open / forge-write / credential path: + * the harness clones and executes locally, then discards. Readiness-mode behavior is untouched. + */ +export async function evaluateRepoExecution(entry, options = {}) { + // Step 2 (plan) is folded into the readiness gate: the plan instructions come from readiness's SINGLE + // buildCodingTaskSpec call (production buildCodingTaskSpec is side-effecting + non-idempotent, so we must + // never call it twice). + const readiness = evaluateRepoReadinessCore(entry, options); + if (!readiness.result.passed) + return readiness.result; + const repoFullName = readiness.result.repoFullName; + const usedDefaultGoalSpec = readiness.result.usedDefaultGoalSpec; + const instructions = readiness.instructions; + const stack = readiness.result.stack; + if (!stack || stack.detected !== true) { + // Defensive: a passing readiness always carries a detected stack. Guards type-narrowing + robustness. + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, "Readiness passed without a detected stack.", { + stackDetected: false, + usedDefaultGoalSpec, + executed: true, + }); + } + const cloneImpl = options.cloneRepo ?? defaultCloneRepo; + const agentImpl = options.runCodingAgent ?? defaultRunCodingAgent; + const testImpl = options.runTests ?? defaultRunTests; + const testTimeoutMs = typeof options.testTimeoutMs === "number" && options.testTimeoutMs > 0 + ? options.testTimeoutMs + : DEFAULT_EXECUTION_TEST_TIMEOUT_MS; + const execExtra = { + stackDetected: true, + usedDefaultGoalSpec, + stack, + executed: true, + }; + // Step 1 (setup): clone/checkout the target repo locally. Read-only -- never writes back upstream. + let clone; + try { + clone = await cloneImpl(entry, options); + } + catch (error) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXEC_SETUP, describeError(error), execExtra); + } + if (clone?.ok !== true) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXEC_SETUP, clone?.error ?? "Repository clone/checkout failed before the execution loop could start.", execExtra); + } + const workingDirectory = typeof clone.repoPath === "string" && clone.repoPath.trim() + ? clone.repoPath.trim() + : readiness.repoPath || resolveEvaluationRepoPath(entry, options); + // Step 3 (code): run the coding agent to produce a diff. Default is a non-spawning shadow (dry-run). + let agentResult; + try { + agentResult = await agentImpl({ repoFullName, repoPath: workingDirectory, instructions, stack, entry }); + } + catch (error) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), execExtra); + } + if (agentResult?.ok !== true) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.PLAN_COMPILE, agentResult?.error ?? "Coding agent formed a plan but the code phase did not produce a compiling change.", execExtra); + } + const changedFiles = Array.isArray(agentResult.changedFiles) ? [...agentResult.changedFiles] : []; + // Step 4 (test): run the TARGET repo's own test suite locally against the produced change. + const testCommand = stack.testCommand; + const withDiff = { + ...execExtra, + changedFiles, + testCommand: testCommand ?? null, + }; + if (typeof testCommand === "string" && testCommand.trim()) { + let testResult; + try { + testResult = await testImpl(testCommand, workingDirectory, testTimeoutMs); + } + catch (error) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), withDiff); + } + const exitCode = testResult?.code ?? null; + const withExit = { ...withDiff, testExitCode: exitCode }; + if (testResult?.timedOut === true) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.TEST_FAILURE, `Target repo test command timed out after ${testTimeoutMs}ms: ${testCommand}.`, withExit); + } + if (exitCode !== 0) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.TEST_FAILURE, `Target repo test command exited ${exitCode ?? "null"} (${testCommand}).`, withExit); + } + // Step 5 (no-op guard): tests are green but the agent changed nothing -> a vacuous fix. + if (changedFiles.length === 0) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.NO_OP_DIFF, "Target repo tests passed but the coding agent produced an empty diff (no-op change).", withExit); + } + return buildPass(repoFullName, withExit); + } + // No inferred test command (only reachable when requireTestCommand is not set): still guard the no-op diff. + if (changedFiles.length === 0) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.NO_OP_DIFF, "Coding agent produced an empty diff (no-op change) and no test command was available to verify a fix.", withDiff); + } + return buildPass(repoFullName, { ...withDiff, testExitCode: null }); } /** * Run the harness across every repo in a parsed manifest (#4788). @@ -288,6 +526,21 @@ export function runCrossRepoEvaluation(parsed, options = {}) { } return results; } +/** + * DRY-RUN full-execution run across every repo in a parsed manifest (#7634). Sequential (one clone+agent+test + * loop at a time) so the local machine is never hammered. Same options-injection surface as the readiness run, + * plus the clone/agent/test seams. Repos are read/executed-locally-and-discarded; no PR is ever opened. + */ +export async function runCrossRepoExecution(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; +} /** * Reduce per-repo results to pass/fail counts and whether a strict majority passed (#4788). */ @@ -308,12 +561,14 @@ export function summarizeCrossRepoEvaluation(results) { const total = passed + failed; const majorityPassed = total > 0 ? passed > failed : false; const withoutLoopoverConfig = list.filter((r) => r?.usedDefaultGoalSpec !== false).length; + const executedCount = list.filter((r) => r?.executed === true).length; return { total, passed, failed, majorityPassed, withoutLoopoverConfig, + executedCount, failuresByCategory, }; } @@ -334,6 +589,11 @@ export function formatCrossRepoEvaluationReport(results, summary = summarizeCros if (summary.total > 0) { lines.push(`without loopover-specific target config: ${summary.withoutLoopoverConfig}/${summary.total}`); } + // Dry-run full-execution runs surface how many repos actually entered the clone+agent+test loop (#7634). + // Readiness-only runs never set `executed`, so this line is omitted and the readiness format is unchanged. + if (summary.executedCount > 0) { + lines.push(`dry-run full-execution: ${summary.executedCount}/${summary.total} entered the code+test loop`); + } const categories = Object.entries(summary.failuresByCategory).sort(([a], [b]) => a.localeCompare(b)); if (categories.length > 0) { lines.push("", "failures by category:"); @@ -343,4 +603,4 @@ 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 +//# 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..f2eeb67517 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.ts @@ -4,27 +4,41 @@ // 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 { spawn } from "node:child_process"; import { existsSync } from "node:fs"; import { join } from "node:path"; import { buildCodingTaskSpec } from "./coding-task-spec.js"; import { resolveMinerGoalSpec } from "./miner-goal-spec.js"; -import { isValidRepoSegment, resolveRepoCloneDir } from "./repo-clone.js"; +import { ensureRepoCloned, isValidRepoSegment, resolveRepoCloneDir } from "./repo-clone.js"; import { detectRepoStack } from "./stack-detection.js"; import type { RepoStackResult } from "./stack-detection.js"; -/** Failure taxonomy surfaced in per-repo reports (#4788). */ +/** Failure taxonomy surfaced in per-repo reports (#4788). The first five members are the offline + * readiness taxonomy; the four `EXEC_*`/plan/test/no-op members are the dry-run full-execution taxonomy + * (#7634) surfaced only when the `--full-execution` loop actually clones, runs the agent, and runs the + * target repo's own tests. New members are appended in the same frozen literal so existing members are + * never removed. */ export const CROSS_REPO_FAILURE_CATEGORY: Readonly<{ STACK_DETECTION: "stack_detection_gap"; EXECUTION: "execution_gap"; GITTENSOR_ASSUMPTION: "loopover_assumption"; CLONE_SETUP: "clone_setup"; OTHER: "other"; + EXEC_SETUP: "exec_setup_gap"; + PLAN_COMPILE: "plan_compile_gap"; + TEST_FAILURE: "test_failure"; + NO_OP_DIFF: "no_op_diff"; }> = Object.freeze({ STACK_DETECTION: "stack_detection_gap", EXECUTION: "execution_gap", GITTENSOR_ASSUMPTION: "loopover_assumption", CLONE_SETUP: "clone_setup", OTHER: "other", + // Dry-run full-execution taxonomy (#7634): + EXEC_SETUP: "exec_setup_gap", // clone / checkout of the target repo failed before the loop could start + PLAN_COMPILE: "plan_compile_gap", // plan formed but the code phase did not produce a compiling change + TEST_FAILURE: "test_failure", // change compiled but the target repo's own tests failed + NO_OP_DIFF: "no_op_diff", // tests passed but the coding agent produced an empty (no-op) diff }); /** Instruction substrings that indicate a POSITIVE loopover/LoopOver CI assumption leaked into the agent prompt. @@ -62,6 +76,11 @@ export type CrossRepoEvaluationResult = { usedDefaultGoalSpec: boolean | null; assumptionFindings: Array<{ id: string; line: string }>; stack?: RepoStackResult; + /** Full-execution (dry-run) fields (#7634); absent on readiness-only results. */ + executed?: boolean; + changedFiles?: string[]; + testCommand?: string | null; + testExitCode?: number | null; }; export type CrossRepoEvaluationSummary = { @@ -70,9 +89,43 @@ export type CrossRepoEvaluationSummary = { failed: number; majorityPassed: boolean; withoutLoopoverConfig: number; + /** Repos that entered the dry-run clone+agent+test loop (#7634); 0 for a readiness-only run. */ + executedCount: number; failuresByCategory: Record; }; +/** Result of the dry-run clone/checkout seam (#7634). Mirrors repo-clone's EnsureRepoClonedResult. */ +export type CrossRepoExecutionCloneResult = { + ok: boolean; + repoPath?: string; + error?: string; +}; + +/** Context handed to the dry-run coding-agent seam (#7634). */ +export type CrossRepoExecutionAgentContext = { + repoFullName: string; + repoPath: string; + instructions: string; + stack: RepoStackResult; + entry: CrossRepoEvaluationManifestRepo; +}; + +/** Result of the dry-run coding-agent seam (#7634): the produced (canned/real) diff surface. */ +export type CrossRepoExecutionAgentResult = { + ok: boolean; + changedFiles?: readonly string[]; + summary?: string; + error?: string; +}; + +/** Result of the dry-run target-repo test seam (#7634). Mirrors the executeLocalWrite subprocess shape. */ +export type CrossRepoExecutionTestResult = { + code: number | null; + stdout?: string; + stderr?: string; + timedOut?: boolean; +}; + type EvaluateRepoReadinessOptions = { repoPath?: string; resolveRepoPath?: (entry: { repoFullName: string }) => string; @@ -85,6 +138,23 @@ type EvaluateRepoReadinessOptions = { verdict?: string; instructions?: string; }; + // Full-execution (dry-run) seams (#7634). Every one is defaulted with `?? realImpl` exactly like the + // readiness seams above, so unit tests drive the whole loop with fakes and zero real IO. There is NO + // PR-open / forge-write / credential path anywhere in the execution loop -- the boundary is structural. + fullExecution?: boolean; + testTimeoutMs?: number; + cloneRepo?: ( + entry: CrossRepoEvaluationManifestRepo, + options: EvaluateRepoReadinessOptions, + ) => CrossRepoExecutionCloneResult | Promise; + runCodingAgent?: ( + context: CrossRepoExecutionAgentContext, + ) => CrossRepoExecutionAgentResult | Promise; + runTests?: ( + command: string, + cwd: string, + timeoutMs: number, + ) => CrossRepoExecutionTestResult | Promise; }; // True UTF-8 byte count for the size guard (#7223): JS string `.length` is UTF-16 code units, which under-counts @@ -276,20 +346,65 @@ function defaultClaimLedger(repoFullName: string): { listClaims: () => never[] } return { listClaims: () => [] }; } +function describeError(error: unknown): string { + return error instanceof Error ? error.message : String(error); +} + /** - * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). + * Compose the synthetic coding-task spec both the readiness gate and the full-execution loop use (#4788 / #7634). + * Shared so the "plan" (spec instructions) is derived identically in both modes -- readiness validates it is + * leak-free; full-execution reuses it as the agent's plan. */ -export function evaluateRepoReadiness( +function composeCrossRepoEvaluationSpec( + repoFullName: string, + repoPath: string, + buildSpecImpl: NonNullable, + detectImpl: (repoPath: string) => RepoStackResult, +): { ready: boolean; verdict?: string; instructions?: string } { + return 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, + }); +} + +/** Internal readiness evaluation carrying the single composed spec so full-execution can reuse it (#7634). */ +type ReadinessEvaluation = { + result: CrossRepoEvaluationResult; + /** The composed coding-task plan/instructions when the repo passed readiness; "" otherwise. */ + instructions: string; + /** The local working-copy path readiness resolved (may be unusable on an early failure). */ + repoPath: string; +}; + +/** + * Readiness core (#4788 / #7634). Identical logic to {@link evaluateRepoReadiness} but also returns the plan + * instructions from the SINGLE `buildCodingTaskSpec` call, so the full-execution loop never re-invokes that + * (production `buildCodingTaskSpec` is side-effecting -- it writes acceptance-criteria.json -- and not idempotent). + */ +function evaluateRepoReadinessCore( entry: CrossRepoEvaluationManifestRepo, options: EvaluateRepoReadinessOptions = {}, -): CrossRepoEvaluationResult { +): ReadinessEvaluation { const repoFullName = entry?.repoFullName; if (typeof repoFullName !== "string" || !normalizeCrossRepoFullName(repoFullName)) { - return buildFailure( - typeof repoFullName === "string" ? repoFullName : "(invalid)", - CROSS_REPO_FAILURE_CATEGORY.OTHER, - "Benchmark entry is missing a valid owner/repo name.", - ); + return { + result: buildFailure( + typeof repoFullName === "string" ? repoFullName : "(invalid)", + CROSS_REPO_FAILURE_CATEGORY.OTHER, + "Benchmark entry is missing a valid owner/repo name.", + ), + instructions: "", + repoPath: "", + }; } const existsImpl = options.existsSync ?? existsSync; @@ -301,11 +416,15 @@ export function evaluateRepoReadiness( const repoPath = resolveEvaluationRepoPath(entry, options); if (!existsImpl(repoPath)) { - return buildFailure( - repoFullName, - CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP, - `Repository path does not exist: ${repoPath}. Clone the repo or set LOOPOVER_MINER_REPO_CLONE_DIR.`, - ); + return { + result: buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP, + `Repository path does not exist: ${repoPath}. Clone the repo or set LOOPOVER_MINER_REPO_CLONE_DIR.`, + ), + instructions: "", + repoPath, + }; } const goalSpec = goalSpecImpl(repoPath); @@ -313,67 +432,310 @@ export function evaluateRepoReadiness( const stack = detectImpl(repoPath); if (stack?.detected !== true) { - return buildFailure( - repoFullName, - CROSS_REPO_FAILURE_CATEGORY.STACK_DETECTION, - stack?.reason ?? "Stack auto-detection did not recognize this repository.", - { stackDetected: false, usedDefaultGoalSpec }, - ); + return { + result: buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.STACK_DETECTION, + stack?.reason ?? "Stack auto-detection did not recognize this repository.", + { stackDetected: false, usedDefaultGoalSpec }, + ), + instructions: "", + repoPath, + }; } if (entry.requireTestCommand === true && !stack.testCommand) { - return buildFailure( - repoFullName, - CROSS_REPO_FAILURE_CATEGORY.EXECUTION, - "Stack detection succeeded but no test command was inferred while requireTestCommand is set.", - { stackDetected: true, usedDefaultGoalSpec, stack }, - ); + return { + result: buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION, + "Stack detection succeeded but no test command was inferred while requireTestCommand is set.", + { stackDetected: true, usedDefaultGoalSpec, stack }, + ), + instructions: "", + repoPath, + }; } 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 = composeCrossRepoEvaluationSpec(repoFullName, repoPath, buildSpecImpl, detectImpl); } catch (error) { - const message = error instanceof Error ? error.message : String(error); - return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, message, { - stackDetected: true, + return { + result: buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), { + stackDetected: true, + usedDefaultGoalSpec, + stack, + }), + instructions: "", + repoPath, + }; + } + + if (specResult?.ready !== true) { + return { + result: buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION, + `Coding task spec is not ready (verdict: ${specResult?.verdict ?? "unknown"}).`, + { stackDetected: true, usedDefaultGoalSpec, stack }, + ), + instructions: "", + repoPath, + }; + } + + const assumptionFindings = scanPositiveLoopoverAssumptions(specResult.instructions ?? ""); + if (assumptionFindings.length > 0) { + return { + result: buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.GITTENSOR_ASSUMPTION, + `Agent instructions leak loopover-specific assumptions (${assumptionFindings.map((f) => f.id).join(", ")}).`, + { stackDetected: true, usedDefaultGoalSpec, stack, assumptionFindings }, + ), + instructions: "", + repoPath, + }; + } + + return { + result: buildPass(repoFullName, { usedDefaultGoalSpec, stack }), + instructions: specResult.instructions ?? "", + repoPath, + }; +} + +/** + * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). + */ +export function evaluateRepoReadiness( + entry: CrossRepoEvaluationManifestRepo, + options: EvaluateRepoReadinessOptions = {}, +): CrossRepoEvaluationResult { + return evaluateRepoReadinessCore(entry, options).result; +} + +/** 10-minute cap on a target repo's own test suite when the caller does not override `testTimeoutMs` (#7634). */ +export const DEFAULT_EXECUTION_TEST_TIMEOUT_MS: number = 600_000; + +/** + * Default clone seam (#7634): a read-only local clone/checkout. When the working copy is already on disk (the + * normal case -- readiness resolves the same path via entry.fixturePath / options.repoPath / the clone cache and + * has already gated its existence), it is reused directly with NO network. Otherwise it falls back to repo-clone's + * ensureRepoCloned. Either way it never writes back to the third-party repo and never opens a PR -- it is the + * "local clone" the dry-run permits. + */ +async function defaultCloneRepo( + entry: CrossRepoEvaluationManifestRepo, + options: EvaluateRepoReadinessOptions, +): Promise { + const existsImpl = options.existsSync ?? existsSync; + const localPath = resolveEvaluationRepoPath(entry, options); + if (localPath && existsImpl(localPath)) { + return { ok: true, repoPath: localPath }; + } + const result = await ensureRepoCloned(entry.repoFullName, { + env: (options.env ?? process.env) as Record, + }); + const out: CrossRepoExecutionCloneResult = { ok: result.ok, repoPath: result.repoPath }; + if (result.error !== undefined) out.error = result.error; + return out; +} + +/** + * Default coding-agent seam (#7634): a DRY-RUN SHADOW that never spawns a coding agent, never forwards + * credentials, and produces no diff. A real diff is produced only when a caller injects options.runCodingAgent + * (unit tests inject a fake CodingAgentDriver-shaped runner; a future live mode would inject the real driver). + */ +function defaultRunCodingAgent(_context: CrossRepoExecutionAgentContext): CrossRepoExecutionAgentResult { + return { + ok: true, + changedFiles: [], + summary: "dry-run: coding agent not executed (shadow); inject options.runCodingAgent to produce a diff.", + }; +} + +/** + * Default test seam (#7634): run the TARGET repo's own inferred test command locally via `sh -c`, mirroring the + * executeLocalWrite subprocess wrapper (resolve-not-reject; SIGKILL on timeout). Purely local; no network. + */ +function defaultRunTests(command: string, cwd: string, timeoutMs: number): Promise { + return new Promise((resolve) => { + let stdout = ""; + let stderr = ""; + let timedOut = false; + let child; + try { + child = spawn("sh", ["-c", command], { cwd }); + } catch (error) { + resolve({ code: null, stdout, stderr: describeError(error), timedOut }); + return; + } + const timer = setTimeout(() => { + timedOut = true; + child.kill("SIGKILL"); + }, timeoutMs); + child.stdout?.on("data", (chunk) => { + stdout += String(chunk); + }); + child.stderr?.on("data", (chunk) => { + stderr += String(chunk); + }); + child.on("error", (error) => { + clearTimeout(timer); + resolve({ code: null, stdout, stderr: `${stderr}${describeError(error)}`, timedOut }); + }); + child.on("close", (code) => { + clearTimeout(timer); + resolve({ code, stdout, stderr, timedOut }); + }); + }); +} + +/** + * DRY-RUN full-execution evaluation of one benchmark repo (#7634). Reuses the readiness gate unchanged, then -- + * only for a repo that already passes readiness -- runs the discover->plan->code->test loop LOCALLY: + * + * 1. clone/checkout the repo (setup) -> EXEC_SETUP on failure + * 2. reuse the readiness-composed spec (plan) -- no second (side-effecting) buildCodingTaskSpec call + * 3. run the coding agent to produce a diff -> PLAN_COMPILE when the code phase does not converge + * 4. run the target repo's own tests locally -> TEST_FAILURE when the suite is red + * 5. no-op guard -> NO_OP_DIFF when tests pass but the diff is empty + * + * Every side-effecting step (clone, agent, tests) is behind an injectable `options.*` seam so unit tests drive + * the whole loop with fakes and zero real IO. There is deliberately NO PR-open / forge-write / credential path: + * the harness clones and executes locally, then discards. Readiness-mode behavior is untouched. + */ +export async function evaluateRepoExecution( + entry: CrossRepoEvaluationManifestRepo, + options: EvaluateRepoReadinessOptions = {}, +): Promise { + // Step 2 (plan) is folded into the readiness gate: the plan instructions come from readiness's SINGLE + // buildCodingTaskSpec call (production buildCodingTaskSpec is side-effecting + non-idempotent, so we must + // never call it twice). + const readiness = evaluateRepoReadinessCore(entry, options); + if (!readiness.result.passed) return readiness.result; + + const repoFullName = readiness.result.repoFullName; + const usedDefaultGoalSpec = readiness.result.usedDefaultGoalSpec; + const instructions = readiness.instructions; + const stack = readiness.result.stack; + if (!stack || stack.detected !== true) { + // Defensive: a passing readiness always carries a detected stack. Guards type-narrowing + robustness. + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, "Readiness passed without a detected stack.", { + stackDetected: false, usedDefaultGoalSpec, - stack, + executed: true, }); } - if (specResult?.ready !== true) { + const cloneImpl = options.cloneRepo ?? defaultCloneRepo; + const agentImpl = options.runCodingAgent ?? defaultRunCodingAgent; + const testImpl = options.runTests ?? defaultRunTests; + const testTimeoutMs = + typeof options.testTimeoutMs === "number" && options.testTimeoutMs > 0 + ? options.testTimeoutMs + : DEFAULT_EXECUTION_TEST_TIMEOUT_MS; + + const execExtra: Partial = { + stackDetected: true, + usedDefaultGoalSpec, + stack, + executed: true, + }; + + // Step 1 (setup): clone/checkout the target repo locally. Read-only -- never writes back upstream. + let clone: CrossRepoExecutionCloneResult; + try { + clone = await cloneImpl(entry, options); + } catch (error) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXEC_SETUP, describeError(error), execExtra); + } + if (clone?.ok !== true) { return buildFailure( repoFullName, - CROSS_REPO_FAILURE_CATEGORY.EXECUTION, - `Coding task spec is not ready (verdict: ${specResult?.verdict ?? "unknown"}).`, - { stackDetected: true, usedDefaultGoalSpec, stack }, + CROSS_REPO_FAILURE_CATEGORY.EXEC_SETUP, + clone?.error ?? "Repository clone/checkout failed before the execution loop could start.", + execExtra, ); } + const workingDirectory = + typeof clone.repoPath === "string" && clone.repoPath.trim() + ? clone.repoPath.trim() + : readiness.repoPath || resolveEvaluationRepoPath(entry, options); - const assumptionFindings = scanPositiveLoopoverAssumptions(specResult.instructions ?? ""); - if (assumptionFindings.length > 0) { + // Step 3 (code): run the coding agent to produce a diff. Default is a non-spawning shadow (dry-run). + let agentResult: CrossRepoExecutionAgentResult; + try { + agentResult = await agentImpl({ repoFullName, repoPath: workingDirectory, instructions, stack, entry }); + } catch (error) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), execExtra); + } + if (agentResult?.ok !== true) { return buildFailure( repoFullName, - CROSS_REPO_FAILURE_CATEGORY.GITTENSOR_ASSUMPTION, - `Agent instructions leak loopover-specific assumptions (${assumptionFindings.map((f) => f.id).join(", ")}).`, - { stackDetected: true, usedDefaultGoalSpec, stack, assumptionFindings }, + CROSS_REPO_FAILURE_CATEGORY.PLAN_COMPILE, + agentResult?.error ?? "Coding agent formed a plan but the code phase did not produce a compiling change.", + execExtra, ); } + const changedFiles = Array.isArray(agentResult.changedFiles) ? [...agentResult.changedFiles] : []; + + // Step 4 (test): run the TARGET repo's own test suite locally against the produced change. + const testCommand = stack.testCommand; + const withDiff: Partial = { + ...execExtra, + changedFiles, + testCommand: testCommand ?? null, + }; + if (typeof testCommand === "string" && testCommand.trim()) { + let testResult: CrossRepoExecutionTestResult; + try { + testResult = await testImpl(testCommand, workingDirectory, testTimeoutMs); + } catch (error) { + return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, describeError(error), withDiff); + } + const exitCode = testResult?.code ?? null; + const withExit: Partial = { ...withDiff, testExitCode: exitCode }; + if (testResult?.timedOut === true) { + return buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.TEST_FAILURE, + `Target repo test command timed out after ${testTimeoutMs}ms: ${testCommand}.`, + withExit, + ); + } + if (exitCode !== 0) { + return buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.TEST_FAILURE, + `Target repo test command exited ${exitCode ?? "null"} (${testCommand}).`, + withExit, + ); + } + // Step 5 (no-op guard): tests are green but the agent changed nothing -> a vacuous fix. + if (changedFiles.length === 0) { + return buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.NO_OP_DIFF, + "Target repo tests passed but the coding agent produced an empty diff (no-op change).", + withExit, + ); + } + return buildPass(repoFullName, withExit); + } - return buildPass(repoFullName, { usedDefaultGoalSpec, stack }); + // No inferred test command (only reachable when requireTestCommand is not set): still guard the no-op diff. + if (changedFiles.length === 0) { + return buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.NO_OP_DIFF, + "Coding agent produced an empty diff (no-op change) and no test command was available to verify a fix.", + withDiff, + ); + } + return buildPass(repoFullName, { ...withDiff, testExitCode: null }); } /** @@ -392,6 +754,24 @@ export function runCrossRepoEvaluation( return results; } +/** + * DRY-RUN full-execution run across every repo in a parsed manifest (#7634). Sequential (one clone+agent+test + * loop at a time) so the local machine is never hammered. Same options-injection surface as the readiness run, + * plus the clone/agent/test seams. Repos are read/executed-locally-and-discarded; no PR is ever opened. + */ +export async function runCrossRepoExecution( + parsed: ParsedCrossRepoEvaluationManifest, + options: { repoFilter?: string } & EvaluateRepoReadinessOptions = {}, +): Promise { + const repos = parsed?.manifest?.repos ?? []; + const results: CrossRepoEvaluationResult[] = []; + for (const entry of repos) { + if (options.repoFilter && entry.repoFullName !== options.repoFilter) continue; + results.push(await evaluateRepoExecution(entry, options)); + } + return results; +} + /** * Reduce per-repo results to pass/fail counts and whether a strict majority passed (#4788). */ @@ -412,12 +792,14 @@ export function summarizeCrossRepoEvaluation(results: CrossRepoEvaluationResult[ const total = passed + failed; const majorityPassed = total > 0 ? passed > failed : false; const withoutLoopoverConfig = list.filter((r) => r?.usedDefaultGoalSpec !== false).length; + const executedCount = list.filter((r) => r?.executed === true).length; return { total, passed, failed, majorityPassed, withoutLoopoverConfig, + executedCount, failuresByCategory, }; } @@ -445,6 +827,11 @@ export function formatCrossRepoEvaluationReport( if (summary.total > 0) { lines.push(`without loopover-specific target config: ${summary.withoutLoopoverConfig}/${summary.total}`); } + // Dry-run full-execution runs surface how many repos actually entered the clone+agent+test loop (#7634). + // Readiness-only runs never set `executed`, so this line is omitted and the readiness format is unchanged. + if (summary.executedCount > 0) { + lines.push(`dry-run full-execution: ${summary.executedCount}/${summary.total} entered the code+test loop`); + } const categories = Object.entries(summary.failuresByCategory).sort(([a], [b]) => a.localeCompare(b)); if (categories.length > 0) { lines.push("", "failures by category:"); diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts index c263aa2347..b08339b3c0 100644 --- a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts +++ b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts @@ -1,11 +1,22 @@ import type { + CrossRepoEvaluationManifestRepo, CrossRepoEvaluationResult, CrossRepoEvaluationSummary, + CrossRepoExecutionAgentContext, + CrossRepoExecutionAgentResult, + CrossRepoExecutionCloneResult, + CrossRepoExecutionTestResult, 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 }; @@ -15,6 +26,32 @@ export type CrossRepoEvaluationCliOptions = { repoFilter?: string | null; }; +/** Full-execution (dry-run) CLI options (#7634): the readiness options plus the injectable clone/agent/test seams + * that unit tests replace with fakes for zero real IO. */ +export type CrossRepoExecutionCliOptions = CrossRepoEvaluationCliOptions & { + fullExecution?: boolean; + testTimeoutMs?: number; + env?: Record; + existsSync?: (path: string) => boolean; + buildCodingTaskSpec?: (input: Record) => { + ready: boolean; + verdict?: string; + instructions?: string; + }; + cloneRepo?: ( + entry: CrossRepoEvaluationManifestRepo, + options: CrossRepoExecutionCliOptions, + ) => CrossRepoExecutionCloneResult | Promise; + runCodingAgent?: ( + context: CrossRepoExecutionAgentContext, + ) => CrossRepoExecutionAgentResult | Promise; + runTests?: ( + command: string, + cwd: string, + timeoutMs: number, + ) => CrossRepoExecutionTestResult | Promise; +}; + export declare function resolveDefaultManifestPath(): string; export declare function parseCrossRepoEvaluationArgs(argv?: readonly string[]): CrossRepoEvaluationCliArgs; @@ -26,3 +63,11 @@ export declare function runCrossRepoEvaluationCli(options?: CrossRepoEvaluationC results: CrossRepoEvaluationResult[]; summary: CrossRepoEvaluationSummary; }; + +/** DRY-RUN full-execution driver (#7634): clones each benchmark repo locally, runs the discover->plan->code->test + * loop, and runs the target repo's own tests. Async; never opens a PR. */ +export declare function runCrossRepoExecutionCli(options?: CrossRepoExecutionCliOptions): Promise<{ + parsed: ParsedCrossRepoEvaluationManifest; + results: CrossRepoEvaluationResult[]; + summary: CrossRepoEvaluationSummary; +}>; diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.mjs b/packages/loopover-miner/scripts/cross-repo-evaluation.mjs index 04de1d9fa4..1e65c2dee2 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, + runCrossRepoExecution, 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,21 @@ export function runCrossRepoEvaluationCli(options = {}) { return { parsed, results, summary }; } +// DRY-RUN full-execution driver (#7634): clones each benchmark repo locally, runs the discover->plan->code->test +// loop, runs the target repo's own tests, and reports execution-specific categories. Async because the loop +// clones and spawns local subprocesses. Injectable seams (cloneRepo/runCodingAgent/runTests/...) are forwarded +// straight through, so unit tests drive it with fakes and zero real IO. No PR is ever opened. +export async function runCrossRepoExecutionCli(options = {}) { + const parsed = options.parsed ?? loadCrossRepoEvaluationManifest(options.manifestPath ?? resolveDefaultManifestPath()); + const results = await runCrossRepoExecution(parsed, { + ...options, + repoFilter: options.repoFilter ?? null, + fullExecution: true, + }); + const summary = summarizeCrossRepoEvaluation(results); + return { parsed, results, summary }; +} + function printHelp() { console.log( [ @@ -79,6 +100,9 @@ function printHelp() { " --repo Evaluate a single benchmark entry", " --json Emit machine-readable JSON on stdout", " --require-majority Exit 1 unless a strict majority of repos pass", + " --full-execution DRY-RUN: clone each repo, run the discover->plan->code->test loop locally, and", + " run the target repo's own tests (no PR is ever opened). Reports execution", + " categories: exec_setup_gap, plan_compile_gap, test_failure, no_op_diff.", " -h, --help Show this help", "", "Prerequisite: clone benchmark repos into LOOPOVER_MINER_REPO_CLONE_DIR (see docs/cross-repo-evaluation.md).", @@ -86,7 +110,7 @@ function printHelp() { ); } -function main() { +async function main() { const parsedArgs = parseCrossRepoEvaluationArgs(); if (parsedArgs.help) { printHelp(); @@ -97,7 +121,9 @@ function main() { return 2; } - const { parsed, results, summary } = runCrossRepoEvaluationCli(parsedArgs); + const { parsed, results, summary } = parsedArgs.fullExecution + ? await runCrossRepoExecutionCli(parsedArgs) + : runCrossRepoEvaluationCli(parsedArgs); if (parsedArgs.json) { console.log(JSON.stringify({ warnings: parsed.warnings, results, summary }, null, 2)); } else { @@ -112,5 +138,7 @@ function main() { } if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) { - process.exitCode = main(); + main().then((code) => { + process.exitCode = code; + }); } diff --git a/test/unit/miner-cross-repo-evaluation.test.ts b/test/unit/miner-cross-repo-evaluation.test.ts index 1f1de6a21d..e2e60f035a 100644 --- a/test/unit/miner-cross-repo-evaluation.test.ts +++ b/test/unit/miner-cross-repo-evaluation.test.ts @@ -12,10 +12,12 @@ import { DEFAULT_CROSS_REPO_MANIFEST_RELATIVE_PATH, MAX_CROSS_REPO_MANIFEST_BYTES, formatCrossRepoEvaluationReport, + evaluateRepoExecution, evaluateRepoReadiness, normalizeCrossRepoFullName, parseCrossRepoEvaluationManifest, runCrossRepoEvaluation, + runCrossRepoExecution, scanPositiveLoopoverAssumptions, summarizeCrossRepoEvaluation, } from "../../packages/loopover-miner/lib/cross-repo-evaluation.js"; @@ -25,6 +27,7 @@ import { parseCrossRepoEvaluationArgs, resolveDefaultManifestPath, runCrossRepoEvaluationCli, + runCrossRepoExecutionCli, } from "../../packages/loopover-miner/scripts/cross-repo-evaluation.mjs"; const roots: string[] = []; @@ -371,6 +374,204 @@ describe("cross-repo evaluation harness (#4788)", () => { }); }); + describe("evaluateRepoExecution --full-execution (dry-run) (#7634)", () => { + // A node fixture whose real stack detection yields a non-null test command, so readiness passes and the + // execution loop reaches the clone/agent/test steps. + const nodeRepo = () => tempRepo({ "package.json": pkg({ scripts: { test: "node --test" } }) }); + const readySpec = () => ({ ready: true, instructions: "Fix the failing test." }); + + it("returns the readiness failure unchanged when the repo is not even ready (reuses the gate)", async () => { + const result = await evaluateRepoExecution( + { repoFullName: "acme/missing", requireTestCommand: false }, + { repoPath: "/tmp/definitely-missing-repo-path", existsSync: () => false }, + ); + expect(result.passed).toBe(false); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP); + // Readiness-only failure never entered the execution loop. + expect(result.executed).toBeUndefined(); + }); + + it("fails exec_setup_gap when the clone step reports not-ok", async () => { + const repoPath = nodeRepo(); + const result = await evaluateRepoExecution( + { repoFullName: "acme/clone-fail", requireTestCommand: false }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => ({ ok: false, error: "git clone exited 128" }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXEC_SETUP); + expect(result.reason).toContain("128"); + expect(result.executed).toBe(true); + }); + + it("fails exec_setup_gap when the clone step throws", async () => { + const repoPath = nodeRepo(); + const result = await evaluateRepoExecution( + { repoFullName: "acme/clone-throws", requireTestCommand: false }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => { + throw new Error("network down"); + }, + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXEC_SETUP); + expect(result.reason).toBe("network down"); + }); + + it("fails plan_compile_gap when the coding agent does not converge into a compiling change", async () => { + const repoPath = nodeRepo(); + const result = await evaluateRepoExecution( + { repoFullName: "acme/agent-fail", requireTestCommand: false }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => ({ ok: true, repoPath }), + runCodingAgent: () => ({ ok: false, error: "compile error: TS2322" }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.PLAN_COMPILE); + expect(result.reason).toContain("TS2322"); + }); + + it("fails other when the coding agent throws", async () => { + const repoPath = nodeRepo(); + const result = await evaluateRepoExecution( + { repoFullName: "acme/agent-throws", requireTestCommand: false }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => ({ ok: true, repoPath }), + runCodingAgent: () => { + throw new Error("agent-boom"); + }, + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.OTHER); + expect(result.reason).toBe("agent-boom"); + }); + + it("fails test_failure when the target repo's own tests are red", async () => { + const repoPath = nodeRepo(); + let ranCommand: string | null = null; + const result = await evaluateRepoExecution( + { repoFullName: "acme/tests-red", requireTestCommand: true }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => ({ ok: true, repoPath }), + runCodingAgent: () => ({ ok: true, changedFiles: ["src/foo.ts", "src/foo.test.ts"], summary: "guard + test" }), + runTests: (command) => { + ranCommand = command; + return { code: 1, stdout: "", stderr: "1 failing", timedOut: false }; + }, + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.TEST_FAILURE); + expect(result.testExitCode).toBe(1); + expect(ranCommand).toBeTruthy(); // the detected test command was actually handed to the runner + expect(result.changedFiles).toEqual(["src/foo.ts", "src/foo.test.ts"]); + }); + + it("fails test_failure when the target repo's own tests time out", async () => { + const repoPath = nodeRepo(); + const result = await evaluateRepoExecution( + { repoFullName: "acme/tests-timeout", requireTestCommand: true }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => ({ ok: true, repoPath }), + runCodingAgent: () => ({ ok: true, changedFiles: ["src/foo.ts"] }), + runTests: () => ({ code: null, stdout: "", stderr: "", timedOut: true }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.TEST_FAILURE); + expect(result.reason).toContain("timed out"); + }); + + it("fails no_op_diff when tests pass but the agent produced an empty diff", async () => { + const repoPath = nodeRepo(); + const result = await evaluateRepoExecution( + { repoFullName: "acme/no-op", requireTestCommand: true }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => ({ ok: true, repoPath }), + runCodingAgent: () => ({ ok: true, changedFiles: [] }), + runTests: () => ({ code: 0, stdout: "ok", stderr: "", timedOut: false }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.NO_OP_DIFF); + expect(result.testExitCode).toBe(0); + expect(result.changedFiles).toEqual([]); + }); + + it("passes end-to-end when clone, agent, and target tests all succeed with a real diff", async () => { + const repoPath = nodeRepo(); + const result = await evaluateRepoExecution( + { repoFullName: "acme/full-pass", requireTestCommand: true }, + { + repoPath, + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: () => ({ ok: true, repoPath }), + runCodingAgent: () => ({ ok: true, changedFiles: ["src/fix.ts"], summary: "applied fix" }), + runTests: () => ({ code: 0, stdout: "all green", stderr: "", timedOut: false }), + }, + ); + expect(result.passed).toBe(true); + expect(result.executed).toBe(true); + expect(result.changedFiles).toEqual(["src/fix.ts"]); + expect(result.testExitCode).toBe(0); + expect(result.failureCategory).toBeNull(); + }); + + it("runCrossRepoExecution drives every manifest repo through the dry-run loop", async () => { + const repoA = nodeRepo(); + const repoB = nodeRepo(); + const parsed = parseCrossRepoEvaluationManifest( + JSON.stringify({ + repos: [ + { repoFullName: "acme/exec-a", fixturePath: repoA, requireTestCommand: true }, + { repoFullName: "acme/exec-b", fixturePath: repoB, requireTestCommand: true }, + ], + }), + ); + const results = await runCrossRepoExecution(parsed, { + existsSync: () => true, + buildCodingTaskSpec: readySpec, + cloneRepo: (entry) => ({ ok: true, repoPath: entry.fixturePath ?? "" }), + runCodingAgent: (context) => + context.repoFullName.includes("exec-b") + ? { ok: true, changedFiles: [] } // exec-b makes no change -> no_op_diff + : { ok: true, changedFiles: ["src/a.ts"] }, + runTests: () => ({ code: 0, stdout: "", stderr: "", timedOut: false }), + }); + expect(results).toHaveLength(2); + expect(results[0]?.passed).toBe(true); + expect(results[1]?.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.NO_OP_DIFF); + + const summary = summarizeCrossRepoEvaluation(results); + expect(summary.executedCount).toBe(2); + expect(summary.passed).toBe(1); + expect(summary.failuresByCategory[CROSS_REPO_FAILURE_CATEGORY.NO_OP_DIFF]).toBe(1); + + const report = formatCrossRepoEvaluationReport(results, summary); + expect(report).toContain("dry-run full-execution: 2/2 entered the code+test loop"); + expect(report).toContain("- no_op_diff: 1"); + }); + }); + describe("runCrossRepoEvaluation + summarizeCrossRepoEvaluation", () => { it("filters to a single repo and computes majority + category counts", () => { const parsed = parseCrossRepoEvaluationManifest( @@ -495,12 +696,23 @@ describe("cross-repo evaluation harness (#4788)", () => { json: true, repoFilter: "acme/widgets", requireMajority: true, + fullExecution: false, }); expect(parseCrossRepoEvaluationArgs(["--manifest"])).toEqual({ error: "Missing value for --manifest." }); expect(parseCrossRepoEvaluationArgs(["--nope"])).toEqual({ error: "Unknown argument: --nope" }); expect(parseCrossRepoEvaluationArgs(["--help"])).toEqual({ help: true }); }); + it("parses the --full-execution dry-run flag (#7634)", () => { + expect(parseCrossRepoEvaluationArgs(["--full-execution"])).toEqual({ + manifestPath: resolveDefaultManifestPath(), + json: false, + repoFilter: null, + requireMajority: false, + fullExecution: true, + }); + }); + it("runs the harness driver against a fixture manifest", () => { const repoPath = tempRepo({ "package.json": pkg({ scripts: { test: "node --test" } }), @@ -523,6 +735,50 @@ describe("cross-repo evaluation harness (#4788)", () => { expect(formatCrossRepoEvaluationReport(results, summary)).toContain("PASS acme/fixture"); }); + it("runCrossRepoExecutionCli drives a dry-run full-execution loop over >=2 repos with injected seams (#7634)", async () => { + const repoA = tempRepo({ "package.json": pkg({ scripts: { test: "node --test" } }) }); + const repoB = tempRepo({ "package.json": pkg({ scripts: { test: "node --test" } }) }); + const manifestDir = tempRepo(); + writeFileSync( + join(manifestDir, "manifest.json"), + JSON.stringify({ + repos: [ + { repoFullName: "acme/exec-pass", fixturePath: repoA, requireTestCommand: true }, + { repoFullName: "acme/exec-red", fixturePath: repoB, requireTestCommand: true }, + ], + }), + "utf8", + ); + + const { results, summary } = await runCrossRepoExecutionCli({ + manifestPath: join(manifestDir, "manifest.json"), + // Every side-effecting seam is a fake -> zero real clone / agent / test-run / network. + buildCodingTaskSpec: () => ({ ready: true, instructions: "Apply the smallest correct fix." }), + cloneRepo: (entry: { fixturePath?: string }) => ({ ok: true, repoPath: entry.fixturePath ?? "" }), + runCodingAgent: (context: { repoFullName: string }) => ({ + ok: true, + changedFiles: ["src/change.ts"], + summary: `edited ${context.repoFullName}`, + }), + runTests: (command: string, cwd: string) => ({ + code: cwd === repoB ? 1 : 0, // exec-red's suite is red + stdout: "", + stderr: "", + timedOut: false, + }), + }); + + expect(results).toHaveLength(2); + expect(results[0]?.passed).toBe(true); + expect(results[0]?.executed).toBe(true); + expect(results[1]?.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.TEST_FAILURE); + expect(summary.passed).toBe(1); + expect(summary.executedCount).toBe(2); + const report = formatCrossRepoEvaluationReport(results, summary); + expect(report).toContain("dry-run full-execution: 2/2"); + expect(report).toContain("- test_failure: 1"); + }); + it("parseCrossRepoEvaluationArgs treats a missing --repo value as an error", () => { expect(parseCrossRepoEvaluationArgs(["--repo"])).toEqual({ error: "Missing value for --repo." }); }); @@ -534,5 +790,8 @@ describe("cross-repo evaluation harness (#4788)", () => { expect(doc).toContain("stack_detection_gap"); expect(doc).toContain("cross-repo-evaluation.mjs"); expect(doc).toContain("benchmarks/cross-repo/manifest.json"); + // The dry-run full-execution mode (#7634) and its execution-specific categories are documented in-style. + expect(doc).toContain("--full-execution"); + expect(doc).toContain("no_op_diff"); }); });