@orangepro/orangepro-mcp 0.2.46 → 0.2.47

package/dist/local/autoProve.js

@@ -17,6 +17,7 @@ import { basename, dirname, join, posix, relative, resolve, sep } from "node:pat
 import { generateTests, readDeclaredDeps, unresolvedLocalImports } from "./generate/generator.js";
 import { GENERATED_DIR, runHintsFor } from "./generate/runHints.js";
 import { rankRiskGaps } from "./score/risk.js";
+import { globToRegExp, loadRiskConfig } from "./score/riskConfig.js";
 import { resolveProviderConfig } from "./localConfig.js";
 import { buildProvider, DeterministicProvider } from "./generate/providers.js";
 import { resolveContained } from "./reprove/paths.js";
@@ -371,6 +372,14 @@ const GEN_WINDOW = 5;
 // file (every eligible symbol × every importing test) cannot starve the shared budget before
 // a provable hard-edge symbol is tried. Small K; promote to a flag if a repo needs a wider sweep.
 const EXISTING_LANE_MAX_WEAK_PER_SYMBOL = 3;
+// A runner that crashes without returning a result (no JSON) fails for the whole
+// project root, not for one test: test-specific problems come back as a classified
+// result. Three crashes in a row in one root stop further calls there instead of
+// walking every remaining linked target (litellm-scale repos queue 1,000+).
+const RUNNER_CRASH_LIMIT = 3;
+const RUNNER_CRASH_RE = /did not return JSON/;
+// Out of disk space is machine-wide: every later sandbox copy fails the same way.
+const DISK_FULL_RE = /\bENOSPC\b|no space left on device/i;
 const RUNNER_ROOT_MARKERS = {
     typescript: ["package.json"],
     javascript: ["package.json"],
@@ -867,6 +876,13 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
     let nonPythonCountedAttempts = 0;
     const pythonPreflightGreen = new Set();
     const pythonBlockedCounts = new Map();
+    // classification.rank_exclude_paths removes paths from ranking; proof follows the
+    // same scope so excluded areas never cost runner calls or sandbox copies.
+    const proofExcludeRe = loadRiskConfig(sourceRoot).config.classification.rank_exclude_paths.map(globToRegExp);
+    const excludedTargets = new Set();
+    const runnerCrashes = new Map();
+    const crashBlocked = new Map();
+    let diskFull;
     const changed = opts.changedFiles && opts.changedFiles.length > 0 ? new Set(opts.changedFiles) : null;
     const reader = fileReaderFor(sourceRoot); // R-2: source scan for the node:sqlite env profile
     // Fix 3: hard TESTED_BY/COVERS pairs first, weak MAY_* pairs after and capped per symbol.
@@ -884,6 +900,12 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
             continue;
         if (changed && !changed.has(symbolFileOf(node)))
             continue;
+        if (diskFull)
+            break;
+        if (proofExcludeRe.length > 0 && proofExcludeRe.some((re) => re.test(symbolFileOf(node)))) {
+            excludedTargets.add(symId);
+            continue;
+        }
         // Fix 1: already Proven for the CURRENT code (fingerprint match under #162) → skip. Re-closing
         // it would overstate newly-proven and append a redundant closed cert every run.
         if (alreadyProven.has(symId))
@@ -894,6 +916,12 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         const targetFileRel = symbolFileOf(node);
         const targetLanguageName = language ?? targetLanguage(symId);
         const runnerRoot = projectRoot ?? proofRunnerRoot(sourceRoot, targetFileRel, testRel);
+        const crashKey = `${targetLanguageName}\u0000${runnerRoot}`;
+        const crashBlock = crashBlocked.get(crashKey);
+        if (crashBlock) {
+            crashBlock.skipped++;
+            continue;
+        }
         // A prior candidate in this exact runner project hit a classified project-wide
         // toolchain/environment failure. Preserve the budget and explain the skip.
         const isPython = isPythonFile(targetFileRel);
@@ -980,9 +1008,22 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
             attempted--;
             if (!isPython)
                 nonPythonCountedAttempts--;
-            reportProgress(`proof skipped: ${symId}: ${redactSecrets(errMsg(e))}`);
+            const message = redactSecrets(errMsg(e));
+            reportProgress(`proof skipped: ${symId}: ${message}`);
+            if (DISK_FULL_RE.test(message)) {
+                diskFull = message;
+                break;
+            }
+            if (RUNNER_CRASH_RE.test(message)) {
+                const crashes = (runnerCrashes.get(crashKey) ?? 0) + 1;
+                runnerCrashes.set(crashKey, crashes);
+                if (crashes >= RUNNER_CRASH_LIMIT) {
+                    crashBlocked.set(crashKey, { language: targetLanguageName, root: runnerRoot, skipped: 0, lastError: message.slice(0, 200) });
+                }
+            }
             continue;
         }
