Karzone/TestAtlas

A queryable, semantic map of your .NET test-automation solution — in one SQLite file, served to your AI agent over MCP.
Zero config  ·  No AI  ·  No network  ·  Deterministic
11 MCP tools
resolve_step · step_catalog · impact · search_steps · search_scenarios · get_scenario · get_step_definition · list_tags · list_endpoints · project_dependencies · stats
The problem ·
See it in action ·
Quick start ·
MCP ·
Commands ·
Fresh maps ·
Roadmap
---
The problem
Large test-automation solutions are hard to navigate — for humans *and* for AI agents. Asked to
automate a new story, an agent can't see which steps already exist, where similar code lives, or
what conventions the solution follows — so it duplicates steps and misplaces code. TestAtlas
indexes the solution once into a single SQLite map and answers those questions precisely:
deterministically, offline, without a model or a network call.
---
See it in action
Index the bundled 8-project sample once — testatlas index samples/SampleShop/SampleShop.sln — then
ask it questions from the terminal. Every number below is real output from that run:
…or let your agent ask them over MCP. Here an agent checks whether a step it is about to write
already exists — resolve_step answers with the definitions that would bind it, or the closest
near-misses to reuse instead:
Live sample outputs, committed from that same solution:
**HTML report** (features, scenarios, bindings, class kinds, endpoints) ·
**dependency map** (the eight projects in layers — click one to see what it uses, what uses it, and which tests a change can reach).
(GitHub serves .html as source, so the links route through htmlpreview.github.io — or download from docs/ and open locally.)
What you get
TestAtlas statically analyses the solution and emits codemap.db — projects and their dependency
edges, Gherkin features/scenarios/steps, step definitions and their bindings (bound / unbound /
ambiguous), page objects, API clients, helpers, test classes, and the call/usage edges connecting
them — then turns that map into answers:
| | Capability | What you get |
|:--:|---|---|
| 🧩 | **Reuse-first authoring** | resolve_step — would this phrase bind an existing definition? step_catalog — the reusable step vocabulary with placeholders + allowed values |
| 💥 | **Impact** | Blast radius — the scenarios affected by changing a class, method, step, or endpoint |
| 🔍 | **Search** | FTS5 over step definitions + scenarios — *"does a step for this already exist?"* |
| 🔌 | **MCP** | All of it served to an AI agent over stdio — precise answers in a few hundred tokens, no context stuffing |
| 📊 | **Report & map** | Self-contained HTML drill-down of the whole map + a layered, searchable project-dependency graph |
| 📈 | **Stats** | Entity counts, class-kind breakdown, binding coverage, diagnostics |
All of it **offline, deterministic, and reproducible** — same input, same map, every time.
---
🚀 Quick start
> **Requires** the .NET SDK 8.0+. On a corporate machine
> where dotnet tool install fails with **401**, see
> docs/troubleshooting.md.
**1 — Install** the CLI (and the MCP server, if you'll connect an agent):
**2 — Index** your solution. This produces the map (./codemap.db) that every query, report, and
MCP answer reads — nothing works without it:
No need to build or restore the solution first — indexing is a syntax-only pass, so an unrestored
checkout maps fine. Point index at a folder (or nothing) and it auto-discovers a single
.sln/.csproj there.
**3 — Query it:**
…and to serve it to your AI agent, continue to MCP setup.
Or run from source (no install)
---
🔌 Use it from an AI agent (MCP)
TestAtlas ships an MCP server — testatlas-mcp — that serves the map to any MCP-aware client
(Visual Studio / VS Code Copilot, Claude Code, and others) over stdio JSON-RPC. The agent asks a
precise question and gets an exact, structured answer straight from the .db — instead of