@optave/codegraph 3.8.0 → 3.9.0

package/src/extractors/zig.ts

@@ -100,78 +100,75 @@ function handleZigVariable(node: TreeSitterNode, ctx: ExtractorOutput): void {
   if (!nameNode) return;
   const name = nameNode.text;
 
-  // Check if this is a struct/enum/union definition
+  if (tryHandleZigContainerDecl(node, name, ctx)) return;
+  if (tryHandleZigImportDecl(node, name, ctx)) 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),
+  });
+}
+
+/** Try to handle a variable_declaration as a struct/enum/union. Returns true if handled. */
+function tryHandleZigContainerDecl(
+  node: TreeSitterNode,
+  name: string,
+  ctx: ExtractorOutput,
+): boolean {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
+    const containerKind = zigContainerKind(child.type);
+    if (!containerKind) 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;
-    }
+    const members = child.type === 'struct_declaration' ? extractZigContainerFields(child) : [];
+    ctx.definitions.push({
+      name,
+      kind: containerKind,
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: members.length > 0 ? members : undefined,
+      visibility: isZigPub(node) ? 'public' : undefined,
+    });
+    if (child.type === 'struct_declaration') extractZigContainerMethods(child, name, ctx);
+    return true;
   }
+  return false;
+}
 
-  // Check for @import
+/** Map a Zig container node type to a definition kind, or undefined if not a container. */
+function zigContainerKind(nodeType: string): 'struct' | 'enum' | undefined {
+  if (nodeType === 'struct_declaration' || nodeType === 'union_declaration') return 'struct';
+  if (nodeType === 'enum_declaration') return 'enum';
+  return undefined;
+}
+
+/** Try to handle a variable_declaration as an @import. Returns true if handled. */
+function tryHandleZigImportDecl(node: TreeSitterNode, name: string, ctx: ExtractorOutput): boolean {
   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;
-          }
-        }
-      }
+    if (!child || child.type !== 'builtin_function') continue;
+    const source = extractZigImportSource(child);
+    if (source) {
+      ctx.imports.push({ source, names: [name], line: node.startPosition.row + 1 });
+      return true;
     }
   }
+  return false;
+}
 
