@orangepro/orangepro-mcp 0.2.2 → 0.2.3

package/README.md

@@ -41,7 +41,38 @@ cd orangepro-mcp && npm ci && npm run build && npm link
 
 OrangePro runs as an MCP server. Any MCP-compatible agent (Cursor, Claude Code, Codex, Copilot, OpenCode) can drive it.
 
-### Setup
+### Quick agent setup
+
+If you already have `opro` on your PATH, print the exact config for your client:
+
+```bash
+opro agent --client codex
+opro agent --client claude-code
+opro agent --client cursor
+opro agent --client opencode
+opro agent --client generic
+```
+
+No global install is required. These commands use the published package:
+
+```bash
+# Codex
+npx -y @orangepro/mcp-server@latest agent --client codex
+
+# Claude Code
+npx -y @orangepro/mcp-server@latest agent --client claude-code
+
+# Cursor
+npx -y @orangepro/mcp-server@latest agent --client cursor
+
+# OpenCode
+npx -y @orangepro/mcp-server@latest agent --client opencode
+
+# Generic MCP clients, including VS Code/Copilot-style MCP settings
+npx -y @orangepro/mcp-server@latest agent --client generic
+```
+
+### Manual MCP config
 
 Add to your client's MCP config:
 
@@ -57,11 +88,13 @@ Add to your client's MCP config:
 ```
 
 | Client | Config location |
+| --- | --- |
 |--------|----------------|
 | Claude Code | `.mcp.json` or `~/.claude.json` |
 | Cursor | `~/.cursor/mcp.json` or Settings → MCP |
-| Codex | MCP config printed by `opro agent --client codex`; plugin install after OrangePro is listed in a configured marketplace |
-| VS Code / Copilot | MCP settings |
+| Codex | Config printed by `opro agent --client codex` or `npx -y @orangepro/mcp-server@latest agent --client codex` |
+| VS Code / Copilot | MCP settings; use the `generic` config if your client accepts raw MCP server JSON |
+| OpenCode | Config printed by `opro agent --client opencode` |
 
 ### The workflow
 

package/dist/local/analyze/treeSitter/engine.js

@@ -766,6 +766,17 @@ function goAssertionCalls(node, assertLocals, dotAssertMethods, shadowed) {
         return Boolean(fn?.type === "identifier" && !shadowed.has(fn.text) && dotAssertMethods.has(fn.text));
     });
 }
+function goAssertionIdentifierArgs(assertion, testingParams) {
+    const sel = callFunctionSelector(assertion);
+    const name = sel?.name ?? assertion.childForFieldName("function")?.text;
+    const args = namedChildren(assertion.childForFieldName("arguments") ?? assertion).filter((n) => n.type !== "comment");
+    if (!name || args.length < 2)
+        return [];
+    if (!testingParams.has(args[0]?.text ?? ""))
+        return [];
+    const slots = name === "Equal" || name === "NotEqual" ? [args[1], args[2]] : [args[1]];
+    return slots.filter((n) => n?.type === "identifier").map((n) => n.text);
+}
 function goAssertionSubject(assertion, testingParams) {
     const sel = callFunctionSelector(assertion);
     const name = sel?.name ?? assertion.childForFieldName("function")?.text;
@@ -862,9 +873,36 @@ function extractGoProofCalls(root, imports) {
         }
     };
     const processBlock = (block, testName, testingParams, shadowed) => {
+        // ONE-HOP block-local dataflow: a standalone `x, err := F(...)` statement is
+        // credited when a LATER statement in the SAME block checks a declared name
+        // (if-fail condition or assert subject). This covers the dominant real-Go
+        // idiom the if-initializer shape misses. Discipline kept: single product
+        // call per statement (goShortVarCalls), last write wins, plain reassignment
+        // invalidates, never crosses block boundaries. Metadata only — the dynamic
+        // oracle still re-verifies every edge before anything is Proven.
+        const pending = new Map();
+        // Deferred pending credits: witness lines are collected per call and flushed
+        // after the block — one witness keeps its exact line (subtest binding),
+        // several witnesses drop the line (the oracle's frame-line gate must never
+        // refuse a real kill firing at a sibling check).
+        const pendingHits = new Map();
+        const hitPending = (assertion, calls, line) => {
+            for (const c of calls) {
+                const key = `${assertion}|${c.qualifier ?? ""}|${c.callee}`;
+                const hit = pendingHits.get(key) ?? { assertion, calls: [c], lines: new Set() };
+                if (line !== undefined)
+                    hit.lines.add(line);
+                pendingHits.set(key, hit);
+            }
+        };
         for (const stmt of blockStatements(block)) {
             for (const assertion of goAssertionCalls(stmt, assertLocals, dotAssertMethods, shadowed)) {
-                add(testName, shadowed, "assert_helper", singleGoProductCallIn(goAssertionSubject(assertion, testingParams)), assertion.startPosition.row + 1);
+                const subject = goAssertionSubject(assertion, testingParams);
+                add(testName, shadowed, "assert_helper", singleGoProductCallIn(subject), assertion.startPosition.row + 1);
+                for (const argName of goAssertionIdentifierArgs(assertion, testingParams)) {
+                    if (pending.has(argName))
+                        hitPending("assert_helper", pending.get(argName), assertion.startPosition.row + 1);
+                }
             }
             if (stmt.type === "if_statement" && hasGoTestingFailure(stmt.childForFieldName("consequence"), testingParams)) {
                 const condition = stmt.childForFieldName("condition");
@@ -876,6 +914,10 @@ function extractGoProofCalls(root, imports) {
                 const initCalls = init ? goShortVarCalls(init) : null;
                 if (initCalls && containsIdentifier(condition, initCalls.names))
                     add(testName, shadowed, "testing_fail", initCalls.calls, failLine);
+                for (const [name, calls] of pending) {
+                    if (containsIdentifier(condition, new Set([name])))
+                        hitPending("testing_fail", calls, failLine);
+                }
             }
             for (const child of namedChildren(stmt)) {
                 if (child.type === "block")
@@ -886,6 +928,23 @@ function extractGoProofCalls(root, imports) {
                 const subTestName = subtest.subName ? `${testName}/${subtest.subName}` : testName;
                 processBlock(subtest.body, subTestName, subtest.testingParams, shadowed);
             }
+            // Record declarations AFTER uses: a declaration is never its own check.
+            const sv = stmt.type === "short_var_declaration" ? goShortVarCalls(stmt) : null;
+            if (sv) {
+                for (const name of sv.names)
+                    pending.set(name, sv.calls);
+            }
+            else if (stmt.type === "assignment_statement") {
+                // Plain reassignment kills the binding — the checked value is no longer F's.
+                const reassigned = new Set();
+                collectNames(stmt.childForFieldName("left") ?? stmt.namedChild(0), reassigned);
+                for (const name of reassigned)
+                    pending.delete(name);
+            }
+        }
+        for (const hit of pendingHits.values()) {
+            const line = hit.lines.size === 1 ? [...hit.lines][0] : undefined;
+            add(testName, shadowed, hit.assertion, hit.calls, line);
         }
     };
     const processSuiteBlock = (block, testName, receiver, shadowed) => {

package/dist/local/cli.js

@@ -106,7 +106,7 @@ Usage:
   opro ai-links [--all] [--apply] [--provider openai|anthropic|ollama] [--model <name>] [--max-behaviors <n>] [--symbols-per-behavior <n>] [--max-prompt-tokens <n>] [--json]
     # opt-in AI lane: stage weak candidate behavior↔code links in .orangepro/ai/links.json; --apply merges them into candidate_edges only
   opro ai-flows [--apply] [--provider openai|anthropic|ollama] [--model <name>] [--json]
-    # opt-in AI lane: stage candidate behavior flows (closed anchor set) in .orangepro/ai/flows.json; --apply stores them under analysis.candidate_flows only — a verify-these worklist, never evidence
+    # opt-in AI lane: stage candidate behavior flows (closed anchor set) in .orangepro/flows.json; --apply stores them under analysis.candidate_flows only — a verify-these worklist, never evidence
   opro generate [--target REQ-001] [--base <ref>] [--pr <n> [--yes]] [--changed] [--framework playwright] [--limit 3] [--prompt-version v2|v5] [--provider openai|anthropic|ollama|deterministic] [--model <name>] [--single [--raw]] [--background] [--json]
     # default: A/B both arms (prompt-only vs Local KG, same model) scored side by side + writes a fresh report; --single generates one arm only
     # --base <ref>: NON-MUTATING default for PR/branch review — generate only for the behaviors the diff vs <ref> touches (e.g. --base main); read-only \`git diff\`, no checkout

package/dist/local/flows/llmFlowDiscovery.js

@@ -19,8 +19,20 @@ const MAX_PROMPT_ENTRIES = 60;
 const MAX_PROMPT_SYMBOLS = 300;
 const MAX_COMPLETION_TOKENS = 3000;
 export function aiFlowsPath(root) {
+    return join(workspacePaths(root).dir, "flows.json");
+}
+function legacyAiFlowsPath(root) {
     return join(workspacePaths(root).dir, "ai", "flows.json");
 }
+function readAiFlowsArtifact(root) {
+    const path = aiFlowsPath(root);
+    const current = readArtifact(path);
+    if (current.artifact || current.invalid)
+        return { ...current, path };
+    const legacy = legacyAiFlowsPath(root);
+    const fallback = readArtifact(legacy);
+    return { ...fallback, path: fallback.artifact || fallback.invalid ? legacy : path };
+}
 function buildAnchorContext(graph) {
     const entries = dedupeEntries([
         ...endpointEntries(graph.nodes, graph.edges),
@@ -210,12 +222,12 @@ export async function generateAiFlows(root, graph, provider, clock) {
         node_set_hash: nodeSetHash
     }));
     const path = aiFlowsPath(root);
-    const cached = readArtifact(path);
+    const cached = readAiFlowsArtifact(root);
     if (cached.artifact?.cache_key === cacheKey) {
         const hit = cached.artifact;
         return {
             mode: "generate",
-            ai_flows_path: path,
+            ai_flows_path: cached.path,
             cache_hit: true,
             model_provider: hit.model_provider,
             model_name: hit.model_name,
@@ -306,8 +318,7 @@ export async function generateAiFlows(root, graph, provider, clock) {
  * edges/candidate_edges/nodes/analysis.flows.
  */
 export function applyAiFlows(root, graph) {
-    const path = aiFlowsPath(root);
-    const { artifact, invalid } = readArtifact(path);
+    const { path, artifact, invalid } = readAiFlowsArtifact(root);
     if (invalid) {
         throw new Error(`AI flows artifact at ${path} is invalid or corrupted; re-run \`opro ai-flows\` to regenerate it.`);
     }