+        runnerCrashes.delete(crashKey);
         const { classification, reason, category } = classifyProof(result, { sourceRoot, targetFileRel });
         const baselineGreen = baselineGreenOf(result);
         if (isPython) {
@@ -1036,7 +1077,28 @@ function proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, p
         project_root: root,
         blocked_by: block.blockedBy
     }));
-    return { attempts, needsSetup, skipped, proven, attempted, nonPythonAttempted: nonPythonCountedAttempts, provenSymbols };
+    for (const block of crashBlocked.values()) {
+        skipped.push({
+            title: `${block.language} project ${block.root}`,
+            reason: `the proof runner crashed ${RUNNER_CRASH_LIMIT} times in a row without returning a result; ${block.skipped} remaining linked target${block.skipped === 1 ? " was" : "s were"} not attempted in this root. Last error: ${block.lastError}`,
+            language: block.language,
+            project_root: block.root
+        });
+    }
+    if (excludedTargets.size > 0) {
+        const n = excludedTargets.size;
+        skipped.push({
+            title: "Excluded paths",
+            reason: `${n} linked target${n === 1 ? " is" : "s are"} under classification.rank_exclude_paths and ${n === 1 ? "was" : "were"} not attempted.`
+        });
+    }
+    if (diskFull) {
+        skipped.push({
+            title: "Disk full",
+            reason: `the disk ran out of space while preparing a proof sandbox; all remaining proof attempts were stopped. Free disk space and rerun. (${diskFull.slice(0, 200)})`
+        });
+    }
+    return { attempts, needsSetup, skipped, proven, attempted, nonPythonAttempted: nonPythonCountedAttempts, provenSymbols, ...(diskFull ? { diskFull } : {}) };
 }
 /**
  * Drive prove for the top provable TS/JS targets. Two lanes: (1) prove the repo's OWN
@@ -1083,12 +1145,14 @@ export async function autoProve(root, opts, deps) {
     const genLimit = Math.max(1, Math.min(MAX_AUTO_LIMIT, Math.floor(opts.proof_gen_limit ?? DEFAULT_PROOF_GEN_LIMIT)));
     // ── Lane 1: existing associated tests — NO key required, runs FIRST (PR 1.5). ──
     const ex = proveExistingAssociatedTests(root, graph, sourceRoot, nodeById, opts, proveLoop, proveDeps, alreadyProven, projectBlocked, existingLimit, genLimit, autoLimit);
-    if (opts.existingOnly) {
+    if (opts.existingOnly || ex.diskFull) {
         const status = ex.proven > 0 ? "proven-run" : ex.attempted > 0 ? "ran-no-proof" : "no-targets";
         return {
             ran: ex.attempted > 0,
             status,
-            reason: "existing-tests-only: generation disabled.",
+            reason: ex.diskFull
+                ? "Proof stopped: the disk ran out of space while preparing a proof sandbox. Free disk space and rerun."
+                : "existing-tests-only: generation disabled.",
             attempted: ex.attempted,
             proven: ex.proven,
             needs_setup: ex.needsSetup,

package/dist/local/generate/generator.js

@@ -26,7 +26,7 @@ const MAX_RELATED_FILES = 4;
 const SYMBOL_EXCERPT_CONTEXT_LINES = 3;
 const MAX_EXCERPT_CHARS = 8000;
 const MAX_TARGET_TYPE_EXCERPT_CHARS = 5000;
-const STATIC_CHECK_TIMEOUT_MS = 3000;
+const STATIC_CHECK_TIMEOUT_MS = 10000;
 // Large Go monorepos can spend tens of seconds populating a cold module cache
 // before the target package is compiled. Keep the check authoritative instead
 // of downgrading valid generated tests while dependencies are still downloading.
@@ -71,6 +71,11 @@ function testFilesForSourceFile(graph, sourceFile) {
     }
     return [...out];
 }
+/** `Model provider HTTP 429: {...body...}` → `Model provider HTTP 429 (response body omitted)`. */
+export function persistedProviderError(message) {
+    const match = /^(Model provider HTTP \d+):/.exec(message);
+    return match ? `${match[1]} (response body omitted)` : message;
+}
 /**
  * Strip a Markdown code fence (and any prose around it) from a model body. Real
  * BYOK models frequently wrap the test in ```ts … ``` with a prose preamble/suffix;
@@ -2389,14 +2394,18 @@ export async function generateTests(graph, opts, provider, fileReader, clock = s
             }
             catch (callErr) {
                 const msg = redactSecrets(callErr instanceof Error ? callErr.message : String(callErr));
+                // The terminal warning keeps the provider's response for diagnosis. Persisted
+                // drafts and missing-evidence rows end up in shareable reports, so they carry
+                // only the status line, never the provider's response body (account/billing text).
+                const persisted = persistedProviderError(msg);
                 warnings.push(`V5 planning call failed for "${gc.ctx.behavior_title}": ${msg} — no test emitted.`);
                 missing.push({
                     external_id: behavior.external_id,
                     title: gc.ctx.behavior_title,
-                    reason: `V5 planning call failed: ${msg}`,
+                    reason: `V5 planning call failed: ${persisted}`,
                     needed: ["a reachable model provider"]
                 });
-                emitManualPlanningFallback(`V5 planning call failed: ${msg}.`);
+                emitManualPlanningFallback(`V5 planning call failed: ${persisted}.`);
                 continue;
             }
             try {

package/dist/local/operations.js

@@ -1687,7 +1687,9 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
     // Proof is minted only by opProveLoop's UNCHANGED oracle; no key ⇒ no files, no proof.
     reportProgress(opts.noAuto
         ? "auto-prove: disabled (--no-auto)"
-        : "auto-prove: driving generate → prove on the top provable targets", { current: 6, total: 8 });
+        : opts.ai === false
+            ? "auto-prove: proving with existing tests only (--no-ai: no test generation)"
+            : "auto-prove: driving generate → prove on the top provable targets", { current: 6, total: 8 });
     let autoProveResult;
     try {
         const scopedFiles = autoProveChangedScope(loadGraph(workspacePaths(root).graphPath), changed, opts.baseRef);
@@ -1699,7 +1701,12 @@ export async function opStart(root, opts = {}, deps = defaultDeps()) {
             provider: providerOpts.provider,
             model: providerOpts.model,
             prompt_version: opts.promptVersion,
-            changedFiles
+            changedFiles,
+            // --no-ai means no model calls anywhere in the run. The generation lane is gated
+            // only by a key in the environment, so with a real provider configured it must
+            // honor the flag explicitly. Without a key (or with the offline deterministic
+            // provider) no model is called anyway and the released no-key path is unchanged.
+            existingOnly: opts.ai === false && generationProviderConfigured && !deterministicGeneration
         }, { ...providerDeps, proveLoop: opProveLoop });
         autoProveResult = await runAutoProve(scopedFiles);
         if (scopedFiles && autoProveResult.attempted === 0 && !opts.baseRef && !opts.noAuto) {

package/dist/local/viz/behaviorReportData.js

@@ -516,7 +516,10 @@ export function riskContext(risk, churnWindowDays, churnMeta, sameSinkAs) {
             : "change history unavailable";
     const tier = risk.detection_tier ?? "";
     const evidence = tier === "candidate"
-        ? "no test links here (a similarly-named test exists but never calls it)"
+        // Candidate = a name-level signal only. The analyzer did not credit an asserted
+        // call; it cannot claim the test never calls the code (stored-result asserts and
+        // pytest.raises are not yet credited for Python).
+        ? "no confirmed test link (a similarly-named test exists, but no asserted call to it was recognized)"
         : tier === "associated" ? "a test calls it but nothing proves it fails when broken" : "no test links here";
     const sinkShort = sink ? sink.split(".").pop() ?? sink : "";
     // Line 1 — the consequence, in plain English, from the signals only.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.2.46",
+  "version": "0.2.47",
   "private": false,
   "description": "OrangePro (`opro`) — a local-first, BYOK CLI + MCP server that builds an evidence graph from a local checkout, ingests runtime coverage, and generates grounded tests. Metadata-only exports; no source upload; generated tests stay local.",
   "license": "MIT",

package/scripts/spikes/dynamic-proof-spike.mjs

@@ -646,8 +646,33 @@ function copyRuntimeAliasTarget(absTarget, dest, isFile) {
   });
 }
 
-function copyFixtureRoot(root, label, { linkNodeModules, workspaceRoot }) {
+// A failed copy (e.g. ENOSPC) must not leave a partial multi-GB sandbox behind:
+// remove this copy's temp dir before rethrowing.
+function copyFixtureRoot(root, label, options) {
   const tmpRoot = mkdtempSync(path.join(tmpdir(), `opro-dynamic-proof-${label}-`));
+  try {
+    return populateFixtureRoot(tmpRoot, root, options);
+  } catch (error) {
+    rmSync(tmpRoot, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// Directories that are never JS test inputs but can be very large when the analyzed
+// root is a polyglot repo: Python environments and caches, and Rust build output
+// (`target/` next to a Cargo.toml). Copying them made each sandbox several GB.
+const NON_JS_HEAVY_DIRS = new Set([".venv", "venv", "__pycache__", ".pytest_cache", ".mypy_cache", ".ruff_cache", ".tox"]);
+function isNonJsHeavyDir(source, name) {
+  if (!NON_JS_HEAVY_DIRS.has(name) && name !== "target") {
+    return false;
+  }
+  if (!lstatSync(source).isDirectory()) {
+    return false;
+  }
+  return name !== "target" || existsSync(path.join(path.dirname(source), "Cargo.toml"));
+}
+
+function populateFixtureRoot(tmpRoot, root, { linkNodeModules, workspaceRoot }) {
   const monoRoot = path.join(tmpRoot, "mono");
   // On any policy violation, mirror nothing → package lands alone at tmpRoot/mono with its
   // dangling extends / unresolved alias → baseline fails to transform/resolve → honest
@@ -730,6 +755,9 @@ function copyFixtureRoot(root, label, { linkNodeModules, workspaceRoot }) {
       if (source !== root && lstatSync(source).isSymbolicLink()) {
         return false;
       }
+      if (source !== root && isNonJsHeavyDir(source, name)) {
+        return false;
+      }
       return name !== "node_modules" && name !== ".git" && name !== ".orangepro";
     }
   });
@@ -2283,7 +2311,13 @@ function main() {
   const mochaBin = args.mochaBin ? path.resolve(args.mochaBin) : defaultMochaBin(root, workspaceRoot);
 
   const baselineCopy = copyFixtureRoot(root, "baseline", { linkNodeModules: args.linkNodeModules, workspaceRoot });
-  const mutantCopy = copyFixtureRoot(root, "mutant", { linkNodeModules: args.linkNodeModules, workspaceRoot });
+  let mutantCopy;
+  try {
+    mutantCopy = copyFixtureRoot(root, "mutant", { linkNodeModules: args.linkNodeModules, workspaceRoot });
+  } catch (error) {
+    rmSync(baselineCopy.tmpRoot, { recursive: true, force: true });
+    throw error;
+  }
   try {
     const baseline = runTest({ runner, repoRoot: baselineCopy.repoRoot, monoRoot: baselineCopy.monoRoot, testRel, vitestBin, jestBin, mochaBin, vitestConfigRel, jestConfigRel, timeoutMs, testEnv, aliases: baselineCopy.aliases });
     mutateMethod(path.join(mutantCopy.repoRoot, targetRel), args.method, replacementBody);

package/scripts/spikes/go-dynamic-proof-spike.mjs

@@ -126,16 +126,22 @@ function resolveInside(root, relOrAbs) {
 function copyModuleRoot(root, label) {
   const tmpRoot = mkdtempSync(path.join(tmpdir(), `opro-go-proof-${label}-`));
   const repoRoot = path.join(tmpRoot, "module");
-  cpSync(root, repoRoot, {
-    recursive: true,
-    filter(source) {
-      const name = path.basename(source);
-      if (source !== root && lstatSync(source).isSymbolicLink()) {
-        return false;
+  try {
+    cpSync(root, repoRoot, {
+      recursive: true,
+      filter(source) {
+        const name = path.basename(source);
+        if (source !== root && lstatSync(source).isSymbolicLink()) {
+          return false;
+        }
+        return name !== "node_modules" && name !== ".git" && name !== ".orangepro";
       }
-      return name !== "node_modules" && name !== ".git" && name !== ".orangepro";
-    }
-  });
+    });
+  } catch (error) {
+    // A failed copy (e.g. ENOSPC) must not leave a partial sandbox behind.
+    rmSync(tmpRoot, { recursive: true, force: true });
+    throw error;
+  }
   return { tmpRoot, repoRoot };
 }
 
@@ -558,7 +564,13 @@ function main() {
   const pkgPath = pkgDirRel === "." ? "./" : `./${pkgDirRel.split(path.sep).join("/")}`;
 
   const baselineCopy = copyModuleRoot(root, "baseline");
-  const mutantCopy = copyModuleRoot(root, "mutant");
+  let mutantCopy;
+  try {
+    mutantCopy = copyModuleRoot(root, "mutant");
+  } catch (error) {
+    rmSync(baselineCopy.tmpRoot, { recursive: true, force: true });
+    throw error;
+  }
   // The mutant sandbox's package directory: Go prints failure-frame files as
   // basenames relative to it, so FIX 2 resolves the test source there.
   const pkgDirAbs = path.join(mutantCopy.repoRoot, path.dirname(targetRel));

package/scripts/spikes/java-dynamic-proof-spike.mjs

@@ -106,16 +106,22 @@ function resolveInside(root, relOrAbs) {
 function copyModuleRoot(root, label) {
   const tmpRoot = mkdtempSync(path.join(tmpdir(), `opro-java-proof-${label}-`));
   const repoRoot = path.join(tmpRoot, "module");
-  cpSync(root, repoRoot, {
-    recursive: true,
-    filter(source) {
-      const name = path.basename(source);
-      if (source !== root && lstatSync(source).isSymbolicLink()) {
-        return false;
+  try {
+    cpSync(root, repoRoot, {
+      recursive: true,
+      filter(source) {
+        const name = path.basename(source);
+        if (source !== root && lstatSync(source).isSymbolicLink()) {
+          return false;
+        }
+        return name !== "node_modules" && name !== ".git" && name !== ".orangepro" && name !== "target";
       }
-      return name !== "node_modules" && name !== ".git" && name !== ".orangepro" && name !== "target";
-    }
-  });
+    });
+  } catch (error) {
+    // A failed copy (e.g. ENOSPC) must not leave a partial sandbox behind.
+    rmSync(tmpRoot, { recursive: true, force: true });
+    throw error;
+  }
   return { tmpRoot, repoRoot };
 }
 
@@ -506,7 +512,13 @@ function main() {
   const timeoutMs = parseTimeoutMs(args.timeoutMs);
 
   const baselineCopy = copyModuleRoot(root, "baseline");
-  const mutantCopy = copyModuleRoot(root, "mutant");
+  let mutantCopy;
+  try {
+    mutantCopy = copyModuleRoot(root, "mutant");
+  } catch (error) {
+    rmSync(baselineCopy.tmpRoot, { recursive: true, force: true });
+    throw error;
+  }
   try {
     const baseline = runSurefire({
       repoRoot: baselineCopy.repoRoot,