npm / @colbymchenry/codegraph
@colbymchenry/codegraph
What changed in @colbymchenry/codegraph 1, from its official release notes, upgrade guides and advisories. Sources checked 2026-11-04.
75 breaking25 new APIs and options3 performance58 behavior and defaults10 tooling157 fixes and other
See which of these apply to your code, ranked, in your agent:
npx @unstale/cli init@colbymchenry/codegraph 1328 changes
Breaking changes 75
Types written in C# or VB.NET code resolve to their type declarations rather than same-named properties, methods, or fields; property reads and method values continue to resolve as before.
Bare names resolve only to members of the current or outer classes, their base classes, or types brought in with using static, including global and project-file static imports.
Interface members are treated as public and modifierless types as internal; interface-typed calls resolve to interface methods, and production references no longer guess to test mocks or helpers.
Case-sensitive languages no longer link names to symbols that differ only in case; case-insensitive languages are unchanged.
Unqualified calls resolve only to the component and its ancestors; untyped receiver calls require a matching component name rather than linking to unrelated methods.
Calls on values with unknown types resolve to Dart's String, List, or Map methods instead of same-named project methods; extensions match by the extended type.
Calls without receivers resolve to the nearest applicable class, superclass, mixin, interface, or extension method; class aliases using
class A = B with C;are indexed under their declared name.An unnamed
extension on Xis no longer mistaken for typeX, and its members are reachable only within the declaring file.Calls handed off to another object no longer resolve to the calling method; JavaScript and TypeScript field receivers count as recursion only when declared by the method's class.
In monorepos alongside Next.js, Expo Router reads only its own app files, not Next.js or shared-package files; re-index after upgrading.
JavaScript and TypeScript middleware, controller, and service conventions select declarations from the calling file; other files require an import or require.
C#, Java, and Kotlin calls through fields, properties, and parameters resolve using their declared type, including inherited and generic types; external types produce no link.
Django, FastAPI, Flask, ASP.NET, Gin, SwiftUI, and Vapor conventions select only visible classes, starting in the reference's file and package.
Names accessed through an imported package from outside the module no longer link to same-named project symbols.
Calls on imported values no longer resolve to same-named methods declared in the calling file.
Bare Java calls resolve only to methods on the enclosing class, its parents, or static imports, including inherited methods and project static imports; re-index Java projects after upgrading.
Bare Java type names resolve only when the type is in reach through its package, imports, nesting, inheritance, or owner qualification.
Names imported from outside the project resolve to the imported class or member rather than same-named project symbols, including static imports.
Unexported top-level functions, variables, and types are no longer linked from other files; all documented export forms remain effective.
Parameters and preceding var, let, or const declarations resolve as local bindings instead of same-named functions; destructured hook results still link to their source functions.
A barrel's export * as form exports only its namespace; namespace imports also resolve forwarded members and nested namespace paths.
Kotlin imports determine name resolution, including choosing among same-named classes and resolving renaming imports; declarations in the file still take precedence.
Calls without receivers resolve only to methods in reach through the current class, inheritance, extension receivers, DSL receivers, or imported object members; re-index after upgrading.
Route names now include leading slashes, group prefixes and Laravel's
/apiprefix as configured by the application.Calls through standard or host library tables and string methods no longer resolve to same-named project methods, while project-defined table functions still link.
Bare calls resolve to Lua's own functions unless the file defines a same-named function; aliases of host table members are followed.
Local variables and functions no longer link across files; global functions remain linked across files.
Calls in Java, C#, Kotlin, Swift, Scala, Dart, and VB.NET now resolve to the overload whose parameters fit the arguments.
Minimal API paths written without a leading slash are now named with one.
Functions and names passed as values resolve according to scope where written; locals and parameters take precedence, and pytest fixtures are limited to their module or conftest.py.
NestJS provider conventions select classes only from the reference's own file; other files are reached through imports or ordinary nearest-name matching.
An Objective-C class conforming to a protocol of the same name now links to the protocol, and Swift naming conventions no longer apply to Objective-C code.
Function calls after
=>in arrays are parsed as plain function calls rather than method calls.Calls without receivers are treated as function calls and no longer link to same-named project methods, fields, or classes.
Unqualified class names resolve to the current namespace's class or an imported class; imported library classes do not resolve to project symbols.
Calls on untyped variables no longer link to an unrelated class method just because it is the only same-named method; the variable must match the method's class or an inheriting class.
Calls resolve only to members of their named receiver or to in-scope imports, rather than arbitrary project methods with the same name; re-index Python projects after upgrading.
Calls to names bound locally by a function or module resolve to that local value rather than a same-named function elsewhere; this also applies to parameters and for/with targets.
Variables assigned at the top of a test file are no longer linked across package or test files;
helper-*.Randsetup-*.Rvariables remain shared.React hook and context conventions select only declarations in the reference's file, including for optional calls; other files require imports.
Guesses from receiver names no longer resolve to framework-dispatched request handlers or test doubles that the calling file does not mention.
Calls on untyped receivers require a matching class name, while calls without receivers resolve within the class, its ancestors, and included, extended, or prepended modules.
Chained calls with standard-library method names no longer resolve to unrelated project methods, and plain calls do not resolve to methods.
Struct, handler, and service names no longer resolve to items inside function bodies; a file's own item takes precedence over items from other crates.
Bare names such as
Ok,Some,Result, andVecresolve to the standard library unless the file defines or imports a project item; enum variants require an import.Calls on another expression's result, and initializer chains that call a same-named method, no longer resolve to the calling method itself.
A type extending another type with the same name now links to its base; an explicit qualifier selects between same-named candidates.
Package-object members resolve only where the package object is in scope: its package, nested packages, or files importing through it.
Kind-projector placeholders in types no longer resolve to operator methods, and symbolic names in types resolve only to types.
Calls without receivers resolve to the surrounding contract or an inherited contract; Erlang imported calls follow
-import, while unimported cross-module calls no longer link elsewhere.Overloaded function calls resolve to the overload whose parameter count fits.
Spring class names resolve to a class in the reference's file or package before folder-convention guesses; nested classes in other files are not reached by bare name.
Declarations in Svelte instance scripts and Vue script setup are private to their component, except for exported types; module scripts and plain Vue scripts remain externally reachable.
Calls without receivers and calls through self or super resolve within the enclosing type and its conformances or inheritance, with the nearest override winning; unrelated globals and standard-library names are not guessed.
Calls on variables are no longer guessed to target methods on Mocked, Fake, Stub, or Dummy classes solely because they are the only same-named methods.
Path aliases use the tsconfig or jsconfig nearest the importing file, allowing each monorepo app to resolve its own aliases.
Type-only imports bind the imported name rather than a symbol named type; package types and case-sensitive JavaScript and TypeScript names no longer link to unrelated project symbols.
Calls through VB.NET receivers resolve only through Me, MyBase, MyClass, the member's own class or module, or the service lookup's type.
Components own their setup scripts, Svelte instance scripts, and Astro frontmatter; imports and module-level scripts remain file-owned.
Built-in method calls on untyped values no longer resolve to same-named project methods; this.#field.method() resolves using the field's type.
Function-like macro invocations no longer bind to same-named functions or types in another file; a build-settable flag preserves both sides of #ifdef, and local object initialization records constructor calls.
Cross-call source deduplication is now available only as an explicit opt-in; fresh subagents and compacted contexts receive source again by default.
Index refuses uninitialized paths and identifies the nearest initialized parent instead of silently rebuilding it.
Direct MCP mode now takes an exclusive writer lock, so a second direct writer exits with guidance instead of silently killing auto-sync.
A second direct-mode MCP server on the same project exits rather than silently disabling auto-sync.
Sync reports a busy index and exits non-zero when another process holds the write lock, rather than claiming the index is up to date.
Render links now follow a component's own declaration or import, and JavaScript tags prefer JavaScript components over same-named native classes. Re-index after upgrading.
Calls through a default-imported API object now resolve to its functions, and export default NAME resolves to that named const.
Name matching now declines targets inaccessible across files due to language visibility rules, while preserving same-file and specified Rust visibility cases.
A JS/TS file with imports but no exports no longer offers its local bindings as cross-file targets; CommonJS, classic scripts, later exports, and declare global names are unaffected.
A receiver-less call through a function parameter or local func value no longer links to a same-named method.
Scala objects are indexed as modules so extends/with resolves to a trait or class rather than its companion object.
Only SvelteKit pages are indexed as routes; adjacent layouts and error files no longer create duplicate routes.
Production code under samples or examples package paths is no longer treated as test code; only layout above src/ determines this.
Returns weakly related files as name, symbol, and line-number pointers rather than spending answer space on their source.
New APIs and options 25
Angular routes and navigation split across Nx libraries are followed through re-exports, with paths read from constants or enums.
Angular route arrays, child and lazy-loaded routes, redirects, navigation APIs, template links and child components are represented in the graph.
Controls how long a project queried through
projectPathremains open without queries; the default idle release is 10 minutes and0keeps it open.Expo Router
+apifiles are indexed as endpoints, one per exported method, bound to their handler functions rather than shown as screens.ASP.NET FastEndpoints endpoint classes produce routes linked to their handlers, including paths stored in a request class's
Routeconstant.Links made by framework or bridge resolvers now record which resolver made them in
metadata.framework.Named route tables, per-module files and
new Router(...)are read; child paths, layout components, lazy views and navigation are linked.Project guidance for Codex and Astra now lives in
AGENTS.md, with nested guidance indocs/AGENTS.md;CLAUDE.mdwraps it for Claude Code.The callers, callees and impact commands accept
--fileto narrow ambiguous names and resolve qualified names.Claude Code now loads the MCP tool from the first prompt; codegraph install writes alwaysLoad: true. Copilot CLI's entry sets deferTools to never.
Direct MCP sessions serve concurrent calls from an off-thread query pool with two workers by default; this variable changes the pool size.
Explore can follow literal web requests, queue jobs, events, socket messages and Next.js server actions across application tiers.
Indexing adds Next.js pages, API endpoints and navigation links to the graph, including App Router, Pages Router and redirect calls.
Indexing adds file-based and code-based TanStack Router routes and navigation edges, excluding computed destinations.
Indexing adds Vue Router and Nuxt routes and navigation edges, resolved by route name or path.
Adds a task-context command that builds a markdown or JSON context pack containing relevant symbols, relationships, and code.
Setting this environment variable to 0 turns off codegraph_explore's repeat-source deduplication.
Runs initialization without prompts, enabling non-interactive setup in a fresh container or CI job.
Can configure GitHub Copilot Chat in VS Code, the Copilot CLI, and JetBrains IDEs; installed surfaces are auto-detected, existing MCP entries are preserved, and uninstall reverses setup.
Adds an option to configure agents and build the current project's index in one command; indexing still requires explicitly requesting it with the flag.
Adds per-project Codex setup, writing configuration to ./.codex/config.toml and a CodeGraph block to the project's AGENTS.md; local uninstall reverses it without affecting global setup.
Setting this environment variable to 1 opts out of reference rebinding during sync.
Sets the resting-size bound for the database write-ahead log, which is 64 MB by default.
Adds a codegraph.json setting for gitignore-style patterns that lower matching paths in search and codegraph_explore ranking without removing them from the index.
C, C++, Objective-C, and Rust unions are indexed as first-class union nodes; C union dispatch tables resolve function pointers, and typedef unions retain the typedef name.
Performance 3
Headers are read once per include state, and a hard limit stops resolution on excessively large include trees, preventing indexing from running out of memory.
Small projects on busy machines no longer start unusable extra background threads for resolving references, reducing run time and memory use.
Uses the name index instead of repeatedly scanning every indexed symbol, so lookup time no longer grows with project size.
Behavior and default changes 58
Astro component-name matching now applies only inside .astro files.
Claude Code now receives the full status text and stale-index refusal text instead of only structured freshness JSON.
JavaScript and TypeScript CommonJS requires count as imports, with module paths resolved using extensions, index files, and aliases.
Calls to Expo modules now link to native iOS and Android functions even when the JavaScript module name differs.
Files with
@flowin their header are parsed like TypeScript, preserving classes and type-annotated methods during indexing; files without the pragma are unchanged.Minified or bundled JavaScript is recognized as generated even without a .min.js name, ranking its one-letter functions below user code in search and codegraph_explore.
Delphi and Free Pascal
.incfiles are indexed as Pascal; PHP tags and explicit codegraph.json mappings retain precedence.Infix calls are recorded as calls to the infix function; numeric bit operations remain Kotlin operators even if same-named extensions exist.
Route names now include global prefixes and exclusions, URI versioning,
@Version,VERSION_NEUTRALand controller versions.Play projects in subdirectories are recognized and their
conf/routesfiles are read.Calls on pytest parameters resolve through the class returned by their fixture; fixtures brought in through conftest.py imports or pytest_plugins count as in reach.
React hook and context rules no longer apply to backend code in projects that also have a React front end.
Events named by constants now link native emitters to JavaScript listeners, resolving constants through file, import or owning-class scope.
Data-router paths include nested children and constants, lazy routes link to their module component, and guard wrappers no longer stand in for pages.
React Router v5
Redirectelements and styled links now produce navigation links between screens.Paper-style React Native native components link JavaScript to iOS and Android implementations, including in plain JavaScript files.
Production code no longer links to same-named symbols inside test suites; shipped test-support code remains reachable.
Spring and Laravel controllers exercised by URL-based tests and request helpers now count as tested, and codegraph_explore names the reaching test suite.
The prompt hook context cap is reduced to 9,000 characters so Claude Code displays it inline instead of persisting it with only a short preview.
The installer honors this variable for global Claude Code setup so CodeGraph loads in the selected profile.
CLAUDE.mdis now a thin@AGENTS.mdwrapper for Claude Code; Codex and Astra read the canonical guide directly.callers, callees, and query now report when limits hide matches; callers/callees JSON and MCP answers include totals or a showing N of M note.
WSL projects on Windows drives receive a separate
.codegraph-wsl/index by default; this variable still selects the index directory when set.Explore flags dynamic imports or requires built from template literals with substitutions or string concatenation.
Index coordinates with a running MCP daemon, stops it cleanly before rebuilding, and tells MCP callers to retry during the rebuild.
Init and index list unsupported file extensions and explain when no supported source files are found.
The installer honors this variable for global Codex setup so CodeGraph loads in the selected profile.
FastAPI router and literal mount prefixes now compose into route names, including nested routers and imported or aliased modules; non-string setting prefixes are not guessed.
Functions assigned to locals, table members, or keyed table fields are indexed as callable nodes, with calls attributed to their named function or method.
Conditional destinations now produce an edge for each route arm; arms naming the same route produce one edge.
Re-indexing is required after upgrading to write the new navigation links and other indexing-time fixes into existing project indexes.
Docstrings are indexed alongside preceding comments, making their prose searchable and visible.
Indexing adds React Router navigation edges and resolves optional route parameters; computed or undeclared destinations are omitted.
Handlers created with useCallback, React.useCallback, or useEffectEvent are extracted as named function symbols; handler values in JSX and hook-returned objects are represented as references.
Interface methods and properties are indexed for node, callers, and impact; declaration-only files retain lower flow-query ranking. Re-index TypeScript projects.
Bounds output for files built around very long functions to a window of whole lines, retaining the signature, top of body, and relevant call site.
Budgets source per file so an early file cannot consume space reserved for later files; files that no longer fit whole are shown as excerpts instead of disappearing.
Trims trailing notes rather than discarding a whole file's source when an answer reaches its size limit.
Budgets and trims pointers for files not covered so full answers still tell users which names to request next.
Shortens oversized excerpts by whole methods to fit the answer rather than dropping a useful excerpt entirely.
Follows caller chains up to three hops when checking test coverage and reports indirect coverage as tested via callers.
Avoids resending unchanged source already shown in the conversation, returning a pointer instead and using the space for unseen code; edited files are shown in full again.
Matches query words against words inside camelCase identifiers, helping plain-language questions find relevant code.
Counts variables and constants when choosing starting symbols, so state held in plain variables is no longer overlooked.
Concentrates answers on code that answers the question instead of spreading results across files that merely share a word.
States up front that CodeGraph indexes 30+ languages so agents do not assume a language is unsupported and skip the graph.
Verifies files against the index before returning sliced code; stale files are shown whole with current source or withheld with a changed-on-disk notice.
Shows write-ahead-log size next to database size and warns when killed sessions leave it oversized.
Changes to exclude, include, or .gitignore while the MCP server runs refresh the watcher and trigger a full reconcile immediately.
Generated declaration files identified by a generation banner are recognized as generated, reducing irrelevant source in explore answers.
Ranks handwritten ambient shims, vendored typings, and module augmentations lower for behavior questions while still returning them first for queries about a type by name.
Makes a visible warning when parsing falls back to comment-stripped source, since the recovered result may be incomplete.
Bounds the default parse budget for data-only C/C++ headers near the file-size limit while still honoring explicitly configured larger timeouts.
Uses the sole indexed project below the launch directory as the session default when the launch directory itself has no index.
Records why files were skipped for size or repeated parse failures, preventing unchanged rejected files from being retried on every status check and sync.
Classes used as values, including returned classes, aliases, registry entries, and arguments, now produce graph reference edges.
Recognizes test and spec files in top-level test/ or spec/ directories so they take less room from code requested in explore answers.
Anonymous telemetry is stored on CodeGraph's first-party infrastructure; events are deleted after 90 days, leaving anonymous daily totals, with collection and off-switches unchanged.
Tooling 10
Astro endpoints now link to their exported HTTP-verb handlers.
Routes registered with
add_url_ruleor project helpers passing path lists andview_func=are found and linked to their views.File-routed Nuxt pages now link to the component defined by the page file, allowing callers, impact and flows to continue from the route.
Calls in CFML tags and expressions are linked; tag-wrapped functions and
cfinterfacedeclarations are indexed.Options API methods, computed properties, watchers and lifecycle hooks are indexed individually, and template event handlers link to their methods.
Flow hops now show the source conditions under which calls execute for JavaScript, TypeScript, Swift, Python, Java, Kotlin, C#, Go and C.
Files under an e2e/ directory now count as tests.
Expo Router screen files become route nodes, and supported navigation calls link to their destination screens.
MSVC COM interface declarations in C++ headers are indexed as types with their methods.
Indexing adds SvelteKit navigation edges and links pages to their page files and adjacent server files.
Fixes and other changes 157
Methods called by Angular templates now have caller links, improving impact and callers results and preventing false unused-code reports.
Sessions that lose the shared-server connection or cannot reach it at startup reconnect automatically when the server becomes available.
C calls no longer link to methods of C++ classes, which C cannot call.
Classes using access-specifier macros, attribute macros, or mid-declaration preprocessor conditionals retain their members; re-index after upgrading.
C# names now follow block and nested namespace scopes, using directives, project-local global usings, and nested-type reachability through owners or derived types.
Calls into macro-opened namespaces select an overload based on argument types and count.
Qualified names resolve inside namespaces opened by macros and through namespace aliases.
C# types resolve through their namespace, using directives, project-wide global usings, project and SDK implicit usings, or aliases.
PHP, CFML, Pascal, COBOL, and VB.NET calls with different casing from their definitions now resolve.
Calls through class names now resolve to inherited class methods using declarations, across Pascal, Python, Ruby, PHP, TypeScript/JavaScript, and the Java family.
The prompt hook no longer runs on subagent-report handoff messages, avoiding hook timeouts and unrelated context injection.
COBOL files ending inside columns 1–6 no longer stall indexing and then enter the index without symbols.
The daemon command waits for a shutting-down server to exit, for up to about 20 seconds, rather than reporting it could not stop.
Indexing waits for the background daemon to finish shutting down, up to about 20 seconds, instead of failing daemon-stop verification.
Syncing files with duplicate definitions no longer moves callers onto one definition or loses callers after an interrupted sync.
Windows upgrades can swap files while CodeGraph is running and restore the previous version if anything fails.
Calls through CommonJS require bindings resolve exported functions and named properties, including multiple bindings in one var declaration; external packages no longer link to local variables.
Calls through names destructured from composables or custom hooks now resolve to the functions returned by those hooks.
Inline Express function handlers now link to their calls, including wrapped handlers and trailing commas; the route's last argument is identified as the handler.
Calls on variables or types declared outside the project no longer link to project methods with the same name; Python keyword arguments are no longer mistaken for assignments.
Bare calls in build.gradle.kts no longer resolve to methods or properties of project classes, while build-logic extension functions on Gradle types still resolve.
Calls in inline route handlers retain their receivers and resolve like ordinary method calls.
Methods declared in Java enum constants with bodies are indexed, preserving calls made inside them.
Calls no longer link to same-named class members through namespace imports, npm imports, or bare calls; package-imported hooks and components and nested hooks are not false targets.
Calls inside DSL lambdas resolve through the lambda's own receiver, including receivers supplied through a typealias, instead of other project lambda receivers.
Methods declared in Kotlin enum entries with bodies are indexed, preserving calls made inside them.
Calls to infix functions whose names start with e now parse cleanly, preventing the rest of a line or enclosing class from being lost.
Parsing now preserves enclosing classes when Kotlin files use when guards, ..< ranges, multi-dollar strings, or nullable function-type receivers; re-index after upgrading.
String-named route controllers resolve to handlers without requiring a
Controllersuffix, preserve their namespace, and support resource options arrays.Calls on library-owned types and modules resolve to the library rather than same-named project methods; chained Rust and Go calls are named after the chain's first line.
Calls through local aliases resolve to the function they name, including module members and renamed exports; aliases of Lua functions no longer appear as project calls.
Calls no longer resolve to same-named functions in vendored minified scripts or bundles.
Calls, imports and types resolve according to language scopes, reducing links to unrelated same-named symbols and improving callers, impact and codegraph_explore results.
Objective-C messages resolve only to methods that can receive them: self and super use the class hierarchy, local variables use their declared type, and C-style calls are not treated as methods or properties.
Messages sent to super resolve to the superclass method rather than the sending class's override, including when the index lacks the implementation range.
Calls resolve to matching overloads and parent methods; calls to another object's same-named method no longer appear recursive.
Calls from one overload to another overload of itself link to the target overload, which lists convenience overloads among its callers; real recursion is unchanged.
Calls on
$this,self,static, andparentresolve through the current class, parents, and traits using namespace and import information; re-index PHP projects after upgrading.Namespaced PHP class names resolve through aliases, namespace-relative names, and fully qualified names.
Calls written on an instance resolve to the class's own method even when the file imports a same-named function.
Methods accessed through module-level variables assigned by setup functions now resolve to the assigned class's method, or to a declaration inherited by all possible backend classes.
Module members accessed through an imported package now follow re-exports to their definitions, preserving resolution of qualified members such as generic.ObjectEditView.
An attribute passed through an object of unknown type is no longer linked to an unrelated project method with the same name.
Names imported from a package now resolve through its re-exports, including explicit and wildcard imports in __init__.py.
Imports split across multiple lines inside parentheses are now read in full, allowing their names to resolve correctly.
Calls such as
c(1, 2)no longer resolve to a non-function data binding with the same name; factory-built functions still resolve.Rails routes now account for namespaces, scopes, nested resources, member and collection blocks, and routes in engines.
Links and navigate calls written through route-config objects now reach their destination routes; arrow-function attributes before
toare read.Rails resource declarations now read
only:andexcept:in all forms Rails accepts, including%i,%w, quoted names, and the older hash syntax.Self::Errorresolves to the enclosing impl or trait's associated type, and generic-parameter paths no longer resolve to unrelated same-named structs.Rust names follow scoping and imports, including module-qualified paths and imports from outside the project.
Scala calls resolve within scope: local bindings take precedence, chained calls use the receiver's members, and plain calls use the enclosing class, supertypes, companion, or imported objects.
Scala calls no longer resolve to another test's local values or treat every class member as in scope through a package import; genuinely in-scope package-object members still resolve.
The MCP server promptly answers newer clients' discovery probes with method not found so they continue to the regular handshake.
A session serving CodeGraph without the background server waits for its work to stop before exiting, avoiding partial exits and Windows crashes.
Calls to a parent implementation no longer make an overriding method appear recursive or list itself as a caller.
Route names now omit
(group)folders and normalize matcher parameters to:id, allowing links and navigation to reach the page.Calls, initializers, and enum cases through nested type paths resolve to the named type, including types in extensions; paths naming no project type remain unlinked.
Overloaded Swift calls resolve using argument labels as well as argument count, with defaulted parameters remaining optional.
Calls through typed Swift properties resolve to methods on the property's type or its inherited methods, rather than unrelated same-named methods.
Swift types with protocol compositions split across lines are now parsed whole, retaining their methods, initializers, and properties.
Calls on values constructed inline resolve to methods of that value's type or its inherited methods.
Swift type references resolve to the type declaration rather than an extension file; qualified names and extension methods on conforming types also resolve correctly.
SwiftUI views, @main apps, view controllers, and UIView subclasses are indexed once instead of producing a duplicate one-line copy without callers or calls.
Generic type parameters no longer link to same-named project symbols; function-local types and parameters, nested types, and Scala def parameters also follow their scope.
Anonymous telemetry now sends one daily count per tool or command rather than duplicate counts from each CodeGraph process.
Vapor routes resolve to the handler they name, including nested and extension-declared handlers and self.index; re-index Vapor projects after upgrading.
Trailing-closure, WebSocket and
routes.onregistrations are found; closure routes link to the calls they contain.Vue compiler macros, Nuxt auto-imports, and component-name rules apply only to app scripts, preventing backend calls from resolving to Vue components.
Component calls follow JavaScript and TypeScript resolution rules; package imports declared in nested package.json files or Deno import maps are not mistaken for project symbols.
Git calls run hidden on Windows, preventing console or terminal windows from flashing during background operation and resyncs.
Windows access-violation crashes during parsing, indexing, background sync and shutdown are fixed by waiting for helper threads to finish startup and cleanup.
Windows paths differing only in drive-letter or folder-name case now join the same background server instead of creating duplicate sessions.
Handler-first mappings in endpoint groups are now indexed as routes, with app group heads and class RoutePrefix values applied.
Methods called by a base class outside the index, including framework lifecycle and hook methods, are no longer reported as dead code.
Calls to C macros with designated initializers no longer cause parser recovery to swallow following functions. Re-index.
Callers, callees and impact now suggest alternatives for missing names and return empty results for exact matches with no callers.
A method called on another call's result no longer links to an unrelated same-named top-level function in Python or JavaScript/TypeScript.
Now finds Go, Python, and JVM test files while preserving custom --filter behavior.
Queries with line numbers now return the method containing the line or the exact requested range instead of pinning the file and ignoring the numbers.
Explore prioritizes named functions and methods in large files, uses available answer space for them, and identifies shortened or omitted source.
File references with line numbers or ranges are accepted, and the range becomes the read window unless
--offsetor--limitis supplied.Sync reports pending references it resolved instead of saying the index is up to date while doing that work.
Incremental sync stops with an error if the WAL exceeds its limit and checkpointing cannot finish; raise this variable if the limit is too tight.
CommonJS exported arrow functions and functions are indexed as exported handlers, with their calls owned by the handler. Re-index JavaScript projects.
Nested conditional destinations are paired correctly; three-way choices are left alone.
Calls, constructors, and inheritance no longer link to same-named symbols in unrelated languages; real interop edges remain.
Functions passed to curried wrappers are now indexed under their declarator or property name.
Dart 3 extension types are indexed as types with their members attached.
Calls in declaration initializers now belong to their owning declaration across Kotlin, Java, TypeScript, JavaScript, Scala, Rust, and Python. Re-index with codegraph index -f.
A Delphi DFM component range now extends through its closing end, associating its properties and event bindings with the component.
codegraph_explore again lists a dynamic-dispatch link when the same symbols also have an ordinary call.
An Express handler passed through an async wrapper is now bound to its route as the endpoint handler.
Mounted Express routers compose their prefixes into route names, chained route methods register separately, and client requests pair with the composed paths.
Framework detection now works when project dependencies and files are in subfolders or workspace packages.
Fuzzy matching now declines an unreachable closure candidate instead of assigning it calls; it does not filter candidates before checking reachability.
Depth-limited impact, callers and callees now find every dependent within the requested number of hops, including nodes first reached by a longer path.
Files opted in with
includeIgnoredremain indexed on Git versions older than 2.36, and embedded repositories remain visible to the watcher.External Rust or npm supertypes no longer attach to unrelated local same-named symbols; TypeScript classes implementing a value-and-interface service now link to its interface. Re-index.
Methods and calls in anonymous classes initialized in Java fields are now exposed in the graph.
Methods are no longer candidates for receiver-less calls, preventing a bare call from resolving to a same-named method; receiver-qualified calls still resolve.
Calls in Kotlin property accessors, initialization blocks, and destructuring declarations now retain their correct owner.
Kotlin functions and methods now include
(params): ReturnTypesignatures in codegraph_explore and node. Re-index Kotlin projects.Liquid render, include, section, and assign statements are extracted with correct line numbers, while commented and raw content is ignored.
Mapper extraction now handles whitespace inside closing tags and include references to another namespace.
Functions bound with const inside another function are now indexed as symbols, contained by their enclosing function and owning their calls. Re-index.
Imports from Node built-ins or npm packages no longer connect to unrelated type members with matching names. Re-index to clear existing false dependencies.
Calls through object-literal members that reference an outer function now resolve to that function.
Headers are now indexed as Objective-C in projects without an .m file.
Static calls through imported class aliases now reach the correct class when services and repositories share method names.
Calls and file dependencies through from-package module imports with aliases now appear in the graph.
Python and Go methods passed as values now appear in callers and impact results.
Quoted parameter annotations, including those under future annotations, now resolve methods called on the parameter. Re-index Python projects.
Calls through imported project modules whose names collide with builtin collection methods are no longer dropped as builtin calls.
Method calls on module-scope builtin collections no longer create false calls or file dependencies to unrelated same-named project methods.
JavaScript calls through an RCT_EXTERN_MODULE shim resolve to Swift methods, and inline native-event listeners are attributed to their registering component.
Each Route tag and route object is read from its own attributes or fields, preventing an element from bleeding into sibling or parent routes.
Navigation in a multi-app repository now resolves to a route within its own app.
Rust unit structs and their trait implementation relationships now appear in the graph after re-indexing.
The bundled Scala grammar is updated to official tree-sitter-scala v0.26.2, preserving inheritance edges for classes with multiple parameter lists.
Functions defined through a single-argument macro are indexed under their real name when the macro definition proves it.
Spring DI patterns now apply only to Java/Kotlin references; inheritance resolves through imports and name matching, avoiding cross-language false relationships. Re-index.
A callback registered with subscribe(this.handler) now links to that exact handler rather than the first same-named method in the project.
Same-named symbols on one line, such as a one-line getter/setter pair, no longer collide and drop one; existing symbol IDs remain unchanged.
Rust functions annotated as Tauri commands are no longer reported as dead code.
Client calls with a type argument now resolve to their route like untyped calls.
When emitted .js, .jsx, .mjs, or .cjs files are absent, import resolution retries source extensions; a real emitted-extension file still wins.
Collection calls through local variables and nested properties no longer link to unrelated project methods. Re-index.
Calls through an enclosing class field resolve using its declared type; external or builtin field types remain unresolved rather than guessed. Re-index.
Calls through value aliases now forward call edges to the aliased function, improving callers and impact results. Re-index after upgrading.
Actions in stores exported on a later line via export default or export {} are now extracted like actions in export const stores.
Checks database-file progress before killing a server waiting on a slow disk.
Bounds compiled-pattern caches to prevent regular-expression code-space exhaustion in very large repositories.
Falls back to another parser and records a parse warning for extremely deeply nested files instead of crashing the indexing process.
C++ headers containing a plain derived type are recognized as C++, including when a long C-compatible preamble precedes the type.
Resolves file paths named in a query against the index and guarantees a matching file a place at the top of the answer; unmatched paths are called out.
Matches kebab-case indexed filenames even when queries omit their extension, without splitting ordinary hyphenated words that do not name a file.
Preserves definitions explicitly named in a query, including sibling symbols, when selecting and trimming answer source.
Writes a platform-correct Claude Code prompt hook command on Windows, and rerunning install or upgrade repairs existing installs.
Includes new files inside brand-new, untracked directories in its pending-changes report.
Avoids a maximum-call-stack crash while resolving references in large changed-file batches, preserving graph connections.
Repairs files incorrectly recorded with zero symbols after an interrupted first parse, including records already present in the index.
Clears stale daemon artifacts as well as the indexing lock.
Binary literals no longer cause commas inside arguments to be counted as argument separators, preventing dropped or mislinked behaviour-dispatch edges.
Erlang functions with the same name but different arities are separate symbols identified as module:fun/arity, with arity-specific specs, spans, exports, and exploration.
Calls to methods on exported object-literal constants now resolve to those methods in defining files and through imports, improving caller and impact analysis.
Recognizes generated files by the // Code generated by … DO NOT EDIT. banner, preventing generated layers from crowding out handwritten code in explore answers.
Methods in generic or lifetime-parameterized Rust impl blocks, including impls on references and module-qualified types, are attributed to the implementing type.
Restores dropped database indexes after a crash during bulk loading and marks a successful recovery sync complete.
Rebinds references when symbol definitions change so long-lived sync results remain closer to a fresh index; body-only edits do no extra work.
Runs JSX rendering analysis only on JavaScript-family files, avoiding impossible call edges from JSX-looking strings in other languages.
Reports when no project can be resolved, including the searched directory and nearby indexed sub-projects.
Method calls on struct fields resolve against the field's declared type, looking through references and Box, Rc, and Arc; unsupported or external field types remain unresolved rather than guessed.
Handles Swift Vapor calls with long labeled argument lists and no use: handler without stalling indexing or the MCP server.
Import aliases from shared and inherited TypeScript configs are now followed, improving cross-package resolution in monorepos.
Folds oversized leftover logs back into the index and trims them automatically the next time a project opens after a force-killed session.
Extensionless imports in SAP HANA .xsjs files now resolve across files to .xsjslib modules, creating accurate cross-file call edges.