Claude finished @carlos-alm's task —— View job

PR Review: Batch 2 Language Support

Reviewing this PR that adds 6 new language parsers (Elixir, Lua, Dart, Zig, Haskell, OCaml) following the comprehensive review framework.

Review Progress

• Phase 1: Root Cause Analysis
• Phase 2: Configuration Change Detection
• Phase 3: Test Integrity Check
• Phase 4: Code Quality Review
• Phase 5: Backlog Compliance Assessment
• Final Assessment and Rating

Phase 1: Root Cause Analysis ✅

Problem Being Solved: Expanding language support from ROADMAP Phase 7 to meet growing demand for multi-language codebases. This adds 6 carefully selected languages (Elixir, Lua, Dart, Zig, Haskell, OCaml) that complement existing coverage and address specific ecosystem needs.

Why This Approach: Follows established dual-engine pattern with both WASM TypeScript extractors and native Rust extractors. Maintains architecture consistency with existing language implementations.

Risk Assessment: Low risk - purely additive functionality following proven patterns. All new parsers are non-required (gracefully degrade if WASM unavailable). Comprehensive test coverage included.

Phase 2: Configuration Change Detection ✅

✅ No High-Risk Configuration Changes Detected

• No Biome/linting rule relaxation - only existing any[] usage follows established patterns
• No test timeout increases or coverage threshold changes
• No build configuration or module resolution changes
• No TypeScript strict mode flag modifications
• Only additions to devDependencies (tree-sitter grammars) and Cargo.toml (new language crates)

Phase 3: Test Integrity Check ✅

✅ Strong Test Coverage for New Languages

• 6 new test files added (one per language): elixir.test.ts, lua.test.ts, dart.test.ts, zig.test.ts, haskell.test.ts, ocaml.test.ts
• 34 total tests across new languages covering core extraction patterns
• Each test file follows established pattern: module/function/class extraction, imports, calls
• No weakened assertions - all tests use proper expect().toContainEqual() assertions
• Tests validate both symbol extraction and kind classification correctly

Phase 4: Code Quality Review ✅

✅ Excellent Implementation Quality

Architecture Consistency:

• All 6 languages correctly added to LANGUAGE_REGISTRY with required: false (graceful degradation)
• Dual extractors: TypeScript in src/extractors/ (169-304 LOC each) + Rust in crates/codegraph-core/src/extractors/
• New Cargo dependencies: 6 tree-sitter crates added (elixir, lua, dart, zig, haskell, ocaml)
• Follows existing patterns perfectly - no architectural divergence

Code Quality:

• No TODOs/FIXMEs/HACKs in new code - production-ready implementations
• Consistent error handling and node traversal patterns
• Appropriate symbol kind mappings (e.g., Elixir protocols → interface, Dart mixins → class)
• Clean separation of concerns: parsing, symbol extraction, type mapping

Phase 5: Backlog Compliance Assessment ✅

Backlog Compliance

• Zero-dep: ✅ — No new runtime dependencies. Only adds tree-sitter grammar devDependencies for build-time WASM generation
• Foundation-aligned: ✅ — Fully aligned with all 8 core principles. Maintains single registry (P6), preserves dual-engine architecture (P2), zero-cost core (P4)
• Problem-fit: 4 — Significantly improves agent accuracy by expanding language coverage from 17 to 23 languages. Directly reduces "unsupported language" gaps that force agents to work blind
• Breaking: No — Purely additive. All new languages are required: false with graceful degradation
• Tier: 1 — Zero-dep ✅ + Foundation-aligned ✅

Critical Concerns

None identified. This is a textbook implementation of the established language addition pattern.

Final Recommendation

• Rating: ⭐⭐⭐⭐☆ (4/5)
• Action: APPROVE
• Reasoning: High-quality implementation that follows all established patterns. Comprehensive test coverage, dual-engine consistency, graceful degradation, and zero architectural debt. The only reason this isn't 5/5 is that language additions, while valuable, don't break new architectural ground — they execute a proven pattern excellently.

This PR successfully delivers 6 new language parsers with production-ready quality and zero architectural compromise. Strongly recommend approval.

Greptile Summary

This PR completes Phase 7 Batch 2 of the language support roadmap by adding Elixir, Lua, Dart, Zig, Haskell, and OCaml — bringing the project from 17 to 23 supported languages. Each language ships with a dual-engine extractor (WASM TypeScript + native Rust), AST configs, and parser tests, following the established pattern from Batch 1.

The implementation is thorough and well-structured. Key language-specific design decisions are handled correctly: Elixir's generic call AST nodes are dispatched by keyword text; Zig's anonymous structs are named from their enclosing variable_declaration; Haskell's grammar typo (type_synomym) is correctly matched in both engines; OCaml's let_binding double-emission risk is guarded; Dart's method de-duplication via isInsideDartClass works correctly.

One P1 issue found:

• OCaml .mli interface files are parsed with the wrong grammar (LANGUAGE_OCAML / grammars/ocaml) in both the Rust native engine (parser_registry.rs) and the WASM engine (parser.ts + build-wasm.ts). OCaml interface files require LANGUAGE_OCAML_INTERFACE / grammars/ocaml_interface. Using the wrong grammar produces an error-filled AST, causing all definitions, calls, and imports to be silently missed for .mli files. There are no .mli tests, so this went undetected.

