MCP Tools Reference

Enumerate every entry into the codebase — HTTP routes, jobs, MQ consumers, CLI commands, lifecycle hooks, GraphQL subscriptions, webhooks, mobile deep links.

Inputs

(none) — or { method?: string, service?: string }

Returns

Array of { method, path, handler, file, line, service, auth, meta }.

Tokens

~1.8k tokens for a medium repo (~150 entries).

Deep dive on one route: its handler source, immediate callees, called DB tables, sequence diagram nodes.

Inputs

{ method, path } or { handlerName }

Returns

{ handler, sequence, dependencies, schemaTouches }

Tokens

~700 tokens per route.

Bundle every route, function, and file that belongs to one Louvain-detected feature cluster.

Inputs

{ clusterId | clusterLabel }

Returns

{ routes, functions, files, healthSignals }

Weighted reverse-indexed keyword search across features, routes, functions, classes. camelCase / snake_case aware.

Inputs

{ query: string, requireAll?: boolean }

Returns

Ranked hits with { kind, label, file, line, score }.

Top-line numerical summary of what changed vs baseline — files added/deleted/modified, routes touched, services affected.

Inputs

(none)

Returns

{ files: { added, deleted, modified }, routes: …, services: … }

Tokens

~28 tokens.

Blast radius for a hypothesised edit. Direct callers, transitive callers, tests that need re-running.

Inputs

{ file | symbol }

Returns

{ direct: string[], transitive: string[], reviewRequired: string[] }

What changed in the public HTTP/GraphQL/gRPC surface vs baseline. Added routes, removed routes, signature changes.

Inputs

(none) — or { service }

Returns

{ added: Route[], removed: Route[], modified: Route[] }

One-shot context for a file you're about to edit. Purpose, callers, callees, nearby tests, recent diffs.

Inputs

{ file: string }

Returns

Compact JSON brief, typically 600–900 tokens.

Notes

The cheapest way to brief an agent before any edit.

"What should I re-test for this change?" — composes the working diff, blast radius, coverage, and cross-repo consumers into a ranked re-test plan.

Inputs

(none) — or { repoId } in multi-repo workspaces

Returns

{ changedEntryPoints, impactedEntryPoints, crossRepoConsumers, coverageGaps }

Pull a single function's source by name, with surrounding context.

Inputs

{ name, file? }

Returns

{ source, file, lineStart, lineEnd, language }

BFS over the workspace call graph from A to B. Useful for proving reachability.

Inputs

{ from: string, to: string, maxDepth?: number }

Returns

Array of paths, each path = string[].

Direct in- and out-edges for a function. Cheaper alternative to trace_call_path when you just need 1 hop.

Inputs

{ name, file? }

Returns

{ callers: string[], callees: string[] }

Functions with structurally similar bodies — duplication / DRY candidates.

Inputs

{ name, file?, threshold?: number }

Returns

Ranked list of similar functions with similarity scores.

Dead code, god files, high-coupling hotspots, cycles, orphaned clusters.

Inputs

(none)

Returns

{ deadCode, godFiles, highCoupling, cycles, orphans } — each entry severity-ranked.

Rule-based violations of declared architecture (layer crossings, banned dependencies). Configured via repo's .codeatlas/rules.json.

Inputs

(none)

Returns

Violation list with { rule, source, target, severity }.

Per-route coverage when LCOV / Istanbul JSON is present. Lets the agent prefer covered code paths.

Inputs

(none)

Returns

{ route → { coveredLines, totalLines, percent } }

List the registered graph overlays (diff, comments, coverage, TODO density, future Sentry/APM adapters) with their paint style and current toggle state.

Inputs

(none)

Returns

Array of { id, displayName, paint, join, enabled }.

Fetch one overlay's data points joined to graph anchors. UI toggles never gate data — the agent always gets the points.

Inputs

{ id: string } — e.g. "coverage", "todo-comments"

Returns

{ points: Array<{ target, value, severity? }>, unresolved: number }

Same as list_entrypoints but with cursor pagination — for repos with thousands of routes.

Inputs

{ cursor?, limit?: number }

Returns

{ items, nextCursor }

Saved diagram views (filtered subsets of features / services). Users save them in the browser UI.

Inputs

(none)

Returns

Array of { id, label, filter, layer }

