@optave/codegraph 3.9.0 → 3.9.1

package/src/features/complexity.ts

@@ -535,75 +535,97 @@ function upsertAstComplexity(
   return 1;
 }
 
-export async function buildComplexityMetrics(
+/** Collect native bulk-insert rows from precomputed complexity data.
+ *  Returns the rows array, or null if any definition is missing complexity
+ *  (signalling that JS fallback is needed). */
+function collectNativeBulkRows(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+): Array<Record<string, unknown>> | null {
+  const rows: Array<Record<string, unknown>> = [];
+
+  for (const [relPath, symbols] of fileSymbols) {
+    for (const def of symbols.definitions) {
+      if (def.kind !== 'function' && def.kind !== 'method') continue;
+      if (!def.line) continue;
+      // Interface/type property signatures and single-line stubs are extracted
+      // as methods but the native engine correctly never assigns complexity.
+      // Mirror the leniency in initWasmParsersIfNeeded to avoid bailing out
+      // of the native bulk-insert path for every TypeScript codebase (#846).
+      if (!def.complexity) {
+        if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) continue;
+        return null; // genuine function body missing complexity — needs JS fallback
+      }
+      const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+      if (!nodeId) continue;
+      const ch = def.complexity.halstead;
+      const cl = def.complexity.loc;
+      rows.push({
+        nodeId,
+        cognitive: def.complexity.cognitive ?? 0,
+        cyclomatic: def.complexity.cyclomatic ?? 0,
+        maxNesting: def.complexity.maxNesting ?? 0,
+        loc: cl ? cl.loc : 0,
+        sloc: cl ? cl.sloc : 0,
+        commentLines: cl ? cl.commentLines : 0,
+        halsteadN1: ch ? ch.n1 : 0,
+        halsteadN2: ch ? ch.n2 : 0,
+        halsteadBigN1: ch ? ch.bigN1 : 0,
+        halsteadBigN2: ch ? ch.bigN2 : 0,
+        halsteadVocabulary: ch ? ch.vocabulary : 0,
+        halsteadLength: ch ? ch.length : 0,
+        halsteadVolume: ch ? ch.volume : 0,
+        halsteadDifficulty: ch ? ch.difficulty : 0,
+        halsteadEffort: ch ? ch.effort : 0,
+        halsteadBugs: ch ? ch.bugs : 0,
+        maintainabilityIndex: def.complexity.maintainabilityIndex ?? 0,
+      });
+    }
+  }
+
+  return rows;
+}
+
+/** Try the native bulk-insert fast path. Returns true if all rows were
+ *  inserted successfully (caller can return early). */
+function tryNativeBulkInsert(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
-  rootDir: string,
   engineOpts?: {
     nativeDb?: { bulkInsertComplexity?(rows: Array<Record<string, unknown>>): number };
     suspendJsDb?: () => void;
     resumeJsDb?: () => void;
   },
-): Promise<void> {
-  // ── Native bulk-insert fast path ──────────────────────────────────────
+): boolean {
   const nativeDb = engineOpts?.nativeDb;
-  if (nativeDb?.bulkInsertComplexity) {
-    const rows: Array<Record<string, unknown>> = [];
-    let needsJsFallback = false;
-
-    for (const [relPath, symbols] of fileSymbols) {
-      for (const def of symbols.definitions) {
-        if (def.kind !== 'function' && def.kind !== 'method') continue;
-        if (!def.line) continue;
-        if (!def.complexity) {
-          needsJsFallback = true;
-          break;
-        }
-        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-        if (!nodeId) continue;
-        const ch = def.complexity.halstead;
-        const cl = def.complexity.loc;
-        rows.push({
-          nodeId,
-          cognitive: def.complexity.cognitive ?? 0,
-          cyclomatic: def.complexity.cyclomatic ?? 0,
-          maxNesting: def.complexity.maxNesting ?? 0,
-          loc: cl ? cl.loc : 0,
-          sloc: cl ? cl.sloc : 0,
-          commentLines: cl ? cl.commentLines : 0,
-          halsteadN1: ch ? ch.n1 : 0,
-          halsteadN2: ch ? ch.n2 : 0,
-          halsteadBigN1: ch ? ch.bigN1 : 0,
-          halsteadBigN2: ch ? ch.bigN2 : 0,
-          halsteadVocabulary: ch ? ch.vocabulary : 0,
-          halsteadLength: ch ? ch.length : 0,
-          halsteadVolume: ch ? ch.volume : 0,
-          halsteadDifficulty: ch ? ch.difficulty : 0,
-          halsteadEffort: ch ? ch.effort : 0,
-          halsteadBugs: ch ? ch.bugs : 0,
-          maintainabilityIndex: def.complexity.maintainabilityIndex ?? 0,
-        });
-      }
-      if (needsJsFallback) break;
-    }
+  if (!nativeDb?.bulkInsertComplexity) return false;
+
+  const rows = collectNativeBulkRows(db, fileSymbols);
+  if (rows === null) return false; // missing complexity — needs JS fallback
+  if (rows.length === 0) return true; // nothing to insert — native path done
+
+  let inserted: number;
+  try {
+    engineOpts?.suspendJsDb?.();
+    inserted = nativeDb.bulkInsertComplexity(rows);
+  } finally {
+    engineOpts?.resumeJsDb?.();
+  }
 
-    if (!needsJsFallback && rows.length > 0) {
-      let inserted: number;
-      try {
-        engineOpts?.suspendJsDb?.();
-        inserted = nativeDb.bulkInsertComplexity(rows);
-      } finally {
-        engineOpts?.resumeJsDb?.();
-      }
-      if (inserted === rows.length) {
-        info(`Complexity (native bulk): ${inserted} functions analyzed`);
-        return;
-      }
-      debug(`Native bulkInsertComplexity partial: ${inserted}/${rows.length} — falling back to JS`);
-    }
+  if (inserted === rows.length) {
+    info(`Complexity (native bulk): ${inserted} functions analyzed`);
+    return true;
   }
+  debug(`Native bulkInsertComplexity partial: ${inserted}/${rows.length} — falling back to JS`);
+  return false;
+}
 
-  // ── JS fallback path ─────────────────────────────────────────────────
+/** JS/WASM fallback: parse files and compute metrics via AST traversal. */
+async function computeJsFallbackMetrics(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+): Promise<void> {
   const { parsers, extToLang } = await initWasmParsersIfNeeded(fileSymbols);
   const { getParser } = await import('../domain/parser.js');
 
@@ -649,6 +671,20 @@ export async function buildComplexityMetrics(
   }
 }
 
+export async function buildComplexityMetrics(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+  engineOpts?: {
+    nativeDb?: { bulkInsertComplexity?(rows: Array<Record<string, unknown>>): number };
+    suspendJsDb?: () => void;
+    resumeJsDb?: () => void;
+  },
+): Promise<void> {
+  if (tryNativeBulkInsert(db, fileSymbols, engineOpts)) return;
+  await computeJsFallbackMetrics(db, fileSymbols, rootDir);
+}
+
 // ─── Query-Time Functions (re-exported from complexity-query.ts) ──────────
 // Split to separate query-time concerns (DB reads, filtering, pagination)
 // from compute-time concerns (AST traversal, metric algorithms).

package/src/features/dataflow.ts

@@ -23,6 +23,7 @@ import { hasDataflowTable, openReadonlyOrFail, openReadonlyWithNative } from '..
 import { ALL_SYMBOL_KINDS, normalizeSymbol } from '../domain/queries.js';
 import { debug, info } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import type { NormalizedSymbol } from '../shared/normalize.js';
 import { paginateResult } from '../shared/paginate.js';
 import type { BetterSqlite3Database, NativeDatabase, NodeRow, TreeSitterNode } from '../types.js';
 import { findNodes } from './shared/find-nodes.js';
@@ -438,85 +439,126 @@ function prepareDataflowStmts(db: BetterSqlite3Database): DataflowStmts {
   };
 }
 
