@optave/codegraph 3.0.3 → 3.0.4

package/README.md

@@ -555,14 +555,14 @@ Self-measured on every release via CI ([build benchmarks](generated/benchmarks/B
 
 | Metric | Latest |
 |---|---|
-| Build speed (native) | **11.5 ms/file** |
-| Build speed (WASM) | **17.8 ms/file** |
+| Build speed (native) | **12.3 ms/file** |
+| Build speed (WASM) | **16.3 ms/file** |
 | Query time | **3ms** |
 | No-op rebuild (native) | **5ms** |
-| 1-file rebuild (native) | **384ms** |
+| 1-file rebuild (native) | **375ms** |
 | Query: fn-deps | **0.8ms** |
 | Query: path | **0.8ms** |
-| ~50,000 files (est.) | **~575.0s build** |
+| ~50,000 files (est.) | **~615.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.3",
+  "version": "3.0.4",
   "description": "Local code graph CLI — parse codebases with tree-sitter, build dependency graphs, query them",
   "type": "module",
   "main": "src/index.js",
@@ -71,10 +71,13 @@
   },
   "optionalDependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@optave/codegraph-darwin-arm64": "3.0.3",
-    "@optave/codegraph-darwin-x64": "3.0.3",
-    "@optave/codegraph-linux-x64-gnu": "3.0.3",
-    "@optave/codegraph-win32-x64-msvc": "3.0.3"
+    "@optave/codegraph-darwin-arm64": "3.0.4",
+    "@optave/codegraph-darwin-x64": "3.0.4",
+    "@optave/codegraph-linux-arm64-gnu": "3.0.4",
+    "@optave/codegraph-linux-arm64-musl": "3.0.4",
+    "@optave/codegraph-linux-x64-gnu": "3.0.4",
+    "@optave/codegraph-linux-x64-musl": "3.0.4",
+    "@optave/codegraph-win32-x64-msvc": "3.0.4"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",

package/src/ast.js

@@ -197,33 +197,33 @@ 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)) {
-      if (symbols._tree) {
-        // WASM path: walk the tree-sitter AST
+    // 2. Non-call AST nodes (new, throw, await, string, regex)
+    if (symbols.astNodes?.length) {
+      // Native path: use pre-extracted AST nodes from Rust (all languages)
+      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;
+        }
+        allRows.push({
+          file: relPath,
+          line: n.line,
+          kind: n.kind,
+          name: n.name,
+          text: n.text || null,
+          receiver: n.receiver || null,
+          parentNodeId,
+        });
+      }
+    } else {
+      // WASM fallback: walk the tree-sitter AST (JS/TS/TSX only)
+      const ext = path.extname(relPath).toLowerCase();
+      if (WALK_EXTENSIONS.has(ext) && symbols._tree) {
         const astRows = [];
         walkAst(symbols._tree.rootNode, defs, relPath, astRows, nodeIdMap);
         allRows.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;
-          }
-          allRows.push({
-            file: relPath,
-            line: n.line,
-            kind: n.kind,
-            name: n.name,
-            text: n.text || null,
-            receiver: n.receiver || null,
-            parentNodeId,
-          });
-        }
       }
     }
   }

package/src/builder.js

