Dev build 3.12.1-dev.67

Dev build from commit 4d8f09e3d72a9ad87bcc376c715fb5185c2c86f0 on main.

Dev build 3.12.1-dev.66

Dev build from commit d3865ba2210fef7947da145cf25394162faf43b2 on main.

Dev build 3.12.1-dev.65

Dev build from commit 1b96f2411fca8059728b77c7dcebc260a8957b02 on main.

Dev build 3.12.1-dev.64

Dev build from commit 04d1e5c70cd141ffd7f787307cff3bc606c498da on main.

Dev build 3.12.1-dev.63

Dev build from commit aca4b46bfc0a167fde9f38911c9a426c3ceb2f1b on main.

v3.12.0

Phase 8 Analysis Depth lands in full, plus a 30-technique JavaScript/TypeScript resolution sweep. Sub-phases 8.1 through 8.6 are now complete, with 8.3 substantially complete (one stretch-goal item — full allocation-site abstraction with fixed-point iteration — deferred to a future release): TypeScript compiler API type resolution (typescriptResolver opt-in in .codegraphrc.json) upgrades confidence-0.7 heuristic edges to compiler-verified 1.0; inter-procedural return-type propagation resolves method chains and factory patterns up to 3 hops; field-based points-to analysis (Phases 8.3 through 8.3f) covers callbacks, event handlers, parameter flows, object property writes, and object destructuring rest parameters in both WASM and native engines; barrel re-export chain resolution traces symbols through index.ts re-exports to their actual declaration files; CHA+RTA dynamic dispatch resolves interface method calls to all instantiated concrete implementations; and Phase 8.6 adds a byTechnique breakdown to codegraph stats --json showing edges attributed to each resolver technique. Beyond the Phase 8 work, a parallel accuracy sweep adds resolution for prototype-based method calls, Object.defineProperty accessor this-dispatch, super.method() dispatch via class expressions and static blocks, .call/.apply/.bind receiver rebinding, for-of/Set/Array.from iteration callbacks, inline-array spread call edges, and constructor-assigned property types. C# call graphs improve with same-class bare static call resolution and var-typed local type inference. Six native engine parity issues in the incremental rebuild path are fixed. Caller coverage for real-world TypeScript projects is substantially higher after this release. Note: most resolver improvements appear under Bug Fixes below — they used fix: commit prefixes because they corrected missing edges in existing resolution logic rather than introducing entirely new CLI capabilities.

Features

