@optave/codegraph 3.13.0 → 3.15.0

package/src/extractors/kotlin.ts

@@ -44,6 +44,9 @@ function walkKotlinNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'navigation_expression':
       handleKotlinNavExpression(node, ctx);
       break;
+    case 'callable_reference':
+      handleKotlinCallableRef(node, ctx);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -270,7 +273,10 @@ function handleKotlinCallExpression(node: TreeSitterNode, ctx: ExtractorOutput):
   const funcNode = node.child(0);
   if (!funcNode) return;
   if (funcNode.type === 'simple_identifier') {
-    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+    const name = funcNode.text;
+    // Bare invoke() with no receiver is a resolvable operator fun invoke() self-call —
+    // only flag as unresolved-dynamic when called on a receiver (handled in handleKotlinNavExpression).
+    ctx.calls.push({ name, line: node.startPosition.row + 1 });
   }
 }
 
@@ -280,12 +286,60 @@ function handleKotlinNavExpression(node: TreeSitterNode, ctx: ExtractorOutput):
   const lastChild = node.child(node.childCount - 1);
   const firstChild = node.child(0);
   if (lastChild && lastChild.type === 'simple_identifier' && firstChild) {
-    const call: Call = { name: lastChild.text, line: node.startPosition.row + 1 };
-    call.receiver = firstChild.text;
+    const methodName = lastChild.text;
+    const receiver = firstChild.text;
+    // fn.invoke(args) on a Kotlin callable — unresolvable without type info
+    if (methodName === 'invoke') {
+      ctx.calls.push({
+        name: '<dynamic:unresolved>',
+        line: node.startPosition.row + 1,
+        dynamic: true,
+        dynamicKind: 'unresolved-dynamic',
+        receiver,
+      });
+      return;
+    }
+    const call: Call = { name: methodName, line: node.startPosition.row + 1 };
+    call.receiver = receiver;
     ctx.calls.push(call);
   }
 }
 
+/**
+ * Handle Kotlin callable references: `::greet` and `obj::method`.
+ * Emits a reflection-kind call with the referenced member name.
+ */
+function handleKotlinCallableRef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // callable_reference: [qualifier '::'] simple_identifier
+  // Find the simple_identifier after '::'
+  let foundDoubleColon = false;
+  let qualifier: string | undefined;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === '::') {
+      foundDoubleColon = true;
+      continue;
+    }
+    if (!foundDoubleColon) {
+      // Everything before '::' is the qualifier
+      if (child.type === 'simple_identifier' || child.type === 'type_identifier') {
+        qualifier = child.text;
+      }
+    } else if (child.type === 'simple_identifier') {
+      // The member name
+      ctx.calls.push({
+        name: child.text,
+        line: node.startPosition.row + 1,
+        dynamic: true,
+        dynamicKind: 'reflection',
+        receiver: qualifier,
+      });
+      return;
+    }
+  }
+}
+
 // ── Child extraction helpers ────────────────────────────────────────────────
 
 function extractKotlinParameters(funcNode: TreeSitterNode): SubDeclaration[] {

package/src/extractors/objc.ts

@@ -336,7 +336,19 @@ function handleCCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   } else {
     call.name = funcNode.text;
   }
-  if (call.name) ctx.calls.push(call);
+  if (!call.name) return;
+  // objc_msgSend(obj, sel, ...) — raw ObjC runtime call; selector is a SEL value
+  if (call.name === 'objc_msgSend') {
+    ctx.calls.push({
+      name: '<dynamic:unresolved>',
+      line: call.line,
+      dynamic: true,
+      dynamicKind: 'unresolved-dynamic',
+      receiver: call.receiver,
+    });
+    return;
+  }
+  ctx.calls.push(call);
 }
 
 function handleMessageExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
@@ -368,6 +380,18 @@ function handleMessageExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
     name = selector.text;
   }
 
+  // performSelector: / performSelector:withObject: — SEL dispatch; not statically resolvable
+  if (name === 'performSelector:' || name.startsWith('performSelector:withObject')) {
+    ctx.calls.push({
+      name: '<dynamic:unresolved>',
+      line: node.startPosition.row + 1,
+      dynamic: true,
+      dynamicKind: 'unresolved-dynamic',
+      receiver: receiver?.text,
+    });
+    return;
+  }
+
   const call: Call = { name, line: node.startPosition.row + 1 };
   if (receiver) call.receiver = receiver.text;
   ctx.calls.push(call);

