@orangepro/orangepro-mcp 0.1.0 → 0.2.0

package/dist/local/analyze/analyzer.js

@@ -333,6 +333,14 @@ export function analyzeRepo(root, opts = {}) {
     // file, and every CodeSymbol external_id that made it into the graph (so a
     // confirmed-but-capped symbol downgrades instead of COVERS-ing the file).
     const eligibleSymbolsByFile = new Map();
+    // Proof-edge eligibility for non-TS languages. A hard TESTED_BY/COVERS proof edge is REAL
+    // derivable evidence (a test the repo already runs), independent of the entry-point-adjacent
+    // DENOMINATOR bar. It admits behavior-callable symbols that are `eligible` OR merely
+    // `not_entry_point_adjacent` (e.g. a Formatter/Converter SPI method like PetTypeFormatter#print)
+    // but still EXCLUDES infra plumbing (behaviorSurfaceExcluded) and boilerplate/generated. Used
+    // only by the Go/Java/Python proof-target resolvers; `eligibleSymbolsByFile` (the denominator)
+    // is unchanged, so this never widens the denominator.
+    const proofEligibleSymbolsByFile = new Map();
     const codeSymbolIds = new Set();
     let testFiles = 0;
     let flowsTruncated = 0;
@@ -798,6 +806,15 @@ export function analyzeRepo(root, opts = {}) {
                         else
                             eligibleSymbolsByFile.set(file.relPath, [sym.name]);
                     }
+                    // Proof-edge eligibility: eligible OR not_entry_point_adjacent, but never infra
+                    // (behaviorSurfaceExcluded). Denominator-neutral — only the non-TS proof resolvers read it.
+                    if (eligible || notEntryPointAdjacent) {
+                        const list = proofEligibleSymbolsByFile.get(file.relPath);
+                        if (list)
+                            list.push(sym.name);
+                        else
+                            proofEligibleSymbolsByFile.set(file.relPath, [sym.name]);
+                    }
                     symbolCount++;
                 }
                 const contractsForFile = behaviorContractsByFile.get(file.relPath) ?? [];
