@optave/codegraph 3.1.5 → 3.3.0

package/src/ast-analysis/engine.js

@@ -50,294 +50,227 @@ async function getParserModule() {
   return _parserModule;
 }
 
-// ─── Public API ──────────────────────────────────────────────────────────
+// ─── WASM pre-parse ─────────────────────────────────────────────────────
 
-/**
- * Run all enabled AST analyses in a coordinated pass.
- *
- * @param {object} db - open better-sqlite3 database (read-write)
- * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, calls, _tree, _langId, ... }>
- * @param {string} rootDir - absolute project root path
- * @param {object} opts - build options (ast, complexity, cfg, dataflow toggles)
- * @param {object} [engineOpts] - engine options
- * @returns {Promise<{ astMs: number, complexityMs: number, cfgMs: number, dataflowMs: number }>}
- */
-export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
-  const timing = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
-
-  const doAst = opts.ast !== false;
+async function ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir) {
   const doComplexity = opts.complexity !== false;
   const doCfg = opts.cfg !== false;
   const doDataflow = opts.dataflow !== false;
 
-  if (!doAst && !doComplexity && !doCfg && !doDataflow) return timing;
-
-  const extToLang = buildExtToLangMap();
-
-  // ── WASM pre-parse for files that need it ───────────────────────────
-  // The native engine only handles parsing (symbols, calls, imports).
-  // Complexity, CFG, and dataflow all require a WASM tree-sitter tree
-  // for their visitor walks. Without this, incremental rebuilds on the
-  // native engine silently lose these analyses for changed files (#468).
-  if (doComplexity || doCfg || doDataflow) {
-    let needsWasmTrees = false;
-    for (const [relPath, symbols] of fileSymbols) {
-      if (symbols._tree) continue;
-      const ext = path.extname(relPath).toLowerCase();
-      const defs = symbols.definitions || [];
-
-      const needsComplexity =
-        doComplexity &&
-        COMPLEXITY_EXTENSIONS.has(ext) &&
-        defs.some((d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity);
-      const needsCfg =
-        doCfg &&
-        CFG_EXTENSIONS.has(ext) &&
-        defs.some(
-          (d) =>
-            (d.kind === 'function' || d.kind === 'method') &&
-            d.line &&
-            d.cfg !== null &&
-            !Array.isArray(d.cfg?.blocks),
-        );
-      const needsDataflow = doDataflow && !symbols.dataflow && DATAFLOW_EXTENSIONS.has(ext);
-
-      if (needsComplexity || needsCfg || needsDataflow) {
-        needsWasmTrees = true;
-        break;
-      }
-    }
-
-    if (needsWasmTrees) {
-      try {
-        const { ensureWasmTrees } = await getParserModule();
-        await ensureWasmTrees(fileSymbols, rootDir);
-      } catch (err) {
-        debug(`ensureWasmTrees failed: ${err.message}`);
-      }
-    }
-  }
-
-  // ── Phase 7 Optimization: Unified pre-walk ─────────────────────────
-  // For files with WASM trees, run all applicable visitors in a SINGLE
-  // walkWithVisitors call. Store results in the format that buildXxx
-  // functions already expect as pre-computed data (same fields as native
-  // engine output). This eliminates ~3 redundant tree traversals per file.
-  const t0walk = performance.now();
+  if (!doComplexity && !doCfg && !doDataflow) return;
 
+  let needsWasmTrees = false;
   for (const [relPath, symbols] of fileSymbols) {
-    if (!symbols._tree) continue; // No WASM tree — native path handles it
-
+    if (symbols._tree) continue;
     const ext = path.extname(relPath).toLowerCase();
-    const langId = symbols._langId || extToLang.get(ext);
-    if (!langId) continue;
-
     const defs = symbols.definitions || [];
-    const visitors = [];
-    const walkerOpts = {
-      functionNodeTypes: new Set(),
-      nestingNodeTypes: new Set(),
-      getFunctionName: (_node) => null,
-    };
-
-    // ─ AST-store visitor ─
-    const astTypeMap = AST_TYPE_MAPS.get(langId);
-    let astVisitor = null;
-    if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !symbols.astNodes?.length) {
-      const nodeIdMap = new Map();
-      for (const row of bulkNodeIdsByFile(db, relPath)) {
-        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
-      }
-      astVisitor = createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap);
-      visitors.push(astVisitor);
-    }
 
-    // ─ Complexity visitor (file-level mode) ─
-    const cRules = COMPLEXITY_RULES.get(langId);
-    const hRules = HALSTEAD_RULES.get(langId);
-    let complexityVisitor = null;
-    if (doComplexity && cRules) {
-      // Only use visitor if some functions lack pre-computed complexity
-      const needsWasmComplexity = defs.some(
-        (d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity,
-      );
-      if (needsWasmComplexity) {
-        complexityVisitor = createComplexityVisitor(cRules, hRules, {
-          fileLevelWalk: true,
-          langId,
-        });
-        visitors.push(complexityVisitor);
-
-        // Merge nesting nodes for complexity tracking
-        // NOTE: do NOT add functionNodes here — funcDepth in the complexity
-        // visitor already tracks function-level nesting.  Adding them to
-        // nestingNodeTypes would inflate context.nestingLevel by +1 inside
-        // every function body, double-counting in cognitive += 1 + nestingLevel.
-        for (const t of cRules.nestingNodes) walkerOpts.nestingNodeTypes.add(t);
-
-        // Provide getFunctionName for complexity visitor
-        const dfRules = DATAFLOW_RULES.get(langId);
-        walkerOpts.getFunctionName = (node) => {
-          // Try complexity rules' function name field first
-          const nameNode = node.childForFieldName('name');
-          if (nameNode) return nameNode.text;
-          // Fall back to dataflow rules' richer name extraction
-          if (dfRules) return getFuncName(node, dfRules);
-          return null;
-        };
-      }
-    }
-
-    // ─ CFG visitor ─
-    const cfgRulesForLang = CFG_RULES.get(langId);
-    let cfgVisitor = null;
-    if (doCfg && cfgRulesForLang && CFG_EXTENSIONS.has(ext)) {
-      // Only use visitor if some functions lack pre-computed CFG
-      const needsWasmCfg = defs.some(
+    const needsComplexity =
+      doComplexity &&
+      COMPLEXITY_EXTENSIONS.has(ext) &&
+      defs.some((d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity);
+    const needsCfg =
+      doCfg &&
+      CFG_EXTENSIONS.has(ext) &&
+      defs.some(
         (d) =>
           (d.kind === 'function' || d.kind === 'method') &&
           d.line &&
           d.cfg !== null &&
           !Array.isArray(d.cfg?.blocks),
       );
-      if (needsWasmCfg) {
-        cfgVisitor = createCfgVisitor(cfgRulesForLang);
-        visitors.push(cfgVisitor);
-      }
+    const needsDataflow = doDataflow && !symbols.dataflow && DATAFLOW_EXTENSIONS.has(ext);
+
+    if (needsComplexity || needsCfg || needsDataflow) {
+      needsWasmTrees = true;
+      break;
     }
+  }
 
-    // ─ Dataflow visitor ─
-    const dfRules = DATAFLOW_RULES.get(langId);
-    let dataflowVisitor = null;
-    if (doDataflow && dfRules && DATAFLOW_EXTENSIONS.has(ext) && !symbols.dataflow) {
-      dataflowVisitor = createDataflowVisitor(dfRules);
-      visitors.push(dataflowVisitor);
+  if (needsWasmTrees) {
+    try {
+      const { ensureWasmTrees } = await getParserModule();
+      await ensureWasmTrees(fileSymbols, rootDir);
+    } catch (err) {
+      debug(`ensureWasmTrees failed: ${err.message}`);
     }
+  }
+}
 
-    // ─ Run unified walk if we have visitors ─
-    if (visitors.length === 0) continue;
+// ─── Per-file visitor setup ─────────────────────────────────────────────
 
-    const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
+function setupVisitors(db, relPath, symbols, langId, opts) {
+  const ext = path.extname(relPath).toLowerCase();
+  const defs = symbols.definitions || [];
+  const doAst = opts.ast !== false;
+  const doComplexity = opts.complexity !== false;
+  const doCfg = opts.cfg !== false;
+  const doDataflow = opts.dataflow !== false;
 
-    // ─ Store AST results (buildAstNodes will find symbols.astNodes and skip its walk) ─
-    if (astVisitor) {
-      const astRows = results['ast-store'] || [];
-      if (astRows.length > 0) {
-        // Store in the format buildAstNodes expects for the native path
-        symbols.astNodes = astRows;
-      }
+  const visitors = [];
+  const walkerOpts = {
+    functionNodeTypes: new Set(),
+    nestingNodeTypes: new Set(),
+    getFunctionName: (_node) => null,
+  };
+
+  // AST-store visitor
+  let astVisitor = null;
+  const astTypeMap = AST_TYPE_MAPS.get(langId);
+  if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !symbols.astNodes?.length) {
+    const nodeIdMap = new Map();
+    for (const row of bulkNodeIdsByFile(db, relPath)) {
+      nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
     }
+    astVisitor = createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap);
+    visitors.push(astVisitor);
+  }
 
-    // ─ Store complexity results on definitions (buildComplexityMetrics will find def.complexity) ─
-    if (complexityVisitor) {
-      const complexityResults = results.complexity || [];
-      // Match results back to definitions by function start line
-      // Store the full result (metrics + funcNode) for O(1) lookup
-      const resultByLine = new Map();
-      for (const r of complexityResults) {
-        if (r.funcNode) {
-          const line = r.funcNode.startPosition.row + 1;
-          if (!resultByLine.has(line)) resultByLine.set(line, []);
-          resultByLine.get(line).push(r);
-        }
-      }
-      for (const def of defs) {
-        if ((def.kind === 'function' || def.kind === 'method') && def.line && !def.complexity) {
-          const candidates = resultByLine.get(def.line);
-          const funcResult = !candidates
-            ? undefined
-            : candidates.length === 1
-              ? candidates[0]
-              : (candidates.find((r) => {
-                  const n = r.funcNode.childForFieldName('name');
-                  return n && n.text === def.name;
-                }) ?? candidates[0]);
-          if (funcResult) {
-            const { metrics } = funcResult;
-            const loc = computeLOCMetrics(funcResult.funcNode, langId);
-            const volume = metrics.halstead ? metrics.halstead.volume : 0;
-            const commentRatio = loc.loc > 0 ? loc.commentLines / loc.loc : 0;
-            const mi = computeMaintainabilityIndex(
-              volume,
-              metrics.cyclomatic,
-              loc.sloc,
-              commentRatio,
-            );
-
-            def.complexity = {
-              cognitive: metrics.cognitive,
-              cyclomatic: metrics.cyclomatic,
-              maxNesting: metrics.maxNesting,
-              halstead: metrics.halstead,
-              loc,
-              maintainabilityIndex: mi,
-            };
-          }
-        }
-      }
+  // Complexity visitor (file-level mode)
+  let complexityVisitor = null;
+  const cRules = COMPLEXITY_RULES.get(langId);
+  const hRules = HALSTEAD_RULES.get(langId);
+  if (doComplexity && cRules) {
+    const needsWasmComplexity = defs.some(
+      (d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity,
+    );
+    if (needsWasmComplexity) {
+      complexityVisitor = createComplexityVisitor(cRules, hRules, { fileLevelWalk: true, langId });
+      visitors.push(complexityVisitor);
+
+      for (const t of cRules.nestingNodes) walkerOpts.nestingNodeTypes.add(t);
+
+      const dfRules = DATAFLOW_RULES.get(langId);
+      walkerOpts.getFunctionName = (node) => {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) return nameNode.text;
+        if (dfRules) return getFuncName(node, dfRules);
+        return null;
+      };
     }
+  }
 
-    // ─ Store CFG results on definitions (buildCFGData will find def.cfg and skip its walk) ─
-    if (cfgVisitor) {
-      const cfgResults = results.cfg || [];
-      const cfgByLine = new Map();
-      for (const r of cfgResults) {
-        if (r.funcNode) {
-          const line = r.funcNode.startPosition.row + 1;
-          if (!cfgByLine.has(line)) cfgByLine.set(line, []);
-          cfgByLine.get(line).push(r);
-        }
-      }
-      for (const def of defs) {
-        if (
-          (def.kind === 'function' || def.kind === 'method') &&
-          def.line &&
-          !def.cfg?.blocks?.length
-        ) {
-          const candidates = cfgByLine.get(def.line);
-          const cfgResult = !candidates
-            ? undefined
-            : candidates.length === 1
-              ? candidates[0]
-              : (candidates.find((r) => {
-                  const n = r.funcNode.childForFieldName('name');
-                  return n && n.text === def.name;
-                }) ?? candidates[0]);
-          if (cfgResult) {
-            def.cfg = { blocks: cfgResult.blocks, edges: cfgResult.edges };
-
-            // Override complexity's cyclomatic with CFG-derived value (single source of truth)
-            // and recompute maintainability index to stay consistent
-            if (def.complexity && cfgResult.cyclomatic != null) {
-              def.complexity.cyclomatic = cfgResult.cyclomatic;
-              const { loc, halstead } = def.complexity;
-              const volume = halstead ? halstead.volume : 0;
-              const commentRatio = loc?.loc > 0 ? loc.commentLines / loc.loc : 0;
-              def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
-                volume,
-                cfgResult.cyclomatic,
-                loc?.sloc ?? 0,
-                commentRatio,
-              );
-            }
-          }
-        }
-      }
+  // CFG visitor
+  let cfgVisitor = null;
+  const cfgRulesForLang = CFG_RULES.get(langId);
+  if (doCfg && cfgRulesForLang && CFG_EXTENSIONS.has(ext)) {
+    const needsWasmCfg = defs.some(
+      (d) =>
+        (d.kind === 'function' || d.kind === 'method') &&
+        d.line &&
+        d.cfg !== null &&
+        !Array.isArray(d.cfg?.blocks),
+    );
+    if (needsWasmCfg) {
+      cfgVisitor = createCfgVisitor(cfgRulesForLang);
+      visitors.push(cfgVisitor);
     }
+  }
+
+  // Dataflow visitor
+  let dataflowVisitor = null;
+  const dfRules = DATAFLOW_RULES.get(langId);
+  if (doDataflow && dfRules && DATAFLOW_EXTENSIONS.has(ext) && !symbols.dataflow) {
+    dataflowVisitor = createDataflowVisitor(dfRules);
+    visitors.push(dataflowVisitor);
+  }
+
+  return { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor };
+}
 
-    // ─ Store dataflow results (buildDataflowEdges will find symbols.dataflow and skip its walk) ─
-    if (dataflowVisitor) {
-      symbols.dataflow = results.dataflow;
+// ─── Result storage helpers ─────────────────────────────────────────────
+
+function storeComplexityResults(results, defs, langId) {
+  const complexityResults = results.complexity || [];
+  const resultByLine = new Map();
+  for (const r of complexityResults) {
+    if (r.funcNode) {
+      const line = r.funcNode.startPosition.row + 1;
+      if (!resultByLine.has(line)) resultByLine.set(line, []);
+      resultByLine.get(line).push(r);
     }
   }
+  for (const def of defs) {
+    if ((def.kind === 'function' || def.kind === 'method') && def.line && !def.complexity) {
+      const candidates = resultByLine.get(def.line);
+      const funcResult = !candidates
+        ? undefined
+        : candidates.length === 1
+          ? candidates[0]
+          : (candidates.find((r) => {
+              const n = r.funcNode.childForFieldName('name');
+              return n && n.text === def.name;
+            }) ?? candidates[0]);
+      if (funcResult) {
+        const { metrics } = funcResult;
+        const loc = computeLOCMetrics(funcResult.funcNode, langId);
+        const volume = metrics.halstead ? metrics.halstead.volume : 0;
+        const commentRatio = loc.loc > 0 ? loc.commentLines / loc.loc : 0;
+        const mi = computeMaintainabilityIndex(volume, metrics.cyclomatic, loc.sloc, commentRatio);
+
+        def.complexity = {
+          cognitive: metrics.cognitive,
+          cyclomatic: metrics.cyclomatic,
+          maxNesting: metrics.maxNesting,
+          halstead: metrics.halstead,
+          loc,
+          maintainabilityIndex: mi,
+        };
+      }
+    }
+  }
+}
 
-  timing._unifiedWalkMs = performance.now() - t0walk;
+function storeCfgResults(results, defs) {
+  const cfgResults = results.cfg || [];
+  const cfgByLine = new Map();
+  for (const r of cfgResults) {
+    if (r.funcNode) {
+      const line = r.funcNode.startPosition.row + 1;
+      if (!cfgByLine.has(line)) cfgByLine.set(line, []);
+      cfgByLine.get(line).push(r);
+    }
+  }
+  for (const def of defs) {
+    if (
+      (def.kind === 'function' || def.kind === 'method') &&
+      def.line &&
+      !def.cfg?.blocks?.length
+    ) {
+      const candidates = cfgByLine.get(def.line);
+      const cfgResult = !candidates
+        ? undefined
+        : candidates.length === 1
+          ? candidates[0]
+          : (candidates.find((r) => {
+              const n = r.funcNode.childForFieldName('name');
+              return n && n.text === def.name;
+            }) ?? candidates[0]);
+      if (cfgResult) {
+        def.cfg = { blocks: cfgResult.blocks, edges: cfgResult.edges };
+
+        // Override complexity's cyclomatic with CFG-derived value (single source of truth)
+        if (def.complexity && cfgResult.cyclomatic != null) {
+          def.complexity.cyclomatic = cfgResult.cyclomatic;
+          const { loc, halstead } = def.complexity;
+          const volume = halstead ? halstead.volume : 0;
+          const commentRatio = loc?.loc > 0 ? loc.commentLines / loc.loc : 0;
+          def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
+            volume,
+            cfgResult.cyclomatic,
+            loc?.sloc ?? 0,
+            commentRatio,
+          );
+        }
+      }
+    }
+  }
+}
 
-  // ── Delegate to buildXxx functions ─────────────────────────────────
-  // Each function finds pre-computed data from the unified walk above
-  // (or from the native engine) and only does DB writes + native fallback.
+// ─── Build delegation ───────────────────────────────────────────────────
 
-  if (doAst) {
+async function delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing) {
+  if (opts.ast !== false) {
     const t0 = performance.now();
     try {
       const { buildAstNodes } = await import('../features/ast.js');
@@ -348,7 +281,7 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     timing.astMs = performance.now() - t0;
   }
 
-  if (doComplexity) {
+  if (opts.complexity !== false) {
     const t0 = performance.now();
     try {
       const { buildComplexityMetrics } = await import('../features/complexity.js');
@@ -359,7 +292,7 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     timing.complexityMs = performance.now() - t0;
   }
 
-  if (doCfg) {
+  if (opts.cfg !== false) {
     const t0 = performance.now();
     try {
       const { buildCFGData } = await import('../features/cfg.js');
@@ -370,7 +303,7 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     timing.cfgMs = performance.now() - t0;
   }
 
-  if (doDataflow) {
+  if (opts.dataflow !== false) {
     const t0 = performance.now();
     try {
       const { buildDataflowEdges } = await import('../features/dataflow.js');
@@ -380,6 +313,67 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     }
     timing.dataflowMs = performance.now() - t0;
   }
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────
+
+/**
+ * Run all enabled AST analyses in a coordinated pass.
+ *
+ * @param {object} db - open better-sqlite3 database (read-write)
+ * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, calls, _tree, _langId, ... }>
+ * @param {string} rootDir - absolute project root path
+ * @param {object} opts - build options (ast, complexity, cfg, dataflow toggles)
+ * @param {object} [engineOpts] - engine options
+ * @returns {Promise<{ astMs: number, complexityMs: number, cfgMs: number, dataflowMs: number }>}
+ */
+export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
+  const timing = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+
+  const doAst = opts.ast !== false;
+  const doComplexity = opts.complexity !== false;
+  const doCfg = opts.cfg !== false;
+  const doDataflow = opts.dataflow !== false;
+
+  if (!doAst && !doComplexity && !doCfg && !doDataflow) return timing;
+
+  const extToLang = buildExtToLangMap();
+
+  // WASM pre-parse for files that need it
+  await ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir);
+
+  // Unified pre-walk: run all applicable visitors in a single DFS per file
+  const t0walk = performance.now();
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (!symbols._tree) continue;
+
+    const ext = path.extname(relPath).toLowerCase();
+    const langId = symbols._langId || extToLang.get(ext);
+    if (!langId) continue;
+
+    const { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor } =
+      setupVisitors(db, relPath, symbols, langId, opts);
+
+    if (visitors.length === 0) continue;
+
+    const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
+    const defs = symbols.definitions || [];
+
+    if (astVisitor) {
+      const astRows = results['ast-store'] || [];
+      if (astRows.length > 0) symbols.astNodes = astRows;
+    }
+
+    if (complexityVisitor) storeComplexityResults(results, defs, langId);
+    if (cfgVisitor) storeCfgResults(results, defs);
+    if (dataflowVisitor) symbols.dataflow = results.dataflow;
+  }
+
+  timing._unifiedWalkMs = performance.now() - t0walk;
+
+  // Delegate to buildXxx functions for DB writes + native fallback
+  await delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing);
 
   return timing;
 }

package/src/ast-analysis/shared.js

@@ -176,18 +176,6 @@ export function findFunctionNode(rootNode, startLine, _endLine, rules) {
   return best;
 }
 
-/**
- * Truncate a string to a maximum length, appending an ellipsis if truncated.
- *
- * @param {string} str - Input string
- * @param {number} [max=200] - Maximum length
- * @returns {string}
- */
-export function truncate(str, max = 200) {
-  if (!str) return '';
-  return str.length > max ? `${str.slice(0, max)}…` : str;
-}
-
 // ─── Extension / Language Mapping ─────────────────────────────────────────
 
 /**