-function buildNodeDataflowResult(
-  node: NodeRow,
-  stmts: DataflowStmts,
-  db: BetterSqlite3Database,
-  hc: Map<string, string | null>,
+// ─── Shared dataflow result builder ──────────────────────────────────
+
+/** Pre-mapped raw dataflow edge arrays shared between SQL and native paths. */
+interface RawDataflowEdges {
+  flowsTo: {
+    target: string;
+    kind: string;
+    file: string;
+    line: number;
+    paramIndex: number;
+    expression: string;
+    confidence: number;
+  }[];
+  flowsFrom: {
+    source: string;
+    kind: string;
+    file: string;
+    line: number;
+    paramIndex: number;
+    expression: string;
+    confidence: number;
+  }[];
+  returnConsumers: {
+    consumer: string;
+    kind: string;
+    file: string;
+    line: number;
+    expression: string;
+  }[];
+  returnedBy: { producer: string; kind: string; file: string; line: number; expression: string }[];
+  mutatesTargets: { target: string; expression: string; line: number }[];
+  mutatedBy: { source: string; expression: string; line: number }[];
+}
+
+/**
+ * Build a unified dataflow result from pre-mapped edge data.
+ * Shared between the SQL and native code paths.
+ */
+function buildDataflowResult(
+  sym: NormalizedSymbol,
+  edges: RawDataflowEdges,
   noTests: boolean,
 ): Record<string, unknown> {
-  const sym = normalizeSymbol(node, db, hc);
-
-  const flowsTo = stmts.flowsToOut.all(node.id).map((r: any) => ({
-    target: r.target_name,
-    kind: r.target_kind,
-    file: r.target_file,
-    line: r.line,
-    paramIndex: r.param_index,
-    expression: r.expression,
-    confidence: r.confidence,
-  }));
-
-  const flowsFrom = stmts.flowsToIn.all(node.id).map((r: any) => ({
-    source: r.source_name,
-    kind: r.source_kind,
-    file: r.source_file,
-    line: r.line,
-    paramIndex: r.param_index,
-    expression: r.expression,
-    confidence: r.confidence,
-  }));
-
-  const returnConsumers = stmts.returnsOut.all(node.id).map((r: any) => ({
-    consumer: r.target_name,
-    kind: r.target_kind,
-    file: r.target_file,
-    line: r.line,
-    expression: r.expression,
-  }));
-
-  const returnedBy = stmts.returnsIn.all(node.id).map((r: any) => ({
-    producer: r.source_name,
-    kind: r.source_kind,
-    file: r.source_file,
-    line: r.line,
-    expression: r.expression,
-  }));
-
-  const mutatesTargets = stmts.mutatesOut.all(node.id).map((r: any) => ({
-    target: r.target_name,
-    expression: r.expression,
-    line: r.line,
-  }));
-
-  const mutatedBy = stmts.mutatesIn.all(node.id).map((r: any) => ({
-    source: r.source_name,
-    expression: r.expression,
-    line: r.line,
-  }));
-
   if (noTests) {
     const filter = (arr: any[]) => arr.filter((r: any) => !isTestFile(r.file));
     return {
       ...sym,
-      flowsTo: filter(flowsTo),
-      flowsFrom: filter(flowsFrom),
-      returns: returnConsumers.filter((r) => !isTestFile(r.file)),
-      returnedBy: returnedBy.filter((r) => !isTestFile(r.file)),
-      mutates: mutatesTargets,
-      mutatedBy,
+      flowsTo: filter(edges.flowsTo),
+      flowsFrom: filter(edges.flowsFrom),
+      returns: edges.returnConsumers.filter((r: any) => !isTestFile(r.file)),
+      returnedBy: edges.returnedBy.filter((r: any) => !isTestFile(r.file)),
+      mutates: edges.mutatesTargets,
+      mutatedBy: edges.mutatedBy,
     };
   }
 
   return {
     ...sym,
-    flowsTo,
-    flowsFrom,
-    returns: returnConsumers,
-    returnedBy,
-    mutates: mutatesTargets,
-    mutatedBy,
+    flowsTo: edges.flowsTo,
+    flowsFrom: edges.flowsFrom,
+    returns: edges.returnConsumers,
+    returnedBy: edges.returnedBy,
+    mutates: edges.mutatesTargets,
+    mutatedBy: edges.mutatedBy,
+  };
+}
+
+function buildNodeDataflowResult(
+  node: NodeRow,
+  stmts: DataflowStmts,
+  db: BetterSqlite3Database,
+  hc: Map<string, string | null>,
+  noTests: boolean,
+): Record<string, unknown> {
+  const sym = normalizeSymbol(node, db, hc);
+  const edges: RawDataflowEdges = {
+    flowsTo: stmts.flowsToOut.all(node.id).map((r: any) => ({
+      target: r.target_name,
+      kind: r.target_kind,
+      file: r.target_file,
+      line: r.line,
+      paramIndex: r.param_index,
+      expression: r.expression,
+      confidence: r.confidence,
+    })),
+    flowsFrom: stmts.flowsToIn.all(node.id).map((r: any) => ({
+      source: r.source_name,
+      kind: r.source_kind,
+      file: r.source_file,
+      line: r.line,
+      paramIndex: r.param_index,
+      expression: r.expression,
+      confidence: r.confidence,
+    })),
+    returnConsumers: stmts.returnsOut.all(node.id).map((r: any) => ({
+      consumer: r.target_name,
+      kind: r.target_kind,
+      file: r.target_file,
+      line: r.line,
+      expression: r.expression,
+    })),
+    returnedBy: stmts.returnsIn.all(node.id).map((r: any) => ({
+      producer: r.source_name,
+      kind: r.source_kind,
+      file: r.source_file,
+      line: r.line,
+      expression: r.expression,
+    })),
+    mutatesTargets: stmts.mutatesOut.all(node.id).map((r: any) => ({
+      target: r.target_name,
+      expression: r.expression,
+      line: r.line,
+    })),
+    mutatedBy: stmts.mutatesIn.all(node.id).map((r: any) => ({
+      source: r.source_name,
+      expression: r.expression,
+      line: r.line,
+    })),
   };
+  return buildDataflowResult(sym, edges, noTests);
 }
 
 function buildNativeDataflowResult(
@@ -528,72 +570,51 @@ function buildNativeDataflowResult(
 ): Record<string, unknown> {
   const sym = normalizeSymbol(node, db, hc);
   const d = nativeDb.getDataflowEdges!(node.id);
-
-  const flowsTo = d.flowsToOut.map((r: any) => ({
-    target: r.name,
-    kind: r.kind,
-    file: r.file,
-    line: r.line,
-    paramIndex: r.paramIndex,
-    expression: r.expression,
-    confidence: r.confidence,
-  }));
-  const flowsFrom = d.flowsToIn.map((r: any) => ({
-    source: r.name,
-    kind: r.kind,
-    file: r.file,
-    line: r.line,
-    paramIndex: r.paramIndex,
-    expression: r.expression,
-    confidence: r.confidence,
-  }));
-  const returnConsumers = d.returnsOut.map((r: any) => ({
-    consumer: r.name,
-    kind: r.kind,
-    file: r.file,
-    line: r.line,
-    expression: r.expression,
-  }));
-  const returnedBy = d.returnsIn.map((r: any) => ({
-    producer: r.name,
-    kind: r.kind,
-    file: r.file,
-    line: r.line,
-    expression: r.expression,
-  }));
-  const mutatesTargets = d.mutatesOut.map((r: any) => ({
-    target: r.name,
-    expression: r.expression,
-    line: r.line,
-  }));
-  const mutatedBy = d.mutatesIn.map((r: any) => ({
-    source: r.name,
-    expression: r.expression,
-    line: r.line,
-  }));
-
-  if (noTests) {
-    const filter = (arr: any[]) => arr.filter((r: any) => !isTestFile(r.file));
-    return {
-      ...sym,
-      flowsTo: filter(flowsTo),
-      flowsFrom: filter(flowsFrom),
-      returns: returnConsumers.filter((r: any) => !isTestFile(r.file)),
-      returnedBy: returnedBy.filter((r: any) => !isTestFile(r.file)),
-      mutates: mutatesTargets,
-      mutatedBy,
-    };
-  }
-
-  return {
-    ...sym,
-    flowsTo,
-    flowsFrom,
-    returns: returnConsumers,
-    returnedBy,
-    mutates: mutatesTargets,
-    mutatedBy,
+  const edges: RawDataflowEdges = {
+    flowsTo: d.flowsToOut.map((r: any) => ({
+      target: r.name,
+      kind: r.kind,
+      file: r.file,
+      line: r.line,
+      paramIndex: r.paramIndex,
+      expression: r.expression,
+      confidence: r.confidence,
+    })),
+    flowsFrom: d.flowsToIn.map((r: any) => ({
+      source: r.name,
+      kind: r.kind,
+      file: r.file,
+      line: r.line,
+      paramIndex: r.paramIndex,
+      expression: r.expression,
+      confidence: r.confidence,
+    })),
+    returnConsumers: d.returnsOut.map((r: any) => ({
+      consumer: r.name,
+      kind: r.kind,
+      file: r.file,
+      line: r.line,
+      expression: r.expression,
+    })),
+    returnedBy: d.returnsIn.map((r: any) => ({
+      producer: r.name,
+      kind: r.kind,
+      file: r.file,
+      line: r.line,
+      expression: r.expression,
+    })),
+    mutatesTargets: d.mutatesOut.map((r: any) => ({
+      target: r.name,
+      expression: r.expression,
+      line: r.line,
+    })),
+    mutatedBy: d.mutatesIn.map((r: any) => ({
+      source: r.name,
+      expression: r.expression,
+      line: r.line,
+    })),
   };
+  return buildDataflowResult(sym, edges, noTests);
 }
 
 export function dataflowData(