@optave/codegraph 3.8.0 → 3.8.1

package/src/domain/graph/builder/stages/insert-nodes.ts

@@ -11,6 +11,8 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { bulkNodeIdsByFile } from '../../../../db/index.js';
+import { debug } from '../../../../infrastructure/logger.js';
+import { toErrorMessage } from '../../../../shared/errors.js';
 import type {
   BetterSqlite3Database,
   ExtractorOutput,
@@ -36,35 +38,31 @@ interface PrecomputedFileData {
   _reverseDepOnly?: boolean;
 }
 
-// ── Native fast-path ─────────────────────────────────────────────────
+// ── Native fast-path helpers ─────────────────────────────────────────
 
-function tryNativeInsert(ctx: PipelineContext): boolean {
-  // Use NativeDatabase persistent connection (Phase 6.15+).
-  // Standalone napi functions were removed in 6.17 — falls through to JS if nativeDb unavailable.
-  if (!ctx.nativeDb?.bulkInsertNodes) return false;
-
-  const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
-
-  // Marshal allSymbols → InsertNodesBatch[]
-  const batches: Array<{
-    file: string;
-    definitions: Array<{
+/** Shape of a marshaled batch for native bulk insert. */
+interface InsertNodesBatch {
+  file: string;
+  definitions: Array<{
+    name: string;
+    kind: string;
+    line: number;
+    endLine?: number;
+    visibility?: string;
+    children: Array<{
       name: string;
       kind: string;
       line: number;
       endLine?: number;
       visibility?: string;
-      children: Array<{
-        name: string;
-        kind: string;
-        line: number;
-        endLine?: number;
-        visibility?: string;
-      }>;
     }>;
-    exports: Array<{ name: string; kind: string; line: number }>;
-  }> = [];
+  }>;
+  exports: Array<{ name: string; kind: string; line: number }>;
+}
 
+/** Marshal allSymbols into the batch format expected by native bulkInsertNodes. */
+function marshalSymbolBatches(allSymbols: Map<string, ExtractorOutput>): InsertNodesBatch[] {
+  const batches: InsertNodesBatch[] = [];
   for (const [relPath, symbols] of allSymbols) {
     batches.push({
       file: relPath,
@@ -89,14 +87,18 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
       })),
     });
   }
+  return batches;
+}
 
