feat(java): capture super() constructor-chain edges in the call graph (#138)

Round-4 Java deep-dive (spring-petclinic + commons-cli + gson). Three agents
audited code skeletons/CFG/type-inference, duplicate detection, and the MCP
context tools (orient/get_subgraph/get_signatures/...) — all returned clean
bills with the full rounds-1-3 regression sweep PASSing. The one genuine gap
left was constructor edges.

Java `super(...)` explicit constructor invocations were invisible to the call
graph (JAVA_CALL_QUERY only matched method_invocation / object_creation), so
class-hierarchy constructor chains never showed in impact analysis or fan-in/
out. synthesizeJavaSuperCalls now reads each class's parent from its `extends`
clause and emits a constructor-typed edge to the parent class's constructor
(constructors are keyed by class simple-name).

Deliberately scoped to avoid noise/regressions:
- this(...) is omitted — overloaded constructors collapse to one node, so it
  would only ever be a self-loop.
- super(...) to a superclass outside the codebase (e.g. extends RuntimeException)
  is dropped during resolution rather than turned into an external leaf node,
  via a callType:'constructor' guard in Strategy 4. Java `new` edges leave
  callType undefined, so existing behavior is untouched.

Verified: commons-cli yields 7 internal super() edges (e.g. AmbiguousOption-
Exception -> UnrecognizedOptionException); external superclasses add no node;
petclinic (implicit super only) correctly yields 0. Also added an explicit
package-info/module-info entity-filter regression test (agent suggestion).

Full suite green (3720 passing).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: clay-good

src/core/analyzer/artifact-generator.test.ts

@@ -307,6 +307,33 @@ describe('AnalysisArtifactGenerator', () => {
       }
     });
 
