@optave/codegraph 3.0.0 → 3.0.1

package/README.md

@@ -208,8 +208,8 @@ Full agent setup: [AI Agent Guide](docs/guides/ai-agent-guide.md) · [CLAU
 | 📋 | **Composite audit** | Single `audit` command combining explain + impact + health metrics per function — one call instead of 3-4 |
 | 🚦 | **Triage queue** | `triage` merges connectivity, hotspots, roles, and complexity into a ranked audit priority queue |
 | 📦 | **Batch querying** | Accept a list of targets and return all results in one JSON payload — enables multi-agent parallel dispatch |
-| 🔬 | **Dataflow analysis** | Track how data moves through functions with `flows_to`, `returns`, and `mutates` edges — opt-in via `build --dataflow` (JS/TS) |
-| 🧩 | **Control flow graph** | Intraprocedural CFG construction for all 11 languages — `cfg` command with text/DOT/Mermaid output, opt-in via `build --cfg` |
+| 🔬 | **Dataflow analysis** | Track how data moves through functions with `flows_to`, `returns`, and `mutates` edges — included by default (JS/TS), skip with `--no-dataflow` |
+| 🧩 | **Control flow graph** | Intraprocedural CFG construction for all 11 languages — `cfg` command with text/DOT/Mermaid output, included by default, skip with `--no-cfg` |
 | 🔎 | **AST node querying** | Stored queryable AST nodes (calls, `new`, string, regex, throw, await) — `ast` command with SQL GLOB pattern matching |
 | 🧬 | **Expanded node/edge types** | `parameter`, `property`, `constant` node kinds with `parent_id` for sub-declaration queries; `contains`, `parameter_of`, `receiver` edge kinds |
 | 📊 | **Exports analysis** | `exports <file>` shows all exported symbols with per-symbol consumers, re-export detection, and counts |
@@ -327,7 +327,7 @@ codegraph ast -k call                 # Filter by kind: call, new, string, regex
 codegraph ast -k throw --file src/    # Combine kind and file filters
 ```
 
-> **Note:** Dataflow requires `codegraph build --dataflow` (JS/TS only). CFG requires `codegraph build --cfg`. Both are opt-in to keep default builds fast.
+> **Note:** Dataflow (JS/TS only) and CFG are included by default. Use `--no-dataflow` / `--no-cfg` for faster builds.
 
 ### Audit, Triage & Batch
 
@@ -552,14 +552,14 @@ Self-measured on every release via CI ([build benchmarks](generated/benchmarks/B
 
 | Metric | Latest |
 |---|---|
-| Build speed (native) | **1.9 ms/file** |
-| Build speed (WASM) | **8.3 ms/file** |
+| Build speed (native) | **4.4 ms/file** |
+| Build speed (WASM) | **13.7 ms/file** |
 | Query time | **3ms** |
 | No-op rebuild (native) | **4ms** |
-| 1-file rebuild (native) | **124ms** |
-| Query: fn-deps | **1.4ms** |
-| Query: path | **1.4ms** |
-| ~50,000 files (est.) | **~95.0s build** |
+| 1-file rebuild (native) | **325ms** |
+| Query: fn-deps | **0.8ms** |
+| Query: path | **0.8ms** |
+| ~50,000 files (est.) | **~220.0s build** |
 
 Metrics are normalized per file for cross-version comparability. Times above are for a full initial build — incremental rebuilds only re-parse changed files.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optave/codegraph",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Local code graph CLI — parse codebases with tree-sitter, build dependency graphs, query them",
   "type": "module",
   "main": "src/index.js",
@@ -71,10 +71,10 @@
   },
   "optionalDependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@optave/codegraph-darwin-arm64": "3.0.0",
-    "@optave/codegraph-darwin-x64": "3.0.0",
-    "@optave/codegraph-linux-x64-gnu": "3.0.0",
-    "@optave/codegraph-win32-x64-msvc": "3.0.0"
+    "@optave/codegraph-darwin-arm64": "3.0.1",
+    "@optave/codegraph-darwin-x64": "3.0.1",
+    "@optave/codegraph-linux-x64-gnu": "3.0.1",
+    "@optave/codegraph-win32-x64-msvc": "3.0.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",

package/src/ast.js

@@ -156,9 +156,8 @@ export async function buildAstNodes(db, fileSymbols, _rootDir, _engineOpts) {
     return;
   }
 
-  const getNodeId = db.prepare(
-    'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?',
-  );
+  // Bulk-fetch all node IDs per file (replaces per-def getNodeId calls)
+  const bulkGetNodeIds = db.prepare('SELECT id, name, kind, line FROM nodes WHERE file = ?');
 
   const tx = db.transaction((rows) => {
     for (const r of rows) {
@@ -172,14 +171,20 @@ export async function buildAstNodes(db, fileSymbols, _rootDir, _engineOpts) {
     const rows = [];
     const defs = symbols.definitions || [];
 
+    // Pre-load all node IDs for this file into a map
+    const nodeIdMap = new Map();
+    for (const row of bulkGetNodeIds.all(relPath)) {
+      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+    }
+
     // 1. Call nodes from symbols.calls (all languages)
     if (symbols.calls) {
       for (const call of symbols.calls) {
         const parentDef = findParentDef(defs, call.line);
         let parentNodeId = null;
         if (parentDef) {
-          const row = getNodeId.get(parentDef.name, parentDef.kind, relPath, parentDef.line);
-          if (row) parentNodeId = row.id;
+          parentNodeId =
+            nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
         }
         rows.push({
           file: relPath,
@@ -195,10 +200,32 @@ export async function buildAstNodes(db, fileSymbols, _rootDir, _engineOpts) {
 
     // 2. AST walk for JS/TS/TSX — extract new, throw, await, string, regex
     const ext = path.extname(relPath).toLowerCase();
-    if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
-      const astRows = [];
-      walkAst(symbols._tree.rootNode, defs, relPath, astRows, getNodeId);
-      rows.push(...astRows);
+    if (WALK_EXTENSIONS.has(ext)) {
+      if (symbols._tree) {
+        // WASM path: walk the tree-sitter AST
+        const astRows = [];
+        walkAst(symbols._tree.rootNode, defs, relPath, astRows, nodeIdMap);
+        rows.push(...astRows);
+      } else if (symbols.astNodes?.length) {
+        // Native path: use pre-extracted AST nodes from Rust
+        for (const n of symbols.astNodes) {
+          const parentDef = findParentDef(defs, n.line);
+          let parentNodeId = null;
+          if (parentDef) {
+            parentNodeId =
+              nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
+          }
+          rows.push({
+            file: relPath,
+            line: n.line,
+            kind: n.kind,
+            name: n.name,
+            text: n.text || null,
+            receiver: n.receiver || null,
+            parentNodeId,
+          });
+        }
+      }
     }
 
     if (rows.length > 0) {
@@ -213,7 +240,7 @@ export async function buildAstNodes(db, fileSymbols, _rootDir, _engineOpts) {
 /**
  * Walk a tree-sitter AST and collect new/throw/await/string/regex nodes.
  */
-function walkAst(node, defs, relPath, rows, getNodeId) {
+function walkAst(node, defs, relPath, rows, nodeIdMap) {
   const kind = JS_TS_AST_TYPES[node.type];
   if (kind) {
     // tree-sitter lines are 0-indexed, our DB uses 1-indexed
@@ -237,7 +264,7 @@ function walkAst(node, defs, relPath, rows, getNodeId) {
       if (content.length < 2) {
         // Still recurse children
         for (let i = 0; i < node.childCount; i++) {
-          walkAst(node.child(i), defs, relPath, rows, getNodeId);
+          walkAst(node.child(i), defs, relPath, rows, nodeIdMap);
         }
         return;
       }
@@ -251,8 +278,7 @@ function walkAst(node, defs, relPath, rows, getNodeId) {
     const parentDef = findParentDef(defs, line);
     let parentNodeId = null;
     if (parentDef) {
-      const row = getNodeId.get(parentDef.name, parentDef.kind, relPath, parentDef.line);
-      if (row) parentNodeId = row.id;
+      parentNodeId = nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
     }
 
     rows.push({
@@ -271,7 +297,7 @@ function walkAst(node, defs, relPath, rows, getNodeId) {
   }
 
   for (let i = 0; i < node.childCount; i++) {
-    walkAst(node.child(i), defs, relPath, rows, getNodeId);
+    walkAst(node.child(i), defs, relPath, rows, nodeIdMap);
   }
 }
 

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';
@@ -448,17 +448,21 @@ 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 — auto-promote to full rebuild
+  // 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) {
       info(`Engine changed (${prevEngine} → ${engineName}), promoting to full rebuild.`);
       forceFullRebuild = true;
     }
-    if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
-      info(`Version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`);
+    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;
     }
   }
@@ -522,9 +526,9 @@ export async function buildGraph(rootDir, opts = {}) {
   }
 
   if (!isFullBuild && parseChanges.length === 0 && removed.length === 0) {
-    // Check if optional analysis was requested but never computed
+    // Check if default analyses were never computed (e.g. legacy DB)
     const needsCfg =
-      opts.cfg &&
+      opts.cfg !== false &&
       (() => {
         try {
           return db.prepare('SELECT COUNT(*) as c FROM cfg_blocks').get().c === 0;
@@ -533,16 +537,10 @@ export async function buildGraph(rootDir, opts = {}) {
         }
       })();
     const needsDataflow =
-      opts.dataflow &&
+      opts.dataflow !== false &&
       (() => {
         try {
-          return (
-            db
-              .prepare(
-                "SELECT COUNT(*) as c FROM edges WHERE kind IN ('flows_to','returns','mutates')",
-              )
-              .get().c === 0
-          );
+          return db.prepare('SELECT COUNT(*) as c FROM dataflow').get().c === 0;
         } catch {
           return true;
         }
@@ -721,44 +719,66 @@ 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);
 
+      // Phase 1: Insert file node + definitions + exports (no children yet)
       insertNode.run(relPath, 'file', relPath, 0, null, null);
-      const fileRow = getNodeId.get(relPath, 'file', relPath, 0);
       for (const def of symbols.definitions) {
         insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null, null);
-        const defRow = getNodeId.get(def.name, def.kind, relPath, def.line);
+      }
+      for (const exp of symbols.exports) {
+        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 (fileRow && defRow) {
-          insertEdge.run(fileRow.id, defRow.id, 'contains', 1.0, 0);
+        if (fileId && defId) {
+          insertEdge.run(fileId, defId, 'contains', 1.0, 0);
         }
-        if (def.children?.length && defRow) {
+        if (def.children?.length && defId) {
           for (const child of def.children) {
-            insertNode.run(
-              child.name,
-              child.kind,
-              relPath,
-              child.line,
-              child.endLine || null,
-              defRow.id,
-            );
-            // Parent → child contains edge
-            const childRow = getNodeId.get(child.name, child.kind, relPath, child.line);
-            if (childRow) {
-              insertEdge.run(defRow.id, childRow.id, 'contains', 1.0, 0);
+            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(childRow.id, defRow.id, 'parameter_of', 1.0, 0);
+                insertEdge.run(childId, defId, 'parameter_of', 1.0, 0);
               }
             }
           }
         }
       }
-      for (const exp of symbols.exports) {
-        insertNode.run(exp.name, exp.kind, relPath, exp.line, null, null);
-      }
 
       // Update file hash with real mtime+size for incremental builds
       // Skip for reverse-dep files — they didn't actually change
@@ -1229,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}`);
   }
