@optave/codegraph 3.1.1 → 3.1.3

package/src/builder.js

@@ -4,7 +4,17 @@ import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { loadConfig } from './config.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from './constants.js';
-import { closeDb, getBuildMeta, initSchema, MIGRATIONS, openDb, setBuildMeta } from './db.js';
+import {
+  bulkNodeIdsByFile,
+  closeDb,
+  getBuildMeta,
+  getNodeId,
+  initSchema,
+  MIGRATIONS,
+  openDb,
+  purgeFilesData,
+  setBuildMeta,
+} from './db.js';
 import { readJournal, writeJournalHeader } from './journal.js';
 import { debug, info, warn } from './logger.js';
 import { loadNative } from './native.js';
@@ -350,91 +360,11 @@ function getChangedFiles(db, allFiles, rootDir) {
  * @param {boolean} [options.purgeHashes=true] - Also delete file_hashes entries
  */
 export function purgeFilesFromGraph(db, files, options = {}) {
-  const { purgeHashes = true } = options;
-  if (!files || files.length === 0) return;
-
-  // Check if embeddings table exists
-  let hasEmbeddings = false;
-  try {
-    db.prepare('SELECT 1 FROM embeddings LIMIT 1').get();
-    hasEmbeddings = true;
-  } catch {
-    /* table doesn't exist */
-  }
-
-  const deleteEmbeddingsForFile = hasEmbeddings
-    ? db.prepare('DELETE FROM embeddings WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)')
-    : null;
-  const deleteNodesForFile = db.prepare('DELETE FROM nodes WHERE file = ?');
-  const deleteEdgesForFile = db.prepare(`
-    DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = @f)
-    OR target_id IN (SELECT id FROM nodes WHERE file = @f)
-  `);
-  const deleteMetricsForFile = db.prepare(
-    'DELETE FROM node_metrics WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
-  );
-  let deleteComplexityForFile;
-  try {
-    deleteComplexityForFile = db.prepare(
-      'DELETE FROM function_complexity WHERE node_id IN (SELECT id FROM nodes WHERE file = ?)',
-    );
-  } catch {
-    deleteComplexityForFile = null;
-  }
-  let deleteDataflowForFile;
-  try {
-    deleteDataflowForFile = db.prepare(
-      'DELETE FROM dataflow WHERE source_id IN (SELECT id FROM nodes WHERE file = ?) OR target_id IN (SELECT id FROM nodes WHERE file = ?)',
-    );
-  } catch {
-    deleteDataflowForFile = null;
-  }
-  let deleteHashForFile;
-  if (purgeHashes) {
-    try {
-      deleteHashForFile = db.prepare('DELETE FROM file_hashes WHERE file = ?');
-    } catch {
-      deleteHashForFile = null;
-    }
-  }
-  let deleteAstNodesForFile;
-  try {
-    deleteAstNodesForFile = db.prepare('DELETE FROM ast_nodes WHERE file = ?');
-  } catch {
-    deleteAstNodesForFile = null;
-  }
-  let deleteCfgForFile;
-  try {
-    deleteCfgForFile = db.prepare(
-      'DELETE FROM cfg_edges WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?)',
-    );
-  } catch {
-    deleteCfgForFile = null;
-  }
-  let deleteCfgBlocksForFile;
-  try {
-    deleteCfgBlocksForFile = db.prepare(
-      'DELETE FROM cfg_blocks WHERE function_node_id IN (SELECT id FROM nodes WHERE file = ?)',
-    );
-  } catch {
-    deleteCfgBlocksForFile = null;
-  }
-
-  for (const relPath of files) {
-    deleteEmbeddingsForFile?.run(relPath);
-    deleteEdgesForFile.run({ f: relPath });
-    deleteMetricsForFile.run(relPath);
-    deleteComplexityForFile?.run(relPath);
-    deleteDataflowForFile?.run(relPath, relPath);
-    deleteAstNodesForFile?.run(relPath);
-    deleteCfgForFile?.run(relPath);
-    deleteCfgBlocksForFile?.run(relPath);
-    deleteNodesForFile.run(relPath);
-    if (purgeHashes) deleteHashForFile?.run(relPath);
-  }
+  purgeFilesData(db, files, options);
 }
 
 export async function buildGraph(rootDir, opts = {}) {
+  const _t_buildStart = performance.now();
   rootDir = path.resolve(rootDir);
   const dbPath = path.join(rootDir, '.codegraph', 'graph.db');
   const db = openDb(dbPath);
@@ -677,9 +607,12 @@ export async function buildGraph(rootDir, opts = {}) {
     }
   }
 
-  const getNodeId = db.prepare(
-    'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
-  );
+  const getNodeIdStmt = {
+    get: (name, kind, file, line) => {
+      const id = getNodeId(db, name, kind, file, line);
+      return id != null ? { id } : undefined;
+    },
+  };
 
   // Batch INSERT helpers — multi-value INSERTs reduce SQLite round-trips
   const BATCH_CHUNK = 200;
@@ -736,6 +669,7 @@ export async function buildGraph(rootDir, opts = {}) {
 
   // ── Phase timing ────────────────────────────────────────────────────
   const _t = {};
+  _t.setupMs = performance.now() - _t_buildStart;
 
   // ── Unified parse via parseFilesAuto ───────────────────────────────
   const filePaths = filesToParse.map((item) => item.file);
@@ -752,7 +686,7 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   // Bulk-fetch all node IDs for a file in one query (replaces per-node getNodeId calls)
-  const bulkGetNodeIds = db.prepare('SELECT id, name, kind, line FROM nodes WHERE file = ?');
+  const bulkGetNodeIds = { all: (file) => bulkNodeIdsByFile(db, file) };
 
   const insertAll = db.transaction(() => {
     // Phase 1: Batch insert all file nodes + definitions + exports
@@ -1032,16 +966,22 @@ export async function buildGraph(rootDir, opts = {}) {
     for (const [relPath, symbols] of fileSymbols) {
       // Skip barrel-only files — loaded for resolution, edges already in DB
       if (barrelOnlyFiles.has(relPath)) continue;
-      const fileNodeRow = getNodeId.get(relPath, 'file', relPath, 0);
+      const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
       if (!fileNodeRow) continue;
       const fileNodeId = fileNodeRow.id;
 
       // Import edges
       for (const imp of symbols.imports) {
         const resolvedPath = getResolved(path.join(rootDir, relPath), imp.source);
-        const targetRow = getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
+        const targetRow = getNodeIdStmt.get(resolvedPath, 'file', resolvedPath, 0);
         if (targetRow) {
-          const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
+          const edgeKind = imp.reexport
+            ? 'reexports'
+            : imp.typeOnly
+              ? 'imports-type'
+              : imp.dynamicImport
+                ? 'dynamic-imports'
+                : 'imports';
           allEdgeRows.push([fileNodeId, targetRow.id, edgeKind, 1.0, 0]);
 
           if (!imp.reexport && isBarrelFile(resolvedPath)) {
@@ -1055,12 +995,16 @@ export async function buildGraph(rootDir, opts = {}) {
                 !resolvedSources.has(actualSource)
               ) {
                 resolvedSources.add(actualSource);
-                const actualRow = getNodeId.get(actualSource, 'file', actualSource, 0);
+                const actualRow = getNodeIdStmt.get(actualSource, 'file', actualSource, 0);
                 if (actualRow) {
                   allEdgeRows.push([
                     fileNodeId,
                     actualRow.id,
-                    edgeKind === 'imports-type' ? 'imports-type' : 'imports',
+                    edgeKind === 'imports-type'
+                      ? 'imports-type'
+                      : edgeKind === 'dynamic-imports'
+                        ? 'dynamic-imports'
+                        : 'imports',
                     0.9,
                     0,
                   ]);
@@ -1078,7 +1022,7 @@ export async function buildGraph(rootDir, opts = {}) {
       const nativeFiles = [];
       for (const [relPath, symbols] of fileSymbols) {
         if (barrelOnlyFiles.has(relPath)) continue;
-        const fileNodeRow = getNodeId.get(relPath, 'file', relPath, 0);
+        const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
         if (!fileNodeRow) continue;
 
         // Pre-resolve imported names (including barrel resolution)
@@ -1120,7 +1064,7 @@ export async function buildGraph(rootDir, opts = {}) {
       // JS fallback — call/receiver/extends/implements edges
       for (const [relPath, symbols] of fileSymbols) {
         if (barrelOnlyFiles.has(relPath)) continue;
-        const fileNodeRow = getNodeId.get(relPath, 'file', relPath, 0);
+        const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
         if (!fileNodeRow) continue;
 
         // Build import name -> target file mapping
@@ -1145,14 +1089,14 @@ export async function buildGraph(rootDir, opts = {}) {
               if (call.line <= end) {
                 const span = end - def.line;
                 if (span < callerSpan) {
-                  const row = getNodeId.get(def.name, def.kind, relPath, def.line);
+                  const row = getNodeIdStmt.get(def.name, def.kind, relPath, def.line);
                   if (row) {
                     caller = row;
                     callerSpan = span;
                   }
                 }
               } else if (!caller) {
-                const row = getNodeId.get(def.name, def.kind, relPath, def.line);
+                const row = getNodeIdStmt.get(def.name, def.kind, relPath, def.line);
                 if (row) caller = row;
               }
             }
@@ -1393,96 +1337,30 @@ export async function buildGraph(rootDir, opts = {}) {
     }
   }
 
-  // AST node extraction (calls, new, string, regex, throw, await)
-  _t.ast0 = performance.now();
-  if (opts.ast !== false) {
+  // ── Unified AST analysis engine ──────────────────────────────────────
+  // Replaces 4 sequential buildXxx calls with one coordinated pass.
+  {
+    const { runAnalyses } = await import('./ast-analysis/engine.js');
     try {
-      const { buildAstNodes } = await import('./ast.js');
-      await buildAstNodes(db, astComplexitySymbols, rootDir, engineOpts);
+      const analysisTiming = await runAnalyses(db, astComplexitySymbols, rootDir, opts, engineOpts);
+      _t.astMs = analysisTiming.astMs;
+      _t.complexityMs = analysisTiming.complexityMs;
+      _t.cfgMs = analysisTiming.cfgMs;
+      _t.dataflowMs = analysisTiming.dataflowMs;
     } catch (err) {
-      debug(`AST node extraction failed: ${err.message}`);
+      debug(`Unified analysis engine failed: ${err.message}`);
     }
   }
-  _t.astMs = performance.now() - _t.ast0;
 
-  // Compute per-function complexity metrics (cognitive, cyclomatic, nesting)
-  _t.complexity0 = performance.now();
-  if (opts.complexity !== false) {
-    try {
-      const { buildComplexityMetrics } = await import('./complexity.js');
-      await buildComplexityMetrics(db, astComplexitySymbols, rootDir, engineOpts);
-    } catch (err) {
-      debug(`Complexity analysis failed: ${err.message}`);
-    }
-  }
-  _t.complexityMs = performance.now() - _t.complexity0;
-
-  // Pre-parse files missing WASM trees (native builds) so CFG + dataflow
-  // share a single parse pass instead of each creating parsers independently.
-  // Skip entirely when native engine already provides CFG + dataflow data.
-  if (opts.cfg !== false || opts.dataflow !== false) {
-    const needsCfg = opts.cfg !== false;
-    const needsDataflow = opts.dataflow !== false;
-
-    let needsWasmTrees = false;
-    for (const [, symbols] of astComplexitySymbols) {
-      if (symbols._tree) continue; // already has a tree
-      // CFG: need tree if any function/method def lacks native CFG
-      if (needsCfg) {
-        const fnDefs = (symbols.definitions || []).filter(
-          (d) => (d.kind === 'function' || d.kind === 'method') && d.line,
-        );
-        if (
-          fnDefs.length > 0 &&
-          !fnDefs.every((d) => d.cfg === null || Array.isArray(d.cfg?.blocks))
-        ) {
-          needsWasmTrees = true;
-          break;
-        }
-      }
-      // Dataflow: need tree if file lacks native dataflow
-      if (needsDataflow && !symbols.dataflow) {
-        needsWasmTrees = true;
-        break;
-      }
-    }
+  _t.finalize0 = performance.now();
 
-    if (needsWasmTrees) {
+  // Release any remaining cached WASM trees — call .delete() to free WASM memory
+  for (const [, symbols] of allSymbols) {
+    if (symbols._tree && typeof symbols._tree.delete === 'function') {
       try {
-        const { ensureWasmTrees } = await import('./parser.js');
-        await ensureWasmTrees(astComplexitySymbols, rootDir);
-      } catch (err) {
-        debug(`WASM pre-parse failed: ${err.message}`);
-      }
-    }
-  }
-
-  // CFG analysis (skip with --no-cfg)
-  if (opts.cfg !== false) {
-    _t.cfg0 = performance.now();
-    try {
-      const { buildCFGData } = await import('./cfg.js');
-      await buildCFGData(db, astComplexitySymbols, rootDir, engineOpts);
-    } catch (err) {
-      debug(`CFG analysis failed: ${err.message}`);
-    }
-    _t.cfgMs = performance.now() - _t.cfg0;
-  }
-
-  // Dataflow analysis (skip with --no-dataflow)
-  if (opts.dataflow !== false) {
-    _t.dataflow0 = performance.now();
-    try {
-      const { buildDataflowEdges } = await import('./dataflow.js');
-      await buildDataflowEdges(db, astComplexitySymbols, rootDir, engineOpts);
-    } catch (err) {
-      debug(`Dataflow analysis failed: ${err.message}`);
+        symbols._tree.delete();
+      } catch {}
     }
-    _t.dataflowMs = performance.now() - _t.dataflow0;
-  }
-
-  // Release any remaining cached WASM trees for GC
-  for (const [, symbols] of allSymbols) {
     symbols._tree = null;
     symbols._langId = null;
   }
@@ -1587,8 +1465,11 @@ export async function buildGraph(rootDir, opts = {}) {
     }
   }
 
+  _t.finalizeMs = performance.now() - _t.finalize0;
+
   return {
     phases: {
+      setupMs: +_t.setupMs.toFixed(1),
       parseMs: +_t.parseMs.toFixed(1),
       insertMs: +_t.insertMs.toFixed(1),
       resolveMs: +_t.resolveMs.toFixed(1),
@@ -1599,6 +1480,7 @@ export async function buildGraph(rootDir, opts = {}) {
       complexityMs: +_t.complexityMs.toFixed(1),
       ...(_t.cfgMs != null && { cfgMs: +_t.cfgMs.toFixed(1) }),
       ...(_t.dataflowMs != null && { dataflowMs: +_t.dataflowMs.toFixed(1) }),
+      finalizeMs: +_t.finalizeMs.toFixed(1),
     },
   };
 }