-  // Build file hash entries
-  const precomputedData = new Map<string, PrecomputedFileData>();
-  for (const item of filesToParse) {
-    if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
-  }
-
+/** Build file hash entries from parsed symbols and precomputed/metadata sources. */
+function buildFileHashes(
+  allSymbols: Map<string, ExtractorOutput>,
+  precomputedData: Map<string, PrecomputedFileData>,
+  metadataUpdates: MetadataUpdate[],
+  rootDir: string,
+): Array<{ file: string; hash: string; mtime: number; size: number }> {
   const fileHashes: Array<{ file: string; hash: string; mtime: number; size: number }> = [];
+
   for (const [relPath] of allSymbols) {
     const precomputed = precomputedData.get(relPath);
     if (precomputed?._reverseDepOnly) {
@@ -119,7 +121,8 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
       let code: string | null;
       try {
         code = readFileSafe(absPath);
-      } catch {
+      } catch (e) {
+        debug(`buildFileHashes: readFileSafe failed for ${relPath}: ${toErrorMessage(e)}`);
         code = null;
       }
       if (code !== null) {
@@ -138,6 +141,24 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
     fileHashes.push({ file: item.relPath, hash: item.hash, mtime, size });
   }
 
+  return fileHashes;
+}
+
+// ── Native fast-path ─────────────────────────────────────────────────
+
+function tryNativeInsert(ctx: PipelineContext): boolean {
+  if (!ctx.nativeDb?.bulkInsertNodes) return false;
+
+  const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+
+  const batches = marshalSymbolBatches(allSymbols);
+
+  const precomputedData = new Map<string, PrecomputedFileData>();
+  for (const item of filesToParse) {
+    if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
+  }
+  const fileHashes = buildFileHashes(allSymbols, precomputedData, metadataUpdates, rootDir);
+
   // WAL guard: same suspendJsDb/resumeJsDb pattern used by feature modules
   // (ast, cfg, complexity, dataflow). Checkpoint JS side before native write,
   // then checkpoint native side after, so neither library reads WAL frames
@@ -151,8 +172,10 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
   } finally {
     try {
       ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore — nativeDb may already be closed */
+    } catch (e) {
+      debug(
+        `tryNativeInsert: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
+      );
     }
   }
   return result;
@@ -324,7 +347,8 @@ function updateFileHashes(
       let code: string | null;
       try {
         code = readFileSafe(absPath);
-      } catch {
+      } catch (e) {
+        debug(`updateFileHashes: readFileSafe failed for ${relPath}: ${toErrorMessage(e)}`);
         code = null;
       }
       if (code !== null) {
@@ -364,8 +388,8 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
         // Removed-file hash cleanup is handled inside the native call
         return;
       }
-    } catch {
-      // Native insert failed — fall through to JS implementation
+    } catch (e) {
+      debug(`insertNodes: native insert failed, falling back to JS: ${toErrorMessage(e)}`);
     }
   }
 
@@ -380,7 +404,8 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
     upsertHash = ctx.db.prepare(
       'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
     );
-  } catch {
+  } catch (e) {
+    debug(`insertNodes: file_hashes prepare failed (table may not exist): ${toErrorMessage(e)}`);
     upsertHash = null;
   }
 

package/src/domain/graph/builder/stages/resolve-imports.ts

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { debug } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
 import type { Import } from '../../../../types.js';
 import { parseFilesAuto } from '../../../parser.js';
 import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
@@ -12,20 +13,10 @@ interface ReexportEntry {
   wildcardReexport: boolean;
 }
 
-export async function resolveImports(ctx: PipelineContext): Promise<void> {
-  const { db, fileSymbols, rootDir, aliases, allFiles, isFullBuild, engineOpts } = ctx;
-  const t0 = performance.now();
-  const batchInputs: Array<{ fromFile: string; importSource: string }> = [];
-  for (const [relPath, symbols] of fileSymbols) {
-    const absFile = path.join(rootDir, relPath);
-    for (const imp of symbols.imports) {
-      batchInputs.push({ fromFile: absFile, importSource: imp.source });
-    }
-  }
-  ctx.batchResolved = resolveImportsBatch(batchInputs, rootDir, aliases, allFiles);
-  ctx.timing.resolveMs = performance.now() - t0;
-
+/** Collect reexport entries from fileSymbols into the reexportMap. */
+function buildReexportMap(ctx: PipelineContext): void {
   ctx.reexportMap = new Map<string, ReexportEntry[]>();
+  const { fileSymbols, rootDir } = ctx;
   for (const [relPath, symbols] of fileSymbols) {
     const reexports = symbols.imports.filter((imp) => imp.reexport);
     if (reexports.length > 0) {
@@ -39,110 +30,141 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
       );
     }
   }
+}
 
-  ctx.barrelOnlyFiles = new Set<string>();
-  if (!isFullBuild) {
-    // Collect the set of changed file paths to scope barrel re-parsing.
-    const changedRelPaths = new Set<string>(fileSymbols.keys());
-
-    // For small incremental builds (≤5 files), only re-parse barrel files
-    // that are related to the changed files — either re-exporting from them
-    // or imported by them. For larger changes, re-parse all barrels.
-    let barrelCandidates: Array<{ file: string }>;
-    if (changedRelPaths.size <= 5) {
-      // All known barrel files (has at least one reexport edge)
-      const allBarrelFiles = new Set(
-        (
-          db
-            .prepare(
-              `SELECT DISTINCT n1.file FROM edges e
-               JOIN nodes n1 ON e.source_id = n1.id
-               WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
-            )
-            .all() as Array<{ file: string }>
-        ).map((r) => r.file),
-      );
+/**
+ * Find barrel files related to changed files for scoped re-parsing.
+ * For small incremental builds (<=5 files), only barrels that re-export from
+ * or are imported by the changed files. For larger changes, all barrels.
+ */
+function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
+  const { db, fileSymbols, rootDir, aliases } = ctx;
+  const changedRelPaths = new Set<string>(fileSymbols.keys());
 
-      const barrels = new Set<string>();
-
-      // Find barrels imported by changed files using parsed import data
-      // (can't query DB edges — they were purged for the changed files).
-      for (const relPath of changedRelPaths) {
-        const symbols = fileSymbols.get(relPath);
-        if (!symbols) continue;
-        for (const imp of symbols.imports) {
-          const resolved = ctx.batchResolved?.get(`${path.join(rootDir, relPath)}|${imp.source}`);
-          const target =
-            resolved ??
-            resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
-          if (allBarrelFiles.has(target)) barrels.add(target);
-        }
-      }
+  const SMALL_CHANGE_THRESHOLD = 5;
+  if (changedRelPaths.size <= SMALL_CHANGE_THRESHOLD) {
+    const allBarrelFiles = new Set(
+      (
+        db
+          .prepare(
+            `SELECT DISTINCT n1.file FROM edges e
+             JOIN nodes n1 ON e.source_id = n1.id
+             WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
+          )
+          .all() as Array<{ file: string }>
+      ).map((r) => r.file),
+    );
 
-      // Also find barrels that re-export from the changed files
-      const reexportSourceStmt = db.prepare(
-        `SELECT DISTINCT n1.file FROM edges e
-         JOIN nodes n1 ON e.source_id = n1.id
-         JOIN nodes n2 ON e.target_id = n2.id
-         WHERE e.kind = 'reexports' AND n1.kind = 'file' AND n2.file = ?`,
-      );
-      for (const relPath of changedRelPaths) {
-        for (const row of reexportSourceStmt.all(relPath) as Array<{ file: string }>) {
-          barrels.add(row.file);
-        }
+    const barrels = new Set<string>();
+
+    // Find barrels imported by changed files using parsed import data
+    // (can't query DB edges -- they were purged for the changed files).
+    for (const relPath of changedRelPaths) {
+      const symbols = fileSymbols.get(relPath);
+      if (!symbols) continue;
+      for (const imp of symbols.imports) {
+        const resolved = ctx.batchResolved?.get(
+          `${normalizePath(path.join(rootDir, relPath))}|${imp.source}`,
+        );
+        const target =
+          resolved ?? resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
+        if (allBarrelFiles.has(target)) barrels.add(target);
       }
-      barrelCandidates = [...barrels].map((file) => ({ file }));
-    } else {
-      barrelCandidates = db
-        .prepare(
-          `SELECT DISTINCT n1.file FROM edges e
-           JOIN nodes n1 ON e.source_id = n1.id
-           WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
-        )
-        .all() as Array<{ file: string }>;
     }
 
-    // Batch-parse all barrel candidates at once instead of one-by-one
-    const barrelPaths: string[] = [];
-    for (const { file: relPath } of barrelCandidates) {
-      if (!fileSymbols.has(relPath)) {
-        barrelPaths.push(path.join(rootDir, relPath));
+    // Also find barrels that re-export from the changed files
+    const reexportSourceStmt = db.prepare(
+      `SELECT DISTINCT n1.file FROM edges e
+       JOIN nodes n1 ON e.source_id = n1.id
+       JOIN nodes n2 ON e.target_id = n2.id
+       WHERE e.kind = 'reexports' AND n1.kind = 'file' AND n2.file = ?`,
+    );
+    for (const relPath of changedRelPaths) {
+      for (const row of reexportSourceStmt.all(relPath) as Array<{ file: string }>) {
+        barrels.add(row.file);
       }
     }
+    return [...barrels].map((file) => ({ file }));
+  }
 
-    if (barrelPaths.length > 0) {
-      const deleteOutgoingEdges = db.prepare(
-        'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
-      );
+  return db
+    .prepare(
+      `SELECT DISTINCT n1.file FROM edges e
+       JOIN nodes n1 ON e.source_id = n1.id
+       WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
+    )
+    .all() as Array<{ file: string }>;
+}
 
-      try {
-        const barrelSymbols = await parseFilesAuto(barrelPaths, rootDir, engineOpts);
-        for (const [relPath, fileSym] of barrelSymbols) {
-          deleteOutgoingEdges.run(relPath);
-          fileSymbols.set(relPath, fileSym);
-          ctx.barrelOnlyFiles.add(relPath);
-          const reexports = fileSym.imports.filter((imp: Import) => imp.reexport);
-          if (reexports.length > 0) {
-            ctx.reexportMap.set(
-              relPath,
-              reexports.map((imp: Import) => ({
-                source: getResolved(ctx, path.join(rootDir, relPath), imp.source),
-                names: imp.names,
-                wildcardReexport: imp.wildcardReexport || false,
-              })),
-            );
-          }
-        }
-      } catch (e: unknown) {
-        debug(`Barrel re-parse failed (non-fatal): ${(e as Error).message}`);
+/** Re-parse barrel files and update fileSymbols/reexportMap with fresh data. */
+async function reparseBarrelFiles(
+  ctx: PipelineContext,
+  barrelCandidates: Array<{ file: string }>,
+): Promise<void> {
+  const { db, fileSymbols, rootDir, engineOpts } = ctx;
+
+  const barrelPaths: string[] = [];
+  for (const { file: relPath } of barrelCandidates) {
+    if (!fileSymbols.has(relPath)) {
+      barrelPaths.push(path.join(rootDir, relPath));
+    }
+  }
+
+  if (barrelPaths.length === 0) return;
+
+  const deleteOutgoingEdges = db.prepare(
+    'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+  );
+
+  try {
+    const barrelSymbols = await parseFilesAuto(barrelPaths, rootDir, engineOpts);
+    for (const [relPath, fileSym] of barrelSymbols) {
+      deleteOutgoingEdges.run(relPath);
+      fileSymbols.set(relPath, fileSym);
+      ctx.barrelOnlyFiles.add(relPath);
+      const reexports = fileSym.imports.filter((imp: Import) => imp.reexport);
+      if (reexports.length > 0) {
+        ctx.reexportMap.set(
+          relPath,
+          reexports.map((imp: Import) => ({
+            source: getResolved(ctx, path.join(rootDir, relPath), imp.source),
+            names: imp.names,
+            wildcardReexport: imp.wildcardReexport || false,
+          })),
+        );
       }
     }
+  } catch (e: unknown) {
+    debug(`Barrel re-parse failed (non-fatal): ${(e as Error).message}`);
+  }
+}
+
+export async function resolveImports(ctx: PipelineContext): Promise<void> {
+  const { fileSymbols, rootDir, aliases, allFiles, isFullBuild } = ctx;
+  const t0 = performance.now();
+
+  const batchInputs: Array<{ fromFile: string; importSource: string }> = [];
+  for (const [relPath, symbols] of fileSymbols) {
+    const absFile = path.join(rootDir, relPath);
+    for (const imp of symbols.imports) {
+      batchInputs.push({ fromFile: absFile, importSource: imp.source });
+    }
+  }
+  ctx.batchResolved = resolveImportsBatch(batchInputs, rootDir, aliases, allFiles);
+  ctx.timing.resolveMs = performance.now() - t0;
+
+  buildReexportMap(ctx);
+
+  ctx.barrelOnlyFiles = new Set<string>();
+  if (!isFullBuild) {
+    const barrelCandidates = findBarrelCandidates(ctx);
+    await reparseBarrelFiles(ctx, barrelCandidates);
   }
 }
 
 export function getResolved(ctx: PipelineContext, absFile: string, importSource: string): string {
   if (ctx.batchResolved) {
-    const key = `${absFile}|${importSource}`;
+    const key = `${normalizePath(absFile)}|${importSource}`;
     const hit = ctx.batchResolved.get(key);
     if (hit !== undefined) return hit;
   }

package/src/domain/graph/cycles.ts

@@ -1,9 +1,14 @@
-import { tarjan } from '../../graph/algorithms/tarjan.js';
-import { buildDependencyGraph } from '../../graph/builders/dependency.js';
-import { CodeGraph } from '../../graph/model.js';
+import { getCallableNodes, getCallEdges, getFileNodesAll, getImportEdges } from '../../db/index.js';
 import { loadNative } from '../../infrastructure/native.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
 import type { BetterSqlite3Database } from '../../types.js';
 
+/**
+ * Find cycles using Tarjan's SCC algorithm.
+ *
+ * Builds a label-based adjacency list directly from DB rows — no intermediate
+ * CodeGraph construction. This is O(V + E) with minimal memory overhead.
+ */
 export function findCycles(
   db: BetterSqlite3Database,
   opts: { fileLevel?: boolean; noTests?: boolean } = {},
@@ -11,40 +16,122 @@ export function findCycles(
   const fileLevel = opts.fileLevel !== false;
   const noTests = opts.noTests || false;
 
-  const graph = buildDependencyGraph(db, { fileLevel, noTests });
+  const edges: Array<{ source: string; target: string }> = [];
+  const seen = new Set<string>();
 
-  const idToLabel = new Map<string, string>();
-  for (const [id, attrs] of graph.nodes()) {
-    if (fileLevel) {
-      idToLabel.set(id, attrs.file as string);
-    } else {
-      idToLabel.set(id, `${attrs.label}|${attrs.file}`);
+  if (fileLevel) {
+    let nodes = getFileNodesAll(db);
+    if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+    const nodeIds = new Set<number>();
+    const idToFile = new Map<number, string>();
+    for (const n of nodes) {
+      nodeIds.add(n.id);
+      idToFile.set(n.id, n.file);
+    }
+    for (const e of getImportEdges(db)) {
+      if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
+      if (e.source_id === e.target_id) continue;
+      const src = idToFile.get(e.source_id)!;
+      const tgt = idToFile.get(e.target_id)!;
+      const key = `${src}\0${tgt}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ source: src, target: tgt });
+    }
+  } else {
+    let nodes = getCallableNodes(db);
+    if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+    const nodeIds = new Set<number>();
+    const idToLabel = new Map<number, string>();
+    for (const n of nodes) {
+      nodeIds.add(n.id);
+      idToLabel.set(n.id, `${n.name}|${n.file}`);
+    }
+    for (const e of getCallEdges(db)) {
+      if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
+      if (e.source_id === e.target_id) continue;
+      const src = idToLabel.get(e.source_id)!;
+      const tgt = idToLabel.get(e.target_id)!;
+      const key = `${src}\0${tgt}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ source: src, target: tgt });
     }
   }
 
-  const edges = graph.toEdgeArray().map((e) => ({
-    source: idToLabel.get(e.source) ?? e.source,
-    target: idToLabel.get(e.target) ?? e.target,
-  }));
-
   const native = loadNative();
   if (native) {
     return native.detectCycles(edges) as string[][];
   }
 
-  const labelGraph = new CodeGraph();
-  for (const { source, target } of edges) {
-    labelGraph.addEdge(source, target);
-  }
-  return tarjan(labelGraph);
+  return tarjanFromEdges(edges);
 }
 
 export function findCyclesJS(edges: Array<{ source: string; target: string }>): string[][] {
-  const graph = new CodeGraph();
+  return tarjanFromEdges(edges);
+}
+
+/**
+ * Run Tarjan's SCC on a flat edge list. Returns SCCs with length > 1 (cycles).
+ * Uses a simple adjacency-list Map instead of a full CodeGraph.
+ */
+function tarjanFromEdges(edges: Array<{ source: string; target: string }>): string[][] {
+  const adj = new Map<string, string[]>();
+  const allNodes = new Set<string>();
   for (const { source, target } of edges) {
-    graph.addEdge(source, target);
+    allNodes.add(source);
+    allNodes.add(target);
+    let list = adj.get(source);
+    if (!list) {
+      list = [];
+      adj.set(source, list);
+    }
+    list.push(target);
   }
-  return tarjan(graph);
+
+  let index = 0;
+  const stack: string[] = [];
+  const onStack = new Set<string>();
+  const indices = new Map<string, number>();
+  const lowlinks = new Map<string, number>();
+  const sccs: string[][] = [];
+
+  function strongconnect(v: string): void {
+    indices.set(v, index);
+    lowlinks.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+
+    const successors = adj.get(v);
+    if (successors) {
+      for (const w of successors) {
+        if (!indices.has(w)) {
+          strongconnect(w);
+          lowlinks.set(v, Math.min(lowlinks.get(v)!, lowlinks.get(w)!));
+        } else if (onStack.has(w)) {
+          lowlinks.set(v, Math.min(lowlinks.get(v)!, indices.get(w)!));
+        }
+      }
+    }
+
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc: string[] = [];
+      let w: string | undefined;
+      do {
+        w = stack.pop()!;
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length > 1) sccs.push(scc);
+    }
+  }
+
+  for (const id of allNodes) {
+    if (!indices.has(id)) strongconnect(id);
+  }
+
+  return sccs;
 }
 
 export function formatCycles(cycles: string[][]): string {

package/src/domain/graph/resolve.ts

@@ -565,7 +565,7 @@ export function resolveImportsBatch(
       // Native resolver's .js → .ts remap fails on unnormalized paths —
       // apply JS-side fallback (same fix as resolveImportPath).
       const resolved = remapJsToTs(normalized, rootDir);
-      map.set(`${r.fromFile}|${r.importSource}`, resolved);
+      map.set(`${normalizePath(r.fromFile)}|${r.importSource}`, resolved);
     }
     return map;
   } catch (e) {