Tags: codewpf/codegraph
Tags
Release 0.9.4: framework-aware routing + dynamic-dispatch coverage + … …retrieval improvements (colbymchenry#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>
release: roll WASM Zone OOM fix into 0.9.3 (not 0.9.4) (colbymchenry#323 ) 0.9.3 was prepped in the repo but never released (latest published is 0.9.2), so the turboshaft WASM Zone OOM fix ships as part of 0.9.3. Fold its changelog entry into [0.9.3] and revert the version bump. Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
fix(installer): Windows npm launcher EINVAL on modern Node (colbymche… …nry#289) (colbymchenry#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>
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>
chore(release): add 0.7.12 changelog entry Folds all changes since 0.7.10 into 0.7.12 (0.7.11 was unpublished from npm): size-adaptive codegraph_explore output budget (colbymchenry#185/colbymchenry#187), line numbers in explore source sections (colbymchenry#188), explore-first tool guidance (colbymchenry#191), language-neutral source-omission markers, and Kotlin/Swift test-file detection (colbymchenry#191). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
PreviousNext