code-atlas

Run a raw tree-sitter S-expression query over indexed files of one language and return every capture as path:line with the captured text. Powerful for structural searches no regex can express, e.g. `(call_expression function: (identifier) @fn (#eq? @fn "eval"))` or `(for_statement (await_expression) @hit)`. Parses files on demand, normalized the same way the indexer parses them (e.g. C++ dllexport macros blanked so class nodes parse) — use path_prefix to narrow scope on big repos.

Compact one-line info for up to 50 symbol ids in a single call — resolve the #ids from call_hierarchy / change_impact / find_dead_code output without one get_symbol_info round trip each. Set include_source for the definition snippets too.

Who calls this symbol (direction=in) or what it calls (direction=out), as a tree up to `depth` levels. Uses the exact language server when available ([lsp 1.00] edges), structural index otherwise (confidence per edge).

Which files historically change together with this one? Directional: "when I touch A, B changes 45% of the time" and the reverse, because the asymmetry is the signal. Flags coupled files with NO import edge — config, fixtures, generated code and string-keyed lookups the structural graph cannot see. Co-change is correlation, not causation; commits touching more than 50 files are excluded as refactors.

Blast radius of a change: transitive callers/subtypes of the target plus files reachable through imports, with affected TEST files highlighted. Target a symbol (symbol_id/path+line/name), a set of files (files=[...]), or nothing — no arguments analyzes the uncommitted git diff.

One-call, token-budgeted briefing on a symbol: definition source, surrounding file outline, type context, top callers/callees, route (if a handler), and related tests — instead of stitching six separate lookups. Sections that exceed the budget are named so you can ask for them specifically. Optional task string pulls in possibly relevant symbols.

Reverse lookup across engine assets: which scenes/prefabs/Blueprints reference this script, scene, asset path, or handler method? Accepts a workspace-relative path, a res:// or /Game/ path, or a bare method/class/event name (Unreal: called functions via call_function, event handlers via handles_event).

Symbols nothing references: no resolved occurrence and no graph edge points at them, after excluding entry points, route handlers, and engine/framework lifecycle callbacks. Candidates with unresolved same-name usages elsewhere are hedged as "possibly dead" — dynamic dispatch and reflection are invisible to a structural index, so treat this as a review list, not a delete list. A second section lists exported symbols only ever used inside their own file.

Usages of a symbol. Uses the exact language server when one is available (provenance lsp), falling back to indexed usages: resolved references first (with confidence), then unresolved same-name occurrences as candidates.

Which code serves this URL? Matches a concrete request path (e.g. "/api/users/7") against indexed route patterns, parameter segments (:id, {id}, <int:pk>) treated as wildcards. Returns the handler symbol (#id chains into call_hierarchy / change_impact).

Does a helper for this already exist? Near-duplicate search over the indexed code: target an existing symbol or paste a snippet. Uses local embedding vectors when ready ([cos]), degrading to token-shingle text similarity ([jaccard]) while embedding coverage builds.

Render index data as a Mermaid diagram (returned in a ```mermaid fence — paste into GitHub markdown, docs, or a Mermaid viewer). kind=imports: workspace import graph, file-level with directory clusters or collapsed to directories (granularity, path_prefix to scope). kind=calls: call graph around one symbol (direction in/out/both, depth). kind=types: inheritance diagram around one type. kind=call_path: shortest call chain from one symbol to another (from_name/from_id -> to_name/to_id). Dotted arrows are low-confidence structural edges (< 0.70) — hints, not facts.

What a file imports (direction=out) or which files import it (direction=in). Unresolved specifiers are external packages or system headers.

Hierarchical outline of every definition in a file, with signatures — read the structure of a file without reading its source. Pass a DIRECTORY instead of a file to get its public API surface in one call rather than one call per file. Over budget, nesting depth is shed before any top-level symbol is dropped, so the shape stays honest. Set include_docs to also get first-line doc comments.

Node tree of a game-engine scene file with attached scripts, instanced sub-scenes, and signal connections. Supports Godot .tscn/.tres today (Unity prefabs planned).

Full detail for one symbol: signature, doc comment, location, container — and optionally its source. Identify the symbol by id (from search_symbols/get_file_outline), by file+line position, or by exact name.

Definition site of the identifier at a file position. Uses the exact language server when available, falling back to the structural index (resolved occurrence at that position).

Risk-ranked files: git commit churn over a window multiplied by current size (score = commits × log2(lines)). High churn on large files marks refactor and review targets.

Indexing progress, per-file errors, and freshness of the code index.

Web-framework routes indexed across the workspace (Express, Fastify, NestJS, FastAPI, Flask, Django, plus file-based routing for Next.js, SvelteKit, Nuxt, and Remix), one line per route with its handler symbol. Filter by framework, HTTP method, or a path fragment.

Cheap orientation router: languages, file/symbol counts, index freshness, top-level layout, entry-point and dependency counts. Call repo_map next for the annotated architecture map.

Force an incremental re-scan of the workspace (hash-checks every file, reindexes changed ones).

Annotated architecture map of the workspace — the first call to make in an unfamiliar repo. Directory tree with per-directory file/symbol counts, dominant language, role, size and import fan-in/fan-out (so layering is visible), plus entry points, the highest-fan-in symbols, and the third-party dependency inventory. One budgeted call instead of a grep sweep. Use path_prefix and depth to zoom into a subtree, and sections to ask for just one part. Ranking is structural and heuristic: reflection, DI and string-keyed dispatch are invisible to it.

Find engine-reflected declarations: Unreal UCLASS/UPROPERTY/UFUNCTION specifiers (e.g. "BlueprintCallable", "Replicated"), Unity attributes ("[SerializeField]"), and Godot annotations ("@export", "@onready") or signals. Answers from the index: declaration signatures plus Unreal reflection macros captured onto the annotated symbol.

Search definitions (functions, classes, methods, …) by name across the whole workspace. Matches name prefixes and doc comments; falls back to substring match. Returns one line per symbol with its id (#N) for use with get_symbol_info.

Natural-language search over the code: describe behavior ("where is retry backoff implemented", "function that validates auth tokens") rather than symbol names. Hybrid keyword+embedding ranking, fully local. First-ever call downloads the embedding model (~150 MB one-time); until embedding coverage completes, results are keyword-weighted and say so.

How did this symbol get this way? Line-range git history (git log -L) for the symbol's span: commit, date, author and subject, following the code as it moves within its file. Answers "why is this here" and "who do I ask" without reading the diff.

Which tests exercise this symbol? Walks the call/type graph backwards from the target to test files (strongest evidence, names the test-case symbol), then adds test files that only reach it through imports (weaker signal). Complements change_impact: this answers "what should I run?" for one symbol directly.

Shortest call chain from one symbol to another over the indexed call graph — "how does the request handler end up in the DB layer?". Both ends accept a symbol id or an exact name.

Supertypes (direction=super: what this type extends/implements) or subtypes (direction=sub: what extends/implements it), as a tree.

Post-edit structural check of the uncommitted working tree (or explicit files) against git HEAD: imports that stopped resolving, removed exports that other files still reference, and signature changes with live callers. change_impact predicts blast radius before an edit; this confirms what actually broke after. Waits for the index to catch up with the edits before answering.