Healthcheck — is the snapshot DB present, when was the last successful index, what files are dirty.

Inputs

(none)

Returns

{ snapshotAt, dirtyFiles, lockHolder, version }

Workspace-wide impact view: top hotspots, files with the largest transitive caller set.

Inputs

(none) — or { limit?: number }

Returns

Ranked list.

Return the column list for every allowlisted table in the snapshot DB. Call this first so the model can write valid SQL.

Inputs

(none)

Returns

{ tableName → ColumnInfo[] }

Read-only SELECT (or WITH cte AS SELECT) against the snapshot DB. Strict guardrails — single statement, allowlist tables, CTE-aware, row cap.

Inputs

{ sql: string, params?: any[] }

Returns

{ rows, rowCount, truncated? }

Notes

No LLM in the loop — deterministic.

Diff this workspace against another snapshot path. Useful for monorepo↔monorepo or before/after migrations.

Inputs

{ otherWorkspacePath: string }

Returns

{ routeDiff, fileDiff, healthDiff }

Deterministic extractive summariser. Compresses long tool outputs (e.g. a 50-route list) without an LLM round-trip.

Inputs

{ payload, maxTokens? }

Returns

{ summary, droppedKeys }

Emit an OpenAPI 3.1 document from detected routes (HTTP only).

Inputs

(none)

Returns

OpenAPI JSON.

Emit an OpenAI / Anthropic function-calling schema for every detected route. Drop into a function-calling LLM as-is.

Inputs

(none)

Returns

Array of function-calling tool descriptors.

Return one entry per detected repository in a multi-repo workspace (each top-level folder with a manifest, or each serverless service folder, or each binary entry point in a multi-binary Go / Rust workspace). Single-repo workspaces return one entry.

Inputs

(none)

Returns

{ mode: 'single' | 'multi', repos: [{ repoId, name, root, kind }] }

Notes

Pair with any per-repo-scoped tool (e.g. `list_entrypoints({ repoId })`) to reach a specific repo.

Generate a guided codebase walkthrough — ordered list of routes / functions / files most worth understanding first. Driven by fan-in ranking + entry-point priority so tests, migrations, seeds, and library internals don't lead.

Inputs

{ mode?: 'codebase' | 'recent', maxSteps?: number }

Returns

{ steps: [{ id, label, blurb, layer, openIn }], totalSteps }

Tokens

~700 tokens for a 5-step tour.

Execute a multi-step API call chain end-to-end. Each step carries env-var extraction recipes + per-step assertions. Pre-/post-scripts run in a sandbox with a curated `pm.*` API (Postman-compatible).

Inputs

{ steps: ChainStep[], initialEnv?, stopOnFirstFailure?: boolean }

Returns

{ steps: StepResult[], finalEnv, passed, failed, errored, aborted }

Notes

Pairs with `generate_chain` so an agent can both author and execute a chain in one session.

Open a Server-Sent Events stream against a URL and capture inbound messages. Times out cleanly.

Inputs

{ url, headers?, timeoutMs?, maxMessages? }

Returns

{ messages: [{ event, data, id, retry, ts }], closedAt }

Open a WebSocket connection, optionally send a message, and capture inbound frames within a timeout window. Useful for testing real-time endpoints.

Inputs

{ url, headers?, sendOnConnect?: string, timeoutMs?, maxMessages? }

Returns

{ messages: [{ data, ts, type }], closedAt }

Exchange an authorization code (or refresh token) for an access token against an OAuth2 token endpoint. Stores the resulting token in the environment under a named variable for follow-up requests.

Inputs

{ tokenUrl, grantType, code?, refreshToken?, clientId, clientSecret?, redirectUri?, scope?, storeAs? }

Returns

{ access_token, token_type, expires_in, refresh_token?, scope? }

Build a fully-formed OAuth2 authorization URL (PKCE-safe) for the user to open in a browser. Returns the URL plus a state/verifier pair to pass into `oauth2_token`.

Inputs

{ authorizationEndpoint, clientId, redirectUri, scope?, usePkce?: boolean, state? }

Returns

{ url, state, codeVerifier? }

Import a Postman, Insomnia, or OpenAPI collection into the API Testing workbench. Auto-detects format from file content.

Inputs

{ source: 'file' | 'json', path?, json?, mergeStrategy?: 'replace' | 'merge' }