package/src/extractors/scala.ts

@@ -142,6 +142,23 @@ function handleScalaImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
   });
 }
 
+/** Extract the first string literal argument from a Scala call_expression. */
+function getFirstStringArgScala(node: TreeSitterNode): string | null {
+  const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
+  if (!args) return null;
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child) continue;
+    const t = child.type;
+    if (t === '(' || t === ')' || t === ',') continue;
+    if (t === 'string' || t === 'string_literal') {
+      return child.text.replace(/^["']|["']$/g, '');
+    }
+    break;
+  }
+  return null;
+}
+
 function handleScalaCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const funcNode = node.childForFieldName('function');
   if (!funcNode) return;
@@ -154,7 +171,52 @@ function handleScalaCallExpression(node: TreeSitterNode, ctx: ExtractorOutput):
   } else {
     call.name = funcNode.text;
   }
-  if (call.name) ctx.calls.push(call);
+  if (!call.name) return;
+
+  // method.invoke(target, args) — Java/Scala reflection; target unknown statically.
+  // Require a non-null receiver to avoid false positives on user-defined `invoke` methods.
+  if (call.name === 'invoke' && call.receiver !== undefined) {
+    ctx.calls.push({
+      name: '<dynamic:unresolved>',
+      line: call.line,
+      dynamic: true,
+      dynamicKind: 'unresolved-dynamic',
+      receiver: call.receiver,
+    });
+    return;
+  }
+
+  // clazz.getMethod("name") / getDeclaredMethod("name") — resolvable if literal.
+  // Require a non-null receiver to avoid false positives on gRPC ServiceDescriptor.getMethod(),
+  // Spring AnnotationUtils.getDeclaredMethod(), proto-generated descriptors, and any other API
+  // that exposes a method by this name unrelated to java.lang.Class reflection.
+  if (
+    (call.name === 'getMethod' || call.name === 'getDeclaredMethod') &&
+    call.receiver !== undefined
+  ) {
+    const literal = getFirstStringArgScala(node);
+    if (literal) {
+      ctx.calls.push({
+        name: literal,
+        line: call.line,
+        dynamic: true,
+        dynamicKind: 'reflection',
+        keyExpr: literal,
+        receiver: call.receiver,
+      });
+    } else {
+      ctx.calls.push({
+        name: '<dynamic:computed-key>',
+        line: call.line,
+        dynamic: true,
+        dynamicKind: 'computed-key',
+        receiver: call.receiver,
+      });
+    }
+    return;
+  }
+
+  ctx.calls.push(call);
 }
 
 function handleScalaValVarDef(node: TreeSitterNode, ctx: ExtractorOutput): void {

package/src/extractors/swift.ts

@@ -42,6 +42,7 @@ function walkSwiftNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
       handleSwiftCallExpression(node, ctx);
       break;
     case 'property_declaration':
+      seedSwiftPropertyTypeMap(node, ctx);
       handleSwiftPropertyDecl(node, ctx);
       break;
   }