@@ -1512,13 +1529,13 @@ export function analyzeRepo(root, opts = {}) {
             return matches.length === 1 ? matches[0] : null;
         };
         const eligibleGoSymbol = (targetRel, name) => {
-            if (!targetRel || !(eligibleSymbolsByFile.get(targetRel) ?? []).includes(name))
+            if (!targetRel || !(proofEligibleSymbolsByFile.get(targetRel) ?? []).includes(name))
                 return null;
             const symId = `sym:${targetRel}#${name}`;
             return codeSymbolIds.has(symId) ? symId : null;
         };
         const eligiblePythonSymbol = (targetRel, name) => {
-            if (!targetRel || !(eligibleSymbolsByFile.get(targetRel) ?? []).includes(name))
+            if (!targetRel || !(proofEligibleSymbolsByFile.get(targetRel) ?? []).includes(name))
                 return null;
             const symId = `sym:${targetRel}#${name}`;
             return codeSymbolIds.has(symId) ? symId : null;
@@ -1530,7 +1547,7 @@ export function analyzeRepo(root, opts = {}) {
             return Boolean(nonTsStructureByFile.get(targetRel)?.structure.javaClasses?.some((c) => c.name === className && c.methods.includes(methodName)));
         };
         const eligibleJavaSymbol = (targetRel, name, expectedKind) => {
-            if (!targetRel || !(eligibleSymbolsByFile.get(targetRel) ?? []).includes(name))
+            if (!targetRel || !(proofEligibleSymbolsByFile.get(targetRel) ?? []).includes(name))
                 return null;
             if (symbolKind(targetRel, name) !== expectedKind)
                 return null;
@@ -1720,6 +1737,19 @@ export function analyzeRepo(root, opts = {}) {
                     continue;
                 seenGoProof.add(edgeKey);
                 goProofConfirmedPairs++;
+                // `test_name` = the enclosing `func TestXxx` (or its literal-named subtest path,
+                // `TestXxx/sub`) where the assertion witnessed the target. STRUCTURAL METADATA ONLY
+                // (never proof) — it lets Go auto-drive pick the exact `go test -run` for THIS target
+                // even when the file has many tests, where the file-level `test_names[]` cannot
+                // disambiguate. Only `[A-Za-z0-9_]` path segments are accepted (defensive; the
+                // extractor already drops runtime/unsafe subtest names to the bare parent).
+                // `assertion_line` (Slice 2) = the 1-based test-source line of the assertion that
+                // witnessed the target. STRUCTURAL METADATA ONLY — it lets the Go oracle bind a
+                // runtime-named subtest's mutant failure to THIS exact assertion (a sibling subtest
+                // asserting at a different line is refused). Emitted only alongside a valid test_name.
+                const goEdgeProps = /^Test[A-Za-z0-9_]+(\/[A-Za-z0-9_]+)*$/.test(proof.testName)
+                    ? { test_name: proof.testName, ...(typeof proof.assertionLine === "number" ? { assertion_line: proof.assertionLine } : {}) }
+                    : undefined;
                 edges.push(makeEdge({
                     from_external_id: symId,
                     to_external_id: testExternalId,
@@ -1727,7 +1757,8 @@ export function analyzeRepo(root, opts = {}) {
                     evidence_strength: "hard",
                     review_status: "auto_detected",
                     provenance: prov(testRel, hashString(`${symId}:${proof.assertion}`)),
-                    last_verified: proofVerifiedAt
+                    last_verified: proofVerifiedAt,
+                    ...(goEdgeProps ? { properties: goEdgeProps } : {})
                 }));
                 edges.push(makeEdge({
                     from_external_id: testExternalId,
@@ -1736,7 +1767,8 @@ export function analyzeRepo(root, opts = {}) {
                     evidence_strength: "hard",
                     review_status: "auto_detected",
                     provenance: prov(testRel, hashString(`${symId}:${proof.assertion}`)),
-                    last_verified: proofVerifiedAt
+                    last_verified: proofVerifiedAt,
+                    ...(goEdgeProps ? { properties: goEdgeProps } : {})
                 }));
             }
         }
@@ -1753,11 +1785,19 @@ export function analyzeRepo(root, opts = {}) {
                     continue;
                 seenJavaProof.add(edgeKey);
                 javaProofConfirmedPairs++;
+                // `test_name` = the enclosing `@Test` method where the assertion witnessed the
+                // target. STRUCTURAL METADATA ONLY (never proof) — it lets Java auto-drive pick
+                // the exact `mvn test -Dtest=Class#method` for THIS target even when the test
+                // class has many @Test methods, where the file-level `test_names[]` cannot
+                // disambiguate. Only a plain Java identifier is recorded (defensive; the
+                // extractor already yields one). Provenance hash is unchanged.
+                const javaEdgeProps = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(proof.testName) ? { test_name: proof.testName } : undefined;
                 edges.push(...makeProofEdges({
                     testRel,
                     symId,
                     provenance: prov(testRel, hashString(`${symId}:${proof.assertion}:${proof.className}.${proof.callee}`)),
-                    lastVerified: proofVerifiedAt
+                    lastVerified: proofVerifiedAt,
+                    ...(javaEdgeProps ? { properties: javaEdgeProps } : {})
                 }));
             }
         }

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

@@ -749,6 +749,14 @@ function hasGoTestingFailure(node, testingParams) {
         return Boolean(sel && testingParams.has(sel.qualifier) && GO_TEST_FAIL_METHODS.has(sel.name));
     });
 }
