@optave/codegraph 3.4.1 → 3.6.0

package/src/ast-analysis/engine.ts

@@ -102,11 +102,12 @@ async function ensureWasmTreesIfNeeded(
   opts: AnalysisOpts,
   rootDir: string,
 ): Promise<void> {
+  const doAst = opts.ast !== false;
   const doComplexity = opts.complexity !== false;
   const doCfg = opts.cfg !== false;
   const doDataflow = opts.dataflow !== false;
 
-  if (!doComplexity && !doCfg && !doDataflow) return;
+  if (!doAst && !doComplexity && !doCfg && !doDataflow) return;
 
   let needsWasmTrees = false;
   for (const [relPath, symbols] of fileSymbols) {
@@ -131,6 +132,8 @@ async function ensureWasmTreesIfNeeded(
       d.endLine > d.line &&
       !d.name.includes('.');
 
+    // AST: need tree when native didn't provide non-call astNodes
+    const needsAst = doAst && !Array.isArray(symbols.astNodes) && WALK_EXTENSIONS.has(ext);
     const needsComplexity =
       doComplexity &&
       COMPLEXITY_EXTENSIONS.has(ext) &&
@@ -141,7 +144,7 @@ async function ensureWasmTreesIfNeeded(
       defs.some((d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks));
     const needsDataflow = doDataflow && !symbols.dataflow && DATAFLOW_EXTENSIONS.has(ext);
 
-    if (needsComplexity || needsCfg || needsDataflow) {
+    if (needsAst || needsComplexity || needsCfg || needsDataflow) {
       needsWasmTrees = true;
       break;
     }
@@ -159,6 +162,80 @@ async function ensureWasmTreesIfNeeded(
 
 // ─── Per-file visitor setup ─────────────────────────────────────────────
 
+/** Check if a definition has a real function body (not a type signature). */
+function hasFuncBody(d: {
+  name: string;
+  kind: string;
+  line: number;
+  endLine?: number | null;
+}): boolean {
+  return (
+    (d.kind === 'function' || d.kind === 'method') &&
+    d.line > 0 &&
+    d.endLine != null &&
+    d.endLine > d.line &&
+    !d.name.includes('.')
+  );
+}
+
+/** Set up AST-store visitor if applicable. */
+function setupAstVisitor(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: ExtractorOutput,
+  langId: string,
+  ext: string,
+): Visitor | null {
+  const astTypeMap = AST_TYPE_MAPS.get(langId);
+  if (!astTypeMap || !WALK_EXTENSIONS.has(ext) || Array.isArray(symbols.astNodes)) return null;
+  const nodeIdMap = new Map<string, number>();
+  for (const row of bulkNodeIdsByFile(db, relPath)) {
+    nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+  }
+  return createAstStoreVisitor(astTypeMap, symbols.definitions || [], relPath, nodeIdMap);
+}
+
+/** Set up complexity visitor if any definitions need WASM complexity analysis. */
+function setupComplexityVisitorForFile(
+  defs: Definition[],
+  langId: string,
+  walkerOpts: WalkOptions,
+): Visitor | null {
+  const cRules = COMPLEXITY_RULES.get(langId);
+  if (!cRules) return null;
+
+  const hRules = HALSTEAD_RULES.get(langId);
+  const needsWasmComplexity = defs.some((d) => hasFuncBody(d) && !d.complexity);
+  if (!needsWasmComplexity) return null;
+
+  const visitor = createComplexityVisitor(cRules, hRules, { fileLevelWalk: true, langId });
+
+  for (const t of cRules.nestingNodes) walkerOpts.nestingNodeTypes?.add(t);
+
+  const dfRules = DATAFLOW_RULES.get(langId);
+  walkerOpts.getFunctionName = (node: TreeSitterNode): string | null => {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode) return nameNode.text;
+    if (dfRules) return getFuncName(node, dfRules as any);
+    return null;
+  };
+
+  return visitor;
+}
+
+/** Set up CFG visitor if any definitions need WASM CFG analysis. */
+function setupCfgVisitorForFile(defs: Definition[], langId: string, ext: string): Visitor | null {
+  const cfgRulesForLang = CFG_RULES.get(langId);
+  if (!cfgRulesForLang || !CFG_EXTENSIONS.has(ext)) return null;
+
+  const needsWasmCfg = defs.some(
+    (d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks),
+  );
+  if (!needsWasmCfg) return null;
+
+  return createCfgVisitor(cfgRulesForLang);
+}
+
 function setupVisitors(
   db: BetterSqlite3Database,
   relPath: string,
@@ -168,10 +245,6 @@ function setupVisitors(
 ): SetupResult {
   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;
 
   const visitors: Visitor[] = [];
   const walkerOpts: WalkOptions = {
@@ -180,75 +253,19 @@ function setupVisitors(
     getFunctionName: (_node: TreeSitterNode) => null,
   };
 
-  // AST-store visitor
-  let astVisitor: Visitor | null = null;
-  const astTypeMap = AST_TYPE_MAPS.get(langId);
-  if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !Array.isArray(symbols.astNodes)) {
-    const nodeIdMap = new Map<string, number>();
-    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);
-  }
+  const astVisitor = opts.ast !== false ? setupAstVisitor(db, relPath, symbols, langId, ext) : null;
+  if (astVisitor) visitors.push(astVisitor);
 
-  // Complexity visitor (file-level mode)
-  let complexityVisitor: Visitor | null = null;
-  const cRules = COMPLEXITY_RULES.get(langId);
-  const hRules = HALSTEAD_RULES.get(langId);
-  if (doComplexity && cRules) {
-    // Only trigger WASM complexity for definitions with real function bodies.
-    // Interface/type property signatures (dotted names, single-line span)
-    // correctly lack native complexity data and should not trigger a fallback.
-    const needsWasmComplexity = defs.some(
-      (d) =>
-        (d.kind === 'function' || d.kind === 'method') &&
-        d.line > 0 &&
-        d.endLine != null &&
-        d.endLine > d.line &&
-        !d.name.includes('.') &&
-        !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: TreeSitterNode): string | null => {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) return nameNode.text;
-        if (dfRules) return getFuncName(node, dfRules as any);
-        return null;
-      };
-    }
-  }
+  const complexityVisitor =
+    opts.complexity !== false ? setupComplexityVisitorForFile(defs, langId, walkerOpts) : null;
+  if (complexityVisitor) visitors.push(complexityVisitor);
 
-  // CFG visitor
-  let cfgVisitor: Visitor | null = 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 > 0 &&
-        d.endLine != null &&
-        d.endLine > d.line &&
-        !d.name.includes('.') &&
-        d.cfg !== null &&
-        !Array.isArray(d.cfg?.blocks),
-    );
-    if (needsWasmCfg) {
-      cfgVisitor = createCfgVisitor(cfgRulesForLang);
-      visitors.push(cfgVisitor);
-    }
-  }
+  const cfgVisitor = opts.cfg !== false ? setupCfgVisitorForFile(defs, langId, ext) : null;
+  if (cfgVisitor) visitors.push(cfgVisitor);
 
-  // Dataflow visitor
   let dataflowVisitor: Visitor | null = null;
   const dfRules = DATAFLOW_RULES.get(langId);
-  if (doDataflow && dfRules && DATAFLOW_EXTENSIONS.has(ext) && !symbols.dataflow) {
+  if (opts.dataflow !== false && dfRules && DATAFLOW_EXTENSIONS.has(ext) && !symbols.dataflow) {
     dataflowVisitor = createDataflowVisitor(dfRules);
     visitors.push(dataflowVisitor);
   }
@@ -258,88 +275,80 @@ function setupVisitors(
 
 // ─── Result storage helpers ─────────────────────────────────────────────
 
-function storeComplexityResults(results: WalkResults, defs: Definition[], langId: string): void {
-  const complexityResults = (results.complexity || []) as ComplexityFuncResult[];
-  const resultByLine = new Map<number, ComplexityFuncResult[]>();
-  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);
-    }
+/** Index per-function results by start line for O(1) lookup. */
+function indexByLine<T extends { funcNode: TreeSitterNode }>(results: T[]): Map<number, T[]> {
+  const byLine = new Map<number, T[]>();
+  for (const r of results) {
+    if (!r.funcNode) continue;
+    const line = r.funcNode.startPosition.row + 1;
+    if (!byLine.has(line)) byLine.set(line, []);
+    byLine.get(line)?.push(r);
   }
+  return byLine;
+}
+
+/** Find the best matching result for a definition by line + name. */
+function matchResultToDef<T extends { funcNode: TreeSitterNode }>(
+  candidates: T[] | undefined,
+  defName: string,
+): T | undefined {
+  if (!candidates) return undefined;
+  if (candidates.length === 1) return candidates[0];
+  return (
+    candidates.find((r) => {
+      const n = r.funcNode.childForFieldName('name');
+      return n && n.text === defName;
+    }) ?? candidates[0]
+  );
+}
+
+function storeComplexityResults(results: WalkResults, defs: Definition[], langId: string): void {
+  const byLine = indexByLine((results.complexity || []) as ComplexityFuncResult[]);
   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,
-        };
-      }
+      const funcResult = matchResultToDef(byLine.get(def.line), def.name);
+      if (!funcResult) continue;
+      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,
+      };
     }
   }
 }
 
 function storeCfgResults(results: WalkResults, defs: Definition[]): void {
-  const cfgResults = (results.cfg || []) as CfgFuncResult[];
-  const cfgByLine = new Map<number, CfgFuncResult[]>();
-  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);
-    }
-  }
+  const byLine = indexByLine((results.cfg || []) as CfgFuncResult[]);
   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.loc > 0 ? loc.commentLines / loc.loc : 0;
