58 Commits

Author	SHA1	Message	Date
Colby Mchenry	d1b75a1a27	feat(kernel): R7b Dart walker — dart module, vendored-grammar-C d4d8f3e + wasm byte-copy vendor, dart default-routed (#1386) ... R7b batch 4 #4 — the FINAL R7b language (docs/design/dart-kernel-port-checklist.md is the authoritative quirk list). The fourth vendored-grammar-C language, with a twist: production dart resolved its wasm from tree-sitter-wasms, whose dart dependency is an UNPINNED github:UserNobody14/tree-sitter-dart — a routine dependency update would have silently changed dart's grammar. This PR byte-copies the shipping 0.1.13 artifact into src/extraction/wasm/ (VENDORED_WASM_LANGS += dart) and compiles the same-commit (d4d8f3e337d8) parser.c/scanner.c in the kernel — table identity proven by the kernel-grammar-parity row. crates.io tree-sitter-dart is the nielsenko fork (different lineage) — rejected. The center of gravity is THE SIBLING-BODY DOUBLE-WALK, reproduced bug-for-bug: dart attaches every function/method body as a NEXT SIBLING of its signature, and the TS walkers consume each body TWICE — once via resolveBody (attributed to the function/method) and once via the enclosing generic walk (attributed to the file/class). Duplicate local-function nodes with the SAME id under different parents, duplicated calls/instantiates refs, and file/class-attributed fn-ref twins all emit in the exact observed interleave (a dedicated fixture pins the duplicate-id rows; the bloc kind-census spot-check pins the counts). Also preserved (probe-pinned): the extractBareCall selector matrix (the first callTypes=[] language — cascades completely invisible, `?.` encodes like `.`, the `ConfigT.load()` calls+references double emission with no callee-of-call skip, capitalized-chain `Foo.create().run` re-encode, const-object callee names); the constructor hooks (unnamed ctor skipped, named ctors/factories renamed to the CTOR name with the class as returnType, `@override (T) m()` record-misparse rescued by class-name validation); operator methods minting `method "<anonymous>"`; static_final_declaration constants via the visitNode hook while instance fields mint NOTHING; the prefixed-return-type prefix bug (`other.OtherClass f()` → returnType `other`); enum `with` mixins silent vs `implements` working; anonymous extensions named after the ON type; deferred imports invisible; named-argument callbacks NOT fn-ref-captured (the Flutter `onPressed:` idiom — future accuracy PR, TS-side first); `async*`/`sync*` NOT async; value-refs with the LIVE dart sibling-body pull and the `$X`-vs-`${X}` interpolation asymmetry; dartdoc kept in all three comment forms with the annotation-broken chain. Gates: parity sweeps first-run 0-diff on shelf/bloc/flutter — 5,815 clean files byte-parity, deferrals 10/21/1341 ≈ the survey's 10/21/~1340 (both-arm grammar reality: empty object patterns — the sealed-class idiom — and unnamed `library;` dominate; --max-deferral 0.3); full-init dumps byte-identical ×3 (shelf 7,959 / bloc 40,026 / flutter 1,855,319 dump lines); bloc per-kind node census identical across arms (the double-walk duplicate rows survive the store identically); kernel-dart-parity suite (7 fixtures + in-memory CRLF variants + double-walk duplicate-id pin + generated-file skip pin + two defer pins); full suite 2,688 green ×2 with CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += dart (20 langs — R7b COMPLETE). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 19:55:48 -05:00
Colby Mchenry	bdd687b49f	feat(kernel): R7b Scala walker — scala module, vendored-grammar-C master@0aca5d0a6f, scala default-routed (#1385) ... R7b batch 4 #3 (docs/design/scala-kernel-port-checklist.md is the authoritative quirk list). The third vendored-grammar-C language and the biggest grammar in the tree (35MB parser.c): the vendored wasm is tree-sitter/tree-sitter-scala master@0aca5d0a6f — a post-v0.26.0 generation sync that is not a release (the 0.26.0 crate is 30 states BEHIND, so a crate pin would be a silent downgrade). NO wasm change: production has parsed with this exact revision since #91 — the kernel-grammar-parity row (ABI 15, 26,650 states, 32 fields, id-by-id tables) is the whole alignment proof. Preserved bug-for-bug (all probe-pinned): the leak-through asymmetries — extension methods mint NO nodes (first def's body calls leak to the enclosing scope, later defs invisible, and the braced form resolves its body field to the `{` TOKEN via first-match-wins field lookup → whole extension invisible); anonymous `new T { … }` template_body members leak to the enclosing scope (findAnonymousClassBody misses template_body); the bodied-vs-bodiless class asymmetry (bodiless headers walk class_parameters → default-value calls emit FROM the class; bodied ones never see them) — plus first-segment import names (`import com.example.C` → `com`), the val/var hook keyed on the enclosing-definition NODE TYPE (object vals → constants/value-ref targets, class/trait/enum/given vals → fields) with consumed initializers, every def routed through extractMethod with the top-level function fallback, nested defs in bodies minting NOTHING (the inverse of kotlin) while body-local classes extract fully, curried signatures keeping only the FIRST parameter list (type params win the `parameters` field), enum cases positioned at the CASE node with invisible params/extends tails, extends with-chains via scalaBaseTypeName, `@deprecated(args)` decorates, the #750 capitalized-chain re-encode (`WidgetS.create().render`), literal-receiver silence, static-member reads AND writes, infix invisibility, `derives` silence, scaladoc retention with the CRLF `\r` pin, full value-reference machinery (shadow prune, last-wins same-name targets, `$X`/`${X}` interpolation reads), and SCALA_SPEC fn-refs (bare ids + postfix eta unwrap + varinit, var-init non-capture). Gates: parity sweeps first-run 0-diff on os-lib/cats/scala3-compiler-src/ scala3-library-src — 1,935 clean files byte-parity, deferrals 0/15/57/116 matching the survey's predictions exactly (scala-3's PHANTOM hasError files — flag-true, zero ERROR nodes, capture-checking `^` — defer on the FLAG); full-init dumps byte-identical ×3 (os-lib, cats, scala3 whole-repo 950,889 dump lines); kernel-scala-parity suite (9 fixtures + 9 in-memory CRLF variants incl. Scala-3 indentation through the external scanner + phantom/real-error defer pins + first-segment/namespace/value-ref pins); full suite 2,669 green ×3 with CODEGRAPH_KERNEL_EXPECT=1 (kernel-scaffold's stays-wasm example moved scala → pascal). DEFAULT_ROUTED += scala (19 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 19:02:52 -05:00
Colby Mchenry	e32135171e	feat(kernel): R7b Lua+Luau walker — one lua module, vendored-grammar-C lua v0.4.1, tree-sitter-luau 1.2.0 pin, both default-routed (#1384) ... R7b batch 4 #2 (docs/design/lua-luau-kernel-port-checklist.md is the authoritative quirk list). ONE walker for both dialects (ccpp precedent) — the differences are exactly four: luau's type_definition aliases, the `export `-slice isExported hook, the return-type signature suffix, and the grammar handle. Grammar prep is kernel-side only, no wasm change: lua is the SECOND vendored-grammar-C language (the vendored wasm is the v0.4.1 tag, a revision not on crates.io — tag artifacts compiled via build.rs, shas pinned); luau is a plain crate pin =1.2.0 whose tarball is sha-identical to the tag (the swift tag≠crate divergence does not recur). Grammar-parity rows replace the bump gate entirely. Preserved bug-for-bug (all probe-pinned): the require/visitNode-hook ASYMMETRIES (top-level requires — including inside top-level if/for/while — mint import nodes while the identical body-level statement emits `calls "require"`; top-level `local x = foo()` initializers are invisible while global `x = foo()` calls emit), the BFS string-win inside require args (`require(script:WaitForChild("Kid"))` → import Kid) and Roblox instance paths, receiver-QN methods (`M.sub.deep::chained`, `_G::installed`, stack-QN nested globals like `render::leakedGlobal`), the raw-text callee world (colon forms with `self` never stripped, bracket callees, newline-glued chains byte-verbatim, the `(handler)` paren-conversion), LUA_SPEC function-as-value capture with the `M.cb = cb` param-storage skip and first-occurrence dedupe, LuaDoc `---` keeping a leading `- ` plus `--!strict` joining docstring chains (block-comment docstrings keep interior CRLF bytes), variable nodes at the IDENTIFIER with positional value pairing, duplicate same-(kind,name,line) ids, and the lua↔luau isExported wire divergence (lua functions: flag absent; luau functions: present-false; methods: absent in both; variables: present-false in both; `export type`: true). Gates: parity sweeps first-run 0-diff on kong/lazy.nvim/lua-resty-core (lua) + lune/Fusion (luau) — 1,734 clean files byte-parity, deferrals 1/0/0/3/8 matching the survey's both-arm predictions exactly (kong's 1 = a deliberately invalid fixture; luau's = grammar-inherent generic type packs and default type params); full-init dumps byte-identical kernel-vs-wasm ×4 (kong 157,650 dump lines); kernel-lua-parity suite (both torture fixtures + in-memory CRLF variants + glue-chain, duplicate-id, and cross-dialect defer pins + kernel-arm wire-flag pins); full suite 2,647 green ×2 with CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += lua, luau (18 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 18:42:14 -05:00
Colby Mchenry	b2f9ab1800	feat(kernel): R7b R walker — rlang module, tree-sitter-r 1.2.0 crate pin, r default-routed (#1383) ... R7b batch 4 #1 (docs/design/r-kernel-port-checklist.md is the authoritative quirk list; survey + probe record therein). The lightest-shared-surface, heaviest-hook port: languages/r.ts works entirely through the visitNode hook (every type list empty except callTypes:['call']), so the walker is a file node + a faithful hook transcription + the generic extractCall + pre-order recursion — four shared machineries (value-refs, static-member reads, type annotations, fn-ref capture) are dead by language gates and stay dead. Grammar prep is the first true no-op of the arc: the crates.io tree-sitter-r 1.2.0 tarball ships parser.c AND scanner.c sha-identical to the r-lib v1.2.0 tag the vendored wasm was built from — crate pin only, no wasm change, no bump gate; kernel-grammar-parity gains the r row (ABI 14, same-revision). Preserved bug-for-bug (all probe-pinned): calls "return" on every return(x) (named node in v1.2.0), the import quintet's silent dynamic-arg consumption vs class/generic fall-through asymmetry, library(help = pkg) importing the named arg, class-idiom variable suppression by callee name, chained/right- assign/precedence-ghost gaps, env$fn body-leak-to-file, raw-text callees verbatim (pkg::fn, obj$meth, "strfn" quotes kept, (handler) conversion), duplicate same-(kind,name,line) ids, roxygen dropped entirely, UTF-16 columns/slices. Gates: parity sweeps first-run 0-diff on AnomalyDetection/dplyr/ggplot2/ shiny (838 files; deferrals exactly 0/0/0/1 — the 1 is the moustache- template pseudo-R file, both-arm) — kernel-parity.mjs gained lowercased- extension matching so .R files sweep (matches detectLanguage routing); full-init dumps byte-identical kernel-vs-wasm on dplyr/ggplot2/shiny; kernel-r-parity suite (torture fixture + in-memory CRLF + BOM variants + defer pin + kernel-arm quirk pins); full suite 2,638 green ×2 with CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += r (16 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 18:28:28 -05:00
Colby Mchenry	45a53eb5b5	feat(kernel): R7b Kotlin walker — kotlin module, vendored-grammar-C build, kotlin default-routed (#1382) ... Sixth R7b port — the T1½ batch finale. Checklist-first recipe (docs/design/kotlin-kernel-port-checklist.md, 1,121 lines, dist-extractor ground truth); parity passed FIRST RUN on all three repos. THE NOVEL MECHANISM — vendored-grammar-C (the §4 tracker's prescription, first use): the crates.io tree-sitter-kotlin 0.3.8 pins `tree-sitter >= 0.21, < 0.23` (the kernel links 0.25) and tree-sitter-kotlin-ng is a DIFFERENT grammar (8 fields vs 0, renamed kinds — extractor-breaking), so no crate dep is possible. The fwcd 0.3.8 tag's sha-matched parser.c + scanner.c are vendored into codegraph-kernel/grammars/kotlin and compiled by build.rs (cc), exposed via tree-sitter-language::LanguageFn. The wasm re-vendor is behavior-NEUTRAL (0 CST/error disagreements across 1,984 gate-repo files; old-vs-new full-init dumps byte-identical ×3) — a reproducibility re-vendor, ABI stays 14. Walker firsts: extension-function receivers (getReceiverType → `WidgetK::extend` QN OVERRIDE with no package prefix, the qualified-receiver `com::qext` first-segment bug, and the owner-contains fallback that excludes `interface` kinds and is source-order dependent) and extractModifiers (expect/actual platform modifiers → the node DECORATORS wire field on every created node — the KMP synthesizer's feed, incl. `actual typealias`). Preserved bug-for-bug: the FIELD_COUNT-0 dead cluster (no signatures, ZERO type-annotation refs), hook-consumed property initializers emitting nothing (incl. `by lazy {}`), the bodiless-vs-bodied class header asymmetry, enum- entry bodies being invisible, KDoc never a docstring AND chain-breaking, comment-gluing into import/package extents, `@Anno(args)` emitting nothing while `@Marker` decorates, zero instantiates refs, the paren-then-lambda `trailing()` garbage callee, text-includes visibility/suspend false positives, and the packaged-file value-ref target drop. The fun-interface misparse-recovery hook is DEFER-SHIELDED (every such file has_error) and deliberately not ported. The swift-sweep lesson pre-applied: the shared `assignment` shadow-prune case is implemented alongside the property_declaration case. Gates: sweeps 0-diff okio 299/322, okhttp 531/580, kotlinx.coroutines 1031/1082 (deferrals exactly the predicted 23/49/51 — both-arm grammar reality incl. PHANTOM hasError files with complete CSTs; the kernel trusts the flag); full-init dumps byte-identical ×3 (46.5k/108.9k/92.3k lines); KMP expect/actual synthesis IDENTICAL across arms (412 edges on kotlinx.coroutines — the tracker's KMP validation); kernel-kotlin-parity suite (torture reflowed off the phantom shapes + .kts script + CRLF variants + fun-interface and phantom defer pins) + kotlin grammar-parity row (the C-build ↔ wasm table identity proof); full suite 2,633 green ×2 under CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += kotlin (15 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 17:33:18 -05:00
Colby Mchenry	09e301bbfa	feat(kernel): R7b Swift walker — swift module, tree-sitter-swift 0.7.3 bump, swift default-routed (#1381) ... Fifth R7b batch-3 port, checklist-first recipe (docs/design/swift-kernel-port-checklist.md, 1,056 lines — the largest of the arc, with a built-extractor-validated emission pin and a childForFieldName truth table). Grammar bump first, validated standalone: tree-sitter-wasms ^0.4.0 (ABI 13) → crate 0.7.3 — with a provenance twist: the wasm is built from the CRATE TARBALL's src/ (alex-pinkus keeps generated files off main and the 0.7.3-with-generated-files tag ships an older ABI-14 generation that can never sha-match; grammar.json rules are JSON-equal; the tarball is byte-for-byte what the kernel's cargo build compiles — table identity by construction). Older crates evaluated and rejected: clean-parse shapes are byte-identical on 0.7.3 (53-line CST battery diff, all inert), so an older pin buys nothing and loses the macro-era wins. Delta = error-set membership (63 old-error files parse clean: swift-testing #expect, #Preview/#GET macros, package access, typed throws — vapor 23.1%→9.3%; 21 NEW-only regressions in 3 probed construct classes) + two gate-found categories: docstring boundaries near #if directives (7 clean files, docstring-field-only — verified mechanically) and array-literal-callee call refs (2 refs, 1 file). Every hunk classified via the error-union rule + parked-ref↔edge ripple pairing. Walker (the arc's biggest) centers on the #1020 DEDICATED property branch: computed properties → property nodes with the getter walked under the property (SwiftUI body), static let/var → constant/variable, stored → field, decorator/type-annotation/@Siblings-attr-arg refs all attached to the ENCLOSING TYPE, stored initializer calls attributed to the class. Preserved bug-for-bug: the never-resolving 'parameter' field (zero param type refs, zero signatures), present-false isAsync, open→internal visibility, everything-is-extends inheritance (first type_identifier per specifier), no instantiates refs ever, subscript reads as `calls arr`, `defer` as `calls defer`, multi-case enum entries minting only the first case, /** */ block docs ignored AND chain-breaking, init/deinit/subscript minting no nodes with visitNode-routed bodies (calls → class, static reads → nothing), multi- segment extension resolveName, sugar extension names, the #selector shapes, and the value_argument label-forward skip. ONE fix found by the sweep (then pinned in the fixture + checklist): the shared `assignment` shadow-prune case is swift-live — declared-then-assigned `let X: T` prunes X as a value-ref target. Gates: sweeps 0-diff Alamofire 89/98, vapor 224/247, swift-nio 407/554 (--max-deferral 0.3 — swift error incidence is 9–27% on BOTH arms, structural; every deferral count matches the survey's table exactly); full-init dumps byte-identical ×3 (31.9k/20.7k/126.3k lines); the Alamofire census reproduces property=348 (the #1020 number) on the kernel arm; kernel-swift-parity suite (206-line torture + CRLF + the #if-between-enum- cases defer fixture) + swift grammar-parity row; full suite 2,626 green ×2 under CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += swift (14 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 17:09:12 -05:00
Colby Mchenry	a6c62d77df	feat(kernel): R7b PHP walker — php module, tree-sitter-php 0.24.2 bump, php default-routed (#1380) ... Fourth and final R7b batch-2 port, checklist-first recipe (docs/design/php-kernel-port-checklist.md). Grammar bump first, validated standalone with the diff ENUMERATED + CLASSIFIED (unlike rust/ruby the php bump is NOT graph-neutral): tree-sitter-php ^0.22 (tree-sitter-wasms, 2023) → v0.24.2, the full HTML-interleaving `php` variant (the walker calls LANGUAGE_PHP, never PHP_ONLY) — crate pinned =0.24.2, wasm built from tag 5b5627f's checked-in php/src/parser.c + scanner.c + shared common/scanner.h (all sha-matched against the crates.io tarball, ABI 14→15). Old-vs-new full-init diffs decompose completely into: (1) the anonymous_class wrapper shape (anon-class nodes/methods re-shape — 2,532 rows), (2) grouped nested-clause skip (absent in the gate repos, fixture-pinned), (3) 32 formerly-erroring files parsing clean (monolog Level.php, symfony Request/Response with 8.4 property hooks), (4) a survey-missed category found at gate time: the 8.4 parenthesis-free `new X()->m()` chaining misparse fix (86 garbage instantiates refs disappear, precision-positive), plus resolution RIPPLE proven mechanically (every remaining ref-table flip pairs 1:1 with a resolved edge on the opposite side; node rows byte-stable outside 1/3/4). Walker (java.rs chassis + the php specifics) preserves bug-for-bug: the visitNode hook (const_declaration at ANY scope → bare `constant` nodes, values never walked; trait-use → implements refs WITH filePath via the ruby port's REF_FLAG_FILE_PATH wire slot), FIRST-namespace whole-file scoping (braced namespaces scope nothing; namespaced files DROP top-level const value-ref targets), the import trio (single/aliased/grouped incl. the nested-clause skip, include/require static-literal-only, `Foo\Bar::Baz` use refs), the call-encoding zoo (DOT-joined scoped calls, `this->prop.m` #1251 encoding, `Cls::factory().m` fluent with inner args dropped, nullsafe `?->` emitting nothing, unsuppressed literal receivers), interface multi-extends first-base-only drop, anon-class methods as file-level functions (top) or vanishing (in-body), property type-hints emitting no field refs, the final-modifier-as-type signature quirk, HOF-gated string callables (skipGate) + array callables, and the `name`-node value-ref reader. Gates: sweeps 0-diff monolog 217/217, laravel-framework 3007/3008, symfony 10726/10737 (13,950 files byte-parity; 12 deferrals = exactly the predicted genuinely-broken fixtures, ≈0–0.1%); full-init dumps byte-identical ×3 (16.1k/354.2k/702.8k lines); kernel-php-parity suite (torture + drupal .module + leading-HTML fixtures, CRLF variants, wire-flag pin, defer) + php grammar-parity row; full suite 2,622 green ×2 under CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += php (13 languages). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 16:08:22 -05:00
Colby Mchenry	1909931238	feat(kernel): R7b Ruby walker — ruby module, tree-sitter-ruby 0.23.1 bump, ref-flag wire slot, ruby default-routed (#1379) ... Third R7b port, checklist-first recipe (docs/design/ruby-kernel-port-checklist.md). Grammar bump first, validated standalone (the rust pattern): tree-sitter-ruby ^0.20.1 (tree-sitter-wasms, 2024-02) → v0.23.1 — crate pinned =0.23.1, wasm built from tag 71bd32f's checked-in parser.c/scanner.c (both sha-matched against the crates.io tarball; content bump, ABI stays 14). Old-vs-new full-init dumps: sinatra/jekyll byte-identical; rails = exactly the one classified hunk (the `recv&.!=` safe-nav operator misparse fix, `table_name.!` → `table_name.!=`, precision-positive). Walker (python.rs chassis + the six ruby divergences) preserves bug-for-bug: the importTypes:['call'] funnel (class-body DSL — attr_accessor, has_many, define_method incl. its block, sinatra route blocks — emits NOTHING at non-body scope), hook-handled module multiply-capture (nested modules re-scan their subtree per level after popping — `this.hooked` fn-refs from class AND module AND file), the sibling-scan visibility trio (bare `private` invisible; `private :sym`/`private def` poison all later defs; the inner def stays public), bare-call statements (do…end body_statement emits, brace-block block_body doesn't), `.new` instantiates with last-`::`-segment names, constant-receiver references refs, require/require_relative path refs (posix-normalized, `.rb`-suffixed, `Kernel.require` and interpolated-path quirks included), `=begin` docstring marker survival, and the reverse-order value-ref DFS. Wire v2: the hook's mixin `implements` refs carry `filePath: ctx.filePath` — the ONE extraction-ref denormalized field (php's trait-use refs share the shape). RefRow's first pad byte becomes a flags slot (REF_FLAG_FILE_PATH); decode re-attaches its own filePath parameter; KERNEL_ABI_VERSION 1→2 on both sides (mismatched dist/.node pairs degrade to wasm, as designed). Gates: sweeps 0-diff sinatra 147/147, jekyll 164/164, rails 3452/3452 (3,763 files, 0 deferrals — ruby error incidence 0.00%, any deferral = walker bug); full-init dumps byte-identical ×3 (7.2k/9.4k/375.6k lines); kernel-ruby-parity suite (torture + CRLF + wire-flag pin + defer) + ruby grammar-parity row; full suite 2,613 green ×2 under CODEGRAPH_KERNEL_EXPECT=1 (one unrelated mcp-initialize timing flake under parallel load, passes solo 3/3 ×3). DEFAULT_ROUTED += ruby (12 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 15:44:13 -05:00
Colby Mchenry	286e9ccc2d	feat(kernel): R7b C# walker — csharp module, tree-sitter-c-sharp 0.23.5 pin, csharp default-routed (#1378) ... Second R7b port, checklist-first recipe (docs/design/csharp-kernel-port-checklist.md; parity passed FIRST RUN again). No grammar bump — the #717 vendored wasm verified table-identical to crate 0.23.5 (ABI 15, STATE_COUNT 8053, node-kind + field tables); first port with no grammar-prep step. The #237 #if-blanking preParse stays TS-side via the existing route-point hoist. Walker preserves bug-for-bug: the single-namespace-node quirks (second namespace nests under the first, nested namespaces leave no trace, import refs hang off the namespace node), raw member-access callee texts (this./base./literal receivers, multi-line fluent chains) with unconditional chain re-encode, deliberate emission holes (property accessor/expression bodies, ctor initializers, delegates/events/ operators/indexers/local functions, top-level locals), garbage extends refs ((repo) primary-ctor args, BaseDto(Name) record bases, enum : byte), the alias- import moduleName quirks, nameof-as-call, CSHARP fn-ref spec (+= subscription, this.X bare-name form, argument layer, initializer lists), C# type-ref engine (nested-generic returnType failure included), and value-ref shadow pruning. Gates: sweeps 0-diff serilog 211/216 / Newtonsoft.Json 914/945 / jellyfin 2104/2105 (deferrals match the survey's per-repo predictions — both-arm #if damage; default --max-deferral 0.1 holds, no c/cpp exemption); full-init dumps byte-identical ×3 (14.0k/109.1k/210.8k lines); kernel-csharp-parity suite (torture ×3 + CRLF variants + 8 micro-pins + defer) + csharp grammar-parity row; full suite 2,608 ×2 under CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += csharp (11 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 13:46:12 -05:00
Colby Mchenry	f1ca991943	feat(kernel): R7b Rust walker — rustlang module, tree-sitter-rust 0.24.2 bump, rust default-routed (#1371) ... First R7b language port. Grammar: tree-sitter-rust pinned =0.24.2 + wasm vendored from tag 77a3747 (parser.c/scanner.c sha-matched against the crates.io tarball), replacing the 2023 ABI-14 tree-sitter-wasms build — the bump alone is precision-positive on the wasm path (receiver-qualified instance-method resolutions replace ambiguous bare-name matches; node sections byte-identical on ripgrep/tokio). Walker mirrors the TS reference bug-for-bug per docs/design/rust-lang-kernel-port-checklist.md (survey artifact): dead-code isAsync, impl-pushes-no-scope, the impl-Trait-for-Generic<T> trait-receiver quirk, phantom const identifiers, use-binding triple emission, wildcard-use-emits-nothing, scoped-supertrait drop, chained-call re-encode gated on scoped_identifier, Rocket route macros body-only. Gates: parity sweeps 0 diffs — ripgrep 101/101, tokio 790/790, rust-analyzer 1217/1488 (271 deferrals are token-macro-table sources that error on BOTH arms — grammar-inherent); full-init dump-diffs byte-identical on all three (3,857 / 13,440 / 39,030 nodes); kernel-rustlang-parity suite (torture + CRLF + defer) in npm test; full suite green x2 with CODEGRAPH_KERNEL_EXPECT=1. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 00:08:09 -05:00
Colby Mchenry	2d72891b59	feat(kernel): R7a C/C++ walker — dual-lang ccpp module, preParse hoist, 7 new blanks, c/cpp default-routed (#1346) ... Parity: 0 diffs on redis/git/fmt/protobuf/ALS sweeps; full-init dumps byte-identical on all five + linux at kernel scale (10.4M dump lines, same sha256 both arms). Linux 2c/6GB envelope: kernel-arm 19.1min vs wasm-arm 22.9min (parse 356s vs 435s) on a much richer graph (the new blanks recover error-swallowed code: git 2x nodes, linux kernel/+mm/ 3x). Deferral guard corrected by measurement (C/C++ error incidence 9-42%; --max-deferral flag); defer-reuse memo kills the 3x re-blank/re-parse cost deferred files paid. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-17 16:56:41 -05:00
Colby McHenry	2a79432b13	docs(kernel): R6 — kernel-scale re-validation record (§4f) + parity-harness symlink robustness ... cg1212 (Linux kernel, 2 CPU/6GB): completes in 26.4min vs the ~27min baseline with all new machinery active — no regression; graph scale identical (2,048,664 nodes / 6,405,964 edges). The §6 parse expectation (6m → ~2m) was mis-premised: the tree is ~99% C, an unported T2 language, so it transfers to the C/C++ port (R7). Resolution remains the kernel-scale wall (19.2m, 73% — P1). The tree's own Python tooling files: 99/99 byte-parity. kernel-parity.mjs now skips dangling symlinks (Linux dtc fixtures). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-17 00:19:39 -05:00
Colby McHenry	c2503e2bee	feat(kernel): R5 — Python and Go ports, gates passed, default-on ... Python (codegraph-kernel/src/python.rs) and Go (src/go.rs) join the native kernel, mirroring the wasm extractors bug-for-bug. Python: decorated_definition docstrings/decorators (decorates refs only for bare-identifier decorators — the call-kind quirk), function-in-class → method, module-level assignments always extract as variable, from-import per-name binding refs, self.x fn-ref candidates as bare names. Go: receiver methods with Recv::name qualified names + contains edges to the first earlier struct of that name, type_spec struct/interface classification with embedding→extends and interface method nodes, composite-literal instantiates keeping the package qualifier, top-level var/const initializer walks attributed to the declared symbol (#693), 2-hop field chains (#1276), New().Method() re-encode (#645/#608), and the GO_SPEC fn-ref layers. Grammars: tree-sitter-python 0.23.6 + tree-sitter-go 0.23.4 crates, with wasm vendored from the same tags (parser.c sha-matched) — both were 2023-era in tree-sitter-wasms. Gates: extraction sweeps 100% (flask 83/83, django 3,035/3,038 +3 error-file deferrals, gin 99/99, prometheus 978/979 +1); full-init dump-diffs byte-identical on flask (10,833 rows), gin (17,540), django (360,794), and prometheus (213,758); torture fixtures enforced in npm test. DEFAULT_ROUTED now covers typescript/tsx/javascript/jsx/java/ python/go. Full suite: 2,471 tests pass. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-16 23:50:02 -05:00
Colby McHenry	03d54e47a1	feat(kernel): R4 — Java port with Lombok synthesis, gate passed, default-on ... Java joins the native kernel (codegraph-kernel/src/java.rs), mirroring the wasm extractor's Java paths bug-for-bug: package namespaces, imports, javadoc, annotations→decorates, type_list inheritance, static-final constants, enum constants, anonymous classes (including the TS side's 0-based-line quirk on the extends ref), method_invocation calls with the this.field unwrap and the Foo.getInstance().bar() chain encoding (#645/#608), static-member value reads, method-reference fn-refs (#756), value-reference edges, and the full Lombok member synthesizer (#912: Getter/Setter/Data/Value/Builder/ToString/ EqualsAndHashCode/Slf4j-family with taken-member dedup). The shared docstring/textutil modules moved to crate level. Grammar: tree-sitter-java 0.23.5, with the wasm grammar vendored from the same tag (parser.c sha-matched) replacing tree-sitter-wasms' 2023-era build. Gate (plan §4c): extraction sweeps 100% — gson 262/262, retrofit 341/341, dubbo 4,048/4,048 — plus a Java torture fixture in npm test; full-init dump-diffs byte-identical on gson (49,766 rows), retrofit (62,735), and dubbo (441,266 rows); all R2/R3 repos re-verified; Linux container runs all 23 kernel tests green under CODEGRAPH_KERNEL_EXPECT=1. The gate caught a real cross-language bug: fn-ref dedupe and value-ref self-target checks must compare node ID STRINGS, not node-table rows — ids collide for same-(kind, name, line) nodes, which minified one-line bundles hit routinely (retrofit's website JS exposed it; latent in the TS/JS walker since R2, never released). Fixed in both walkers. Benchmark honesty: dubbo fresh-init on an 11-core Mac is ~flat (parse-loop wall 5,020→4,394ms; total ~11.3s both arms) because that wall is main-thread-bound (reads + store), not worker-CPU-bound — the §6 expectation assumed otherwise. Where worker CPU binds the kernel delivers: dubbo on a 2-CPU/6GB container drops 27.8-28.6s → 22.3-22.8s (~1.25×). The identified lever for the many-core headline is decoding kernel buffers directly into store rows (skipping per-node JS object materialization); the buffer contract already carries everything. DEFAULT_ROUTED now includes java. Full suite: 2,467 tests pass. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-16 23:25:29 -05:00
Colby McHenry	c8cca9a601	feat(kernel): R3 — TS/JS equivalence gate passed, kernel default-on ... Gate evidence (docs/design/rust-kernel-migration-plan.md §4b): - Graph parity, byte-identical (stronger than the §5 ≤0.5% bar): full codegraph-init dump-diffs kernel-vs-wasm on express (13,712 rows), excalidraw (89,898), and vscode (2,378,238 rows) — identical bytes. Python control repo (flask) identical + timing unchanged. The parity harness is now ORDER-sensitive (emission order drives rowids, which drive resolution order) and dumps come from the new scripts/dump-graph.mjs (natural keys, no rowids/timestamps). - The one real find, caught by the vscode tier: tree-sitter error RECOVERY is encoding-dependent — byte-identical grammar sources and the same core (0.25.10) recover erroring files differently under UTF-8 (native) vs UTF-16 (web-tree-sitter) parsing; proven by reproducing the wasm tree with a native UTF-16 parse. Policy: the kernel defers any file whose tree has_error() to the wasm extractor (silent 'defer:' signal, per file) — parity by construction on erroring files (incidence 0-0.42% across the gate repos), and the harness fails if deferrals exceed 10% so a broken kernel can't hide behind the fallback. - Retrieval invariants: canonical excalidraw flow (mutateElement → renderStaticScene) connects end-to-end on the kernel-indexed graph; synthesized-edge families present. Agent A/B is vacuous under byte-identical DBs (same justification as #1320-#1322). - Perf: vscode init 105.4s → 82.1s (1.28×) on an 11-core Mac; excalidraw on a 2-CPU/6GB Linux container (the CI-runner envelope) 6.2-7.1s → 4.3-4.8s (~1.5×). Linux arm64 in-container build: all 22 kernel tests green under CODEGRAPH_KERNEL_EXPECT=1. Windows VM leg deferred (VM stopped; prlctl start needs Parallels Pro) — benign: a missing .node falls back to wasm, and the release matrix builds and gates the win32 prebuilds. - Full suite: 2,465 tests pass WITH default-on routing, so the entire extraction corpus now exercises the kernel for TS/JS wherever a .node is staged. DEFAULT_ROUTED = {typescript, tsx, javascript, jsx}. Override: CODEGRAPH_KERNEL_LANGS (replaces the set) / CODEGRAPH_KERNEL=0 (kill). Changelog entry added under [Unreleased]. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-16 22:50:02 -05:00
Colby McHenry	9ad5cd7ba2	feat(kernel): R2 — full TypeScript/JavaScript extraction port, byte-parity with the wasm path ... Replaces the R1 seed .scm emitter with a bespoke Rust walker (codegraph-kernel/src/tsjs/) that mirrors TreeSitterExtractor's TS/JS paths function-for-function: declarations (incl. #808 field/property classification), qualified names, docstrings (#780 wrapper climbs), signatures, imports/re-exports + per-binding refs, calls with receiver-qualified callees (#1230 literal-receiver skip), instantiations, decorators, inheritance, type annotations (#381), type-alias members + tuple contracts (#359/#634), React component recognition (#841 forwardRef/memo/styled), object-of-functions / zustand-through-middleware / RTK Query endpoints + generated hooks / vuex + pinia store shapes, function-as-value capture with the flush gate (#756), and value-reference edges with the shadow prune (#895/#897). The generic query emitter is deleted — extraction parity needs logic .scm can't express; future languages get walkers too (migration plan §4a). Positions and JS string-slice semantics are emitted in UTF-16 code units natively, so kernel output is byte-identical to web-tree-sitter's — no column diff class exists. Parity evidence (macOS): scripts/kernel-parity.mjs (full-object multiset diff per file) — this repo 353/353 files, excalidraw 643/643 (10,650 nodes / 10,726 edges / 68,307 refs), plus torture fixtures checked into __tests__/fixtures/kernel-parity/ and enforced in npm test by kernel-tsjs-parity.test.ts. The strict compare caught one real decoder bug the loose harness missed: refs must NOT carry denormalized filePath/language at the extractFromSource seam (the store fills them). Perf: extraction 2.6× single-thread on excalidraw (487ms vs 1,255ms, identical outputs). Routing stays opt-in (CODEGRAPH_KERNEL_LANGS) until the R3 equivalence gate (large repo, DB dump-diff, retrieval invariants, agent A/B, Linux/Windows) passes. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-16 22:14:40 -05:00
Colby McHenry	c5eebe6beb	feat(kernel): R1 scaffold — napi-rs extraction kernel, buffer contract, routing + fallback, grammar-parity CI ... Phase 0 of the Rust extraction-kernel migration (docs/design/ rust-kernel-migration-plan.md, now checked in with §3a recording the shipped state): - codegraph-kernel/ napi-rs crate: extractFile(path, content, language) → five flat buffers (meta/nodes/edges/refs/arena), one JS boundary crossing per file. Node ids computed Rust-side, byte-identical to generateNodeId (pinned by test vector). Reserved per-node metrics slot for the Arc 3.2 code-metrics work. - Generic .scm-driven emitter (@def.<kind>/@name/@ref.<kind> captures, byte-range scope stack → ::-joined qualified names, contains edges, refs attributed to the innermost enclosing symbol). Seed TS/JS queries are smoke-level; R2 replaces them with the full port. - Routing seam in extractFromSource with per-file wasm fallback. DEFAULT_ROUTED is empty — no behavior change until a language passes its equivalence gate (R3). Dev opt-in: CODEGRAPH_KERNEL_LANGS. Kill switch: CODEGRAPH_KERNEL=0. Loader verifies ABI + kind tables before routing; EDGE_KINDS became a runtime array because kind order is now wire contract. - Grammar-source parity: vendored TS/TSX/JS wasm grammars built from the exact crate revisions (tree-sitter-typescript v0.23.2, tree-sitter-javascript v0.25.0, checked-in parser.c, ts-cli 0.25.10) — the tree-sitter-wasms builds were 2023-era, which the new kernel-grammar-parity test caught on day one. Production TS/JS parsing gets 2.5 years of grammar fixes; full suite green (2456 tests). - Build/release wiring: scripts/build-kernel.sh + npm run build:kernel; release.yml kernel prebuild matrix (continue-on-error — the kernel is optional everywhere, bundles fall back to the wasm path); bundles stage lib/kernel/codegraph-kernel.node; release job runs the kernel suites with CODEGRAPH_KERNEL_EXPECT=1. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-16 20:13:51 -05:00
Colby Mchenry	ad5300a601	fix(ui): show synthesis as a 'Linking dynamic dispatch' phase; mute node:sqlite warning spam (#1299) ... Two first-run UX bugs surfaced by indexing a real 1,342-file C repo: 1. After 'Resolving refs' hit 100%, the ~40 dynamic-dispatch synthesis passes ran with no progress surface, so the bar sat frozen at 100% long enough to read as a hang (the C fn-pointer pass alone can hold for a while on C-heavy repos). Synthesis now reports per-pass progress through a new 'linking' IndexProgress phase, rendered as 'Linking dynamic dispatch'. The step total is pinned by a test to the synthesizer's actual __mark() count so adding a pass without bumping it fails loudly. 2. node:sqlite's ExperimentalWarning is emitted once per THREAD, so the main process plus every parse worker printed it mid-index, interleaved with the progress UI. All launch paths now pass --disable-warning=ExperimentalWarning: both bundle launchers, the Windows npm-shim invocation, and the CLI self-relaunch (NODE_RUNTIME_FLAGS, deliberately excluded from the re-exec gate so an older installed launcher never triggers a pointless re-exec, and version-gated off nodes older than the flag). Verified end-to-end on the same repo: zero warnings, live linking bar, byte-identical graph (50,520 nodes / 148,232 edges). Full suite green. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-15 19:44:09 -05:00
Colby Mchenry	2b0b4b587e	ci(release): publish npm packages with provenance and attest release bundles (#1296) ... Every published artifact is now cryptographically verifiable as built by this repo's Release workflow: npm publishes carry npm provenance (OIDC, shows the Provenance badge on npmjs.com), and the GitHub Release bundles + SHA256SUMS get signed build attestations via actions/attest-build-provenance, verifiable with `gh attestation verify <file> -R colbymchenry/codegraph`. pack-npm.sh now writes a repository field into the generated shim and per-platform package.jsons — npm --provenance refuses to publish without one matching the repo — and the root package.json gains the same field. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-15 19:10:34 -05:00
Colby Mchenry	c9f8c0ebaf	fix(mcp): reap the server when its launcher is killed during startup (#1185) (#1199) ... An MCP host that kills the launcher chain within the server's first ~100ms while keeping the stdio pipes open (config probe, cancelled request, startup timeout; Rust hosts that kill a child without dropping its stdio handles) left the server orphaned: it booted already reparented to init, so the PPID watchdog's "ppid changed" baseline was captured as 1 and could never fire, and stdin never EOF'd. The process lingered — idle, ~30MB — until the host itself exited, accumulating one per abandoned launch (the pile-up reported in #1185). Reproduced on released 1.2.0/macOS: SIGKILL the launcher at +50ms → permanent orphan; at +150ms the old late baseline had already run and reaped it. Three-part fix: - Capture process.ppid at the earliest line of the CLI entry (early-ppid.ts) and use it as every watchdog baseline, shrinking the blind window to the few ms before our first JS runs. - Thread the real host pid down the bundled path: the npm shim and the standalone sh launcher set CODEGRAPH_HOST_PPID (an outer launcher's value wins), so the watchdog polls the host directly. Previously only the --liftoff-only relaunch set it, leaving the entire npm/standalone install base with hostPpid=null. - Never-initialized backstop (startup-handshake.ts): a serve --mcp that receives no MCP traffic for CODEGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS (default 15min, 0 disables) shuts down — the catch-all for a kill landing in the residual pre-JS window. Disarmed on the first byte, so a quiet-but-live session is never touched. Also scrub CODEGRAPH_HOST_PPID from the detached daemon's env — it has no host, and a stale pid must not leak into anything it spawns. Validated end-to-end on the built bundle: the +50ms early-kill orphan is now reaped while the host still holds the pipes open, and all six normal lifecycle paths (clean close, SIGTERM/SIGKILL child, host exit/SIGKILL, fd-holding adversarial host) stay clean. New coverage in startup-handshake.test.ts, mcp-startup-orphan.test.ts, and npm-shim.test.ts. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-07 08:45:12 -05:00
Colby Mchenry	41620c60fa	feat(extraction): add COBOL language support (.cbl/.cob/.cpy) (#590, #648) (#1161) ... Programs, sections/paragraphs (reconstructed extents over the grammar's flat header stream), PERFORM/THRU/GO TO/CALL call edges, COPY copybook imports incl. standalone .cpy fragments, DATA DIVISION records/fields/ 88-levels with write-site impact references, and CICS flows: EXEC LINK/XCTL program targets (literal + same-file VALUE deref), EXEC SQL INCLUDE, and pseudo-conversational RETURN/START TRANSID hops resolved to the owning program via a CICS framework resolver. Fixed and free source format (free format via a scanner wide-mode sentinel). Grammar: vendored wasm built from a patched yutaro-sakamoto/ tree-sitter-cobol (EXEC blocks as an external-scanner token, copybook fragment entry point, single-quote continuation, COPY REPLACING pseudo-text, NOT=, CALL GIVING, ENTRY, FREE, bitwise ops, abbreviated relations, COBOL-2002 usages, and more). Patch + provenance + upstream PR draft in docs/grammars/. Parse health: AWS CardDemo 43/44 native (upstream: 9/31), 44/44 through preParse; copybooks 28/29; CobolCraft free-format 17/17 (upstream: 0); NIST COBOL85 unchanged at 373/382. Copybook members resolve to files like C includes (basename index, name-matcher short-circuit so compiler-supplied members stay honestly unresolved): CardDemo imports 5 -> 285. Impact proof: ACCT-CURR-BAL (CVACT01Y copybook) surfaces its 4 writer programs cross-file. Also: run-all.sh now neutralizes the ambient prompt-hook in both A/B arms (CODEGRAPH_NO_PROMPT_HOOK=1); COBOL corpus entries for agent-eval. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-03 09:17:53 -05:00
Colby Mchenry	6dd5512d8d	fix(windows): set windowsHide on remaining child spawns to stop console flash (#1092) (#1104) ... On Windows, a black console (conhost) window flashed briefly when CodeGraph ran as a background MCP server. Several child spawns were missing `windowsHide: true`, so Windows created a visible console for the child: - scripts/npm-shim.js — launching the bundled runtime (every server start / daemon-idle reconnect) and the self-heal `tar` extraction of a missing platform bundle. - src/reasoning/login.ts — the detached `cmd /c start` browser open. - src/upgrade/index.ts — package-manager spawn (console-attached, so no flash in practice, but set for uniformity: every child spawn now hides). The daemon spawn (#411) and all git execFileSync sites already set it; this closes the remaining gaps. Adds an all-platforms source guard to __tests__/npm-shim.test.ts asserting every spawn in the shim sets windowsHide. Closes #1092 Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-01 09:55:29 -05:00
Colby Mchenry	31a58070c8	fix(install): prune old version bundles instead of piling them up (#1074) (#1075) ... install.sh kept each release in its own versions/<v> dir (~50 MB with the vendored Node runtime) and only moved the `current` symlink, so old versions accumulated forever across upgrades. Keep only the just-installed version and delete the rest; `codegraph upgrade` re-runs install.sh, so this covers upgrades too. The npm-shim self-heal cache (~/.codegraph/bundles/) prunes the same way. Windows installs overwrite a single dir in place and were never affected. Validated real-world on macOS, Linux (Docker/dash), and Windows (VM): a v1.1.2 -> v1.1.4 install leaves only the latest behind. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-29 23:35:50 -05:00
Colby Mchenry	dfe13b03c8	feat(mcp): off-load read-tool dispatch to a worker pool to fix concurrent-call timeouts (#1002) ... The shared daemon served every session on one event loop with synchronous node:sqlite. codegraph_explore is CPU-bound work stitched together by microtask awaits, so N concurrent explores keep the microtask queue continuously full and starve the macrotask phases — timers AND socket I/O. The transport freezes: no response can flush until the whole batch drains, so with ~10 subagents on a large repo clients routinely time out (reported via X by @symbolic2020). Move the heavy read-tool dispatch onto a worker-thread pool. Each worker holds its own WAL read connection (verified: a worker reader sees the main writer's committed catch-up/watcher writes); the single watcher/writer, the catch-up gate, codegraph_status, and the staleness/worktree notices stay on the main thread. Concurrent reads now run in true parallel up to core count and the main loop stays free for the MCP transport, so responses flush incrementally instead of all-at-once after the batch drains. Enabled for the shared daemon only; direct (single-stdio-client) mode is unchanged. - crash recovery: respawn + retry-once, with a circuit breaker that falls back to in-process dispatch if workers can't run on this platform - graceful backstop: an overloaded pool returns success-shaped "busy, retry" guidance, never isError (so it can't teach the agent to abandon codegraph) - pending-aware growth + capped concurrent cold-starts avoid a startup thundering herd (N simultaneous module-loads + DB opens could stall the loop) - config: CODEGRAPH_QUERY_POOL_SIZE (default clamp(cores-1, 1, 16); 0 disables → in-process), CODEGRAPH_QUERY_BUSY_TIMEOUT_MS (default 45s) 10 concurrent explores on vscode (10.5k files): 31s → ~9s, staggered flush, 0 timeouts, byte-identical output; scales with cores (≈3.3× on 8, 1.8× on 2). Full suite passes plus 10 new query-pool tests (fake-worker injection so the scheduling logic is covered without spawning threads). Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-26 15:42:18 -05:00
Colby Mchenry	3e1547bbe1	fix(mcp): bold labels instead of ATX headings in tool results (#778) (#951) ... MCP tool results used Markdown ATX headings (##/###/####) for section headers — the status summary, each search hit, every file section in an exploration — which Markdown-rendering clients (e.g. the Claude Code VSCode extension) blow up to H1–H4 font size, filling the transcript with oversized lines (worst on search/explore, where the noise scales with result count). Swap them all for bold labels, which render at body size while keeping the same structure. CLI/TTY output (ContextBuilder) is unchanged — the issue notes it's fine. The format is parse-coupled, so kept in sync: - The explore truncation boundary and the offload chunker (reasoning/reasoner.ts) both key off the per-file header, now a unique `**`-prefixed marker emitted via a shared fileSectionHeader() helper. - Updated the offload strip regexes and switched the opt-in report-style prompt off ATX headings (same client, same rendering issue). - Updated test helpers (sectionFor, sourcedFiles, the callers section-boundary scan) that scanned the old markers. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 12:06:35 -05:00
Colby McHenry	4f8782cbe5	test(agent-eval): add output-style A/B harness, cost/token analyzer, and DISALLOW/REP_START controls ... Three additions to tighten the eval loop: - offload-eval-styles.sh: new 4-arm eval (raw/refs/map/src) isolating the Worker's output shape's effect on main-session tokens, latency, and accuracy. Delegation blocked by default (DISALLOW=Agent) so variance from Haiku subagent spawning doesn't contaminate the measurement. - offload-eval-cost.mjs: cost/token analyzer that reads Claude Code's own per-model accounting (modelUsage.costUSD) rather than re-deriving from raw token counts, giving a correct main(Sonnet)/sub(Haiku) split with proper per-tier pricing. - offload-eval-3arm.sh: adds DISALLOW env to block sub-agent delegation across all arms, and REP_START to append reps to an existing run without clobbering earlier jsonls (e.g. REP_START=4 REPS=3 → reps 4,5,6). Also adds CODEGRAPH_OFFLOAD_STYLE forwarding to the managed gateway so the styles eval can drive output shape end-to-end; the field is stripped before the upstream model call and never sent to BYO endpoints.	2026-06-19 16:43:10 -05:00
Colby McHenry	f82a662ddb	feat(mcp): pare default tool surface to codegraph_explore alone + redux-thunk synthesizer	2026-06-19 02:15:14 -05:00
Colby McHenry	7ddd3fa7eb	test(agent-eval): persist offload accuracy/adoption eval harness + front-load hook ... Reproducible suite measuring the managed CodeGraph AI offload and the front-load UserPromptSubmit hook (approach 1) vs raw codegraph and no-codegraph, across repo sizes, on time / main-session tokens+cost / CodeGraph-AI tokens+cost / accuracy. All agent arms run claude -p sonnet --effort high; eval-only, nothing shipped. - offload-eval-setup.sh: clone + index 4 memory-probe-verified "not-trained-on" repos (mtkruto/postybirb/shapeshift/trezor — small→large) so the no-codegraph baseline is honest. - offload-eval-3arm.sh / -frontload.sh: one repo, the arms (offload/raw/nocg, frontload). - offload-eval-matrix.sh / -frontload-matrix.sh: drive all 4 tiers. - offload-eval-hook.mjs: the front-load hook (self-locates its engine; CG_FRONTLOAD_DEBUG to log). - offload-eval-metrics.mjs / -judge.mjs (Sonnet) / -summarize.mjs: extract, score, aggregate. - offload-eval-ground-truth.json: source-verified canonical flows (the judge's reference). - offload-eval.md: usage + the 2026-06 findings (raw = the win; offload least-accurate; front-load solves adoption but exposes explore's dynamic-dispatch gaps). Scripts are path-portable (self-locating $HERE/$ENGINE; AGENT_EVAL_OUT scratch dir). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-18 22:30:30 -05:00
Colby Mchenry	df6f4bec43	feat(explore): dynamic-dispatch boundary surfacing — announce where a flow ends instead of guessing edges (#687) (#835) ... * feat(explore): announce dynamic-dispatch boundaries when a flow can't connect statically (#687) When buildFlowFromNamedSymbols can't connect the agent's named symbols, scan the disconnected symbols' bodies (query-time, deterministic, zero graph mutation) for dynamic-dispatch forms — computed member calls, getattr, reflection, typed message buses, runtime-keyed emits, Proxy — and announce the exact site where the static path ends, with candidate runtime targets when a dispatch key is statically visible. The honest alternative to guessing edges: surface the boundary, don't fabricate the bridge. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(agent-eval): ab-new-vs-baseline survives files added since the baseline ref A single multi-file 'git checkout <ref> --' with one unknown pathspec checks out nothing, so the baseline arm silently ran the NEW build. Check out per-file and remove files that don't exist on the baseline. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * docs(playbook): boundary surfacing as the mechanism floor for non-gateable dispatch (#687) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(explore): render a direct synthesized hop between two named symbols (#687) A 2-node chain populates pathIds but renders nothing (Flow needs >=3), and the dynamic-links section skipped its edge as 'already in the main chain' — so a custom EventBus emit→handler connection was invisible. Skip-as-in-chain now applies only when a chain actually renders, and the boundary scan treats short-chain endpoints as connected. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-12 11:26:33 -05:00
Colby Mchenry	0682681175	chore(agent-eval): standing A/B model policy — sonnet + high effort, never Opus/Fable (#816) ... All agent A/B arms now run claude --model sonnet --effort high by default (MODEL/EFFORT env overrides exist). Sonnet is the deliberate floor model: codegraph's users attach whatever host they already run (Cursor Composer, Gemini, ...), and a stronger model's tool-use masks the salience problems a weaker one exposes — what lands on Sonnet generalizes up; Opus/Fable-only wins don't generalize down. Policy recorded in CLAUDE.md's validation methodology; 11 hardcoded --model opus call sites across 9 eval scripts switched to the env-overridable default. Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-11 19:39:16 -05:00
Colby Mchenry	1983590533	feat(mcp): codegraph_node reads files like the Read tool — offset/limit, byte-parity (#738) ... Makes codegraph_node a drop-in faster Read for indexed source files (file-read mode: <n>\t<line> like Read, offset/limit, + blast-radius header; symbolsOnly for the map). Fixes the old file-view dropping imports/line-numbers. #383/#527 preserved. Validated by A/B: explore/node already return source + line numbers, so Read=0 when used. Includes the A/B eval harness scripts. Full suite green (1270).	2026-06-08 13:48:42 -04:00
Colby Mchenry	0e2789ab71	docs(agent-eval): nested MCP attach is startup-latency, not a hard block (#735) ... Corrects the "run non-nested only" conclusion from #734. The codegraph server is healthy (handshake ~165ms); the flakiness is that on a multi-step implementation task the agent dives into Read/grep before codegraph finishes its ~2-3s startup (worse under nested CPU contention), so it runs with no codegraph. Fix: pre-warm a persistent daemon (high idle timeout) + skip the startup re-exec (CODEGRAPH_WASM_RELAUNCHED=1) so claude connects before the agent's first turn. claude's init snapshot can show status:"pending" even when it then connects — judge by actual codegraph usage, not the init line. ab-new-vs-baseline.sh now bakes in the pre-warm + skip-re-exec. Validated: a clean A/B showed the new build's agent used codegraph 2x / 5 Reads vs the baseline's 0 / 8 on the same fully-implemented task. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 10:25:40 -04:00
Colby Mchenry	28c5268ee3	docs(agent-eval): evals must run non-nested + add ab-new-vs-baseline.sh (#734) ... Running scripts/agent-eval against a `claude -p` spawned from within a Claude Code session (nested, e.g. from a Bash tool call) makes the codegraph MCP attach unreliable: the server is healthy (full handshake ~165ms) but the nested client marks it status:"pending"/0-tools under CPU/timing contention, so the agent silently runs with no codegraph. NO_DAEMON + `< /dev/null` don't fix it — it's the nested client, not the server. Documented in CLAUDE.md's validation methodology. Adds ab-new-vs-baseline.sh: A/Bs a retrieval/steering change as new-build vs baseline-build (both codegraph-on, isolating the change — vs run-all.sh's with-vs-without), on a throwaway copy of an indexed repo. Run it in a real terminal. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 09:59:07 -04:00
Colby Mchenry	68eaf0dbd8	feat(mcp): codegraph_explore as the sole primary tool + store coverage + overload disambiguation (#647) ... ## Summary Completes the explore-overhaul arc: `codegraph_explore` becomes the single primary tool an agent reaches for, and its coverage + output shape are tuned so flow/architecture questions resolve with near-zero Read/Grep. ### What changed - **explore is the sole primary tool** — removed `codegraph_context` (the fuzzy-input Read-trigger) and `codegraph_trace` (under-picked by agents); explore already surfaces the call flow among the symbols you name. A plain natural-language question now works as the query. - **Store/handler coverage** — functions defined inside object literals (Zustand `create((set, get) => ({ … }))`, Redux/Pinia/MobX, exported handler/route maps) are indexed as real symbols, including calls through `useStore.getState().fn()` and destructured `const { fn } = useStore.getState()`. A general AST rule, not a per-lib hack. - **Overload disambiguation** — explore leads with the *right* definition when a method name is overloaded across types (a PascalCase type token in the query biases to that type's own def); `codegraph_node` returns *every* overload's body in one call, with an optional `file`/`line` selector to pin one. - **Method-atomic render** — explore never returns half a method; at the size budget it drops whole methods/files (and lists what it dropped) instead of truncating a body mid-method. - **Native-read-shaped output** — per-call output is capped to ~24K with a 25K hard ceiling and concentrated into ~150–250-line flow windows, mirroring how the agent natively reads; repo size scales the *call* budget, not the per-call size (a larger response just gets externalized to a file the host Reads back). - **Blast radius** folded into explore (dependents + covering tests, locations only). ### Benchmark (refreshed on this build) Re-validated the 7-repo A/B on 2026-06-02 (Opus 4.8, effort=high, median of 4). WITH arm re-measured on this build, WITHOUT reused: **~16% cheaper · 47% fewer tokens · 22% faster · 58% fewer tool calls** — 0 file reads on 6 of 7 repos (Gin ~1). The arc trades larger, cache-heavy explore responses for guaranteed near-zero reads, so cost/token margins soften vs the prior build (Excalidraw and Tokio land at cost break-even) while time and tool-calls stay clear wins everywhere — consistent with the project's stated optimization target (latency + tool-calls, not token cost). ### Validation - Full suite green: **1112 passed, 2 skipped**. - 28/28 plain WITH runs across the 7 README repos completed clean; reads median 0 on 6/7. 🤖 Generated with [Claude Code](https://claude.com/claude-code)	2026-06-02 10:15:27 -05:00
Colby Mchenry	89d4d37a29	feat(npm): restore programmatic/embedded SDK API (#354) (#603) ... The 0.9.x thin-installer turned @colbymchenry/codegraph into a bin-only shim: require("@colbymchenry/codegraph") threw MODULE_NOT_FOUND and no types shipped, breaking embedded library consumers (e.g. Electron apps) upgrading from 0.8.0. Restore programmatic use without re-bloating the thin shim or duplicating the ~49 MB of grammars the per-platform bundle already carries: - main -> npm-sdk.js re-exports the installed per-platform bundle's compiled library (lib/dist/index.js) at runtime, reusing that bundle's own deps; it falls back to a self-healed cache bundle, else throws an actionable error. - types -> ship the .d.ts tree only (~590 KB) in the main package, built from the same release so it can never skew from the runtime it re-exports. - exports map resolves the `types` condition (nodenext) and the default entry. - DatabaseConnection + QueryBuilder are now top-level exports, so embedded callers get the building blocks from the package entry instead of deep dist/ imports (which the shim no longer ships). The CLI/MCP `bin` keeps execing the bundled Node; only library consumers run on their own runtime, which must be Node 22.5+ for the built-in node:sqlite. Validated end-to-end: built a real darwin-arm64 bundle, packed the npm packages, installed them into a throwaway consumer, and confirmed require() plus a full init/indexAll/searchNodes round-trip and the low-level DatabaseConnection/QueryBuilder path all work on the host Node; types resolve under both nodenext and classic node resolution; and the CLI shim still launches. New hermetic tests cover npm-sdk resolution, cache fallback, and the missing-bundle error. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-05-31 19:05:40 -05:00
Colby Mchenry	3a1ddf41cd	feat(mcp): trace relevance + closure-collection + god-file rendering + cold-start handshake (#580) ... Trace endpoint relevance (overloaded names resolve to the real implementation instead of an empty protocol/delegate stub), Swift closure-collection synthesizer, multi-phase god-file explore rendering, and serve --mcp cold-start handshake sped ~811ms→~90ms (proxy answers initialize/tools-list locally). Full suite green (1090 pass).	2026-05-31 18:41:41 -05:00
Colby Mchenry	f58de8a391	feat(resolution): gin middleware-chain synthesizer + Opus 4.8 benchmark refresh (#547) ... * fix(agent-eval): detect idle by content-stability, not spinner absence Opus 4.8's extended-thinking TUI shows no spinner / interrupt hint / timer while it streams its final answer — those appear only during the thinking and tool-use phases. The old detector treated ~5s of not-busy + prompt-present as done, so it killed interactive runs mid-answer, silently truncating both arms of the tmux A/B (low tool counts; the final assistant message left as a mid-investigation preamble). Now a run is done only when the captured pane stops changing for ~8s; while streaming, the pane changes every poll so stability never accrues. BUSY_RE stays as the immediate busy-reset for the thinking/tool/live-timer phase. Content-stability is model-agnostic — it survives future spinner re-wordings. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs(readme): refresh VS Code benchmark on v0.9.7 + Opus 4.8 Re-ran the VS Code A/B (headless median-of-4) on the current build and model. Cost savings held at 26% ($0.66->$0.89), but token/time/tool-call savings narrowed (78->63%, 52->20%, 85->69%) because Opus 4.8's without-CodeGraph arm explores far more efficiently than 4.7's did (16 tool calls vs 55, no Explore-subagent fan-out); the WITH arm is unchanged at 5 calls / 0 reads. Recomputed the average row and noted that the VS Code row is now a different model/version epoch than the other six. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(resolution): synthesize gin middleware-chain edges (Next -> registered handlers) Gin runs its entire handler chain through one dynamic line in (*Context).Next -- c.handlers[c.index](c), a slice-index dispatch tree-sitter can't resolve. So callees(Next) dead-ended at the len() helper and the flow ServeHTTP -> handleHTTPRequest -> Next stopped at the exact symbol a 'how does the middleware chain work' question is about, sending the agent to re-query and Read/grep (a measured gin WITH-arm rabbit-hole: 2/4 headless runs spiraled to ~5min, one mis-firing the opt-in Workflow orchestration tool). Find the chain dispatcher (a Go method invoking a handlers slice by index) and link it -> every HandlerFunc registered via .Use/.GET/.../.Handle, so callees(Next) and trace(ServeHTTP, handler) connect end-to-end. Gated on the dispatcher existing (inert on non-gin Go repos), named handlers only (inline closures skipped), capped; provenance heuristic / synthesizedBy gin-middleware-chain, registeredAt = the registration site. Validated: gin callees(Next) now surfaces Logger/Recovery/ErrorLogger + handlers (node count stable at 2,544; 5 precise edges); agent A/B (headless median-of-4, Opus 4.8) flipped gin from -58% cost / -129% time to +7% cost / +35% tokens / +8% time / 38% tool calls, all 4 WITH runs clean (0 Read/Grep/Bash). 167/167 unit tests pass incl. the new gin-middleware-chain test. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs(readme): publish uniform Opus 4.8 benchmark + per-repo breakdown accordion Refresh all 7 benchmark rows to the v0.9.7 / Opus 4.8 headless median-of-4 (was a mix of the 4.8 VS Code row + six 4.7 rows). New average 18% cheaper / 51% fewer tokens / 16% faster / 57% fewer tool calls; headline + methodology note updated 4.7->4.8. The gap is smaller than the prior 4.7 numbers because Opus 4.8's native grep/read is more efficient (the without-arm no longer fans out into large Explore-subagent sweeps) -- not a codegraph regression; CodeGraph still cuts tool calls and tokens on all 7 repos, with cost marginal/negative only on django + okhttp. Adds a top-level 'Per-repo breakdown' accordion (per-metric Time/Reads/Grep-Bash/Tool calls/Tokens/Cost, WITH vs WITHOUT, per repo) directly below the condensed summary; methodology/queries/why-wins move to a second accordion. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs(changelog): note Gin middleware-chain synthesizer under [Unreleased] Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-05-28 23:41:11 -05:00
Colby Mchenry	71935e37c2	feat(mcp): multi-module Go trace-quality + small-repo retrieval tuning (#494) ... * feat(go): generated-file down-rank + gRPC stub-impl bridge + trace-failure inlining Multi-pronged fix to make codegraph competitive on Go multi-module repos (cosmos-sdk, etcd) where it previously lost or tied. Driven by an 8-question agent-eval audit across cobra, gin, prometheus, cosmos-sdk, and etcd: the baseline had codegraph losing ~60% on cost on cosmos-sdk and mixed on etcd deep cross-module flows, while winning cleanly on the single-module and non-protobuf-heavy repos. Diagnostics ruled OUT `go.work` parsing as the gap (prometheus crushes without it). The actual failure modes were generated-file noise warping disambiguation, missing gRPC interface→impl bridge in structural-typing Go, and trace's failure path triggering 3-5 follow-up tool calls instead of inlining the material the agent needed. Changes: - New `src/extraction/generated-detection.ts` — path-pattern classifier for `.pb.go`, `.pulsar.go`, `_grpc.pb.go`, `_mock.go`, `_mocks.go`, `mock_*.go`, `.generated.[jt]sx?`, `_pb2(_grpc)?.py`, `.pb.{cc,h}`, `.g.dart`, `.freezed.dart`. Applied as a stable sort tiebreaker in `findSymbol`, `findAllSymbols`, `codegraph_search` (MCP + CLI), `codegraph_explore` file ranking, and context formatter Entry Points / Related Symbols / Code blocks. Cosmos's `msgServer.Send` now ranks #3 instead of #9 on a `Send` search. - New `goGrpcStubImplEdges` synthesizer in `callback-synthesizer.ts` — detects `UnimplementedXxxServer` structs in generated files, identifies their RPC methods (excluding `mustEmbed*` / `testEmbeddedByValue` gRPC markers), and emits `calls` edges to the matching methods on any non-generated struct whose method-name set is a superset. Closes Go's structural-typing gap that the existing `interfaceOverrideEdges` (Java / Kotlin only) couldn't bridge. 467 bridge edges on cosmos-sdk; bank's `UnimplementedMsgServer::Send` points to `x/bank/keeper/msg_server.go` only, not to `msgClient` siblings or mock files. - Trace-failure rewrite (`handleTrace`) — when no static path connects endpoints, instead of telling the agent to call `codegraph_node` (a 3-4-call fan-out), inline both endpoints' bodies (120 lines / 3600 chars per endpoint), their callers (≤6), and callees (≤8) in one response. - Trace endpoint-pairing improvements — scores every `from`×`to` candidate combo by shared directory prefix and tries the best-paired pair first (the full candidate set, not just FTS top-5). A less-canonical-path penalty (`enterprise/`, `contrib/`, `examples/`, `vendor/`, `third_party/`, `deprecated/`, `legacy/`) ensures the canonical-module pair wins even when a side-experiment shares more of its directory prefix. Find-path probe budget capped at 20 pairs. - Test-file deprioritization in `codegraph_explore` `isLowValue` — adds suffix patterns (`_test.go`, `_spec.rb`, `.test.ts`, `.spec.tsx`, `Test.java`, `Spec.kt`) alongside the existing directory-style patterns. Otherwise etcd's `watchable_store_test.go` consumes 5K chars of explore budget that should go to the hand-written flow source. Tests: - New `__tests__/generated-detection.test.ts` (4 unit tests) pins the suffix patterns. - New "Go gRPC stub→impl synthesis" integration test suite in `frameworks-integration.test.ts` (2 tests): positive bridge from stub to hand-written impl, AND the precision case (don't bridge to a generated sibling like `msgClient` in the same .pb.go). - Full suite: 1076/1076 pass. Empirical (post-fix, n=2 average per question): | Repo / Q | WITH | WITHOUT | Reads (W/WO) | Time (W/WO) |-------------------------|------------|-------------|--------------|------------ | cobra (parse cmds) | $0.27 | $0.27 | 0 / 4 | 39s / 60s | prometheus (scrape→TSDB)| $0.63 | $0.70 | 0 / 6 | 106s/143s | cosmos-sdk Q1 (MsgSend) | $0.41 | $0.26 | 1 / 2 | 67s / 64s | cosmos-sdk Q2 (Delegate)| $0.47 | $0.46 | 0 / 5 | 50s / 73s | cosmos-sdk Q3 (gov tally)| $0.34 | $0.31 | 1.5 / 3 | 54s / 76s | etcd Q1 (Put→raft) | $0.65 | $0.78 | 0 / 4 | 98s / 129s | etcd Q2 (watch) | $0.36 | $0.50 | 0 / 4+ | 58s / 89s Codegraph wins on reads + time on every question. Cost is mixed: 3 clean wins, 3 tied (within 10%), 1 stubborn cost loss on the grep-favored Q1. Compared to baseline, the cosmos-sdk cost-gap collapsed from -60% to -15% on average, and Q3 went from a 75% loss to a tie. Raw run artifacts in `/tmp/cg-finalv2-*/` and `/tmp/cg-final-*/`. Memory written at `project_go_multi_module_audit.md` for the methodology + before/after numbers. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): auto-inline trace in codegraph_context for flow queries When a codegraph_context task contains a flow keyword ("trace", "from", "reach", "flow", "propagat", "how does", "how do") AND at least two distinct PascalCase / camelCase identifiers, internally invoke trace between the first two extracted symbols and splice the trace body into the context response. Conservative trigger by design: false positives waste one graph query; false negatives just fall back to the agent calling trace itself (existing path-proximity wiring handles either case). Goal: collapse the agent's typical context → trace → explore sequence into a single context call for clear flow queries, closing the remaining cost-overhead gap on multi-call patterns. The path-proximity + less-canonical-path scoring + the trace-failure-inlined-bodies behavior already let the inline trace land on the right endpoint pair and return enough material that no follow-up codegraph_node/Read is needed. Doesn't fire on: - cobra's "How does cobra parse commands and flags?" (no PascalCase symbols) — verified in regression run, no behavior change ($0.260 WITH vs $0.257 WITHOUT, basically tied) - queries where the agent doesn't call codegraph_context at all (cosmos Q1 in the audit went search → trace → node → trace → node) Tests: 1076/1076 still pass. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): trace failure inlines TO file siblings to displace node fan-out The cosmos-Q1 audit revealed a static-resolution gap: msgServer.Send's *real* next hop is `k.Keeper.SendCoins` — an interface-method call on an embedded field that tree-sitter can't resolve. The static getCallees list for msgServer.Send is all utility/error functions (StringToBytes, Wrapf, …). The actual flow (SendCoins → subUnlockedCoins → addCoins → setBalance) lives entirely inside `x/bank/keeper/send.go`, which is also where the TO endpoint (setBalance) lives. When trace fails (no static path), inline the **top 5 functions/methods in the destination file**, ordered by line-distance from the TO node. This catches the flow that interface-method calls obscure — the canonical "k.<Iface>.<Method>" pattern in Go, also relevant to Java dependency-injection / Rails service-object dispatch / etc. where interface dispatch hides the real call. Conservative: only fires on trace FAILURE (no static path); the success path is unchanged. Per-body cap (40 lines / 1200 chars), top 5 siblings. Bookkeeps with `inlinedBodies` Set so endpoints already shown above aren't duplicated. Result: cosmos-Q1 — historically the most stubborn cost loss (-2.2× to -39% across the audit) — flipped to a clean WIN: $0.257 WITH vs $0.449 WITHOUT (-43%), 34s vs 79s, 0 Reads vs 2 Reads + 5 Greps, 5 codegraph calls vs 12. Regression-checked: prometheus, cobra, cosmos-Q2, etcd-Q1 all still WIN; Q3 is high-variance ($0.30-$0.45 range historically) and fell within that on this run. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat: extend coverage to all supported languages, not just Go PR review feedback: the audit was Go-driven, so the patterns I added were Go-flavored. Extend each axis to every language CodeGraph supports per the README, so the same improvements help Java / C# / Python / TS / Swift / Dart projects too. **generated-detection.ts** — Added patterns for: - TS/JS: `.gen.[jt]sx?`, `.pb.[jt]s`, `_pb.[jt]s`, `_grpc_pb.[jt]s` (ts-proto, gRPC-web, Apollo / GraphQL codegen, Hasura). - Python: `_pb2.pyi` (mypy stubs from protobuf). - C#: `.g.cs` (T4 / Razor codegen), `Grpc.cs` (protoc-gen-csharp). - Java: `OuterClass.java` (protoc-gen-java), `Grpc.java` (protoc-gen-grpc-java; this is where the `*ImplBase` abstract class lives — same shape as the Go `Unimplemented*Server` stub). - Swift: `.pb.swift` (protoc-gen-swift). - Dart: `.pb.dart`, `.pbgrpc.dart`, `.chopper.dart`. - Rust: `.generated.rs`. **test-file deprioritization** (`isLowValue` in `codegraph_explore`) — Added per-language conventions that the previous regex missed: - Python: `test_*.py` (pytest discovery) and `*_test.py`. - Ruby: `*_test.rb` (minitest) — `*_spec.rb` already covered. - C#: `*Tests.cs`, `*Test.cs`, `*Spec.cs`. - Swift: `*Tests.swift` (XCTest). - Dart: `*_test.dart`. **IFACE_OVERRIDE_LANGS** in `callback-synthesizer.ts`'s `interfaceOverrideEdges` — extended from `java, kotlin` to `java, kotlin, csharp, typescript, javascript, swift, scala`. Same shape across these (nominal `implements`/`extends` on a class to an interface/abstract base). Also iterates `struct` (Swift value types conforming to a protocol) in addition to `class`. The existing matchesSymbol-style logic and `getOutgoingEdges(..., ['implements', 'extends'])` work unchanged. **CLAUDE.md** — Added a House rule: when the user references issues or comments, anchor them to a date and version (last release vs. last main commit vs. current branch tip) BEFORE concluding a fix is incomplete. Issue #388 comments from May 25-27 were responding to the released v0.9.5 / merged-PR-469 state — not to this branch's in-flight work. The new rule walks through the disambiguation: `grep -m1 '^## \[' CHANGELOG.md` for release version, `git log --first-parent main -1` for main tip. Tests: 1076/1076 still pass. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): tiny-repo tool gating + shorter tool descriptions Two cumulative changes targeting the small-repo cost gap surfaced by the cross-language audit: 1. **Tool descriptions trimmed** (~2.1KB total saved across 10 tools). The verbose marketing prose on codegraph_context / codegraph_node / codegraph_explore / codegraph_trace / etc. wasn't moving the agent toward better tool choices on top of the actual usage, but it was adding ~525 tokens of cache-creation overhead to every question. The trimmed descriptions keep the operational hints (e.g. "Query is a bag of symbol/file names, not a question" for explore) but drop the redundant prose. 2. **Dynamic tiny-repo tool gating** in `ToolHandler.getTools()`. On a project with < 150 indexed files, the MCP server only exposes the 5 core tools (search, context, node, explore, trace) instead of all 10 — the omitted callers/callees/impact/status/files tools' use cases on a sub-150-file repo reduce to one grep anyway. The MCP tool-defs overhead is the #1 source of cost loss on tiny repos (~$0.10-0.15 fixed cache-creation per question); cutting 5 tools drops that by ~50%. Effect on ky (~25 files, the worst pre-fix offender): - Before: $0.59 WITH vs $0.42 WITHOUT (+42% loss, n=1) - After: $0.32 WITH vs $0.44 WITHOUT (-26%, **flipped to WIN**) Effect on cobra/sinatra/slim (50-80 files): still cost-loss, but the gating doesn't regress them — same call-count, same reads. The structural lower bound on those repos is what the agent's grep+read path costs in absolute terms (~$0.20-0.30). Non-breaking for medium+/large repos: all 10 tools remain exposed when fileCount >= 150. Tests: 1076/1076 still pass. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): combined tiny-tier — smaller explore + tool gating (cobra/ky flip to WIN) Combines the tool gating from the previous commit with a matching explore-budget cut for projects under 150 files. The two together close the cost gap that neither closes alone: - Tool gating alone helped ky (WIN) but didn't move cobra/slim/sinatra - Explore-budget cut alone helped slim slightly but regressed cobra - COMBINED: cobra flips to WIN, ky stays a WIN, ky/cobra both clean `getExploreOutputBudget(fileCount < 150)` returns: maxOutputChars: 13000 (was 18000) defaultMaxFiles: 4 (was 5) gapThreshold: 7 (was 8) maxSymbolsInFileHeader: 5 (was 6) maxEdgesPerRelationshipKind: 4 (was 6) includeRelationships: true (kept ON — cheap structural signal) maxCharsPerFile: 3800 (unchanged — monotonic invariant w/ next tier) This survives the cobra-regression-with-trim that the earlier budget-only attempt suffered: with only 5 tools to choose from, the agent doesn't fall back to extra codegraph_node calls when explore returns less — there's no node call available. Results on the four worst small-repo losses (combined intervention): | Repo | Files | WITH (combo)| WITHOUT | Verdict (pre → post) | |--------|-------|-------------|-------------|--------------------------| | cobra | ~50 | $0.25 | $0.31 | loss → **WIN** (-19%) | | ky | ~25 | $0.39 | $0.39 | -42% → tied | | slim | ~80 | $0.31 | $0.24 | LOSS 31% → still LOSS | | sinatra| ~60 | $0.30 | $0.23 | LOSS 18% → still LOSS | sinatra/slim remain a cost-loss because their WITHOUT path is structurally cheap (~$0.20 — fewer than 4 cheap grep+read calls). Codegraph can't beat that absolute floor with any meaningful response. Both still WIN on time + reads + tool-call count. Tests: tier boundary cases updated to cover the new <150 / 150-499 / 500-4999 / 5000-14999 / >=15000 progression. Off-by-one guard updated to include the new 149↔150 boundary. All 1076 tests pass. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(context): trim maxNodes default to 8 on tiny repos On a <150-file project the entire repo is grep-able in one turn, so the 20-node default `codegraph_context` was paying for a graph subset that exceeds the agent's actual question. Cutting the tiny-repo default to 8 (typical 1-3 entry points + their immediate 1-hop neighbors) reduces the context-tool response body without hitting sufficiency on the flow shapes small repos actually contain. Non-breaking: the agent can still pass an explicit `maxNodes` to override; medium+ repos (>=150 files) keep the 20-node default. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(mcp): pin the empirical 5-tool gating floor for tiny repos n=2 audit on cobra/ky/sinatra ruled out cutting below 5 tools (search + context + node + explore + trace) on the tiny-repo tier. The smaller 3-tool gate (search + context + trace) saved ~$0.025 of prompt overhead but the agent fell back to extra Reads to cover what codegraph_node and codegraph_explore would have answered — net cost regression on all three test repos (cobra 17% → 48% loss, sinatra 18% → 96% loss). Documented inline so future tuners don't re-try this dead-end. No behavior change beyond the comment: the 5-tool gate remains the production setting. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(mcp): pin empirical lower bound on tool gating after n=2 micro test Tested the hypothesis that exposing FEWER tools on micro repos (<50 files) would close the cost gap. Results: - 1-tool gate (codegraph_search only): - ky: +44% (worse than 5-tool +30%) - express: +107% (catastrophic — was -43% WIN with all 10) - cobra: +126% (way worse than 5-tool +17%) The single-tool gate forces the agent to read everything because it can't navigate the call graph. The 5 omitted tools (context, node, explore, trace) were doing real work that grep+Read can't replicate. Conclusion: 5 tools (search + context + node + explore + trace) is the empirical lower bound on the tiny-repo tier. Cutting below regresses EVERY tested repo. The remaining ~$0.04-0.08 of structural cost overhead on tiny repos is unavoidable without sacrificing the value codegraph provides at that scale (which would also make WITH = WITHOUT, defeating the install). Comment documents the dead-ends so future tuners don't relitigate. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): iter3/iter4 — raise tool-gate to 500, sufficiency steering in context, hard-exclude low-value files Three layered changes targeting the sinatra/slim/small-repo cost gap that iter2's body-shrink failed to close (smaller bodies just pushed the agent to Read instead): 1. **Tool-gate threshold 150 → 500** (`TINY_REPO_FILE_THRESHOLD`). Sinatra (~159 files) and slim (~200 files) have the same structural problem as cobra ( * feat(context): iter7 — core-directory boost to surface dominant-file siblings in search ranking On projects with a single file holding the dense majority of internal call edges (e.g. sinatra's `lib/sinatra/base.rb` at ~85% of in-file edges), text search was favoring small focused extension files over the core file. A small focused file like `multi_route.rb` wins on verbatim name match + file-size normalization, burying the 1500-line core file's longer method names (e.g. `route!` vs `route`). Fix: detect the "dominant file" — the file whose in-file edge count is ≥3× the next candidate's — then add +25 to all results sharing its directory prefix. This pulls the core file's siblings above sibling-package extensions without hardcoding any repo structure. `getDominantFile()` excludes test/spec files and generated files (e.g. etcd's `rpc.pb.go` has 4× the in-file edges of `server.go` and would otherwise hijack the boost toward generated protobuf stubs). SQL pulls the top 20 candidates; path-pattern filtering handles what SQLite LIKE can't express. * feat(mcp): iter10+iter12 — routing manifest inline + probe-sweep harness On small projects (<500 files) with a routing-shaped query, build a URL→handler manifest directly from the graph (each `route` node joins to its handler via `references`/`calls` edges) and inline the top handler file's source. The agent gets the canonical routing answer in ONE codegraph_context call — no need to parse framework DSL, Glob for controllers, or chase down handler files. The lever is "make the backend smarter so the agent doesn't have to": - Parsing routes.rb / routes/api.php / urls.py DSL is the agent's job in the WITHOUT arm. Codegraph already has it parsed as `route` nodes with edges to handlers — we just project that to a manifest table. - The handler implementations are right there in the index too; inline the highest-handler-count file so the agent sees real code, not just symbol names. Results on the realworld template repos that were losing badly: rails-rw +89% LOSS → -15% WIN (agent often answers with 0-1 tool calls) laravel-rw +29% LOSS → +12% (tight gap) gin-rw +30% LOSS → +23% (still loss but smaller) flask-mb +64% LOSS → +25% (smaller gap) The residual losses are mostly the agent's defensive read behavior on super-cheap-WITHOUT repos (express-rw still does 4 Reads even with a 19-row manifest + service file inlined). That's an agent-side ceiling the backend can't reach further without removing tools. Also lands `scripts/agent-eval/probe-sweep.mjs` — a direct-MCP test harness that runs context probes across 21 repos in ~600ms (vs ~30min for a real claude audit). Enables rapid iteration on backend changes: edit tools.ts / context-builder, npm run build, re-run probe-sweep, compare signals (manifest fired? handler file inlined? response size?) before paying for a claude run. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(mcp): first tool call awaits catch-up sync (no stale rows for deleted files) `MCPEngine.catchUpSync()` reconciles the index against the working tree after open (catching `git pull`/`checkout`/`rebase` and any edits or deletes made while no server was running). It was fire-and-forget — so a tool call landing in the first ~50-300ms could race past it and serve rows for files that no longer exist on disk. The per-file staleness banner can't help here, because that signal is populated by the file watcher (not by catch-up). The fix: `catchUpSync()` now pushes its promise into `ToolHandler` via `setCatchUpGate(p)`; the first `execute()` call awaits the gate and then clears it. Subsequent calls pay nothing. Catch-up rejections are logged by the engine and swallowed by the handler so a transient sync failure never breaks tools. Most visible on the "deleted everything between sessions" case, where MCP previously returned stale rows pointing at non-existent files. Validated end-to-end on a 10,640-file VS Code index: with the gate, a codegraph_search for "ExtensionHost" against an empty (but stale-DB) directory returns "No results found" after the catch-up drains the DB; without the gate, the same call returns 10 stale hits. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(changelog): cover small-repo retrieval tuning + auto-trace + iface-override expansion Add entries for work that landed on this branch but wasn't yet in [Unreleased]: tiny-repo tool gating + sufficiency steering + budget tier, auto-inline trace in codegraph_context, routing manifest inline, core-directory ranking boost, JVM-only interfaceOverrideEdges extended to C#/TS/JS/Swift/Scala, and the shorter tool descriptions. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-28 12:38:03 -05:00
Colby Mchenry	f6fabe9b5a	docs(claude): rewrite release section for auto-promote workflow + link-ref on promote (#437) ... Two paired updates: 1. **`CLAUDE.md` § Releases** — rewritten to match the actual workflow now that #436's auto-promote step lands the entries automatically. The old text told Claude to 'Add a new `## [X.Y.Z] - YYYY-MM-DD` block at the top of CHANGELOG.md' as the first step. That instruction is the exact pattern that caused the v0.9.5 sparse-release-notes incident — a hand-added sparse `[X.Y.Z]` block (one early fix pre-staged) is what the extractor picked, ignoring everything under `[Unreleased]` above it. New default: write entries under `## [Unreleased]` during normal work. The Release workflow promotes them at release time. The formatting rules (sub-section grouping, user-perspective wording, issue/PR refs) are preserved. The link-reference rule moves to 'don't add it yourself' since `prepare-release.mjs` now appends it. 2. **`scripts/prepare-release.mjs`** — extended to also append a `[X.Y.Z]: https://github.com/colbymchenry/codegraph/releases/tag/vX.Y.Z` link reference at the end of CHANGELOG.md when promoting (idempotent — no-op if one already exists, regardless of where in the file it sits). This is what makes the `## [X.Y.Z]` heading text auto-link to its release tag in GitHub's renderer; without it the heading still renders, just unlinked. 3 new tests cover Case A append, Case B append-when-merging, and no-double-add. 940/942 existing tests still pass (2 pre-existing skips); +3 new tests. Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-26 03:25:06 -05:00
Colby Mchenry	b77af782c5	feat(release): auto-promote [Unreleased] into [<version>] on release workflow run (#436) ... Fixes the silent-sparse-release-notes failure mode that surfaced on v0.9.5: the Release workflow used to do a literal `extract-release-notes.mjs <version>` lookup with an `[Unreleased]` fallback. The fallback only triggered when the `[<version>]` block DIDN'T exist at all — and in practice maintainers sometimes had a sparse `[<version>]` block pre-populated (e.g. one early fix documented before the rest of the work landed). The workflow then extracted that sparse block, ignoring the much-larger `[Unreleased]` section above it. Result: the published v0.9.5 release notes were missing the shared MCP daemon, the per-file staleness banner, the Objective-C indexing, AND the Mixed iOS/RN/Expo bridging. The fix is a new `scripts/prepare-release.mjs` step that runs at the start of the workflow: Case A — `[<version>]` does not yet exist: Rename `[Unreleased]` → `[<version>] - <today>`. Add a fresh empty `[Unreleased]` above. The common path. Case B — `[<version>]` exists AND `[Unreleased]` has content: Merge `[Unreleased]`'s sub-sections (### Added / ### Fixed / ### Changed / ### Removed / ### Deprecated / ### Security) into the corresponding sub-sections of `[<version>]`. Unmatched sub-sections are appended. Then empty `[Unreleased]`. Case C — `[Unreleased]` is empty: No-op. Re-runs of the workflow are safe. After the script runs, the workflow auto-commits + pushes the CHANGELOG.md change back to main (with a `[skip ci]` tag in the commit body) so future runs and human eyes both see the same on-disk truth. 9 unit tests (`__tests__/prepare-release.test.ts`) cover all three cases, idempotency, version-source precedence, and an extract-release-notes.mjs integration check. Workflow comment header rewritten to reflect the new flow. Trigger reminder going forward: bump package.json. CHANGELOG entries can live under `[Unreleased]` — the workflow takes care of moving them. 937/939 existing tests pass (2 pre-existing skips); +9 new tests. Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-26 03:21:06 -05:00
Colby Mchenry	025ebc88d6	Release 0.9.4: framework-aware routing + dynamic-dispatch coverage + retrieval improvements (#365) ... * feat(resolution): close dynamic-dispatch coverage holes (callback synthesis + django ORM) Static tree-sitter extraction misses calls whose target is computed or indirect, so flows through callbacks, observers, and descriptors were absent from the graph. - callback-synthesizer.ts: whole-graph pass after base resolution. Detects registrar/dispatcher channels (field-backed observers + string-keyed EventEmitters), correlates registration sites, and synthesizes dispatcher->callback `calls` edges (provenance:'heuristic'). Records the registration site (registeredAt) in edge metadata. Precision guards: named handlers only, registrar-name match, event fan-out cap. - frameworks/python.ts + resolution/{index,types}.ts: claimsReference hook + django ORM resolver (_iterable_class -> ModelIterable.__iter__). - extraction/tree-sitter.ts: extract named nested functions so inline named handlers become linkable nodes. trace(mutateElement, triggerRender) and trace(_fetch_all, execute_sql) now connect; node count stable (no explosion). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): self-sufficient flow output + fix explore budget regression - Surface synthesized-edge evidence in trace, the node trail, and context call paths: a dynamic-dispatch hop now shows "callback via onUpdate @App.tsx:3148" with the registration site inline (and trace inlines each hop's call-site source line) -- the exact glue agents previously Read/Grep'd to reconstruct. - Fix non-monotonic explore output budget: the 500-5000 file tier capped maxCharsPerFile at 2500, BELOW the <500 tier's 3800, so on god-file projects (excalidraw's 415 KB App.tsx) one explore returned <1% of the file and forced a Read. Raised to 6500/file, 28000 total. - Stop explore from inviting Read: truncation/trim notes said "use Read for more"; they now steer to another codegraph_explore and treat returned source as already Read. Measured on excalidraw: best-case flow answer went from 5 reads / 131s to 0 reads / 73s with ~3-4 codegraph calls. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore(agent-eval): coverage probes, block-read hook, and design docs Dev-only validation harness for the dynamic-dispatch coverage work: - probe-{trace,node,context,explore}.mjs: drive MCP tools against a built index without a full agent run. - block-read-hook.sh + hook-settings.json: PreToolUse experiment that denies source Reads to measure codegraph sufficiency (forced Read-0). - docs/design/: callback-edge-synthesis + dynamic-dispatch-coverage playbook. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): bridge React boundaries — re-render + JSX child synthesis Closes the two dynamic-dispatch hops that broke "state mutation -> on-screen render" flows in React apps. Both are call-invisible (React-internal) but the code between them is fully call-connected, so one synthesized edge each makes the whole flow trace end-to-end. - reactRenderEdges: setState(...) re-runs the component's render(). For each class with a render method, link sibling methods calling this.setState -> render. The setState gate keeps it to React class components. - reactJsxChildEdges: a component that returns <Child .../> mounts Child. Link parent -> each capitalized JSX child, resolved to a component/function/class node (the resolution gate drops TS generics like Array<Foo>). File-oriented, capped per parent. - Surface both in synthEdgeNote (trace + node trail) and context call-paths. Validated on excalidraw: trace(mutateElement, renderStaticScene) now connects in 6 hops across callback -> react-render -> jsx-child; 1 + 46 + 280 synthesized edges, node count stable (no explosion). Partial coverage is worse than none: react-render alone raised agent reads (revealed a hop it then drilled); adding the jsx hop closed the flow and dropped reads to 0-1. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(claude): retrieval performance contract + coverage validation methodology Add a "Retrieval performance & dynamic-dispatch coverage" section so future changes/PRs don't silently regress agent retrieval: - the explore call+output budget table by repo size, with the monotonic-per-file invariant (the bug that started this: <5000 tier's 2500 < <500 tier's 3800). - the "partial coverage is worse than none" principle. - the required validation methodology (small/medium/large x >=3 prompts per language x framework; deterministic probes + agent A/B; pass bar). - the Excalidraw worked example (before/after numbers) as the template to replicate for every language/framework. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(claude): use full n=4 measured range in Excalidraw worked example Best run 0 Read/3 cg/76s; typical ~1 Read/~4 cg; occasional over-drill outlier. Report the range, not a single run — run-to-run variance is large. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): steer flow questions to codegraph_trace first (tightens variance) codegraph_trace was absent from every steering intent map — all three guidance files routed "how does X reach Y" to context+explore, never to the trace tool. So agents used trace only by chance; when one didn't, it floundered reconstructing the path with search+callers (an 18-call run vs ~6 for trace-users). Add codegraph_trace to the intent map + a "flow" common chain (trace from->to FIRST = the whole path in one call, then ONE explore for bodies) across all three synced files (server-instructions, instructions-template, .cursor rule). Validated on excalidraw (hard "to the screen" Q, n=4 before/after): - call count 3-10 -> 3-4 (over-drill outlier gone) - duration 64-112s -> 51-74s - trace adoption 3/4 -> 4/4; search+callers path-reconstruction -> 0 - fully-clean runs (0 Read, 0 Grep) 0/4 -> 2/4; best 3 cg / 0 / 0 / 51s Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Vue SFC template coverage (events + kebab components) The .vue extractor only parses <script>, so template usage is invisible — handlers and kebab child components used only in <template> have no edge. Add a vueTemplateEdges channel (scoped to the <template> block of .vue files): - event bindings: @click="onClick" / v-on:submit="save" -> handler method/function (skips inline arrows and $emit; resolves same-file first to avoid cross-app mis-match in monorepos). - kebab child components: <el-button> -> ElButton (PascalCase children like <VPNav/> are already caught by the JSX channel via the SFC component node). Surface vue-handler in synthEdgeNote (trace/node trail) + context call-paths. Validated on vue repos (reindex, no node explosion): - vue-handler edges: vitepress 15, vben 404, element-plus 603 — all precise (code-login @submit -> handleLogin, register @submit -> handleSubmit, ...). - callers(handleLogin) now includes the login component (was 0); each monorepo app's login resolves to its own same-file handler. - composition: PascalCase + kebab work; element-plus's el-/filename naming (el-button -> button.vue) is a known library-prefix limitation. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Vue validation in coverage matrix + limits Vue / Nuxt row → ✅ template events + composition (vitepress S / vben M / element-plus L); 🔬 reactive→render (vue-core Proxy runtime, deferred). §7: Vue results + the two real limits — composable-destructure handlers (@click="closeSidebar" from useSidebarControl, a data-flow frontier) and prefix-convention kebab (el-button→button.vue). Agent reads dropped in every size; strongest where handlers are local functions. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): resolve Vue composable-destructure template handlers @click="closeSidebar" where `const { close: closeSidebar } = useSidebarControl()` previously didn't resolve — the handler is a destructured composable return, not a local fn node. Now: parse the SFC's `use*()` destructures into alias→{composable, key}, and for an unresolved template handler follow alias → composable → the returned member (`close`) defined in the composable's file. Precise-only: no fallback to the composable itself (the component already has a static useX() call edge), so we add an edge only when the specific returned fn is found. Validated: vitepress Layout @click→close / @open-menu→open (in composables/ sidebar.ts); sidebar-flow agent run dropped 6→0 reads (best case). element-plus's fallback-only matches correctly drop to 0; node counts stable; direct handlers (vben handleLogin) unaffected. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): composable-destructure handlers now resolved (Vue) @click="closeSidebar" → composable returned fn; vitepress sidebar 6→0 reads. Remaining Vue limits: prefix-convention kebab + reactive→render frontier. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(extraction): extract function-valued properties of exported-const objects `export const actions = { default: async () => {...} }` (SvelteKit form actions, and general JS handler/route/reducer maps) left the arrow functions unextracted — the walker skips object-literal functions (deliberately, to avoid inline-object noise like `ctx.set({...})`). So an action's body (and its calls) was invisible. Now: for an EXPORTED const whose initializer is an object literal, extract each function-valued property (arrow / function expression) as a function named by its key and walk its body. extractFunction gains a nameOverride so ONLY this explicit path names pair-arrows — inline-object arrows reached by the general walker still fall through to the <anonymous> skip, so no noise returns. JS/TS-gated. Validated: fixtures extract the actions + walk bodies (default→helper, default→ api.post resolve); SvelteKit detection doesn't break it. Blast radius tiny: excalidraw +1 node, Python (django) +0, Vue repos +0, realworld +11 (the actions). Known residual: a `$lib`-alias namespace-member call (`api.post`) from an extracted action node doesn't resolve even though the same alias resolves for `load` — a deeper resolver interaction, separate from this extraction change. Local/relative calls from actions connect fine. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Svelte validation (already well-covered) + actions fix Svelte/SvelteKit row → already strong (template calls/composition/namespace/load); + exported-const object-of-functions extraction. Lesson: measure before assuming a hole — modern Svelte barely uses on:click={fn}; Svelte needed far less than Vue. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): connect Express inline arrow route handlers to their services The Express resolver created route nodes but linked handlers via a single regex whose `[^)]+` broke on inline arrows — so `router.post('/x', async (req,res) => {...})` (the dominant modern pattern) connected to NOTHING, and the anonymous handler's body (the actual request→service flow) was lost. The whole inline-handler API was unreachable: e.g. realworld's `POST /users/login` route → 0 edges. Now: match the route head, span the full call with a string-aware balanced-paren scan, and for an inline arrow handler extract its body's calls (string-aware brace scan) and attribute them to the route node as `calls` edges. A RESERVED denylist drops res/req/builtin methods (json, next, status, ...) to keep only business calls. Named-handler routes keep the existing reference behavior. Validated: realworld POST /users/login → login (auth.service); 19 precise route→service edges (was 0) — POST /articles→createArticle, .../favorite→ favoriteArticle, etc., no json/next noise. ghost +65 inline-handler edges. No node explosion (ghost 40767, parse 3394 unchanged). Framework-scoped: zero blast radius off Express. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Express validation (inline-handler fix) Express/Koa row → resolver already handled named handlers; the real hole was inline arrow route handlers (router.post('/x', async (req,res)=>{...})) — fixed: route→service body calls (realworld 19 / ghost 65 edges, no explosion). Agent A/B muddied by repo size (realworld tiny) / complexity (ghost layered API). Lesson inverse of Svelte: Express's dominant pattern WAS the uncovered one. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record NestJS validation (already well-covered) NestJS row → resolver handles @decorator routes; DI controller→service (this.svc.method) resolves correctly at scale (immich: addUsersToAlbum→addUsers, etc.). Agent A/B: codegraph eliminated Grep (0 vs 3). No dynamic-dispatch hole. Surfaced a general hygiene gap (not NestJS): committed dist/ build output gets indexed (no default build-dir ignore) — narrow (real apps gitignore dist/), deferred as a core-indexer follow-up. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Rails RESTful resources routing → controller#action The rails resolver only saw explicit `get '/x' => 'c#a'` routes, so apps using the dominant `resources :articles` / `resource :user` RESTful routing had ZERO route nodes (realworld + spree: 0 routes despite full routes.rb files). The whole request→controller flow was disconnected. Fix (frameworks/ruby.ts): - extract: expand `resources`/`resource` into their REST actions (only/except filters; pluralize the singular `resource :user` → users_controller), emit a precise `controller#action` ref per action. Explicit routes now also reference `controller#action` instead of a bare ambiguous `action`. - resolve: new `controller#action` pattern → the action method in <ctrl>_controller.rb (file convention + controller-class fallback). - claimsReference: claim `controller#action` refs so resolveOne's pre-filter doesn't drop them before resolve() runs (same hook the django ORM work needed — these refs name no declared symbol). Validated: realworld 0→16, forem 0→635 precise route→action edges (GET /articles→ index, resource :user→users#show, etc.), pluralization correct, no node explosion (route nodes proportional to resources). Agent A/B (forem, large): with codegraph 1-4 reads / 0 grep / 47-53s vs without 4-5 reads / 2-3 grep / 66-85s. Framework- scoped (zero blast radius off Rails). Residuals: Rails Engine routing (spree mounts an engine), ActiveRecord dynamic finders (metaprogramming frontier). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Spring bare + class-prefixed route mappings → controller method The Spring resolver required a string path in the mapping regex, so BARE method mappings (`@PostMapping` with the path on the class-level `@RequestMapping`) were missed — the dominant multi-method-controller pattern. realworld's two-action ArticleFavoriteApi only linked one method; halo had 28 routes for 2444 files. Fix (frameworks/java.ts): - Treat class-level `@RequestMapping` as a PREFIX (not a bogus route) and join it onto each method's path. - Match verb-specific mappings (@GetMapping/@PostMapping/...) BARE or with a path. - Also handle method-level `@RequestMapping(value=..., method=RequestMethod.X)` (older style) — restored after an initial cut dropped it (mall regressed 292→1; caught by the regression check). Validated: realworld 13→19, mall 246 (all precise, class prefix joined: GET /subject/listAll→listAll, POST /articles/{slug}/favorite→favoriteArticle + DELETE→unfavoriteArticle), no node explosion. DI controller→service resolves (article→findBySlug, updateArticle→canWriteArticle). Agent A/B (mall cart flow): with codegraph 0 reads/0 grep vs without 2/2. Residuals: halo's complex custom patterns (9/29 resolve); Spring Data JPA derived queries (metaprogramming frontier). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Spring validation (bare-mapping routing fix) Spring row → bare @GetMapping/@PostMapping + class @RequestMapping prefix join → route→method (realworld 13→19, mall →246); DI controller→service resolves. A first cut regressed mall 292→1 (dropped @RequestMapping-on-method), caught by the route-count regression check. Residuals: halo custom patterns, JPA derived queries. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Django DRF router.register → ViewSet Django's ORM (_iterable_class, prior work) and URL routing (path/url/as_view→view) were already covered. The remaining hole: DRF `router.register(r'articles', ArticleViewSet)` — the core CRUD endpoints — wasn't extracted (only path()/url()), so a DRF API's main resources connected to nothing (realworld's ArticleViewSet: 0 callers). Fix (frameworks/python.ts): match `.register(r'prefix', XViewSet)` → route→ViewSet class. The STRING first arg distinguishes DRF router.register from `admin.site.register(Model, Admin)` (model class first arg); View/ViewSet suffix keeps it to viewsets. The ViewSet class resolves via the existing View/ViewSet pattern. Validated: realworld VIEWSET /articles → ArticleViewSet (was 0). Narrow in corpus (realworld 1 router; wagtail=path, saleor=GraphQL) but real for DRF-router APIs. Agent A/B (wagtail Page flow, medium): with codegraph 4-7 reads / 1-4 grep / 58-81s vs without 7-9 reads / 6 grep / 82-86s. No regression (wagtail/saleor route counts unchanged — purely additive). Residuals: signals, DRF inherited viewset actions, GraphQL resolvers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Laravel route → precise Controller@method (not bare action) extractLaravelHandler discarded the controller: `Route::get([UserController::class, 'index'])` and `'UserController@index'` both emitted a BARE `index` ref. With the route in routes/api.php (not the controller file), name-matching mis-resolved every common action to the WRONG controller — realworld's GET user → ArticleController.index (should be UserController), GET articles/feed → ArticleController (should be FeedController), etc. The routes existed but pointed at the wrong handler. Fix (frameworks/laravel.ts): emit precise `Controller@method` (array + string syntax, namespace-stripped) and `claimsReference` it so resolveOne's pre-filter doesn't drop it before Pattern-4 resolveControllerMethod runs (the recurring hook, also needed by django ORM + Rails routing). Validated: realworld all routes now resolve to the correct controller; bookstack 267/332 precise (GET pages → PageApiController.list, array syntax). No node explosion. Agent A/B (bookstack page-view, large): with codegraph 2-3 reads / 1-2 grep / 51-60s vs without 4-6 / 3-5 / 60-74s. Residuals: firefly's fluent ->uses()/['uses'=>...] handler format (3/568 resolve), Eloquent dynamic finders. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Gin/chi routes on group vars (any receiver, not just r/router) The route regex matched only `(router|r|mux|app|e).METHOD(...)`, but real Gin/chi apps route on GROUP variables — `v1.GET`, `PublicGroup.GET`, `userRouter.POST` — so group-routed apps connected almost nothing: gin-vue-admin had 4 routes for 625 files. Broaden the receiver to ANY identifier; the verb + string-path + handler-arg gates keep it route-specific (e.g. `http.Get(url)` has no handler arg, so it's excluded). Validated: gin-vue-admin 4→259 routes, 257 resolve precisely (POST createInfo→ CreateInfo, GET getInfoList→GetInfoList); realworld stable 24→25 (no regression); no garbage (257/259 resolve, not false positives), node count proportional. gitness (chi, custom handlers) is a residual (26/321). Inline `func(c *gin.Context){...}` handlers still lose their body (anonymous, like Express was) — separate residual. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Gin validation (group-var routing fix) Gin/chi row → routes on ANY group var (v1.GET/PublicGroup.GET), not just r/router (gin-vue-admin 4→259 routes). Agent A/B: 0 reads/0 grep/26-30s vs 3/3/52-53s — cleanest backend win yet. Residuals: inline func handlers, gitness chi custom. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): ASP.NET feature-folder detection + bare attribute routes Two holes left ASP.NET apps disconnected: 1. detect() only fired on a /Controllers/ dir, root Program.cs/Startup.cs, or a .csproj (which often isn't in the indexed source set). Feature-folder apps (realworld: Features/*/FooController.cs, subdir Program.cs) were never detected → 0 routes despite a full set of controllers. Broaden: scan Controller/Program/ Startup .cs source for ASP.NET signatures ([ApiController]/[Route]/[Http*], ControllerBase, MapControllers, WebApplication, Microsoft.AspNetCore). 2. The attribute regex required a string path, so BARE [HttpGet] (route on the class [Route("[controller]")]) was missed — eShopOnWeb was 24 bare / 2 string. Match bare-or-with-path + join the class [Route] prefix (like the Spring fix). No claimsReference needed: ASP.NET attribute routes are co-located IN the controller with the action, so the bare method-name ref resolves same-file. Validated: realworld 0→19 routes (all precise: GET /articles→Get, POST /articles→ Create, class prefix joined), eShopOnWeb 9→33. Route→action correct + co-located. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record ASP.NET validation (detection + bare-attribute fix) ASP.NET Core row → feature-folder detection (realworld 0→19, was undetected) + bare [HttpGet] / class [Route] prefix (eShopOnWeb 9→33, jellyfin 362→399). No claimsReference needed (routes co-located in controller). Agent A/B (eShop): 1-2 reads/0 grep vs 6-7/1-6. Residual: EF Core LINQ. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Flask/FastAPI route holes + Python builtin-name handler guard Three fixes that connect the request→route→handler flow for Flask and FastAPI. Validated S/L: fastapi-realworld 12→20, flask-microblog 6→27, Netflix dispatch 290/290 (100%), redash decorator routes 6/6; canonical flows trace end-to-end (login→get_user_by_email, create_user→from_dict). - Flask: the route regex required `def` immediately after `@x.route(...)`, so an intervening decorator (@login_required, @cache.cached) or stacked @x.route lines (one view bound to several URLs) dropped the route. Switch to the findHandler scan (match the decorator, then find the next def) like FastAPI — skips intervening decorators. - FastAPI: the path regex `[^'"]+` rejected the empty path `@router.get("")` (router/prefix-root routes, frequently multi-line). Allow empty path + guard the route name against a trailing space. - Python builtin-name guard (src/resolution/index.ts): a handler named after a Python builtin method (index/get/update/count…) was filtered by isBuiltInOrExternal and lost its route→handler edge. Mirror the dotted-method branch's knownNames guard onto the bare branch — a bare name a declared symbol owns is a real target, not a builtin call. +2 legit edges on realworld, 0 change on the django control (precision held). Tests: new Flask (intervening/stacked decorator) and FastAPI (empty-path, multi-line) extractor cases + a Flask end-to-end integration test (a view named `index` behind @login_required). Also corrects 6 pre-existing stale Laravel/Rails route-ref assertions surfaced by the suite — they expected the old bare action name, but the resolvers now emit precise controller@action / controller#action (from earlier precision commits). Full suite green (781 passed). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Flask/FastAPI validation (decorator + builtin-name fixes) Matrix row Python/Flask+FastAPI 🔬→✅ and a §7 note: Flask intervening/ stacked decorators, FastAPI empty-path routes, the Python builtin-name handler guard, S/L numbers, the login-auth A/B (0–1 read/0 grep with vs 3 read/2 grep without), and residuals (Flask-RESTful class-based add_resource; redash JS file-route false-positives). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Drupal route-handler resolution (claimsReference, single-colon controllers, contrib detection) The *.routing.yml extractor and _controller/_form resolver existed but two gaps left most routes unlinked. Validated S/M/L: admin_toolbar 0→14 (14/14), webform 144/208, drupal-core 536→731/836 (87%); canonical flow traverses (getAnnouncements ← /admin/announcements_feed); node count unchanged. - claimsReference: Drupal handler refs are FQCNs (\Drupal\…\Class::method), bare form classes (\…\SettingsForm), or single-colon controller-services (\…\Controller:method). Only the ::method shape survived resolveOne's pre-filter (its member is a known method name); the bare-FQCN forms and single-colon controllers were dropped before resolve() ran. Claim FQCN / Class:method / hook_* refs (same pattern as Rails controller#action). - Single-colon controller match: broaden the controller regex from :: to :{1,2} and tighten the _form branch to !name.includes(':'). - Detection: detect() only checked composer `require` for a drupal/* dep, but a contrib module often has an empty require and is identified only by "name":"drupal/<m>" + "type":"drupal-module" (admin_toolbar → 0 routes). Broaden to composer name/type + a *.info.yml fallback. Remaining unresolved is the entity-annotation handler frontier (_entity_form: type.op) and OOP #[Hook] attributes (Drupal 11 moved ~all procedural hooks to attribute methods — out of scope here). Tests: contrib detection, *.info.yml fallback, claimsReference, single-colon controller. Full suite green (787 passed). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Drupal validation (claimsReference + contrib detection) Add the PHP/Drupal matrix row (✅) and a §7 note: the claimsReference pre-filter fix for FQCN/single-colon handlers, broadened contrib detection, S/M/L numbers (admin_toolbar 0→14, webform 144/208, core 536→731), the route→controller A/B (0 read/1 grep with vs 1 read/2 grep+glob without), and the frontier residuals (entity-annotation handlers, OOP #[Hook] attributes). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Axum chained methods + namespaced handlers The Axum route extractor used a flat regex that captured only the first method(handler) of a .route() call and only a bare \w+ handler, so two dominant Axum idioms broke: - method chains: .route("/user", get(get_current_user).put(update_user)) emitted no node for the .put arm — half the API was missing. - namespaced handlers: get(listing::feed_articles) captured `listing` (the module), so the route resolved to nothing. Rewrite with a balanced-paren scan of each .route(...) call, a route node per chained method, and last-::-segment handler names. realworld-axum 12→19 routes, 19/19 resolved (every chained PUT/DELETE/POST now present, feed_articles resolves). Rocket needed nothing (550/556, 99%, attribute macros); crates.io confirms namespaced axum handlers resolve. Residual frontier: actix runtime routing web::get().to(handler) (the dominant actix style, unextracted; attribute macros 35/51). Fix is Axum-scoped — the attribute/actix/Rocket path is untouched. Tests: chained methods + multi-line namespaced handler. Full suite green (789 passed). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Rust/Axum validation (chained methods + namespaced handlers) Update the Rust matrix row 🔬→✅ and add a §7 note: the Axum chained-method + namespaced-handler fix (realworld-axum 12→19, 19/19), Rocket already 99%, crates.io (utoipa routes! macro frontier + SvelteKit frontend routes), the update-user A/B, and the actix runtime-routing frontier. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Vapor grouped/RouteCollection routing (was 0 routes on real apps) The Vapor extractor only matched (app|router|routes).METHOD("path", use: handler), but real Vapor apps route on a grouped builder inside RouteCollection.boot(routes:): `let todos = routes.grouped("todos"); todos.get(use: index)` — any var receiver, no path arg (the path is the group prefix). Every real app tested extracted 0 routes (template, SteamPress, SwiftPackageIndex-Server, penny-bot, Feather). Rewrite the extractor: - any receiver (\w+), not just app/router/routes; - optional path segments that may be non-string (User.parameter, :id, a path constant) — the `use:` keyword discriminates a route from Environment.get("X") / req.parameters.get("X"); - a group-prefix map from `let X = Y.grouped("a")` and `Y.group("a") { X in }` so a grouped/nested route gets its full path (todo.delete(use: delete) -> DELETE /todos/:todoID). Result: vapor-template 0→3 (3/3, nested path exact), SteamPress 0→27 (27/27), SwiftPackageIndex-Server 0→14 (14/14 handler resolution). Canonical flow traverses (createPostHandler <- GET /createPost -> createPostView). Route names now carry a leading slash (GET /users), consistent with the other frameworks. Frontier: typed-route enums (SPI's SiteURL.x.pathComponents — handler resolves, path label only) and closure handlers (app.get("x"){ } — anonymous). Tests: grouped RouteCollection, self.handler + non-string segments, use:-discriminator. Full suite green (792 passed). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Vapor validation (grouped RouteCollection routing) Update the Swift/Vapor matrix row ⬜→✅ and add a §7 note: the extractor was dead on real apps (0 routes everywhere); rewrote for any receiver, optional non-string paths, .grouped/.group{} prefix tracking, and the use: discriminator. S/M/L all 100% handler resolution (template 0→3, SteamPress 0→27, SPI 0→14), the create-post A/B (0 read/0 grep with vs 1–4 read without), and frontiers (typed-route enums, closure handlers). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): React Router <Route> JSX route extraction react.ts extracted components/hooks and Next.js file routes but returned references: [], so React Router <Route> declarations produced no route nodes or route→component edges. Add <Route> JSX extraction: scan a window after each <Route (so the nested > in element={<Comp/>} doesn't truncate the match), pull path="…" + component={C} (v5) or element={<C/>} (v6) in any attribute order, emit a route node + component reference (resolved by the existing PascalCase resolveComponent). The <Routes> container is excluded via the \b boundary. react-realworld 0→10 routes, 10/10 resolved (/login→Login, /editor/:slug→Editor, /@:username→Profile). No regression on excalidraw (9,290 nodes, 46 react-render synth edges intact, 0 false routes). Tests: v5 component=, v6 element=, <Routes>-container guard. Suite green (794). Frontier: object data-router createBrowserRouter([{path,element}]) (modern v6) is object-based not JSX — not covered. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record React Router routing (the React row's routing half) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): actix-web builder-API routing (web::resource / .to(handler)) Actix's attribute macros were covered, but the dominant actix style is the builder API — web::resource("/path").route(web::get().to(handler)), web::resource("/").to(handler) (all methods), and App .route("/path", web::get().to(handler)). The handler is in .to(handler), not get(handler), so the Axum .route scan extracted nothing — actix-examples had 80 web::resource calls all unlinked. Add an actix block: scan each web::resource("/path") (bounding its method chain at the next resource) for web::METHOD().to(h) pairs, fall back to a direct .to(h) (method ANY), plus the App-level .route("/x", web::METHOD().to(h)) form. actix-examples 51→128 routes, 35→112 resolved (GET /user/{name}→with_param, POST /user→add_user). No regression on Axum (realworld-axum still 19/19). Tests: resource+route, resource direct .to, App-level route. Suite green (797). Frontier: web::scope("/api") prefixes not prepended; anonymous .to(|req|…) closures have no named target. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record actix builder-API routing validation Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(extraction): Flutter setState→build synthesis + Dart method body ranges Two changes that connect Flutter's reactive dispatch: - Dart method ranges (foundational): Dart models a method body as a SIBLING of the method_signature node, so every Dart method node had endLine == startLine (signature only) — body-level analysis (callees, context slices, the synthesizer's body scan) saw only `void f() {`. Extend endLine to the resolved body in the shared createNode, guarded to only ever extend (child-body grammars are a no-op; controls excalidraw 9,290 / django 302 unchanged). - Flutter setState→build synthesizer channel (the Dart analog of react-render): for each Dart class with a `build` method, link sibling methods whose body calls setState( → build. setState re-runs build (Flutter-internal, no static edge), so "tap → handler → setState → rebuilt UI" dead-ended at setState. counter initState→build, books build→BookDetail/BookForm. Widget composition needs no synthesis — Dart widgets are explicit constructor calls, already static (compass_app build→ErrorIndicator/HomeButton). Tests: Dart method spans its body; Flutter handler→build synthesis end-to-end. Suite green (798). Frontier: MVVM Command/ChangeNotifier dispatch (no setState) + Navigator.push route-as-widget navigation. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Dart/Flutter validation (setState→build + method ranges) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Spring Boot Kotlin routing (.kt + fun handlers) Kotlin had zero framework coverage — no resolver listed kotlin, and the Spring resolver was languages:['java'] with a .java-only extract gate and a Java-syntax handler regex (public X name()). Spring Boot Kotlin apps (same @GetMapping/@RestController annotations, .kt files) extracted 0 routes. Extend the Spring resolver: languages ['java','kotlin'], accept .kt, and add a Kotlin `fun name(` alternative to the handler-method regex (Kotlin has no access modifier; the return type follows the name). Also allow Kotlin class modifiers (open/data/sealed) in the class @RequestMapping-prefix detection, and tag route/ref language per file. spring-petclinic-kotlin 0→18 routes, 18/18 resolved; class @RequestMapping prefixes join, stacked annotations skipped, DI controller→repo resolves (showOwner ← GET /owners/{ownerId} → OwnerRepository.findById). Java Spring unchanged (realworld 19/19 — the Kotlin fun and Java public-X alternatives are disjoint per language). Jetpack Compose composition already works (@Composable→child are plain function calls). Tests: Kotlin @GetMapping+fun, class-prefix + stacked annotation. Suite green (800). Frontier: Ktor inline-lambda routing, Compose recomposition, coroutines/Flow. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Kotlin validation (Spring Boot Kotlin + Compose) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Lua/Luau validation (module dispatch already covered) Measure-first: Neovim/Roblox dispatch is module-heavy (require + cross-file mod.fn calls), already resolved by general import+name resolution (telescope.nvim 220 imports + 335 cross-file calls; traces end-to-end). The matrix's assumed "callback synthesizer" hole isn't real — event-callback registration (keymap/autocmd/:Connect) is predominantly inline anonymous closures (corpus ~12 inline vs ~2 named), too rare to synthesize. A/B: 0 read/0 grep with codegraph vs 1 read without. No code change; validated. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Play Framework conf/routes → controller routing (Scala/Java) Play declares routes in an extensionless conf/routes file (GET /computers controllers.Application.list(p: Int ?= 0)) the file walk never indexed (isSourceFile requires an extension), so Play apps had 0 route nodes. - grammars.ts: add isPlayRoutesFile (conf/routes + *.routes), opt it into isSourceFile, and map it to the no-grammar (yaml-style) path in detectLanguage so the framework resolver extracts it. Narrow match — only ADDS Play routes files, never affects other indexing. - play.ts: a Play resolver — detect (build.sbt/conf), extract (parse each METHOD /path Controller.action(args) line, drop package + args), resolve (Controller.action → the action method in that controller class), claimsReference for the dotted Controller.action handler. computer-database 0→8 routes, 7/8 resolved (the 1 unresolved is controllers.Assets.versioned — Play's framework controller, external); starter 0→4 (3/4). Flow connects request→route→controller→DAO. No-regression (excalidraw 9,290 / suite unchanged). Tests: routes parse + `->` include skipped, conf/routes file detection. Frontier: SIRD programmatic routers (-> include + case GET(p"/x")) + Akka actor message→handler. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Scala/Play validation (conf/routes → controller) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(extraction): C++ inheritance (base_class_clause) + virtual-override synthesis C/C++ direct dispatch already resolves well (redis 29k / leveldb 1.4k cross-file calls). Two changes close the C++ virtual-dispatch gap: - extractInheritance handled base_clause (PHP) but not C++'s base_class_clause, so C++ `extends` edges were missing/partial. Add the C++ branch (emit an extends ref per base type, skipping access specifiers) — leveldb extends 219→298. - cpp-override synthesizer channel (the C++ analog of react-render): for each extends edge, link each base method → the subclass override of the same name, so trace/callees from a virtual/interface method reach the implementation. Gated to C++, capped per class. leveldb 12 precise edges (Iterator::Next/Seek/Prev → MergingIterator), 0 on C (redis) and TS (excalidraw). Test: base virtual → subclass override bridge. Frontier: C callback structs (cmd->proc() → 422-way fan-out, too noisy) and C++ pure-virtual base methods (declarations aren't nodes, so those overrides can't bridge). Suite green (804). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record C/C++ validation (inheritance fix + override synthesis) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): React Router object data-router + Next.js route precision - Object data-router (v6.4+): createBrowserRouter([{ path, element: <Comp/> }]) / { path, Component: Comp } — extract route + component (gated to files using the data-router API; requires a component so a stray `path:` field isn't a route). - Next.js precision: filePathToRoute treated config files (next.config.mjs, vite.config.ts) and a `nextjs-pages/` dir (substring of "pages/") as routes. Require a real page extension (.tsx/.ts/.jsx/.js), exclude *.config.* and _app/_document, and match pages/ + app/ as path SEGMENTS. bulletproof-react 4 bogus config "routes" → 0. Frontier: lazy data-router routes (path: paths.x.path + lazy: () => import()) use variable paths + lazily-imported modules — no literal path/named component. Tests: object-router literal form, config/nextjs-pages exclusion. Suite 806. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Flask-RESTful add_resource + tuple methods + broader detection Three Flask gaps closed (redash Flask-RESTful 6→77 py routes; flask-realworld 0→19): - Flask-RESTful: api.add_resource(ResourceClass, '/path') (+ redash's add_org_resource) now extracts a route per path referencing the Resource class, whose get/post verb methods resolve as the handlers. - Tuple methods: @x.route('/p', methods=('POST',)) — the method regex only accepted a list [...]; now accepts a tuple (...) too, so POST/DELETE routes aren't mislabeled GET. - Detection: detect() only checked root app.py for the literal Flask(__name__); broadened to requirements/pyproject/Pipfile/setup.py + any entrypoint file (root or subdir, e.g. conduit/app.py) that imports flask and instantiates Flask(...). flask-realworld (subdir app-factory) 0→19; django not falsely detected. Tests: tuple methods, add_resource. Suite green (808). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record frontier pass; test(go): gorilla/mux subrouter coverage Frontier triage after the main sweep — tractable partials closed (React object data-router, Next.js false-positive fix, Flask-RESTful add_resource, Flask tuple methods + detection, gorilla/mux confirmed), and the genuinely hard/low-precision ones (C callback fan-out, metaprogramming finders, reactive runtimes, Akka, anonymous closures, lazy data-router, C++ pure-virtual) left documented with rationale. Adds a gorilla/mux subrouter-var HandleFunc test (confirms the any-receiver handling already covers it). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(benchmarks): A/B with/without codegraph across every language (S/M/L) 37-cell matrix (every flow-relevant language × small/medium/large indexed repos): a headless agent answers one canonical flow question per repo, with the codegraph MCP vs without any MCP. Fresh re-index per cell so the with-arm reflects current resolvers. Result: 75% fewer file reads with codegraph (40 vs 158 across cells), ~70% fewer greps, never more reads in any cell. Biggest wins on medium/large backends (excalidraw 0R vs 9R, spring-halo 0R vs 9R+8 Bash, jellyfin 4R vs 13R+ 21 Bash + a spawned sub-agent); tie zone on tiny repos where the flow fits in 1-2 files. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): self-sufficient codegraph_trace + CODEGRAPH_MCP_TOOLS allowlist codegraph_trace now returns a complete flow dossier in one call: each hop with its full body inlined (not just the call-site line), plus the destination's own outgoing calls — the last mile agents otherwise explore/Read to get. Validated by A/B (arm I, 6 repos x 2): >= baseline on reads/turns/cost with no wall-clock regression, because one richer trace call displaces the explore+node+Read follow-ups. Sufficiency, not steering: complete context is what stops further investigation. Also adds CODEGRAPH_MCP_TOOLS, an optional comma-separated allowlist that trims the exposed MCP tool surface (inert when unset); used to run the tool-ablation experiment cleanly, and useful for constraining an agent to a minimal surface. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(benchmarks): call-sequence + tool-ablation analysis; agent-eval arms harness Records why codegraph read savings (-75%) under-convert to wall-clock (-16%): the bottleneck is round-trips + the synthesis turn, not reads. Ablation (arms A-I) shows explore is 68% of payload but load-bearing, trace is path-scoped but under-adopted, instruction/description steering cannot match an append-prompt's salience (and regresses), and the shippable win is making the trace output sufficient (arm I). Adds harness: seq-matrix, run-arms/arms-*, parse-arms. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): line-number codegraph_node + codegraph_trace source output node's code block and trace's inlined hop/destination bodies now carry cat -n line numbers (reusing numberSourceLines, matching codegraph_explore and Read), so the agent can cite or edit exact lines without re-Reading the file just to get them. Consistency across the code-returning tools + edit-workflow sufficiency. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(resolution): Java/Kotlin interface & abstract dispatch synthesis A call through an injected interface (Spring @Autowired svc.list()) or an abstract base dead-ended at the interface method — no static edge to the implementation — so request->service->impl flows broke at the DI boundary. Adds interfaceOverrideEdges: for each class implementing an interface (or extending an abstract base), synthesize interface/base-method -> same-name override 'calls' edges (JVM-gated, capped per class, overload-aware), with an 'interface-impl' trace label. trace + callees now follow the flow into the implementation. Validated on spring-mall: 310 synth edges, node count unchanged (edges only); trace(PmsProductController.getList, PmsProductServiceImpl.list) connects in 3 hops (controller -> service interface -> impl) where it previously dead-ended at the interface. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(playbook): record Java/Kotlin interface-DI synthesizer (probe-validated; agent A/B adoption-gated) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): codegraph_explore surfaces the execution flow from its named symbols Agents call explore far more than trace and pass a bag of symbol names that spans the flow they're after. explore now resolves those names and surfaces the longest call path AMONG them — riding synthesized dynamic-dispatch edges (callback/react-render/jsx/interface-impl) — leading the output with it, so a flow question answered via explore gets the trace-quality path without switching tools. Precision: ambiguous tokens disambiguated by CO-NAMING (keep candidates whose qualifiedName SEGMENT matches another named token, so 'list' resolves to PmsProductServiceImpl::list not OmsOrderService::list); BFS anchored at named symbols on both ends with <=1 consecutive unnamed bridge (crosses a missing intermediate, never wanders a god-function's fan-out). Validated by probe: spring-mall getList->service-interface->impl (3 hops); excalidraw mutateElement->triggerUpdate->[callback]->triggerRender->[react-render]->render->[jsx]->StaticCanvas (full re-render chain). No flow section on fuzzy queries (safe). Suite green. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(mcp): explore-flow resolves qualified Class.method query tokens The agent often passes fully-qualified names to explore (PostEndpoint.publishPost, PmsProductServiceImpl.list) — its most precise input. The tokenizer's file-extension strip mangled Class.method into Class (treating .method as an extension), then the identifier filter dropped anything with a dot, throwing the method away. Now strips only REAL file extensions and keeps qualified tokens, which findAllSymbols resolves exactly; disambiguates ambiguous SIMPLE names by whether their container class is also named (segment match). Validated: 'PmsProductController.getList PmsProductServiceImpl.list' now surfaces getList->interface->impl. (spring-halo's publish flow stays absent — it's reactive/reconciler dispatch with no static edges, a coverage frontier, not an explore-flow gap.) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(claude): record the 'adapt the tool to the agent' retrieval principle The lever that decides whether a retrieval change lands: make a tool the agent already calls do more with the input it already gives; changes that need the agent to behave differently (different tool, query, examples) hit codegraph's low-salience channels and don't land. Captures the validated evidence (sufficiency + explore-flow pass; steering + new-tools + context-fuzzy-flow fail) and points coverage as the remaining lever. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs: correct 'cost stays flat' → neutral-to-lower (excalidraw with/without A/B) Fresh with-vs-without A/B on excalidraw (current build, n=3): 3x faster (49s vs 145s), 15x fewer tool calls, ~0 vs 23 reads, and -40% cost ($0.41 vs $0.68). Cost is neutral-to-lower, not flat — compact codegraph answers cache across turns while the without-arm's read/grep thrash is fresh, poorly-cacheable input. Recorded in call-sequence-analysis.md; corrected the CLAUDE.md optimization-target note (still: don't optimize for cost; target wall-clock + tool-call count). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(benchmarks): current-build A/B on all 7 README repos + fix token-measurement bug Re-ran the README benchmark on the current build (7 repos reindexed, median of 4): avg 35% cost / 57% tokens / 46% time / 71% tool calls saved — reproduces the published README (35/59/49/70), no regression. Adds bench-readme.sh + parse-bench-readme.mjs harness. Fixes a token-measurement bug: result.usage is last-turn-only in current Claude Code; must sum per-turn assistant usage for cumulative tokens. Corrects the earlier excalidraw note (its '-34% tokens' was off this bug; real ~90%) and the cost MECHANISM (volume/fewer-turns, not cache-ability — the without-arm's huge token volume is mostly cheap cache-reads, so token savings 57% > cost savings 35%). Cost/time were always correct. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs: finalize 0.9.4 — consolidate CHANGELOG + re-validate README benchmark Folds the framework sweep + retrieval work into [0.9.4] (2026-05-24). README benchmark table refreshed with current-build medians (avg 35% cost / 57% tokens / 46% time / 71% tool calls) + a v0.9.4 re-validation note. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(readme): add codegraph_trace to the MCP Tools table Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-24 04:41:04 -05:00
Colby Mchenry	15072aa29f	fix: self-heal missing platform bundle from GitHub Releases (#303) (#335) ... Installing from a registry mirror (npmmirror/cnpm) that hadn't mirrored the per-platform optionalDependency left codegraph failing with "no prebuilt bundle for <platform>" — npm treats an unfetchable optional dep as success and silently skips it. The npm-shim now self-heals: when the bundle is missing it downloads the matching archive from GitHub Releases (checksum-verified, with a download timeout) and caches it, so a global install works on any registry. release.yml now publishes SHA256SUMS and triggers an npmmirror sync after publish. Adds hermetic tests for the shim (resolution, cache reuse, disable knob, download + checksum match/mismatch/absent). Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 11:38:28 -05:00
Colby Mchenry	e5d633075c	fix: prevent V8 turboshaft WASM Zone OOM during indexing (#298, #293) (#322) ... Large multi-language indexes crashed with `Fatal process out of memory: Zone` on Node 22/24 (including the bundled runtime) — V8's turboshaft optimizing WASM compiler exhausts its per-compilation Zone arena while compiling tree-sitter grammars on a background thread, even with tens of GB free (the Zone is a V8-internal arena, not the JS heap). Run node with V8 `--liftoff-only`, which keeps grammar compilation on the Liftoff baseline and never reaches the optimizing tier. Delivered via the bundled launcher + a one-shot CLI re-exec guard for all other launch paths. Empirically only `--liftoff-only` stops it (`--no-wasm-tier-up` / `--no-wasm-dynamic-tiering` do not), and it must be on node's command line (setFlagsFromString / worker execArgv / NODE_OPTIONS all fail). Reproduced the exact crash with the real indexer on Node 24.16 against a 2,880-file / 18-language repo and confirmed the fix eliminates it; full suite + 7 new tests pass. Bumps to 0.9.4. Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-22 05:39:24 -05:00
Colby Mchenry	c41559a9d0	fix(installer): Windows npm launcher EINVAL on modern Node (#289) (#292) ... The npm thin-installer shim spawned the per-platform bundle's `.cmd` launcher directly. Modern Node on Windows refuses to spawn `.cmd`/`.bat` without `shell: true` (the CVE-2024-27980 hardening), so every `codegraph` command failed with `spawnSync …\codegraph.cmd EINVAL` (seen on Node 24). On Windows the shim now invokes the bundled `node.exe` against the app entry point directly, bypassing the `.cmd` (and avoiding the arg-quoting pitfalls of `shell: true`). Unix is unchanged. Validated end-to-end against a real win32-x64 bundle: `npm install` of the packed tarballs + `codegraph init -i`/`status` run on the bundled Node 24. Also cuts release 0.9.2, rolling up the pending Drupal, zero-config, config-removal, Hermes-installer, and symlink-security changes. Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-21 21:22:50 -05:00
Colby McHenry	2759afa57b	fix(dist): resolve symlinks in the bundle launcher (curl install was broken) ... install.sh symlinks ~/.local/bin/codegraph -> the bundle launcher, but the launcher derived its dir from $0, which is the symlink path — so it looked for `node` next to the symlink and failed with `exec: .../node: not found`. Follow the symlink chain to the real bundle dir first. (npm was unaffected — the shim invokes the launcher by absolute path.) Verified via the symlinked install path in a clean no-Node Linux container. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-21 16:07:46 -05:00
Colby McHenry	630c60f852	chore: remove obsolete manual-publish paths (release.sh, /publish skill) ... Releases now go through .github/workflows/release.yml, which builds the bundles and publishes the npm thin-installer. The old manual paths published the root (non-bundled) package, which would break Node < 22.5 users — remove them so they can't be run by accident. CLAUDE.md + add-lang updated to point at the workflow. scripts/extract-release-notes.mjs is kept (the workflow uses it). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-21 15:57:12 -05:00
Colby Mchenry	ac52fd76c0	Self-contained distribution: bundle Node + node:sqlite, drop better-sqlite3/wasm (closes #238) (#282) ... * fix(db): eliminate concurrent-read "database is locked"; add node:sqlite backend (#238) WAL + busy_timeout were already enabled, so the issue's suggested fix was a no-op. The real causes, addressed here: - busy_timeout is now set first (before journal_mode) and lowered 120s -> 5s, so open-time pragmas wait out a lock instead of hanging for two minutes. - getCodeGraph no longer opens a second connection to the default project when a tool passes its own projectPath (the in-process lock amplifier). - The wasm fallback (no WAL) gets a bounded read-retry on SQLITE_BUSY. - New: node:sqlite backend, preferred over wasm, so installs whose native better-sqlite3 build fails land on a real-WAL backend instead of no-WAL wasm. - codegraph status / codegraph_status now report the effective journal mode, so a lock report is triageable (wal vs delete). - CLI hard-blocks Node < 20 to actually enforce the engines floor. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * refactor(db)!: node:sqlite is the sole backend; drop better-sqlite3 + wasm Now that distribution will bundle a Node 24 runtime, node:sqlite (real SQLite with WAL + FTS5) is always available. Collapse the three-backend adapter to node:sqlite only and remove the machinery the other two needed: - Remove better-sqlite3 (optionalDependency) and node-sqlite3-wasm (dependency). - Remove WasmDatabaseAdapter, the named->positional param translation, the SQLITE_BUSY read-retry, the wasm fallback banner, the backend env override, and the native/node-sqlite/wasm selection chain. - createDatabase now opens node:sqlite directly, with a clear error pointing at the bundled release / Node 22.5+ when the module is absent. - NodeSqliteAdapter.close() is idempotent and pragma() supports { simple }, to match the better-sqlite3 behavior callers relied on. - status (CLI + MCP) reports the single node:sqlite backend; journal-mode diagnostics and the getCodeGraph single-connection fix are retained. - Tests repointed off better-sqlite3 onto node:sqlite. Net -1044 lines. Running from source now requires Node 22.5+. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(dist): self-contained bundle prototype (vendored Node + install channels) Phase 3 of the node:sqlite migration: ship a vendored Node runtime so CodeGraph runs with no system Node and no native build (node:sqlite is built in). - scripts/build-bundle.sh: build a per-platform archive (official Node + dist + prod deps + launcher). Same recipe per platform; pins Node v24.16.0. - install.sh: curl|sh installer (no Node required) — detects os/arch, pulls the archive from Releases, symlinks onto PATH; re-run to upgrade, --uninstall to remove. The VPS/SSH path. - scripts/npm-shim.js: thin launcher for the npm channel — resolves the per-platform optionalDependency bundle and execs it, so `npm i -g` keeps working and the real work runs on the bundled Node regardless of the user's. - BUNDLING.md: distribution design + release-pipeline TODO (CI matrix, platform packages, code signing, brew, retiring the Node-version gate). Validated end-to-end: darwin-arm64 and linux-x64 bundles both run init + index + status (Backend: node:sqlite, Journal: wal) + FTS query with NO system Node — linux-x64 verified in a clean ubuntu:24.04 amd64 container. Release archives are gitignored; CI will produce and upload them. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(dist): add Windows PowerShell installer (install.ps1) The `irm … | iex` one-liner for Windows, mirroring install.sh: detect arch, pull the matching bundle from Releases, extract to %LOCALAPPDATA%\codegraph, add it to user PATH. Re-run to upgrade. (Windows bundle production in build-bundle.sh is still TODO.) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(dist): release workflow + npm packaging; README/CHANGELOG for bundled distro - .github/workflows/release.yml: manually-triggered (workflow_dispatch) release matrix. Builds a self-contained bundle per platform on its own runner (darwin-arm64/x64, linux-x64/arm64), publishes a GitHub Release with all archives, and publishes the npm thin-installer (shim + per-platform packages). Windows targets are TODO (build-bundle.sh is unix-only). - scripts/pack-npm.sh: assemble the npm packages from built bundles — per-platform packages tagged os/cpu + the main shim package with them as optionalDependencies (esbuild pattern). Proven locally: npm-install the tarballs, run via the shim, resolves the bundle and runs on the bundled Node 24 (node:sqlite / WAL). - README: install section now leads with the no-Node one-liners (curl|sh, irm|iex) then npm/npx; "bundled · none required" badge. - CHANGELOG: standout headline for the self-contained release, plus Added/Changed/ Removed for the install channels, node:sqlite backend, and dropped deps. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(dist): Windows bundles + single-trigger release workflow - build-bundle.sh: add win32-x64 / win32-arm64 targets — download Node's Windows zip, bundle node.exe + a .cmd launcher, output a .zip. Verified structurally (PE32+ node.exe, CRLF .cmd, portable node_modules). Since there are no native addons, any target builds on any OS, so the whole matrix builds on one runner. - pack-npm.sh: handle .zip bundles and win32 packages (os: win32, node.exe). - release.yml: simplified to your spec — manual trigger reads the version from package.json, builds all platform bundles, creates the GitHub Release with notes pulled from CHANGELOG.md, and publishes the npm shim + platform packages. - BUNDLING.md: Windows + build-anywhere notes; release pipeline documented. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-21 15:48:04 -05:00
Colby Mchenry	4329a52bec	feat: add Lua and Luau language support (#273) ... Adds Lua (.lua) and Luau (.luau) extraction — functions, methods with receivers, type aliases (Luau), require imports (incl. Roblox instance-path), and call edges. Vendors the ABI-15 Lua and ABI-14 Luau tree-sitter grammars. Addresses #232.	2026-05-21 09:28:00 -05:00
Colby McHenry	2fc0df7108	chore: remove leftover debug scripts and stale docs ... Delete dead dev scratch (debug_python_ast*.js, test_python_inheritance.js), the obsolete tree-sitter-dart native patch (Dart loads via WASM now and the package is no longer a dependency), and orphaned docs superseded by the current code and the agent-eval skill (IMPLEMENTATION_PLAN.md, DELPHI-SUPPORT.md, run-interactive-test.md). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-21 08:27:12 -05:00
Colby McHenry	7fe64b32be	feat(eval): add agent-eval harness and /audit + /publish Claude skills ... Replaces the old interactive publish.js script with two Claude skills and a full agent-evaluation harness: - `.claude/skills/audit/` — `/audit` skill drives `scripts/agent-eval/audit.sh` to benchmark retrieval quality (with vs. without codegraph) on a chosen real-world repo from the new `corpus.json` (17 repos across 14 languages). - `.claude/skills/publish/` — `/publish` skill orchestrates the full release workflow (preflight → changelog → confirmation gate → bump/build → npm publish → GitHub release), replacing `publish.js`. - `scripts/agent-eval/` — headless (`run-agent.sh`, `run-all.sh`) and interactive tmux (`itrun.sh`) harnesses with stream-json parsers (`parse-run.mjs`, `parse-session.mjs`) that report tool calls, token usage, and a VERDICT line summarising codegraph_explore vs. Read/Grep counts. - `run-interactive-test.md` — documents the two harnesses, idle-detection approach, and what "good" agent behavior looks like after explore-first guidance.	2026-05-20 09:39:17 -05:00