jCodemunch MCP

Find concrete implementations of an interface, abstract class, or method. Multi-source resolution with confidence scoring: SCIP/LSP evidence (1.0), AST class hierarchy (0.85), duck-typed name match (0.65), decorator handler (0.45) — declared priors; _meta.confidence_provenance states each channel's basis and measured precision/recall. Classifies each impl (subclass_override / interface_impl / duck_typed / decorator_handler / subclass), ranks by PageRank × byte_length, attaches differs_by breakdown. Optional cross_repo=true surfaces impls in other indexed repos via the package registry.

Find all files that import a given file. Answers 'what uses this file?'. has_importers=false on a result means that importer is itself unreachable (dead code chain). Supports dbt {{ ref() }} edges. Use file_paths for batch queries. Set cross_repo=true to also find importers in other indexed repos. Import edges only; textual uses are not reported.

Find the files that import or re-export an identifier, via the import graph. Answers 'who imports this?'. SCOPE: import sites + dbt `{{ ref() }}` edges + (when `include_call_chain=true`) symbols whose bodies mention it. NOT the tool for 'where is this used': call sites are invisible to the import graph (a single-file library reports 0), so ask check_references or search_text. Use `identifiers` for batch queries.

Find clusters of similar functions/methods/classes — consolidation candidates. Blends three signals: semantic (embedding cosine when embed_repo has run), structural (signature-token Jaccard + size ratio), and behavioral (callee-set Jaccard). Runs union-find clustering, classifies each cluster (near_duplicate / similar_logic / parallel_implementation), picks a canonical symbol per cluster (highest PageRank), and surfaces 'differs_by' breakdowns so an agent can recommend keep-this/replace-those. Pre-filters via BM25 inverted index — sub-N^2 on large repos. Degrades gracefully without embeddings …

Symbols with zero (or stale) runtime hits over the look-back window. Distinct from find_dead_code: this surfaces code that's reachable on paper but never executed — only possible to detect with runtime data. Excludes test files and entry-point filenames by default. Returns an empty results list when no traces have been ingested (refuses to flag every symbol as 'unused' against an empty runtime baseline).

Structural concentration, dependency depth, and modularity in one read-only call, over the file import graph. concentration: Gini coefficient (0 even -> 1 hoarded) over per-file symbol count, size, fan-in (importers), and fan-out (imports) + the top concentrators — answers 'is complexity/coupling piling up in a few files?' which a hotspot list (the peaks) can't. depth: longest dependency chain + level distribution (Lakos levelization) over the cycle-condensed DAG. modularity: cluster count + the hidden coupling a Design Structure Matrix highlights (back-edges = cycle-participating import edges…

Find all files affected by changing a symbol. Returns confirmed files (import + name match) and potential files (import only, e.g. wildcard). Use before renaming or deleting a symbol. Set cross_repo=true to also find consumers in other indexed repos. Set include_source=true to get source snippets at each reference site (fix-ready context in one call). For automated edit plans, use plan_refactoring instead.

Return incoming callers and outgoing callees for a symbol, N levels deep. Uses AST-derived call detection: callers = symbols in importing files that mention this name; callees = imported symbols mentioned in this symbol's body. Useful for understanding how a symbol fits into the call graph before refactoring. For a 'what breaks if I delete this?' answer, use get_impact_preview instead. Detection is name-based, so same-name symbols in different modules can merge and dynamic dispatch is missed. Only depth-1 rows are direct callers; on a deeper row, `via` names the row it is reached from. `caller…

Map a git diff to affected symbols: given two commits, returns which symbols were added, removed, modified, or renamed. Useful after merging a PR to answer 'what actually changed?' for code review or regression triage. Requires a locally indexed repo (index_folder). Defaults to comparing current HEAD against the SHA stored at index time.

Return git churn metrics for a file or symbol: commit count, unique authors, first_seen date, last_modified date, and churn_per_week over a configurable window. assessment: 'stable' (<=1/week), 'active' (<=3/week), 'volatile' (>3/week). Requires a locally indexed repo (index_folder); GitHub-indexed repos are not supported.