-          def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
-            volume,
-            cfgResult.cyclomatic,
-            loc?.sloc ?? 0,
-            commentRatio,
-          );
-        }
+      const cfgResult = matchResultToDef(byLine.get(def.line), def.name);
+      if (!cfgResult) continue;
+      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.loc > 0 ? loc.commentLines / loc.loc : 0;
+        def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
+          volume,
+          cfgResult.cyclomatic,
+          loc?.sloc ?? 0,
+          commentRatio,
+        );
       }
     }
   }

package/src/ast-analysis/rules/javascript.ts

@@ -237,6 +237,7 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
 export const astTypes: Record<string, string> | null = {
+  call_expression: 'call',
   new_expression: 'new',
   throw_statement: 'throw',
   await_expression: 'await',

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -14,7 +14,7 @@ interface AstStoreRow {
   kind: string;
   name: string | null | undefined;
   text: string | null;
-  receiver: null;
+  receiver: string | null;
   parentNodeId: number | null;
 }
 
@@ -44,6 +44,22 @@ function extractExpressionText(node: TreeSitterNode): string | null {
   return truncate(node.text);
 }
 
+function extractCallName(node: TreeSitterNode): string {
+  for (const field of ['function', 'method', 'name']) {
+    const fn = node.childForFieldName(field);
+    if (fn) return fn.text;
+  }
+  return node.text?.split('(')[0] || '?';
+}
+
+/** Extract receiver for call expressions (e.g. "obj" in "obj.method()"). */
+function extractCallReceiver(node: TreeSitterNode): string | null {
+  const fn = node.childForFieldName('function');
+  if (!fn || fn.type !== 'member_expression') return null;
+  const obj = fn.childForFieldName('object');
+  return obj ? obj.text : null;
+}
+
 function extractName(kind: string, node: TreeSitterNode): string | null {
   if (kind === 'throw') {
     for (let i = 0; i < node.childCount; i++) {
@@ -102,49 +118,115 @@ export function createAstStoreVisitor(
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
   }
 
+  /** Recursively walk a subtree collecting AST nodes — used for arguments-only traversal. */
+  function walkSubtree(node: TreeSitterNode | null): void {
+    if (!node) return;
+    if (matched.has(node.id)) return;
+
+    const kind = astTypeMap[node.type];
+    if (kind === 'call') {
+      // Capture this call and recurse only into its arguments
+      collectNode(node, kind);
+      walkCallArguments(node);
+      return;
+    }
+    if (kind) {
+      collectNode(node, kind);
+      if (kind !== 'string' && kind !== 'regex') return; // skipChildren for non-leaf kinds
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      walkSubtree(node.child(i));
+    }
+  }
+
+  /**
+   * Recurse into only the arguments of a call node — mirrors the native engine's
+   * strategy that prevents double-counting nested calls in the function field
+   * (e.g. chained calls like `a().b()`).
+   */
+  function walkCallArguments(callNode: TreeSitterNode): void {
+    // Try field-based lookup first, fall back to kind-based matching
+    const argsNode =
+      callNode.childForFieldName('arguments') ??
+      findChildByKind(callNode, ['arguments', 'argument_list', 'method_arguments']);
+    if (!argsNode) return;
+    for (let i = 0; i < argsNode.childCount; i++) {
+      walkSubtree(argsNode.child(i));
+    }
+  }
+
+  function findChildByKind(node: TreeSitterNode, kinds: string[]): TreeSitterNode | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && kinds.includes(child.type)) return child;
+    }
+    return null;
+  }
+
+  function collectNode(node: TreeSitterNode, kind: string): void {
+    if (matched.has(node.id)) return;
+
+    const line = node.startPosition.row + 1;
+    let name: string | null | undefined;
+    let text: string | null = null;
+    let receiver: string | null = null;
+
+    if (kind === 'call') {
+      name = extractCallName(node);
+      text = truncate(node.text);
+      receiver = extractCallReceiver(node);
+    } else if (kind === 'new') {
+      name = extractNewName(node);
+      text = truncate(node.text);
+    } else if (kind === 'throw') {
+      name = extractName('throw', node);
+      text = extractExpressionText(node);
+    } else if (kind === 'await') {
+      name = extractName('await', node);
+      text = extractExpressionText(node);
+    } else if (kind === 'string') {
+      const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
+      if (content.length < 2) return;
+      name = truncate(content, 100);
+      text = truncate(node.text);
+    } else if (kind === 'regex') {
+      name = node.text || '?';
+      text = truncate(node.text);
+    }
+
+    rows.push({
+      file: relPath,
+      line,
+      kind,
+      name,
+      text,
+      receiver,
+      parentNodeId: resolveParentNodeId(line),
+    });
+
+    matched.add(node.id);
+  }
+
   return {
     name: 'ast-store',
 
     enterNode(node: TreeSitterNode, _context: VisitorContext): EnterNodeResult | undefined {
+      // Guard: skip re-collection but do NOT skipChildren — node.id (memory address)
+      // can be reused by tree-sitter, so a collision would incorrectly suppress an
+      // unrelated subtree. The parent call's skipChildren handles the intended case.
       if (matched.has(node.id)) return;
 
       const kind = astTypeMap[node.type];
       if (!kind) return;
 
-      const line = node.startPosition.row + 1;
-      let name: string | null | undefined;
-      let text: string | null = null;
-
-      if (kind === 'new') {
-        name = extractNewName(node);
-        text = truncate(node.text);
-      } else if (kind === 'throw') {
-        name = extractName('throw', node);
-        text = extractExpressionText(node);
-      } else if (kind === 'await') {
-        name = extractName('await', node);
-        text = extractExpressionText(node);
-      } else if (kind === 'string') {
-        const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-        if (content.length < 2) return;
-        name = truncate(content, 100);
-        text = truncate(node.text);
-      } else if (kind === 'regex') {
-        name = node.text || '?';
-        text = truncate(node.text);
-      }
+      collectNode(node, kind);
 
-      rows.push({
-        file: relPath,
-        line,
-        kind,
-        name,
-        text,
-        receiver: null,
-        parentNodeId: resolveParentNodeId(line),
-      });
-
-      matched.add(node.id);
+      if (kind === 'call') {
+        // Mirror native: skip full subtree, recurse only into arguments.
+        // Prevents double-counting chained calls like service.getUser().getName().
+        walkCallArguments(node);
+        return { skipChildren: true };
+      }
 
       if (kind !== 'string' && kind !== 'regex') {
         return { skipChildren: true };

package/src/ast-analysis/visitors/complexity-visitor.ts

@@ -87,6 +87,16 @@ function classifyBranchNode(
   }
 }
 
+function classifyLogicalOp(node: TreeSitterNode, cRules: AnyRules, acc: ComplexityAcc): void {
+  const op = node.child(1)?.type;
+  if (!op || !cRules.logicalOperators.has(op)) return;
+  acc.cyclomatic++;
+  const parent = node.parent;
+  const sameSequence =
+    parent != null && parent.type === cRules.logicalNodeType && parent.child(1)?.type === op;
+  if (!sameSequence) acc.cognitive++;
+}
+
 function classifyPlainElse(
   node: TreeSitterNode,
   type: string,
@@ -215,17 +225,7 @@ export function createComplexityVisitor(
       if (nestingLevel > acc.maxNesting) acc.maxNesting = nestingLevel;
 
       if (type === cRules.logicalNodeType) {
-        const op = node.child(1)?.type;
-        if (op && cRules.logicalOperators.has(op)) {
-          acc.cyclomatic++;
-          const parent = node.parent;
-          let sameSequence = false;
-          if (parent && parent.type === cRules.logicalNodeType) {
-            const parentOp = parent.child(1)?.type;
-            if (parentOp === op) sameSequence = true;
-          }
-          if (!sameSequence) acc.cognitive++;
-        }
+        classifyLogicalOp(node, cRules, acc);
       }
 
       if (type === cRules.optionalChainType) acc.cyclomatic++;

package/src/db/better-sqlite3.ts

@@ -0,0 +1,20 @@
+/**
+ * Lazy-loaded better-sqlite3 constructor.
+ *
+ * Centralises the `createRequire` + cache pattern so every call site that
+ * needs a JS-side SQLite handle can `import { getDatabase } from '…/db/better-sqlite3.js'`
+ * instead of duplicating the boilerplate.  The native engine path (NativeDatabase /
+ * rusqlite) never touches this module.
+ */
+import { createRequire } from 'node:module';
+
+const _require = createRequire(import.meta.url);
+let _Database: any;
+
+/** Return the `better-sqlite3` Database constructor, loading it on first call. */
+export function getDatabase(): new (...args: any[]) => any {
+  if (!_Database) {
+    _Database = _require('better-sqlite3');
+  }
+  return _Database;
+}