One P2 note:

• handleLuaVariableDecl in src/extractors/lua.ts contains dead code: it looks for an assignment_statement child inside a variable_declaration, but these are sibling statement types in tree-sitter-lua (not parent-child). The require() detection path there never fires; it works correctly only because handleLuaFunctionCall intercepts the function_call node via the recursive walk.

Confidence Score: 4/5

Safe to merge after fixing the OCaml .mli grammar mismatch — all other extractors are correct and well-tested.

One P1 bug: OCaml .mli files are parsed with the wrong tree-sitter grammar in both engines, producing silently empty extraction results. This affects a real registered file type. All other five languages look correct. The P2 dead-code note in the Lua extractor does not affect behavior.

crates/codegraph-core/src/parser_registry.rs, src/domain/parser.ts, and scripts/build-wasm.ts for the OCaml interface grammar issue.

Important Files Changed

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[Source File] -->|extension lookup| B{LanguageKind}
    B -->|.ex/.exs| C[Elixir]
    B -->|.lua| D[Lua]
    B -->|.dart| E[Dart]
    B -->|.zig| F[Zig]
    B -->|.hs| G[Haskell]
    B -->|.ml/.mli| H[Ocaml ⚠️]

    C --> I{Engine}
    D --> I
    E --> I
    F --> I
    G --> I
    H --> I

    I -->|WASM| J[TS Extractor\nsrc/extractors/*.ts]
    I -->|Native| K[Rust Extractor\ncrates/codegraph-core/src/extractors/*.rs]

    J --> L[ExtractorOutput\ndefinitions / calls / imports / classes]
    K --> L

    H -.->|.mli uses LANGUAGE_OCAML\nshould use LANGUAGE_OCAML_INTERFACE| M[❌ Parse errors on .mli]

_{Reviews (3): Last reviewed commit: "fix(elixir): remove dead visibility vari..." | Re-trigger Greptile}

Addressing all Greptile review comments

P1 — Elixir WASM currentModule never propagated (f47be65)
Fixed in src/extractors/elixir.ts. walkElixirNode now detects defmodule call nodes and updates nextModule before recursing into children. Functions inside modules now get qualified names (e.g. Greeter.greet), matching the native Rust engine. Test assertion strengthened to verify qualified name.

P1 — Zig WASM duplicate struct method emission (0f7c637)
Fixed in src/extractors/zig.ts. Added isInsideZigContainer() guard to handleZigFunction — if the node is inside a struct_declaration or union_declaration, it returns early since extractZigContainerMethods already emits qualified method definitions.

P2 — is_pub computed but never used in zig.rs (0f7c637)
Removed the dead is_pub call from handle_zig_function in the Rust extractor. The Definition struct lacks a visibility field, so the value couldn't be wired through. Added #[allow(dead_code)] + TODO on the helper function for when the struct gains visibility support.

P2 — README/ROADMAP/CHANGELOG language counts (441fcd1)

• CHANGELOG v3.6.0 entry now references Batch 2 languages (Elixir, Lua, Dart, Zig, Haskell, OCaml) and total of 23
• README comparison table: 17 → 23
• README feature descriptions: all "17 languages" → "23 languages" (5 occurrences)
• README multi-language list: added Elixir, Lua, Dart, Zig, Haskell, OCaml
• ROADMAP Phase 7 summary: updated to reflect Batch 1+2 shipped, 11 remaining in 2 batches

CI failure (incremental-parity test): Resolved by merging main into the branch — the test relied on a CFG fix that landed on main after this branch diverged.

@greptileai review

Addressing remaining Greptile findings from summary review

1. elixir.rs — dead visibility variable (line 94)
Fixed in 67b8200. Removed the unused visibility binding. The Definition struct has no visibility field, so the value could never be stored. Left a comment documenting the intended wiring for when the struct gains that field.

2. elixir.rs — engine parity gap in handle_defmodule (children: None)
Fixed in 67b8200. Added collect_module_children() that walks the module's do_block, collects def/defp child functions, and populates children via opt_children() — matching the TS extractor's collectModuleMembers behavior.

3. parser_registry.rs — .mli files mapped to wrong OCaml grammar
Tracked as follow-up issue #720. This requires adding a new OcamlInterface variant to the LanguageKind enum, building a separate WASM grammar from grammars/interface, and potentially adapting the extractor for interface-specific node types. The scope is too large for this PR (which is purely additive language support), and .mli files are uncommon enough that the impact is low. The issue has full implementation details.

4. Cargo.lock — missing batch-2 tree-sitter deps
Also fixed in 67b8200. The Cargo.lock was not updated when the new tree-sitter crates (elixir, lua, dart, zig, haskell, ocaml) were added to Cargo.toml.

CI note: The incremental-parity test failure (preserves CFG blocks for changed file) is a pre-existing issue on main, not introduced by this PR. It is being addressed separately in PR #719.

@greptileai review