colbymchenry/codegraph

Maintainer? Show your league in your README

Card: your league's emblem, from Copper to Legendary

[![bestofgithub](https://bestofgithub.dev/badge/colbymchenry/codegraph.svg?style=card)](https://bestofgithub.dev/repo/colbymchenry/codegraph)

Flat: fits beside your other badges

[![bestofgithub](https://bestofgithub.dev/badge/colbymchenry/codegraph.svg)](https://bestofgithub.dev/repo/colbymchenry/codegraph)

Loading README…

Codebase	Language	Tool calls	Time	File reads	Tokens	Cost
VS Code	TypeScript · ~11k files	2 vs 28	2.2× faster (58s vs 2m 10s)	0 vs 12	77% fewer	71% cheaper
Excalidraw	TypeScript · ~640	2 vs 43	3.6× faster (45s vs 2m 42s)	0 vs 18	84% fewer	78% cheaper
Django	Python · ~3k	3 vs 14	35% faster (54s vs 1m 23s)	0 vs 8.5	41% fewer	13% cheaper¹
Tokio	Rust · ~790	3 vs 29	2.6× faster (1m 3s vs 2m 43s)	0 vs 19	65% fewer	64% cheaper
OkHttp	Java · ~645	1 vs 6	43% faster (33s vs 58s)	0 vs 2	54% fewer	21% cheaper
Gin	Go · ~110	1 vs 7	39% faster (28s vs 46s)	0 vs 4	52% fewer	~even¹
Alamofire	Swift · ~110	4 vs 33	2.6× faster (54s vs 2m 22s)	0 vs 16.5	59% fewer	57% cheaper

Codebase	Metric	WITH cg	WITHOUT cg
VS Code	Time / Tools / Tokens / Cost	58s / 2 / 155k / $0.53	2m 10s / 28 / 670k / $1.80
Excalidraw	Time / Tools / Tokens / Cost	45s / 2 / 156k / $0.54	2m 42s / 43 / 991k / $2.43
Django	Time / Tools / Tokens / Cost	54s / 3 / 183k / $0.55	1m 23s / 14 / 309k / $0.63
Tokio	Time / Tools / Tokens / Cost	1m 3s / 3 / 201k / $0.66	2m 43s / 29 / 573k / $1.83
OkHttp	Time / Tools / Tokens / Cost	33s / 1 / 107k / $0.39	58s / 6 / 230k / $0.50
Gin	Time / Tools / Tokens / Cost	28s / 1 / 87k / $0.31	46s / 7 / 180k / $0.31
Alamofire	Time / Tools / Tokens / Cost	54s / 4 / 209k / $0.54	2m 22s / 33 / 505k / $1.27

Codebase	Query
VS Code	"How does the extension host communicate with the main process?"
Excalidraw	"How does Excalidraw render and update canvas elements?"
Django	"How does Django's ORM build and execute a query from a QuerySet?"
Tokio	"How does tokio schedule and run async tasks on its runtime?"
OkHttp	"How does OkHttp process a request through its interceptor chain?"
Gin	"How does gin route requests through its middleware chain?"
Alamofire	"How does Alamofire build, send, and validate a request?"


Native Rust Kernel	Parsing and extraction run in a compiled Rust engine for 20 languages — with graphs verified byte-for-byte identical to the reference engine, and automatic per-file fallback so nothing ever breaks
Adapts to Your Machine	Sizes its worker pools and caches from what the system actually has — real core counts (container-aware), honest available RAM, measured per-project cost. A workstation gets the full parallel pipeline; a 2-core VPS gets one tuned to finish reliably
Surgical Context	One tool call returns entry points, related symbols, and code snippets — no slow file-by-file exploration
Full-Text Search	Find code by name instantly across your entire codebase, powered by FTS5
Impact Analysis	Trace callers, callees, and the full impact radius of any symbol before making changes
Always Fresh	File watcher uses native OS events (FSEvents/inotify/ReadDirectoryChangesW) with debounced auto-sync — the graph stays current as you code, zero config
20+ Languages	TypeScript, JavaScript, ArkTS, Python, Go, Rust, Java, C#, VB.NET, PHP, Ruby, C, C++, CUDA, Objective-C, Metal, Swift, Kotlin, Scala, Dart, Lua, Luau, R, Nix, Erlang, CFML, COBOL, Solidity, Terraform/OpenTofu, Svelte, Vue, Astro, Liquid, Pascal/Delphi
Framework-aware Routes	Recognizes web-framework routing files and links URL patterns to their handlers across 17 frameworks
Mixed iOS / React Native / Expo	Closes cross-language flows that static parsing misses: Swift ↔ ObjC bridging, React Native legacy bridge + TurboModules + Fabric view components, native → JS event emitters, Expo Modules
100% Local	No data leaves your machine. No API keys. No external services. SQLite database only

Framework	Shapes recognized
Django	`path()`, `re_path()`, `url()`, `include()` in `urls.py` (CBV `.as_view()`, dotted paths)
Flask	`@app.route('/path', methods=[...])`, blueprint routes
FastAPI	`@app.get(...)`, `@router.post(...)`, all standard methods
Express	`app.get(...)`, `router.post(...)` with middleware chains
NestJS	`@Controller` + `@Get/@Post/...` (with `RouterModule` prefixes, `setGlobalPrefix` and URI versioning), GraphQL `@Resolver` + `@Query/@Mutation`, `@MessagePattern`/`@EventPattern`, `@SubscribeMessage`
Laravel	`Route::get()`, `Route::resource()`, `Controller@action`, tuple syntax
Drupal	`.routing.yml` routes (`_controller`, `_form`, entity handlers); `hook_` implementations in `.module`/`.theme`/`.install`/`.inc`
Rails	`get '/x', to: 'users#index'`, hash-rocket `=>` syntax
Spring	`@GetMapping`, `@PostMapping`, `@RequestMapping` on methods
Play	`GET`/`POST`/… verb routes in `conf/routes` → `Controller.method` actions (Scala + Java)
Gin / chi / gorilla / mux	`r.GET(...)`, `router.HandleFunc(...)`
Axum / actix / Rocket	`.route("/x", get(handler))`
ASP.NET	`[HttpGet("/x")]` attributes on action methods
Vapor	`app.get("x", use: handler)`
Astro	`src/pages/` file-based routes (`.astro` pages + `.ts` endpoints, `[param]`/`[...rest]` syntax)

colbymchenry/codegraph

CodeGraph

Supercharge Claude Code, Cursor, Codex, OpenCode, Hermes Agent, Gemini, Antigravity, Kiro, and GitHub Copilot with Semantic Code Intelligence

Documentation & Website →

Contents

Get Started

1. Install the CLI

2. Wire up your agent(s)

3. Initialize each project

4. No more syncing!

Uninstall

Language Support

Why CodeGraph?

Benchmark Results

Built for speed — the Rust kernel

Key Features

Framework-aware Routes

Routers — routes and the navigation between them

Mixed iOS / React Native / Expo bridging

Quick Start

1. Run the Installer

2. Restart Your Agent

3. Initialize Projects

How It Works

CLI Reference

`codegraph affected`

MCP Tools

Library Usage

Configuration

Custom file extensions

Telemetry

Verified releases

Supported Platforms

Supported Agents

Supported Languages

Measured cross-file coverage

Troubleshooting

License

Router	Routes from	Navigation from
Expo Router	Every screen file under `app/` (`app/item/[id].tsx` → `/item/[id]`, groups stripped), bound to its default-export component; `+api` files are endpoints (`GET /hello`) bound to their handlers	`router.push` / `replace` / `navigate`, template hrefs, `{ pathname }` objects, and a helper's returned href
Next.js	App Router `app//page.tsx` and Pages Router pages (`(group)` stripped, `[slug]` → `:slug`); `app/api//route.ts` exports and `pages/api/*` are endpoints, not screens	`router.push` / `replace` / `prefetch`, `redirect()` / `permanentRedirect()` in a server action or page, `NextResponse.redirect(new URL(…))` in middleware, `<Link href>` and internal `<a href>`
React Router	`<Route path component/element>` (v5 and v6) and `createBrowserRouter([{ path, element }])`	`history.push` / `replace`, `useNavigate`'s `navigate`, a loader's `redirect`, `<Link to>` / `<NavLink to>` / `<Navigate to>` / v5's `<Redirect to>` / react-router-bootstrap's `<LinkContainer to>`, and a `styled(Link)` wrapper
TanStack Router	`createFileRoute('/posts/$postId')` (file-based) and `createRoute({ path, getParentRoute })` composed up its parent chain (code-based); `_pathless` segments, `(group)` folders, `__root` and `<Outlet/>` layouts are not addresses	`navigate({ to })`, a thrown `redirect({ to })`, `<Link to>` / `<Navigate to>` — where `to` is the route PATTERN and the values ride beside it in `params`
Vue Router / Nuxt	`createRouter({ routes: [...] })` / `new Router(...)` and the route tables it's given (`export const constantRoutes = [...]`, per-module route files), with the view each entry names — a lazy `() => import(…)` bound to its file — and `children` joined onto their parent's path, the parent being the layout around them; plus Nuxt `pages/` file-based routes, `server/api/` endpoints and route middleware	`router.push` / `replace`, `this.$router.push`, Nuxt's `navigateTo`, `<router-link>` / `<RouterLink>` / `<NuxtLink>` — by route name (`push({ name: 'profile' })`) as well as by path
SvelteKit	`src/routes/**/+page.svelte` (`[slug]` → `:slug`, `[[opt]]` → `:opt?`, `[id=matcher]` → `:id`, `(group)` folders stripped), joined to the `+page.server.js` beside it so a loader's guard belongs to its page	`goto('/x')`, `redirect(status, '/x')` from a load or form action, and the plain `<a href>` that is a link in a SvelteKit app
Angular	`Routes` arrays (`RouterModule.forRoot` / `forChild`, `provideRouter`, a routes file's default export) with `component` or a lazy `loadComponent`; `children` and lazy `loadChildren` (an NgModule's through its routing module) joined into full paths; paths written as route constants or `$localize` strings; a route with children is a layout around the screens inside it	`router.navigate([...])`, `navigateByUrl`, a guard's `createUrlTree` / `parseUrl` — a command array, a route constant, or a component property holding one — `routerLink` / `[routerLink]` in the component's template, and `redirectTo`. Each template's child components (`<app-foo>`) are linked to the component that renders them

Boundary	JS / Swift side	Native side	How
Swift → ObjC	Swift `obj.foo(bar:)`	ObjC selector `-fooWithBar:`	`@objc` auto-bridging rules (including init/property/protocol forms) + Cocoa preposition prefixes (`With`/`For`/`By`/`In`/`On`/`At`/…)
ObjC → Swift	ObjC `[obj fooWithBar:]`	Swift `@objc func foo(bar:)`	Reverse-bridge name candidates; verifies `@objc` exposure from source
React Native legacy bridge	JS `NativeModules.X.fn(...)`	ObjC `RCT_EXPORT_METHOD` / `RCT_REMAP_METHOD` · Java/Kotlin `@ReactMethod`	Parses macro/annotation declarations to build a JS-name → native-method map
React Native TurboModules	JS `import M from './NativeM'; M.fn(...)`	Native impl matching the Codegen spec	Treats the `Native<X>.ts` spec interface as ground truth
RN native → JS events	JS `new NativeEventEmitter(...).addListener('e', cb)`	ObjC `[self sendEventWithName:@"e" body:...]` · Swift `sendEvent(withName: "e", ...)` · Java/Kotlin `.emit("e", ...)`	Synthesized cross-language event channel keyed by literal event name
Expo Modules	JS `requireNativeModule('X').fn(...)`, directly or through a binding (`export default requireNativeModule<T>('X')`)	Swift / Kotlin `Module { Name("X"); AsyncFunction("fn") { ... } }`	Parses the Expo DSL literals into method nodes; a call on a binding resolves to module `X`'s `fn` on both platforms, else to the method on the binding's declared type
Fabric view components	JSX `<MyView prop={v}/>`	TS Codegen spec + native impl class	Spec → `component` node; convention-based name+suffix lookup (`View`/`ComponentView`/`Manager`/`ViewManager`) bridges to native
Legacy Paper view managers	JSX `<MyView prop={v}/>`, through a `requireNativeComponent('X')` module	ObjC `RCT_EXPORT_VIEW_PROPERTY` · Java/Kotlin `@ReactProp`	Same as Fabric — `requireNativeComponent('X')` is a JS `component` node, and Paper-era declarations also produce `component` + `property` nodes

Bridge	Small	Medium	Large
Swift ↔ ObjC	Charts	realm-swift	Wikipedia-iOS
RN legacy bridge	AsyncStorage	react-native-svg	react-native-firebase
RN native → JS events	RNGeolocation	—	react-native-firebase
Expo Modules	expo-haptics	expo-camera	expo SDK sweep (7 packages)
Fabric / Paper views	react-native-segmented-control	react-native-screens	react-native-skia

Flag	Values	Default
`--target`	`auto`, `all`, `none`, or csv (`claude,cursor,...`)	prompt
`--location`	`global`, `local`	prompt
`--yes`	(boolean)	prompt every step
`--init`	(boolean) run `codegraph init` in the current directory after wiring agents	—
`--no-permissions`	(boolean) skip Claude auto-allow list	permissions on
`--print-config <id>`	dump snippet for one agent and exit	—

Option	Description	Default
`--stdin`	Read file list from stdin	`false`
`-d, --depth <n>`	Max dependency traversal depth	`5`
`-f, --filter <glob>`	Custom glob to identify test files	auto-detect
`-j, --json`	Output as JSON	`false`
`-q, --quiet`	Output file paths only	`false`

Platform	Architectures	Install
Windows	x64, arm64	PowerShell installer or npm
macOS	x64, arm64	shell installer or npm
Linux	x64, arm64	shell installer or npm

Language	Extension	Status
TypeScript	`.ts`, `.tsx`	Full support
JavaScript	`.js`, `.jsx`, `.mjs`	Full support
ArkTS (HarmonyOS)	`.ets`	Full support (everything TypeScript has, plus `@Component`/`@ComponentV2` structs with their ArkUI decorators (`@State`/`@Prop`/`@Link`/`@Local`/`@Builder`/…), `build()` view trees — parent→child component edges, chained-attribute links to `@Extend`/`@Styles` functions, `.onClick(this.handler)` event bindings — dynamic-dispatch bridges for state→`build()` re-renders, `@ohos.events.emitter` emit→subscriber pairs (static event keys only), and `router.pushUrl` literal urls → the target page struct; ohpm workspace modules resolve bare `import { X } from "data"` through `oh-package.json5` `file:` dependencies, honoring each module's `main` entry)
Python	`.py`	Full support
Go	`.go`	Full support
Rust	`.rs`	Full support
Java	`.java`	Full support
C#	`.cs`	Full support
PHP	`.php`	Full support
Ruby	`.rb`	Full support
C	`.c`, `.h`	Full support
C++	`.cpp`, `.hpp`, `.cc`	Full support
Objective-C	`.m`, `.mm`, `.h`	Partial support (classes, protocols, methods, `@property`, `#import`, message sends; `.mm` ObjC++ may parse incompletely)
Metal	`.metal`	Full support (vertex/fragment/kernel functions, structs, type aliases, call edges — MSL parses as C++, with `[[attribute]]` annotations handled)
CUDA	`.cu`, `.cuh`	Full support (kernels and device/host functions, structs, classes, host→kernel call edges through `<<<grid, block>>>` launch syntax — templated launches, function-pointer launches (`auto kernel = &fn<...>`), `dim3{...}` configs, and macro-defined kernels included; `__global__`/`__device__`/`__launch_bounds__` specifiers handled; CUDA in plain `.h`/`.hpp` headers recognized by content)
Swift	`.swift`	Full support
Kotlin	`.kt`, `.kts`	Full support
Scala	`.scala`, `.sc`	Full support (classes, traits, methods, type aliases, Scala 3 enums)
Dart	`.dart`	Full support
Svelte	`.svelte`	Full support (script extraction, Svelte 5 runes, SvelteKit routes)
Vue	`.vue`	Full support (script + script-setup extraction, Nuxt page/API/middleware routes)
Astro	`.astro`	Full support (frontmatter + script extraction, template component/call references, `src/pages/` routes)
Liquid	`.liquid`	Full support
Pascal / Delphi	`.pas`, `.dpr`, `.dpk`, `.lpr`	Full support (classes, records, interfaces, enums, DFM/FMX form files)
Lua	`.lua`	Full support (functions, methods with receivers, local variables, `require` imports, call edges)
R	`.R` `.r`	Full support (functions in every assignment form, S4/R5/R6 classes with methods, `library`/`require` imports, `source()` file references, call edges)
Luau	`.luau`	Full support (everything in Lua, plus `type`/`export type` aliases, typed signatures, and Roblox instance-path `require`)
CFML	`.cfc`, `.cfm`, `.cfs`	Full support (tag-based `<cfcomponent>`/`<cffunction>` and bare-script `component { ... }` styles, `extends`/`implements`, embedded `<cfscript>` delegation, call edges)
COBOL	`.cbl`, `.cob`, `.cpy`	Full support (programs, sections/paragraphs with PERFORM/GO TO call edges, CALL 'literal' cross-program calls, COPY copybook imports — including standalone `.cpy` files — DATA DIVISION records/fields/88-levels, EXEC CICS LINK/XCTL and EXEC SQL INCLUDE targets; fixed and free format)
Visual Basic .NET	`.vb`	Full support (classes, Modules, interfaces, structures, enums, properties, events, `Declare` P/Invoke, `Handles`/`WithEvents`, `Inherits`/`Implements` edges, call edges through VB's call/index paren ambiguity, `As New` instantiation, interpolated strings, LINQ, Unicode identifiers)
Erlang	`.erl`, `.hrl`, `.escript`, `.app.src`, `.app`	Full support (functions with multi-clause/multi-arity grouping, `-spec` signatures, records with fields, `-type`/`-opaque` aliases, `-define` macros, `-include`/`-include_lib`/`-import` edges, local and `mod:fn` remote call edges, `fun name/arity` references, `spawn`/`apply`/`proc_lib`/`timer`/`rpc` MFA-argument call edges, `gen_server:call/cast(?MODULE)` → own `handle_call`/`handle_cast` links, `-behaviour` links, `-export`-based visibility)
Solidity	`.sol`	Full support (contracts, libraries, interfaces, structs, enums, modifiers, events, errors, state variables, `import`/`using` directives, `emit`/`revert` calls)
Terraform / OpenTofu	`.tf`, `.tfvars`, `.tofu`	Full support (resources, data sources, modules, variables, outputs, providers incl. aliases, `locals`; `var.`/`local.`/`module.`/resource references with Terraform's per-directory scoping enforced; module calls bridged across the boundary — inputs to the child module's variables, `module.M.out` to the child's output, `source` to the module's files; cloudposse/atmos `remote-state` cross-component wiring when the component is statically named; `provider = aws.east` selections resolved up the module tree; `moved`/`import`/`removed`/`check` block references; `.tfvars` assignments linked to the variables they set)
Nix	`.nix`	Full support (functions with simple/destructured/curried params, `let`/attrset bindings, `inherit`, `import ./path` file edges — `./dir` resolving through `default.nix` — plus NixOS module `imports = [ ./x.nix ]` lists and `callPackage ./pkg.nix` file edges; call edges; module-system option wiring — a config write like `launchd.user.agents.x = { ... }` links to the module declaring `options.launchd.user.agents`, so option flows trace across modules)

Language	Benchmark repo	Coverage
TypeScript / JavaScript	this repo	95.8%
Python	psf/requests	100%
Go	gin-gonic/gin	96.6%
Rust	BurntSushi/ripgrep	86.7%
Java	google/gson	93.3%
C#	jbogard/MediatR	85.2%
PHP	guzzle/guzzle	100%
Ruby	sidekiq/sidekiq	100%
C	redis/redis	92.2%
C++	google/leveldb	94.8%
Objective-C	SDWebImage	91.6%
Swift	Alamofire	95.3%
Kotlin	square/okhttp	96.2%
Scala	gatling/gatling	91.2%
Dart	flutter/packages	92.4%
Svelte / SvelteKit	sveltejs/realworld	100%
Vue / Nuxt	nuxt/movies	93.5%
Astro	xingwangzhe/stalux	93.0%
Lua	nvim-telescope/telescope.nvim	84.2%
Luau	dphfox/Fusion	92.2%
Liquid	Shopify/dawn	73.8%
Pascal / Delphi	PascalCoin	77.4%