Get the full inheritance hierarchy for a class: ancestors (base classes via extends/implements) and descendants (subclasses/implementors). Works across Python, Java, TypeScript, C#, and any language where class signatures contain 'extends' or 'implements'. Bases are resolved from indexed signature text, so a dynamically assigned or generated base class is not found.

Get full source + imports for one or more symbols in one call. Multi-symbol bundles deduplicate shared imports. Set token_budget to cap response size; use budget_strategy to control what's kept. Supports fqn (PHP FQN via PSR-4) as alternative to symbol_id.

Return afferent coupling (Ca), efferent coupling (Ce), and instability score for a file/module. Ca = files that import this module (dependents). Ce = files this module imports (dependencies). Instability I = Ce/(Ca+Ce): 0 = stable, 1 = unstable. Use to identify fragile modules and guide refactoring priorities. Counts import edges only, so a module coupled through configuration, strings, or dependency injection reads as stable.

Return which indexed repos depend on which other indexed repos at the package level. Shows the full cross-repository dependency map based on package names extracted from manifest files (pyproject.toml, package.json, go.mod, Cargo.toml, etc.). Use to visualize how your indexed repos are interconnected. Pass repo to filter to a single repo's perspective. Edges come from package names in manifest files, so a path or git dependency with no manifest entry is invisible.

Find likely-dead functions and methods using three independent evidence signals: (1) the symbol's file is not reachable from any entry point via the import graph (filename heuristic + package.json main/module/exports/bin), (2) no indexed symbol calls this symbol in the call graph, (3) the symbol name is not re-exported from any __init__ or barrel file (recursively follows CJS `module.exports = require(...)` and ES `export * from`). Each result includes a confidence score (0.33 = 1 signal, 0.67 = 2 signals, 1.0 = all 3). More reliable than single-signal dead-code detection. Use min_confidence=0…

Repo-wide census of decorators / annotations / attributes: 'where is every @app.route / @Injectable / @pytest.fixture / [Serializable], and how many?' in one read-only call. Cross-language by construction (aggregates the decorators the index stored on each symbol). Forms are NORMALIZED (leading @, call-arguments, and [] brackets stripped) so @app.route('/a') and @app.route('/b') count under one bucket instead of scattering; each bucket keeps the distinct raw_forms it collapsed, a per-decorator symbol-kind breakdown, and a file count. Filter by name_filter (substring on the normalized name), sc…

