fix(parity): restore call AST node extraction in WASM engine (#705)

* refactor(extractors): add parser abstraction layer (Phase 7.1)

Extract shared patterns from 9 language extractors into 4 reusable
helpers in helpers.ts, reducing per-language boilerplate by ~30 lines:

- findParentNode: replaces 6 findParent*/findCurrentImpl functions
- extractBodyMembers: replaces 5 body-iteration patterns for enums/structs
- stripQuotes: replaces inline .replace(/"/g,'') across 3 extractors
- lastPathSegment: replaces inline .split('.').pop() across 6 extractors

Net: +77 helper lines, -159 extractor lines = -82 lines total.

* fix: address Greptile review comments (#700)

Add clarifying comment to empty self_parameter if-block in rust.ts
and document anchored-vs-global semantics in stripQuotes JSDoc.

* fix: revert subpath imports to relative imports in builder stages

* fix(parity): restore call AST node extraction in WASM engine (#697)

PR #686 incorrectly removed call_expression extraction from the WASM
ast-store-visitor and added filters to strip call nodes from native
output — documenting a parity gap as expected behavior rather than
fixing it. This restores full parity:

- Restore call_expression in JS astTypes map
- Restore call extraction logic in ast-store-visitor with receiver
  extraction, argument-only recursion, and dedup tracking
- Remove three call-kind filters (engine.ts, ast.ts bulk path, ast.ts
  JS fallback path) that stripped native call nodes
- Clear stale engineOpts.nativeDb reference after pipeline closes the
  NativeDatabase to prevent stages from using a closed connection
- Update ast-nodes test to assert calls ARE stored

* fix: make enterNode skipChildren guard unconditional for matched nodes (#705)

When enterNode encountered an already-matched node it returned undefined,
relying on the parent call's skipChildren to prevent redundant descent.
This was correct but fragile — a future change to walkCallArguments could
silently break the invariant. Now returns { skipChildren: true } explicitly.

* fix: pin exact call node count in ast-nodes test (#705)

Replace loose toBeGreaterThanOrEqual(1) with exact toBe(3) and verify
each expected call name (eval, result.set, console.log). The fixture
produces exactly 3 call nodes — fetch is captured as kind:await instead.
Pinning the count catches future parity regressions immediately.

* fix: revert enterNode skipChildren guard — node.id reuse causes false skips (#705)

Reverts the { skipChildren: true } guard for matched nodes. Tree-sitter
node.id is a memory address that can be reused across different nodes in
the same tree. Returning skipChildren on an ID collision suppresses an
unrelated subtree, breaking WASM ast_node extraction in the build-parity
test. The original undefined return is correct: it prevents re-collection
without suppressing children, and the parent call's skipChildren handles
the intended dedup case.

* ci: retry CI run (#705)

* fix: add diagnostic logging for ast_nodes parity failure (#705)

When native and WASM ast_node counts diverge, log both counts and the
distinct kinds present in each. This will reveal whether the CI-only
failure is caused by native extracting calls that WASM misses, or a
deeper issue with the WASM walker path.

* ci: add diagnostic logging to trace WASM ast_nodes CI failure (#705)

* ci: expand diagnostic logging to trace buildAstNodes path (#705)

* fix: coerce null receiver to empty string for NAPI compat (#705)

The prebuilt native binary (v3.5.0) expects `receiver` as `String`
(not `Option<String>`), so passing JS `null` from WASM-extracted
ast_nodes crashes the bulk insert with:
  Failed to convert JavaScript value `Null` into rust type `String`

Coerce `null`/`undefined` receiver to `""` before passing to the
native `bulkInsertAstNodes` path. This fixes the build-parity test
(native 19 vs WASM 0 ast_nodes) and the typed-method-call test.

* fix: remove parity-diag console.error logging (#705)

Remove temporary diagnostic logging added to trace the WASM ast_nodes
CI failure. The root cause (null receiver in NAPI bulk insert) is now
fixed, so these stderr diagnostics are no longer needed.

Author: carlos-alm

src/ast-analysis/engine.ts

@@ -427,17 +427,6 @@ export async function runAnalyses(
 
   if (!doAst && !doComplexity && !doCfg && !doDataflow) return timing;
 
-  // Strip dead 'call' kind from native astNodes upfront. Call AST nodes are no
-  // longer extracted by the WASM visitor; native binaries still emit them until
-  // the Rust extractors are updated (see #701). Clear the array when only calls
-  // remain so the WASM visitor runs and extracts non-call kinds.
-  for (const [, symbols] of fileSymbols) {
-    if (Array.isArray(symbols.astNodes)) {
-      const filtered = symbols.astNodes.filter((n) => n.kind !== 'call');
-      symbols.astNodes = filtered.length > 0 ? (filtered as typeof symbols.astNodes) : undefined;
-    }
-  }
-
   const extToLang = buildExtToLangMap();
 
   // WASM pre-parse for files that need it

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',

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++) {
@@ -82,6 +98,7 @@ export function createAstStoreVisitor(
   nodeIdMap: Map<string, number>,
 ): Visitor {
   const rows: AstStoreRow[] = [];
+  const matched = new Set<number>();
 
   function findParentDef(line: number): Definition | null {
     let best: Definition | null = null;
@@ -101,45 +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),
-      });
+      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 };

src/domain/graph/builder/pipeline.ts

@@ -185,6 +185,11 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
       /* ignore close errors */
     }
     ctx.nativeDb = undefined;
+    // Also clear stale reference in engineOpts to prevent stages from
+    // calling methods on the closed NativeDatabase.
+    if (ctx.engineOpts?.nativeDb) {
+      ctx.engineOpts.nativeDb = undefined;
+    }
   }
 
   await collectFiles(ctx);

src/domain/graph/builder/stages/build-edges.ts

@@ -6,9 +6,9 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { getNodeId } from '#db/index.js';
-import { debug } from '#infrastructure/logger.js';
-import { loadNative } from '#infrastructure/native.js';
+import { getNodeId } from '../../../../db/index.js';
+import { debug } from '../../../../infrastructure/logger.js';
+import { loadNative } from '../../../../infrastructure/native.js';
 import type {
   BetterSqlite3Database,
   Call,
@@ -18,7 +18,7 @@ import type {
   NativeAddon,
   NodeRow,
   TypeMapEntry,
-} from '#types';
+} from '../../../../types.js';
 import { computeConfidence } from '../../resolve.js';
 import type { PipelineContext } from '../context.js';
 import { BUILTIN_RECEIVERS, batchInsertEdges } from '../helpers.js';

src/domain/graph/builder/stages/build-structure.ts

@@ -5,9 +5,9 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { debug } from '#infrastructure/logger.js';
-import { normalizePath } from '#shared/constants.js';
-import type { ExtractorOutput } from '#types';
+import { debug } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
+import type { ExtractorOutput } from '../../../../types.js';
 import type { PipelineContext } from '../context.js';
 import { readFileSafe } from '../helpers.js';
 

src/domain/graph/builder/stages/collect-files.ts

@@ -7,8 +7,8 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { debug, info } from '#infrastructure/logger.js';
-import { normalizePath } from '#shared/constants.js';
+import { debug, info } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
 import { readJournal } from '../../journal.js';
 import type { PipelineContext } from '../context.js';
 import { collectFiles as collectFilesUtil } from '../helpers.js';

src/features/ast.ts

@@ -103,16 +103,14 @@ export async function buildAstNodes(
 
     for (const [relPath, symbols] of fileSymbols) {
       if (Array.isArray(symbols.astNodes)) {
-        // Filter out 'call' kind — dead AST node type, see JS fallback path comment.
-        const filtered = symbols.astNodes.filter((n) => n.kind !== 'call');
         batches.push({
           file: relPath,
-          nodes: filtered.map((n) => ({
+          nodes: symbols.astNodes.map((n) => ({
             line: n.line,
             kind: n.kind,
             name: n.name,
             text: n.text,
-            receiver: n.receiver,
+            receiver: n.receiver ?? '',
           })),
         });
       } else if (symbols.calls || symbols._tree) {
@@ -168,16 +166,9 @@ export async function buildAstNodes(
       nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
     }
 
-    // Call AST nodes were removed — 'call' kind entries in ast_nodes are dead
-    // (never queried by any feature or command). symbols.calls are still used
-    // for call *edges* but no longer written to ast_nodes.
-
     if (Array.isArray(symbols.astNodes)) {
-      // Native engine provided AST nodes (may be empty for files with no AST content).
-      // Filter out 'call' kind — call AST nodes are dead (never queried by any feature).
-      // The WASM visitor no longer extracts them; native binaries still emit them until
-      // the next Rust release strips them from the extractor.
-      for (const n of symbols.astNodes.filter((n) => n.kind !== 'call')) {
+      // Native engine provided AST nodes (may be empty for files with no AST content)
+      for (const n of symbols.astNodes) {
         const parentDef = findParentDef(defs, n.line);
         let parentNodeId: number | null = null;
         if (parentDef) {

tests/integration/build-parity.test.ts

@@ -114,6 +114,18 @@ describeOrSkip('Build parity: native vs WASM', () => {
   it('produces identical ast_nodes', () => {
     const wasmGraph = readGraph(path.join(wasmDir, '.codegraph', 'graph.db'));
     const nativeGraph = readGraph(path.join(nativeDir, '.codegraph', 'graph.db'));
+    // Diagnostic: log counts to help debug CI-only parity failures
+    if (nativeGraph.astNodes.length !== wasmGraph.astNodes.length) {
+      console.error(
+        `[parity-diag] native astNodes: ${nativeGraph.astNodes.length}, wasm astNodes: ${wasmGraph.astNodes.length}`,
+      );
+      console.error(
+        `[parity-diag] native kinds: ${JSON.stringify([...new Set((nativeGraph.astNodes as any[]).map((n: any) => n.kind))])}`,
+      );
+      console.error(
+        `[parity-diag] wasm kinds: ${JSON.stringify([...new Set((wasmGraph.astNodes as any[]).map((n: any) => n.kind))])}`,
+      );
+    }
     expect(nativeGraph.astNodes).toEqual(wasmGraph.astNodes);
   });
 });

tests/parsers/ast-nodes.test.ts

@@ -100,9 +100,15 @@ function queryAllAstNodes() {
 // ─── Tests ────────────────────────────────────────────────────────────
 
 describe('buildAstNodes — JS extraction', () => {
-  test('call kind AST nodes are no longer stored (dead code removed)', () => {
+  test('captures call_expression as kind:call', () => {
     const calls = queryAstNodes('call');
-    expect(calls.length).toBe(0);
+    // eval(input), result.set('data', data), console.log(result)
+    // Note: fetch('/api/data') is inside await — captured as kind:await, not kind:call
+    expect(calls.length).toBe(3);
+    const names = calls.map((n) => n.name);
+    expect(names).toContain('eval');
+    expect(names).toContain('result.set');
+    expect(names).toContain('console.log');
   });
 
   test('captures new_expression as kind:new', () => {