@optave/codegraph 3.5.0 → 3.6.0

package/src/extractors/swift.ts

@@ -0,0 +1,293 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Swift files.
+ */
+export function extractSwiftSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkSwiftNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkSwiftNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'class_declaration':
+      handleSwiftClassDecl(node, ctx);
+      break;
+    case 'protocol_declaration':
+      handleSwiftProtocolDecl(node, ctx);
+      break;
+    case 'function_declaration':
+      handleSwiftFunctionDecl(node, ctx);
+      break;
+    case 'import_declaration':
+      handleSwiftImportDecl(node, ctx);
+      break;
+    case 'call_expression':
+      handleSwiftCallExpression(node, ctx);
+      break;
+    case 'property_declaration':
+      handleSwiftPropertyDecl(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkSwiftNode(child, ctx);
+  }
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function hasKeywordChild(node: TreeSitterNode, keyword: string): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.text === keyword) return true;
+  }
+  return false;
+}
+
+function handleSwiftClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const isStruct = hasKeywordChild(node, 'struct');
+  const isEnum = hasKeywordChild(node, 'enum');
+
+  // Name is a type_identifier direct child
+  const nameNode = findChild(node, 'type_identifier');
+  if (!nameNode) return;
+  const name = nameNode.text;
+
+  const kind = isEnum ? 'enum' : isStruct ? 'struct' : 'class';
+
+  const children: SubDeclaration[] = [];
+
+  if (isEnum) {
+    // Enum cases: enum_entry > simple_identifier, inside enum_class_body
+    const body = findChild(node, 'enum_class_body');
+    if (body) {
+      for (let i = 0; i < body.childCount; i++) {
+        const child = body.child(i);
+        if (child && child.type === 'enum_entry') {
+          const entryName = findChild(child, 'simple_identifier');
+          if (entryName) {
+            children.push({
+              name: entryName.text,
+              kind: 'constant',
+              line: child.startPosition.row + 1,
+            });
+          }
+        }
+      }
+    }
+  } else {
+    // Extract properties from class_body
+    const body = findChild(node, 'class_body');
+    if (body) {
+      for (let i = 0; i < body.childCount; i++) {
+        const child = body.child(i);
+        if (child && child.type === 'property_declaration') {
+          const pattern = findChild(child, 'pattern');
+          if (pattern) {
+            const propName = findChild(pattern, 'simple_identifier');
+            if (propName) {
+              children.push({
+                name: propName.text,
+                kind: 'property',
+                line: child.startPosition.row + 1,
+                visibility: extractModifierVisibility(child),
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  ctx.definitions.push({
+    name,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  // Methods inside class_body or enum_class_body
+  const body = findChild(node, 'class_body') || findChild(node, 'enum_class_body');
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child && child.type === 'function_declaration') {
+        const methName = findChild(child, 'simple_identifier');
+        if (methName) {
+          ctx.definitions.push({
+            name: `${name}.${methName.text}`,
+            kind: 'method',
+            line: child.startPosition.row + 1,
+            endLine: child.endPosition.row + 1,
+            visibility: extractModifierVisibility(child),
+          });
+        }
+      }
+    }
+  }
+
+  // Inheritance: inheritance_specifier nodes are DIRECT children of class_declaration
+  // First specifier is the superclass (extends), rest are protocol conformances (implements)
+  let first = true;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child || child.type !== 'inheritance_specifier') continue;
+    // inheritance_specifier > user_type > type_identifier
+    const userType = findChild(child, 'user_type');
+    if (userType) {
+      const typeId = findChild(userType, 'type_identifier');
+      if (typeId) {
+        if (first) {
+          ctx.classes.push({
+            name,
+            extends: typeId.text,
+            line: node.startPosition.row + 1,
+          });
+          first = false;
+        } else {
+          ctx.classes.push({
+            name,
+            implements: typeId.text,
+            line: node.startPosition.row + 1,
+          });
+        }
+      }
+    }
+  }
+}
+
+function handleSwiftProtocolDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'type_identifier');
+  if (!nameNode) return;
+  const name = nameNode.text;
+
+  ctx.definitions.push({
+    name,
+    kind: 'interface',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+
+  // Methods inside protocol_body or class_body
+  const body = findChild(node, 'protocol_body') || findChild(node, 'class_body');
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child && child.type === 'function_declaration') {
+        const methName = findChild(child, 'simple_identifier');
+        if (methName) {
+          ctx.definitions.push({
+            name: `${name}.${methName.text}`,
+            kind: 'method',
+            line: child.startPosition.row + 1,
+            endLine: child.endPosition.row + 1,
+          });
+        }
+      }
+    }
+  }
+}
+
+function handleSwiftFunctionDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Skip methods already emitted by class/protocol handlers
+  if (
+    node.parent?.type === 'class_body' ||
+    node.parent?.type === 'protocol_body' ||
+    node.parent?.type === 'enum_class_body'
+  ) {
+    if (
+      node.parent.parent?.type === 'class_declaration' ||
+      node.parent.parent?.type === 'protocol_declaration'
+    ) {
+      return;
+    }
+  }
+  const nameNode = findChild(node, 'simple_identifier');
+  if (!nameNode) return;
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility: extractModifierVisibility(node),
+  });
+}
+
+function handleSwiftImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const identNode = findChild(node, 'identifier');
+  if (!identNode) return;
+  const source = identNode.text;
+  ctx.imports.push({
+    source,
+    names: [source],
+    line: node.startPosition.row + 1,
+    swiftImport: true,
+  });
+}
+
+function handleSwiftCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+  if (funcNode.type === 'navigation_expression') {
+    // obj.method(...)
+    const lastChild = funcNode.child(funcNode.childCount - 1);
+    const firstChild = funcNode.child(0);
+    if (lastChild && lastChild.type === 'simple_identifier' && firstChild) {
+      call.name = lastChild.text;
+      call.receiver = firstChild.text;
+    }
+  } else if (funcNode.type === 'simple_identifier') {
+    call.name = funcNode.text;
+  } else {
+    call.name = funcNode.text;
+  }
+  if (call.name) ctx.calls.push(call);
+}
+
+function handleSwiftPropertyDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Only handle top-level properties (class properties are handled inline)
+  if (
+    node.parent?.type === 'class_body' ||
+    node.parent?.type === 'protocol_body' ||
+    node.parent?.type === 'enum_class_body'
+  ) {
+    return;
+  }
+  // Skip function-local let/var bindings
+  if (node.parent?.type === 'statements' || node.parent?.type === 'function_body') {
+    return;
+  }
+  const pattern = findChild(node, 'pattern');
+  if (!pattern) return;
+  const nameNode = findChild(pattern, 'simple_identifier');
+  if (!nameNode) return;
+  // let → constant, var → variable
+  const isLet = hasKeywordChild(node, 'let');
+  const kind = isLet ? 'constant' : 'variable';
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}

