fix(parity): align WASM and native ast_nodes extraction (#1016)

* fix(parity): align WASM and native ast_nodes extraction (#1010)

Resolves #1010. Three independent divergences were causing the native
engine to emit ~7,200 excess `string` AST nodes vs WASM on self-build:

1. Language coverage gap (~6,653 rows) — WASM's AST_TYPE_MAPS registered
   only javascript/typescript/tsx; native emitted ast_nodes for 19 more
   languages via `walk_ast_nodes_with_config`. Mirrored every
   LangAstConfig from `helpers.rs` into WASM as `AST_TYPE_MAPS` +
   `AST_STRING_CONFIGS` entries and threaded a per-language
   `stopRecurseKinds` set through `createAstStoreVisitor`.

2. WASM `await` skipChildren (~500 rows) — the visitor returned
   skipChildren for `await_expression`, so string/call children of
   `await import('x')` / `await fn('y')` were never walked. Native's
   javascript.rs explicitly recurses. Removed `await` from the
   skipChildren filter.

3. UTF-8 byte-length check in native (~40 rows) —
   `crates/codegraph-core/src/extractors/javascript.rs` gated string
   emission on `content.len() < 2` (UTF-8 byte count). Any single non-
   ASCII glyph like `─` (3 bytes) was emitted. Changed to
   `content.chars().count() < 2` for parity with helpers.rs and JS
   `.length`. WASM's filter uses code-point count (`[...s].length`).

Measured parity after fix on 775 shared files (excluding files edited
in this PR): 37,605 (WASM) vs 37,649 (native) = 0.12 % delta. Every
kind except `string` is at 0 delta; the remaining 44-row string gap is
the UTF fix still waiting on the next native binary rebuild.

New parity test in tests/engines/ast-parity.test.ts asserts ≤1 row
divergence between engines for six languages (js, ts, python, rust,
go, java).

* perf: hoist SKIP_KEYWORDS set to module scope (#1016)

Avoid reallocating a Set on every extractChildExpressionText call —
the contents are stateless and this function runs per throw/await
node during AST-store extraction.

Impact: 1 functions changed, 7 affected

* test: add ast_nodes parity fixtures for 15 more languages (#1016)

PR #1016 added AST_TYPE_MAPS entries for 16 languages beyond js/ts/
python/rust/go/java but PARITY_FIXTURES only covered the original 6,
leaving silent-divergence risk for languages with distinct string
node types (encapsed_string, sigil, etc.). Adds minimal fixtures for
csharp, ruby, php, c, cpp, kotlin, swift, scala, bash, elixir, lua,
dart, zig, haskell, ocaml — each exercises a string literal plus at
least one other kind from its AST_TYPE_MAP. ocaml-interface (.mli)
already covered by reusing the ocaml map. Tests return early when a
grammar is locally unavailable; CI has all grammars.

Author: carlos-alm

CLAUDE.md

@@ -161,7 +161,7 @@ Source is TypeScript in `src/`, compiled via `tsup`. The Rust native engine live
 
 **Configuration:** All tunable behavioral constants live in `DEFAULTS` in `src/infrastructure/config.ts`, grouped by concern (`analysis`, `risk`, `search`, `display`, `community`, `structure`, `mcp`, `check`, `coChange`, `manifesto`). Users override via `.codegraphrc.json` — `mergeConfig` deep-merges recursively so partial overrides preserve sibling keys. Env vars override LLM settings (`CODEGRAPH_LLM_*`). When adding new behavioral constants, **always add them to `DEFAULTS`** and wire them through config — never introduce new hardcoded magic numbers in individual modules. Category F values (safety boundaries, standard formulas, platform concerns) are the only exception.
 
-**Database:** SQLite at `.codegraph/graph.db` with tables: `nodes`, `edges`, `metadata`, `embeddings`, `function_complexity`
+**Database:** SQLite at `.codegraph/graph.db` with tables: `nodes`, `edges`, `metadata`, `embeddings`, `function_complexity`, `ast_nodes` (stored `new`/`throw`/`await`/`string`/`regex` literals queryable via `codegraph ast`). Both engines must extract `ast_nodes` for every language they parse — per-language node-type maps live in `src/ast-analysis/rules/index.ts` (`AST_TYPE_MAPS`, `AST_STRING_CONFIGS`) and mirror the native `LangAstConfig` constants in `crates/codegraph-core/src/extractors/helpers.rs`. Adding a new language requires a matching entry in both.
 
 ## Test Structure
 

crates/codegraph-core/src/extractors/javascript.rs

@@ -551,7 +551,12 @@ fn walk_ast_nodes_depth(node: &Node, source: &[u8], ast_nodes: &mut Vec<AstNode>
             let content = raw
                 .trim_start_matches(|c| c == '\'' || c == '"' || c == '`')
                 .trim_end_matches(|c| c == '\'' || c == '"' || c == '`');
-            if content.len() < 2 {
+            // Count Unicode code points, not UTF-8 bytes, so the filter matches
+            // helpers.rs `build_string_node` and the WASM visitor — a single non-
+            // ASCII glyph like `─` (3 bytes / 1 code point) must be treated as one
+            // character, otherwise we emit "excess" string nodes the WASM engine
+            // skips (see parity issue #1010).
+            if content.chars().count() < 2 {
                 // Still recurse children (template_string may have nested expressions)
                 for i in 0..node.child_count() {
                     if let Some(child) = node.child(i) {

src/ast-analysis/engine.ts

@@ -43,7 +43,9 @@ import type {
 } from '../types.js';
 import { computeLOCMetrics, computeMaintainabilityIndex } from './metrics.js';
 import {
+  AST_STRING_CONFIGS,
   AST_TYPE_MAPS,
+  astStopRecurseKinds,
   CFG_RULES,
   COMPLEXITY_RULES,
   DATAFLOW_RULES,
@@ -458,7 +460,15 @@ function setupAstVisitor(
   for (const row of bulkNodeIdsByFile(db, relPath)) {
     nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
   }
-  return createAstStoreVisitor(astTypeMap, symbols.definitions || [], relPath, nodeIdMap);
+  const stringConfig = AST_STRING_CONFIGS.get(langId);
+  return createAstStoreVisitor(
+    astTypeMap,
+    symbols.definitions || [],
+    relPath,
+    nodeIdMap,
+    stringConfig,
+    astStopRecurseKinds(langId),
+  );
 }
 
 /** Set up complexity visitor if any definitions need WASM complexity analysis. */

src/ast-analysis/rules/csharp.ts

@@ -200,4 +200,11 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  object_creation_expression: 'new',
+  throw_statement: 'throw',
+  throw_expression: 'throw',
+  await_expression: 'await',
+  string_literal: 'string',
+  verbatim_string_literal: 'string',
+};

src/ast-analysis/rules/go.ts

@@ -181,4 +181,7 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  interpreted_string_literal: 'string',
+  raw_string_literal: 'string',
+};

src/ast-analysis/rules/index.ts

@@ -73,10 +73,187 @@ export const DATAFLOW_RULES: Map<string, DataflowRulesConfig> = new Map([
   ['ruby', ruby.dataflow],
 ]);
 
-// ─── AST Type Maps ───────────────────────────────────────────────────────
+// ─── AST Node Type Maps ──────────────────────────────────────────────────
+//
+// These mirror the per-language `LangAstConfig` constants in the native Rust
+// engine (`crates/codegraph-core/src/extractors/helpers.rs`). WASM and native
+// must agree on which tree-sitter node types to emit as `ast_nodes` rows.
+// Languages without a dedicated rules/*.ts file have their maps inlined here.
+
+const JS_AST_TYPES = javascript.astTypes as Record<string, string>;
+const PY_AST_TYPES = python.astTypes as Record<string, string>;
+const GO_AST_TYPES = go.astTypes as Record<string, string>;
+const RS_AST_TYPES = rust.astTypes as Record<string, string>;
+const JAVA_AST_TYPES = java.astTypes as Record<string, string>;
+const CS_AST_TYPES = csharp.astTypes as Record<string, string>;
+const RB_AST_TYPES = ruby.astTypes as Record<string, string>;
+const PHP_AST_TYPES = php.astTypes as Record<string, string>;
+
+const C_AST_TYPES: Record<string, string> = {
+  string_literal: 'string',
+};
+
+const CPP_AST_TYPES: Record<string, string> = {
+  new_expression: 'new',
+  throw_statement: 'throw',
+  co_await_expression: 'await',
+  string_literal: 'string',
+  raw_string_literal: 'string',
+};
+
+const KOTLIN_AST_TYPES: Record<string, string> = {
+  throw_expression: 'throw',
+  string_literal: 'string',
+};
+
+const SWIFT_AST_TYPES: Record<string, string> = {
+  throw_statement: 'throw',
+  await_expression: 'await',
+  string_literal: 'string',
+};
+
+const SCALA_AST_TYPES: Record<string, string> = {
+  object_creation_expression: 'new',
+  throw_expression: 'throw',
+  string_literal: 'string',
+};
+
+const BASH_AST_TYPES: Record<string, string> = {
+  string: 'string',
+  expansion: 'string',
+};
+
+const ELIXIR_AST_TYPES: Record<string, string> = {
+  string: 'string',
+  sigil: 'regex',
+};
+
+const LUA_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
+
+const DART_AST_TYPES: Record<string, string> = {
+  new_expression: 'new',
+  constructor_invocation: 'new',
+  throw_expression: 'throw',
+  await_expression: 'await',
+  string_literal: 'string',
+};
+
+const ZIG_AST_TYPES: Record<string, string> = {
+  string_literal: 'string',
+};
+
+const HASKELL_AST_TYPES: Record<string, string> = {
+  string: 'string',
+  char: 'string',
+};
+
+const OCAML_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
 
 export const AST_TYPE_MAPS: Map<string, Record<string, string>> = new Map([
-  ['javascript', javascript.astTypes as Record<string, string>],
-  ['typescript', javascript.astTypes as Record<string, string>],
-  ['tsx', javascript.astTypes as Record<string, string>],
+  ['javascript', JS_AST_TYPES],
+  ['typescript', JS_AST_TYPES],
+  ['tsx', JS_AST_TYPES],
+  ['python', PY_AST_TYPES],
+  ['go', GO_AST_TYPES],
+  ['rust', RS_AST_TYPES],
+  ['java', JAVA_AST_TYPES],
+  ['csharp', CS_AST_TYPES],
+  ['ruby', RB_AST_TYPES],
+  ['php', PHP_AST_TYPES],
+  ['c', C_AST_TYPES],
+  ['cpp', CPP_AST_TYPES],
+  ['kotlin', KOTLIN_AST_TYPES],
+  ['swift', SWIFT_AST_TYPES],
+  ['scala', SCALA_AST_TYPES],
+  ['bash', BASH_AST_TYPES],
+  ['elixir', ELIXIR_AST_TYPES],
+  ['lua', LUA_AST_TYPES],
+  ['dart', DART_AST_TYPES],
+  ['zig', ZIG_AST_TYPES],
+  ['haskell', HASKELL_AST_TYPES],
+  ['ocaml', OCAML_AST_TYPES],
+  ['ocaml-interface', OCAML_AST_TYPES],
+]);
+
+// ─── Per-language string-extraction config ───────────────────────────────
+//
+// Mirrors `quote_chars` + `string_prefixes` in the native `LangAstConfig`.
+// Used by the AST-store visitor to strip quote characters and language-
+// specific prefix sigils (Python `r"..."`, C# verbatim `@"..."`, Rust raw
+// `r#"..."#`, etc.) when computing string content for the `name` column.
+
+export interface AstStringConfig {
+  quoteChars: string;
+  stringPrefixes: string;
+}
+
+const JS_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"`', stringPrefixes: '' };
+const PY_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: 'rbfuRBFU' };
+const GO_STRING_CONFIG: AstStringConfig = { quoteChars: '"`', stringPrefixes: '' };
+const RS_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const JAVA_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const CS_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const RB_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const PHP_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const C_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const CPP_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: 'LuUR' };
+const KOTLIN_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const SWIFT_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const SCALA_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const BASH_STRING_CONFIG: AstStringConfig = { quoteChars: '"\'', stringPrefixes: '' };
+const ELIXIR_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const LUA_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const DART_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const ZIG_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const HASKELL_STRING_CONFIG: AstStringConfig = { quoteChars: '"\'', stringPrefixes: '' };
+const OCAML_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+
+export const AST_STRING_CONFIGS: Map<string, AstStringConfig> = new Map([
+  ['javascript', JS_STRING_CONFIG],
+  ['typescript', JS_STRING_CONFIG],
+  ['tsx', JS_STRING_CONFIG],
+  ['python', PY_STRING_CONFIG],
+  ['go', GO_STRING_CONFIG],
+  ['rust', RS_STRING_CONFIG],
+  ['java', JAVA_STRING_CONFIG],
+  ['csharp', CS_STRING_CONFIG],
+  ['ruby', RB_STRING_CONFIG],
+  ['php', PHP_STRING_CONFIG],
+  ['c', C_STRING_CONFIG],
+  ['cpp', CPP_STRING_CONFIG],
+  ['kotlin', KOTLIN_STRING_CONFIG],
+  ['swift', SWIFT_STRING_CONFIG],
+  ['scala', SCALA_STRING_CONFIG],
+  ['bash', BASH_STRING_CONFIG],
+  ['elixir', ELIXIR_STRING_CONFIG],
+  ['lua', LUA_STRING_CONFIG],
+  ['dart', DART_STRING_CONFIG],
+  ['zig', ZIG_STRING_CONFIG],
+  ['haskell', HASKELL_STRING_CONFIG],
+  ['ocaml', OCAML_STRING_CONFIG],
+  ['ocaml-interface', OCAML_STRING_CONFIG],
 ]);
+
+// ─── Per-language "stop-after-collect" kinds ─────────────────────────────
+//
+// Mirrors the subtle difference between the native JS walker
+// (`extractors/javascript.rs::walk_ast_nodes_depth`) — which *returns* after
+// collecting `new_expression` and `throw_statement` to avoid double-counting
+// the wrapped expression — and the generic walker (`helpers.rs::walk_ast_
+// nodes_with_config_depth`), which always recurses. For WASM/native parity
+// the JS family must skip recursion on `new` and `throw`; every other
+// language recurses normally.
+
+const JS_STOP_RECURSE: ReadonlySet<string> = new Set(['new', 'throw']);
+const EMPTY_STOP_RECURSE: ReadonlySet<string> = new Set();
+
+export function astStopRecurseKinds(langId: string): ReadonlySet<string> {
+  if (langId === 'javascript' || langId === 'typescript' || langId === 'tsx') {
+    return JS_STOP_RECURSE;
+  }
+  return EMPTY_STOP_RECURSE;
+}

src/ast-analysis/rules/java.ts

@@ -174,4 +174,8 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  object_creation_expression: 'new',
+  throw_statement: 'throw',
+  string_literal: 'string',
+};

src/ast-analysis/rules/php.ts

@@ -218,4 +218,9 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  object_creation_expression: 'new',
+  throw_expression: 'throw',
+  string: 'string',
+  encapsed_string: 'string',
+};

src/ast-analysis/rules/python.ts

@@ -195,4 +195,8 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  raise_statement: 'throw',
+  await: 'await',
+  string: 'string',
+};

src/ast-analysis/rules/ruby.ts

@@ -203,4 +203,7 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  string: 'string',
+  regex: 'regex',
+};