Returns

{ imported: { collections, requests }, dropped, format }

Propose a request body for a detected route. Inferred from the handler source — every field is grounded in a quoted source line; fields without evidence are dropped before returning.

Inputs

{ apiId, llmConfig }

Returns

{ body: object, evidence: { field → sourceQuote }, dropped: string[], rawText, model, usage }

Notes

Evidence-gated. The model cannot invent fields that don't appear in the handler.

Propose a runnable multi-step API call chain from a natural-language description of a workflow. Each step is evidence-gated against handler source — extractions and assertions reference quoted lines.

Inputs

{ description: string, llmConfig }

Returns

{ chain: ChainStep[], evidence, dropped, rawText, model, usage }

Notes

Pair with `run_api_chain` to execute the proposed chain.

Propose test cases (positive, negative, edge) for a detected route. Each case quotes a handler source line so the model can't invent unreachable branches.

Inputs

{ apiId, llmConfig }

Returns

{ cases: TestCase[], dropped, rawText, model, usage }

Every AI-review finding with severity, category, and the source lines it quotes. Filter by layer, severity, status, or entry point.

Inputs

{ graphId?, entryPointId?, severity?, status?, limit? }

Returns

{ items: Finding[], total }

Tokens

~50 tokens per finding.

One finding's full body, all layer bindings, the source it quotes, and the file/symbol anchor.

Inputs

{ findingId }

Returns

Single Finding.

Counts grouped by diagram layer, entry point, and severity. Drop-in for the count badges on each layer header.

Inputs

(none) — or { status }

Returns

{ byGraph, byEntryPoint, bySeverity, total }

Tokens

~80 tokens.

Mark a finding resolved or ignored after the fix lands. Refused in read-only mode.

Inputs

{ findingId, status: 'open' | 'resolved' | 'ignored' }

Returns

Updated Finding.

Read the team's free-text review rules currently injected into every review prompt.

Inputs

(none)

Returns

{ text, hash, updatedAt }

Replace the team's review rules (up to 8 KB). The new rules are used on the next review run. Refused in read-only mode.

Inputs

{ text: string }

Returns

{ text, hash, updatedAt }

Natural-language search over findings. "What's wrong with auth?" / "anything fishy in the article create flow?" — the intent is parsed to a route, cluster, or file scope before matching.

Inputs

{ query: string, limit? }

Returns

{ intent, matches: [{ finding, score, reason }] }

Extractive 3–7 bullet summary of findings in a scope. Deterministic — no LLM call. For small-context agents.

Inputs

{ graphId?, entryPointId?, maxBullets? }

Returns

{ title, bullets, counts }

Group open findings by which guideline triggered them. Surfaces which rules are pulling weight vs. which guidelines yield nothing.

Inputs

(none) — or { guidelinesHash }

Returns

{ groups, totalGroups }

Single low-token call for "how's the review looking?" — total findings by layer + severity, last guidelines hash, top error samples.

Inputs

(none)

Returns

{ counts, guidelines, topErrors }

Tokens

~200 tokens.

Wipe AI-review findings within a scope before a fresh review run. Refused in read-only mode.

Inputs

{ scope: 'all' | 'cluster' | 'entry', clusterId?, entryPointId? }

Returns

{ removed }

One-shot bundle for an agent that wants to fix a finding: the finding + the entry-point pack + impact analysis + adjacent comments — all in one call, ready for a code-edit prompt.

Inputs

{ findingId }

Returns

{ finding, pack, siblingComments }

Tokens

Typically ~8 KB for a median entry point.

Rank a set of findings against a natural-language query. Useful when you have many findings and want only the ones relevant to a specific question.

Inputs

{ query, findingIds?, threshold?, limit? }

Returns

{ items, intent }

Given a finding the user agreed with, propose a one-line guideline that would catch the same pattern next time. The user reviews + adds it via set_review_guidelines.

Inputs

{ findingId }

Returns

{ proposedGuideline, rationale, sourceFinding }

Surface the scope of entry points that changed since baseline, ready for a targeted review. Cheaper than a full re-review when only a few routes changed.

Inputs

{ scope?: 'changed' | 'cluster' | 'entry', clusterId?, entryPointId? }

Returns

{ scope, entryPointCount, entryPoints, instruction }