| search_codebase | Find code by concept, symbol, or path — hybrid codebase search. For QUESTIONS ("how does X work", "where is Y handled", "why is Z like
this"), call get_answer instead: it runs this same hybrid retrieval
internally and synthesizes a cited answer, so a search_codebase call
before get_answer is a wasted round-trip. Use this tool directly when you
want the raw ranked hits themselves — enumerating matches, resolving an
identifier to a symbol_id, or scoping a later get_context call.
mode="auto" (default) routes the query: identifier-shaped queries search
the indexed symbols (returns symbol_id/file/line bounds — pipe into
get_symbol), path-shaped queries resolve files (pipe into get_context),
and conceptual queries ("rate limiting", "where do we handle webhooks")
run wiki-semantic search. Mixed natural-language + identifier queries run
hybrid (symbol hits first, then concept pages). Concept results carry
search_method ("embedding" or "bm25" fallback: verify those); decision
records rank below file pages unless the query is why-shaped.
Args:
query: identifier, path, or natural-language query.
limit: max results (default 5).
page_type: file_page | module_page | symbol_spotlight (concept only).
kind: implementation | test | config | doc (concept/symbol modes).
repo: alias, or "all" for workspace-wide.
mode: auto | concept | symbol | path | hybrid.
symbol_kind: filter symbol hits by kind (function|class|method|...).
|
| get_answer | Synthesised answer with citations and a calibrated trust signal. The single entry point for questions: "how does X work" / "where is Y" /
"why is Z". It runs the full hybrid retrieval internally (no prior
search_codebase call needed) and answers in one round-trip.
confidence=high is content-grounded (value + citation-source + frame
gates): cite it directly, no verification Read needed. A "why" answer
whose named mechanism is absent from the retrieved source is downgraded
to medium (the rationale may be conflated). Low confidence returns
best_guesses with one-line justifications instead of an empty answer.
retrieval_quality separately rates the retrieval that fed synthesis.
When the answer names a function/method/class, ``symbol_bodies`` carries
its full live body — read that instead of a follow-up get_symbol.
Args:
question: developer question.
scope: optional path-prefix filter (e.g. "src/pkg/").
repo: usually omitted.
|
| get_change_riskA | Score a live commit or base..head range from its diff shape. Use this for a pre-merge score of a commit or PR range. It is distinct from
``get_risk``, which assesses indexed files and PR blast radius. ``extensions``
restricts counted suffixes; ``exclude_patterns`` omits gitignore-style paths.
Both filters also apply to the baseline used for the repository percentile.
Prefer ``risk_percentile`` as the indicator of change risk: it ranks this
change against sampled recent commits in the same repository. Summarize it
with ``review_priority`` and ``classification``. ``score``, ``probability``,
and ``level`` are secondary corpus-calibrated context, the fallback only
when ``risk_percentile`` is unavailable.
``impacted_tests`` names the tests the per-test coverage map proves execute
the change's changed *lines* (line-precise, narrower than get_risk's
file-level ``tests_to_run``), with ``missing_tests`` buckets for changed
lines no test covers. Its ``status`` is ``no_map`` (unknown, run the full
suite), never "untested", when no map is ingested.
Args:
revspec: Commit or ``base..head`` range to score. Defaults to ``HEAD``.
repo: Repository alias in workspace mode; omit for the default repository.
extensions: File suffixes to count, for example ``[".py", ".ts"]``.
exclude_patterns: Gitignore-style paths to omit, for example ``["tests/", "*.md"]``.
baseline: Recent commits to sample for percentile ranking; 0 disables it.
|
| get_contextA | Triage card for files / modules / symbols — relationships, not source bytes. Returns title, summary, signatures, hotspot bit, decision_record titles,
and symbol_ids to pipe into get_symbol (cheaper than Read for bodies).
Batch targets in one call. File targets above ~80 lines default to a
skeleton (every signature + top-PageRank bodies, with a verified flag —
a fraction of Read cost); ``mostly_full`` marks files where a direct
Read costs little more.
Args:
targets: file paths, module paths, or "path::Symbol" ids.
include: opt-in blocks: full_doc | ownership | last_change | callers
| callees | metrics | community | decisions | skeleton.
compact: default True; False adds structure+imports+docstrings.
repo: usually omitted.
|
| get_dead_codeA | Unused exports, unreachable files, zombie packages — tiered by confidence. Run before a cleanup sprint, not a targeted fix. Findings tier
high/medium/low with per-directory and per-owner rollups; workspace
mode lowers confidence on findings other repos import.
Args:
repo: usually omitted.
kind: unreachable_file | unused_export | unused_internal | zombie_package.
min_confidence: floor, default 0.5 (0.7 = cleanup-ready only).
safe_only: deletion-ready findings only (no runtime-load risk).
limit: max findings per tier (clamped to 25).
tier: "high" (>=0.8) | "medium" | "low".
directory: path-prefix filter.
owner: primary-owner filter.
group_by: "directory" | "owner" rollup.
include_internals: also scan private symbols (more false positives).
include_zombie_packages: monorepo package findings (default true).
no_unreachable: skip file-level reachability findings.
no_unused_exports: skip public-export findings.
|
| get_healthA | Code-health scores and findings — self-check a file before/after editing. No ``targets`` → repo dashboard (KPIs, worst files, ``high_leverage_files``
ranked by ``weighted_deficit`` = the files that actually move the repo
average). With ``targets`` → per-file scores + findings for those paths.
Three co-equal dimensions per file: ``score`` (defect risk, the headline),
``maintainability_score`` (readability/change-cost smells), and
``performance_score`` (static I/O-in-loop / N+1 RISK, high-precision /
low-recall, never blended into the defect headline). Each finding carries
its ``dimension``; a performance finding's ``details`` name the
``boundary_kind`` (db/network/filesystem/subprocess/lock) and, for
cross-function N+1, the caller→sink ``path``.
Args:
targets: file paths or ``module:<name>``. Empty → dashboard mode.
include: opt-in blocks (default stays lean): ``biomarkers`` (findings
in dashboard mode) | ``refactoring`` (deterministic suggestion per
finding) | ``trend`` | ``coverage`` | ``accuracy`` (does the score
rank the buggy files first) | ``signals`` (per-file churn/owners/
degree, targeted mode) | ``churn_complexity`` (danger-zone
quadrant) | ``performance``/``defect``/``maintainability``
(filter findings to one dimension).
repo: usually omitted.
limit: max rows in ranked lists (capped at 50).
|
| get_overviewA | Architecture map for an unfamiliar repo — first call when you don't know your way around. Returns the synthesised overview plus key modules, entry points, repo-wide
git health (hotspot count, churn trend, bus-factor distribution), the
knowledge map (top owners, knowledge silos), and the community summary.
Skip this on subsequent calls — once you have the map, jump straight to
``get_context`` / ``get_answer``.
Compact by default: ``content_md`` carries only the overview essay's summary
section — the rest of the essay repeats ``key_modules`` / ``entry_points`` /
``architecture.layers``. Pass ``include=["content"]`` for the full essay.
In workspace mode:
- Omit ``repo`` for the default repo's overview plus a workspace footer.
- ``repo="all"`` returns the cross-repo topology (co-changes, package deps,
API contracts) — no single-repo detail.
- ``repo="<alias>"`` targets one specific repo.
Args:
repo: Repository alias, path, or ID. Use ``"all"`` for workspace overview.
include: Opt-in extras. ``"content"`` returns the full overview essay in
``content_md`` instead of the compact summary section.
|
| list_repos | List repos available through this MCP server. In workspace mode this returns every configured workspace repo alias. Use
those aliases as the ``repo`` parameter on workspace-aware tools.
|
| get_riskA | What history says about touching these files — churn, owners, blast radius. Fuses git temporal signals (churn percentile, trend, bus factor) with
graph topology (dependents, co-changes, impact surface) and security
findings. Consult before editing 95th+ churn-percentile files. Pass
changed_files for PR mode: the response leads with a directive block
(will_break, missing_cochanges, missing_tests, tests_to_run) — read it
first. tests_to_run is coverage-backed: the tests the per-test map proves
exercise the changed files, empty when no coverage map is ingested.
To score a live commit or ``base..head`` diff by revspec instead of file
paths, use ``get_change_risk``.
Args:
targets: file paths to assess.
repo: usually omitted.
changed_files: PR-changed files for blast-radius mode.
|
| get_symbolA | Read one function/class/constant with live-verified line bounds. Raw source of one indexed symbol, bounded (~600 lines) — cheaper than
Read+offset math. ``source`` uses Read's exact line-numbered format;
treat it as an already-performed Read. ``verified: true`` = bounds
checked (or corrected) against the live file: no follow-up Read needed.
``bounds: "approximate"`` = the symbol moved and re-location failed.
An ambiguous id (overloads, re-exports) returns ALL matching bodies in
``candidates`` — none is silently chosen. Also serves live range reads
("path.py:140-180", ≤200 lines, always verified) and omission refs
("repowise#<12-hex>"). Index misses grep the live file and return
fallback_lines instead of a dead end. When ``truncated`` is true the
response carries a ``continuation`` token — the exact range read that
fetches the remainder; pass it straight back to get_symbol.
Args:
symbol_id: "path/to/file.py::Name" (from get_context),
"path/to/file.py:140-180" for a live range, or an omission ref.
context_lines: extra lines before/after (0-50).
repo: usually omitted.
query: omission refs only — regex/substring filter on lines.
id: accepted alias for ``symbol_id`` — the tool table documents this
tool as ``get_symbol(id)``, so ``id=`` is the natural call and is
forgiven here rather than met with a hard argument error.
|
| get_whyA | Why this code is shaped this way — decision records + evidence commits. Call before refactors or pattern divergences. Query modes: a question
("why is auth using JWT?"), a file path (governing decisions + origin
story + alignment score), a question anchored to targets, or no query
(decision health dashboard). Falls back to git archaeology when no
decisions exist for a path — never empty.
Args:
query: question, file/module path, or omit for the dashboard.
targets: optional file paths to anchor the search.
repo: usually omitted.
|