@@ -444,7 +444,7 @@ export async function buildGraph(rootDir, opts = {}) {
     opts.incremental !== false && config.build && config.build.incremental !== false;
 
   // Engine selection: 'native', 'wasm', or 'auto' (default)
-  const engineOpts = { engine: opts.engine || 'auto' };
+  const engineOpts = { engine: opts.engine || 'auto', dataflow: opts.dataflow !== false };
   const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
   info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
 
@@ -548,7 +548,11 @@ export async function buildGraph(rootDir, opts = {}) {
 
     if (needsCfg || needsDataflow) {
       info('No file changes. Running pending analysis pass...');
-      const analysisSymbols = await parseFilesAuto(files, rootDir, engineOpts);
+      const analysisOpts = {
+        ...engineOpts,
+        dataflow: needsDataflow && opts.dataflow !== false,
+      };
+      const analysisSymbols = await parseFilesAuto(files, rootDir, analysisOpts);
       if (needsCfg) {
         const { buildCFGData } = await import('./cfg.js');
         await buildCFGData(db, analysisSymbols, rootDir, engineOpts);
@@ -1317,16 +1321,47 @@ export async function buildGraph(rootDir, opts = {}) {
   _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
+  // 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) {
-    _t.wasmPre0 = performance.now();
-    try {
-      const { ensureWasmTrees } = await import('./parser.js');
-      await ensureWasmTrees(astComplexitySymbols, rootDir);
-    } catch (err) {
-      debug(`WASM pre-parse failed: ${err.message}`);
+    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;
+      }
+    }
+
+    if (needsWasmTrees) {
+      _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;
+    } else {
+      _t.wasmPreMs = 0;
     }
-    _t.wasmPreMs = performance.now() - _t.wasmPre0;
   }
 
   // CFG analysis (skip with --no-cfg)

package/src/cfg.js

@@ -1053,8 +1053,14 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
     if (!symbols._tree) {
       const ext = path.extname(relPath).toLowerCase();
       if (CFG_EXTENSIONS.has(ext)) {
-        needsFallback = true;
-        break;
+        // Check if all function/method defs already have native CFG data
+        const hasNativeCfg = symbols.definitions
+          .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
+          .every((d) => d.cfg === null || d.cfg?.blocks?.length);
+        if (!hasNativeCfg) {
+          needsFallback = true;
+          break;
+        }
       }
     }
   }
@@ -1102,8 +1108,13 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
       let tree = symbols._tree;
       let langId = symbols._langId;
 
-      // WASM fallback if no cached tree
-      if (!tree) {
+      // Check if all defs already have native CFG — skip WASM parse if so
+      const allNative = symbols.definitions
+        .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
+        .every((d) => d.cfg === null || d.cfg?.blocks?.length);
+
+      // WASM fallback if no cached tree and not all native
+      if (!tree && !allNative) {
         if (!extToLang || !getParserFn) continue;
         langId = extToLang.get(ext);
         if (!langId || !CFG_LANG_IDS.has(langId)) continue;
@@ -1135,7 +1146,7 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
       if (!cfgRules) continue;
 
       const complexityRules = COMPLEXITY_RULES.get(langId);
-      if (!complexityRules) continue;
+      // complexityRules only needed for WASM fallback path
 
       for (const def of symbols.definitions) {
         if (def.kind !== 'function' && def.kind !== 'method') continue;
@@ -1144,11 +1155,19 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
         const row = getNodeId.get(def.name, relPath, def.line);
         if (!row) continue;
 
-        const funcNode = findFunctionNode(tree.rootNode, def.line, def.endLine, complexityRules);
-        if (!funcNode) continue;
+        // Native path: use pre-computed CFG from Rust engine
+        let cfg = null;
+        if (def.cfg?.blocks?.length) {
+          cfg = def.cfg;
+        } else {
+          // WASM fallback: compute CFG from tree-sitter AST
+          if (!tree || !complexityRules) continue;
+          const funcNode = findFunctionNode(tree.rootNode, def.line, def.endLine, complexityRules);
+          if (!funcNode) continue;
+          cfg = buildFunctionCFG(funcNode, langId);
+        }
 
-        const cfg = buildFunctionCFG(funcNode, langId);
-        if (cfg.blocks.length === 0) continue;
+        if (!cfg || cfg.blocks.length === 0) continue;
 
         // Clear old CFG data for this function
         deleteEdges.run(row.id);

package/src/dataflow.js

@@ -1009,7 +1009,7 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
   let needsFallback = false;
 
   for (const [relPath, symbols] of fileSymbols) {
-    if (!symbols._tree) {
+    if (!symbols._tree && !symbols.dataflow) {
       const ext = path.extname(relPath).toLowerCase();
       if (DATAFLOW_EXTENSIONS.has(ext)) {
         needsFallback = true;
@@ -1061,41 +1061,45 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
       const ext = path.extname(relPath).toLowerCase();
       if (!DATAFLOW_EXTENSIONS.has(ext)) continue;
 
-      let tree = symbols._tree;
-      let langId = symbols._langId;
+      // Use native dataflow data if available — skip WASM extraction
+      let data = symbols.dataflow;
+      if (!data) {
+        let tree = symbols._tree;
+        let langId = symbols._langId;
+
+        // WASM fallback if no cached tree
+        if (!tree) {
+          if (!extToLang || !getParserFn) continue;
+          langId = extToLang.get(ext);
+          if (!langId || !DATAFLOW_LANG_IDS.has(langId)) continue;
+
+          const absPath = path.join(rootDir, relPath);
+          let code;
+          try {
+            code = fs.readFileSync(absPath, 'utf-8');
+          } catch {
+            continue;
+          }
 
-      // WASM fallback if no cached tree
-      if (!tree) {
-        if (!extToLang || !getParserFn) continue;
-        langId = extToLang.get(ext);
-        if (!langId || !DATAFLOW_LANG_IDS.has(langId)) continue;
+          const parser = getParserFn(parsers, absPath);
+          if (!parser) continue;
 
-        const absPath = path.join(rootDir, relPath);
-        let code;
-        try {
-          code = fs.readFileSync(absPath, 'utf-8');
-        } catch {
-          continue;
+          try {
+            tree = parser.parse(code);
+          } catch {
+            continue;
+          }
         }
 
-        const parser = getParserFn(parsers, absPath);
-        if (!parser) continue;
-
-        try {
-          tree = parser.parse(code);
-        } catch {
-          continue;
+        if (!langId) {
+          langId = extToLang ? extToLang.get(ext) : null;
+          if (!langId) continue;
         }
-      }
-
-      if (!langId) {
-        langId = extToLang ? extToLang.get(ext) : null;
-        if (!langId) continue;
-      }
 
-      if (!DATAFLOW_RULES.has(langId)) continue;
+        if (!DATAFLOW_RULES.has(langId)) continue;
 
-      const data = extractDataflow(tree, relPath, symbols.definitions, langId);
+        data = extractDataflow(tree, relPath, symbols.definitions, langId);
+      }
 
       // Resolve function names to node IDs in this file first, then globally
       function resolveNode(funcName) {

package/src/native.js

@@ -12,9 +12,27 @@ import os from 'node:os';
 let _cached; // undefined = not yet tried, null = failed, object = module
 let _loadError = null;
 
-/** Map of (platform-arch) → npm package name. */
+/**
+ * Detect whether the current Linux environment uses glibc or musl.
+ * Returns 'gnu' for glibc, 'musl' for musl, 'gnu' as fallback.
+ */
+function detectLibc() {
+  try {
+    const { readdirSync } = require('node:fs');
+    const files = readdirSync('/lib');
+    if (files.some((f) => f.startsWith('ld-musl-') && f.endsWith('.so.1'))) {
+      return 'musl';
+    }
+  } catch {}
+  return 'gnu';
+}
+
+/** Map of (platform-arch[-libc]) → npm package name. */
 const PLATFORM_PACKAGES = {
-  'linux-x64': '@optave/codegraph-linux-x64-gnu',
+  'linux-x64-gnu': '@optave/codegraph-linux-x64-gnu',
+  'linux-x64-musl': '@optave/codegraph-linux-x64-musl',
+  'linux-arm64-gnu': '@optave/codegraph-linux-arm64-gnu',
+  'linux-arm64-musl': '@optave/codegraph-linux-arm64-musl', // not yet published — placeholder for future CI target
   'darwin-arm64': '@optave/codegraph-darwin-arm64',
   'darwin-x64': '@optave/codegraph-darwin-x64',
   'win32-x64': '@optave/codegraph-win32-x64-msvc',
@@ -29,7 +47,9 @@ export function loadNative() {
 
   const require = createRequire(import.meta.url);
 
-  const key = `${os.platform()}-${os.arch()}`;
+  const platform = os.platform();
+  const arch = os.arch();
+  const key = platform === 'linux' ? `${platform}-${arch}-${detectLibc()}` : `${platform}-${arch}`;
   const pkg = PLATFORM_PACKAGES[key];
   if (pkg) {
     try {

package/src/parser.js

@@ -205,6 +205,22 @@ function normalizeNativeSymbols(result) {
             maintainabilityIndex: d.complexity.maintainabilityIndex ?? null,
           }
         : null,
+      cfg: d.cfg?.blocks?.length
+        ? {
+            blocks: d.cfg.blocks.map((b) => ({
+              index: b.index,
+              type: b.type,
+              startLine: b.startLine,
+              endLine: b.endLine,
+              label: b.label ?? null,
+            })),
+            edges: d.cfg.edges.map((e) => ({
+              sourceIndex: e.sourceIndex,
+              targetIndex: e.targetIndex,
+              kind: e.kind,
+            })),
+          }
+        : null,
       children: d.children?.length
         ? d.children.map((c) => ({
             name: c.name,
@@ -253,6 +269,46 @@ function normalizeNativeSymbols(result) {
       text: n.text ?? null,
       receiver: n.receiver ?? null,
     })),
+    dataflow: result.dataflow
+      ? {
+          parameters: (result.dataflow.parameters || []).map((p) => ({
+            funcName: p.funcName,
+            paramName: p.paramName,
+            paramIndex: p.paramIndex,
+            line: p.line,
+          })),
+          returns: (result.dataflow.returns || []).map((r) => ({
+            funcName: r.funcName,
+            expression: r.expression ?? '',
+            referencedNames: r.referencedNames ?? [],
+            line: r.line,
+          })),
+          assignments: (result.dataflow.assignments || []).map((a) => ({
+            varName: a.varName,
+            callerFunc: a.callerFunc ?? null,
+            sourceCallName: a.sourceCallName,
+            expression: a.expression ?? '',
+            line: a.line,
+          })),
+          argFlows: (result.dataflow.argFlows ?? []).map((f) => ({
+            callerFunc: f.callerFunc ?? null,
+            calleeName: f.calleeName,
+            argIndex: f.argIndex,
+            argName: f.argName ?? null,
+            binding: f.bindingType ? { type: f.bindingType } : null,
+            confidence: f.confidence,
+            expression: f.expression ?? '',
+            line: f.line,
+          })),
+          mutations: (result.dataflow.mutations || []).map((m) => ({
+            funcName: m.funcName ?? null,
+            receiverName: m.receiverName,
+            binding: m.bindingType ? { type: m.bindingType } : null,
+            mutatingExpr: m.mutatingExpr,
+            line: m.line,
+          })),
+        }
+      : null,
   };
 }
 
@@ -384,7 +440,7 @@ export async function parseFileAuto(filePath, source, opts = {}) {
   const { native } = resolveEngine(opts);
 
   if (native) {
-    const result = native.parseFile(filePath, source);
+    const result = native.parseFile(filePath, source, !!opts.dataflow);
     return result ? normalizeNativeSymbols(result) : null;
   }
 
@@ -407,7 +463,7 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
   const result = new Map();
 
   if (native) {
-    const nativeResults = native.parseFiles(filePaths, rootDir);
+    const nativeResults = native.parseFiles(filePaths, rootDir, !!opts.dataflow);
     for (const r of nativeResults) {
       if (!r) continue;
       const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');