From 4565de30f27d675a63b6aacac5cca1614a4e2f26 Mon Sep 17 00:00:00 2001 From: bitfathers94 <237535319+bitfathers94@users.noreply.github.com> Date: Tue, 21 Jul 2026 05:43:10 +0000 Subject: [PATCH 1/2] feat(miner): add a --full-execution dry-run mode to the cross-repo harness Extend the cross-repo evaluation harness (#4788) from readiness-only to a full-execution mode that drives the live discover -> plan -> code -> test loop against a curated subset of the benchmark repos, generating a real diff and running each target repo's own build + test commands locally. Dry-run only, same read/execute-locally-and-discard posture as the readiness harness: the coding agent edits a throwaway clone, the diff is captured with git, and no PR is opened against any third-party repo. - executeRepoAttempt / runCrossRepoExecution classify the outcome; the agent, build, and test runners are injectable (real spawnSync defaults). - Extend CROSS_REPO_FAILURE_CATEGORY with execution_no_diff, execution_compile_gap, execution_test_failure, and execution_noop_diff; results reuse the existing report + summary format. - --full-execution CLI flag wires a real driver-backed executor; a fullExecution manifest flag marks the subset (--repo overrides it). - Document the new mode and taxonomy in docs/cross-repo-evaluation.md. Closes #7634 --- .../benchmarks/cross-repo/manifest.json | 6 +- .../docs/cross-repo-evaluation.md | 47 ++- .../lib/cross-repo-evaluation.d.ts | 87 ++++- .../lib/cross-repo-evaluation.js | 180 +++++++++- .../lib/cross-repo-evaluation.ts | 316 +++++++++++++++++- .../scripts/cross-repo-evaluation.d.mts | 28 +- .../scripts/cross-repo-evaluation.mjs | 77 ++++- test/unit/miner-cross-repo-evaluation.test.ts | 266 +++++++++++++++ 8 files changed, 966 insertions(+), 41 deletions(-) diff --git a/packages/loopover-miner/benchmarks/cross-repo/manifest.json b/packages/loopover-miner/benchmarks/cross-repo/manifest.json index a6d1bc1b35..164b18e16d 100644 --- a/packages/loopover-miner/benchmarks/cross-repo/manifest.json +++ b/packages/loopover-miner/benchmarks/cross-repo/manifest.json @@ -8,7 +8,8 @@ { "repoFullName": "expressjs/express", "stackHint": "nodejs", - "requireTestCommand": true + "requireTestCommand": true, + "fullExecution": true }, { "repoFullName": "pallets/flask", @@ -28,7 +29,8 @@ { "repoFullName": "lodash/lodash", "stackHint": "nodejs", - "requireTestCommand": true + "requireTestCommand": true, + "fullExecution": true } ] } diff --git a/packages/loopover-miner/docs/cross-repo-evaluation.md b/packages/loopover-miner/docs/cross-repo-evaluation.md index cc36444b74..efe29589f3 100644 --- a/packages/loopover-miner/docs/cross-repo-evaluation.md +++ b/packages/loopover-miner/docs/cross-repo-evaluation.md @@ -33,6 +33,8 @@ bare `"owner/repo"` string or an object: - **`stackHint`** — documentation only (not used by the evaluator) - **`requireTestCommand`** — when `true`, stack detection must infer a test command or the repo fails with `execution_gap` +- **`fullExecution`** — when `true`, this entry is part of the full-execution subset (#7634): a bare + `--full-execution` run drives the live attempt against every entry flagged `true` (see below) Malformed manifest fields degrade to documented defaults with warnings (same tolerant-parser convention as the fleet run-manifest). @@ -60,6 +62,43 @@ 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` — run the live attempt loop instead of the readiness check (see below) + +## Full-execution mode (#7634) + +Readiness answers *"can the miner form a plan for this repo."* **Full-execution mode** answers the real question +behind [#4810](https://github.com/JSONbored/loopover/issues/4810)'s launch-readiness bar — *"does the miner +actually produce working, correct code for this repo"* — by driving the live **discover → plan → code → test** +loop against a subset of the same benchmark repos: + +```bash +# Runs every manifest entry flagged "fullExecution": true; --repo overrides and runs one entry. +MINER_CODING_AGENT_PROVIDER=... node packages/loopover-miner/scripts/cross-repo-evaluation.mjs --full-execution +``` + +It is **dry-run only**, the same read/execute-locally-and-discard posture as the readiness harness, one step +further: the coding agent edits a **throwaway local clone**, the harness captures the resulting diff with `git` +and runs the target repo's **own** build + test commands (from stack detection) locally. There is **no live +GitHub PR submission, no write access to the third-party repos, and no credentials beyond the local clone** — a +PR that adds real PR-submission against a benchmark repo does not satisfy this mode. + +Each subset repo still receives one **pass/fail** line in the same report format. A repo **passes** only when the +agent produced a real (non-empty) diff, it built, and the target test suite passed. The failure taxonomy extends +the readiness categories with execution-specific ones: + +| Category | Meaning | +| --- | --- | +| `execution_no_diff` | The agent ran (or could not be launched) but produced no usable diff | +| `execution_compile_gap` | The generated diff did not build | +| `execution_test_failure` | The diff built but the target repo's own test suite failed | +| `execution_noop_diff` | Tests passed only because the diff was a no-op (no file changes) | + +Readiness-stage failures (`stack_detection_gap`, `clone_setup`, `loopover_assumption`, `execution_gap`) still +apply and short-circuit before the agent runs — a repo the miner cannot even plan for never reaches execution. + +Library entry points: `executeRepoAttempt(entry, options)` and `runCrossRepoExecution(parsed, options)` classify +the outcome; the coding-agent step, build, and test runners are all injectable (the CLI wires the real +driver-backed executor; unit tests inject fakes). ## Library API @@ -73,6 +112,8 @@ Pure functions live in [`lib/cross-repo-evaluation.js`](../lib/cross-repo-evalua ## Wiring -This harness is **readiness-only**: it does not run the coding agent, open PRs, or call forge APIs. A green report -means the miner’s repo-agnostic stack-detection and coding-task-spec path is prepared for the benchmark repo; a live -attempt still needs credentials, governor policy, and queue state as documented in [`DEPLOYMENT.md`](../DEPLOYMENT.md). +The default mode is **readiness-only**: it does not run the coding agent, open PRs, or call forge APIs. A green +report means the miner’s repo-agnostic stack-detection and coding-task-spec path is prepared for the benchmark +repo. `--full-execution` (#7634) goes one step further and runs the agent locally against a throwaway clone, but +still opens no PRs and performs no forge writes. A production attempt against a real target 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..04325345e6 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts @@ -1,10 +1,15 @@ import type { RepoStackResult } from "./stack-detection.js"; -/** Failure taxonomy surfaced in per-repo reports (#4788). */ +/** Failure taxonomy surfaced in per-repo reports. Readiness-mode categories (#4788) plus the full-execution + * categories (#7634) that classify how a live discover → plan → code → test attempt fell short. */ export declare const CROSS_REPO_FAILURE_CATEGORY: Readonly<{ STACK_DETECTION: "stack_detection_gap"; EXECUTION: "execution_gap"; GITTENSOR_ASSUMPTION: "loopover_assumption"; CLONE_SETUP: "clone_setup"; + EXECUTION_NO_DIFF: "execution_no_diff"; + EXECUTION_COMPILE: "execution_compile_gap"; + EXECUTION_TEST: "execution_test_failure"; + EXECUTION_NOOP: "execution_noop_diff"; OTHER: "other"; }>; /** Instruction substrings that indicate a POSITIVE loopover/LoopOver CI assumption leaked into the agent prompt. @@ -21,6 +26,9 @@ export type CrossRepoEvaluationManifestRepo = { stackHint?: string; requireTestCommand?: boolean; fixturePath?: string; + /** Opt this entry into full-execution mode (#7634): `--full-execution` runs the live attempt against every + * entry flagged `true` (a `--repo` filter overrides the flag and runs that one entry regardless). */ + fullExecution?: boolean; }; export type ParsedCrossRepoEvaluationManifest = { present: boolean; @@ -67,6 +75,62 @@ type EvaluateRepoReadinessOptions = { instructions?: string; }; }; +/** Result of running a local shell command (build/test) during a full-execution attempt (#7634). */ +export type LocalCommandResult = { + ok: boolean; + /** True when there was no command to run (e.g. the stack inferred no build command) — treated as a pass. */ + skipped?: boolean; + code?: number | null; + output?: string; +}; +/** Everything a coding-agent executor needs to run one benchmark repo's live attempt (#7634). */ +export type CodingAttemptContext = { + repoFullName: string; + repoPath: string; + stack: RepoStackResult; + instructions: string; + attemptId: string; + maxTurns: number; +}; +/** What a coding-agent executor reports back: the real unified diff it produced (empty string when it made no + * change), plus whether the agent itself considered the run successful (#7634). */ +export type CodingAttemptOutcome = { + ok: boolean; + diff: string; + summary?: string; + error?: string; +}; +export type ExecuteRepoAttemptOptions = EvaluateRepoReadinessOptions & { + /** Discover → plan → code step: run the coding agent against the clone and return its diff. The CLI injects a + * real driver-backed executor; unit tests inject a fake. Left unset, the harness reports `execution_no_diff` + * rather than pretending an agent ran. */ + runCodingAttempt?: (context: CodingAttemptContext) => CodingAttemptOutcome | Promise; + /** Build/compile the clone after the diff is applied. Defaults to running `stack.buildCommand` locally. */ + compileRepo?: (context: { + repoPath: string; + stack: RepoStackResult; + }) => LocalCommandResult | Promise; + /** Run the target repo's own test suite locally. Defaults to running `stack.testCommand`. */ + runRepoTests?: (context: { + repoPath: string; + stack: RepoStackResult; + }) => LocalCommandResult | Promise; + /** Shared spawn used by the default compile/test runners; defaults to a real `spawnSync` in the clone dir. */ + runLocalCommand?: (command: string, context: { + cwd: string; + env?: NodeJS.ProcessEnv; + }) => LocalCommandResult; + /** Turn budget handed to the coding agent (CLI default: 30). */ + maxTurns?: number; +}; +export type CrossRepoExecutionResult = CrossRepoEvaluationResult & { + /** False when the attempt never reached the live agent (readiness gated it out). */ + executed: boolean; + compilePassed?: boolean | null; + testsPassed?: boolean | null; + /** Character length of the produced diff (0 for a no-op); null when no agent ran. */ + diffChars?: number | null; +}; /** Canonical `owner/repo` with exactly one slash and safe segments; anything else → null. */ export declare function normalizeCrossRepoFullName(value: unknown): string | null; /** @@ -92,6 +156,27 @@ export declare function evaluateRepoReadiness(entry: CrossRepoEvaluationManifest export declare function runCrossRepoEvaluation(parsed: ParsedCrossRepoEvaluationManifest, options?: { repoFilter?: string; } & EvaluateRepoReadinessOptions): CrossRepoEvaluationResult[]; +/** + * Run one benchmark repo's full-execution attempt (#7634): gate on readiness, then run the live discover → plan + * → code → test loop against the local clone and classify the outcome. Dry-run only — no forge writes, no PR + * submission; the agent edits a throwaway clone and the diff/results are discarded by the caller. + * + * The pipeline mirrors the failure taxonomy the issue calls for, in order: + * 1. readiness fails → the existing readiness category (attempt never starts; `executed: false`) + * 2. agent errors / no diff → `execution_no_diff` + * 3. diff doesn't build → `execution_compile_gap` + * 4. builds but tests fail → `execution_test_failure` + * 5. tests pass but diff no-op → `execution_noop_diff` + * 6. tests pass, real diff → PASS + */ +export declare function executeRepoAttempt(entry: CrossRepoEvaluationManifestRepo, options?: ExecuteRepoAttemptOptions): Promise; +/** + * Run the full-execution harness across a parsed manifest (#7634). Without a `repoFilter`, only entries flagged + * `fullExecution: true` run (the curated subset); a `repoFilter` overrides the flag and runs that one entry. + */ +export declare function runCrossRepoExecution(parsed: ParsedCrossRepoEvaluationManifest, options?: { + repoFilter?: string; +} & ExecuteRepoAttemptOptions): 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..a726c9de60 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.js +++ b/packages/loopover-miner/lib/cross-repo-evaluation.js @@ -3,17 +3,26 @@ // 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 { spawnSync } 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 { detectRepoStack } from "./stack-detection.js"; -/** Failure taxonomy surfaced in per-repo reports (#4788). */ +/** Failure taxonomy surfaced in per-repo reports. Readiness-mode categories (#4788) plus the full-execution + * categories (#7634) that classify how a live discover → plan → code → test attempt fell short. */ export const CROSS_REPO_FAILURE_CATEGORY = Object.freeze({ STACK_DETECTION: "stack_detection_gap", EXECUTION: "execution_gap", GITTENSOR_ASSUMPTION: "loopover_assumption", CLONE_SETUP: "clone_setup", + // Full-execution taxonomy (#7634): the plan formed and the coding agent ran, but the attempt failed at a + // later stage — the agent produced no usable diff, the diff didn't build, the target test suite failed, or + // the tests passed only because the diff was a no-op. + EXECUTION_NO_DIFF: "execution_no_diff", + EXECUTION_COMPILE: "execution_compile_gap", + EXECUTION_TEST: "execution_test_failure", + EXECUTION_NOOP: "execution_noop_diff", OTHER: "other", }); /** Instruction substrings that indicate a POSITIVE loopover/LoopOver CI assumption leaked into the agent prompt. @@ -97,6 +106,7 @@ function normalizeRepoList(value, warnings) { let stackHint = null; let requireTestCommand = false; let fixturePath = null; + let fullExecution = false; if (typeof entry === "string") { repoFullName = normalizeCrossRepoFullName(entry); } @@ -106,6 +116,7 @@ function normalizeRepoList(value, warnings) { stackHint = normalizeOptionalString(record.stackHint, "stackHint", warnings); requireTestCommand = normalizeBoolean(record.requireTestCommand, "requireTestCommand", false, warnings); fixturePath = normalizeOptionalString(record.fixturePath, "fixturePath", warnings); + fullExecution = normalizeBoolean(record.fullExecution, "fullExecution", false, warnings); } else { warnings.push(`CrossRepoEvaluationManifest "repos" skipped a non-string, non-mapping entry.`); @@ -125,6 +136,8 @@ function normalizeRepoList(value, warnings) { normalized.stackHint = stackHint; if (fixturePath) normalized.fixturePath = fixturePath; + if (fullExecution) + normalized.fullExecution = true; result.push(normalized); } return result; @@ -216,6 +229,23 @@ function resolveEvaluationRepoPath(entry, options = {}) { function defaultClaimLedger(repoFullName) { return { listClaims: () => [] }; } +/** Compose the synthetic coding-task spec both readiness and full-execution evaluate against, so the two modes + * drive the exact same discover/plan surface a real attempt would (#7634). */ +function buildEvaluationCodingTaskSpec(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, + }); +} /** * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). */ @@ -244,19 +274,7 @@ export function evaluateRepoReadiness(entry, options = {}) { } let specResult; try { - specResult = buildSpecImpl({ - repoFullName, - issue: { - number: 1, - title: "Cross-repo evaluation harness smoke issue", - body: "Synthetic issue used only by the cross-repo evaluation harness.", - labels: ["bug"], - }, - context: { issues: [{ number: 1 }], pullRequests: [] }, - claimLedger: defaultClaimLedger(repoFullName), - workingDirectory: repoPath, - detectRepoStack: detectImpl, - }); + specResult = buildEvaluationCodingTaskSpec(repoFullName, repoPath, buildSpecImpl, detectImpl); } catch (error) { const message = error instanceof Error ? error.message : String(error); @@ -288,6 +306,138 @@ export function runCrossRepoEvaluation(parsed, options = {}) { } return results; } +/** First non-empty line of command output, trimmed and length-capped, for a compact failure reason (#7634). */ +function firstOutputLine(output) { + if (typeof output !== "string") + return ""; + const line = output.split("\n").find((l) => l.trim().length > 0)?.trim() ?? ""; + return line.length > 200 ? `${line.slice(0, 200)}…` : line; +} +/** Real default local-command runner: a synchronous `sh -c` in the clone dir, resolve-not-throw so a non-zero + * exit becomes `ok: false` with its captured output rather than an exception (#7634). */ +function defaultRunLocalCommand(command, context) { + const result = spawnSync("sh", ["-c", command], { + cwd: context.cwd, + env: context.env ?? process.env, + encoding: "utf8", + }); + const output = `${result.stdout ?? ""}${result.stderr ?? ""}`; + if (result.error) { + return { ok: false, code: null, output: result.error.message }; + } + return { ok: result.status === 0, code: result.status, output }; +} +function runStackCommand(command, context, runLocalCommand, options) { + if (!command) + return { ok: true, skipped: true }; + return runLocalCommand(command, { + cwd: context.repoPath, + ...(options.env !== undefined ? { env: options.env } : {}), + }); +} +function executionResult(base, extra) { + return { ...base, executed: true, compilePassed: null, testsPassed: null, diffChars: null, ...extra }; +} +/** + * Run one benchmark repo's full-execution attempt (#7634): gate on readiness, then run the live discover → plan + * → code → test loop against the local clone and classify the outcome. Dry-run only — no forge writes, no PR + * submission; the agent edits a throwaway clone and the diff/results are discarded by the caller. + * + * The pipeline mirrors the failure taxonomy the issue calls for, in order: + * 1. readiness fails → the existing readiness category (attempt never starts; `executed: false`) + * 2. agent errors / no diff → `execution_no_diff` + * 3. diff doesn't build → `execution_compile_gap` + * 4. builds but tests fail → `execution_test_failure` + * 5. tests pass but diff no-op → `execution_noop_diff` + * 6. tests pass, real diff → PASS + */ +export async function executeRepoAttempt(entry, options = {}) { + const readiness = evaluateRepoReadiness(entry, options); + if (!readiness.passed) { + return { ...readiness, executed: false }; + } + const repoFullName = readiness.repoFullName; + const repoPath = resolveEvaluationRepoPath(entry, options); + const stack = readiness.stack; + const detectImpl = options.detectRepoStack ?? detectRepoStack; + const buildSpecImpl = options.buildCodingTaskSpec ?? buildCodingTaskSpec; + const runLocalCommand = options.runLocalCommand ?? defaultRunLocalCommand; + const compileImpl = options.compileRepo ?? ((context) => runStackCommand(context.stack.detected ? context.stack.buildCommand : null, context, runLocalCommand, options)); + const testImpl = options.runRepoTests ?? ((context) => runStackCommand(context.stack.detected ? context.stack.testCommand : null, context, runLocalCommand, options)); + // Re-derive the same coding-task instructions readiness already validated, to hand the live agent (#7634). + let instructions = ""; + try { + instructions = buildEvaluationCodingTaskSpec(repoFullName, repoPath, buildSpecImpl, detectImpl).instructions ?? ""; + } + catch { + instructions = ""; + } + // Stage 2 — discover → plan → code. Without an injected executor the harness will not fabricate a run. + if (typeof options.runCodingAttempt !== "function") { + return executionResult(buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF, "No coding-agent executor configured for full-execution mode (set MINER_CODING_AGENT_PROVIDER and run via the CLI).", { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }), { diffChars: null }); + } + let attempt; + try { + attempt = await options.runCodingAttempt({ + repoFullName, + repoPath, + stack, + instructions, + attemptId: `cross-repo-exec-${repoFullName.replace("/", "__")}`, + maxTurns: Number.isFinite(options.maxTurns) ? options.maxTurns : 30, + }); + } + catch (error) { + const message = error instanceof Error ? error.message : String(error); + return executionResult(buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF, `Coding agent did not run: ${message}`, { + stackDetected: true, + usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, + stack, + }), { diffChars: null }); + } + const diff = typeof attempt?.diff === "string" ? attempt.diff : ""; + if (!attempt || (attempt.ok === false && diff.trim().length === 0)) { + return executionResult(buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF, attempt?.error ?? "Coding agent reported failure and produced no diff.", { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }), { diffChars: diff.length }); + } + // Stage 3 — the produced diff must still build. + const compile = await compileImpl({ repoPath, stack }); + if (!compile.ok) { + return executionResult(buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION_COMPILE, `Generated diff did not build${firstOutputLine(compile.output) ? `: ${firstOutputLine(compile.output)}` : "."}`, { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }), { compilePassed: false, diffChars: diff.length }); + } + // Stage 4 — the target repo's own test suite must pass. + const test = await testImpl({ repoPath, stack }); + if (!test.ok) { + return executionResult(buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION_TEST, `Target test suite failed${firstOutputLine(test.output) ? `: ${firstOutputLine(test.output)}` : "."}`, { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }), { compilePassed: true, testsPassed: false, diffChars: diff.length }); + } + // Stage 5 — a passing run with no actual change is a no-op, not a success. + if (diff.trim().length === 0) { + return executionResult(buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NOOP, "Tests passed but the coding agent produced a no-op diff (no file changes).", { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }), { compilePassed: true, testsPassed: true, diffChars: 0 }); + } + return executionResult(buildPass(repoFullName, { usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }), { + compilePassed: true, + testsPassed: true, + diffChars: diff.length, + }); +} +/** + * Run the full-execution harness across a parsed manifest (#7634). Without a `repoFilter`, only entries flagged + * `fullExecution: true` run (the curated subset); a `repoFilter` overrides the flag and runs that one entry. + */ +export async function runCrossRepoExecution(parsed, options = {}) { + const repos = parsed?.manifest?.repos ?? []; + const results = []; + for (const entry of repos) { + if (options.repoFilter) { + if (entry.repoFullName !== options.repoFilter) + continue; + } + else if (entry.fullExecution !== true) { + continue; + } + results.push(await executeRepoAttempt(entry, options)); + } + return results; +} /** * Reduce per-repo results to pass/fail counts and whether a strict majority passed (#4788). */ @@ -343,4 +493,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..cfc0726c82 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.ts @@ -4,6 +4,7 @@ // 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 { spawnSync } from "node:child_process"; import { existsSync } from "node:fs"; import { join } from "node:path"; import { buildCodingTaskSpec } from "./coding-task-spec.js"; @@ -12,18 +13,30 @@ import { 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. Readiness-mode categories (#4788) plus the full-execution + * categories (#7634) that classify how a live discover → plan → code → test attempt fell short. */ export const CROSS_REPO_FAILURE_CATEGORY: Readonly<{ STACK_DETECTION: "stack_detection_gap"; EXECUTION: "execution_gap"; GITTENSOR_ASSUMPTION: "loopover_assumption"; CLONE_SETUP: "clone_setup"; + EXECUTION_NO_DIFF: "execution_no_diff"; + EXECUTION_COMPILE: "execution_compile_gap"; + EXECUTION_TEST: "execution_test_failure"; + EXECUTION_NOOP: "execution_noop_diff"; OTHER: "other"; }> = Object.freeze({ STACK_DETECTION: "stack_detection_gap", EXECUTION: "execution_gap", GITTENSOR_ASSUMPTION: "loopover_assumption", CLONE_SETUP: "clone_setup", + // Full-execution taxonomy (#7634): the plan formed and the coding agent ran, but the attempt failed at a + // later stage — the agent produced no usable diff, the diff didn't build, the target test suite failed, or + // the tests passed only because the diff was a no-op. + EXECUTION_NO_DIFF: "execution_no_diff", + EXECUTION_COMPILE: "execution_compile_gap", + EXECUTION_TEST: "execution_test_failure", + EXECUTION_NOOP: "execution_noop_diff", OTHER: "other", }); @@ -45,6 +58,9 @@ export type CrossRepoEvaluationManifestRepo = { stackHint?: string; requireTestCommand?: boolean; fixturePath?: string; + /** Opt this entry into full-execution mode (#7634): `--full-execution` runs the live attempt against every + * entry flagged `true` (a `--repo` filter overrides the flag and runs that one entry regardless). */ + fullExecution?: boolean; }; export type ParsedCrossRepoEvaluationManifest = { @@ -87,6 +103,58 @@ type EvaluateRepoReadinessOptions = { }; }; +/** Result of running a local shell command (build/test) during a full-execution attempt (#7634). */ +export type LocalCommandResult = { + ok: boolean; + /** True when there was no command to run (e.g. the stack inferred no build command) — treated as a pass. */ + skipped?: boolean; + code?: number | null; + output?: string; +}; + +/** Everything a coding-agent executor needs to run one benchmark repo's live attempt (#7634). */ +export type CodingAttemptContext = { + repoFullName: string; + repoPath: string; + stack: RepoStackResult; + instructions: string; + attemptId: string; + maxTurns: number; +}; + +/** What a coding-agent executor reports back: the real unified diff it produced (empty string when it made no + * change), plus whether the agent itself considered the run successful (#7634). */ +export type CodingAttemptOutcome = { + ok: boolean; + diff: string; + summary?: string; + error?: string; +}; + +export type ExecuteRepoAttemptOptions = EvaluateRepoReadinessOptions & { + /** Discover → plan → code step: run the coding agent against the clone and return its diff. The CLI injects a + * real driver-backed executor; unit tests inject a fake. Left unset, the harness reports `execution_no_diff` + * rather than pretending an agent ran. */ + runCodingAttempt?: (context: CodingAttemptContext) => CodingAttemptOutcome | Promise; + /** Build/compile the clone after the diff is applied. Defaults to running `stack.buildCommand` locally. */ + compileRepo?: (context: { repoPath: string; stack: RepoStackResult }) => LocalCommandResult | Promise; + /** Run the target repo's own test suite locally. Defaults to running `stack.testCommand`. */ + runRepoTests?: (context: { repoPath: string; stack: RepoStackResult }) => LocalCommandResult | Promise; + /** Shared spawn used by the default compile/test runners; defaults to a real `spawnSync` in the clone dir. */ + runLocalCommand?: (command: string, context: { cwd: string; env?: NodeJS.ProcessEnv }) => LocalCommandResult; + /** Turn budget handed to the coding agent (CLI default: 30). */ + maxTurns?: number; +}; + +export type CrossRepoExecutionResult = CrossRepoEvaluationResult & { + /** False when the attempt never reached the live agent (readiness gated it out). */ + executed: boolean; + compilePassed?: boolean | null; + testsPassed?: boolean | null; + /** Character length of the produced diff (0 for a no-op); null when no agent ran. */ + diffChars?: number | null; +}; + // True UTF-8 byte count for the size guard (#7223): JS string `.length` is UTF-16 code units, which under-counts // any multi-byte character (up to 4x for astral-plane code points), so `MAX_CROSS_REPO_MANIFEST_BYTES` -- named // and warned about in BYTES -- was actually being compared against a code-unit count. Mirrors the identical helper @@ -153,6 +221,7 @@ function normalizeRepoList(value: unknown, warnings: string[]): CrossRepoEvaluat let stackHint: string | null = null; let requireTestCommand = false; let fixturePath: string | null = null; + let fullExecution = false; if (typeof entry === "string") { repoFullName = normalizeCrossRepoFullName(entry); } else if (entry && typeof entry === "object" && !Array.isArray(entry)) { @@ -161,6 +230,7 @@ function normalizeRepoList(value: unknown, warnings: string[]): CrossRepoEvaluat stackHint = normalizeOptionalString(record.stackHint, "stackHint", warnings); requireTestCommand = normalizeBoolean(record.requireTestCommand, "requireTestCommand", false, warnings); fixturePath = normalizeOptionalString(record.fixturePath, "fixturePath", warnings); + fullExecution = normalizeBoolean(record.fullExecution, "fullExecution", false, warnings); } else { warnings.push(`CrossRepoEvaluationManifest "repos" skipped a non-string, non-mapping entry.`); continue; @@ -177,6 +247,7 @@ function normalizeRepoList(value: unknown, warnings: string[]): CrossRepoEvaluat const normalized: CrossRepoEvaluationManifestRepo = { repoFullName, requireTestCommand }; if (stackHint) normalized.stackHint = stackHint; if (fixturePath) normalized.fixturePath = fixturePath; + if (fullExecution) normalized.fullExecution = true; result.push(normalized); } return result; @@ -276,6 +347,31 @@ function defaultClaimLedger(repoFullName: string): { listClaims: () => never[] } return { listClaims: () => [] }; } +type BuildCodingTaskSpecImpl = NonNullable; + +/** Compose the synthetic coding-task spec both readiness and full-execution evaluate against, so the two modes + * drive the exact same discover/plan surface a real attempt would (#7634). */ +function buildEvaluationCodingTaskSpec( + repoFullName: string, + repoPath: string, + buildSpecImpl: BuildCodingTaskSpecImpl, + detectImpl: (repoPath: string) => RepoStackResult, +): ReturnType { + 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, + }); +} + /** * Evaluate one benchmark repo's miner readiness without running a live coding agent (#4788). */ @@ -332,19 +428,7 @@ export function evaluateRepoReadiness( let specResult; try { - specResult = buildSpecImpl({ - repoFullName, - issue: { - number: 1, - title: "Cross-repo evaluation harness smoke issue", - body: "Synthetic issue used only by the cross-repo evaluation harness.", - labels: ["bug"], - }, - context: { issues: [{ number: 1 }], pullRequests: [] }, - claimLedger: defaultClaimLedger(repoFullName), - workingDirectory: repoPath, - detectRepoStack: detectImpl, - }); + specResult = buildEvaluationCodingTaskSpec(repoFullName, repoPath, buildSpecImpl, detectImpl); } catch (error) { const message = error instanceof Error ? error.message : String(error); return buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.OTHER, message, { @@ -392,6 +476,210 @@ export function runCrossRepoEvaluation( return results; } +/** First non-empty line of command output, trimmed and length-capped, for a compact failure reason (#7634). */ +function firstOutputLine(output: string | undefined): string { + if (typeof output !== "string") return ""; + const line = output.split("\n").find((l) => l.trim().length > 0)?.trim() ?? ""; + return line.length > 200 ? `${line.slice(0, 200)}…` : line; +} + +/** Real default local-command runner: a synchronous `sh -c` in the clone dir, resolve-not-throw so a non-zero + * exit becomes `ok: false` with its captured output rather than an exception (#7634). */ +function defaultRunLocalCommand( + command: string, + context: { cwd: string; env?: NodeJS.ProcessEnv }, +): LocalCommandResult { + const result = spawnSync("sh", ["-c", command], { + cwd: context.cwd, + env: context.env ?? process.env, + encoding: "utf8", + }); + const output = `${result.stdout ?? ""}${result.stderr ?? ""}`; + if (result.error) { + return { ok: false, code: null, output: result.error.message }; + } + return { ok: result.status === 0, code: result.status, output }; +} + +function runStackCommand( + command: string | null, + context: { repoPath: string; stack: RepoStackResult }, + runLocalCommand: NonNullable, + options: ExecuteRepoAttemptOptions, +): LocalCommandResult { + if (!command) return { ok: true, skipped: true }; + return runLocalCommand(command, { + cwd: context.repoPath, + ...(options.env !== undefined ? { env: options.env } : {}), + }); +} + +function executionResult( + base: CrossRepoEvaluationResult, + extra: Partial, +): CrossRepoExecutionResult { + return { ...base, executed: true, compilePassed: null, testsPassed: null, diffChars: null, ...extra }; +} + +/** + * Run one benchmark repo's full-execution attempt (#7634): gate on readiness, then run the live discover → plan + * → code → test loop against the local clone and classify the outcome. Dry-run only — no forge writes, no PR + * submission; the agent edits a throwaway clone and the diff/results are discarded by the caller. + * + * The pipeline mirrors the failure taxonomy the issue calls for, in order: + * 1. readiness fails → the existing readiness category (attempt never starts; `executed: false`) + * 2. agent errors / no diff → `execution_no_diff` + * 3. diff doesn't build → `execution_compile_gap` + * 4. builds but tests fail → `execution_test_failure` + * 5. tests pass but diff no-op → `execution_noop_diff` + * 6. tests pass, real diff → PASS + */ +export async function executeRepoAttempt( + entry: CrossRepoEvaluationManifestRepo, + options: ExecuteRepoAttemptOptions = {}, +): Promise { + const readiness = evaluateRepoReadiness(entry, options); + if (!readiness.passed) { + return { ...readiness, executed: false }; + } + const repoFullName = readiness.repoFullName; + const repoPath = resolveEvaluationRepoPath(entry, options); + const stack = readiness.stack as RepoStackResult; + + const detectImpl = options.detectRepoStack ?? detectRepoStack; + const buildSpecImpl: BuildCodingTaskSpecImpl = + options.buildCodingTaskSpec ?? (buildCodingTaskSpec as unknown as BuildCodingTaskSpecImpl); + const runLocalCommand = options.runLocalCommand ?? defaultRunLocalCommand; + const compileImpl = + options.compileRepo ?? ((context) => runStackCommand(context.stack.detected ? context.stack.buildCommand : null, context, runLocalCommand, options)); + const testImpl = + options.runRepoTests ?? ((context) => runStackCommand(context.stack.detected ? context.stack.testCommand : null, context, runLocalCommand, options)); + + // Re-derive the same coding-task instructions readiness already validated, to hand the live agent (#7634). + let instructions = ""; + try { + instructions = buildEvaluationCodingTaskSpec(repoFullName, repoPath, buildSpecImpl, detectImpl).instructions ?? ""; + } catch { + instructions = ""; + } + + // Stage 2 — discover → plan → code. Without an injected executor the harness will not fabricate a run. + if (typeof options.runCodingAttempt !== "function") { + return executionResult( + buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF, + "No coding-agent executor configured for full-execution mode (set MINER_CODING_AGENT_PROVIDER and run via the CLI).", + { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }, + ), + { diffChars: null }, + ); + } + + let attempt: CodingAttemptOutcome; + try { + attempt = await options.runCodingAttempt({ + repoFullName, + repoPath, + stack, + instructions, + attemptId: `cross-repo-exec-${repoFullName.replace("/", "__")}`, + maxTurns: Number.isFinite(options.maxTurns) ? (options.maxTurns as number) : 30, + }); + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + return executionResult( + buildFailure(repoFullName, CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF, `Coding agent did not run: ${message}`, { + stackDetected: true, + usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, + stack, + }), + { diffChars: null }, + ); + } + + const diff = typeof attempt?.diff === "string" ? attempt.diff : ""; + if (!attempt || (attempt.ok === false && diff.trim().length === 0)) { + return executionResult( + buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF, + attempt?.error ?? "Coding agent reported failure and produced no diff.", + { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }, + ), + { diffChars: diff.length }, + ); + } + + // Stage 3 — the produced diff must still build. + const compile = await compileImpl({ repoPath, stack }); + if (!compile.ok) { + return executionResult( + buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION_COMPILE, + `Generated diff did not build${firstOutputLine(compile.output) ? `: ${firstOutputLine(compile.output)}` : "."}`, + { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }, + ), + { compilePassed: false, diffChars: diff.length }, + ); + } + + // Stage 4 — the target repo's own test suite must pass. + const test = await testImpl({ repoPath, stack }); + if (!test.ok) { + return executionResult( + buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION_TEST, + `Target test suite failed${firstOutputLine(test.output) ? `: ${firstOutputLine(test.output)}` : "."}`, + { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }, + ), + { compilePassed: true, testsPassed: false, diffChars: diff.length }, + ); + } + + // Stage 5 — a passing run with no actual change is a no-op, not a success. + if (diff.trim().length === 0) { + return executionResult( + buildFailure( + repoFullName, + CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NOOP, + "Tests passed but the coding agent produced a no-op diff (no file changes).", + { stackDetected: true, usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }, + ), + { compilePassed: true, testsPassed: true, diffChars: 0 }, + ); + } + + return executionResult(buildPass(repoFullName, { usedDefaultGoalSpec: readiness.usedDefaultGoalSpec, stack }), { + compilePassed: true, + testsPassed: true, + diffChars: diff.length, + }); +} + +/** + * Run the full-execution harness across a parsed manifest (#7634). Without a `repoFilter`, only entries flagged + * `fullExecution: true` run (the curated subset); a `repoFilter` overrides the flag and runs that one entry. + */ +export async function runCrossRepoExecution( + parsed: ParsedCrossRepoEvaluationManifest, + options: { repoFilter?: string } & ExecuteRepoAttemptOptions = {}, +): Promise { + const repos = parsed?.manifest?.repos ?? []; + const results: CrossRepoExecutionResult[] = []; + for (const entry of repos) { + if (options.repoFilter) { + if (entry.repoFullName !== options.repoFilter) continue; + } else if (entry.fullExecution !== true) { + continue; + } + results.push(await executeRepoAttempt(entry, options)); + } + return results; +} + /** * Reduce per-repo results to pass/fail counts and whether a strict majority passed (#4788). */ diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts index c263aa2347..74826999d6 100644 --- a/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts +++ b/packages/loopover-miner/scripts/cross-repo-evaluation.d.mts @@ -1,11 +1,23 @@ import type { + CodingAttemptContext, + CodingAttemptOutcome, CrossRepoEvaluationResult, CrossRepoEvaluationSummary, + CrossRepoExecutionResult, + ExecuteRepoAttemptOptions, + LocalCommandResult, ParsedCrossRepoEvaluationManifest, } from "../lib/cross-repo-evaluation.js"; +import type { CodingAgentDriver } from "@loopover/engine"; 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 +27,9 @@ export type CrossRepoEvaluationCliOptions = { repoFilter?: string | null; }; +export type CrossRepoExecutionCliOptions = CrossRepoEvaluationCliOptions & + Pick; + export declare function resolveDefaultManifestPath(): string; export declare function parseCrossRepoEvaluationArgs(argv?: readonly string[]): CrossRepoEvaluationCliArgs; @@ -26,3 +41,14 @@ export declare function runCrossRepoEvaluationCli(options?: CrossRepoEvaluationC results: CrossRepoEvaluationResult[]; summary: CrossRepoEvaluationSummary; }; + +export declare function defaultFullExecutionCodingAttempt( + context: CodingAttemptContext, + deps?: { env?: NodeJS.ProcessEnv; driver?: CodingAgentDriver; spawnSync?: typeof import("node:child_process").spawnSync }, +): Promise; + +export declare function runCrossRepoExecutionCli(options?: CrossRepoExecutionCliOptions): Promise<{ + parsed: ParsedCrossRepoEvaluationManifest; + results: CrossRepoExecutionResult[]; + summary: CrossRepoEvaluationSummary; +}>; diff --git a/packages/loopover-miner/scripts/cross-repo-evaluation.mjs b/packages/loopover-miner/scripts/cross-repo-evaluation.mjs index 04de1d9fa4..7f60654365 100644 --- a/packages/loopover-miner/scripts/cross-repo-evaluation.mjs +++ b/packages/loopover-miner/scripts/cross-repo-evaluation.mjs @@ -1,12 +1,16 @@ #!/usr/bin/env node -import { readFileSync } from "node:fs"; +import { spawnSync } from "node:child_process"; +import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; import { dirname, join } from "node:path"; import { fileURLToPath, pathToFileURL } from "node:url"; +import { constructProductionCodingAgentDriver } from "../lib/coding-agent-construction.js"; import { DEFAULT_CROSS_REPO_MANIFEST_RELATIVE_PATH, formatCrossRepoEvaluationReport, parseCrossRepoEvaluationManifest, runCrossRepoEvaluation, + runCrossRepoExecution, summarizeCrossRepoEvaluation, } from "../lib/cross-repo-evaluation.js"; @@ -22,6 +26,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 +37,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 +60,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 +75,56 @@ export function runCrossRepoEvaluationCli(options = {}) { return { parsed, results, summary }; } +// Real, dry-run full-execution coding attempt (#7634): resolve the configured coding agent, let it edit the +// local clone, then capture the resulting diff with git -- all against a throwaway clone, no forge writes. +// `git add -A` before the diff so brand-new untracked files count; the acceptance-criteria file is written to +// the OS temp dir (never the clone) so it can't leak into the captured diff. +export async function defaultFullExecutionCodingAttempt(context, deps = {}) { + const env = deps.env ?? process.env; + const driver = deps.driver ?? constructProductionCodingAgentDriver(env); + const scratch = mkdtempSync(join(tmpdir(), "loopover-cross-repo-exec-")); + const acceptanceCriteriaPath = join(scratch, "acceptance-criteria.md"); + writeFileSync(acceptanceCriteriaPath, context.instructions || "Address the synthetic benchmark issue.", "utf8"); + try { + const result = await driver.run({ + attemptId: context.attemptId, + workingDirectory: context.repoPath, + acceptanceCriteriaPath, + instructions: context.instructions, + maxTurns: context.maxTurns, + }); + const spawn = deps.spawnSync ?? spawnSync; + spawn("git", ["add", "-A"], { cwd: context.repoPath }); + const diffResult = spawn("git", ["--no-pager", "diff", "--cached"], { + cwd: context.repoPath, + encoding: "utf8", + maxBuffer: 64 * 1024 * 1024, + }); + const diff = typeof diffResult.stdout === "string" ? diffResult.stdout : ""; + return { ok: result.ok === true, diff, summary: result.summary, error: result.error }; + } finally { + rmSync(scratch, { recursive: true, force: true }); + } +} + +export async function runCrossRepoExecutionCli(options = {}) { + const parsed = options.parsed ?? loadCrossRepoEvaluationManifest(options.manifestPath ?? resolveDefaultManifestPath()); + const env = options.env ?? process.env; + const runCodingAttempt = + options.runCodingAttempt ?? ((context) => defaultFullExecutionCodingAttempt(context, { env })); + const results = await runCrossRepoExecution(parsed, { + repoFilter: options.repoFilter ?? null, + runCodingAttempt, + env, + ...(options.compileRepo ? { compileRepo: options.compileRepo } : {}), + ...(options.runRepoTests ? { runRepoTests: options.runRepoTests } : {}), + ...(options.runLocalCommand ? { runLocalCommand: options.runLocalCommand } : {}), + ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}), + }); + const summary = summarizeCrossRepoEvaluation(results); + return { parsed, results, summary }; +} + function printHelp() { console.log( [ @@ -79,6 +138,10 @@ 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 the live discover→plan→code→test loop (#7634) against the", + " fullExecution subset, generating a real diff and running each repo's", + " own test suite locally — no PR submission, no forge writes. Requires a", + " configured coding agent (MINER_CODING_AGENT_PROVIDER).", " -h, --help Show this help", "", "Prerequisite: clone benchmark repos into LOOPOVER_MINER_REPO_CLONE_DIR (see docs/cross-repo-evaluation.md).", @@ -86,7 +149,7 @@ function printHelp() { ); } -function main() { +async function main() { const parsedArgs = parseCrossRepoEvaluationArgs(); if (parsedArgs.help) { printHelp(); @@ -97,7 +160,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 +177,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..50743ebfd8 100644 --- a/test/unit/miner-cross-repo-evaluation.test.ts +++ b/test/unit/miner-cross-repo-evaluation.test.ts @@ -11,20 +11,25 @@ import { CROSS_REPO_FAILURE_CATEGORY, DEFAULT_CROSS_REPO_MANIFEST_RELATIVE_PATH, MAX_CROSS_REPO_MANIFEST_BYTES, + executeRepoAttempt, formatCrossRepoEvaluationReport, evaluateRepoReadiness, normalizeCrossRepoFullName, parseCrossRepoEvaluationManifest, runCrossRepoEvaluation, + runCrossRepoExecution, scanPositiveLoopoverAssumptions, summarizeCrossRepoEvaluation, } from "../../packages/loopover-miner/lib/cross-repo-evaluation.js"; +import type { CodingAttemptContext } from "../../packages/loopover-miner/lib/cross-repo-evaluation.js"; import type { RepoStackResult } from "../../packages/loopover-miner/lib/stack-detection.js"; import { + defaultFullExecutionCodingAttempt, loadCrossRepoEvaluationManifest, parseCrossRepoEvaluationArgs, resolveDefaultManifestPath, runCrossRepoEvaluationCli, + runCrossRepoExecutionCli, } from "../../packages/loopover-miner/scripts/cross-repo-evaluation.mjs"; const roots: string[] = []; @@ -166,6 +171,26 @@ describe("cross-repo evaluation harness (#4788)", () => { expect(parsed.manifest.repos[0]?.fixturePath).toBeUndefined(); expect(parsed.warnings).toEqual([]); }); + + it("parses the fullExecution flag, attaching it only when true (#7634)", () => { + const parsed = parseCrossRepoEvaluationManifest( + JSON.stringify({ + repos: [ + { repoFullName: "acme/on", fullExecution: true }, + { repoFullName: "acme/off", fullExecution: false }, + { repoFullName: "acme/absent" }, + { repoFullName: "acme/bad", fullExecution: "yes" }, + ], + }), + ); + expect(parsed.manifest.repos).toEqual([ + { repoFullName: "acme/on", requireTestCommand: false, fullExecution: true }, + { repoFullName: "acme/off", requireTestCommand: false }, + { repoFullName: "acme/absent", requireTestCommand: false }, + { repoFullName: "acme/bad", requireTestCommand: false }, + ]); + expect(parsed.warnings.some((w) => w.includes("fullExecution"))).toBe(true); + }); }); describe("scanPositiveLoopoverAssumptions", () => { @@ -495,6 +520,7 @@ 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" }); @@ -528,6 +554,237 @@ describe("cross-repo evaluation harness (#4788)", () => { }); }); + describe("full-execution mode (#7634)", () => { + const nodeRepo = () => tempRepo({ "package.json": pkg({ scripts: { test: "node --test" } }) }); + const okAttempt = (diff: string) => () => Promise.resolve({ ok: true, diff }); + + it("passes readiness failures straight through with executed:false", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/missing", requireTestCommand: false }, + { repoPath: "/tmp/definitely-missing", existsSync: () => false, runCodingAttempt: okAttempt("x") }, + ); + expect(result.executed).toBe(false); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.CLONE_SETUP); + }); + + it("reports execution_no_diff when no coding-agent executor is configured", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/unwired", requireTestCommand: false }, + { repoPath: nodeRepo(), existsSync: () => true }, + ); + expect(result.executed).toBe(true); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF); + expect(result.reason).toContain("No coding-agent executor"); + }); + + it("reports execution_no_diff when the agent throws", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/boom", requireTestCommand: false }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: () => { + throw new Error("driver exploded"); + }, + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF); + expect(result.reason).toContain("driver exploded"); + expect(result.diffChars).toBeNull(); + }); + + it("reports execution_no_diff when the agent fails and produces no diff", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/empty", requireTestCommand: false }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: () => Promise.resolve({ ok: false, diff: " ", error: "agent gave up" }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NO_DIFF); + expect(result.reason).toBe("agent gave up"); + }); + + it("reports execution_compile_gap when the generated diff does not build", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/nobuild", requireTestCommand: false }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: okAttempt("diff --git a/x b/x\n+broken"), + compileRepo: () => ({ ok: false, code: 1, output: "SyntaxError: bad token\nmore" }), + runRepoTests: () => ({ ok: true }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION_COMPILE); + expect(result.compilePassed).toBe(false); + expect(result.testsPassed).toBeNull(); + expect(result.reason).toContain("SyntaxError: bad token"); + }); + + it("reports execution_test_failure when the built diff fails the target test suite", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/redtests", requireTestCommand: false }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: okAttempt("diff --git a/x b/x\n+change"), + compileRepo: () => ({ ok: true }), + runRepoTests: () => ({ ok: false, code: 1, output: "1 failing" }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION_TEST); + expect(result.compilePassed).toBe(true); + expect(result.testsPassed).toBe(false); + expect(result.reason).toContain("1 failing"); + }); + + it("reports execution_noop_diff when tests pass but the diff is empty", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/noop", requireTestCommand: false }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: okAttempt(" \n "), + compileRepo: () => ({ ok: true }), + runRepoTests: () => ({ ok: true }), + }, + ); + expect(result.failureCategory).toBe(CROSS_REPO_FAILURE_CATEGORY.EXECUTION_NOOP); + expect(result.testsPassed).toBe(true); + expect(result.diffChars).toBe(0); + }); + + it("passes end-to-end when a real diff builds and the tests pass", async () => { + const result = await executeRepoAttempt( + { repoFullName: "acme/green", requireTestCommand: false }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: okAttempt("diff --git a/x b/x\n+real change"), + compileRepo: () => ({ ok: true }), + runRepoTests: () => ({ ok: true }), + }, + ); + expect(result.passed).toBe(true); + expect(result.executed).toBe(true); + expect(result.compilePassed).toBe(true); + expect(result.testsPassed).toBe(true); + expect(result.diffChars).toBeGreaterThan(0); + }); + + it("uses the default compile/test runners via an injected runLocalCommand (skips a null build command)", async () => { + const commands: string[] = []; + const result = await executeRepoAttempt( + { repoFullName: "acme/defaults", requireTestCommand: true }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: okAttempt("diff --git a/x b/x\n+change"), + runLocalCommand: (command) => { + commands.push(command); + return { ok: true, code: 0, output: "" }; + }, + }, + ); + expect(result.passed).toBe(true); + // The plain-Node repo has a test script but no build script, so only the inferred test command is spawned. + expect(commands).toEqual(["npm test"]); + }); + + it("threads the derived instructions and attemptId into the coding agent", async () => { + let seen: CodingAttemptContext | null = null; + const result = await executeRepoAttempt( + { repoFullName: "acme/threaded", requireTestCommand: false }, + { + repoPath: nodeRepo(), + existsSync: () => true, + runCodingAttempt: (context) => { + seen = context; + return Promise.resolve({ ok: true, diff: "diff --git a/x b/x\n+c" }); + }, + compileRepo: () => ({ ok: true }), + runRepoTests: () => ({ ok: true }), + }, + ); + expect(result.passed).toBe(true); + expect(seen).not.toBeNull(); + expect(seen!.attemptId).toBe("cross-repo-exec-acme__threaded"); + expect(typeof seen!.instructions).toBe("string"); + }); + + it("runCrossRepoExecution runs only fullExecution entries, and a repoFilter overrides the flag", async () => { + const parsed = parseCrossRepoEvaluationManifest( + JSON.stringify({ + repos: [ + { repoFullName: "acme/a", fullExecution: true }, + { repoFullName: "acme/b" }, + { repoFullName: "acme/c", fullExecution: true }, + ], + }), + ); + const opts = { existsSync: () => false, runCodingAttempt: okAttempt("x") }; + + const subset = await runCrossRepoExecution(parsed, opts); + expect(subset.map((r) => r.repoFullName)).toEqual(["acme/a", "acme/c"]); + + const filtered = await runCrossRepoExecution(parsed, { ...opts, repoFilter: "acme/b" }); + expect(filtered.map((r) => r.repoFullName)).toEqual(["acme/b"]); + }); + + it("defaultFullExecutionCodingAttempt runs the driver then captures the staged diff via git", async () => { + const calls: string[][] = []; + const fakeDriver = { + run: async () => ({ ok: true, changedFiles: ["x"], summary: "done" }), + }; + const fakeSpawn = ((cmd: string, args: string[]) => { + calls.push([cmd, ...args]); + return args.includes("diff") + ? { stdout: "diff --git a/x b/x\n+1", status: 0 } + : { stdout: "", status: 0 }; + }) as never; + + const outcome = await defaultFullExecutionCodingAttempt( + { + repoFullName: "acme/x", + repoPath: nodeRepo(), + stack: { detected: true } as never, + instructions: "do the thing", + attemptId: "a1", + maxTurns: 5, + }, + { driver: fakeDriver, spawnSync: fakeSpawn }, + ); + expect(outcome.ok).toBe(true); + expect(outcome.diff).toContain("diff --git"); + expect(calls[0]).toEqual(["git", "add", "-A"]); + expect(calls[1]).toEqual(["git", "--no-pager", "diff", "--cached"]); + }); + + it("runCrossRepoExecutionCli drives a fixture manifest with injected primitives", async () => { + const repoPath = nodeRepo(); + const manifestDir = tempRepo(); + writeFileSync( + join(manifestDir, "manifest.json"), + JSON.stringify({ + repos: [{ repoFullName: "acme/fixture", fixturePath: repoPath, requireTestCommand: true, fullExecution: true }], + }), + "utf8", + ); + + const { results, summary } = await runCrossRepoExecutionCli({ + manifestPath: join(manifestDir, "manifest.json"), + runCodingAttempt: okAttempt("diff --git a/x b/x\n+shipped"), + compileRepo: () => ({ ok: true }), + runRepoTests: () => ({ ok: true }), + }); + expect(results[0]?.passed).toBe(true); + expect(results[0]?.executed).toBe(true); + expect(summary.passed).toBe(1); + }); + }); + it("documents the harness in packages/loopover-miner/docs/cross-repo-evaluation.md", () => { const doc = readFileSync(join(process.cwd(), "packages/loopover-miner/docs/cross-repo-evaluation.md"), "utf8"); expect(doc).toContain("#4788"); @@ -535,4 +792,13 @@ describe("cross-repo evaluation harness (#4788)", () => { expect(doc).toContain("cross-repo-evaluation.mjs"); expect(doc).toContain("benchmarks/cross-repo/manifest.json"); }); + + it("documents the full-execution mode and its taxonomy (#7634)", () => { + const doc = readFileSync(join(process.cwd(), "packages/loopover-miner/docs/cross-repo-evaluation.md"), "utf8"); + expect(doc).toContain("--full-execution"); + expect(doc).toContain("#7634"); + expect(doc).toContain("execution_compile_gap"); + expect(doc).toContain("execution_test_failure"); + expect(doc).toContain("execution_noop_diff"); + }); }); From 62d411e658ab34f7fad73c35eb47ab2e97403795 Mon Sep 17 00:00:00 2001 From: bitfathers94 <237535319+bitfathers94@users.noreply.github.com> Date: Tue, 21 Jul 2026 06:03:03 +0000 Subject: [PATCH 2/2] fix(miner): run detected stack commands without a shell to close a P1 injection surface defaultRunLocalCommand executed `sh -c ` where the command is derived from untrusted cloned-repo metadata (e.g. a crafted package.json script name), so shell metacharacters could inject extra commands on the evaluating host. Split the command into a plain argv and spawn it directly with `shell: false`; stack commands are already whitespace-separated argv. Adds direct unit tests covering the no-shell argv, inert-metacharacter, spawn-error, and empty-command paths. --- .../lib/cross-repo-evaluation.d.ts | 10 ++++ .../lib/cross-repo-evaluation.js | 17 ++++-- .../lib/cross-repo-evaluation.ts | 15 ++++-- test/unit/miner-cross-repo-evaluation.test.ts | 52 +++++++++++++++++++ 4 files changed, 85 insertions(+), 9 deletions(-) diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts index 04325345e6..d0cb1639f2 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.d.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.d.ts @@ -1,3 +1,4 @@ +import { spawnSync } from "node:child_process"; import type { RepoStackResult } from "./stack-detection.js"; /** Failure taxonomy surfaced in per-repo reports. Readiness-mode categories (#4788) plus the full-execution * categories (#7634) that classify how a live discover → plan → code → test attempt fell short. */ @@ -156,6 +157,15 @@ export declare function evaluateRepoReadiness(entry: CrossRepoEvaluationManifest export declare function runCrossRepoEvaluation(parsed: ParsedCrossRepoEvaluationManifest, options?: { repoFilter?: string; } & EvaluateRepoReadinessOptions): CrossRepoEvaluationResult[]; +/** Real default local-command runner: split the detected command into an argv and spawn it directly in the clone + * dir with NO shell (`shell: false`), so shell metacharacters in untrusted repo metadata (e.g. a crafted + * package.json script name) cannot inject extra commands (#7641). Stack commands are plain whitespace-separated + * argv (`npm run build`, `cargo test`, `go build ./...`). Resolve-not-throw: a non-zero exit becomes `ok: false` + * with its captured output rather than an exception (#7634). Exported for direct unit coverage. */ +export declare function defaultRunLocalCommand(command: string, context: { + cwd: string; + env?: NodeJS.ProcessEnv; +}, spawn?: typeof spawnSync): LocalCommandResult; /** * Run one benchmark repo's full-execution attempt (#7634): gate on readiness, then run the live discover → plan * → code → test loop against the local clone and classify the outcome. Dry-run only — no forge writes, no PR diff --git a/packages/loopover-miner/lib/cross-repo-evaluation.js b/packages/loopover-miner/lib/cross-repo-evaluation.js index a726c9de60..c1afb90201 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.js +++ b/packages/loopover-miner/lib/cross-repo-evaluation.js @@ -313,13 +313,20 @@ function firstOutputLine(output) { const line = output.split("\n").find((l) => l.trim().length > 0)?.trim() ?? ""; return line.length > 200 ? `${line.slice(0, 200)}…` : line; } -/** Real default local-command runner: a synchronous `sh -c` in the clone dir, resolve-not-throw so a non-zero - * exit becomes `ok: false` with its captured output rather than an exception (#7634). */ -function defaultRunLocalCommand(command, context) { - const result = spawnSync("sh", ["-c", command], { +/** Real default local-command runner: split the detected command into an argv and spawn it directly in the clone + * dir with NO shell (`shell: false`), so shell metacharacters in untrusted repo metadata (e.g. a crafted + * package.json script name) cannot inject extra commands (#7641). Stack commands are plain whitespace-separated + * argv (`npm run build`, `cargo test`, `go build ./...`). Resolve-not-throw: a non-zero exit becomes `ok: false` + * with its captured output rather than an exception (#7634). Exported for direct unit coverage. */ +export function defaultRunLocalCommand(command, context, spawn = spawnSync) { + const [file, ...args] = command.trim().split(/\s+/).filter(Boolean); + if (!file) + return { ok: false, code: null, output: "empty command" }; + const result = spawn(file, args, { cwd: context.cwd, env: context.env ?? process.env, encoding: "utf8", + shell: false, }); const output = `${result.stdout ?? ""}${result.stderr ?? ""}`; if (result.error) { @@ -493,4 +500,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":"AAAA,iHAAiH;AACjH,8GAA8G;AAC9G,2GAA2G;AAC3G,6GAA6G;AAC7G,qGAAqG;AAErG,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD;oGACoG;AACpG,MAAM,CAAC,MAAM,2BAA2B,GAUnC,MAAM,CAAC,MAAM,CAAC;IACjB,eAAe,EAAE,qBAAqB;IACtC,SAAS,EAAE,eAAe;IAC1B,oBAAoB,EAAE,qBAAqB;IAC3C,WAAW,EAAE,aAAa;IAC1B,yGAAyG;IACzG,2GAA2G;IAC3G,sDAAsD;IACtD,iBAAiB,EAAE,mBAAmB;IACtC,iBAAiB,EAAE,uBAAuB;IAC1C,cAAc,EAAE,wBAAwB;IACxC,cAAc,EAAE,qBAAqB;IACrC,KAAK,EAAE,OAAO;CACf,CAAC,CAAC;AAEH;mGACmG;AACnG,MAAM,CAAC,MAAM,oCAAoC,GAAmD,MAAM,CAAC,MAAM,CAAC;IAChH,EAAE,EAAE,EAAE,gBAAgB,EAAE,OAAO,EAAE,kBAAkB,EAAE;IACrD,EAAE,EAAE,EAAE,eAAe,EAAE,OAAO,EAAE,iBAAiB,EAAE;IACnD,EAAE,EAAE,EAAE,iBAAiB,EAAE,OAAO,EAAE,qCAAqC,EAAE;IACzE,EAAE,EAAE,EAAE,eAAe,EAAE,OAAO,EAAE,gBAAgB,EAAE;CACnD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yCAAyC,GAAW,qCAAqC,CAAC;AACvG,MAAM,CAAC,MAAM,6BAA6B,GAAW,MAAM,CAAC;AAC5D,MAAM,CAAC,MAAM,6BAA6B,GAAW,GAAG,CAAC;AAwGzD,iHAAiH;AACjH,gHAAgH;AAChH,mHAAmH;AACnH,+GAA+G;AAC/G,0BAA0B;AAC1B,SAAS,cAAc,CAAC,KAAa;IACnC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC;QACvC,IAAI,SAAS,IAAI,IAAI;YAAE,KAAK,IAAI,CAAC,CAAC;aAC7B,IAAI,SAAS,IAAI,KAAK;YAAE,KAAK,IAAI,CAAC,CAAC;aACnC,IAAI,SAAS,IAAI,MAAM;YAAE,KAAK,IAAI,CAAC,CAAC;;YACpC,KAAK,IAAI,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,kBAAkB,CAAC,WAAqB,EAAE;IACjD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC;AAC/D,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,0BAA0B,CAAC,KAAc;IACvD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC3C,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACrD,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACxD,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACzE,OAAO,GAAG,KAAK,IAAI,IAAI,EAAE,CAAC;AAC5B,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc,EAAE,KAAa,EAAE,QAAiB,EAAE,QAAkB;IAC5F,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,QAAQ,CAAC;IAC3D,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IAC7C,QAAQ,CAAC,IAAI,CAAC,sCAAsC,KAAK,wCAAwC,QAAQ,GAAG,CAAC,CAAC;IAC9G,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,uBAAuB,CAAC,KAAc,EAAE,KAAa,EAAE,QAAkB;IAChF,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACvD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,sCAAsC,KAAK,yCAAyC,CAAC,CAAC;QACpG,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,OAAO,OAAO,IAAI,IAAI,CAAC;AACzB,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAc,EAAE,QAAkB;IAC3D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,EAAE,CAAC;IACrD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,QAAQ,CAAC,IAAI,CAAC,wEAAwE,OAAO,KAAK,SAAS,CAAC,CAAC;QAC7G,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,MAAM,MAAM,GAAsC,EAAE,CAAC;IACrD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;QAC7C,IAAI,KAAK,IAAI,6BAA6B,EAAE,CAAC;YAC3C,QAAQ,CAAC,IAAI,CACX,sDAAsD,6BAA6B,kCAAkC,CACtH,CAAC;YACF,MAAM;QACR,CAAC;QACD,IAAI,YAAY,GAAkB,IAAI,CAAC;QACvC,IAAI,SAAS,GAAkB,IAAI,CAAC;QACpC,IAAI,kBAAkB,GAAG,KAAK,CAAC;QAC/B,IAAI,WAAW,GAAkB,IAAI,CAAC;QACtC,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,YAAY,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;QACnD,CAAC;aAAM,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACvE,MAAM,MAAM,GAAG,KAAgC,CAAC;YAChD,YAAY,GAAG,0BAA0B,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAC/D,SAAS,GAAG,uBAAuB,CAAC,MAAM,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;YAC7E,kBAAkB,GAAG,gBAAgB,CAAC,MAAM,CAAC,kBAAkB,EAAE,oBAAoB,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YACxG,WAAW,GAAG,uBAAuB,CAAC,MAAM,CAAC,WAAW,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC;YACnF,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,aAAa,EAAE,eAAe,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC3F,CAAC;aAAM,CAAC;YACN,QAAQ,CAAC,IAAI,CAAC,8EAA8E,CAAC,CAAC;YAC9F,SAAS;QACX,CAAC;QACD,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YAC1B,QAAQ,CAAC,IAAI,CAAC,yFAAyF,CAAC,CAAC;YACzG,SAAS;QACX,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YAC3B,QAAQ,CAAC,IAAI,CAAC,qEAAqE,YAAY,GAAG,CAAC,CAAC;YACpG,SAAS;QACX,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACvB,MAAM,UAAU,GAAoC,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC;QACzF,IAAI,SAAS;YAAE,UAAU,CAAC,SAAS,GAAG,SAAS,CAAC;QAChD,IAAI,WAAW;YAAE,UAAU,CAAC,WAAW,GAAG,WAAW,CAAC;QACtD,IAAI,aAAa;YAAE,UAAU,CAAC,aAAa,GAAG,IAAI,CAAC;QACnD,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gCAAgC,CAC9C,OAAkC;IAElC,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,kBAAkB,EAAE,CAAC;IAC3E,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,OAAO,kBAAkB,CAAC,CAAC,6DAA6D,OAAO,OAAO,GAAG,CAAC,CAAC,CAAC;IAC9G,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,IAAI,CAAC,OAAO;QAAE,OAAO,kBAAkB,EAAE,CAAC;IAC1C,IAAI,cAAc,CAAC,OAAO,CAAC,GAAG,6BAA6B,EAAE,CAAC;QAC5D,OAAO,kBAAkB,CAAC;YACxB,wCAAwC,6BAA6B,4BAA4B;SAClG,CAAC,CAAC;IACL,CAAC;IACD,IAAI,GAAY,CAAC;IACjB,IAAI,CAAC;QACH,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,kBAAkB,CAAC,CAAC,gDAAgD,CAAC,CAAC,CAAC;IAChF,CAAC;IACD,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1D,OAAO,kBAAkB,CAAC,CAAC,yDAAyD,CAAC,CAAC,CAAC;IACzF,CAAC;IACD,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,MAAM,KAAK,GAAG,iBAAiB,CAAE,GAA2B,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC9E,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,CAAC;AAC1D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,+BAA+B,CAAC,IAAY;IAC1D,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACxC,MAAM,QAAQ,GAAwC,EAAE,CAAC;IACzD,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC;YAAE,SAAS;QACzD,KAAK,MAAM,KAAK,IAAI,oCAAoC,EAAE,CAAC;YACzD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC;gBAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,YAAY,CACnB,YAAoB,EACpB,QAAgB,EAChB,MAAc,EACd,QAA4C,EAAE;IAE9C,OAAO;QACL,YAAY;QACZ,MAAM,EAAE,KAAK;QACb,eAAe,EAAE,QAAQ;QACzB,MAAM;QACN,aAAa,EAAE,KAAK;QACpB,mBAAmB,EAAE,IAAI;QACzB,kBAAkB,EAAE,EAAE;QACtB,GAAG,KAAK;KACT,CAAC;AACJ,CAAC;AAED,SAAS,SAAS,CAAC,YAAoB,EAAE,QAA4C,EAAE;IACrF,OAAO;QACL,YAAY;QACZ,MAAM,EAAE,IAAI;QACZ,eAAe,EAAE,IAAI;QACrB,MAAM,EAAE,IAAI;QACZ,aAAa,EAAE,IAAI;QACnB,mBAAmB,EAAE,IAAI;QACzB,kBAAkB,EAAE,EAAE;QACtB,GAAG,KAAK;KACT,CAAC;AACJ,CAAC;AAED,SAAS,yBAAyB,CAChC,KAAsC,EACtC,UAAwC,EAAE;IAE1C,IAAI,KAAK,CAAC,WAAW,IAAI,OAAO,KAAK,CAAC,WAAW,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC,WAAW,CAAC;IACzF,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE;QAAE,OAAO,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACpG,IAAI,OAAO,OAAO,CAAC,eAAe,KAAK,UAAU;QAAE,OAAO,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IACzF,OAAO,mBAAmB,CAAC,KAAK,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,kBAAkB,CAAC,YAAoB;IAC9C,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;AAClC,CAAC;AAID;+EAC+E;AAC/E,SAAS,6BAA6B,CACpC,YAAoB,EACpB,QAAgB,EAChB,aAAsC,EACtC,UAAiD;IAEjD,OAAO,aAAa,CAAC;QACnB,YAAY;QACZ,KAAK,EAAE;YACL,MAAM,EAAE,CAAC;YACT,KAAK,EAAE,2CAA2C;YAClD,IAAI,EAAE,iEAAiE;YACvE,MAAM,EAAE,CAAC,KAAK,CAAC;SAChB;QACD,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE;QACtD,WAAW,EAAE,kBAAkB,CAAC,YAAY,CAAC;QAC7C,gBAAgB,EAAE,QAAQ;QAC1B,eAAe,EAAE,UAAU;KAC5B,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAsC,EACtC,UAAwC,EAAE;IAE1C,MAAM,YAAY,GAAG,KAAK,EAAE,YAAY,CAAC;IACzC,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,0BAA0B,CAAC,YAAY,CAAC,EAAE,CAAC;QAClF,OAAO,YAAY,CACjB,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,EAC7D,2BAA2B,CAAC,KAAK,EACjC,qDAAqD,CACtD,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,UAAU,CAAC;IACpD,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,IAAI,eAAe,CAAC;IAC9D,MAAM,YAAY,GAAG,OAAO,CAAC,oBAAoB,IAAI,oBAAoB,CAAC;IAC1E,MAAM,aAAa,GACjB,OAAO,CAAC,mBAAmB;QAC1B,mBAAmG,CAAC;IACvG,MAAM,QAAQ,GAAG,yBAAyB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAE3D,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO,YAAY,CACjB,YAAY,EACZ,2BAA2B,CAAC,WAAW,EACvC,mCAAmC,QAAQ,wDAAwD,CACpG,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;IACxC,MAAM,mBAAmB,GAAG,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;IAEvD,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IACnC,IAAI,KAAK,EAAE,QAAQ,KAAK,IAAI,EAAE,CAAC;QAC7B,OAAO,YAAY,CACjB,YAAY,EACZ,2BAA2B,CAAC,eAAe,EAC3C,KAAK,EAAE,MAAM,IAAI,yDAAyD,EAC1E,EAAE,aAAa,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAC9C,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,CAAC,kBAAkB,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAC5D,OAAO,YAAY,CACjB,YAAY,EACZ,2BAA2B,CAAC,SAAS,EACrC,6FAA6F,EAC7F,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,CACpD,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,CAAC;IACf,IAAI,CAAC;QACH,UAAU,GAAG,6BAA6B,CAAC,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;IAChG,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvE,OAAO,YAAY,CAAC,YAAY,EAAE,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE;YAC5E,aAAa,EAAE,IAAI;YACnB,mBAAmB;YACnB,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED,IAAI,UAAU,EAAE,KAAK,KAAK,IAAI,EAAE,CAAC;QAC/B,OAAO,YAAY,CACjB,YAAY,EACZ,2BAA2B,CAAC,SAAS,EACrC,2CAA2C,UAAU,EAAE,OAAO,IAAI,SAAS,IAAI,EAC/E,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,CACpD,CAAC;IACJ,CAAC;IAED,MAAM,kBAAkB,GAAG,+BAA+B,CAAC,UAAU,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC;IAC1F,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClC,OAAO,YAAY,CACjB,YAAY,EACZ,2BAA2B,CAAC,oBAAoB,EAChD,0DAA0D,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAC5G,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,kBAAkB,EAAE,CACxE,CAAC;IACJ,CAAC;IAED,OAAO,SAAS,CAAC,YAAY,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,CAAC,CAAC;AACjE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB,CACpC,MAAyC,EACzC,UAAkE,EAAE;IAEpE,MAAM,KAAK,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK,IAAI,EAAE,CAAC;IAC5C,MAAM,OAAO,GAAgC,EAAE,CAAC;IAChD,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;QAC1B,IAAI,OAAO,CAAC,UAAU,IAAI,KAAK,CAAC,YAAY,KAAK,OAAO,CAAC,UAAU;YAAE,SAAS;QAC9E,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IACtD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,+GAA+G;AAC/G,SAAS,eAAe,CAAC,MAA0B;IACjD,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IAC1C,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAC/E,OAAO,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7D,CAAC;AAED;;;;oGAIoG;AACpG,MAAM,UAAU,sBAAsB,CACpC,OAAe,EACf,OAAiD,EACjD,QAA0B,SAAS;IAEnC,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACpE,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;IACrE,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE;QAC/B,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,GAAG,EAAE,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG;QAC/B,QAAQ,EAAE,MAAM;QAChB,KAAK,EAAE,KAAK;KACb,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,IAAI,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC;IAC9D,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;IACjE,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;AAClE,CAAC;AAED,SAAS,eAAe,CACtB,OAAsB,EACtB,OAAqD,EACrD,eAA0E,EAC1E,OAAkC;IAElC,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACjD,OAAO,eAAe,CAAC,OAAO,EAAE;QAC9B,GAAG,EAAE,OAAO,CAAC,QAAQ;QACrB,GAAG,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC3D,CAAC,CAAC;AACL,CAAC;AAED,SAAS,eAAe,CACtB,IAA+B,EAC/B,KAAwC;IAExC,OAAO,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,CAAC;AACxG,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,KAAsC,EACtC,UAAqC,EAAE;IAEvC,MAAM,SAAS,GAAG,qBAAqB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACxD,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;QACtB,OAAO,EAAE,GAAG,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC3C,CAAC;IACD,MAAM,YAAY,GAAG,SAAS,CAAC,YAAY,CAAC;IAC5C,MAAM,QAAQ,GAAG,yBAAyB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC3D,MAAM,KAAK,GAAG,SAAS,CAAC,KAAwB,CAAC;IAEjD,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,IAAI,eAAe,CAAC;IAC9D,MAAM,aAAa,GACjB,OAAO,CAAC,mBAAmB,IAAK,mBAA0D,CAAC;IAC7F,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,sBAAsB,CAAC;IAC1E,MAAM,WAAW,GACf,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC;IACvJ,MAAM,QAAQ,GACZ,OAAO,CAAC,YAAY,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC;IAEvJ,2GAA2G;IAC3G,IAAI,YAAY,GAAG,EAAE,CAAC;IACtB,IAAI,CAAC;QACH,YAAY,GAAG,6BAA6B,CAAC,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC,YAAY,IAAI,EAAE,CAAC;IACrH,CAAC;IAAC,MAAM,CAAC;QACP,YAAY,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,uGAAuG;IACvG,IAAI,OAAO,OAAO,CAAC,gBAAgB,KAAK,UAAU,EAAE,CAAC;QACnD,OAAO,eAAe,CACpB,YAAY,CACV,YAAY,EACZ,2BAA2B,CAAC,iBAAiB,EAC7C,oHAAoH,EACpH,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,KAAK,EAAE,CACnF,EACD,EAAE,SAAS,EAAE,IAAI,EAAE,CACpB,CAAC;IACJ,CAAC;IAED,IAAI,OAA6B,CAAC;IAClC,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,OAAO,CAAC,gBAAgB,CAAC;YACvC,YAAY;YACZ,QAAQ;YACR,KAAK;YACL,YAAY;YACZ,SAAS,EAAE,mBAAmB,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE;YAC/D,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAE,OAAO,CAAC,QAAmB,CAAC,CAAC,CAAC,EAAE;SAChF,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvE,OAAO,eAAe,CACpB,YAAY,CAAC,YAAY,EAAE,2BAA2B,CAAC,iBAAiB,EAAE,6BAA6B,OAAO,EAAE,EAAE;YAChH,aAAa,EAAE,IAAI;YACnB,mBAAmB,EAAE,SAAS,CAAC,mBAAmB;YAClD,KAAK;SACN,CAAC,EACF,EAAE,SAAS,EAAE,IAAI,EAAE,CACpB,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,OAAO,EAAE,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACnE,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QACnE,OAAO,eAAe,CACpB,YAAY,CACV,YAAY,EACZ,2BAA2B,CAAC,iBAAiB,EAC7C,OAAO,EAAE,KAAK,IAAI,qDAAqD,EACvE,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,KAAK,EAAE,CACnF,EACD,EAAE,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,CAC3B,CAAC;IACJ,CAAC;IAED,gDAAgD;IAChD,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;IACvD,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QAChB,OAAO,eAAe,CACpB,YAAY,CACV,YAAY,EACZ,2BAA2B,CAAC,iBAAiB,EAC7C,+BAA+B,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,EAC/G,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,KAAK,EAAE,CACnF,EACD,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,CACjD,CAAC;IACJ,CAAC;IAED,wDAAwD;IACxD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;IACjD,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;QACb,OAAO,eAAe,CACpB,YAAY,CACV,YAAY,EACZ,2BAA2B,CAAC,cAAc,EAC1C,2BAA2B,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,EACrG,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,KAAK,EAAE,CACnF,EACD,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,CACpE,CAAC;IACJ,CAAC;IAED,2EAA2E;IAC3E,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,eAAe,CACpB,YAAY,CACV,YAAY,EACZ,2BAA2B,CAAC,cAAc,EAC1C,4EAA4E,EAC5E,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,KAAK,EAAE,CACnF,EACD,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CACzD,CAAC;IACJ,CAAC;IAED,OAAO,eAAe,CAAC,SAAS,CAAC,YAAY,EAAE,EAAE,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,KAAK,EAAE,CAAC,EAAE;QAC7G,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,IAAI;QACjB,SAAS,EAAE,IAAI,CAAC,MAAM;KACvB,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAyC,EACzC,UAA+D,EAAE;IAEjE,MAAM,KAAK,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK,IAAI,EAAE,CAAC;IAC5C,MAAM,OAAO,GAA+B,EAAE,CAAC;IAC/C,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;QAC1B,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,IAAI,KAAK,CAAC,YAAY,KAAK,OAAO,CAAC,UAAU;gBAAE,SAAS;QAC1D,CAAC;aAAM,IAAI,KAAK,CAAC,aAAa,KAAK,IAAI,EAAE,CAAC;YACxC,SAAS;QACX,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,MAAM,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAAC,OAAoC;IAC/E,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;IACnD,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,MAAM,kBAAkB,GAA2B,EAAE,CAAC;IACtD,KAAK,MAAM,MAAM,IAAI,IAAI,EAAE,CAAC;QAC1B,IAAI,MAAM,EAAE,MAAM,KAAK,IAAI,EAAE,CAAC;YAC5B,MAAM,IAAI,CAAC,CAAC;YACZ,SAAS;QACX,CAAC;QACD,MAAM,IAAI,CAAC,CAAC;QACZ,MAAM,QAAQ,GAAG,MAAM,EAAE,eAAe,IAAI,2BAA2B,CAAC,KAAK,CAAC;QAC9E,kBAAkB,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACzE,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;IAC9B,MAAM,cAAc,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;IAC3D,MAAM,qBAAqB,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,mBAAmB,KAAK,KAAK,CAAC,CAAC,MAAM,CAAC;IAC1F,OAAO;QACL,KAAK;QACL,MAAM;QACN,MAAM;QACN,cAAc;QACd,qBAAqB;QACrB,kBAAkB;KACnB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAoC,EACpC,UAAsC,4BAA4B,CAAC,OAAO,CAAC;IAE3E,MAAM,KAAK,GAAG,CAAC,sCAAsC,EAAE,EAAE,CAAC,CAAC;IAC3D,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,KAAK,CAAC,IAAI,CAAC,QAAQ,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;YAC1C,SAAS;QACX,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,QAAQ,MAAM,CAAC,YAAY,KAAK,MAAM,CAAC,eAAe,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IACzF,CAAC;IACD,KAAK,CAAC,IAAI,CACR,EAAE,EACF,YAAY,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,KAAK,SAAS;QAClD,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,oBAAoB,CAAC,CACzE,CAAC;IACF,IAAI,OAAO,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;QACtB,KAAK,CAAC,IAAI,CAAC,4CAA4C,OAAO,CAAC,qBAAqB,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;IAC3G,CAAC;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACrG,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,uBAAuB,CAAC,CAAC;QACxC,KAAK,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,UAAU,EAAE,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,KAAK,QAAQ,KAAK,KAAK,EAAE,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"} \ 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 cfc0726c82..cfca89a74c 100644 --- a/packages/loopover-miner/lib/cross-repo-evaluation.ts +++ b/packages/loopover-miner/lib/cross-repo-evaluation.ts @@ -483,16 +483,23 @@ function firstOutputLine(output: string | undefined): string { return line.length > 200 ? `${line.slice(0, 200)}…` : line; } -/** Real default local-command runner: a synchronous `sh -c` in the clone dir, resolve-not-throw so a non-zero - * exit becomes `ok: false` with its captured output rather than an exception (#7634). */ -function defaultRunLocalCommand( +/** Real default local-command runner: split the detected command into an argv and spawn it directly in the clone + * dir with NO shell (`shell: false`), so shell metacharacters in untrusted repo metadata (e.g. a crafted + * package.json script name) cannot inject extra commands (#7641). Stack commands are plain whitespace-separated + * argv (`npm run build`, `cargo test`, `go build ./...`). Resolve-not-throw: a non-zero exit becomes `ok: false` + * with its captured output rather than an exception (#7634). Exported for direct unit coverage. */ +export function defaultRunLocalCommand( command: string, context: { cwd: string; env?: NodeJS.ProcessEnv }, + spawn: typeof spawnSync = spawnSync, ): LocalCommandResult { - const result = spawnSync("sh", ["-c", command], { + const [file, ...args] = command.trim().split(/\s+/).filter(Boolean); + if (!file) return { ok: false, code: null, output: "empty command" }; + const result = spawn(file, args, { cwd: context.cwd, env: context.env ?? process.env, encoding: "utf8", + shell: false, }); const output = `${result.stdout ?? ""}${result.stderr ?? ""}`; if (result.error) { diff --git a/test/unit/miner-cross-repo-evaluation.test.ts b/test/unit/miner-cross-repo-evaluation.test.ts index 50743ebfd8..1a738296c2 100644 --- a/test/unit/miner-cross-repo-evaluation.test.ts +++ b/test/unit/miner-cross-repo-evaluation.test.ts @@ -11,6 +11,7 @@ import { CROSS_REPO_FAILURE_CATEGORY, DEFAULT_CROSS_REPO_MANIFEST_RELATIVE_PATH, MAX_CROSS_REPO_MANIFEST_BYTES, + defaultRunLocalCommand, executeRepoAttempt, formatCrossRepoEvaluationReport, evaluateRepoReadiness, @@ -762,6 +763,57 @@ describe("cross-repo evaluation harness (#4788)", () => { expect(calls[1]).toEqual(["git", "--no-pager", "diff", "--cached"]); }); + it("defaultRunLocalCommand spawns the argv directly with no shell (no `sh -c` injection surface)", () => { + let seen: { file: string; args: string[]; opts: Record } | null = null; + const fakeSpawn = ((file: string, args: string[], opts: Record) => { + seen = { file, args, opts }; + return { stdout: "out", stderr: "err", status: 0 }; + }) as never; + + const result = defaultRunLocalCommand("npm run build", { cwd: "/clone", env: { FOO: "1" } }, fakeSpawn); + + expect(result).toEqual({ ok: true, code: 0, output: "outerr" }); + // The command must be split into a real argv and run WITHOUT a shell — never `sh -c ""`. + expect(seen!.file).toBe("npm"); + expect(seen!.args).toEqual(["run", "build"]); + expect(seen!.opts.shell).toBe(false); + expect(seen!.opts.cwd).toBe("/clone"); + expect(seen!.opts.env).toEqual({ FOO: "1" }); + }); + + it("defaultRunLocalCommand keeps a crafted script name as an inert argv token (no metacharacter injection)", () => { + let seen: { file: string; args: string[] } | null = null; + const fakeSpawn = ((file: string, args: string[]) => { + seen = { file, args }; + return { status: 1 }; + }) as never; + + // A malicious repo whose build script is named `build; rm -rf ~` would inject via `sh -c`; here it stays one token. + const result = defaultRunLocalCommand("npm run build;rm", { cwd: "/clone" }, fakeSpawn); + + // Missing stdout/stderr default to empty; a non-zero exit resolves to ok:false rather than throwing. + expect(result).toEqual({ ok: false, code: 1, output: "" }); + expect(seen!.file).toBe("npm"); + expect(seen!.args).toEqual(["run", "build;rm"]); + }); + + it("defaultRunLocalCommand surfaces a spawn error as ok:false with the error message", () => { + const fakeSpawn = (() => ({ error: new Error("spawn ENOENT") })) as never; + const result = defaultRunLocalCommand("cargo build", { cwd: "/clone" }, fakeSpawn); + expect(result).toEqual({ ok: false, code: null, output: "spawn ENOENT" }); + }); + + it("defaultRunLocalCommand rejects an empty command without spawning anything", () => { + let spawned = false; + const fakeSpawn = (() => { + spawned = true; + return { status: 0 }; + }) as never; + const result = defaultRunLocalCommand(" ", { cwd: "/clone" }, fakeSpawn); + expect(result).toEqual({ ok: false, code: null, output: "empty command" }); + expect(spawned).toBe(false); + }); + it("runCrossRepoExecutionCli drives a fixture manifest with injected primitives", async () => { const repoPath = nodeRepo(); const manifestDir = tempRepo();