@@ -413,7 +424,7 @@ function toCandidateFlow(flow, entriesById, knownEdges, provenance) {
         ...(flow.rationale ? { rationale: flow.rationale } : {}),
         provenance: {
             source_scope_id: `ai:${provenance.cache_key}`,
-            source_ref: ".orangepro/ai/flows.json",
+            source_ref: ".orangepro/flows.json",
             detector: "ai_flows",
             model_provider: provenance.model_provider,
             model_name: provenance.model_name,

package/dist/local/mcp.js

@@ -407,7 +407,7 @@ export function createLocalServer() {
     });
     server.registerTool("orangepro_ai_flows", {
         title: "Stage/apply AI candidate flows",
-        description: "Opt-in AI lane: propose candidate behavior-flow chains over existing deterministic entry and CodeSymbol ids. Generate writes .orangepro/ai/flows.json only; apply=true stores survivors under analysis.candidate_flows. Candidate flows are a verify-these worklist and never affect Proven, deterministic flow counts, tiers, or coverage.",
+        description: "Opt-in AI lane: propose candidate behavior-flow chains over existing deterministic entry and CodeSymbol ids. Generate writes .orangepro/flows.json only; apply=true stores survivors under analysis.candidate_flows. Candidate flows are a verify-these worklist and never affect Proven, deterministic flow counts, tiers, or coverage.",
         inputSchema: {
             ...Workspace,
             apply: z.boolean().optional().describe("Apply staged flows into analysis.candidate_flows. Default false stages flows only."),

package/dist/local/viz/behaviorReportData.js

@@ -375,7 +375,6 @@ function riskRows(risks, graph) {
             firstRowForFile.set(r.file, r.id);
     return risks.map((risk, idx) => {
         const methodMatch = risk.title.match(/^(GET|POST|PUT|PATCH|DELETE)\s+(.+)$/i);
-        const pathMatch = risk.file.match(/\/api\/(.+)$/);
         const tags = [];
         const bucket = riskBucket(risk.risk_score);
         if (bucket)
@@ -394,8 +393,8 @@ function riskRows(risks, graph) {
                     applicableCategories: [...new Set(generatedTests.map((t) => t.concern).filter((c) => Boolean(c)))]
                 };
             })(),
-            verb: methodMatch?.[1]?.toUpperCase() ?? (risk.entry_point ? "ENTRY" : "CODE"),
-            path: methodMatch?.[2] ?? (pathMatch ? `/${pathMatch[1]}` : risk.file),
+            verb: methodMatch?.[1]?.toUpperCase() ?? "BEHAVIOR",
+            path: methodMatch?.[2] ?? risk.title,
             desc: risk.reasons.join(" · "),
             tags,
             todo: "Write an integration or behavior test that calls this behavior and asserts the observable outcome."

package/dist/local/viz/behaviorReportHtml.js

@@ -470,8 +470,9 @@ if(cf&&cf.flows.length){
 }
 
 // risks + generated test samples
-let activeRiskFilter="all";
 const riskList=$("#risk-list"),riskTools=$("#risk-tools");
+const generatedRiskCount=D.risks.filter(r=>r.generatedTests&&r.generatedTests.length).length;
+let activeRiskFilter=generatedRiskCount?"generated":"all";
 function riskMatchesFilter(r){
   const hasGenerated=Boolean(r.generatedTests&&r.generatedTests.length);
   if(activeRiskFilter==="generated")return hasGenerated;
@@ -481,7 +482,7 @@ function riskMatchesFilter(r){
 function renderRiskFilters(){
   const options=[
     ["all","All",D.risks.length],
-    ["generated","Generated tests",D.risks.filter(r=>r.generatedTests&&r.generatedTests.length).length],
+    ["generated","Flows with tests",generatedRiskCount],
     ["missing","No generated tests",D.risks.filter(r=>!(r.generatedTests&&r.generatedTests.length)).length]
   ];
   riskTools.innerHTML=options.map(([key,label,count])=>\`<button class="risk-filter" type="button" data-risk-filter="\${key}" aria-pressed="\${key===activeRiskFilter}">\${label} <span class="gc">\${count}</span></button>\`).join("");
@@ -519,16 +520,16 @@ function renderRisks(){
   riskList.innerHTML="";
   D.risks.filter(riskMatchesFilter).forEach(r=>riskList.append(el("div","risk-card",riskCardHtml(r))));
   if(activeRiskFilter==="all"&&D.generatedTotal){
-    const hiddenGenerated=Math.max(0,D.generatedTotal-D.shownCount);
-    const remainingRiskFlows=Math.max(0,D.risks.length-D.generatedTotal);
+    const hiddenGeneratedFlows=Math.max(0,generatedRiskCount-D.risks.filter(riskMatchesFilter).length);
+    const remainingRiskFlows=Math.max(0,D.risks.length-generatedRiskCount);
     riskList.append(el("div","paywall",
-      hiddenGenerated
-        ? \`<div class="paywall-num">\${hiddenGenerated} more tests generated</div>
-           <div class="paywall-txt">OrangePro generated tests for \${D.generatedTotal} behaviors across your highest-risk flows. You're seeing \${D.shownCount}.</div>
+      hiddenGeneratedFlows
+        ? \`<div class="paywall-num">\${hiddenGeneratedFlows} more flows with tests</div>
+           <div class="paywall-txt">OrangePro accepted \${D.generatedTotal} runnable generated test\${D.generatedTotal===1?"":"s"} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Use the “Flows with tests” filter to review them first.</div>
            <a class="paywall-btn" href="https://app.orangepro.ai" target="_blank">View all on OrangePro Platform &rarr;</a>\`
         : remainingRiskFlows
           ? \`<div class="paywall-num">\${remainingRiskFlows} high-risk flows left</div>
-             <div class="paywall-txt">The local MCP accepted \${D.generatedTotal} runnable generated test\${D.generatedTotal===1?"":"s"} for this report. Generate the remaining high-risk flow tests on OrangePro Platform.</div>
+             <div class="paywall-txt">The local MCP accepted \${D.generatedTotal} runnable generated test\${D.generatedTotal===1?"":"s"} across \${generatedRiskCount} high-risk flow\${generatedRiskCount===1?"":"s"}. Generate the remaining high-risk flow tests on OrangePro Platform.</div>
              <a class="paywall-btn" href="https://app.orangepro.ai" target="_blank">Generate remaining tests on Platform &rarr;</a>\`
           : \`<div class="paywall-num">All generated tests are shown</div>
              <div class="paywall-txt">OrangePro generated tests for every high-risk flow in this report, and every generated test is visible here.</div>\`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangepro/orangepro-mcp",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "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",
@@ -85,7 +85,11 @@
     "test:integration:go:auto:slow": "OPRO_SLOW_GO_AUTO=1 vitest run tests/local/autoProveGo.test.ts --pool=forks --poolOptions.forks.maxForks=1",
     "test:integration:java:1": "vitest run tests/local/javaProveIntegration.test.ts -t \"^(?!.*(no-false-Proven|mints the same Proven)).*\" --pool=forks --poolOptions.forks.maxForks=1",
     "test:integration:java:2": "vitest run tests/local/javaProveIntegration.test.ts -t \"no-false-Proven|mints the same Proven\" --pool=forks --poolOptions.forks.maxForks=1",
-    "test:integration:java:3": "vitest run tests/local/autoProveJava.test.ts --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:java:3": "npm run test:integration:java:3:unit && npm run test:integration:java:3:prove && npm run test:integration:java:3:survivor && npm run test:integration:java:3:refused",
+    "test:integration:java:3:unit": "vitest run tests/local/autoProveJava.test.ts -t \"javaTestForTarget|isEligibleProvableTarget\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:java:3:prove": "vitest run tests/local/autoProveJava.test.ts -t \"mints DP\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:java:3:survivor": "vitest run tests/local/autoProveJava.test.ts -t \"equivalent survivor\" --pool=forks --poolOptions.forks.maxForks=1",
+    "test:integration:java:3:refused": "vitest run tests/local/autoProveJava.test.ts -t \"refused-shape\" --pool=forks --poolOptions.forks.maxForks=1",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "smoke:gap-fill": "npm run build && node scripts/smoke-gap-fill-loop.mjs",
     "smoke:generate-prove": "npm run build && node scripts/smoke-generate-prove-e2e.mjs",

package/scripts/spikes/go-mutate.go

@@ -35,6 +35,7 @@ import (
 	"go/printer"
 	"go/token"
 	"os"
+	"strings"
 )
 
 // fail prints a stable, machine-readable marker plus a human message and exits
@@ -104,6 +105,15 @@ func main() {
 
 	if *mode == "sentinel" {
 		target.Body = sentinelBody(results)
+		// The sentinel body can orphan imports the original body used (Go
+		// rejects unused imports, so the mutant would fail to BUILD and the
+		// oracle would refuse — an honest but useless verdict for most real
+		// functions). Rewrite now-unused imports to blank imports: package
+		// init side effects are preserved, no behavior is added, and the
+		// repair is fail-safe in both directions — over-blanking a used
+		// import still fails the build (refusal, never proof), and a missed
+		// unused import is exactly today's behavior.
+		blankUnusedImports(astFile)
 	}
 	// equivalent mode: leave target.Body untouched (semantically identical).
 
@@ -117,6 +127,39 @@ func main() {
 	}
 }
 
+// blankUnusedImports renames imports whose package qualifier is no longer
+// referenced anywhere in the file to blank imports (`_ "path"`). Dot imports
+// and existing blank imports are left untouched. Qualifier detection is
+// syntactic (selector bases), which over-approximates "used" — the safe
+// direction: we only ever blank an import nothing references.
+func blankUnusedImports(f *ast.File) {
+	used := map[string]bool{}
+	ast.Inspect(f, func(n ast.Node) bool {
+		if sel, ok := n.(*ast.SelectorExpr); ok {
+			if id, ok := sel.X.(*ast.Ident); ok {
+				used[id.Name] = true
+			}
+		}
+		return true
+	})
+	for _, imp := range f.Imports {
+		if imp.Name != nil {
+			if imp.Name.Name == "_" || imp.Name.Name == "." {
+				continue
+			}
+			if !used[imp.Name.Name] {
+				imp.Name = ast.NewIdent("_")
+			}
+			continue
+		}
+		path := strings.Trim(imp.Path.Value, "\"")
+		base := path[strings.LastIndex(path, "/")+1:]
+		if !used[base] {
+			imp.Name = ast.NewIdent("_")
+		}
+	}
+}
+
 // sentinelBody builds `{ return <zero>, <zero>, ... }` matching the function's
 // result signature so the mutant COMPILES. Zero values are type-derived and
 // deliberately wrong for any function whose real return is non-zero; when a