Chisel

Test impact analysis and code intelligence built for AI coding agents. Zero external dependencies, open source, MIT licensed.

Chisel maps tests to code, code to git history, and answers: what to run, what's risky, and who touched it. It runs as an MCP server alongside your agent — Claude Code, Cursor, Windsurf, Cline, or any MCP-compatible client.

What it does

Chisel builds a graph connecting your code, tests, and git history, then answers three questions:

1. What to run

You change engine.py:store_document(). Instead of running all 287 tests or guessing with -k "test_store", Chisel tells the agent exactly which tests are impacted — through direct edges and transitive import-chain coupling.

2. What's risky

Risk scores per file based on churn rate, coupling breadth, test coverage gaps, author concentration, and test instability. A file that changes often, has one author, and no tests? That's your highest risk.

3. Who touched it

Blame-based ownership (who wrote it) and commit-activity-based reviewer suggestions (who maintains it). Useful when multiple agents or developers work on the same codebase and you need to understand lineage.

Related MCP server: SYKE

Why it exists

When multiple LLM agents (or agents + humans) work on the same codebase, changes in one area can silently break another.

Chisel gives AI coding assistants the intelligence to understand the blast radius of their changes before they commit. One agent's refactor doesn't silently regress another agent's work — automated code quality checks that work at the speed of your agent.

Install

Available on PyPI:

pip install chisel-test-impact

Or from source:

git clone https://github.com/IronAdamant/Chisel.git
cd Chisel
pip install -e .

Use with Claude Code (MCP)

Add to your Claude Code MCP config (~/.claude/settings.json or project .mcp.json):

{
  "mcpServers": {
    "chisel": {
      "command": "chisel-mcp",
      "env": {
        "CHISEL_PROJECT_DIR": "/path/to/your/project"
      }
    }
  }
}

Run analyze first to build the project graph, then diff_impact after edits to see which tests to run. For large repos, analyze with force=True automatically falls back to a background job so you don't hit MCP timeouts. Working-tree analysis (--working-tree) reuses a cached static import index and falls back to fast stem-matching for untracked files to stay within timeout budgets.

Monorepo sharding: Split large codebases across multiple SQLite databases with the CHISEL_SHARDS environment variable or .chisel/shards.toml. Query tools automatically aggregate across shards; writes route to the correct shard by file path.

After running tests, call record_result so Chisel can track failure rates and test instability over time. Or use chisel run -- pytest tests/ to run tests and record results automatically.

There is also an installable Claude Code skill with the distilled agent protocol: copy skills/SKILL.md to ~/.claude/skills/chisel/SKILL.md.

Use with Cursor, Windsurf, Cline, or other MCP clients

Chisel exposes a standard MCP interface. For stdio-based clients:

pip install chisel-test-impact[mcp]
chisel-mcp

For HTTP-based clients:

chisel serve --port 8377

Quickstart (CLI)

# Analyze a project (builds the graph)
chisel analyze .

# What tests are impacted by my current changes?
chisel diff-impact

# What tests should I run for this file?
chisel suggest-tests engine.py

# Risk heatmap (defaults: line-weighted coverage + proximity adjustment)
chisel risk-map
chisel risk-map --working-tree --auto-update
chisel risk-map --no-proximity --coverage-mode unit   # override defaults

# Find code with no test coverage, sorted by risk
chisel test-gaps --working-tree

# Who owns this code?
chisel ownership engine.py

# Run tests AND record pass/fail results in one step
chisel run -- pytest tests/

# Incremental update (near-instant when nothing changed)
chisel update

Try it on this repo

git clone https://github.com/IronAdamant/Chisel.git
cd Chisel
pip install -e .

chisel analyze .
chisel risk-map
chisel diff-impact
chisel test-gaps

MCP Tools

20 functional tools plus 6 advisory file-lock helpers for multi-agent coordination.

Features

• Zero dependencies — stdlib only, Python 3.11+, works anywhere

• Multi-language — Python, JavaScript/TypeScript, Go, Rust, C#, Java, Kotlin, C/C++, Swift, PHP, Ruby, Dart

• Framework-aware — pytest, Jest, Go test, Rust #[test], Playwright, xUnit/NUnit/MSTest, JUnit (incl. parameterized), XCTest + Swift Testing, PHPUnit, RSpec, Minitest, gtest, Dart test

• Incremental — only re-processes changed files, not the whole repo; a no-change update is near-instant

• gitignore-aware — ignored trees (vendored deps, build output, fixtures) are never scanned; untracked files still are (CHISEL_INCLUDE_IGNORED=1 to override)

• Branch-aware — diff_impact auto-detects feature branch vs main

• Multi-agent safe — cross-process locks so parallel agents don't corrupt the graph

• MCP + CLI — stdio and HTTP MCP servers, plus a full CLI with 28 subcommands

• CI-friendly — real exit codes (chisel analyze && pytest just works); copy-paste GitHub Actions example in examples/github-actions/

• Monorepo sharding — split analysis across per-directory SQLite databases (CHISEL_SHARDS)

• Custom extractors — plug in tree-sitter or LSP via register_extractor() if you need it

Ecosystem

Chisel sits in the agent loop: impact -> tests -> record results -> refresh analysis. It works standalone or alongside Stele for semantic code context.

Docs: Agent playbook | Claude Code skill | Zero-dependency policy | Custom extractors

License

MIT