• stats: add byTechnique breakdown to codegraph stats — codegraph stats --json now includes caller_coverage.byTechnique with edge counts per resolution technique (ts-native, points-to); displayed in human-readable stats output under the caller coverage line; DB migration v17 adds technique column to edges table (#1303)
• config: new typescriptResolver option in .codegraphrc.json — set "build": { "typescriptResolver": true } to enable the TypeScript compiler API enrichment pass; compiler-verified edges (confidence 1.0) replace heuristic typeMap values for factory calls, generic constructors, and other patterns tree-sitter can't resolve alone (#1278)

Bug Fixes

• resolver: TypeScript-native type resolution via ts.createProgram + type checker (Phase 8.1) — upgrades heuristic typeMap entries to compiler-verified confidence 1.0 for .ts/.tsx files; resolves container.get<MyService>() → MyService.doThing() class of edges that tree-sitter cannot see (#1278)
• resolver: inter-procedural return-type propagation (Phase 8.2) — const x = createUser() propagates return type to x for downstream method-call resolution; chain propagation up to 3 hops with confidence decay (1.0 → 0.9 → 0.8 → 0.7); analysis.typePropagationDepth config knob (#1279)
• resolver: field-based points-to analysis for higher-order calls (Phase 8.3) — tracks callback assignments, event-handler registrations, and strategy-pattern wiring; resolves app.use(handler) and events.on('click', handler) call edges (#1289)
• resolver: cross-module points-to propagation (Phase 8.3 + 8.3b) — WASM + native parity; inter-module flows through import edges now propagate type bindings across file boundaries (#1296)
• resolver: parameter-flow tracking in points-to analysis (Phase 8.3c) — function parameters tracked through the call graph; typed parameters seed the receiver typeMap for downstream method resolution (#1294, #1308)
• resolver: object property write tracking in points-to analysis (Phase 8.3d) — obj.handler = fn assignments tracked so obj.handler() resolves to the assigned function (#1295)
• resolver: constructor-assigned property types for receiver-typed resolution (JS/TS) — this.svc = new Service() in constructors seeds the typeMap so this.svc.call() resolves to Service.call (#1314)
• resolver: object destructuring rest parameter resolution (Phase 8.3f) — const { a, ...rest } = obj; rest.method() now resolves method via the rest binding's source type; WASM + native parity (#1355)
• resolver: barrel re-export chain resolution — imports via components/index.ts barrel files now trace to the actual declaration file rather than mapping to the barrel; both WASM buildImportedNamesMap and buildBarrelEdges updated (Phase 8.4) (#1298, #1302)
• resolver: CHA + RTA enhanced dynamic dispatch (Phase 8.5) — interface method calls emit edges to all instantiated concrete implementations; new X() calls tracked for RTA filtering; this.method() resolved through the class's own method table and parent hierarchy (#1302)
• resolver: prototype-based method calls, func-prop this-dispatch, and spread/iteration callback resolution — Dog.prototype.bark = function() definitions extracted; fn.method = function(){ this.other() } this-dispatch wired; object-rest param dispatch (#1331)
• resolver: Object.defineProperty accessor this-dispatch — this.method() calls inside defineProperty getter/setter callbacks resolve through the enclosing class (#1346, #1351)
• resolver: calls through Object.defineProperty / defineProperties / Object.create — accessor definitions emit call edges to the object's own prototype chain (#1328)
• resolver: generator functions extracted as definitions (JS/TS) — function* gen() and async function* gen() now emit definition nodes so callers that iterate them appear in the call graph (#1333)
• resolver: super.method() dispatch via class expression, static block, and field def — super.f() in class bodies, class Foo extends Bar { static { super.f() } }, and field-level assignments now resolve to the parent class method (#1399)
• resolver: .call()/.apply() this-rebinding — fn.call(obj, ...) and fn.apply(obj, [...]) patterns now resolve the call to fn with obj's type as receiver (#1405)
• resolver: Function.bind/call/apply receiver-typed resolution — bound = fn.bind(obj) seeds the typeMap so bound() resolves as a method call on obj's type (#1330)
• resolver: for-of, Set, and Array.from iteration-callback edges — for (const x of items) x.method() and new Set([...]).forEach(item => item.method()) patterns emit call edges (#1397)
• resolver: inline-array spread call edges — fn(...[a, b, c]) unwraps the spread array and emits call edges to each element's method (#1394)
• extractor: inline-new expression recognized as receiver type in extractReceiverName — (new Dog()).bark() directly infers Dog as the receiver type without a prior assignment (#1415)
• resolver: this.prop typeMap key scoped to enclosing class — prevents false edges in multi-class files where two classes define a property of the same name (#1382)
• parity: C# same-class bare static calls resolved + confidence filter for static receiver fallback — MyClass.StaticMethod() from within the same class now resolves; heuristic static-receiver fallback gated on confidence ≥ 0.75 to reduce false positives (#1417, #1427)
• parity: C# var-typed local types inferred from new-expression initializers — var svc = new MyService() now seeds the typeMap with MyService for downstream method-call resolution (#1424)
• parity: C# static receiver calls in WASM engine — static method resolution aligned with the native engine for same-class and qualified receiver patterns (#1395)
• native: extract parameters for prototype method definitions — Dog.prototype.bark = function(name) {} now emits name as a parameter node in the native engine (#1345)
• native: complexity/CFG computed for prototype method definitions — Rust engine now calcul...

v3.11.2

Watch mode correctness sweep. Five independent bugs in the incremental rebuild path are fixed: the call resolver had drifted from the full-build authoritative version, causing inflated calls edges on any watch rebuild touching a widely-imported file; a missing dedup set let the same (caller, target) pair be inserted multiple times; receiver, extends, implements, and dynamic-import edges were silently absent from watch-mode rebuilds; top-level Ruby constants and program-level Python assignments were dropped by the native extractor while WASM captured them; and 10 native grammar crate versions had drifted from their WASM npm counterparts. A new shared call-resolver.ts module now backs both the full-build and incremental paths, closing the structural gap that let these bugs accumulate.

Bug Fixes

• watch: align incremental call resolver with full build — the watcher's resolveCallTargets/buildCallEdges had drifted from the authoritative full-build resolver in build-edges.ts; on a comment-only rebuild of a widely-imported file, calls edges inflated by ~700 (#1261)
• watcher: eliminate calls-edge inflation in incremental cascade — adds the missing seenCallEdges dedup set to buildCallEdges in the incremental path, and tightens the global name fallback in resolveCallTargets to match the full-build resolver (#1264)
• extract: eliminate WASM/native node divergence — native Ruby extractor now handles top-level assignment nodes (program-level constants); native Python extractor extracts program-level function and class definitions that were previously dropped; eliminates the persistent full-build node count gap between engines (#1266)
• watcher: add missing receiver/extends/implements/dynamic-import edges — receiver edges (method call receiver resolution), extends/implements class hierarchy edges, and dynamic-import edges were silently absent from watch-mode incremental rebuilds; now parity-aligned with the full build (#1267)
• engine: align native grammar crate versions with WASM npm packages — upgrades 10 Rust tree-sitter grammar crates in Cargo.toml to match the npm devDependency versions, eliminating grammar-version drift identified as the structural source of native/WASM call-edge divergence (#1268)

Refactors

• engine: extract shared call-resolver, eliminate build/watch duplication — findCaller, resolveByMethodOrGlobal, resolveCallTargets, and resolveReceiverEdge extracted into src/domain/graph/builder/call-resolver.ts; both the full-build and incremental paths share a single implementation via a CallNodeLookup interface (#1272)

Chores

• ci: add grammar version parity check between npm devDeps and Cargo.toml — new scripts/check-grammar-versions.mjs compares grammar major versions across both package managers; wired as a lightweight CI job to catch future drift early (#1270)
• deps: bump commander from 14.0.3 to 15.0.0 (#1251), tree-sitter-erlang to 0.18 (#1252), @biomejs/biome to 2.4.16 (#1250), commitlint to 21.0.2 (#1253, #1254)

v3.11.1

Four new embedding models, sticky model resolution, and a large internal refactor. codegraph embed adds mxbai-large, mxbai-xsmall, bge-m3, and modernbert to the model registry — all publicly accessible without an HF token, covering multilingual, high-quality large, tiny-with-long-context, and ModernBERT-architecture use cases. Sticky model resolution ensures that subsequent codegraph embed runs on an existing graph reuse the model it was originally built with rather than the global default; the default for fresh graphs shifts from nomic-v1.5 to nomic (same dimensions and context window, but the public Xenova mirror instead of the occasionally-gated nomic-ai org). Watch mode delta reporting is corrected — the rebuild log now shows the net edge change instead of an inflated gross re-insertion count. Under the hood, a 10-PR refactor (Titan Grind) decomposed the largest modules — ast-analysis, domain, graph, presentation, extractors, and core-rs — into focused, independently-testable units with no user-visible behavioral changes.

Features

• embed: add mxbai-large, mxbai-xsmall, bge-m3, and modernbert embedding models — all Apache-2.0/MIT licensed, no HF_TOKEN required; bge-m3 is multilingual (100+ languages, 8192 ctx), mxbai-large tops the MTEB BERT-large leaderboard, mxbai-xsmall is tiny with 4096-token context, modernbert uses the ModernBERT architecture (#1229)
• embed: sticky model resolution — codegraph embed on an existing graph now reuses the model stored in embedding_meta rather than falling back to the global default; the default for fresh graphs changes from nomic-v1.5 to nomic (same dim/context, public Xenova mirror avoids occasional HF gating) (#1228)

Bug Fixes

• watch: report net edge delta in rebuild log — previously the count was inflated by re-inserted edges that cancel out; now shows only the true net change (#1245, #1220)

Refactors

• ast-analysis: decompose engine and visitors, break visitor-utils cycle (#1231)
• extractors: shared helpers across language extractors (TS+Rust); adopt shared child-iteration helpers (#1230, #1238)
• core-rs: decompose pipeline, read_queries, edge_builders; collapse walker recursion (#1232)
• graph: decompose Leiden optimiser and roles classifier (#1233)
• presentation: extract shared rendering helpers in cfg and flow (#1234)
• domain: decompose parser, analysis, and search modules (#1236)
• features: decompose complexity/structure/owners; reduce cfg/cochange/feature-warnings complexity (#1237)
• parity: render orchestrator-drop summary as a per-extension table (#1225, #1240)

v3.11.0

Native engine reaches feature parity with WASM, plus an engine-parity sweep across 14 languages. The final 11 extractors (Clojure, CUDA, Julia, Solidity, Erlang, R, Groovy, Gleam, Objective-C, F#, Verilog) are now ported to Rust, so every supported language extracts symbols natively when the prebuilt binary is available — no more silent fallback to WASM for these. In parallel, a multi-PR parity sweep aligned the contains/parameter/inheritance edges that the two engines disagreed on across Java/Kotlin/CUDA/Ruby/Objective-C/HCL/Dart/Scala/Elixir/Haskell/Python/C#/Groovy/C++, so the native engine no longer drops parameters, function-pointer fields, default-value arguments, or interface inheritance edges that WASM was already emitting. F# .fsi signature files now route through a dedicated grammar instead of being parsed as .fs source. On the CLI, -n is now the short form of --limit on every limit-accepting command (previously only on five), build accepts -d/--db, and MCP semantic_search accepts file_pattern to scope hybrid/semantic/keyword searches to a subtree. Watch mode no longer crashes on rebuild when embeddings exist for the file, and barrel-chain re-parse discovery iterates until stable so chained re-exports stop dropping edges.

Features

• cli: unify -n short flag across all --limit-accepting commands — roles, structure, communities, audit, check, children, diff-impact, ast, brief, cfg, context, dataflow, deps, exports, flow, fn-impact, impact, implementations, interfaces, query, sequence, and where now all accept -n in addition to --limit (#1184)
• cli: accept -d/--db on build to match every other DB-scoped command — pre-built graphs can now be re-targeted at build time without cd-ing into the project root (#1183)
• mcp: forward file_pattern (string or string[]) in semantic_search to scope hybrid/semantic/keyword results — closes a silent-drop where MCP callers passing file_pattern got unscoped global hits back with no error (#1149)
• fsharp: route .fsi files through a dedicated signature grammar — new fsharp-signature language id with a val foo : type handler that distinguishes signature declarations from let foo = ... source bindings (#1162)

Performance

• native: port Clojure extractor to Rust (#1097)
• native: port CUDA extractor to Rust (#1099)
• native: port Julia extractor to Rust (#1098)
• native: port Solidity extractor to Rust (#1100)
• native: port Erlang extractor to Rust (#1103)
• native: port R extractor to Rust (#1102)
• native: port Groovy extractor to Rust (#1101)
• native: port Gleam extractor to Rust (#1105)
• native: port Objective-C extractor to Rust (#1106)
• native: port F# extractor to Rust (#1104)
• native: port Verilog extractor to Rust (#1107)
• native: skip backfill on incrementals when orchestrator preserved files — avoids redundant WASM-side backfill work on clean incremental rebuilds (#1082)
• native: skip backfill on clean incrementals + bench guard tuning — removes the residual cost when nothing actually changed (#1085)
• bench: exclude resolution-benchmark fixtures from dogfooding and incremental-benchmark sweeps so per-file timings reflect real source code, not pinned-precision fixture corpora (#1131, #1134)

Bug Fixes

• extractors: drill through function_declarator for parameter names — restores parameter extraction for C-family pointer-to-function declarations across all engines (#1213)
• extractors: recursively walk Haskell pattern parameters so destructured arguments emit edges (#1203)
• extractors/cuda: keep function-pointer class fields that were previously dropped at parity-align time (#1207)
• native/kotlin: strip navigation_suffix wrapper from call name so qualified calls resolve to the correct callee instead of the suffix node (#1205)
• extractors/elixir: extract default-value and pattern-match parameters that were silently dropped on multi-clause functions (#1202)
• extractors: align Ruby/Objective-C contains parity across engines (#1201)
• extractors: align Java/Kotlin/CUDA contains parity across engines (#1199)
• extractors: align HCL/Dart/Scala contains parity across engines (#1196)
• extractors: align Elixir/Haskell/Python contains parity across engines (#1195)
• native/csharp: align extractor with WASM on three engine-parity divergences (#1194)
• db: stop findDbPath walk at cwd when there is no git ceiling, so codegraph invoked outside a repo no longer climbs to the filesystem root (#1193)
• native/cpp: strip reference modifier from parameter names so T& foo extracts foo, not & foo (#1192)
• native: apply WASM callback-callee gating in JS extractor so member_expression callback args no longer create false-positive edges (#1191)
• watch: purge embeddings before nodes to stop FK crash in rebuildFile — incremental rebuilds on watched files with embeddings no longer crash with a foreign-key constraint violation (#1182)
• builder: iterate barrel re-parse discovery to stop dropping chained-barrel edges — the WASM builder now loops until the dirty-barrel set is stable, so a → b → c → d chained re-exports no longer leave edges on the floor (#1179)
• embed: install @huggingface/transformers into codegraph's host node_modules — codegraph embed no longer fails when invoked from a project that hasn't installed transformers itself (#1178)
• hooks: use POSIX [[:space:]] in guard-git.sh grep patterns so the hook works under BSD grep on macOS (#1170)
• hooks: guard-git.sh sed patterns work on macOS BSD sed — closes a silent no-op where the hook ran but matched nothing under BSD (#1146)
• groovy: emit ClassRelation for interface inheritance in both engines so implements edges no longer go missing on Groovy classes (#1158)
• builder: remove duplicate early-return in backfillNativeDroppedFiles (#1148)
• julia: port parameterized-type / qualified-def / qualified-import fixes to WASM so Julia parity matches between engines (#1128)
• gleam: extract parameters for external functions so cross-module Gleam calls resolve (#1127)
• native: purge stale rows when WASM-only files are deleted (#1122)
• native: backfill new dropped-language files on quiet incrementals so newly-added Solidity/Erlang/Verilog files appear on the next rebuild even when the file system signal looks quiet (#1123)
• r: setMethod emits a call edge, not a duplicate definition (#1125)
• groovy: dispatch juxt_function_call in both engines so Groovy DSL-style calls (task { ... }) emit edges (#1124)
• bench: warmup + median for queryTimeMs to remove cold-start noise from the publish gate (#1133)
• scripts: trend annotations fall back to nearest non-null prior release so a missing run no longer breaks the trend chart (#1120)
• scripts: preserve manual NOTES block in incremental report generator (#1119)

Refactors

• objc: use if let Some in for-loop instead of ? to fail-...

v3.10.0

Selective MCP tool filtering, WASM build-speed regression fix, and Haskell parity restoration. A new mcp.disabledTools config field lets you remove specific MCP tools from the schema entirely — useful for smaller-context models that don't need all 33 tools competing for the initial prompt budget. The 3.9.6 expansion of AST_TYPE_MAPS to 23 languages had a side effect of making WASM full builds re-parse every WASM-parseable file in the corpus; the per-file needsFn filter now scopes the re-parse correctly, dropping the 744-file dogfooding build from 14.0s back to 7.8s (matching the 3.9.5 baseline). A second parity fix gates astTypeMap lookups with Object.hasOwn so Haskell's constructor node type no longer walks the prototype chain to Object.prototype.constructor — restoring the Haskell resolver from 0%/0% precision/recall in 3.9.6 to 100%/33% (matching the 3.9.4 baseline). The release benchmark workflow has also been restructured: regression guards now run inside publish.yml before npm publishes, instead of after the docs PR lands, so a regression can no longer ship to npm and then fire on unrelated dev commits.

Features

• mcp: add mcp.disabledTools config to remove specific tools from the MCP schema — drops disabled tools entirely from the schema (not just rejected at runtime) so smaller-context models save initial-prompt tokens; tool names are normalized for matching (#1035)

Bug Fixes

• parity: gate astTypeMap lookup with Object.hasOwn — Haskell constructor nodes (Left, Right, Just, …) no longer fall through to Object.prototype.constructor, which was dropping the non-cloneable Object() function into astNodes.kind and crashing the worker boundary with function Object() { [native code] } could not be cloned; Haskell resolver returns to v3.9.4 baseline (precision=1.0, recall=0.333) (#1041)

Performance

• wasm: scope ensureWasmTrees re-parse to files that actually need it — wasm-worker-entry.ts now serializes empty astNodes arrays (empty ≠ undefined) and ensureWasmTrees accepts an optional needsFn filter so only files genuinely lacking data are re-parsed; WASM full build on the 744-file dogfooding corpus drops from 14.0s back to 7.8s, restoring the 3.9.5 baseline (#1038)

CI

• release: gate npm publish on benchmark regressions — moves the regression guard into a pre-publish-benchmark job in publish.yml so a regression fails the publish workflow before npm sees the new version, instead of firing on unrelated dev commits after the post-publish benchmark PR lands (#1040)
• bench: rename auto-generated benchmark branch prefix from benchmark/ to chore/ — aligns with the local guard-git.sh allow-list so post-publish benchmark PRs no longer require hook bypass when pushed from a Claude Code session (#1044)