@@ -1250,29 +1272,53 @@ export async function buildGraph(rootDir, opts = {}) {
   }
   _t.rolesMs = performance.now() - _t.roles0;
 
-  // Always-on AST node extraction (calls, new, string, regex, throw, await)
+  // 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();
-  try {
-    const { buildAstNodes } = await import('./ast.js');
-    await buildAstNodes(db, allSymbols, rootDir, engineOpts);
-  } catch (err) {
-    debug(`AST node extraction failed: ${err.message}`);
+  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;
 
-  // Opt-in CFG analysis (--cfg)
-  if (opts.cfg) {
+  // CFG analysis (skip with --no-cfg)
+  if (opts.cfg !== false) {
     _t.cfg0 = performance.now();
     try {
       const { buildCFGData } = await import('./cfg.js');
@@ -1283,8 +1329,8 @@ export async function buildGraph(rootDir, opts = {}) {
     _t.cfgMs = performance.now() - _t.cfg0;
   }
 
-  // Opt-in dataflow analysis (--dataflow)
-  if (opts.dataflow) {
+  // Dataflow analysis (skip with --no-dataflow)
+  if (opts.dataflow !== false) {
     _t.dataflow0 = performance.now();
     try {
       const { buildDataflowEdges } = await import('./dataflow.js');
@@ -1348,6 +1394,7 @@ 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: actualEdgeCount,
@@ -1385,8 +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) }),
     },
   };
 }

package/src/cfg.js

@@ -1241,7 +1241,8 @@ export function cfgData(name, customDbPath, opts = {}) {
     return {
       name,
       results: [],
-      warning: 'No CFG data found. Run `codegraph build --cfg` first.',
+      warning:
+        'No CFG data found. Rebuild with `codegraph build` (CFG is now included by default).',
     };
   }
 

package/src/cli.js

@@ -105,13 +105,17 @@ program
   .command('build [dir]')
   .description('Parse repo and build graph in .codegraph/graph.db')
   .option('--no-incremental', 'Force full rebuild (ignore file hashes)')
-  .option('--dataflow', 'Extract data flow edges (flows_to, returns, mutates)')
-  .option('--cfg', 'Build intraprocedural control flow graphs')
+  .option('--no-ast', 'Skip AST node extraction (calls, new, string, regex, throw, await)')
+  .option('--no-complexity', 'Skip complexity metrics computation')
+  .option('--no-dataflow', 'Skip data flow edge extraction')
+  .option('--no-cfg', 'Skip control flow graph building')
   .action(async (dir, opts) => {
     const root = path.resolve(dir || '.');
     const engine = program.opts().engine;
     await buildGraph(root, {
       incremental: opts.incremental,
+      ast: opts.ast,
+      complexity: opts.complexity,
       engine,
       dataflow: opts.dataflow,
       cfg: opts.cfg,

package/src/dataflow.js

@@ -734,7 +734,8 @@ export function dataflowData(name, customDbPath, opts = {}) {
     return {
       name,
       results: [],
-      warning: 'No dataflow data found. Run `codegraph build --dataflow` first.',
+      warning:
+        'No dataflow data found. Rebuild with `codegraph build` (dataflow is now included by default).',
     };
   }
 
@@ -876,7 +877,8 @@ export function dataflowPathData(from, to, customDbPath, opts = {}) {
       from,
       to,
       found: false,
-      warning: 'No dataflow data found. Run `codegraph build --dataflow` first.',
+      warning:
+        'No dataflow data found. Rebuild with `codegraph build` (dataflow is now included by default).',
     };
   }
 
@@ -1005,7 +1007,8 @@ export function dataflowImpactData(name, customDbPath, opts = {}) {
     return {
       name,
       results: [],
-      warning: 'No dataflow data found. Run `codegraph build --dataflow` first.',
+      warning:
+        'No dataflow data found. Rebuild with `codegraph build` (dataflow is now included by default).',
     };
   }
 

package/src/extractors/javascript.js

@@ -170,9 +170,60 @@ function extractSymbolsQuery(tree, query) {
     }
   }
 
+  // Extract top-level constants via targeted walk (query patterns don't cover these)
+  extractConstantsWalk(tree.rootNode, definitions);
+
   return { definitions, calls, imports, classes, exports: exps };
 }
 
+/**
+ * Walk program-level children to extract `const x = <literal>` as constants.
+ * The query-based fast path has no pattern for lexical_declaration/variable_declaration,
+ * so constants are missed. This targeted walk fills that gap without a full tree traversal.
+ */
+function extractConstantsWalk(rootNode, definitions) {
+  for (let i = 0; i < rootNode.childCount; i++) {
+    const node = rootNode.child(i);
+    if (!node) continue;
+
+    let declNode = node;
+    // Handle `export const …` — unwrap the export_statement to its declaration child
+    if (node.type === 'export_statement') {
+      const inner = node.childForFieldName('declaration');
+      if (!inner) continue;
+      declNode = inner;
+    }
+
+    const t = declNode.type;
+    if (t !== 'lexical_declaration' && t !== 'variable_declaration') continue;
+    if (!declNode.text.startsWith('const ')) continue;
+
+    for (let j = 0; j < declNode.childCount; j++) {
+      const declarator = declNode.child(j);
+      if (!declarator || declarator.type !== 'variable_declarator') continue;
+      const nameN = declarator.childForFieldName('name');
+      const valueN = declarator.childForFieldName('value');
+      if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
+      // Skip functions — already captured by query patterns
+      const valType = valueN.type;
+      if (
+        valType === 'arrow_function' ||
+        valType === 'function_expression' ||
+        valType === 'function'
+      )
+        continue;
+      if (isConstantValue(valueN)) {
+        definitions.push({
+          name: nameN.text,
+          kind: 'constant',
+          line: declNode.startPosition.row + 1,
+          endLine: nodeEndLine(declNode),
+        });
+      }
+    }
+  }
+}
+
 function handleCommonJSAssignment(left, right, node, imports) {
   if (!left || !right) return;
   const leftText = left.text;

package/src/flow.js

@@ -45,7 +45,10 @@ export function listEntryPointsData(dbPath, opts = {}) {
     .prepare(
       `SELECT n.name, n.kind, n.file, n.line, n.role
        FROM nodes n
-       WHERE (${prefixConditions})
+       WHERE (
+         (${prefixConditions})
+         OR n.role = 'entry'
+       )
          AND n.kind NOT IN ('file', 'directory')
        ORDER BY n.name`,
     )
@@ -59,7 +62,7 @@ export function listEntryPointsData(dbPath, opts = {}) {
     file: r.file,
     line: r.line,
     role: r.role,
-    type: entryPointType(r.name),
+    type: entryPointType(r.name) || (r.role === 'entry' ? 'exported' : null),
   }));
 
   const byType = {};

package/src/index.js

@@ -123,7 +123,7 @@ export { matchOwners, owners, ownersData, ownersForFiles, parseCodeowners } from
 export { MCP_DEFAULTS, MCP_MAX_LIMIT, paginate, paginateResult, printNdjson } from './paginate.js';
 
 // Unified parser API
-export { getActiveEngine, parseFileAuto, parseFilesAuto } from './parser.js';
+export { getActiveEngine, isWasmAvailable, parseFileAuto, parseFilesAuto } from './parser.js';
 // Query functions (data-returning)
 export {
   ALL_SYMBOL_KINDS,

package/src/mcp.js

@@ -638,7 +638,7 @@ const BASE_TOOLS = [
   },
   {
     name: 'cfg',
-    description: 'Show intraprocedural control flow graph for a function. Requires build --cfg.',
+    description: 'Show intraprocedural control flow graph for a function.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -658,7 +658,7 @@ const BASE_TOOLS = [
   },
   {
     name: 'dataflow',
-    description: 'Show data flow edges or data-dependent blast radius. Requires build --dataflow.',
+    description: 'Show data flow edges or data-dependent blast radius.',
     inputSchema: {
       type: 'object',
       properties: {

package/src/parser.js

@@ -104,6 +104,15 @@ export function getParser(parsers, filePath) {
   return parsers.get(entry.id) || null;
 }
 
+/**
+ * Check whether the required WASM grammar files exist on disk.
+ */
+export function isWasmAvailable() {
+  return LANGUAGE_REGISTRY.filter((e) => e.required).every((e) =>
+    fs.existsSync(grammarPath(e.grammarFile)),
+  );
+}
+
 // ── Unified API ──────────────────────────────────────────────────────────────
 
 function resolveEngine(opts = {}) {
@@ -183,6 +192,13 @@ function normalizeNativeSymbols(result) {
       kind: e.kind,
       line: e.line,
     })),
+    astNodes: (result.astNodes ?? result.ast_nodes ?? []).map((n) => ({
+      kind: n.kind,
+      name: n.name,
+      line: n.line,
+      text: n.text ?? null,
+      receiver: n.receiver ?? null,
+    })),
   };
 }
 

package/src/structure.js

@@ -17,7 +17,7 @@ import { isTestFile } from './queries.js';
  * @param {Map<string, number>} lineCountMap - Map of relPath → line count
  * @param {Set<string>} directories - Set of relative directory paths
  */
-export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, directories) {
+export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, directories, changedFiles) {
   const insertNode = db.prepare(
     'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
   );
@@ -33,15 +33,49 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
-  // Clean previous directory nodes/edges (idempotent rebuild)
-  // Scope contains-edge delete to directory-sourced edges only,
-  // preserving symbol-level contains edges (file→def, class→method, etc.)
-  db.exec(`
-    DELETE FROM edges WHERE kind = 'contains'
-      AND source_id IN (SELECT id FROM nodes WHERE kind = 'directory');
-    DELETE FROM node_metrics;
-    DELETE FROM nodes WHERE kind = 'directory';
-  `);
+  const isIncremental = changedFiles != null && changedFiles.length > 0;
+
+  if (isIncremental) {
+    // Incremental: only clean up data for changed files and their ancestor directories
+    const affectedDirs = new Set();
+    for (const f of changedFiles) {
+      let d = normalizePath(path.dirname(f));
+      while (d && d !== '.') {
+        affectedDirs.add(d);
+        d = normalizePath(path.dirname(d));
+      }
+    }
+    const deleteContainsForDir = db.prepare(
+      "DELETE FROM edges WHERE kind = 'contains' AND source_id IN (SELECT id FROM nodes WHERE name = ? AND kind = 'directory')",
+    );
+    const deleteMetricForNode = db.prepare('DELETE FROM node_metrics WHERE node_id = ?');
+    db.transaction(() => {
+      // Delete contains edges only from affected directories
+      for (const dir of affectedDirs) {
+        deleteContainsForDir.run(dir);
+      }
+      // Delete metrics for changed files
+      for (const f of changedFiles) {
+        const fileRow = getNodeId.get(f, 'file', f, 0);
+        if (fileRow) deleteMetricForNode.run(fileRow.id);
+      }
+      // Delete metrics for affected directories
+      for (const dir of affectedDirs) {
+        const dirRow = getNodeId.get(dir, 'directory', dir, 0);
+        if (dirRow) deleteMetricForNode.run(dirRow.id);
+      }
+    })();
+  } else {
+    // Full rebuild: clean previous directory nodes/edges (idempotent)
+    // Scope contains-edge delete to directory-sourced edges only,
+    // preserving symbol-level contains edges (file→def, class→method, etc.)
+    db.exec(`
+      DELETE FROM edges WHERE kind = 'contains'
+        AND source_id IN (SELECT id FROM nodes WHERE kind = 'directory');
+      DELETE FROM node_metrics;
+      DELETE FROM nodes WHERE kind = 'directory';
+    `);
+  }
 
   // Step 1: Ensure all directories are represented (including intermediate parents)
   const allDirs = new Set();
@@ -61,7 +95,7 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
     }
   }
 
-  // Step 2: Insert directory nodes
+  // Step 2: Insert directory nodes (INSERT OR IGNORE — safe for incremental)
   const insertDirs = db.transaction(() => {
     for (const dir of allDirs) {
       insertNode.run(dir, 'directory', dir, 0, null);
@@ -70,11 +104,28 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
   insertDirs();
 
   // Step 3: Insert 'contains' edges (dir → file, dir → subdirectory)
+  // On incremental, only re-insert for affected directories (others are intact)
+  const affectedDirs = isIncremental
+    ? (() => {
+        const dirs = new Set();
+        for (const f of changedFiles) {
+          let d = normalizePath(path.dirname(f));
+          while (d && d !== '.') {
+            dirs.add(d);
+            d = normalizePath(path.dirname(d));
+          }
+        }
+        return dirs;
+      })()
+    : null;
+
   const insertContains = db.transaction(() => {
     // dir → file
     for (const relPath of fileSymbols.keys()) {
       const dir = normalizePath(path.dirname(relPath));
       if (!dir || dir === '.') continue;
+      // On incremental, skip dirs whose contains edges are intact
+      if (affectedDirs && !affectedDirs.has(dir)) continue;
       const dirRow = getNodeId.get(dir, 'directory', dir, 0);
       const fileRow = getNodeId.get(relPath, 'file', relPath, 0);
       if (dirRow && fileRow) {
@@ -85,6 +136,8 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
     for (const dir of allDirs) {
       const parent = normalizePath(path.dirname(dir));
       if (!parent || parent === '.' || parent === dir) continue;
+      // On incremental, skip parent dirs whose contains edges are intact
+      if (affectedDirs && !affectedDirs.has(parent)) continue;
       const parentRow = getNodeId.get(parent, 'directory', parent, 0);
       const childRow = getNodeId.get(dir, 'directory', dir, 0);
       if (parentRow && childRow) {