+    it('excludes package-info/module-info marker files from entities (#138)', async () => {
+      const files: ScoredFile[] = [
+        createScoredFile({ name: 'TypeToken.java', path: 'src/main/java/com/acme/reflect/TypeToken.java', directory: 'src/main/java/com/acme/reflect', score: 70 }),
+        createScoredFile({ name: 'package-info.java', path: 'src/main/java/com/acme/reflect/package-info.java', directory: 'src/main/java/com/acme/reflect', score: 40 }),
+        createScoredFile({ name: 'module-info.java', path: 'src/main/java/module-info.java', directory: 'src/main/java', score: 40 }),
+      ];
+      const repoMap = createMockRepoMap({
+        highValueFiles: files,
+        allFiles: files,
+        clusters: {
+          byDirectory: { 'src/main/java/com/acme/reflect': files },
+          byDomain: { reflect: files },
+          byLayer: { presentation: files, business: [], data: [], infrastructure: [] },
+        },
+      });
+
+      const artifacts = await generateArtifacts(repoMap, createMockDepGraph(), {
+        rootDir: tempDir,
+        outputDir,
+      });
+
+      const reflect = artifacts.repoStructure.domains.find(d => d.name === 'reflect');
+      expect(reflect?.entities).toContain('TypeToken');
+      expect(reflect?.entities).not.toContain('PackageInfo');
+      expect(reflect?.entities).not.toContain('ModuleInfo');
+    });
+
     it('should generate entry points', async () => {
       const repoMap = createMockRepoMap();
       const depGraph = createMockDepGraph();

src/core/analyzer/call-graph.test.ts

@@ -644,6 +644,54 @@ public class UserRepository {
     expect(nodeNames(result)).toContain('UserRepository');
     expect(nodeNames(result)).toContain('init');
   });
+
+  it('captures super(...) as an edge to the parent class constructor (#138)', async () => {
+    const builder = new CallGraphBuilder();
+    const result = await builder.build([
+      { path: 'Person.java', language: 'Java', content: `
+public class Person {
+    public Person(String name) {}
+}
+      ` },
+      { path: 'Owner.java', language: 'Java', content: `
+public class Owner extends Person {
+    public Owner(String name, int age) { super(name); }
+}
+      ` },
+    ]);
+
+    // Constructor nodes are keyed by the class name; super(name) → Person's ctor.
+    const ctorEdges = result.edges.filter(e => e.callType === 'constructor');
+    expect(ctorEdges).toHaveLength(1);
+    expect(edgePairs(result)).toContain('Owner→Person');
+  });
+
+  it('omits this(...) self-delegation (overloads collapse to one node) (#138)', async () => {
+    const builder = new CallGraphBuilder();
+    const result = await builder.build([{
+      path: 'Point.java', language: 'Java', content: `
+public class Point {
+    public Point(int x, int y) {}
+    public Point() { this(0, 0); }
+}
+      ` }]);
+    // No constructor edge: this(...) would only be a self-loop on the collapsed node.
+    expect(result.edges.filter(e => e.callType === 'constructor')).toHaveLength(0);
+  });
+
+  it('drops super(...) to an external superclass without creating an external node (#138)', async () => {
+    const builder = new CallGraphBuilder();
+    const result = await builder.build([{
+      path: 'FooException.java', language: 'Java', content: `
+public class FooException extends RuntimeException {
+    public FooException(String m) { super(m); }
+}
+      ` }]);
+    // The parent (RuntimeException) is not in the codebase → no edge, no external node.
+    expect(result.edges.filter(e => e.callType === 'constructor')).toHaveLength(0);
+    expect(nodeNames(result)).not.toContain('RuntimeException');
+    expect(Array.from(result.nodes.keys()).some(id => id.includes('RuntimeException'))).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------

src/core/analyzer/call-graph.ts

@@ -1637,6 +1637,57 @@ function dedupeOverlappingCalls(
   return rawEdges;
 }
 
+/**
+ * Synthesize call edges for Java `super(...)` explicit constructor invocations.
+ *
+ * A `super(...)` call targets the PARENT class's constructor, which is keyed in
+ * the graph by the parent's simple name (constructors are named after their
+ * class). We read each class's parent from its `extends` clause and emit a
+ * constructor-typed edge from the enclosing constructor to the parent name.
+ *
+ * `this(...)` is intentionally skipped: overloaded constructors collapse to a
+ * single node, so a `this(...)` edge would only ever be a self-loop.
+ *
+ * Edges whose parent does not resolve to an internal node (e.g. `extends
+ * RuntimeException`) are dropped during resolution — the `callType: 'constructor'`
+ * marker tells Strategy 4 not to manufacture an external leaf node for them, so
+ * the external-node set stays clean.
+ */
+function synthesizeJavaSuperCalls(
+  root: Parser.SyntaxNode,
+  nodes: FunctionNode[],
+  lang: unknown
+): RawEdge[] {
+  // class simple-name → parent simple-name, from `extends` clauses.
+  const parentOf = new Map<string, string>();
+  const clsQuery = new _NativeQuery!(
+    lang as Parser.Language,
+    `(class_declaration name: (identifier) @cls (superclass (type_identifier) @parent))`
+  );
+  for (const m of clsQuery.matches(root)) {
+    const cls = m.captures.find(c => c.name === 'cls')?.node.text;
+    const parent = m.captures.find(c => c.name === 'parent')?.node.text;
+    if (cls && parent) parentOf.set(cls, parent);
+  }
+  if (parentOf.size === 0) return [];
+
+  const out: RawEdge[] = [];
+  const ctorQuery = new _NativeQuery!(
+    lang as Parser.Language,
+    `(explicit_constructor_invocation (super)) @node`
+  );
+  for (const m of ctorQuery.matches(root)) {
+    const node = m.captures.find(c => c.name === 'node')?.node;
+    if (!node) continue;
+    const caller = findEnclosingFunction(nodes, node.startIndex);
+    if (!caller?.className) continue;
+    const parent = parentOf.get(caller.className);
+    if (!parent) continue;
+    out.push({ callerId: caller.id, calleeName: parent, line: node.startPosition.row + 1, callType: 'constructor' });
+  }
+  return out;
+}
+
 async function extractJavaGraph(
   filePath: string,
   content: string
@@ -1704,6 +1755,9 @@ async function extractJavaGraph(
   // preferring the qualified match (it carries the receiver).
   const rawEdges = dedupeOverlappingCalls(callQuery, tree.rootNode, nodes, 'Java');
 
+  // super(...) constructor-chain edges (this(...) intentionally omitted).
+  rawEdges.push(...synthesizeJavaSuperCalls(tree.rootNode, nodes, lang));
+
   return { nodes, rawEdges, cfg };
 }
 
@@ -4226,6 +4280,10 @@ export class CallGraphBuilder {
       if (!calleeNode && !raw.calleeObject) {
         const candidates = trie.findBySimpleName(raw.calleeName);
         if (candidates.length === 0) {
+          // A synthesized super(...) edge whose parent class is not in the
+          // analyzed code (e.g. `extends RuntimeException`) is dropped rather
+          // than turned into an external leaf — keeps the external-node set clean.
+          if (raw.callType === 'constructor') continue;
           // Unresolved bare call — create a synthetic external leaf node
           calleeNode = getOrCreateExternalNode(raw.calleeName, allNodes);
           confidence = 'external';