@optave/codegraph 2.6.0 → 3.0.1

package/src/builder.js

@@ -4,7 +4,7 @@ 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, openDb, setBuildMeta } from './db.js';
+import { closeDb, getBuildMeta, initSchema, MIGRATIONS, openDb, setBuildMeta } from './db.js';
 import { readJournal, writeJournalHeader } from './journal.js';
 import { debug, info, warn } from './logger.js';
 import { getActiveEngine, parseFilesAuto } from './parser.js';
@@ -338,7 +338,103 @@ function getChangedFiles(db, allFiles, rootDir) {
   return { changed, removed, isFullBuild: false };
 }
 
+/**
+ * Purge all graph data for the specified files.
+ * Deletes: embeddings → edges (in+out) → node_metrics → function_complexity → dataflow → nodes.
+ * Handles missing tables gracefully (embeddings, complexity, dataflow may not exist in older DBs).
+ *
+ * @param {import('better-sqlite3').Database} db - Open writable database
+ * @param {string[]} files - Relative file paths to purge
+ * @param {object} [options]
+ * @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);
+  }
+}
+
 export async function buildGraph(rootDir, opts = {}) {
+  rootDir = path.resolve(rootDir);
   const dbPath = path.join(rootDir, '.codegraph', 'graph.db');
   const db = openDb(dbPath);
   initSchema(db);
@@ -352,19 +448,22 @@ export async function buildGraph(rootDir, opts = {}) {
   const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
   info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
 
-  // Check for engine/version mismatch on incremental builds
+  // Check for engine/schema mismatch — auto-promote to full rebuild
+  // Only trigger on engine change or schema version change (not every patch/minor bump)
+  const CURRENT_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;
+  let forceFullRebuild = false;
   if (incremental) {
     const prevEngine = getBuildMeta(db, 'engine');
-    const prevVersion = getBuildMeta(db, 'codegraph_version');
     if (prevEngine && prevEngine !== engineName) {
-      warn(
-        `Engine changed (${prevEngine} → ${engineName}). Consider rebuilding with --no-incremental for consistency.`,
-      );
+      info(`Engine changed (${prevEngine} → ${engineName}), promoting to full rebuild.`);
+      forceFullRebuild = true;
     }
-    if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
-      warn(
-        `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}). Consider rebuilding with --no-incremental for consistency.`,
+    const prevSchema = getBuildMeta(db, 'schema_version');
+    if (prevSchema && Number(prevSchema) !== CURRENT_SCHEMA_VERSION) {
+      info(
+        `Schema version changed (${prevSchema} → ${CURRENT_SCHEMA_VERSION}), promoting to full rebuild.`,
       );
+      forceFullRebuild = true;
     }
   }
 
@@ -384,21 +483,85 @@ export async function buildGraph(rootDir, opts = {}) {
     );
   }
 
-  const collected = collectFiles(rootDir, [], config, new Set());
-  const files = collected.files;
-  const discoveredDirs = collected.directories;
-  info(`Found ${files.length} files to parse`);
-
-  // Check for incremental build
-  const { changed, removed, isFullBuild } = incremental
-    ? getChangedFiles(db, files, rootDir)
-    : { changed: files.map((f) => ({ file: f })), removed: [], isFullBuild: true };
-
-  // Separate metadata-only updates (mtime/size self-heal) from real changes
-  const parseChanges = changed.filter((c) => !c.metadataOnly);
-  const metadataUpdates = changed.filter((c) => c.metadataOnly);
+  // ── Scoped rebuild: rebuild only specified files ──────────────────
+  let files, discoveredDirs, parseChanges, metadataUpdates, removed, isFullBuild;
+
+  if (opts.scope) {
+    const scopedFiles = opts.scope.map((f) => normalizePath(f));
+    const existing = [];
+    const missing = [];
+    for (const rel of scopedFiles) {
+      const abs = path.join(rootDir, rel);
+      if (fs.existsSync(abs)) {
+        existing.push({ file: abs, relPath: rel });
+      } else {
+        missing.push(rel);
+      }
+    }
+    files = existing.map((e) => e.file);
+    // Derive discoveredDirs from scoped files' parent directories
+    discoveredDirs = new Set(existing.map((e) => path.dirname(e.file)));
+    parseChanges = existing;
+    metadataUpdates = [];
+    removed = missing;
+    isFullBuild = false;
+    info(`Scoped rebuild: ${existing.length} files to rebuild, ${missing.length} to purge`);
+  } else {
+    const collected = collectFiles(rootDir, [], config, new Set());
+    files = collected.files;
+    discoveredDirs = collected.directories;
+    info(`Found ${files.length} files to parse`);
+
+    // Check for incremental build
+    const increResult =
+      incremental && !forceFullRebuild
+        ? getChangedFiles(db, files, rootDir)
+        : { changed: files.map((f) => ({ file: f })), removed: [], isFullBuild: true };
+    removed = increResult.removed;
+    isFullBuild = increResult.isFullBuild;
+
+    // Separate metadata-only updates (mtime/size self-heal) from real changes
+    parseChanges = increResult.changed.filter((c) => !c.metadataOnly);
+    metadataUpdates = increResult.changed.filter((c) => c.metadataOnly);
+  }
 
   if (!isFullBuild && parseChanges.length === 0 && removed.length === 0) {
+    // Check if default analyses were never computed (e.g. legacy DB)
+    const needsCfg =
+      opts.cfg !== false &&
+      (() => {
+        try {
+          return db.prepare('SELECT COUNT(*) as c FROM cfg_blocks').get().c === 0;
+        } catch {
+          return true;
+        }
+      })();
+    const needsDataflow =
+      opts.dataflow !== false &&
+      (() => {
+        try {
+          return db.prepare('SELECT COUNT(*) as c FROM dataflow').get().c === 0;
+        } catch {
+          return true;
+        }
+      })();
+
+    if (needsCfg || needsDataflow) {
+      info('No file changes. Running pending analysis pass...');
+      const analysisSymbols = await parseFilesAuto(files, rootDir, engineOpts);
+      if (needsCfg) {
+        const { buildCFGData } = await import('./cfg.js');
+        await buildCFGData(db, analysisSymbols, rootDir, engineOpts);
+      }
+      if (needsDataflow) {
+        const { buildDataflowEdges } = await import('./dataflow.js');
+        await buildDataflowEdges(db, analysisSymbols, rootDir, engineOpts);
+      }
+      closeDb(db);
+      writeJournalHeader(rootDir, Date.now());
+      return;
+    }
+
     // Still update metadata for self-healing even when no real changes
     if (metadataUpdates.length > 0) {
       try {
@@ -435,7 +598,7 @@ export async function buildGraph(rootDir, opts = {}) {
 
   if (isFullBuild) {
     const deletions =
-      'PRAGMA foreign_keys = OFF; DELETE FROM node_metrics; DELETE FROM edges; DELETE FROM function_complexity; DELETE FROM nodes; PRAGMA foreign_keys = ON;';
+      'PRAGMA foreign_keys = OFF; DELETE FROM cfg_edges; DELETE FROM cfg_blocks; DELETE FROM node_metrics; DELETE FROM edges; DELETE FROM function_complexity; DELETE FROM dataflow; DELETE FROM ast_nodes; DELETE FROM nodes; PRAGMA foreign_keys = ON;';
     db.exec(
       hasEmbeddings
         ? `${deletions.replace('PRAGMA foreign_keys = ON;', '')} DELETE FROM embeddings; PRAGMA foreign_keys = ON;`
@@ -446,29 +609,33 @@ export async function buildGraph(rootDir, opts = {}) {
     // Find files with edges pointing TO changed/removed files.
     // Their nodes stay intact (preserving IDs), but outgoing edges are
     // deleted so they can be rebuilt during the edge-building pass.
-    const changedRelPaths = new Set();
-    for (const item of parseChanges) {
-      changedRelPaths.add(item.relPath || normalizePath(path.relative(rootDir, item.file)));
-    }
-    for (const relPath of removed) {
-      changedRelPaths.add(relPath);
-    }
-
+    // When opts.noReverseDeps is true (e.g. agent rollback to same version),
+    // skip this cascade — the agent knows exports didn't change.
     const reverseDeps = new Set();
-    if (changedRelPaths.size > 0) {
-      const findReverseDeps = db.prepare(`
-        SELECT DISTINCT n_src.file FROM edges e
-        JOIN nodes n_src ON e.source_id = n_src.id
-        JOIN nodes n_tgt ON e.target_id = n_tgt.id
-        WHERE n_tgt.file = ? AND n_src.file != n_tgt.file AND n_src.kind != 'directory'
-      `);
-      for (const relPath of changedRelPaths) {
-        for (const row of findReverseDeps.all(relPath)) {
-          if (!changedRelPaths.has(row.file) && !reverseDeps.has(row.file)) {
-            // Verify the file still exists on disk
-            const absPath = path.join(rootDir, row.file);
-            if (fs.existsSync(absPath)) {
-              reverseDeps.add(row.file);
+    if (!opts.noReverseDeps) {
+      const changedRelPaths = new Set();
+      for (const item of parseChanges) {
+        changedRelPaths.add(item.relPath || normalizePath(path.relative(rootDir, item.file)));
+      }
+      for (const relPath of removed) {
+        changedRelPaths.add(relPath);
+      }
+
+      if (changedRelPaths.size > 0) {
+        const findReverseDeps = db.prepare(`
+          SELECT DISTINCT n_src.file FROM edges e
+          JOIN nodes n_src ON e.source_id = n_src.id
+          JOIN nodes n_tgt ON e.target_id = n_tgt.id
+          WHERE n_tgt.file = ? AND n_src.file != n_tgt.file AND n_src.kind != 'directory'
+        `);
+        for (const relPath of changedRelPaths) {
+          for (const row of findReverseDeps.all(relPath)) {
+            if (!changedRelPaths.has(row.file) && !reverseDeps.has(row.file)) {
+              // Verify the file still exists on disk
+              const absPath = path.join(rootDir, row.file);
+              if (fs.existsSync(absPath)) {
+                reverseDeps.add(row.file);
+              }
             }
           }
         }
@@ -482,47 +649,16 @@ export async function buildGraph(rootDir, opts = {}) {
       debug(`Changed files: ${parseChanges.map((c) => c.relPath).join(', ')}`);
     if (removed.length > 0) debug(`Removed files: ${removed.join(', ')}`);
     // Remove embeddings/metrics/edges/nodes for changed and removed files
-    // Embeddings must be deleted BEFORE nodes (we need node IDs to find them)
-    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 deleteOutgoingEdgesForFile = db.prepare(
-      'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+    const changePaths = parseChanges.map(
+      (item) => item.relPath || normalizePath(path.relative(rootDir, item.file)),
     );
-    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;
-    }
-    for (const relPath of removed) {
-      deleteEmbeddingsForFile?.run(relPath);
-      deleteEdgesForFile.run({ f: relPath });
-      deleteMetricsForFile.run(relPath);
-      deleteComplexityForFile?.run(relPath);
-      deleteNodesForFile.run(relPath);
-    }
-    for (const item of parseChanges) {
-      const relPath = item.relPath || normalizePath(path.relative(rootDir, item.file));
-      deleteEmbeddingsForFile?.run(relPath);
-      deleteEdgesForFile.run({ f: relPath });
-      deleteMetricsForFile.run(relPath);
-      deleteComplexityForFile?.run(relPath);
-      deleteNodesForFile.run(relPath);
-    }
+    purgeFilesFromGraph(db, [...removed, ...changePaths], { purgeHashes: false });
 
     // Process reverse deps: delete only outgoing edges (nodes/IDs preserved)
     // then add them to the parse list so they participate in edge building
+    const deleteOutgoingEdgesForFile = db.prepare(
+      'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+    );
     for (const relPath of reverseDeps) {
       deleteOutgoingEdgesForFile.run(relPath);
     }
@@ -533,7 +669,7 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   const insertNode = db.prepare(
-    'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
+    'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line, parent_id) VALUES (?, ?, ?, ?, ?, ?)',
   );
   const getNodeId = db.prepare(
     'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
@@ -583,16 +719,65 @@ 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 insertAll = db.transaction(() => {
     for (const [relPath, symbols] of allSymbols) {
       fileSymbols.set(relPath, symbols);
 
-      insertNode.run(relPath, 'file', relPath, 0, null);
+      // Phase 1: Insert file node + definitions + exports (no children yet)
+      insertNode.run(relPath, 'file', relPath, 0, null, null);
       for (const def of symbols.definitions) {
-        insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null);
+        insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null, null);
       }
       for (const exp of symbols.exports) {
-        insertNode.run(exp.name, exp.kind, relPath, exp.line, null);
+        insertNode.run(exp.name, exp.kind, relPath, exp.line, null, null);
+      }
+
+      // Phase 2: Bulk-fetch IDs for file + definitions
+      const nodeIdMap = new Map();
+      for (const row of bulkGetNodeIds.all(relPath)) {
+        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+      }
+
+      // Phase 3: Insert children with parent_id from the map
+      for (const def of symbols.definitions) {
+        if (!def.children?.length) continue;
+        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+        if (!defId) continue;
+        for (const child of def.children) {
+          insertNode.run(child.name, child.kind, relPath, child.line, child.endLine || null, defId);
+        }
+      }
+
+      // Phase 4: Re-fetch to include children IDs
+      nodeIdMap.clear();
+      for (const row of bulkGetNodeIds.all(relPath)) {
+        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+      }
+
+      // Phase 5: Insert edges using the cached ID map
+      const fileId = nodeIdMap.get(`${relPath}|file|0`);
+      for (const def of symbols.definitions) {
+        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+        // File → top-level definition contains edge
+        if (fileId && defId) {
+          insertEdge.run(fileId, defId, 'contains', 1.0, 0);
+        }
+        if (def.children?.length && defId) {
+          for (const child of def.children) {
+            const childId = nodeIdMap.get(`${child.name}|${child.kind}|${child.line}`);
+            if (childId) {
+              // Parent → child contains edge
+              insertEdge.run(defId, childId, 'contains', 1.0, 0);
+              // Parameter → parent parameter_of edge (inverse direction)
+              if (child.kind === 'parameter') {
+                insertEdge.run(childId, defId, 'parameter_of', 1.0, 0);
+              }
+            }
+          }
+        }
       }
 
       // Update file hash with real mtime+size for incremental builds
@@ -772,7 +957,7 @@ export async function buildGraph(rootDir, opts = {}) {
   // N+1 optimization: pre-load all nodes into a lookup map for edge building
   const allNodes = db
     .prepare(
-      `SELECT id, name, kind, file FROM nodes WHERE kind IN ('function','method','class','interface')`,
+      `SELECT id, name, kind, file FROM nodes WHERE kind IN ('function','method','class','interface','struct','type','module','enum','trait')`,
     )
     .all();
   const nodesByName = new Map();
@@ -789,7 +974,6 @@ export async function buildGraph(rootDir, opts = {}) {
 
   // Second pass: build edges
   _t.edges0 = performance.now();
-  let edgeCount = 0;
   const buildEdges = db.transaction(() => {
     for (const [relPath, symbols] of fileSymbols) {
       // Skip barrel-only files — loaded for resolution, edges already in DB
@@ -805,7 +989,6 @@ export async function buildGraph(rootDir, opts = {}) {
         if (targetRow) {
           const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
           insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
-          edgeCount++;
 
           if (!imp.reexport && isBarrelFile(resolvedPath)) {
             const resolvedSources = new Set();
@@ -827,7 +1010,6 @@ export async function buildGraph(rootDir, opts = {}) {
                     0.9,
                     0,
                   );
-                  edgeCount++;
                 }
               }
             }
@@ -928,7 +1110,29 @@ export async function buildGraph(rootDir, opts = {}) {
             seenCallEdges.add(edgeKey);
             const confidence = computeConfidence(relPath, t.file, importedFrom);
             insertEdge.run(caller.id, t.id, 'calls', confidence, isDynamic);
-            edgeCount++;
+          }
+        }
+
+        // Receiver edge: caller → receiver type node
+        if (
+          call.receiver &&
+          !BUILTIN_RECEIVERS.has(call.receiver) &&
+          call.receiver !== 'this' &&
+          call.receiver !== 'self' &&
+          call.receiver !== 'super'
+        ) {
+          const receiverKinds = new Set(['class', 'struct', 'interface', 'type', 'module']);
+          // Same-file first, then global
+          const samefile = nodesByNameAndFile.get(`${call.receiver}|${relPath}`) || [];
+          const candidates = samefile.length > 0 ? samefile : nodesByName.get(call.receiver) || [];
+          const receiverNodes = candidates.filter((n) => receiverKinds.has(n.kind));
+          if (receiverNodes.length > 0 && caller) {
+            const recvTarget = receiverNodes[0];
+            const recvKey = `recv|${caller.id}|${recvTarget.id}`;
+            if (!seenCallEdges.has(recvKey)) {
+              seenCallEdges.add(recvKey);
+              insertEdge.run(caller.id, recvTarget.id, 'receiver', 0.7, 0);
+            }
           }
         }
       }
@@ -944,7 +1148,6 @@ export async function buildGraph(rootDir, opts = {}) {
           if (sourceRow) {
             for (const t of targetRows) {
               insertEdge.run(sourceRow.id, t.id, 'extends', 1.0, 0);
-              edgeCount++;
             }
           }
         }
@@ -960,7 +1163,6 @@ export async function buildGraph(rootDir, opts = {}) {
           if (sourceRow) {
             for (const t of targetRows) {
               insertEdge.run(sourceRow.id, t.id, 'implements', 1.0, 0);
-              edgeCount++;
             }
           }
         }
@@ -1047,7 +1249,9 @@ export async function buildGraph(rootDir, opts = {}) {
   }
   try {
     const { buildStructure } = await import('./structure.js');
-    buildStructure(db, fileSymbols, rootDir, lineCountMap, relDirs);
+    // Pass changed file paths so incremental builds can scope the rebuild
+    const changedFilePaths = isFullBuild ? null : [...allSymbols.keys()];
+    buildStructure(db, fileSymbols, rootDir, lineCountMap, relDirs, changedFilePaths);
   } catch (err) {
     debug(`Structure analysis failed: ${err.message}`);
   }
@@ -1068,16 +1272,75 @@ export async function buildGraph(rootDir, opts = {}) {
   }
   _t.rolesMs = performance.now() - _t.roles0;
 
+  // For incremental builds, filter out reverse-dep-only files from AST/complexity
+  // — their content didn't change, so existing ast_nodes/function_complexity rows are valid.
+  let astComplexitySymbols = allSymbols;
+  if (!isFullBuild) {
+    const reverseDepFiles = new Set(
+      filesToParse.filter((item) => item._reverseDepOnly).map((item) => item.relPath),
+    );
+    if (reverseDepFiles.size > 0) {
+      astComplexitySymbols = new Map();
+      for (const [relPath, symbols] of allSymbols) {
+        if (!reverseDepFiles.has(relPath)) {
+          astComplexitySymbols.set(relPath, symbols);
+        }
+      }
+      debug(
+        `AST/complexity: processing ${astComplexitySymbols.size} changed files (skipping ${reverseDepFiles.size} reverse-deps)`,
+      );
+    }
+  }
+
+  // AST node extraction (calls, new, string, regex, throw, await)
+  // Must run before complexity which releases _tree references
+  _t.ast0 = performance.now();
+  if (opts.ast !== false) {
+    try {
+      const { buildAstNodes } = await import('./ast.js');
+      await buildAstNodes(db, astComplexitySymbols, rootDir, engineOpts);
+    } catch (err) {
+      debug(`AST node extraction failed: ${err.message}`);
+    }
+  }
+  _t.astMs = performance.now() - _t.ast0;
+
   // Compute per-function complexity metrics (cognitive, cyclomatic, nesting)
   _t.complexity0 = performance.now();
-  try {
-    const { buildComplexityMetrics } = await import('./complexity.js');
-    await buildComplexityMetrics(db, allSymbols, rootDir, engineOpts);
-  } catch (err) {
-    debug(`Complexity analysis failed: ${err.message}`);
+  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;
 
+  // CFG analysis (skip with --no-cfg)
+  if (opts.cfg !== false) {
+    _t.cfg0 = performance.now();
+    try {
+      const { buildCFGData } = await import('./cfg.js');
+      await buildCFGData(db, allSymbols, 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, allSymbols, rootDir, engineOpts);
+    } catch (err) {
+      debug(`Dataflow analysis failed: ${err.message}`);
+    }
+    _t.dataflowMs = performance.now() - _t.dataflow0;
+  }
+
   // Release any remaining cached WASM trees for GC
   for (const [, symbols] of allSymbols) {
     symbols._tree = null;
@@ -1085,7 +1348,8 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   const nodeCount = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c;
-  info(`Graph built: ${nodeCount} nodes, ${edgeCount} edges`);
+  const actualEdgeCount = db.prepare('SELECT COUNT(*) as c FROM edges').get().c;
+  info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
   info(`Stored in ${dbPath}`);
 
   // Verify incremental build didn't diverge significantly from previous counts
@@ -1097,11 +1361,11 @@ export async function buildGraph(rootDir, opts = {}) {
       const prevE = Number(prevEdges);
       if (prevN > 0) {
         const nodeDrift = Math.abs(nodeCount - prevN) / prevN;
-        const edgeDrift = prevE > 0 ? Math.abs(edgeCount - prevE) / prevE : 0;
+        const edgeDrift = prevE > 0 ? Math.abs(actualEdgeCount - prevE) / prevE : 0;
         const driftThreshold = config.build?.driftThreshold ?? 0.2;
         if (nodeDrift > driftThreshold || edgeDrift > driftThreshold) {
           warn(
-            `Incremental build diverged significantly from previous counts (nodes: ${prevN}→${nodeCount} [${(nodeDrift * 100).toFixed(1)}%], edges: ${prevE}→${edgeCount} [${(edgeDrift * 100).toFixed(1)}%], threshold: ${(driftThreshold * 100).toFixed(0)}%). Consider rebuilding with --no-incremental.`,
+            `Incremental build diverged significantly from previous counts (nodes: ${prevN}→${nodeCount} [${(nodeDrift * 100).toFixed(1)}%], edges: ${prevE}→${actualEdgeCount} [${(edgeDrift * 100).toFixed(1)}%], threshold: ${(driftThreshold * 100).toFixed(0)}%). Consider rebuilding with --no-incremental.`,
           );
         }
       }
@@ -1130,9 +1394,10 @@ export async function buildGraph(rootDir, opts = {}) {
       engine: engineName,
       engine_version: engineVersion || '',
       codegraph_version: CODEGRAPH_VERSION,
+      schema_version: String(CURRENT_SCHEMA_VERSION),
       built_at: new Date().toISOString(),
       node_count: nodeCount,
-      edge_count: edgeCount,
+      edge_count: actualEdgeCount,
     });
   } catch (err) {
     warn(`Failed to write build metadata: ${err.message}`);
@@ -1167,7 +1432,10 @@ export async function buildGraph(rootDir, opts = {}) {
       edgesMs: +_t.edgesMs.toFixed(1),
       structureMs: +_t.structureMs.toFixed(1),
       rolesMs: +_t.rolesMs.toFixed(1),
+      astMs: +_t.astMs.toFixed(1),
       complexityMs: +_t.complexityMs.toFixed(1),
+      ...(_t.cfgMs != null && { cfgMs: +_t.cfgMs.toFixed(1) }),
+      ...(_t.dataflowMs != null && { dataflowMs: +_t.dataflowMs.toFixed(1) }),
     },
   };
 }