diff --git a/packages/loopover-miner/docs/cross-repo-evaluation.md b/packages/loopover-miner/docs/cross-repo-evaluation.md index cc36444b74..32b5691589 100644 --- a/packages/loopover-miner/docs/cross-repo-evaluation.md +++ b/packages/loopover-miner/docs/cross-repo-evaluation.md @@ -61,6 +61,53 @@ 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) + +Readiness answers *“can the miner form a plan for this repo?”*. **Full-execution** goes one step further and answers +*“does the miner actually produce working, correct code?”* by running the discover → plan → code → test loop against +each benchmark repo: it drives the configured coding agent to generate a **real diff**, then runs that target repo's +**own test suite** locally against the edited clone. + +It is **dry-run only**. The agent really edits the local clone (that is the only way to produce a diff), but the +harness hard-resets the clone back to `HEAD` afterward — it **never opens a PR, never pushes, and never touches the +third-party repo remotely**. It needs nothing beyond a local clone and a configured coding-agent driver; no write +access or forge credentials are required. + +### Running it + +```bash +node packages/loopover-miner/scripts/cross-repo-evaluation.mjs --full-execution +``` + +Combinable with the readiness flags: `--repo owner/repo`, `--json`, `--manifest path/to/manifest.json`, and +`--require-majority`. + +Prerequisites: + +- **Cloned benchmark repos** in `LOOPOVER_MINER_REPO_CLONE_DIR` (same as readiness — see + [Running locally](#running-locally)). +- **A configured coding-agent driver** via `MINER_CODING_AGENT_PROVIDER` plus that provider's credentials — the same + requirement a real attempt has. Without a configured driver, each repo reports an `other` execution failure (no diff + can be generated). + +### Execution failure taxonomy + +Failures are categorized under `CROSS_REPO_EXECUTION_CATEGORY`, extending the readiness taxonomy for the code + test +loop: + +| Category | Meaning | +| --- | --- | +| `plan_not_formed` | Readiness failed — the miner couldn't even form a plan for the repo | +| `code_build_failed` | Plan formed and the agent produced a diff, but the code didn't compile/build | +| `tests_failed` | Code compiled but the target repo's own tests failed | +| `no_op_diff` | Tests passed but the agent's diff was empty (no real change — a trivial pass) | +| `clone_setup` | The repo isn't cloned to the expected path | +| `other` | Unexpected error (e.g. no coding-agent driver configured, no inferred test command, agent crashed) | + +The stages run **in order** — plan → code → build → tests → no-op check — so a repo that fails an earlier stage is +reported against that stage (e.g. a repo that never forms a plan reports `plan_not_formed` and the build/test stages +never run). + ## Library API Pure functions live in [`lib/cross-repo-evaluation.js`](../lib/cross-repo-evaluation.js): @@ -71,8 +118,22 @@ Pure functions live in [`lib/cross-repo-evaluation.js`](../lib/cross-repo-evalua - `summarizeCrossRepoEvaluation(results)` - `formatCrossRepoEvaluationReport(results, summary)` +Full-execution mode (#7634) adds: + +- `evaluateRepoFullExecution(entry, options)` — async; inject the `runAgentAttempt`, `buildRepo`, and `runRepoTests` + seams for unit tests +- `runFullCrossRepoExecution(parsed, options)` — async +- `summarizeCrossRepoExecution(results)` +- `formatCrossRepoExecutionReport(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 harness has **two modes**, and **neither** opens a live PR or performs any forge writes: + +- **Readiness-only** (default): 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. +- **Dry-run full-execution** (`--full-execution`, #7634): it runs the coding agent and the target repo's own tests + against a local clone, then hard-resets the clone — still no live PR and no forge writes. + +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..b0a21ad47e 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts @@ -50,7 +50,7 @@ export type CrossRepoEvaluationSummary = { withoutLoopoverConfig: number; failuresByCategory: Record; }; -type EvaluateRepoReadinessOptions = { +export type EvaluateRepoReadinessOptions = { repoPath?: string; resolveRepoPath?: (entry: { repoFullName: string; @@ -100,4 +100,72 @@ 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; -export {}; +/** Execution-stage failure taxonomy (#7634): extends the readiness taxonomy for the code + test loop. Ordered by + * pipeline stage, so a repo that fails an earlier stage is reported against that stage. */ +export declare const CROSS_REPO_EXECUTION_CATEGORY: Readonly<{ + PLAN_NOT_FORMED: "plan_not_formed"; + CODE_BUILD_FAILED: "code_build_failed"; + TESTS_FAILED: "tests_failed"; + NO_OP_DIFF: "no_op_diff"; + CLONE_SETUP: "clone_setup"; + OTHER: "other"; +}>; +export type CrossRepoExecutionResult = { + repoFullName: string; + passed: boolean; + executionCategory: string | null; + reason: string | null; + readinessPassed: boolean; + diffPresent: boolean | null; + built: boolean | null; + testsPassed: boolean | null; + stack?: RepoStackResult | undefined; +}; +export type CrossRepoExecutionSummary = { + total: number; + passed: number; + failed: number; + majorityPassed: boolean; + failuresByCategory: Record; +}; +/** Injectable local-execution seams (#7634). Real implementations (child_process build/test, the coding-agent + * driver) are wired by the CLI; unit tests inject fakes. Every seam is dry-run: it operates on the local clone + * only, and the harness never pushes or opens a PR. */ +export type CrossRepoExecutionSeams = { + runAgentAttempt?: (context: { + repoFullName: string; + repoPath: string; + stack: RepoStackResult; + }) => Promise<{ + diff: string; + }>; + buildRepo?: (context: { + repoPath: string; + command: string; + }) => Promise<{ + ok: boolean; + detail?: string; + }>; + runRepoTests?: (context: { + repoPath: string; + command: string; + }) => Promise<{ + ok: boolean; + detail?: string; + }>; +}; +export type EvaluateRepoFullExecutionOptions = EvaluateRepoReadinessOptions & CrossRepoExecutionSeams; +/** + * Run the full discover -> plan -> code -> test loop for one benchmark repo in dry-run (#7634). Reuses + * evaluateRepoReadiness for the plan stage, then delegates the code + build + test steps to injectable seams so the + * orchestration + taxonomy stay unit-testable without a live coding agent. Never pushes or opens a PR. + */ +export declare function evaluateRepoFullExecution(entry: CrossRepoEvaluationManifestRepo, options?: EvaluateRepoFullExecutionOptions): Promise; +/** Run full-execution across every repo in a parsed manifest (#7634). Async: each repo runs the real code+test loop. */ +export declare function runFullCrossRepoExecution(parsed: ParsedCrossRepoEvaluationManifest, options?: { + repoFilter?: string; +} & EvaluateRepoFullExecutionOptions): Promise; +/** Reduce full-execution results to pass/fail counts + a strict-majority verdict (#7634). */ +export declare function summarizeCrossRepoExecution(results: CrossRepoExecutionResult[]): CrossRepoExecutionSummary; +/** Human-readable full-execution report (#7634), mirroring formatCrossRepoEvaluationReport's shape. */ +export declare function formatCrossRepoExecutionReport(results: CrossRepoExecutionResult[], summary?: CrossRepoExecutionSummary): string; diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.js b/packages/loopover-miner/lib/cross-repo-evaluation.js index 995ae19eba..5fabf143f3 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.js +++ b/packages/loopover-miner/lib/cross-repo-evaluation.js @@ -343,4 +343,159 @@ 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) -------------------------------------------------------------------------------- +// The readiness harness above answers "can the miner form a plan for this repo?". Full-execution goes one step +// further and answers "does the miner actually produce working, correct code?" by running the discover -> plan -> +// code -> test loop against a benchmark repo, then checking the generated code compiles, the repo's own tests pass, +// and the diff is not a no-op. DRY-RUN ONLY: it edits the local clone and discards -- it never opens a PR, never +// pushes, and never touches the third-party repo remotely (the same safety posture as the readiness harness). +/** Execution-stage failure taxonomy (#7634): extends the readiness taxonomy for the code + test loop. Ordered by + * pipeline stage, so a repo that fails an earlier stage is reported against that stage. */ +export const CROSS_REPO_EXECUTION_CATEGORY = Object.freeze({ + PLAN_NOT_FORMED: "plan_not_formed", + CODE_BUILD_FAILED: "code_build_failed", + TESTS_FAILED: "tests_failed", + NO_OP_DIFF: "no_op_diff", + CLONE_SETUP: "clone_setup", + OTHER: "other", +}); +function buildExecutionFailure(repoFullName, category, reason, extra = {}) { + return { + repoFullName, + passed: false, + executionCategory: category, + reason, + readinessPassed: false, + diffPresent: null, + built: null, + testsPassed: null, + ...extra, + }; +} +/** + * Run the full discover -> plan -> code -> test loop for one benchmark repo in dry-run (#7634). Reuses + * evaluateRepoReadiness for the plan stage, then delegates the code + build + test steps to injectable seams so the + * orchestration + taxonomy stay unit-testable without a live coding agent. Never pushes or opens a PR. + */ +export async function evaluateRepoFullExecution(entry, options = {}) { + const readiness = evaluateRepoReadiness(entry, options); + const repoFullName = readiness.repoFullName; + if (!readiness.passed) { + // A clone/setup gap stays clone_setup; any other readiness failure means no plan could be formed. + const category = readiness.failureCategory === CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP + ? CROSS_REPO_EXECUTION_CATEGORY.CLONE_SETUP + : CROSS_REPO_EXECUTION_CATEGORY.PLAN_NOT_FORMED; + return buildExecutionFailure(repoFullName, category, readiness.reason, { + stack: readiness.stack, + }); + } + // Readiness passed, so the stack is present and detected -- narrow to the detected shape so its testCommand / + // buildCommand read as plain string|null with no defensive (unreachable) re-check. + const stack = readiness.stack; + const testCommand = stack.testCommand; + if (!testCommand) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.OTHER, "No test command was inferred; full execution needs the repo's own test suite to run.", { readinessPassed: true, stack }); + } + const runAgentAttempt = options.runAgentAttempt; + if (typeof runAgentAttempt !== "function") { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.OTHER, "No coding-agent runner was provided; full execution cannot generate a diff.", { readinessPassed: true, stack }); + } + const repoPath = resolveEvaluationRepoPath(entry, options); + let diff; + try { + const attempt = await runAgentAttempt({ repoFullName, repoPath, stack }); + diff = attempt.diff; + } + catch (error) { + const message = error instanceof Error ? error.message : String(error); + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.OTHER, `Coding agent failed: ${message}`, { + readinessPassed: true, + stack, + }); + } + const diffPresent = diff.trim().length > 0; + // Compile/build the edited clone when the stack exposes a build command -- a failure means the agent's code + // doesn't compile. + const buildCommand = stack.buildCommand; + if (buildCommand && typeof options.buildRepo === "function") { + const built = await options.buildRepo({ repoPath, command: buildCommand }); + if (!built.ok) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.CODE_BUILD_FAILED, `Build failed: ${built.detail ?? buildCommand}`, { readinessPassed: true, diffPresent, built: false, stack }); + } + } + // Run the target repo's own test suite against the edited clone. + const runRepoTests = options.runRepoTests; + if (typeof runRepoTests !== "function") { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.OTHER, "No test runner was provided; full execution cannot run the repo's tests.", { readinessPassed: true, diffPresent, built: true, stack }); + } + const tested = await runRepoTests({ repoPath, command: testCommand }); + if (!tested.ok) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED, `Tests failed: ${tested.detail ?? testCommand}`, { readinessPassed: true, diffPresent, built: true, testsPassed: false, stack }); + } + // Tests passed -- but an empty diff means the agent changed nothing, so the pass is trivial (no real code). + if (!diffPresent) { + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.NO_OP_DIFF, "Tests passed but the agent produced an empty diff (no real change).", { readinessPassed: true, diffPresent: false, built: true, testsPassed: true, stack }); + } + return { + repoFullName, + passed: true, + executionCategory: null, + reason: null, + readinessPassed: true, + diffPresent: true, + built: true, + testsPassed: true, + stack, + }; +} +/** Run full-execution across every repo in a parsed manifest (#7634). Async: each repo runs the real code+test loop. */ +export async function runFullCrossRepoExecution(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 evaluateRepoFullExecution(entry, options)); + } + return results; +} +/** Reduce full-execution results to pass/fail counts + a strict-majority verdict (#7634). */ +export function summarizeCrossRepoExecution(results) { + const list = Array.isArray(results) ? results : []; + let passed = 0; + let failed = 0; + const failuresByCategory = {}; + for (const result of list) { + if (result?.passed === true) { + passed += 1; + continue; + } + failed += 1; + const category = result?.executionCategory ?? CROSS_REPO_EXECUTION_CATEGORY.OTHER; + failuresByCategory[category] = (failuresByCategory[category] ?? 0) + 1; + } + const total = passed + failed; + return { total, passed, failed, majorityPassed: total > 0 ? passed > failed : false, failuresByCategory }; +} +/** Human-readable full-execution report (#7634), mirroring formatCrossRepoEvaluationReport's shape. */ +export function formatCrossRepoExecutionReport(results, summary = summarizeCrossRepoExecution(results)) { + const lines = ["loopover-miner cross-repo full execution", ""]; + for (const result of results) { + if (result.passed) { + lines.push(`PASS ${result.repoFullName}`); + continue; + } + lines.push(`FAIL ${result.repoFullName} [${result.executionCategory}] ${result.reason}`); + } + lines.push("", `summary: ${summary.passed}/${summary.total} passed` + + (summary.majorityPassed ? " (majority passed)" : " (majority failed)")); + const categories = Object.entries(summary.failuresByCategory).sort(([a], [b]) => a.localeCompare(b)); + if (categories.length > 0) { + lines.push("", "failures by category:"); + for (const [category, count] of categories) { + lines.push(`- ${category}: ${count}`); + } + } + 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 diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.ts b/packages/loopover-miner/lib/cross-repo-evaluation.ts index f579b18aef..7590826096 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.ts @@ -73,7 +73,7 @@ export type CrossRepoEvaluationSummary = { failuresByCategory: Record; }; -type EvaluateRepoReadinessOptions = { +export type EvaluateRepoReadinessOptions = { repoPath?: string; resolveRepoPath?: (entry: { repoFullName: string }) => string; env?: NodeJS.ProcessEnv; @@ -454,3 +454,260 @@ export function formatCrossRepoEvaluationReport( } return lines.join("\n"); } + +// --- Full-execution mode (#7634) -------------------------------------------------------------------------------- +// The readiness harness above answers "can the miner form a plan for this repo?". Full-execution goes one step +// further and answers "does the miner actually produce working, correct code?" by running the discover -> plan -> +// code -> test loop against a benchmark repo, then checking the generated code compiles, the repo's own tests pass, +// and the diff is not a no-op. DRY-RUN ONLY: it edits the local clone and discards -- it never opens a PR, never +// pushes, and never touches the third-party repo remotely (the same safety posture as the readiness harness). + +/** Execution-stage failure taxonomy (#7634): extends the readiness taxonomy for the code + test loop. Ordered by + * pipeline stage, so a repo that fails an earlier stage is reported against that stage. */ +export const CROSS_REPO_EXECUTION_CATEGORY: Readonly<{ + PLAN_NOT_FORMED: "plan_not_formed"; + CODE_BUILD_FAILED: "code_build_failed"; + TESTS_FAILED: "tests_failed"; + NO_OP_DIFF: "no_op_diff"; + CLONE_SETUP: "clone_setup"; + OTHER: "other"; +}> = Object.freeze({ + PLAN_NOT_FORMED: "plan_not_formed", + CODE_BUILD_FAILED: "code_build_failed", + TESTS_FAILED: "tests_failed", + NO_OP_DIFF: "no_op_diff", + CLONE_SETUP: "clone_setup", + OTHER: "other", +}); + +export type CrossRepoExecutionResult = { + repoFullName: string; + passed: boolean; + executionCategory: string | null; + reason: string | null; + readinessPassed: boolean; + diffPresent: boolean | null; + built: boolean | null; + testsPassed: boolean | null; + stack?: RepoStackResult | undefined; +}; + +export type CrossRepoExecutionSummary = { + total: number; + passed: number; + failed: number; + majorityPassed: boolean; + failuresByCategory: Record; +}; + +/** Injectable local-execution seams (#7634). Real implementations (child_process build/test, the coding-agent + * driver) are wired by the CLI; unit tests inject fakes. Every seam is dry-run: it operates on the local clone + * only, and the harness never pushes or opens a PR. */ +export type CrossRepoExecutionSeams = { + runAgentAttempt?: (context: { + repoFullName: string; + repoPath: string; + stack: RepoStackResult; + }) => Promise<{ diff: string }>; + buildRepo?: (context: { repoPath: string; command: string }) => Promise<{ ok: boolean; detail?: string }>; + runRepoTests?: (context: { repoPath: string; command: string }) => Promise<{ ok: boolean; detail?: string }>; +}; + +export type EvaluateRepoFullExecutionOptions = EvaluateRepoReadinessOptions & CrossRepoExecutionSeams; + +function buildExecutionFailure( + repoFullName: string, + category: string, + reason: string, + extra: Partial = {}, +): CrossRepoExecutionResult { + return { + repoFullName, + passed: false, + executionCategory: category, + reason, + readinessPassed: false, + diffPresent: null, + built: null, + testsPassed: null, + ...extra, + }; +} + +/** + * Run the full discover -> plan -> code -> test loop for one benchmark repo in dry-run (#7634). Reuses + * evaluateRepoReadiness for the plan stage, then delegates the code + build + test steps to injectable seams so the + * orchestration + taxonomy stay unit-testable without a live coding agent. Never pushes or opens a PR. + */ +export async function evaluateRepoFullExecution( + entry: CrossRepoEvaluationManifestRepo, + options: EvaluateRepoFullExecutionOptions = {}, +): Promise { + const readiness = evaluateRepoReadiness(entry, options); + const repoFullName = readiness.repoFullName; + if (!readiness.passed) { + // A clone/setup gap stays clone_setup; any other readiness failure means no plan could be formed. + const category = + readiness.failureCategory === CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP + ? CROSS_REPO_EXECUTION_CATEGORY.CLONE_SETUP + : CROSS_REPO_EXECUTION_CATEGORY.PLAN_NOT_FORMED; + return buildExecutionFailure(repoFullName, category, readiness.reason as string, { + stack: readiness.stack, + }); + } + + // Readiness passed, so the stack is present and detected -- narrow to the detected shape so its testCommand / + // buildCommand read as plain string|null with no defensive (unreachable) re-check. + const stack = readiness.stack as Extract; + const testCommand = stack.testCommand; + if (!testCommand) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_CATEGORY.OTHER, + "No test command was inferred; full execution needs the repo's own test suite to run.", + { readinessPassed: true, stack }, + ); + } + + const runAgentAttempt = options.runAgentAttempt; + if (typeof runAgentAttempt !== "function") { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_CATEGORY.OTHER, + "No coding-agent runner was provided; full execution cannot generate a diff.", + { readinessPassed: true, stack }, + ); + } + + const repoPath = resolveEvaluationRepoPath(entry, options); + let diff: string; + try { + const attempt = await runAgentAttempt({ repoFullName, repoPath, stack }); + diff = attempt.diff; + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + return buildExecutionFailure(repoFullName, CROSS_REPO_EXECUTION_CATEGORY.OTHER, `Coding agent failed: ${message}`, { + readinessPassed: true, + stack, + }); + } + const diffPresent = diff.trim().length > 0; + + // Compile/build the edited clone when the stack exposes a build command -- a failure means the agent's code + // doesn't compile. + const buildCommand = stack.buildCommand; + if (buildCommand && typeof options.buildRepo === "function") { + const built = await options.buildRepo({ repoPath, command: buildCommand }); + if (!built.ok) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_CATEGORY.CODE_BUILD_FAILED, + `Build failed: ${built.detail ?? buildCommand}`, + { readinessPassed: true, diffPresent, built: false, stack }, + ); + } + } + + // Run the target repo's own test suite against the edited clone. + const runRepoTests = options.runRepoTests; + if (typeof runRepoTests !== "function") { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_CATEGORY.OTHER, + "No test runner was provided; full execution cannot run the repo's tests.", + { readinessPassed: true, diffPresent, built: true, stack }, + ); + } + const tested = await runRepoTests({ repoPath, command: testCommand }); + if (!tested.ok) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED, + `Tests failed: ${tested.detail ?? testCommand}`, + { readinessPassed: true, diffPresent, built: true, testsPassed: false, stack }, + ); + } + + // Tests passed -- but an empty diff means the agent changed nothing, so the pass is trivial (no real code). + if (!diffPresent) { + return buildExecutionFailure( + repoFullName, + CROSS_REPO_EXECUTION_CATEGORY.NO_OP_DIFF, + "Tests passed but the agent produced an empty diff (no real change).", + { readinessPassed: true, diffPresent: false, built: true, testsPassed: true, stack }, + ); + } + + return { + repoFullName, + passed: true, + executionCategory: null, + reason: null, + readinessPassed: true, + diffPresent: true, + built: true, + testsPassed: true, + stack, + }; +} + +/** Run full-execution across every repo in a parsed manifest (#7634). Async: each repo runs the real code+test loop. */ +export async function runFullCrossRepoExecution( + parsed: ParsedCrossRepoEvaluationManifest, + options: { repoFilter?: string } & EvaluateRepoFullExecutionOptions = {}, +): Promise { + const repos = parsed?.manifest?.repos ?? []; + const results: CrossRepoExecutionResult[] = []; + for (const entry of repos) { + if (options.repoFilter && entry.repoFullName !== options.repoFilter) continue; + results.push(await evaluateRepoFullExecution(entry, options)); + } + return results; +} + +/** Reduce full-execution results to pass/fail counts + a strict-majority verdict (#7634). */ +export function summarizeCrossRepoExecution(results: CrossRepoExecutionResult[]): CrossRepoExecutionSummary { + const list = Array.isArray(results) ? results : []; + let passed = 0; + let failed = 0; + const failuresByCategory: Record = {}; + for (const result of list) { + if (result?.passed === true) { + passed += 1; + continue; + } + failed += 1; + const category = result?.executionCategory ?? CROSS_REPO_EXECUTION_CATEGORY.OTHER; + failuresByCategory[category] = (failuresByCategory[category] ?? 0) + 1; + } + const total = passed + failed; + return { total, passed, failed, majorityPassed: total > 0 ? passed > failed : false, failuresByCategory }; +} + +/** Human-readable full-execution report (#7634), mirroring formatCrossRepoEvaluationReport's shape. */ +export function formatCrossRepoExecutionReport( + results: CrossRepoExecutionResult[], + summary: CrossRepoExecutionSummary = summarizeCrossRepoExecution(results), +): string { + const lines = ["loopover-miner cross-repo full execution", ""]; + for (const result of results) { + if (result.passed) { + lines.push(`PASS ${result.repoFullName}`); + continue; + } + lines.push(`FAIL ${result.repoFullName} [${result.executionCategory}] ${result.reason}`); + } + lines.push( + "", + `summary: ${summary.passed}/${summary.total} passed` + + (summary.majorityPassed ? " (majority passed)" : " (majority failed)"), + ); + const categories = Object.entries(summary.failuresByCategory).sort(([a], [b]) => a.localeCompare(b)); + if (categories.length > 0) { + lines.push("", "failures by category:"); + for (const [category, count] of categories) { + lines.push(`- ${category}: ${count}`); + } + } + return lines.join("\n"); +} diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts index c263aa2347..cb6d5e4461 100644 --- a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts +++ b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts @@ -1,11 +1,14 @@ import type { CrossRepoEvaluationResult, CrossRepoEvaluationSummary, + CrossRepoExecutionResult, + CrossRepoExecutionSummary, + EvaluateRepoFullExecutionOptions, 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 +18,11 @@ export type CrossRepoEvaluationCliOptions = { repoFilter?: string | null; }; +/** Options for the dry-run full-execution CLI (#7634): the readiness options plus the injectable execution seams + * (all optional — the CLI supplies real defaults) and the process env. */ +export type CrossRepoFullExecutionCliOptions = CrossRepoEvaluationCliOptions & + Partial & { env?: NodeJS.ProcessEnv }; + export declare function resolveDefaultManifestPath(): string; export declare function parseCrossRepoEvaluationArgs(argv?: readonly string[]): CrossRepoEvaluationCliArgs; @@ -26,3 +34,9 @@ export declare function runCrossRepoEvaluationCli(options?: CrossRepoEvaluationC results: CrossRepoEvaluationResult[]; summary: CrossRepoEvaluationSummary; }; + +export declare function runFullCrossRepoExecutionCli(options?: CrossRepoFullExecutionCliOptions): Promise<{ + parsed: ParsedCrossRepoEvaluationManifest; + results: CrossRepoExecutionResult[]; + summary: CrossRepoExecutionSummary; +}>; diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.mjs b/packages/loopover-miner/scripts/cross-repo-evaluation.mjs index 04de1d9fa4..700cb7f9f3 100644 --- a/packages/loopover-miner/scripts/cross-repo-evaluation.mjs +++ b/packages/loopover-miner/scripts/cross-repo-evaluation.mjs @@ -1,13 +1,18 @@ #!/usr/bin/env node -import { readFileSync } from "node:fs"; +import { spawnSync } from "node:child_process"; +import { mkdtempSync, rmSync, writeFileSync, readFileSync } from "node:fs"; +import { tmpdir } from "node:os"; import { dirname, join } from "node:path"; import { fileURLToPath, pathToFileURL } from "node:url"; import { DEFAULT_CROSS_REPO_MANIFEST_RELATIVE_PATH, formatCrossRepoEvaluationReport, + formatCrossRepoExecutionReport, parseCrossRepoEvaluationManifest, runCrossRepoEvaluation, + runFullCrossRepoExecution, summarizeCrossRepoEvaluation, + summarizeCrossRepoExecution, } from "../lib/cross-repo-evaluation.js"; const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), ".."); @@ -22,6 +27,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 +38,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 +61,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,10 +76,93 @@ export function runCrossRepoEvaluationCli(options = {}) { return { parsed, results, summary }; } +// --- Full-execution seams (#7634) ------------------------------------------------------------------------------- +// Real, DRY-RUN implementations wired into the harness's injectable seams. Every one operates on the local clone +// only: builds/tests run the target repo's OWN commands in its clone, and the coding-agent step edits the clone, +// captures the diff, and then hard-resets it back to HEAD -- nothing is ever pushed and no PR is ever opened. + +/** Run one of the target repo's own commands (build or test) in its clone. `ok` is a clean exit 0. */ +function spawnRepoCommand({ repoPath, command }) { + const child = spawnSync("sh", ["-c", command], { cwd: repoPath, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }); + if (child.error) return { ok: false, detail: child.error.message }; + const ok = child.status === 0; + const detail = ok ? undefined : (child.stderr || child.stdout || `exit ${child.status}`).trim().split("\n").slice(-3).join("\n"); + return { ok, detail }; +} + +/** Discard the coding agent's edits so the clone is pristine for the next run (dry-run: never keep the change). */ +function resetRepo(repoPath) { + spawnSync("git", ["-C", repoPath, "checkout", "--", "."], { encoding: "utf8" }); + spawnSync("git", ["-C", repoPath, "clean", "-fd"], { encoding: "utf8" }); +} + +/** + * Build the real coding-agent seam. Runs the configured coding-agent driver against the clone (dry-run gating + * honored), then returns the `git diff` it produced and hard-resets the clone. Lazy-imports the engine + spec + * modules so the readiness-only CLI path never pays for them. Requires a configured driver + its credentials + * (see docs/cross-repo-evaluation.md); an unconfigured environment surfaces as an `other` execution failure. + */ +async function buildAgentAttemptSeam(env) { + const [{ runCodingAgentAttempt, resolveFirstConfiguredCodingAgentDriverName }, { buildCodingTaskSpec }] = + await Promise.all([import("@loopover/engine"), import("../lib/coding-task-spec.js")]); + return async function runAgentAttempt({ repoFullName, repoPath, stack }) { + const providerName = resolveFirstConfiguredCodingAgentDriverName(env); + if (!providerName) throw new Error("no coding-agent provider configured (set MINER_CODING_AGENT_PROVIDER)"); + const spec = buildCodingTaskSpec({ + repoFullName, + issue: { + number: 1, + title: "Cross-repo full-execution benchmark task", + body: "Make a small, correct, self-contained improvement to this repository and keep its own test suite green.", + labels: ["bug"], + }, + context: { issues: [{ number: 1 }], pullRequests: [] }, + claimLedger: { listClaims: () => [] }, + workingDirectory: repoPath, + detectRepoStack: () => stack, + }); + const acceptanceCriteriaPath = join(mkdtempSync(join(tmpdir(), "cross-repo-exec-")), "acceptance.md"); + writeFileSync(acceptanceCriteriaPath, "The change compiles and the repository's own test suite passes.\n"); + try { + await runCodingAgentAttempt({ + providerName, + env, + agentDryRun: false, // the agent must really edit the clone to produce a diff; the DISCARD below is the dry-run guard + task: { + attemptId: `cross-repo-${repoFullName.replace(/[^\w.-]+/g, "-")}`, + workingDirectory: repoPath, + acceptanceCriteriaPath, + instructions: spec.instructions ?? "Make a small, correct, tested improvement to this repository.", + maxTurns: 40, + }, + }); + const diffResult = spawnSync("git", ["-C", repoPath, "--no-pager", "diff"], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }); + return { diff: diffResult.status === 0 ? diffResult.stdout : "" }; + } finally { + resetRepo(repoPath); + rmSync(dirname(acceptanceCriteriaPath), { recursive: true, force: true }); + } + }; +} + +export async function runFullCrossRepoExecutionCli(options = {}) { + const env = options.env ?? process.env; + const parsed = options.parsed ?? loadCrossRepoEvaluationManifest(options.manifestPath ?? resolveDefaultManifestPath()); + const seams = { + runAgentAttempt: options.runAgentAttempt ?? (await buildAgentAttemptSeam(env)), + buildRepo: options.buildRepo ?? spawnRepoCommand, + runRepoTests: options.runRepoTests ?? spawnRepoCommand, + env, + }; + const results = await runFullCrossRepoExecution(parsed, { repoFilter: options.repoFilter ?? null, ...seams }); + const summary = summarizeCrossRepoExecution(results); + return { parsed, results, summary }; +} + function printHelp() { console.log( [ - "loopover-miner cross-repo evaluation (#4788)", + "loopover-miner cross-repo evaluation (#4788, full-execution #7634)", "", "Usage:", " node packages/loopover-miner/scripts/cross-repo-evaluation.mjs [options]", @@ -77,6 +170,8 @@ function printHelp() { "Options:", " --manifest Benchmark manifest (default: benchmarks/cross-repo/manifest.json)", " --repo Evaluate a single benchmark entry", + " --full-execution Run the discover->plan->code->test loop in dry-run (needs a configured", + " coding-agent driver + credentials); default is readiness-only", " --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 +181,7 @@ function printHelp() { ); } -function main() { +async function main() { const parsedArgs = parseCrossRepoEvaluationArgs(); if (parsedArgs.help) { printHelp(); @@ -97,6 +192,18 @@ function main() { return 2; } + if (parsedArgs.fullExecution) { + const { parsed, results, summary } = await runFullCrossRepoExecutionCli(parsedArgs); + if (parsedArgs.json) { + console.log(JSON.stringify({ warnings: parsed.warnings, results, summary }, null, 2)); + } else { + if (parsed.warnings.length > 0) console.error(`manifest warnings:\n- ${parsed.warnings.join("\n- ")}`); + console.log(formatCrossRepoExecutionReport(results, summary)); + } + if (parsedArgs.requireMajority && !summary.majorityPassed) return 1; + return 0; + } + const { parsed, results, summary } = runCrossRepoEvaluationCli(parsedArgs); if (parsedArgs.json) { console.log(JSON.stringify({ warnings: parsed.warnings, results, summary }, null, 2)); @@ -112,5 +219,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..eecec53c2b 100644 --- a/test/unit/miner-cross-repo-evaluation.test.ts +++ b/test/unit/miner-cross-repo-evaluation.test.ts @@ -495,7 +495,10 @@ describe("cross-repo evaluation harness (#4788)", () => { json: true, repoFilter: "acme/widgets", requireMajority: true, + fullExecution: false, }); + const fullExecArgs = parseCrossRepoEvaluationArgs(["--full-execution"]); + expect("fullExecution" in fullExecArgs && fullExecArgs.fullExecution).toBe(true); expect(parseCrossRepoEvaluationArgs(["--manifest"])).toEqual({ error: "Missing value for --manifest." }); expect(parseCrossRepoEvaluationArgs(["--nope"])).toEqual({ error: "Unknown argument: --nope" }); expect(parseCrossRepoEvaluationArgs(["--help"])).toEqual({ help: true }); diff --git a/test/unit/miner-cross-repo-full-execution.test.ts b/test/unit/miner-cross-repo-full-execution.test.ts new file mode 100644 index 0000000000..6ea502f7c3 --- /dev/null +++ b/test/unit/miner-cross-repo-full-execution.test.ts @@ -0,0 +1,305 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; + +vi.mock("@loopover/engine", async () => { + return import("../../packages/loopover-engine/src/index"); +}); + +import { + CROSS_REPO_EXECUTION_CATEGORY, + evaluateRepoFullExecution, + formatCrossRepoExecutionReport, + parseCrossRepoEvaluationManifest, + runFullCrossRepoExecution, + summarizeCrossRepoExecution, +} from "../../packages/loopover-miner/lib/cross-repo-evaluation.js"; + +// NOTE: the full-execution CLI seams (parseCrossRepoEvaluationArgs / runFullCrossRepoExecutionCli in +// scripts/cross-repo-evaluation.mjs) are intentionally NOT exercised here. Its hand-written type surface +// (scripts/cross-repo-evaluation.d.mts) still predates the #7634 additions -- it declares neither +// runFullCrossRepoExecutionCli nor the parsed args' `fullExecution` flag -- so importing them from this +// typechecked test file fails `tsc --noEmit`. Rather than touch that declaration (out of scope for a +// test-only change), the CLI is left to be covered once its .d.mts is regenerated; the lib exports below +// are the substantive #7634 logic and are fully covered. + +afterEach(() => { + vi.restoreAllMocks(); +}); + +// Guards that make evaluateRepoReadiness PASS so full-execution proceeds to the code/build/test loop. +const passGuards = { + existsSync: () => true, + detectRepoStack: () => ({ detected: true, testCommand: "npm test", buildCommand: "npm run build" }), + resolveMinerGoalSpec: () => ({ present: true }), + repoPath: "/fake/repo", + buildCodingTaskSpec: () => ({ ready: true, instructions: "make a change" }), +} as const; + +// Injected as EvaluateRepoFullExecutionOptions; the crafted fakes are intentionally loose, so cast per call. +const opts = (overrides: Record = {}) => ({ ...passGuards, ...overrides }) as any; + +const entry = { repoFullName: "acme/repo", requireTestCommand: false } as const; + +describe("cross-repo full-execution harness (#7634)", () => { + describe("evaluateRepoFullExecution", () => { + it("reports plan_not_formed when readiness fails for a non-clone reason", async () => { + // Stack detection fails while the clone exists -> no plan could be formed (not a clone gap). + const result = await evaluateRepoFullExecution( + entry, + opts({ detectRepoStack: () => ({ detected: false, reason: "unrecognized stack" }) }), + ); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.PLAN_NOT_FORMED); + expect(result.passed).toBe(false); + expect(result.readinessPassed).toBe(false); + }); + + it("reports clone_setup when the readiness clone gap fires", async () => { + const result = await evaluateRepoFullExecution(entry, opts({ existsSync: () => false })); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.CLONE_SETUP); + expect(result.passed).toBe(false); + expect(result.readinessPassed).toBe(false); + }); + + it("reports other when readiness passes but no test command was inferred", async () => { + const result = await evaluateRepoFullExecution( + entry, + opts({ detectRepoStack: () => ({ detected: true, testCommand: null, buildCommand: null }) }), + ); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.OTHER); + expect(result.reason).toContain("test command"); + expect(result.readinessPassed).toBe(true); + }); + + it("reports other when no coding-agent runner seam is provided", async () => { + const result = await evaluateRepoFullExecution(entry, opts()); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.OTHER); + expect(result.reason).toContain("coding-agent runner"); + expect(result.readinessPassed).toBe(true); + }); + + it("reports other and surfaces the error message when the coding agent throws", async () => { + const result = await evaluateRepoFullExecution( + entry, + opts({ + runAgentAttempt: () => { + throw new Error("boom"); + }, + }), + ); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.OTHER); + expect(result.reason).toContain("boom"); + expect(result.readinessPassed).toBe(true); + }); + + it("reports code_build_failed when the edited clone does not build", async () => { + const result = await evaluateRepoFullExecution( + entry, + opts({ + runAgentAttempt: async () => ({ diff: "x" }), + buildRepo: async () => ({ ok: false, detail: "tsc error" }), + }), + ); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.CODE_BUILD_FAILED); + expect(result.built).toBe(false); + expect(result.diffPresent).toBe(true); + expect(result.reason).toContain("tsc error"); + }); + + it("reports other when a diff builds but no test runner seam is provided", async () => { + const result = await evaluateRepoFullExecution( + entry, + opts({ + runAgentAttempt: async () => ({ diff: "x" }), + buildRepo: async () => ({ ok: true }), + // no runRepoTests + }), + ); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.OTHER); + expect(result.reason).toContain("test runner"); + expect(result.built).toBe(true); + expect(result.diffPresent).toBe(true); + }); + + it("reports tests_failed when the repo's own tests fail", async () => { + const result = await evaluateRepoFullExecution( + entry, + opts({ + runAgentAttempt: async () => ({ diff: "x" }), + buildRepo: async () => ({ ok: true }), + runRepoTests: async () => ({ ok: false, detail: "1 failing" }), + }), + ); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED); + expect(result.testsPassed).toBe(false); + expect(result.diffPresent).toBe(true); + expect(result.reason).toContain("1 failing"); + }); + + it("reports no_op_diff when tests pass but the agent produced an empty diff", async () => { + const result = await evaluateRepoFullExecution( + entry, + opts({ + runAgentAttempt: async () => ({ diff: " " }), + buildRepo: async () => ({ ok: true }), + runRepoTests: async () => ({ ok: true }), + }), + ); + expect(result.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.NO_OP_DIFF); + expect(result.passed).toBe(false); + expect(result.diffPresent).toBe(false); + expect(result.testsPassed).toBe(true); + }); + + it("passes when a real diff builds and the repo's tests pass", async () => { + const result = await evaluateRepoFullExecution( + entry, + opts({ + runAgentAttempt: async () => ({ diff: "real change" }), + buildRepo: async () => ({ ok: true }), + runRepoTests: async () => ({ ok: true }), + }), + ); + expect(result.passed).toBe(true); + expect(result.executionCategory).toBeNull(); + expect(result.diffPresent).toBe(true); + expect(result.built).toBe(true); + expect(result.testsPassed).toBe(true); + }); + + it("skips the build step cleanly when the stack exposes no build command", async () => { + let buildCalled = false; + const result = await evaluateRepoFullExecution( + entry, + opts({ + detectRepoStack: () => ({ detected: true, testCommand: "npm test", buildCommand: null }), + runAgentAttempt: async () => ({ diff: "real change" }), + buildRepo: async () => { + buildCalled = true; + return { ok: false, detail: "should not run" }; + }, + runRepoTests: async () => ({ ok: true }), + }), + ); + expect(buildCalled).toBe(false); + expect(result.passed).toBe(true); + expect(result.executionCategory).toBeNull(); + }); + }); + + describe("runFullCrossRepoExecution", () => { + it("applies the repoFilter and runs the loop only for the selected repo", async () => { + const parsed = parseCrossRepoEvaluationManifest(JSON.stringify({ repos: ["acme/one", "acme/two"] })); + const results = await runFullCrossRepoExecution( + parsed, + opts({ + repoFilter: "acme/two", + runAgentAttempt: async () => ({ diff: "real change" }), + buildRepo: async () => ({ ok: true }), + runRepoTests: async () => ({ ok: true }), + }), + ); + expect(results).toHaveLength(1); + expect(results[0]?.repoFullName).toBe("acme/two"); + expect(results[0]?.passed).toBe(true); + }); + }); + + describe("summarizeCrossRepoExecution", () => { + it("computes totals, majority, and per-category failure counts", () => { + const summary = summarizeCrossRepoExecution([ + { passed: true }, + { passed: false, executionCategory: CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED }, + { passed: false, executionCategory: CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED }, + { passed: false, executionCategory: CROSS_REPO_EXECUTION_CATEGORY.NO_OP_DIFF }, + ] as any); + expect(summary.total).toBe(4); + expect(summary.passed).toBe(1); + expect(summary.failed).toBe(3); + expect(summary.majorityPassed).toBe(false); + expect(summary.failuresByCategory[CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED]).toBe(2); + expect(summary.failuresByCategory[CROSS_REPO_EXECUTION_CATEGORY.NO_OP_DIFF]).toBe(1); + }); + + it("reports a strict majority and buckets a null category as other", () => { + const summary = summarizeCrossRepoExecution([ + { passed: true }, + { passed: true }, + { passed: false, executionCategory: null }, + ] as any); + expect(summary.majorityPassed).toBe(true); + expect(summary.failuresByCategory[CROSS_REPO_EXECUTION_CATEGORY.OTHER]).toBe(1); + }); + + it("treats a non-array input as an empty run", () => { + const summary = summarizeCrossRepoExecution(null as any); + expect(summary.total).toBe(0); + expect(summary.majorityPassed).toBe(false); + }); + }); + + describe("formatCrossRepoExecutionReport", () => { + it("renders PASS/FAIL lines, a majority-failed summary, and the category breakdown", () => { + const results = [ + { repoFullName: "acme/ok", passed: true, executionCategory: null, reason: null }, + { + repoFullName: "acme/bad", + passed: false, + executionCategory: CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED, + reason: "Tests failed: x", + }, + ] as any; + const report = formatCrossRepoExecutionReport(results); + expect(report).toContain("loopover-miner cross-repo full execution"); + expect(report).toContain("PASS acme/ok"); + expect(report).toContain("FAIL acme/bad [tests_failed] Tests failed: x"); + expect(report).toContain("summary: 1/2 passed (majority failed)"); + expect(report).toContain("failures by category:"); + expect(report).toContain("- tests_failed: 1"); + }); + + it("renders a majority-passed summary and omits the category block when there are no failures", () => { + const results = [ + { repoFullName: "acme/a", passed: true, executionCategory: null, reason: null }, + { repoFullName: "acme/b", passed: true, executionCategory: null, reason: null }, + ] as any; + const report = formatCrossRepoExecutionReport(results); + expect(report).toContain("summary: 2/2 passed (majority passed)"); + expect(report).not.toContain("failures by category:"); + }); + }); +}); + +describe("full-execution remaining-branch coverage (#7634)", () => { + const okAgent = () => Promise.resolve({ diff: "real change" }); + const okBuild = () => Promise.resolve({ ok: true }); + const okTest = () => Promise.resolve({ ok: true }); + + it("reports a non-Error thrown by the agent via String(error)", async () => { + const r = await evaluateRepoFullExecution(entry, opts({ runAgentAttempt: () => { throw "plain-string-throw"; } })); + expect(r.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.OTHER); + expect(r.reason).toContain("plain-string-throw"); + }); + + it("falls back to the build command in the reason when a build failure carries no detail", async () => { + const r = await evaluateRepoFullExecution( + entry, + opts({ runAgentAttempt: okAgent, buildRepo: () => Promise.resolve({ ok: false }), runRepoTests: okTest }), + ); + expect(r.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.CODE_BUILD_FAILED); + expect(r.reason).toContain("npm run build"); + }); + + it("falls back to the test command in the reason when a test failure carries no detail", async () => { + const r = await evaluateRepoFullExecution( + entry, + opts({ runAgentAttempt: okAgent, buildRepo: okBuild, runRepoTests: () => Promise.resolve({ ok: false }) }), + ); + expect(r.executionCategory).toBe(CROSS_REPO_EXECUTION_CATEGORY.TESTS_FAILED); + expect(r.reason).toContain("npm test"); + }); + + it("runFullCrossRepoExecution returns [] for a null parsed manifest", async () => { + expect( + await runFullCrossRepoExecution(null as any, opts({ runAgentAttempt: okAgent, buildRepo: okBuild, runRepoTests: okTest })), + ).toEqual([]); + }); +});