@@ -250,11 +251,26 @@ function handleSwiftCallExpression(node: TreeSitterNode, ctx: ExtractorOutput):
   if (!funcNode) return;
   const call: Call = { name: '', line: node.startPosition.row + 1 };
   if (funcNode.type === 'navigation_expression') {
-    // obj.method(...)
+    // obj.method(...) — Swift's tree-sitter grammar wraps the suffix in a
+    // `navigation_suffix` node: navigation_expression > [simple_identifier, navigation_suffix].
+    // We must descend into navigation_suffix to get the bare method name (e.g. "save" not ".save").
+    // Mirrors Rust match_swift_node which also descends into navigation_suffix via find_child
+    // to extract the inner simple_identifier, with a trim_start_matches('.') fallback.
     const lastChild = funcNode.child(funcNode.childCount - 1);
     const firstChild = funcNode.child(0);
-    if (lastChild && lastChild.type === 'simple_identifier' && firstChild) {
-      call.name = lastChild.text;
+    if (lastChild && firstChild) {
+      // Resolve the method name: descend into navigation_suffix to find the
+      // simple_identifier, or fall back to stripping the leading dot from the text.
+      let methodName: string;
+      if (lastChild.type === 'simple_identifier') {
+        methodName = lastChild.text;
+      } else if (lastChild.type === 'navigation_suffix') {
+        const inner = findChild(lastChild, 'simple_identifier');
+        methodName = inner ? inner.text : lastChild.text.replace(/^\./, '');
+      } else {
+        methodName = lastChild.text;
+      }
+      call.name = methodName;
       call.receiver = firstChild.text;
     }
   } else if (funcNode.type === 'simple_identifier') {
@@ -265,6 +281,33 @@ function handleSwiftCallExpression(node: TreeSitterNode, ctx: ExtractorOutput):
   if (call.name) ctx.calls.push(call);
 }
 
+/**
+ * Seed the typeMap for a property_declaration with a type annotation.
+ * This runs for ALL property_declaration nodes (including class-body ones)
+ * so that `repo.method()` calls can be resolved to the correct class.
+ * Mirrors Rust match_swift_type_map which walks all nodes unconditionally.
+ */
+function seedSwiftPropertyTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeAnn = findChild(node, 'type_annotation');
+  if (!typeAnn) return;
+  // type_annotation: ":" <user_type | simple_identifier | ...>
+  // The last child is the actual type node.
+  const lastChild = typeAnn.child(typeAnn.childCount - 1);
+  if (!lastChild) return;
+  // For "user_type > type_identifier", grab the inner identifier text;
+  // for a plain simple_identifier, use it directly.
+  const typeNode =
+    lastChild.type === 'user_type' ? findChild(lastChild, 'type_identifier') : lastChild;
+  if (!typeNode) return;
+  const typeName = typeNode.text;
+  if (!typeName) return;
+  const pattern = findChild(node, 'pattern');
+  if (!pattern) return;
+  const varName = findChild(pattern, 'simple_identifier')?.text ?? pattern.text;
+  if (!varName) return;
+  ctx.typeMap.set(varName, { type: typeName, confidence: 0.9 });
+}
+
 function handleSwiftPropertyDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // Only handle top-level properties (class properties are handled inline)
   if (

package/src/features/audit.ts

@@ -289,6 +289,46 @@ interface FileSymbol {
   signature?: string | null;
 }
 
+/** Query callees, callers, and related test files for a node. */
+function querySymbolEdges(
+  db: BetterSqlite3Database,
+  nodeId: number,
+  noTests: boolean,
+): { callees: SymbolRef[]; callers: SymbolRef[]; relatedTests: { file: string }[] } {
+  const callees = (
+    db
+      .prepare(
+        `SELECT n.name, n.kind, n.file, n.line
+       FROM edges e JOIN nodes n ON e.target_id = n.id
+       WHERE e.source_id = ? AND e.kind = 'calls'`,
+      )
+      .all(nodeId) as SymbolRef[]
+  ).map(toSymbolRef);
+
+  let callers = (
+    db
+      .prepare(
+        `SELECT n.name, n.kind, n.file, n.line
+       FROM edges e JOIN nodes n ON e.source_id = n.id
+       WHERE e.target_id = ? AND e.kind = 'calls'`,
+      )
+      .all(nodeId) as SymbolRef[]
+  ).map(toSymbolRef);
+  if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
+
+  const testCallerRows = db
+    .prepare(
+      `SELECT DISTINCT n.file FROM edges e JOIN nodes n ON e.source_id = n.id
+       WHERE e.target_id = ? AND e.kind = 'calls'`,
+    )
+    .all(nodeId) as { file: string }[];
+  const relatedTests = testCallerRows
+    .filter((r) => isTestFile(r.file))
+    .map((r) => ({ file: r.file }));
+
+  return { callees, callers, relatedTests };
+}
+
 function enrichSymbol(
   db: BetterSqlite3Database,
   sym: FileSymbol,
@@ -305,40 +345,9 @@ function enrichSymbol(
   const endLine = nodeRow?.end_line || null;
   const lineCount = endLine ? endLine - sym.line + 1 : null;
 
-  // Get callers/callees for this symbol
-  let callees: SymbolRef[] = [];
-  let callers: SymbolRef[] = [];
-  let relatedTests: { file: string }[] = [];
-  if (nodeId) {
-    callees = (
-      db
-        .prepare(
-          `SELECT n.name, n.kind, n.file, n.line
-         FROM edges e JOIN nodes n ON e.target_id = n.id
-         WHERE e.source_id = ? AND e.kind = 'calls'`,
-        )
-        .all(nodeId) as SymbolRef[]
-    ).map(toSymbolRef);
-
-    callers = (
-      db
-        .prepare(
-          `SELECT n.name, n.kind, n.file, n.line
-         FROM edges e JOIN nodes n ON e.source_id = n.id
-         WHERE e.target_id = ? AND e.kind = 'calls'`,
-        )
-        .all(nodeId) as SymbolRef[]
-    ).map(toSymbolRef);
-    if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
-
-    const testCallerRows = db
-      .prepare(
-        `SELECT DISTINCT n.file FROM edges e JOIN nodes n ON e.source_id = n.id
-         WHERE e.target_id = ? AND e.kind = 'calls'`,
-      )
-      .all(nodeId) as { file: string }[];
-    relatedTests = testCallerRows.filter((r) => isTestFile(r.file)).map((r) => ({ file: r.file }));
-  }
+  const { callees, callers, relatedTests } = nodeId
+    ? querySymbolEdges(db, nodeId, noTests)
+    : { callees: [], callers: [], relatedTests: [] };
 
   const health = nodeId ? buildHealth(db, nodeId, thresholds) : defaultHealth();
   const impact = nodeId

package/src/features/boundaries.ts

@@ -174,6 +174,21 @@ export function validateBoundaryConfig(config: unknown): { valid: boolean; error
 
 // ─── Preset Rule Generation ─────────────────────────────────────────
 
+/** Collect the names of all modules assigned to layers outer than `layerIdx`. */
+function collectOuterModules(
+  modulesByLayer: Map<string, string[]>,
+  layerIndex: Map<string, number>,
+  layerIdx: number,
+): string[] {
+  const outer: string[] = [];
+  for (const [otherLayer, otherModNames] of modulesByLayer) {
+    if (layerIndex.get(otherLayer)! > layerIdx) {
+      outer.push(...otherModNames);
+    }
+  }
+  return outer;
+}
+
 function generatePresetRules(
   modules: Map<string, ResolvedModule>,
   presetName: string,
@@ -181,8 +196,7 @@ function generatePresetRules(
   const preset = PRESETS[presetName];
   if (!preset) return [];
 
-  const layers = preset.layers;
-  const layerIndex = new Map<string, number>(layers.map((l, i) => [l, i]));
+  const layerIndex = new Map<string, number>(preset.layers.map((l, i) => [l, i]));
 
   const modulesByLayer = new Map<string, string[]>();
   for (const [name, mod] of modules) {
@@ -194,13 +208,7 @@ function generatePresetRules(
 
   const rules: BoundaryRule[] = [];
   for (const [layer, modNames] of modulesByLayer) {
-    const idx = layerIndex.get(layer)!;
-    const outerModules: string[] = [];
-    for (const [otherLayer, otherModNames] of modulesByLayer) {
-      if (layerIndex.get(otherLayer)! > idx) {
-        outerModules.push(...otherModNames);
-      }
-    }
+    const outerModules = collectOuterModules(modulesByLayer, layerIndex, layerIndex.get(layer)!);
     if (outerModules.length > 0) {
       for (const from of modNames) {
         rules.push({ from, notTo: outerModules });

package/src/features/cfg.ts

@@ -136,6 +136,35 @@ async function initCfgParsers(
   return { parsers, getParserFn };
 }
 
+/** Parse source via WASM when no native CFG data is available.
+ *  Returns the parsed tree or undefined on any read/parse failure. */
+function parseTreeForCfg(
+  relPath: string,
+  rootDir: string,
+  _langId: string,
+  parsers: unknown,
+  getParserFn: unknown,
+): { rootNode: TreeSitterNode } | undefined {
+  const absPath = path.join(rootDir, relPath);
+  let code: string;
+  try {
+    code = fs.readFileSync(absPath, 'utf-8');
+  } catch (e) {
+    debug(`cfg: cannot read ${relPath}: ${(e as Error).message}`);
+    return undefined;
+  }
+
+  const parser = (getParserFn as (parsers: unknown, absPath: string) => unknown)(parsers, absPath);
+  if (!parser) return undefined;
+
+  try {
+    return (parser as { parse: (code: string) => { rootNode: TreeSitterNode } }).parse(code);
+  } catch (e) {
+    debug(`cfg: parse failed for ${relPath}: ${(e as Error).message}`);
+    return undefined;
+  }
+}
+
 function getTreeAndLang(
   symbols: FileSymbols,
   relPath: string,
@@ -152,28 +181,8 @@ function getTreeAndLang(
     if (!getParserFn) return null;
     langId = extToLang.get(ext);
     if (!langId || !CFG_RULES.has(langId)) return null;
-
-    const absPath = path.join(rootDir, relPath);
-    let code: string;
-    try {
-      code = fs.readFileSync(absPath, 'utf-8');
-    } catch (e) {
-      debug(`cfg: cannot read ${relPath}: ${(e as Error).message}`);
-      return null;
-    }
-
-    const parser = (getParserFn as (parsers: unknown, absPath: string) => unknown)(
-      parsers,
-      absPath,
-    );
-    if (!parser) return null;
-
-    try {
-      tree = (parser as { parse: (code: string) => { rootNode: TreeSitterNode } }).parse(code);
-    } catch (e) {
-      debug(`cfg: parse failed for ${relPath}: ${(e as Error).message}`);
-      return null;
-    }
+    tree = parseTreeForCfg(relPath, rootDir, langId, parsers, getParserFn);
+    if (!tree) return null;
   }
 
   if (!langId) {

package/src/features/check.ts

@@ -25,6 +25,22 @@ interface ParsedDiff {
 const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 const NEW_FILE_RE = /^\+\+\+ b\/(.+)/;
 
+/** Returns true if the diff line marks the old file as /dev/null (new-file creation). */
+function isDevNullSourceLine(line: string): boolean {
+  return line.startsWith('--- /dev/null');
+}
+
+/** Returns true if the diff line is a `---` source file header (not /dev/null). */
+function isSourceFileHeaderLine(line: string): boolean {
+  return line.startsWith('--- ');
+}
+
+/** Extracts the new filename from a `+++ b/<file>` diff header, or null. */
+function extractNewFileName(line: string): string | null {
+  const m = line.match(NEW_FILE_RE);
+  return m ? m[1]! : null;
+}
+
 function pushHunkRanges(
   line: string,
   currentFile: string,
@@ -53,17 +69,17 @@ export function parseDiffOutput(diffOutput: string): ParsedDiff {
   let prevIsDevNull = false;
 
   for (const line of diffOutput.split('\n')) {
-    if (line.startsWith('--- /dev/null')) {
+    if (isDevNullSourceLine(line)) {
       prevIsDevNull = true;
       continue;
     }
-    if (line.startsWith('--- ')) {
+    if (isSourceFileHeaderLine(line)) {
       prevIsDevNull = false;
       continue;
     }
-    const fileMatch = line.match(NEW_FILE_RE);
-    if (fileMatch) {
-      currentFile = fileMatch[1]!;
+    const newFile = extractNewFileName(line);
+    if (newFile) {
+      currentFile = newFile;
       if (!changedRanges.has(currentFile)) changedRanges.set(currentFile, []);
       if (!oldRanges.has(currentFile)) oldRanges.set(currentFile, []);
       if (prevIsDevNull) newFiles.add(currentFile);

package/src/features/communities.ts

@@ -146,33 +146,42 @@ function analyzeDrift(
 
 // ─── Core Analysis ────────────────────────────────────────────────────
 
-export function communitiesData(
-  customDbPath?: string,
-  opts: {
-    functions?: boolean;
-    resolution?: number;
-    noTests?: boolean;
-    drift?: boolean;
-    json?: boolean;
-    config?: CodegraphConfig;
-    maxLevels?: number;
-    maxLocalPasses?: number;
-    refinementTheta?: number;
-    limit?: number;
-    offset?: number;
-    repo?: Repository;
-  } = {},
-): Record<string, unknown> {
+type CommunitiesDataOpts = {
+  functions?: boolean;
+  resolution?: number;
+  noTests?: boolean;
+  drift?: boolean;
+  json?: boolean;
+  config?: CodegraphConfig;
+  maxLevels?: number;
+  maxLocalPasses?: number;
+  refinementTheta?: number;
+  limit?: number;
+  offset?: number;
+  repo?: Repository;
+};
+
+/** Load dependency graph from the repo, then close the DB connection. */
+function loadCommunityGraph(
+  customDbPath: string | undefined,
+  opts: CommunitiesDataOpts,
+): CodeGraph {
   const { repo, close } = openRepo(customDbPath, opts);
-  let graph: CodeGraph;
   try {
-    graph = buildDependencyGraph(repo, {
+    return buildDependencyGraph(repo, {
       fileLevel: !opts.functions,
       noTests: opts.noTests,
     });
   } finally {
     close();
   }
+}
+
+export function communitiesData(
+  customDbPath?: string,
+  opts: CommunitiesDataOpts = {},
+): Record<string, unknown> {
+  const graph = loadCommunityGraph(customDbPath, opts);
 
   if (graph.nodeCount === 0 || graph.edgeCount === 0) {
     return {