@optave/codegraph 3.5.0 → 3.7.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/extractors/zig.ts

@@ -0,0 +1,294 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Zig files.
+ *
+ * Zig's structs/enums/unions are anonymous — their names come from the
+ * enclosing `variable_declaration` (e.g. `const Foo = struct { ... };`).
+ */
+export function extractZigSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkZigNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkZigNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function_declaration':
+      handleZigFunction(node, ctx);
+      break;
+    case 'variable_declaration':
+      handleZigVariable(node, ctx);
+      break;
+    case 'call_expression':
+      handleZigCallExpression(node, ctx);
+      break;
+    case 'builtin_function':
+      handleZigBuiltin(node, ctx);
+      break;
+    case 'test_declaration':
+      handleZigTest(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkZigNode(child, ctx);
+  }
+}
+
+function isInsideZigContainer(node: TreeSitterNode): boolean {
+  let current = node.parent;
+  while (current) {
+    if (current.type === 'struct_declaration' || current.type === 'union_declaration') return true;
+    current = current.parent;
+  }
+  return false;
+}
+
+function handleZigFunction(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  if (isInsideZigContainer(node)) return; // already emitted by extractZigContainerMethods
+
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  const params = extractZigParams(node);
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: isZigPub(node) ? 'public' : 'private',
+  });
+}
+
+function extractZigParams(funcNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramList = funcNode.childForFieldName('parameters');
+  if (!paramList) return params;
+
+  for (let i = 0; i < paramList.childCount; i++) {
+    const param = paramList.child(i);
+    if (!param || param.type !== 'parameter') continue;
+    const nameNode = findChild(param, 'identifier');
+    if (nameNode) {
+      params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+    }
+  }
+  return params;
+}
+
+function handleZigVariable(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'identifier');
+  if (!nameNode) return;
+  const name = nameNode.text;
+
+  // Check if this is a struct/enum/union definition
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+
+    if (child.type === 'struct_declaration') {
+      const members = extractZigContainerFields(child);
+      ctx.definitions.push({
+        name,
+        kind: 'struct',
+        line: node.startPosition.row + 1,
+        endLine: nodeEndLine(node),
+        children: members.length > 0 ? members : undefined,
+        visibility: isZigPub(node) ? 'public' : undefined,
+      });
+      extractZigContainerMethods(child, name, ctx);
+      return;
+    }
+    if (child.type === 'enum_declaration') {
+      ctx.definitions.push({
+        name,
+        kind: 'enum',
+        line: node.startPosition.row + 1,
+        endLine: nodeEndLine(node),
+        visibility: isZigPub(node) ? 'public' : undefined,
+      });
+      return;
+    }
+    if (child.type === 'union_declaration') {
+      ctx.definitions.push({
+        name,
+        kind: 'struct',
+        line: node.startPosition.row + 1,
+        endLine: nodeEndLine(node),
+        visibility: isZigPub(node) ? 'public' : undefined,
+      });
+      return;
+    }
+  }
+
+  // Check for @import
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'builtin_function') {
+      const builtinId = findChild(child, 'builtin_identifier');
+      if (builtinId?.text === '@import') {
+        const args = findChild(child, 'arguments');
+        if (args) {
+          const strArg = findChild(args, 'string_literal') || findChild(args, 'string');
+          if (strArg) {
+            const source = strArg.text.replace(/^"|"$/g, '');
+            ctx.imports.push({
+              source,
+              names: [name],
+              line: node.startPosition.row + 1,
+            });
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  // Regular constant/variable
+  const isConst = hasChildText(node, 'const');
+  ctx.definitions.push({
+    name,
+    kind: isConst ? 'constant' : 'variable',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function extractZigContainerFields(container: TreeSitterNode): SubDeclaration[] {
+  const fields: SubDeclaration[] = [];
+  for (let i = 0; i < container.childCount; i++) {
+    const child = container.child(i);
+    if (!child || child.type !== 'container_field') continue;
+    const nameNode = child.childForFieldName('name') || findChild(child, 'identifier');
+    if (nameNode) {
+      fields.push({ name: nameNode.text, kind: 'property', line: child.startPosition.row + 1 });
+    }
+  }
+  return fields;
+}
+
+function extractZigContainerMethods(
+  container: TreeSitterNode,
+  parentName: string,
+  ctx: ExtractorOutput,
+): void {
+  for (let i = 0; i < container.childCount; i++) {
+    const child = container.child(i);
+    if (!child || child.type !== 'function_declaration') continue;
+    const nameNode = child.childForFieldName('name');
+    if (nameNode) {
+      ctx.definitions.push({
+        name: `${parentName}.${nameNode.text}`,
+        kind: 'method',
+        line: child.startPosition.row + 1,
+        endLine: nodeEndLine(child),
+        visibility: isZigPub(child) ? 'public' : 'private',
+      });
+    }
+  }
+}
+
+function handleZigCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.childForFieldName('function');
+  if (!funcNode) return;
+
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+
+  if (funcNode.type === 'field_expression' || funcNode.type === 'field_access') {
+    const field = funcNode.childForFieldName('field') || funcNode.childForFieldName('member');
+    const value = funcNode.childForFieldName('value') || funcNode.child(0);
+    if (field) call.name = field.text;
+    if (value) call.receiver = value.text;
+  } else {
+    call.name = funcNode.text;
+  }
+
+  if (call.name) ctx.calls.push(call);
+}
+
+function handleZigBuiltin(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const builtinId = findChild(node, 'builtin_identifier');
+  if (!builtinId) return;
+
+  // Treat @import as import (when standalone, not in variable_declaration)
+  if (builtinId.text === '@import' && node.parent?.type !== 'variable_declaration') {
+    const args = findChild(node, 'arguments');
+    if (args) {
+      const strArg = findChild(args, 'string_literal') || findChild(args, 'string');
+      if (strArg) {
+        const source = strArg.text.replace(/^"|"$/g, '');
+        ctx.imports.push({
+          source,
+          names: ['@import'],
+          line: node.startPosition.row + 1,
+        });
+      }
+    }
+    return;
+  }
+
+  // Other builtins are calls
+  ctx.calls.push({ name: builtinId.text, line: node.startPosition.row + 1 });
+}
+
+function handleZigTest(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  let name = 'test';
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'string_literal' || child.type === 'string') {
+      // Extract the string content child if available, otherwise strip quotes
+      const content = findChild(child, 'string_content');
+      name = content ? content.text : child.text.replace(/^"|"$/g, '');
+      break;
+    }
+    if (child.type === 'identifier') {
+      name = child.text;
+      break;
+    }
+  }
+
+  ctx.definitions.push({
+    name,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function isZigPub(node: TreeSitterNode): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'pub') return true;
+    if (child && child.text === 'pub') return true;
+  }
+  return false;
+}
+
+function hasChildText(node: TreeSitterNode, text: string): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.text === text) return true;
+  }
+  return false;
+}

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,