package/src/features/ast.ts

@@ -80,6 +80,8 @@ export async function buildAstNodes(
         }>,
       ): number;
     };
+    suspendJsDb?: () => void;
+    resumeJsDb?: () => void;
   },
 ): Promise<void> {
   // ── Native bulk-insert fast path ──────────────────────────────────────
@@ -108,7 +110,7 @@ export async function buildAstNodes(
             kind: n.kind,
             name: n.name,
             text: n.text,
-            receiver: n.receiver,
+            receiver: n.receiver ?? '',
           })),
         });
       } else if (symbols.calls || symbols._tree) {
@@ -119,7 +121,13 @@ export async function buildAstNodes(
 
     if (!needsJsFallback) {
       const expectedNodes = batches.reduce((s, b) => s + b.nodes.length, 0);
-      const inserted = nativeDb.bulkInsertAstNodes(batches);
+      let inserted: number;
+      try {
+        engineOpts?.suspendJsDb?.();
+        inserted = nativeDb.bulkInsertAstNodes(batches);
+      } finally {
+        engineOpts?.resumeJsDb?.();
+      }
       if (inserted === expectedNodes) {
         debug(`AST extraction (native bulk): ${inserted} nodes stored`);
         return;
@@ -158,29 +166,6 @@ export async function buildAstNodes(
       nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
     }
 
-    // When native astNodes includes call entries, skip separate symbols.calls processing
-    // to avoid duplication. Fall back to symbols.calls for WASM or older native binaries.
-    const nativeProvidedAstNodes = Array.isArray(symbols.astNodes);
-    if (symbols.calls && !nativeProvidedAstNodes) {
-      for (const call of symbols.calls) {
-        const parentDef = findParentDef(defs, call.line);
-        let parentNodeId: number | null = null;
-        if (parentDef) {
-          parentNodeId =
-            nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
-        }
-        allRows.push({
-          file: relPath,
-          line: call.line,
-          kind: 'call',
-          name: call.name,
-          text: call.dynamic ? `[dynamic] ${call.name}` : null,
-          receiver: call.receiver || null,
-          parentNodeId,
-        });
-      }
-    }
-
     if (Array.isArray(symbols.astNodes)) {
       // Native engine provided AST nodes (may be empty for files with no AST content)
       for (const n of symbols.astNodes) {

package/src/features/audit.ts

@@ -183,27 +183,8 @@ export function auditData(
   let functions: unknown[];
   try {
     if (explained.kind === 'file') {
-      // File target: explainData returns file-level info with publicApi + internal
-      // We need to enrich each symbol
-      functions = [];
-      for (const fileResult of results) {
-        const allSymbols = [
-          ...(fileResult.publicApi || []),
-          ...(fileResult.internal || []),
-        ] as FileSymbol[];
-        if (kind) {
-          const filtered = allSymbols.filter((s) => s.kind === kind);
-          for (const sym of filtered) {
-            functions.push(enrichSymbol(db, sym, fileResult.file, noTests, maxDepth, thresholds));
-          }
-        } else {
-          for (const sym of allSymbols) {
-            functions.push(enrichSymbol(db, sym, fileResult.file, noTests, maxDepth, thresholds));
-          }
-        }
-      }
+      functions = enrichFileResults(db, results, kind, noTests, maxDepth, thresholds);
     } else {
-      // Function target: explainData returns per-function results
       functions = results.map((r: ExplainResult) =>
         enrichFunction(db, r, noTests, maxDepth, thresholds),
       );
@@ -232,6 +213,29 @@ interface ExplainResult {
   relatedTests?: { file: string }[];
 }
 
+/** Enrich all symbols from file-target results. */
+function enrichFileResults(
+  db: BetterSqlite3Database,
+  results: any[],
+  kind: string | undefined,
+  noTests: boolean,
+  maxDepth: number,
+  thresholds: Record<string, ThresholdEntry>,
+): unknown[] {
+  const functions: unknown[] = [];
+  for (const fileResult of results) {
+    let allSymbols = [
+      ...(fileResult.publicApi || []),
+      ...(fileResult.internal || []),
+    ] as FileSymbol[];
+    if (kind) allSymbols = allSymbols.filter((s) => s.kind === kind);
+    for (const sym of allSymbols) {
+      functions.push(enrichSymbol(db, sym, fileResult.file, noTests, maxDepth, thresholds));
+    }
+  }
+  return functions;
+}
+
 function enrichFunction(
   db: BetterSqlite3Database,
   r: ExplainResult,

package/src/features/branch-compare.ts

@@ -5,8 +5,10 @@ import path from 'node:path';
 import { getDatabase } from '../db/better-sqlite3.js';
 import { buildGraph } from '../domain/graph/builder.js';
 import { kindIcon } from '../domain/queries.js';
+import { debug } from '../infrastructure/logger.js';
+import { getNative, isNativeAvailable } from '../infrastructure/native.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
-import type { EngineMode } from '../types.js';
+import type { EngineMode, NativeDatabase } from '../types.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
 
@@ -107,6 +109,18 @@ function loadSymbolsFromDb(
 ): Map<string, SymbolInfo> {
   const Database = getDatabase();
   const db = new Database(dbPath, { readonly: true });
+
+  // Try opening a NativeDatabase for batched fan metrics
+  let nativeDb: NativeDatabase | undefined;
+  if (isNativeAvailable()) {
+    try {
+      const native = getNative();
+      nativeDb = native.NativeDatabase.openReadonly(dbPath);
+    } catch (e) {
+      debug(`loadSymbolsFromDb: native path failed: ${(e as Error).message}`);
+    }
+  }
+
   try {
     const symbols = new Map<string, SymbolInfo>();
 
@@ -132,6 +146,34 @@ function loadSymbolsFromDb(
       end_line: number | null;
     }>;
 
+    // Filter first, then batch fan metrics for all surviving rows
+    const filtered = noTests ? rows.filter((r) => !isTestFile(r.file)) : rows;
+
+    // ── Native fast path: batch all fan-in/fan-out in one napi call ──
+    if (nativeDb?.batchFanMetrics && filtered.length > 0) {
+      const nodeIds = filtered.map((r) => r.id);
+      const metrics = nativeDb.batchFanMetrics(nodeIds);
+      const metricsMap = new Map(metrics.map((m) => [m.nodeId, m]));
+
+      for (const row of filtered) {
+        const lineCount = row.end_line ? row.end_line - row.line + 1 : 0;
+        const m = metricsMap.get(row.id);
+        const key = makeSymbolKey(row.kind, row.file, row.name);
+        symbols.set(key, {
+          id: row.id,
+          name: row.name,
+          kind: row.kind,
+          file: row.file,
+          line: row.line,
+          lineCount,
+          fanIn: m?.fanIn ?? 0,
+          fanOut: m?.fanOut ?? 0,
+        });
+      }
+      return symbols;
+    }
+
+    // ── JS fallback ───────────────────────────────────────────────────
     const fanInStmt = db.prepare(
       `SELECT COUNT(*) AS cnt FROM edges WHERE target_id = ? AND kind = 'calls'`,
     );
@@ -139,9 +181,7 @@ function loadSymbolsFromDb(
       `SELECT COUNT(*) AS cnt FROM edges WHERE source_id = ? AND kind = 'calls'`,
     );
 
-    for (const row of rows) {
-      if (noTests && isTestFile(row.file)) continue;
-
+    for (const row of filtered) {
       const lineCount = row.end_line ? row.end_line - row.line + 1 : 0;
       const fanIn = (fanInStmt.get(row.id) as { cnt: number }).cnt;
       const fanOut = (fanOutStmt.get(row.id) as { cnt: number }).cnt;
@@ -162,6 +202,13 @@ function loadSymbolsFromDb(
     return symbols;
   } finally {
     db.close();
+    if (nativeDb) {
+      try {
+        nativeDb.close();
+      } catch {
+        /* already closed */
+      }
+    }
   }
 }