Call this when you want a cost-per-outcome read on a codebase — how much AI spend produced durable change over a window, not raw commit or token volume. Quantify durable-change delivery over a window: of the non-merge commits in the last window_days, how many landed and stuck (commits_durable) vs were reverted or re-touched within rework_horizon_days (churn-back). commits_durable is the honest numerator for a cost-per-outcome ratio — divide AI spend over the same window by it to show how much got done for how little, instead of rewarding raw activity. Hub files co-touched by most commits (CHAN…

Detect circular import chains in a repository. Returns every strongly-connected component (set of files that mutually import each other, directly or transitively). Run this to identify architectural problems before a refactor, or to understand why a module is hard to test in isolation. Detects cycles in the file-level import graph only; it says nothing about call-level or runtime cycles.

Get the file-level dependency graph for a given file. Traverses import relationships up to 3 hops. Use to understand what a file depends on ('imports'), what depends on it ('importers'), or both. Prerequisite for blast radius analysis. Set cross_repo=true to include cross-repository edges.

Endpoint-centric impact analysis: 'what breaks if I change this HTTP endpoint?' Given an endpoint (method + URL, e.g. 'GET /users') or a handler symbol, returns the handler plus what changing it affects — importing files + callers (blast radius) and any templates it renders. Read-only. Resolves string-dispatch routes (Django/Express/Flask/Rails) and decorator routes (Flask/FastAPI/Spring) by their local path; for prefix-composed FastAPI (APIRouter prefix) or Spring class-level mappings whose full URL isn't resolved yet, pass handler_symbol_id instead.

Identify functions in a file that are good candidates for extraction to a shared module. A candidate must have high cyclomatic complexity (doing a lot) AND be called from multiple other files (already implicitly shared). Results are ranked by score = complexity × caller_file_count. Requires re-indexing with jcodemunch-mcp >= 1.16 to populate complexity data.

Get cached source for a file, optionally sliced to a line range. Reads the indexed copy, not the working tree.

Get all symbols (functions, classes, methods) in a file with full signatures (including parameter names) and summaries. Use signatures to review naming at parameter granularity without reading the full file. Pass repo and file_path (e.g. 'src/main.py'). Indexed symbols only, so an unparsed file returns empty.

Per-symbol composite risk for one file. For each function or method, returns a 0-100 composite score (higher = healthier; lower = riskier) plus per-axis sub-scores (complexity, exposure, churn, test_gap). Powers the VS Code risk-density gutter. complexity is per-symbol (cyclomatic from the index); the other three axes are file-level (shared across all symbols in the file) because per-symbol caller-count needs find_references per symbol and would be too slow for save-time refresh.

Get the file tree of an indexed repository, optionally filtered by path prefix. Results are capped at max_files (default 500) to prevent token overflow; use path_prefix to scope large trees.

Surface the de-facto API contracts across a group of indexed repos. Walks each member's named imports, resolves them to symbols in other members via the package registry, and classifies each shared symbol into one of four verdict tiers: 'de_facto_api' (used by ≥min_importers external repos), 'leaky_internal' (underscore-prefixed or in _internal/ but imported externally — architecture violation), 'dead_contract' (declared public but unused externally; opt-in), 'version_skew' (same name imported via multiple specifier roots — coordination risk). Attaches stability score (churn-weighted), last br…

Return the top-N highest-risk symbols ranked by hotspot score = cyclomatic_complexity x log(1 + commits_last_N_days). Identifies code that is both complex and frequently changed — the highest bug-introduction risk in the codebase. Methodology matches CodeScene/Adam Tornhill. Requires jcodemunch-mcp >= 1.16 for complexity data and a locally indexed repo for churn.

Show what breaks if a symbol is removed or renamed. Walks the call graph transitively to find every symbol that calls this one, returning affected symbols grouped by file with call-chain paths. Use this before deleting or renaming a symbol to understand full impact. For a structured caller/callee tree, use get_call_hierarchy instead. Walks the same name-matched call graph, so a caller reached only by dynamic dispatch or reflection is missing.

Check whether imports respect declared architectural layer boundaries. Reports every import that crosses a forbidden layer boundary. Layer rules can be passed directly or defined in .jcodemunch.jsonc under 'architecture.layers'. Use to enforce clean architecture and detect dependency-direction violations (e.g. API layer importing DB layer directly). Files that match no declared layer are skipped, so coverage depends on your layer rules.

Use when migrating or porting code from one tree or repo to another and you need to know what's already moved, what silently diverged, and what's still unported. Map migration/port parity between a SOURCE symbol tree and a TARGET tree (two subpaths of one repo, or two repos). For each source function/method/class it reports: ported (equivalent counterpart exists), ported_diverged (counterpart exists but its signature/body drifted — the failure a name-only check reports as done), unported (no counterpart), orphaned (unported and no migrated caller — a possible intentional drop), or added (targe…

Produce a unified risk assessment for all changes between two git refs (branch, PR, or SHA range). Fuses five signals — blast radius, complexity, churn, test gaps, and change volume — into a single composite risk_score (0.0–1.0) with actionable recommendations. Returns the top-5 riskiest changed symbols, untested symbols, and per-signal breakdowns. Designed for CI gating and code review workflows. risk_score is null, with unmeasurable_axes, when the blast axis could not be measured; a CI gate must treat null as a failure, not a pass. Requires a locally indexed repo (index_folder).

Auto-discover and parse non-code knowledge files (Dockerfiles, CI configs, docker-compose, K8s manifests, .env templates, Makefiles, package.json scripts) and cross-reference them to indexed code symbols. Returns structured intelligence grouped by category: infra, ci, config, deps, api, data. For categories already in the index (OpenAPI, Terraform, GraphQL, Protobuf, dbt), pulls from the index directly. Requires a local index (index_folder).

Assemble the best-fit context for a query within a token budget: ranks symbols by relevance and/or centrality, loads source for the top candidates, and packs greedily until the budget is exhausted. Exact symbol names in the query are pinned ahead of the ranking, so include identifiers verbatim. Use when you want the best N tokens of context for a task without naming exact symbols.

Per-pattern PII redaction counts from runtime_redaction_log. Operators run this to verify the redaction chokepoint is firing on production traffic — covers the OTel / SQL / stack ingest paths (file-based or HTTP live-ingest, Phase 6). Returns {patterns: [{source, pattern, count, last_redacted}], total_redactions, sources}. Empty patterns list = either no traffic yet, or JCODEMUNCH_RUNTIME_REDACT was disabled.

Find symbols related to a given symbol using heuristic clustering: same-file co-location (weight 3), shared importers (weight 1.5), and name-token overlap (weight 0.5/token). Useful for discovering what else to read when exploring an unfamiliar codebase.

Return a one-call triage snapshot of the entire repository: symbol counts, dead code %, average cyclomatic complexity, top 5 hotspots, dependency cycle count, and unstable module count. Designed to be the first tool called in any new session — one call gives a complete picture to guide follow-up analysis. The dead-code percentage is a heuristic estimate, and the hotspot ranking needs local git history.

Query-less, token-budgeted, signature-level overview of a repository. Groups symbols by file, ranks files by PageRank on the import graph, and greedy-packs signatures (not bodies) under token_budget. Designed for cold-start orientation — 'I just cloned this repo, what matters here?'. Pair with get_tectonic_map (module topology) and get_ranked_context (query-driven) once you know what to ask for.

Get a high-level overview of an indexed repository: directories, file counts, language breakdown, symbol counts. Lighter than get_file_tree. Directories only, not files.

Runtime coverage histogram for a repo or a single file: count of indexed symbols with vs without runtime evidence, plus the diagnostic list of unmapped runtime spans (likely reflective dispatch the AST missed). Pairs with Phase 2's per-result _runtime_confidence stamping. Returns coverage_pct=0 with sources=[] when no traces have been ingested.

Get the current session context — files accessed, searches performed, and edits registered during this MCP session. Use to avoid re-reading the same files. Truncated to max_files (default 50) and max_queries (default 20), and covers this server process only.

Get a compact session snapshot for context continuity. Returns a ~200 token markdown summary of files explored, edits made, searches performed, and dead ends. Designed for injection after context compaction to restore session orientation. Truncated to max_files (10), max_searches (5) and max_edits (10); it is a summary, not a full session log.

Get token savings stats for the current MCP session. Returns tokens saved and cost avoided (this session and all-time), per-tool breakdown, session duration, and cumulative totals. Use to see how much jCodeMunch has saved you. Savings are modelled estimates from the committed benchmark artifacts (cited in savings_provenance), not per-call measurements.

Discover how external signals (HTTP requests, CLI commands, scheduled tasks, events) propagate through the codebase via the call graph. Each signal chain traces a path from a gateway (entry point) through its callees to leaf symbols. Two modes: (1) Discovery — omit symbol to map all chains with orphan detection; (2) Lookup — pass a symbol name/ID to find which user-facing chains it participates in (e.g. 'validate_email sits on POST /api/users and cli:import-users'). Detects gateways from route decorators (Flask/FastAPI/Spring/NestJS/ASP.NET), CLI commands (@click, @app.command), task queues (@…

Return cyclomatic complexity, nesting depth, and parameter count for a single symbol. Complexity data is stored at index time (requires jcodemunch-mcp >= 1.16 / INDEX_VERSION 7). assessment field: 'low' (1-4), 'medium' (5-10), 'high' (11+). Re-index the repo if all metrics show 0 (pre-1.16 index).

Diff symbol sets between two indexed snapshots. Shows added, removed, and changed symbols. Branch workflow: index branch A as repo-main, index branch B as repo-feature, then diff. Compares by (name, kind), so a renamed symbol appears as one removal plus one addition, not a rename.

Return the most architecturally important symbols in a repo, ranked by PageRank or in-degree centrality on the import graph. Useful for orientation: surfaces the symbols that most of the codebase depends on. New tool: use after indexing to understand repo architecture at a glance. Ranks at most top_n symbols (default 20) over the import graph, so a symbol reached only dynamically scores zero.

Trace the complete authorship lineage and evolution narrative of a symbol through git history. Returns every commit that touched the symbol (or its file), classified into semantic categories (creation, bugfix, refactor, feature, perf, rename, revert, etc.) with extracted commit intent. Includes a human-readable narrative summarising who created it, why, how it evolved, and how volatile it is. Use before refactoring unfamiliar code to understand the 'why' behind it. Requires a locally indexed repo (index_folder).

Get full source of one symbol (symbol_id → flat object) or many (symbol_ids[] → {symbols, errors}). Supports verify, context_lines, fqn (PHP FQN via PSR-4), and an optional bounded mode that caps returned source for large symbols/batches.

Discover the logical module topology of a codebase by fusing three coupling signals: structural (import edges), behavioral (shared symbol references), and temporal (git co-churn). Returns tectonic plates (auto-detected file clusters), each with an anchor file, cohesion score, inter-plate coupling, and drifters (files whose directory doesn't match their logical module). Detects nexus plates (god-module risk: coupled to ≥4 other plates). No k parameter — plate count emerges from the topology. Use to find hidden module boundaries, misplaced files, and architectural drift. The temporal signal need…

Find functions and methods with no evidence of being exercised by any test file. Uses import-graph reachability + name matching (AST call_references when available, word-boundary text heuristic as fallback). Returns symbols classified as 'unreached' (no test file imports the source file) or 'imported_not_called' (test imports the module but no test references this specific function). This is heuristic reachability, NOT runtime coverage — it answers 'does any test reference this symbol?' rather than 'what % of lines are covered.' Use after get_repo_health for a deeper quality picture.

Report watch-all daemon coverage: every locally-indexed repo, each repo's staleness / reindex-in-progress state, and the OS-level service status. Call before relying on index freshness when you suspect files may have changed since the last index.

Ingest a runtime trace file into the runtime_* tables for the target repo. source='otel' takes OTel JSON / JSON-Lines / .gz and maps spans via (file_path, line_no, function_name); source='sql_log' takes pg_stat_statements CSV or a generic SQL JSON-Lines log and maps queries via referenced tables (file-stem match) and dbt/SQLMesh column metadata; source='stack_log' takes a plain-text application log or JSON-Lines record set with Python / JVM / Node.js tracebacks and writes to both runtime_calls (severity-agnostic rollup) and runtime_stack_events (per-severity counts: error/warn/info). Returns {…

Resolve and index an INSTALLED third-party dependency of an already-indexed local repo — the version actually in node_modules or the repo's virtualenv site-packages, read from package metadata (no registry lookup, fully local). Copies a filtered snapshot into the index store and indexes it as its own queryable repo (version visible in the repo id), then reports what docs the package ships. Use when the agent needs ground truth for a library API instead of guessing from training data.

Index a single file within an existing index. Surgical update after edits. The file must be under an already-indexed folder's source_root. Can also add new files.

Index a local folder of source code. Response surfaces `discovery_skip_counts` and `no_symbols_files` for diagnosing missing files. Skips .gitignore and extra_ignore_patterns matches.

Index a GitHub repository's source code. Fetches files, parses ASTs, extracts symbols, and saves to local storage. Set JCODEMUNCH_USE_AI_SUMMARIES=false to disable AI summaries globally. github.com URLs only.

Delete the index and cached files for a repository. Forces a full re-index on next index_repo or index_folder call.

Return the version-current CLAUDE.md / AGENT.md policy snippet for jcodemunch-mcp — the same text produced by `jcodemunch-mcp claude-md --generate`. Lets an agent keep a one-line CLAUDE.md (e.g. "Call jcodemunch_guide and strictly follow its instructions.") instead of pasting a static snippet that drifts from the installed version. Idempotent, no repo context required. Matches the active tool surface, tier and disabled_tools — list 'jcodemunch_guide' in disabled_tools to hide it.

Description is built at runtime.

Enumerate monorepo workspace members for an indexed repo. Detects pnpm (pnpm-workspace.yaml), yarn/npm (package.json workspaces), turborepo (turbo.json), lerna (lerna.json), rush (rush.json), Go (go.work), and Cargo ([workspace] members). Returns [{path, package_name, manager}, ...] plus an `is_monorepo` flag and the list of managers that contributed. Use the returned `path` values as the `scope_path` argument on get_project_intel to retrieve per-package intel (Dockerfile / CI / deps) instead of the repo-wide aggregate. Detects only the listed layouts; any other workspace arrangement returns i…

Discover catalog actions without keeping the full tool catalog resident: menu(query?). Returns compact rows (action, summary, required args, state_changing). With no query, lists the catalog. Pair with 'order' to dispatch the chosen action.

Dispatch any jcodemunch action by name: order(action, args). The single-verb front door to the full tool catalog. Read-only by default — actions that change index/session state require allow_state_change=true, and execution/file-write verbs are refused. For exploration questions ('how does X work'), order('get_ranked_context', {repo, query, token_budget}) answers in ONE call — prefer it over chained search/outline/source hops; add compress=true to fit more symbols in the same budget. Call 'menu' to discover actions, or 'route' to pick one from a task.

Generate edit-ready refactoring instructions for renaming, moving, extracting, or changing the signature of a symbol. Returns {old_text, new_text} blocks for every affected file — directly compatible with Edit tool. Handles import rewrites, collision detection, new file generation, and multi-file coordination. Use BEFORE executing any multi-file refactoring to get a complete edit plan in one call. Returns a plan only and never writes a file. Apply the returned blocks yourself, then re-index.

Plan the next turn by analyzing query against the codebase. Returns confidence level (high/medium/low), recommended symbols/files, and guidance. Use as opening move for any task. Recommends at most max_recommended symbols (default 5) and ranks only what the index holds.

Register file edits to invalidate caches. Call after editing files to clear BM25 cache and search result cache for the repo. Clears caches only. It does not re-index unless reindex=true, so search results stay stale until you do.

Render any graph-producing tool's output as rich, annotated Mermaid markup. Pass the raw output dict from get_call_hierarchy, get_signal_chains, get_tectonic_map, get_dependency_cycles, get_impact_preview, get_blast_radius, or get_dependency_graph. Auto-detects the source tool and picks the optimal diagram type: flowchart TD (call hierarchy, blast radius), flowchart BT (impact preview), flowchart LR (tectonic plates, dependency graph, cycles), or sequenceDiagram (signal chains). Encodes metadata as visual signals: edge colors for resolution confidence, node shapes for symbol kind, subgraph gro…

Resolve a filesystem path to its indexed repo identifier. O(1) lookup — faster than list_repos for finding a single repo. Accepts repo root, worktree, subdirectory, or file path. Pass an absolute path; a relative one resolves against the server's working directory.

Map a natural-language task to the best catalog action(s): route(task, repo?, execute?). Returns ranked recommendations with ready-to-run argument templates. With execute=true, dispatches the top recommendation and returns its result in the same call, collapsing discover-then-call into one round-trip. Recommends assemble_task_context / plan_turn for context-gathering intents.

Cross-language AST pattern matching. Finds structural code patterns across all 70+ indexed languages using a single query — no need to know language-specific AST node types. Two modes: (1) preset anti-patterns (empty_catch, bare_except, deeply_nested, nested_loops, god_function, eval_exec, hardcoded_secret, todo_fixme, magic_number, reassigned_param), or (2) custom mini-DSL (call:*.unwrap, string:/password/i, comment:/TODO/i, nesting:5+, loops:3+, lines:80+). Use category='all' to run every preset at once, or category='security'/'error_handling'/'complexity'/'performance'/'maintenance' for a f…

Search column metadata across indexed models. Works with any ecosystem provider that emits column data (dbt, SQLMesh, database catalogs, etc.). Returns model name, file path, column name, and description. Use instead of grep/search_text for column discovery — 77% fewer tokens. Covers only providers that emit column metadata into the index, and returns at most max_results (default 20).

Search for symbols matching a query across the entire indexed repository. Returns matches with signatures and summaries. Searches the index, not the working tree.

Full-text search across indexed file contents. Useful when symbol search misses (e.g., string literals, comments, config values). Supports regex (is_regex=true) and context lines around matches (context_lines=N, like grep -C). Searches the indexed copy, not the working tree.

Explicit tier override for the current session. Narrows or widens the exposed tool list to 'core' / 'standard' / 'full'. Prefer plan_turn(model=...) for routine per-task use; use set_tool_tier only for an explicit override (e.g. escalate to 'full' after a capability-gated failure). A narrowing that costs more than it saves is refused.

Mine the ranking telemetry ledger for retrieval regret (re-query churn, low confidence, thin/ambiguous results, stale-at-query, vocabulary gaps) and return a prioritized, explainable set of SUGGESTED corrections: CLAUDE.md routing/glossary lines (as unified-diff previews), index-freshness hints, stale-config findings, and a dry-run ranking-weight proposal. Read-only by charter — it never writes a user file; applying a patch is your keystroke. Requires perf_telemetry_enabled; returns an honest hint when off.

Suggest search queries, entry-point files, and index stats. Good first call on an unfamiliar repo — surfaces most-imported files, top keywords, and ready-to-run example queries. Suggestions come from index statistics rather than your task, so treat them as starting points.

Re-run AI summarization on all symbols in an existing index. Use this when index_folder completed but AI summaries are missing — e.g., the background summarization thread was interrupted, AI was disabled at index time, or the summarizer provider wasn't configured yet. With force=true (recommended), clears all existing summaries and re-runs the full 3-tier pipeline (docstring → AI → signature fallback). Requires a configured summarizer provider; without one the pipeline falls back to docstrings and signatures.

Diagnostic probe: send one request to the configured AI summarizer and report status, provider, timing, and any error detail. Call it to confirm summarization is wired up before indexing a large repo. It checks connectivity only; a healthy probe says nothing about summary quality. Disabled in the shipped default config, so enable it before calling.

Learn per-repo retrieval weights from the v1.78.0 ranking ledger. Computes confidence correlations for the semantic and identity-match channels and writes overrides to ~/.code-index/tuning.jsonc. search_symbols reads those overrides at query time when the caller doesn't pass an explicit semantic_weight. Learns from a recency window of the ledger (default 90 days) so stale events can't anchor the weights. Safe to re-run; idempotent for stable signal. Requires perf_telemetry_enabled and the ranking ledger it writes; without that history there is nothing to learn from.

Run a multi-axis constraint query against the index in a single round trip. Accepts an ordered list of criteria (AND) intersecting signals no other tool composes: kind, language, name (regex), file glob, cyclomatic complexity, decorator, direct call references, summary/docstring text, and git churn. Survivors are ranked by importance (PageRank, default), complexity, churn, or name. Use for questions like 'complex untested functions that call db.Exec' or 'deprecated methods still churning in the last 30 days' — cases that would otherwise require 4-5 separate calls and client-side merging.