Chisel
Provides a GitHub Actions example for CI integration, enabling automated test impact analysis and code intelligence in CI pipelines.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Chisel
Test impact analysis and code intelligence for AI coding agents. One std-only Rust binary, no crates, MIT licensed.
After an edit, an agent asks Chisel which tests to run, which files are risky, and who knows this code. Chisel answers from a graph of your code, your tests, and your git history, over MCP (Claude Code, Cursor, Windsurf, Cline) or a JSON CLI.

Install
Download a binary for Linux (musl), macOS (arm64, x64), or Windows from Releases, check it against SHA256SUMS, put it on your PATH as chisel, and make sure git is installed. Or build it:
git clone https://github.com/IronAdamant/Chisel.git
cd Chisel
cargo build --release # binary: target/release/chiselOn Windows without the MSVC Build Tools, build with the GNU toolchain: cargo +stable-x86_64-pc-windows-gnu build --release, adding RUSTFLAGS="-C link-self-contained=yes" if your MinGW is llvm-mingw.
Related MCP server: codemap
Use with Claude Code (MCP)
Add to .mcp.json in your project (or ~/.claude.json):
{
"mcpServers": {
"chisel": {
"command": "chisel",
"args": ["serve-mcp"],
"env": { "CHISEL_PROJECT_DIR": "/path/to/your/project" }
}
}
}The snapshot goes to <project>/.chisel/store unless CHISEL_STORAGE_DIR says otherwise. Any stdio MCP client works the same way. chisel serve --port 8377 is a separate JSON HTTP API (GET /health, GET /tools, POST /call), not an MCP URL.
The agent loop: call analyze once, diff_impact after each edit to pick which tests to run (grep finds names; Chisel knows which tests call the code you changed, and their callers), run those tests, then record_result. Work in a git worktree? Pass worktree_root (CLI --worktree), or start the server inside the worktree: Chisel answers for that tree from the main checkout's snapshot. Committed work: since: "main". When something needs doing, the response has a status (no_data: call analyze; stale_db: call update), and most responses suggest next_steps. The full calling contract is in AGENTS.md. A ready-made Claude Code skill is in skills/SKILL.md.
CLI in 30 seconds
chisel analyze . # build the graph (once; `update` after that)
chisel diff-impact --json # tests touched by your changes (on a branch: since the merge-base with main)
chisel diff-impact --since main # every change since main, committed or not
chisel diff-impact --worktree /path/to/wt # the same, for another git worktree, from this checkout's snapshot
chisel suggest-tests src/engine/analyze.rs # ranked tests for one file
chisel triage # top risky files, untested code, stale tests
chisel run -- pytest tests/ # run tests and record pass/failchisel --help lists every command and chisel <command> --help shows its flags. With --json, branch on status: error and git_error exit 1, a usage error (unknown command or flag) exits 2, everything else exits 0.
MCP tools
Tool | Answers |
| Build or incrementally refresh the snapshot. |
| Which tests should I run after this edit? Tests you changed first, then tests that call the changed functions and tests of their callers, ranked by how much of the change they reach. Guard tests and always-run rules come per test file in |
| Which tests cover these files, ranked? |
| Where is risk: churn, coupling, coverage gaps, one-author code, flaky tests? |
| How often does this change, and what changes with it? |
| Who wrote it, and who maintains it now? |
| Which tests point at code that no longer exists? |
| Feed results back (with a failure's message and the OS), read counts and which tests have not passed since a commit or never ran on an OS, compact the snapshot. |
| Which tests are failing, what probably broke them, and what fixed them before. |
| Advisory locks with a |
Tool groups
Every MCP tool belongs to one group. When Chisel runs next to other tools that already cover a feature, switch that group off so its schemas stop taking context. CHISEL_TOOLS lists what to keep (groups or tool names, all allowed); CHISEL_DISABLE lists what to hide and is applied after it. core is always on. Empty values count as unset; with neither set, nothing changes. The CLI is not affected.
Group | Tools | Overlaps with |
|
| none |
|
| none |
|
| other suite tools' git history lookups |
|
| none |
|
| Trammel step claims, CoordinationHub leases |
|
| none |
"env": {"CHISEL_DISABLE": "locks,history"}An unknown name, or core (or a core tool) in CHISEL_DISABLE, stops the server with exit code 2 and a one-line message listing the valid groups and tools. Calling a hidden tool returns an error that says which variable to change.
Choosing groups (for agents)
Write the choice into the project's root AGENTS.md; Chisel re-reads it on each request and tells the client when its tool list changes:
```agent-tools
chisel: disable locks, history
```Turn off locks when one agent works on the project or CoordinationHub/Trammel manages claims, history when you read git history yourself, risk when you only need which tests to run, maintenance when analyze is quick, and issues when no test-capture hook runs in the project. Bad names become warnings in the initialize instructions, never errors. Env vars override the file key by key. See AGENTS.md.
Tests to always run
Some tests no call graph reaches: a guard that reads every file under src/ and asserts on the text, a tool dispatched by its name. Name them in the same block, and diff_impact lists them in guards (source: always_run, one entry per test file) whenever a changed file matches:
```agent-tools
chisel: always-run crates/app/src/**, scripts/*.py -> crates/app/tests/disk_guard.rs, crates/app/tests/tools.rs:catalog_lists_every_tool
```Paths take * (one folder) and ** (any depth). Tests are a test file (all its tests), a test id (path:name) or a test name. Chisel also finds guards that build a folder from env!("CARGO_MANIFEST_DIR") or read a file with include_str!, and lists them in guards as reads_source when that folder changes. A detected scope is dropped when it is the project root or a folder holding two or more Cargo packages (crates/**); a crate's own folders (crates/a/src/**) are kept. A test that reads wider needs a rule. A guard file whose tests are all named runs as cargo test -p <package> --test <name>.
Issues and traceability
Chisel logs test failures as issues with no model tokens spent. A Claude Code PostToolUse hook pipes every test run the agent makes (cargo test, pytest, Jest, Vitest, go test, node:test) into chisel capture, which parses failing tests, records each result, and keeps one issue per distinct failure:
Dedupe: test id plus the error with numbers, paths, addresses and times stripped. Repeats raise a count.
Suspects: the code the failing test covers (its test edges) that changed since the test last passed, ranked by the size of the change, uncommitted edits, recency and churn, each with a one-line reason.
Auto-close: when the test passes again the issue closes with the fixing commit (or
uncommitted) and the files changed since it failed. The same failure later reopens it.
The hook prints nothing on success and one line for a new, reopened or fixed issue; it always exits 0 and does nothing in a project without a snapshot (run chisel analyze once). chisel hook-install prints the hooks and chisel hook-install --write merges them into .claude/settings.local.json:
{"hooks": {
"PostToolUse": [{"matcher": "Bash", "hooks": [{"type": "command", "command": "chisel capture --hook"}]}],
"SessionStart": [{"hooks": [{"type": "command", "command": "chisel issues --brief"}]}]
}}The SessionStart line prints at most two lines, and only when issues are open. Agents read issues through the issues group: issues (compact rows, about 150 bytes each), issue (suspects, occurrences, excerpt, fix) and trace (what broke in a file or function and what fixed it). Without hooks, chisel run -- <test command> runs the tests and captures them the same way.
How it works
Scan.
git ls-fileslists code. A built-in extractor (no tree-sitter) finds functions, classes, and tests in Python, JS/TS, Go, Rust, Java, Kotlin, C#, C/C++, Swift, PHP, Ruby, and Dart, and recognises pytest, Jest, Playwright, Go test, Rust#[test], JUnit, xUnit, XCTest, PHPUnit, RSpec, gtest, and Dart test.Link. Each test's imports and calls become edges to the code units they reach; in a Cargo workspace only units in crates the test's crate depends on. Rust calls resolve by type and path, not by name:
GlyphAtlas::new,self.atlas.clear()andlet a = Atlas::new(); a.glyph()reach that type's methods,Default::default()and std methods on unknown values reach nothing, and a rare name matched only by name weighs half. A closure or parameter the test binds itself is not a call, andstd::fs::writeis not the project'swrite. Imports between code files form a second graph thatdiff_impactwalks for indirect hits, and it follows callers of the changed functions one or two calls up (depth, default 2).Mine git. One
git log --numstatand onegit log -pstream give churn, co-change coupling, per-function history and authorship. Chisel replays git's own-Land blame rules over the stream instead of starting git once per function and per file.Store. Everything lands in one JSON snapshot,
.chisel/store, written atomically under a cross-process lock.updatere-reads only changed files and new commits.Answer. Queries read the snapshot, so most calls return in milliseconds;
diff_impactalso asks git what changed. Each hunk names the function or test whose lines it touches. A test reaching three changed functions ranks above one reaching a helper hundreds of tests call; pastlimitthe rest is summarised per package with a command each.Worktrees. With
worktree_root, a copy of the snapshot under.chisel/overlays/is brought in line with that worktree (only files whose content differs are re-indexed) and answers for it; main's snapshot is never written. The reply addsworktreeandoverlay_files.
Scores are heuristics. Read _meta.uniform_components before trusting a composite risk score.
More
AGENTS.md: statuses, environment variables, sharding, scale limits
docs/AGENT_PLAYBOOK.md and docs/LLM_CONTRACT.md: how an agent should call Chisel
docs/CUSTOM_EXTRACTORS.md: plug in your own extractor executable
docs/ZERO_DEPS.md: why there are no crates
ARCHITECTURE.md: module map
chisel migrate path/to/chisel.dbcopies recorded results from a Python-era SQLite database into the snapshot.
Benchmarks
Timed on this machine: Linux 6.12.94+, 4 vCPUs, Intel Xeon, 15.6 GiB RAM, Rust 1.97.0, Python 3.12.3. Five runs per command. The figure is the median in milliseconds, with the minimum and maximum in parentheses. The small repo is a two-file Python sample. The large repo is the django package from django/django (about 1000 code files) plus 80 of its test modules, with history split into commits of at most 100 paths so a shallow-clone boundary commit does not pair every file with every other file. Peak RSS and the raw log are in scripts/benchmark_results.md. Reproduce with cargo run --release --example benchmark_parity (arguments at the top of examples/benchmark_parity.rs).
Command | Python small | Rust small | Python large | Rust large |
startup ( | 64.6 (63.4–73.4) | 0.3 (0.3–0.5) | 71.6 (64.7–76.1) | 0.4 (0.2–0.5) |
cold analyse | 88.5 (86.7–93.9) | 8.0 (7.7–10.8) | 13692.5 (13542.5–14014.5) | 8034.2 (7627.3–8398.0) |
warm analyse | 82.8 (80.7–89.8) | 2.3 (2.2–2.5) | 8646.5 (8604.2–8754.3) | 63.0 (61.3–77.9) |
warm update | 71.0 (67.9–74.6) | 2.6 (2.2–2.6) | 146.4 (139.1–163.6) | 68.8 (65.3–71.2) |
impact | 63.6 (63.0–66.2) | 0.6 (0.6–0.7) | 111.9 (106.5–113.3) | 45.4 (44.6–48.2) |
suggest-tests | 64.3 (63.7–68.1) | 0.6 (0.6–0.7) | 125.9 (121.5–131.0) | 46.0 (44.6–51.9) |
risk-map | 67.8 (65.9–75.4) | 0.7 (0.6–0.9) | 253.6 (233.9–261.0) | 57.5 (55.8–64.0) |
test-gaps | 64.9 (63.2–69.7) | 0.6 (0.5–0.6) | 163.4 (161.9–180.5) | 73.1 (65.0–76.5) |
triage | 65.8 (64.0–67.1) | 0.7 (0.6–0.8) | 254.4 (239.9–262.7) | 94.9 (93.3–97.5) |
churn | 64.2 (62.9–66.6) | 0.6 (0.6–0.7) | 65.2 (64.4–69.0) | 48.8 (46.0–51.4) |
coupling | 64.3 (63.3–65.5) | 0.6 (0.6–0.7) | 64.1 (63.3–66.1) | 47.7 (41.8–53.4) |
stats | 64.8 (63.8–66.3) | 0.6 (0.5–0.6) | 67.4 (66.5–68.6) | 46.0 (45.0–51.0) |
On that large tree both snapshots have 829 test units, and the small sample has 1 on both sides. Rust is faster on every command in both trees.
License
MIT
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
Hosted code graph over MCP: exact callers, dependencies, and cross-repo blast radius for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAI code impact analysis MCP server that monitors file changes, maps dependency graphs, detects cascading breakage, and gates builds before damage spreads.80 npm2Elastic 2.0
- AlicenseNot gradedqualityBmaintenanceMCP server for local-first code intelligence, providing structural code graph, semantic search, and impact analysis to AI agents.2MIT
- AlicenseAqualityDmaintenanceMCP server that analyzes TypeScript/JavaScript codebases via AST parsing and dependency graph tracing to identify affected tests, detect dead code, circular dependencies, and trace import chains, enabling AI agents to run only relevant tests.1554 npmMIT
- AlicenseNot gradedqualityDmaintenanceMCP server that builds a dependency graph of your codebase, giving AI agents structural understanding to analyze impact, find context, and make safe modifications across languages and infrastructure.MIT