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, 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/chisel

On 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.

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/fail

chisel --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
analyze, update	Build or incrementally refresh the snapshot. start_job, job_status, cancel_job run them in the background.
diff_impact	Which tests should I run after this edit? Ranked: tests that call the changed functions, then tests of their callers. since covers committed work.
impact, suggest_tests	Which tests cover these files, ranked?
triage, risk_map, test_gaps	Where is risk: churn, coupling, coverage gaps, one-author code, flaky tests?
churn, coupling, history	How often does this change, and what changes with it?
ownership, who_reviews	Who wrote it, and who maintains it now?
stale_tests	Which tests point at code that no longer exists?
record_result, stats, optimize_storage	Feed results back, read counts, compact the snapshot.
issues, issue, trace	Which tests are failing, what probably broke them, and what fixed them before.
acquire_file_lock and five more lock tools	Advisory locks with a purpose note so parallel agents see who is editing what.

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
core (always on)	analyze, update, diff_impact, impact, suggest_tests, record_result, stats	none
risk	risk_map, test_gaps, triage, stale_tests	none
history	churn, ownership, coupling, history, who_reviews	other suite tools' git history lookups
maintenance	start_job, job_status, cancel_job, optimize_storage	none
locks	acquire_file_lock, release_file_lock, refresh_file_lock, check_file_lock, check_locks, list_file_locks	Trammel step claims, CoordinationHub leases
issues	issues, issue, trace	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
```

This is the beginning of the README. Read the rest at the original. Read the full README ↗