+/** 1-based source line of the first `t.Error*`/`t.Fatal*` call in a consequence (undefined if none). */
+function goTestingFailureCallLine(node, testingParams) {
+    const call = callExpressions(node).find((c) => {
+        const sel = callFunctionSelector(c);
+        return Boolean(sel && testingParams.has(sel.qualifier) && GO_TEST_FAIL_METHODS.has(sel.name));
+    });
+    return call ? call.startPosition.row + 1 : undefined;
+}
 function goAssertionCalls(node, assertLocals, dotAssertMethods, shadowed) {
     return callExpressions(node).filter((call) => {
         const sel = callFunctionSelector(call);
@@ -808,13 +816,27 @@ function goSubtestBody(stmt, testingParams) {
     });
     if (!call)
         return null;
-    const fn = namedChildren(call.childForFieldName("arguments") ?? call).find((n) => n.type === "func_literal");
+    const args = namedChildren(call.childForFieldName("arguments") ?? call);
+    const fn = args.find((n) => n.type === "func_literal");
     const body = fn?.childForFieldName("body");
     if (!fn || !body)
         return null;
     const nextTestingParams = new Set(testingParams);
     collectGoTestingParamNames(fn.childForFieldName("parameters"), nextTestingParams);
-    return nextTestingParams.size > testingParams.size ? { body, testingParams: nextTestingParams } : null;
+    if (nextTestingParams.size <= testingParams.size)
+        return null;
+    // Only a STRING-LITERAL subtest name with no chars Go would rewrite in the `-run`
+    // path (letters/digits/underscore) is recorded — that segment matches the go-test
+    // JSON `Test` field verbatim (`TestX/sub`). A runtime name (`tc.Name`) or a literal
+    // needing sanitization yields no subName → the caller keeps the parent `TestX`, whose
+    // exact-match oracle safely refuses the runtime subtest frames rather than false-prove.
+    const nameArg = args.find((n) => n.type !== "func_literal");
+    // A double-quoted `interpreted_string_literal` text is the source token WITH quotes
+    // (e.g. `"basic"`); strip them and accept only a `-run`-safe identifier segment.
+    const raw = nameArg?.type === "interpreted_string_literal" ? nameArg.text : undefined;
+    const inner = raw && raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"') ? raw.slice(1, -1) : undefined;
+    const subName = inner && /^[A-Za-z0-9_]+$/.test(inner) ? inner : undefined;
+    return { body, testingParams: nextTestingParams, ...(subName ? { subName } : {}) };
 }
 function goShortVarCalls(stmt) {
     if (stmt.type !== "short_var_declaration")
@@ -830,35 +852,40 @@ function extractGoProofCalls(root, imports) {
     const assertLocals = goAssertLocals(imports);
     const dotAssertMethods = goDotAssertMethods(root);
     const suiteTypes = goCanonicalSuiteTypes(root, goSuiteLocals(imports));
-    const add = (testName, shadowed, assertion, calls) => {
+    const add = (testName, shadowed, assertion, calls, assertionLine) => {
         for (const c of calls) {
             const key = `${testName}|${c.qualifier ?? ""}|${c.callee}|${assertion}`;
             if (seen.has(key))
                 continue;
             seen.add(key);
-            out.push({ caller: testName, testName, ...c, shadowed: [...shadowed], assertion });
+            out.push({ caller: testName, testName, ...c, shadowed: [...shadowed], assertion, ...(assertionLine ? { assertionLine } : {}) });
         }
     };
     const processBlock = (block, testName, testingParams, shadowed) => {
         for (const stmt of blockStatements(block)) {
             for (const assertion of goAssertionCalls(stmt, assertLocals, dotAssertMethods, shadowed)) {
-                add(testName, shadowed, "assert_helper", singleGoProductCallIn(goAssertionSubject(assertion, testingParams)));
+                add(testName, shadowed, "assert_helper", singleGoProductCallIn(goAssertionSubject(assertion, testingParams)), assertion.startPosition.row + 1);
             }
             if (stmt.type === "if_statement" && hasGoTestingFailure(stmt.childForFieldName("consequence"), testingParams)) {
                 const condition = stmt.childForFieldName("condition");
-                add(testName, shadowed, "testing_fail", singleGoProductCallIn(condition));
+                // Go reports the failing frame at the `t.Error*`/`t.Fatal*` CALL inside the
+                // consequence, not the `if` line — bind the line there so the subtest gate matches.
+                const failLine = goTestingFailureCallLine(stmt.childForFieldName("consequence"), testingParams);
+                add(testName, shadowed, "testing_fail", singleGoProductCallIn(condition), failLine);
                 const init = stmt.childForFieldName("initializer");
                 const initCalls = init ? goShortVarCalls(init) : null;
                 if (initCalls && containsIdentifier(condition, initCalls.names))
-                    add(testName, shadowed, "testing_fail", initCalls.calls);
+                    add(testName, shadowed, "testing_fail", initCalls.calls, failLine);
             }
             for (const child of namedChildren(stmt)) {
                 if (child.type === "block")
                     processBlock(child, testName, testingParams, shadowed);
             }
             const subtest = goSubtestBody(stmt, testingParams);
-            if (subtest)
-                processBlock(subtest.body, testName, subtest.testingParams, shadowed);
+            if (subtest) {
+                const subTestName = subtest.subName ? `${testName}/${subtest.subName}` : testName;
+                processBlock(subtest.body, subTestName, subtest.testingParams, shadowed);
+            }
         }
     };
     const processSuiteBlock = (block, testName, receiver, shadowed) => {
@@ -913,6 +940,7 @@ const JAVA_ASSERT_ACTUAL_ARG = new Set([
 ]);
 const JAVA_ASSERT_SUBJECT_ARG = new Set(["assertFalse", "assertNotNull", "assertNull", "assertTrue"]);
 const JAVA_ASSERT_METHODS = new Set([...JAVA_ASSERT_ACTUAL_ARG, ...JAVA_ASSERT_SUBJECT_ARG]);
+const JAVA_ASSERTJ_ASSERT_CLASS = "org.assertj.core.api.Assertions";
 function addJavaAssertionImport(out, name, assertion) {
     if (!JAVA_ASSERT_METHODS.has(name))
         return;
@@ -944,6 +972,57 @@ function javaJunitAssertImports(root) {
     }
     return out;
 }
+/**
+ * True when `assertThat` is statically imported from AssertJ (`org.assertj.core.api.Assertions`,
+ * star or explicit) — the canonical Spring/Mockito unit assertion. AssertJ chains on a subject
+ * (`assertThat(x).isEqualTo(...)`), so recognizing the `assertThat(x)` head lets the extractor see
+ * the target call that produced `x`. Trust is unchanged: the emitted edge only NAMES a candidate
+ * test; the frozen dynamic oracle still re-runs it and refuses/survives if the target isn't proven.
+ */
+function javaHasAssertjAssertThat(root) {
+    for (const node of root.descendantsOfType("import_declaration")) {
+        if (!node)
+            continue;
+        if (!/^import\s+static\b/.test(node.text))
+            continue;
+        const spec = namedChildren(node).find((n) => n.type.endsWith("identifier"))?.text;
+        if (!spec)
+            continue;
+        const star = namedChildren(node).some((n) => n.type === "asterisk");
+        if (star && spec === JAVA_ASSERTJ_ASSERT_CLASS)
+            return true;
+        if (!star && spec === `${JAVA_ASSERTJ_ASSERT_CLASS}.assertThat`)
+            return true;
+    }
+    return false;
+}
+/**
+ * Map each declared FIELD name → its declared type simple name, for a test class. The declared
+ * type IS the receiver's static type (no dataflow needed) — so `private PetTypeFormatter fmt;`
+ * yields `fmt → PetTypeFormatter`. Used to resolve the className when an assertion's target call
+ * has a field receiver (`this.fmt.method(...)` or the bare `fmt.method(...)`), the canonical
+ * `@BeforeEach`/`@Autowired`-injected Spring unit shape.
+ */
+function javaFieldTypes(root) {
+    const out = new Map();
+    for (const node of root.descendantsOfType("field_declaration")) {
+        if (!node)
+            continue;
+        const className = simpleJavaClassName(node.childForFieldName("type")?.text);
+        if (!className)
+            continue;
+        for (const child of namedChildren(node)) {
+            if (child.type !== "variable_declarator")
+                continue;
+            const name = child.childForFieldName("name")?.text;
+            // First declaration wins; a name declared with two different types is left unresolved
+            // (fields don't legally redeclare, but guard against odd trees).
+            if (name && !out.has(name))
+                out.set(name, className);
+        }
+    }
+    return out;
+}
 function javaJunitTestAnnotationLocals(imports) {
     const out = new Set();
     for (const i of imports) {
@@ -1071,7 +1150,28 @@ function javaObjectCreationClassName(node) {
         return null;
     return simpleJavaClassName(node.childForFieldName("type")?.text);
 }
-function javaDirectProofTarget(subject) {
+/**
+ * Resolve a method-invocation receiver `object` node to the target class simple name.
+ * - `Foo.bar()` static-style: a class-shaped bare identifier → the identifier itself.
+ * - `fmt.bar()` bare FIELD identifier → the field's declared type (from `fieldTypes`).
+ * - `this.fmt.bar()` field access → the field's declared type.
+ * A bare identifier that is a known field is resolved as a field (its declared type), NOT as a
+ * class name — the field-type map is authoritative for receivers it knows.
+ */
+function javaReceiverClassName(object, fieldTypes) {
+    if (!object)
+        return null;
+    if (object.type === "identifier") {
+        const field = fieldTypes.get(object.text);
+        return field ?? simpleJavaClassName(object.text);
+    }
+    if (object.type === "field_access" && object.childForFieldName("object")?.type === "this") {
+        const fieldName = object.childForFieldName("field")?.text;
+        return fieldName ? (fieldTypes.get(fieldName) ?? null) : null;
+    }
+    return null;
+}
+function javaDirectProofTarget(subject, fieldTypes) {
     if (!subject || javaCallLikeCount(subject) !== 1)
         return null;
     if (subject.type === "object_creation_expression") {
@@ -1081,8 +1181,7 @@ function javaDirectProofTarget(subject) {
     if (subject.type !== "method_invocation")
         return null;
     const callee = subject.childForFieldName("name")?.text;
-    const object = subject.childForFieldName("object");
-    const className = object?.type === "identifier" ? simpleJavaClassName(object.text) : null;
+    const className = javaReceiverClassName(subject.childForFieldName("object"), fieldTypes);
     return callee && className ? { className, callee, target_kind: "method" } : null;
 }
 function processJavaNestedBlocks(block, testName, shadowed, processBlock) {
@@ -1098,12 +1197,51 @@ function processJavaNestedBlocks(block, testName, shadowed, processBlock) {
     };
     walk(block);
 }
+/**
+ * Map each local variable in a @Test method body → the single method_invocation that initialized
+ * it (e.g. `String r = this.fmt.print(x);` → `r → this.fmt.print(x)`). Lets an AssertJ chain whose
+ * subject is a local (`assertThat(r).isEqualTo(...)`) resolve back to the target call that produced
+ * it. Only the DIRECT initializer of a `local_variable_declaration` is recorded; reassignment is
+ * ignored (fail-closed: an ambiguous local simply yields no edge).
+ */
+function javaLocalVarInits(body) {
+    const out = new Map();
+    for (const decl of body.descendantsOfType("local_variable_declaration")) {
+        if (!decl)
+            continue;
+        for (const child of namedChildren(decl)) {
+            if (child.type !== "variable_declarator")
+                continue;
+            const name = child.childForFieldName("name")?.text;
+            const value = child.childForFieldName("value");
+            if (name && value && !out.has(name))
+                out.set(name, value);
+        }
+    }
+    return out;
+}
+/**
+ * The subject expression an AssertJ chain asserts on, i.e. the sole argument of the `assertThat(x)`
+ * head of a chain. Returns null when it isn't an `assertThat(...)` call with exactly one argument.
+ */
+function javaAssertjSubjectArg(call, shadowed) {
+    if (call.childForFieldName("name")?.text !== "assertThat")
+        return null;
+    if (call.childForFieldName("object"))
+        return null; // must be the bare imported free call
+    if (shadowed.has("assertThat"))
+        return null;
+    const args = namedChildren(call.childForFieldName("arguments") ?? call).filter((n) => n.type !== "comment");
+    return args.length === 1 ? (args[0] ?? null) : null;
+}
 function extractJavaProofCalls(root, imports) {
     const out = [];
     const seen = new Set();
     const assertImports = javaJunitAssertImports(root);
-    if (assertImports.size === 0)
+    const hasAssertj = javaHasAssertjAssertThat(root);
+    if (assertImports.size === 0 && !hasAssertj)
         return out;
+    const fieldTypes = javaFieldTypes(root);
     const testAnnotationLocals = javaJunitTestAnnotationLocals(imports);
     const declaredMethods = javaDeclaredMethodNames(root);
     const add = (testName, shadowed, assertions, target) => {
@@ -1116,12 +1254,29 @@ function extractJavaProofCalls(root, imports) {
         seen.add(key);
         out.push({ testName, ...target, assertion, shadowed: [...shadowed] });
     };
-    const processBlock = (block, testName, shadowed) => {
+    // AssertJ edges carry no static junit4/5 flavor; label them junit5 so `add`'s dedup/hash key is
+    // stable. The value only feeds the provenance hash + edge-props — never a trust decision (the
+    // frozen oracle re-runs the test regardless).
+    const assertjAssertions = new Set(["junit5"]);
+    const processBlock = (block, testName, shadowed, localInits) => {
         for (const stmt of blockStatements(block)) {
             for (const assertion of javaAssertionCalls(stmt, assertImports, shadowed)) {
-                add(testName, shadowed, assertion.assertions, javaDirectProofTarget(javaAssertionSubject(assertion.call, assertion.assertions)));
+                add(testName, shadowed, assertion.assertions, javaDirectProofTarget(javaAssertionSubject(assertion.call, assertion.assertions), fieldTypes));
+            }
+            if (hasAssertj) {
+                for (const call of stmt.descendantsOfType("method_invocation")) {
+                    if (!call || hasAncestorTypeBefore(call, stmt, "lambda_expression"))
+                        continue;
+                    const arg = javaAssertjSubjectArg(call, shadowed);
+                    if (!arg)
+                        continue;
+                    // Subject is either the target call directly (`assertThat(this.fmt.m(...))`) or a local
+                    // whose initializer is the target call (`String r = this.fmt.m(...); assertThat(r)...`).
+                    const subject = arg.type === "identifier" ? (localInits.get(arg.text) ?? null) : arg;
+                    add(testName, shadowed, assertjAssertions, javaDirectProofTarget(subject, fieldTypes));
+                }
             }
-            processJavaNestedBlocks(stmt, testName, shadowed, processBlock);
+            processJavaNestedBlocks(stmt, testName, shadowed, (b, t, s) => processBlock(b, t, s, localInits));
         }
     };
     for (const method of root.descendantsOfType("method_declaration")) {
@@ -1137,7 +1292,7 @@ function extractJavaProofCalls(root, imports) {
         for (const declared of declaredMethods) {
             shadowed.add(declared);
         }
-        processBlock(body, name, shadowed);
+        processBlock(body, name, shadowed, javaLocalVarInits(body));
     }
     return out;
 }