@optave/codegraph 3.0.0 → 3.0.2

package/README.md

@@ -195,6 +195,7 @@ Full agent setup: [AI Agent Guide](docs/guides/ai-agent-guide.md) · [CLAU
 | 👀 | **Watch mode** | Incrementally update the graph as files change |
 | 🤖 | **MCP server** | 30-tool MCP server for AI assistants; single-repo by default, opt-in multi-repo |
 | ⚡ | **Always fresh** | Three-tier incremental detection — sub-second rebuilds even on large codebases |
+| 🔬 | **Data flow analysis** | Intraprocedural parameter tracking, return consumers, argument flows, and mutation detection — all 11 languages |
 | 🧮 | **Complexity metrics** | Cognitive, cyclomatic, nesting depth, Halstead, and Maintainability Index per function |
 | 🏘️ | **Community detection** | Louvain clustering to discover natural module boundaries and architectural drift |
 | 📜 | **Manifesto rule engine** | Configurable pass/fail rules with warn/fail thresholds for CI gates via `check` (exit code 1 on fail) |
@@ -208,8 +209,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 — all 11 languages, included by default, 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 |
@@ -225,6 +226,7 @@ See [docs/examples](docs/examples) for real-world CLI and MCP usage examples.
 ```bash
 codegraph build [dir]          # Parse and build the dependency graph
 codegraph build --no-incremental  # Force full rebuild
+codegraph build --dataflow     # Extract data flow edges (flows_to, returns, mutates)
 codegraph build --engine wasm  # Force WASM engine (skip native)
 codegraph watch [dir]          # Watch for changes, update graph incrementally
 ```
@@ -327,7 +329,8 @@ 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 and CFG are included by default for all 11 languages. Use `--no-dataflow` / `--no-cfg` for faster builds.
+
 
 ### Audit, Triage & Batch
 
@@ -477,15 +480,15 @@ codegraph registry remove <name>  # Unregister
 
 | Language | Extensions | Coverage |
 |---|---|---|
-| ![JavaScript](https://img.shields.io/badge/-JavaScript-F7DF1E?style=flat-square&logo=javascript&logoColor=black) | `.js`, `.jsx`, `.mjs`, `.cjs` | Full — functions, classes, imports, call sites |
-| ![TypeScript](https://img.shields.io/badge/-TypeScript-3178C6?style=flat-square&logo=typescript&logoColor=white) | `.ts`, `.tsx` | Full — interfaces, type aliases, `.d.ts` |
-| ![Python](https://img.shields.io/badge/-Python-3776AB?style=flat-square&logo=python&logoColor=white) | `.py` | Functions, classes, methods, imports, decorators |
-| ![Go](https://img.shields.io/badge/-Go-00ADD8?style=flat-square&logo=go&logoColor=white) | `.go` | Functions, methods, structs, interfaces, imports, call sites |
-| ![Rust](https://img.shields.io/badge/-Rust-000000?style=flat-square&logo=rust&logoColor=white) | `.rs` | Functions, methods, structs, traits, `use` imports, call sites |
-| ![Java](https://img.shields.io/badge/-Java-ED8B00?style=flat-square&logo=openjdk&logoColor=white) | `.java` | Classes, methods, constructors, interfaces, imports, call sites |
-| ![C#](https://img.shields.io/badge/-C%23-512BD4?style=flat-square&logo=dotnet&logoColor=white) | `.cs` | Classes, structs, records, interfaces, enums, methods, constructors, using directives, invocations |
-| ![PHP](https://img.shields.io/badge/-PHP-777BB4?style=flat-square&logo=php&logoColor=white) | `.php` | Functions, classes, interfaces, traits, enums, methods, namespace use, calls |
-| ![Ruby](https://img.shields.io/badge/-Ruby-CC342D?style=flat-square&logo=ruby&logoColor=white) | `.rb` | Classes, modules, methods, singleton methods, require/require_relative, include/extend |
+| ![JavaScript](https://img.shields.io/badge/-JavaScript-F7DF1E?style=flat-square&logo=javascript&logoColor=black) | `.js`, `.jsx`, `.mjs`, `.cjs` | Full — functions, classes, imports, call sites, dataflow |
+| ![TypeScript](https://img.shields.io/badge/-TypeScript-3178C6?style=flat-square&logo=typescript&logoColor=white) | `.ts`, `.tsx` | Full — interfaces, type aliases, `.d.ts`, dataflow |
+| ![Python](https://img.shields.io/badge/-Python-3776AB?style=flat-square&logo=python&logoColor=white) | `.py` | Functions, classes, methods, imports, decorators, dataflow |
+| ![Go](https://img.shields.io/badge/-Go-00ADD8?style=flat-square&logo=go&logoColor=white) | `.go` | Functions, methods, structs, interfaces, imports, call sites, dataflow |
+| ![Rust](https://img.shields.io/badge/-Rust-000000?style=flat-square&logo=rust&logoColor=white) | `.rs` | Functions, methods, structs, traits, `use` imports, call sites, dataflow |
+| ![Java](https://img.shields.io/badge/-Java-ED8B00?style=flat-square&logo=openjdk&logoColor=white) | `.java` | Classes, methods, constructors, interfaces, imports, call sites, dataflow |
+| ![C#](https://img.shields.io/badge/-C%23-512BD4?style=flat-square&logo=dotnet&logoColor=white) | `.cs` | Classes, structs, records, interfaces, enums, methods, constructors, using directives, invocations, dataflow |
+| ![PHP](https://img.shields.io/badge/-PHP-777BB4?style=flat-square&logo=php&logoColor=white) | `.php` | Functions, classes, interfaces, traits, enums, methods, namespace use, calls, dataflow |
+| ![Ruby](https://img.shields.io/badge/-Ruby-CC342D?style=flat-square&logo=ruby&logoColor=white) | `.rb` | Classes, modules, methods, singleton methods, require/require_relative, include/extend, dataflow |
 | ![Terraform](https://img.shields.io/badge/-Terraform-844FBA?style=flat-square&logo=terraform&logoColor=white) | `.tf`, `.hcl` | Resource, data, variable, module, output blocks |
 
 ## ⚙️ How It Works
@@ -552,14 +555,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) | **14.1 ms/file** |
+| Build speed (WASM) | **24.4 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** |
+| No-op rebuild (native) | **5ms** |
+| 1-file rebuild (native) | **915ms** |
+| Query: fn-deps | **0.9ms** |
+| Query: path | **0.8ms** |
+| ~50,000 files (est.) | **~705.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.
 
@@ -804,7 +807,7 @@ const { results: fused } = await multiSearchData(
 - **No full type inference** — parses `.d.ts` interfaces but doesn't use TypeScript's type checker for overload resolution
 - **Dynamic calls are best-effort** — complex computed property access and `eval` patterns are not resolved
 - **Python imports** — resolves relative imports but doesn't follow `sys.path` or virtual environment packages
-- **Dataflow analysis** — currently JS/TS only; intraprocedural (single-function scope), not interprocedural
+- **Dataflow analysis** — intraprocedural (single-function scope), not interprocedural
 
 ## 🗺️ Roadmap
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optave/codegraph",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "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.2",
+    "@optave/codegraph-darwin-x64": "3.0.2",
+    "@optave/codegraph-linux-x64-gnu": "3.0.2",
+    "@optave/codegraph-win32-x64-msvc": "3.0.2"
   },
   "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,45 +1272,81 @@ export async function buildGraph(rootDir, opts = {}) {
   }
   _t.rolesMs = performance.now() - _t.roles0;
 
-  // Always-on AST node extraction (calls, new, string, regex, throw, await)
-  // Must run before complexity which releases _tree references
+  // For incremental builds, filter out reverse-dep-only files from AST/complexity/CFG/dataflow
+  // — 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/CFG/dataflow: processing ${astComplexitySymbols.size} changed files (skipping ${reverseDepFiles.size} reverse-deps)`,
+      );
+    }
+  }
+
+  // AST node extraction (calls, new, string, regex, throw, await)
   _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) {
+  // Pre-parse files missing WASM trees (native builds) so CFG + dataflow
+  // share a single parse pass instead of each creating parsers independently
+  if (opts.cfg !== false || opts.dataflow !== false) {
+    _t.wasmPre0 = performance.now();
+    try {
+      const { ensureWasmTrees } = await import('./parser.js');
+      await ensureWasmTrees(astComplexitySymbols, rootDir);
+    } catch (err) {
+      debug(`WASM pre-parse failed: ${err.message}`);
+    }
+    _t.wasmPreMs = performance.now() - _t.wasmPre0;
+  }
+
+  // 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);
+      await buildCFGData(db, astComplexitySymbols, rootDir, engineOpts);
     } catch (err) {
       debug(`CFG analysis failed: ${err.message}`);
     }
     _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');
-      await buildDataflowEdges(db, allSymbols, rootDir, engineOpts);
+      await buildDataflowEdges(db, astComplexitySymbols, rootDir, engineOpts);
     } catch (err) {
       debug(`Dataflow analysis failed: ${err.message}`);
     }
@@ -1348,6 +1406,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 +1444,11 @@ 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.wasmPreMs != null && { wasmPreMs: +_t.wasmPreMs.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/complexity.js

@@ -1769,9 +1769,6 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
         );
         analyzed++;
       }
-
-      // Release cached tree for GC
-      symbols._tree = null;
     }
   });