-  // Regular constant/variable
-  const isConst = hasChildText(node, 'const');
-  ctx.definitions.push({
-    name,
-    kind: isConst ? 'constant' : 'variable',
-    line: node.startPosition.row + 1,
-    endLine: nodeEndLine(node),
-  });
+/** Extract the import source path from a builtin_function node if it is @import. */
+function extractZigImportSource(builtinNode: TreeSitterNode): string | null {
+  const builtinId = findChild(builtinNode, 'builtin_identifier');
+  if (builtinId?.text !== '@import') return null;
+  const args = findChild(builtinNode, 'arguments');
+  if (!args) return null;
+  const strArg = findChild(args, 'string_literal') || findChild(args, 'string');
+  return strArg ? strArg.text.replace(/^"|"$/g, '') : null;
 }
 
 function extractZigContainerFields(container: TreeSitterNode): SubDeclaration[] {

package/src/features/ast.ts

@@ -58,38 +58,11 @@ function findParentDef(defs: Definition[], line: number): Definition | null {
   return best;
 }
 
-// ─── Build ────────────────────────────────────────────────────────────
+// ─── Build helpers ───────────────────────────────────────────────────
 
-export async function buildAstNodes(
-  db: BetterSqlite3Database,
-  fileSymbols: Map<string, FileSymbols>,
-  _rootDir: string,
-  engineOpts?: {
-    nativeDb?: {
-      bulkInsertAstNodes(
-        batches: Array<{
-          file: string;
-          nodes: Array<{
-            line: number;
-            kind: string;
-            name: string;
-            text?: string | null;
-            receiver?: string | null;
-          }>;
-        }>,
-      ): number;
-    };
-    suspendJsDb?: () => void;
-    resumeJsDb?: () => void;
-  },
-): Promise<void> {
-  // ── Native bulk-insert fast path ──────────────────────────────────────
-  // Uses NativeDatabase persistent connection (Phase 6.15+).
-  // Standalone napi functions were removed in 6.17.
-  const nativeDb = engineOpts?.nativeDb;
-  if (nativeDb?.bulkInsertAstNodes) {
-    let needsJsFallback = false;
-    const batches: Array<{
+interface NativeDbHandle {
+  bulkInsertAstNodes(
+    batches: Array<{
       file: string;
       nodes: Array<{
         line: number;
@@ -98,47 +71,127 @@ export async function buildAstNodes(
         text?: string | null;
         receiver?: string | null;
       }>;
-    }> = [];
-
-    for (const [relPath, symbols] of fileSymbols) {
-      if (Array.isArray(symbols.astNodes)) {
-        batches.push({
-          file: relPath,
-          nodes: symbols.astNodes.map((n) => ({
-            line: n.line,
-            kind: n.kind,
-            name: n.name,
-            text: n.text,
-            receiver: n.receiver ?? '',
-          })),
-        });
-      } else if (symbols.calls || symbols._tree) {
-        needsJsFallback = true;
-        break;
-      }
-    }
+    }>,
+  ): number;
+}
 
-    if (!needsJsFallback) {
-      const expectedNodes = batches.reduce((s, b) => s + b.nodes.length, 0);
-      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;
-      }
-      debug(
-        `AST extraction (native bulk): expected ${expectedNodes}, got ${inserted} — falling back to JS`,
-      );
-      // fall through to JS path
+interface EngineOpts {
+  nativeDb?: NativeDbHandle;
+  suspendJsDb?: () => void;
+  resumeJsDb?: () => void;
+}
+
+/**
+ * Attempt native bulk-insert of AST nodes.
+ * Returns `true` if all nodes were inserted natively, `false` if JS fallback is needed.
+ */
+function tryNativeBulkInsert(
+  fileSymbols: Map<string, FileSymbols>,
+  engineOpts: EngineOpts | undefined,
+): boolean {
+  const nativeDb = engineOpts?.nativeDb;
+  if (!nativeDb?.bulkInsertAstNodes) return false;
+
+  const batches: Array<{
+    file: string;
+    nodes: Array<{
+      line: number;
+      kind: string;
+      name: string;
+      text?: string | null;
+      receiver?: string | null;
+    }>;
+  }> = [];
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (Array.isArray(symbols.astNodes)) {
+      batches.push({
+        file: relPath,
+        nodes: symbols.astNodes.map((n) => ({
+          line: n.line,
+          kind: n.kind,
+          name: n.name,
+          text: n.text,
+          receiver: n.receiver ?? '',
+        })),
+      });
+    } else if (symbols.calls || symbols._tree) {
+      return false; // needs JS fallback
     }
   }
 
-  // ── JS fallback path ──────────────────────────────────────────────────
+  const expectedNodes = batches.reduce((s, b) => s + b.nodes.length, 0);
+  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 true;
+  }
+  debug(
+    `AST extraction (native bulk): expected ${expectedNodes}, got ${inserted} — falling back to JS`,
+  );
+  return false;
+}
+
+/** Collect AST rows for a single file, resolving parent node IDs. */
+function collectFileAstRows(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: FileSymbols,
+): AstRow[] {
+  const defs = symbols.definitions || [];
+  const nodeIdMap = new Map<string, number>();
+  for (const row of bulkNodeIdsByFile(db, relPath)) {
+    nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+  }
+
+  if (Array.isArray(symbols.astNodes)) {
+    return symbols.astNodes.map((n) => {
+      const parentDef = findParentDef(defs, n.line);
+      const parentNodeId = parentDef
+        ? nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null
+        : null;
+      return {
+        file: relPath,
+        line: n.line,
+        kind: n.kind,
+        name: n.name,
+        text: n.text || null,
+        receiver: n.receiver || null,
+        parentNodeId,
+      };
+    });
+  }
+
+  // WASM fallback — walk tree if available
+  const ext = path.extname(relPath).toLowerCase();
+  if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
+    const rows: AstRow[] = [];
+    walkAst(symbols._tree.rootNode, defs, relPath, rows, nodeIdMap);
+    return rows;
+  }
+
+  return [];
+}
+
+// ─── Build ────────────────────────────────────────────────────────────
+
+export async function buildAstNodes(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  _rootDir: string,
+  engineOpts?: EngineOpts,
+): Promise<void> {
+  // Native bulk-insert fast path (Phase 6.15+)
+  if (tryNativeBulkInsert(fileSymbols, engineOpts)) return;
+
+  // JS fallback path
   let insertStmt: ReturnType<BetterSqlite3Database['prepare']>;
   try {
     insertStmt = db.prepare(
@@ -156,43 +209,8 @@ export async function buildAstNodes(
   });
 
   const allRows: AstRow[] = [];
-
   for (const [relPath, symbols] of fileSymbols) {
-    const defs = symbols.definitions || [];
-
-    const nodeIdMap = new Map<string, number>();
-    for (const row of bulkNodeIdsByFile(db, relPath)) {
-      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-    }
-
-    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) {
-        const parentDef = findParentDef(defs, n.line);
-        let parentNodeId: number | null = null;
-        if (parentDef) {
-          parentNodeId =
-            nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
-        }
-        allRows.push({
-          file: relPath,
-          line: n.line,
-          kind: n.kind,
-          name: n.name,
-          text: n.text || null,
-          receiver: n.receiver || null,
-          parentNodeId,
-        });
-      }
-    } else {
-      // WASM fallback — walk tree if available
-      const ext = path.extname(relPath).toLowerCase();
-      if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
-        const astRows: AstRow[] = [];
-        walkAst(symbols._tree.rootNode, defs, relPath, astRows, nodeIdMap);
-        allRows.push(...astRows);
-      }
-    }
+    allRows.push(...collectFileAstRows(db, relPath, symbols));
   }
 
   if (allRows.length > 0) {
@@ -350,23 +368,25 @@ export function astQuery(
   if (outputResult(data, 'results', opts)) return;
 
   if (data.results.length === 0) {
-    console.log(`No AST nodes found${pattern ? ` matching "${pattern}"` : ''}.`);
+    process.stdout.write(`No AST nodes found${pattern ? ` matching "${pattern}"` : ''}.\n`);
     return;
   }
 
   const kindLabel = opts.kind ? ` (kind: ${opts.kind})` : '';
-  console.log(`\n${data.count} AST nodes${pattern ? ` matching "${pattern}"` : ''}${kindLabel}:\n`);
+  process.stdout.write(
+    `\n${data.count} AST nodes${pattern ? ` matching "${pattern}"` : ''}${kindLabel}:\n\n`,
+  );
 
   for (const r of data.results) {
     const icon = KIND_ICONS[r.kind] || '?';
     const parentInfo = r.parent ? `  (in ${r.parent.name})` : '';
-    console.log(`  ${icon} ${r.name}  -- ${r.file}:${r.line}${parentInfo}`);
+    process.stdout.write(`  ${icon} ${r.name}  -- ${r.file}:${r.line}${parentInfo}\n`);
   }
 
   if (data._pagination?.hasMore) {
-    console.log(
-      `\n  ... ${data._pagination.total - data._pagination.offset - data._pagination.returned} more (use --offset ${data._pagination.offset + data._pagination.limit})`,
+    process.stdout.write(
+      `\n  ... ${data._pagination.total - data._pagination.offset - data._pagination.returned} more (use --offset ${data._pagination.offset + data._pagination.limit})\n`,
     );
   }
-  console.log();
+  process.stdout.write('\n');
 }

package/src/features/audit.ts

@@ -4,7 +4,9 @@ import { normalizeFileFilter } from '../db/query-builder.js';
 import { bfsTransitiveCallers } from '../domain/analysis/impact.js';
 import { explainData } from '../domain/queries.js';
 import { loadConfig } from '../infrastructure/config.js';
+import { debug } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import { toErrorMessage } from '../shared/errors.js';
 import type { BetterSqlite3Database, CodegraphConfig } from '../types.js';
 import { RULE_DEFS } from './manifesto.js';
 
@@ -41,8 +43,8 @@ function resolveThresholds(
       };
     }
     return resolved;
-  } catch {
-    // Fall back to defaults if config loading fails
+  } catch (e) {
+    debug(`resolveThresholds: config loading failed, using defaults: ${toErrorMessage(e)}`);
     const resolved: Record<string, ThresholdEntry> = {};
     for (const def of FUNCTION_RULES) {
       resolved[def.name] = {
@@ -110,8 +112,8 @@ function readPhase44(db: BetterSqlite3Database, nodeId: number): Phase44Fields {
         sideEffects: row.side_effects ?? null,
       };
     }
-  } catch {
-    /* columns don't exist yet */
+  } catch (e) {
+    debug(`readPhase44: columns may not exist yet: ${toErrorMessage(e)}`);
   }
   return { riskScore: null, complexityNotes: null, sideEffects: null };
 }
@@ -413,8 +415,8 @@ function buildHealth(
       commentLines: row.comment_lines || 0,
       thresholdBreaches: checkBreaches(row as unknown as Record<string, unknown>, thresholds),
     };
-  } catch {
-    /* table may not exist */
+  } catch (e) {
+    debug(`readHealth: function_complexity table may not exist: ${toErrorMessage(e)}`);
     return defaultHealth();
   }
 }