@optave/codegraph 3.6.0 → 3.8.0

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

@@ -12,10 +12,9 @@ import type { ASTNodeKind, BetterSqlite3Database, Definition, TreeSitterNode } f
 
 // ─── Constants ────────────────────────────────────────────────────────
 
-export const AST_NODE_KINDS: ASTNodeKind[] = ['call', 'new', 'string', 'regex', 'throw', 'await'];
+export const AST_NODE_KINDS: ASTNodeKind[] = ['new', 'string', 'regex', 'throw', 'await'];
 
 const KIND_ICONS: Record<string, string> = {
-  call: '\u0192', // ƒ
   new: '\u2295', // ⊕
   string: '"',
   regex: '/',

package/src/features/cfg.ts

@@ -369,7 +369,7 @@ export async function buildCFGData(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   rootDir: string,
-  engineOpts?: {
+  _engineOpts?: {
     nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
     suspendJsDb?: () => void;
     resumeJsDb?: () => void;
@@ -379,56 +379,11 @@ export async function buildCFGData(
   // skip WASM parser init, tree parsing, and JS visitor entirely — just persist.
   const allNative = allCfgNative(fileSymbols);
 
-  // ── Native bulk-insert fast path ──────────────────────────────────────
-  const nativeDb = engineOpts?.nativeDb;
-  if (allNative && nativeDb?.bulkInsertCfg) {
-    const entries: Array<Record<string, unknown>> = [];
-
-    for (const [relPath, symbols] of fileSymbols) {
-      const ext = path.extname(relPath).toLowerCase();
-      if (!CFG_EXTENSIONS.has(ext)) continue;
-
-      for (const def of symbols.definitions) {
-        if (def.kind !== 'function' && def.kind !== 'method') continue;
-        if (!def.line) continue;
-
-        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-        if (!nodeId) continue;
-
-        deleteCfgForNode(db, nodeId);
-        if (!def.cfg?.blocks?.length) continue;
-
-        const cfg = def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] };
-        entries.push({
-          nodeId,
-          blocks: cfg.blocks.map((b) => ({
-            index: b.index,
-            blockType: b.type,
-            startLine: b.startLine ?? null,
-            endLine: b.endLine ?? null,
-            label: b.label ?? null,
-          })),
-          edges: cfg.edges.map((e) => ({
-            sourceIndex: e.sourceIndex,
-            targetIndex: e.targetIndex,
-            kind: e.kind,
-          })),
-        });
-      }
-    }
-
-    if (entries.length > 0) {
-      let inserted: number;
-      try {
-        engineOpts?.suspendJsDb?.();
-        inserted = nativeDb.bulkInsertCfg(entries);
-      } finally {
-        engineOpts?.resumeJsDb?.();
-      }
-      info(`CFG (native bulk): ${inserted} blocks across ${entries.length} functions`);
-    }
-    return;
-  }
+  // NOTE: nativeDb.bulkInsertCfg is intentionally NOT used here.
+  // The CFG path requires delete-before-insert (deleteCfgForNode) which creates
+  // a dual-connection WAL conflict when deletes go through JS (better-sqlite3)
+  // and inserts go through native (rusqlite). The JS-only persistNativeFileCfg
+  // path below handles both on a single connection safely.
 
   const extToLang = buildExtToLangMap();
   let parsers: unknown = null;

package/src/graph/algorithms/bfs.ts

@@ -1,3 +1,4 @@
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 
 export interface BfsOpts {
@@ -8,6 +9,8 @@ export interface BfsOpts {
 /**
  * Breadth-first traversal on a CodeGraph.
  *
+ * Tries the native Rust implementation first, falls back to JS.
+ *
  * @returns nodeId → depth from nearest start node
  */
 export function bfs(
@@ -19,6 +22,37 @@ export function bfs(
   const direction = opts.direction ?? 'forward';
   const starts = Array.isArray(startIds) ? startIds : [startIds];
 
+  const native = loadNative();
+  if (native?.bfsTraversal) {
+    const edges = graph.toEdgeArray();
+    const nativeMaxDepth = maxDepth === Infinity ? null : maxDepth;
+    // Undirected graphs deduplicate edges to one canonical direction in toEdgeArray(),
+    // so the Rust side must traverse both directions to preserve symmetry.
+    const nativeDirection = !graph.directed ? 'both' : direction;
+    const result = native.bfsTraversal(edges, starts, nativeMaxDepth, nativeDirection);
+    const depths = new Map<string, number>();
+    for (const entry of result) {
+      depths.set(entry.node, entry.depth);
+    }
+    // The Rust side only knows nodes referenced by edges; restore any isolated start nodes.
+    for (const startId of starts) {
+      if (graph.hasNode(startId) && !depths.has(startId)) {
+        depths.set(startId, 0);
+      }
+    }
+    return depths;
+  }
+
+  return bfsJS(graph, starts, maxDepth, direction);
+}
+
+/** Pure JS fallback for BFS (used when native addon is unavailable). */
+function bfsJS(
+  graph: CodeGraph,
+  starts: string[],
+  maxDepth: number,
+  direction: string,
+): Map<string, number> {
   const depths = new Map<string, number>();
   const queue: string[] = [];
 

package/src/graph/algorithms/centrality.ts

@@ -1,3 +1,4 @@
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 
 export interface FanInOut {
@@ -7,8 +8,37 @@ export interface FanInOut {
 
 /**
  * Fan-in / fan-out centrality for all nodes in a CodeGraph.
+ *
+ * Tries the native Rust implementation first, falls back to JS.
  */
 export function fanInOut(graph: CodeGraph): Map<string, FanInOut> {
+  const native = loadNative();
+  if (native?.fanInOut) {
+    let edges = graph.toEdgeArray();
+    if (!graph.directed) {
+      // Undirected: toEdgeArray() deduplicates to one canonical direction;
+      // mirror each edge so the Rust side counts symmetric in/out degrees.
+      edges = [...edges, ...edges.map((e) => ({ source: e.target, target: e.source }))];
+    }
+    const nativeResult = native.fanInOut(edges);
+    const result = new Map<string, FanInOut>();
+    for (const entry of nativeResult) {
+      result.set(entry.node, { fanIn: entry.fanIn, fanOut: entry.fanOut });
+    }
+    // Ensure isolated nodes (no edges) are included
+    for (const id of graph.nodeIds()) {
+      if (!result.has(id)) {
+        result.set(id, { fanIn: 0, fanOut: 0 });
+      }
+    }
+    return result;
+  }
+
+  return fanInOutJS(graph);
+}
+
+/** Pure JS fallback for fan-in/out. */
+function fanInOutJS(graph: CodeGraph): Map<string, FanInOut> {
   const result = new Map<string, FanInOut>();
   for (const id of graph.nodeIds()) {
     result.set(id, {

package/src/graph/algorithms/louvain.ts

@@ -1,11 +1,13 @@
 /**
- * Community detection via vendored Leiden algorithm.
+ * Community detection via native Rust Louvain or vendored Leiden algorithm.
  * Maintains backward-compatible API: { assignments: Map<string, number>, modularity: number }
  *
- * Note: Always runs in undirected mode (`directed: false`) regardless of
- * the input graph's directedness. For direction-aware community detection,
- * use `detectClusters` from `./leiden/index.js` directly.
+ * Native path: classic Louvain (Rust, undirected modularity optimization).
+ * JS fallback: Leiden algorithm via `detectClusters` (always undirected, `directed: false`).
  */
+
+import { warn } from '../../infrastructure/logger.js';
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 import type { DetectClustersResult } from './leiden/index.js';
 import { detectClusters } from './leiden/index.js';
@@ -28,6 +30,31 @@ export function louvainCommunities(graph: CodeGraph, opts: LouvainOptions = {}):
   }
 
   const resolution: number = opts.resolution ?? 1.0;
+
+  const native = loadNative();
+  if (native?.louvainCommunities) {
+    // maxLevels, maxLocalPasses, and refinementTheta are Leiden-specific tuning knobs
+    // not supported by the Rust Louvain implementation. Warn callers who set them.
+    if (opts.maxLevels != null || opts.maxLocalPasses != null || opts.refinementTheta != null) {
+      warn(
+        'louvainCommunities: maxLevels/maxLocalPasses/refinementTheta are ignored by the native Rust path',
+      );
+    }
+    const edges = graph.toEdgeArray();
+    const nodeIds = graph.nodeIds();
+    const result = native.louvainCommunities(edges, nodeIds, resolution, 42);
+    const assignments = new Map<string, number>();
+    for (const entry of result.assignments) {
+      assignments.set(entry.node, entry.community);
+    }
+    return { assignments, modularity: result.modularity };
+  }
+
+  return louvainJS(graph, opts, resolution);
+}
+
+/** JS fallback using the vendored Leiden algorithm. */
+function louvainJS(graph: CodeGraph, opts: LouvainOptions, resolution: number): LouvainResult {
   const result: DetectClustersResult = detectClusters(graph, {
     resolution,
     randomSeed: 42,

package/src/graph/algorithms/shortest-path.ts

@@ -1,8 +1,11 @@
+import { loadNative } from '../../infrastructure/native.js';
 import type { CodeGraph } from '../model.js';
 
 /**
  * BFS-based shortest path on a CodeGraph.
  *
+ * Tries the native Rust implementation first, falls back to JS.
+ *
  * @returns Path from fromId to toId (inclusive), or null if unreachable
  */
 export function shortestPath(graph: CodeGraph, fromId: string, toId: string): string[] | null {
@@ -12,6 +15,23 @@ export function shortestPath(graph: CodeGraph, fromId: string, toId: string): st
   if (!graph.hasNode(from) || !graph.hasNode(to)) return null;
   if (from === to) return [from];
 
+  const native = loadNative();
+  if (native?.shortestPath) {
+    let edges = graph.toEdgeArray();
+    if (!graph.directed) {
+      // Undirected: toEdgeArray() deduplicates to one canonical direction;
+      // mirror each edge so the Rust BFS can traverse in both directions.
+      edges = [...edges, ...edges.map((e) => ({ source: e.target, target: e.source }))];
+    }
+    const result = native.shortestPath(edges, from, to);
+    return result.length > 0 ? result : null;
+  }
+
+  return shortestPathJS(graph, from, to);
+}
+
+/** Pure JS fallback for shortest path. */
+function shortestPathJS(graph: CodeGraph, from: string, to: string): string[] | null {
   const parent = new Map<string, string | null>();
   parent.set(from, null);
   const queue = [from];
@@ -23,7 +43,6 @@ export function shortestPath(graph: CodeGraph, fromId: string, toId: string): st
       if (parent.has(neighbor)) continue;
       parent.set(neighbor, current);
       if (neighbor === to) {
-        // Reconstruct path
         const path: string[] = [];
         let node: string | null = to;
         while (node !== null) {