Skip to main content
Glama
Repo Test Architect

Repo Test Architect

Repo Test Architect MCP server

Audit-first test strategy tooling for codebases.

Repo Test Architect builds a deterministic audit graph before asking any model or agent to reason about tests. The goal is to identify repo-native, high-value test work from facts the tool can inspect locally: project roots, framework signals, existing tests, source classifications, blockers, and remaining risk.

The current implementation can:

  • audit JavaScript/TypeScript, PHP, Python, Ruby, and Swift projects through supported adapters

  • audit supported, bounded Kotlin/JVM fixtures through the same shared artifact model

  • audit conventional Go modules and literal repository-contained go.work members through a supported bounded adapter

  • audit conventional Cargo packages and literal repository-contained workspace members through a supported bounded Rust adapter

  • audit one conventional SDK-style C# test project or one unique literal production/test project edge, including bounded native xUnit MTP-v2 and MSTest.Sdk v4 ownership, literal and one-hop root-aliased target frameworks, one repository-contained direct *.cs compile include, finite target-conditioned package shapes, bounded nearest-file build and central-package props, exact immutable test-field receivers, stable direct-call results, inline out results, framework exception and collection/string assertions, one-hop test helpers, and guarded well-known System type collisions, through a supported bounded .NET adapter

  • audit one conventional Composer/PSR-4 project with PHPUnit through a supported bounded PHP adapter

  • audit one conventional Mix application with exact MixProject/Mixfile, bounded source and Mix-task ownership, literal local ExUnit wrapper discovery, and test-body evidence through a supported bounded Elixir adapter

  • detect polyglot project roots and report unsupported ecosystems without hiding them

  • produce a complete repository analysis, findings, ranking, plan, execution hints, and verification commands in one audit pass

  • classify source files by likely test value and defer low-value direct tests

  • rank candidates and generate test plans from the audit graph

  • derive provider-neutral execution, context, parallel-safety, and repository-reasoning hints without selecting models or spawning subagents

  • analyze conservative test placement findings across project boundaries

  • collect project-level stats for coverage, candidate counts, frameworks, commands, and adapter usage

  • provide disabled-by-default local MCP diagnostics, safe internal-error report IDs, runtime checks, and inspectable sanitized bundles without external reporting

  • expose the same deterministic behavior through CLI commands, a local invoke harness, and a stdio MCP SDK server

  • lock behavior with golden snapshots, model-consistency scenarios, package checks, and cross-OS CI

Native test generation is intentionally deferred. generate_selected_test returns a structured deferred artifact until adapter-specific generation policy and repair-loop fixtures exist.

Repo Test Architect 1.3.0 is available on npm as latest and in the Official MCP Registry, with stable support for the documented CLI, MCP tools, configuration and versioned artifact contracts. Treat its findings as evidence-backed review input rather than an automatic instruction to change a repository. See the 1.3.0 release notes for the Swift and Kotlin/JVM fixes from the first product-monorepo runs, and the 1.2.0 release notes for the bounded review_repository entrypoint, repoRoot inputs on specialist tools, the MCP result size budget, compatibility notes and publication status, and the 1.0.0 release notes for the stable contract.

Ten adapters are supported within their documented boundaries. Dart/Flutter remains experimental, and native test generation remains deferred.

Maintenance is provided as time permits, with no guaranteed response time or feature schedule. Focused community PRs are welcome; see Contributing and Support.

Install

Node.js 20 or newer is required.

Run the CLI without a global install:

npx --yes repo-test-architect doctor
npx --yes repo-test-architect analyze .

Pin the stable version:

npx --yes repo-test-architect@1.3.0 doctor
npx --yes repo-test-architect@1.3.0 analyze .

Or install the CLI and MCP server binaries:

npm install --global repo-test-architect
repo-test-architect doctor
repo-test-architect analyze .

Add the local stdio MCP server to an MCP-capable client:

{
  "mcpServers": {
    "repo-test-architect": {
      "command": "npx",
      "args": [
        "--yes",
        "repo-test-architect",
        "mcp"
      ]
    }
  }
}

To keep an MCP client on this exact release, pin its version:

{
  "mcpServers": {
    "repo-test-architect": {
      "command": "npx",
      "args": [
        "--yes",
        "repo-test-architect@1.3.0",
        "mcp"
      ]
    }
  }
}

The client launches the server locally. Repository source stays on the machine unless the client or another configured tool sends it elsewhere. Connected models receive instructions to start with review_repository, a bounded review that stays small on large monorepos, and to use analyze_repository only when the complete evidence bundle is needed. See MCP client config and agent install paths for global-install, local-checkout, and host-specific guidance.

Related MCP server: graphward

Quick Start

For a human-readable review of the current repository:

npx --yes repo-test-architect analyze .

analyze detects every project root, runs each supported adapter once, and derives the audit summary, top findings, candidate ranking, test plan, execution hints, project stats, and verification commands. Markdown stays compact; JSON preserves the complete evidence bundle:

npx --yes repo-test-architect analyze . --format json
npx --yes repo-test-architect analyze . --changed

review returns the same review bounded for agents and saved context: every blocker, the top findings, and the top-ranked candidates and plan items with execution hints, with per-test evidence reduced to counts. --limit (default 25) caps the ranked lists:

npx --yes repo-test-architect review . --format json --limit 50

Useful focused views:

Goal

Command

Complete repository review

repo-test-architect analyze .

Bounded review for agents

repo-test-architect review . --format json

Concise architecture findings

repo-test-architect findings-projects .

Actionable cross-project plan

repo-test-architect plan-projects .

Raw reusable project audits

repo-test-architect audit-projects . --format json

Runtime readiness

repo-test-architect doctor

Run repo-test-architect --help for the short command map or repo-test-architect <command> --help for options. The CLI reference documents the full surface.

For an MCP-connected model, the default is review_repository, which returns the bounded repository-review/v1 artifact; analyze_repository returns the complete bundle and can exceed client limits on large repositories. Specialist tools accept repoRoot (plus projectRoot for single-project tools) instead of a saved artifact, so explain_target can follow a review without echoing the audit back.

Current Scope

Available adapters:

  • dart (experimental): Dart and Flutter pubspec packages, conventional package:test and flutter_test entrypoints, exact library-import evidence, widget test recommendations, and bounded dart test / flutter test commands; see Dart and Flutter support

  • csharp: one static SDK-style test project or one unique literal production/test project edge, including bounded native xUnit MTP-v2 and MSTest.Sdk v4 ownership, exact literal or one-hop root-aliased target membership, one repository-contained direct *.cs compile include, finite project-local target-conditioned package predicates, and a pair selected amid unrelated projects, with bounded nearest-file Directory.Build.props metadata and static Directory.Packages.props versions, xUnit, NUnit, or MSTest attributed tests, exact project-file commands, runnable-body-owned direct type calls, bounded concrete-local or immutable test-field receivers, one-hop stable direct-call, receiver-call, or inline out var result assertions, bounded exception assertions, and one same-class private-static test-helper hop; see the C# alpha support matrix

  • elixir: one conventional Mix application with literal app and exact MixProject/Mixfile ownership, conventional/app-prefixed modules and protocols, exact Mix tasks, bounded acronym, terminal-plural, repeated-declaration, and compiled local ExUnit-wrapper ownership, static startup options, test-body-scoped direct fully qualified or exact-alias calls, conservative filename evidence, and a blocker-free mix test command; see Elixir alpha support

  • javascript: JavaScript/TypeScript repositories with Node's test runner (including TypeScript execution scripts), Bun test, AVA, Mocha/CommonJS, Vitest, Jest, Playwright, Cypress, Express/Supertest, React Testing Library detection, and bounded literal browser request-to-route evidence; see the alpha support matrix for evidence boundaries and known gaps

  • go: conventional go.mod projects and literal repository-contained go.work members using runnable standard-library TestXxx, FuzzXxx, or ExampleXxx tests, package-local filename, unique top-level and parser-owned concrete receiver-method symbols through explicit types, exact simple constructor results, or exact statically typed test-helper results, bounded standard-library and Testify assertion usage, parser-scoped local shadow checks, same-package or exact external-package imports (including dot imports), generic top-level functions, and bounded callable-body-owned same-package or module-local source hops, module-local commands, and optional explicit GOOS/GOARCH/custom-tag selection; see the alpha support matrix for the supported boundary and blockers

  • kotlin: conventional Gradle/Maven JVM module roots, settings-owned Gradle aggregates, and root-declared Maven reactors with Kotlin and/or Java standard source sets, dependency-qualified direct/exported-transitive module evidence, JUnit 4/5, kotlin.test, bounded Gradle/JUnit Platform Kotest common specs, conventional Gradle/Spock features, and method-level TestNG through direct Maven dependencies or Gradle useTestNG(); see the Kotlin/JVM alpha support matrix

  • php: one root Composer project with literal string-valued PSR-4 source/test ownership, bounded literal autoloaded function files, statically declared PHPUnit, exact bounded commands or explicit safe command withholding, conventional runnable test classes including one unique source- or test-owned PHPUnit base edge, direct imported or exact same-namespace class calls, and conservative basename fallback; see PHP alpha support

  • python: bounded Python package, FastAPI, Django, and Flask layouts with declarative multi-package/namespace ownership, configured pytest discovery, exact absolute/relative imports, one-hop source dependency evidence, static framework test-client route evidence, pytest/unittest, async and property-based extensions, fixture reachability, pip/setuptools, uv, Poetry, Hatch, tox, nox, and coverage configuration; see the Python alpha support matrix

  • rust: conventional Cargo packages and literal repository-contained workspace members using the built-in #[test] harness, inline #[cfg(test)] modules, exact exclusion of external test-only module graphs, exact crate-module imports from tests/, and exact unconditional crate-root symbol re-exports; see the Rust alpha support matrix

  • ruby: one conventional Bundler project with lib/ sources, one root gemspec or a complete exact named root-gemspec set, runnable Minitest::Test test_* methods or RSpec examples, exact bounded commands, root .rspec and exact per-file spec_helper loading, three-edge literal require/unique-constant evidence, exact singleton calls, exact constant-owned RSpec described_class, direct immutable constructor-local, one-line RSpec let/subject, exact source-factory and same-group RSpec helper receivers, and exact same-file literal shared-example inclusion, bounded assertion usage, conservative basename fallback, and explicit Minitest-spec/Rails/mixed-runner blockers; see the Ruby alpha support matrix

  • swift: Swift Package Manager, Xcode-style and Bazel/rules_swift layouts, Swift Testing, XCTest, Quick/Nimble, SnapshotTesting, VaporTesting/XCTVapor, reactive frameworks, and generic Fluent database boundaries with driver-specific qualifiers; see the Swift alpha support matrix

Project detection reports Elixir Mix roots through the supported bounded adapter. Unsupported ecosystems remain visible so clients can distinguish "not audited yet" from "not present."

Don't see your stack? Open an adapter request with the language or ecosystem, build system, test frameworks, and—when possible—a representative public repository. Requests help prioritize adapters against real repository shapes and user demand.

The public package exposes the audit CLI, the stdio MCP server, and a deterministic MCP invoke harness under the stable binary names documented below.

Advanced CLI and Contributor Reference

The commands below expose focused artifacts, fixtures, evals, diagnostics, and release checks for advanced use and repository development.

Run the complete analysis directly or against the polyglot example:

npm run analyze
npm run analyze:json
npm run analyze:example
npm run analyze:example:json
npm run review
npm run review:json
npm run review:example
npm run review:example:json

Check runtime and diagnostics readiness:

npm run doctor
npm run doctor:json

Local MCP diagnostics are disabled by default. They can be explicitly directed to stderr or a bounded local JSONL file; see Local diagnostics. Build a sanitized, inspectable bundle with:

npm run diagnostic-bundle -- --diagnostics-file ./.repo-test-architect/diagnostics.jsonl --format json
node ./src/cli/index.js diagnostic-bundle --diagnostics-file ./.repo-test-architect/diagnostics.jsonl --format json

List registered adapters:

npm run adapters
npm run adapters:json

Inspect project detection marker rules:

npm run detect-rules
npm run detect-rules:json

Detect project roots and adapter matches:

npm run detect:example
npm run detect:example:json
npm run detect:kotlin-fixture
npm run detect:kotlin-fixture:json
npm run detect:apple-fixture
npm run detect:apple-fixture:json
npm run audit-projects:example
npm run audit-projects:example:json
npm run audit-projects:changed-since
npm run summarize-projects:example
npm run summarize-projects:example:json
npm run rank-projects:example
npm run rank-projects:example:json
npm run plan-projects:example
npm run plan-projects:example:json
npm run hints-projects:example
npm run hints-projects:example:json
npm run findings-projects:example
npm run findings-projects:example:json
npm run placement-projects:example
npm run placement-projects:example:json
npm run placement-projects:split-example:json
npm run stats-projects:example
npm run stats-projects:example:json

For project-aware self-audits, exclude checked-in fixture or sample roots with a quoted subtree pattern:

node ./src/cli/index.js findings-projects . --exclude-project "examples/**"

Reuse a saved project audit artifact:

node ./src/cli/index.js audit-projects ./examples/polyglot-workspace --format json
node ./src/cli/index.js summarize-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js rank-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js plan-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js findings-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js placement-projects --from-project-audits ./project-audits.json --format json
node ./src/cli/index.js stats-projects --from-project-audits ./project-audits.json --format json
npm run audit:example
npm run audit:kotlin-fixture

Output the structured audit graph:

npm run audit:example:json
npm run audit:kotlin-fixture:json

Generate an actionable test plan from the audit graph:

npm run plan:example
npm run plan:example:json
npm run hints:example
npm run hints:example:json
npm run plan:kotlin-fixture
npm run plan:kotlin-fixture:json
npm run plan:item:example
npm run plan:changed
npm run plan:changed-since

Derive advisory execution hints while leaving the plan artifact unchanged:

node ./src/cli/index.js hints ./examples/node-vitest-basic --item add-test:src/authService.ts
node ./src/cli/index.js hints-projects ./examples/polyglot-workspace --format json

The installing CLI or agent host remains responsible for model choice, budgets, permissions, context loading, and subagent lifecycle.

Explain one audited target by stable target ID:

npm run explain:example

Rank test candidates without generating tests:

npm run rank:example

Analyze existing test placement from audit evidence:

npm run placement:example
npm run placement:example:json
npm run placement:from-audit:example

Exercise the MCP-style tool surface:

npm run mcp:tools
npm run mcp:review:example
npm run mcp:analyze:example
npm run mcp:adapters
npm run mcp:detect-rules
npm run mcp:detect:example
npm run mcp:audit-projects:example
npm run mcp:summarize-projects:example
npm run mcp:rank-projects:example
npm run mcp:plan-projects:example
npm run mcp:findings-projects:example
npm run mcp:placement-projects:example
npm run mcp:placement-split:example
npm run mcp:stats-projects:example
npm run mcp:audit:example
npm run mcp:audit:kotlin-fixture
npm run mcp:placement:example
npm run mcp:audit:envelope
npm run mcp:stdio
npm run mcp:smoke

Generate a plan from an existing audit JSON file:

npm run plan:from-audit:example

Run the auditor regression tests:

npm test
npm run alpha:check
npm run release:check

Find and rank active public repositories for real-world adapter validation:

npm run validation:repos -- --profile react
npm run validation:repos -- --profile workspace --limit 10
npm run validation:repos -- --profile swift,gradle,maven --format json

The finder uses authenticated GitHub repository search, verifies exact ecosystem markers in root manifests, and ranks candidates using maintenance recency, stars, repository size, lockfiles, CI, and license metadata. Run npm run validation:repos -- --list-profiles for the available profiles and --help for quality-filter options.

Check that every supported adapter has a complete, pinned hardening corpus:

npm run corpus:check
npm run corpus:scorecard
npm run corpus:measure -- --case python-asyncer --checkout /path/to/pinned/asyncer
npm run corpus:measure -- --case python-django --checkout /path/to/pinned/django --profile-phases
npm run csharp:performance:check
npm run javascript:performance:check
npm run python:performance:check
npm run kotlin:performance:check
npm run rust:performance:check
npm run swift:performance:check
npm run go:performance:check
npm run ruby:performance:check
npm run php:performance:check

The versioned evals/validation-corpus.json manifest records one conventional library or service, one framework-heavy application, and one difficult ownership graph per adapter cohort. Every supported adapter must have a complete cohort; a registered experimental adapter may be added only with all three roles. Each record carries the shared detection, ownership, command, evidence, ranking, stability, and performance scorecard. The 33 current pins span ten supported adapters and experimental Dart, with all 231 bounded scorecard areas passing. Dart live validation also records native upstream suite results and remaining limits. A reviewed command may be null when the adapter correctly withholds unsafe execution. Cases may also carry bounded adapter audit options, such as an explicit Go build target, so repeated measurements remain host-independent.

corpus:scorecard renders the review contract for humans. It reports review completeness separately from the pass rate among reviewed checks and keeps PASS, FAIL, and PENDING visible for every area. Use npm run corpus:scorecard -- --format json for the deterministic validation-scorecard/v1 view. These are validation-review results, not a repository-quality rating.

corpus:measure verifies the checkout's exact pinned Git SHA, runs the selected adapter at least three times, rejects canonical audit drift, and reports the raw durations, median duration, evidence-link count, and normalized audit digest used to update the scorecard. For the exact Python and Swift pins, --profile-phases defaults to five runs and additionally reports ordered samples and medians for traversal/text reading, project/build ownership, source discovery/indexing, test parsing/indexing, and evidence/classification/artifact assembly. These development timings are callback-only and never enter audit/v1, CLI/MCP audit output, or local MCP diagnostics.

Each adapter performance check separately runs a generated 400-source/200-test project, verifies its candidate and evidence counts, and enforces a broad cross-platform regression ceiling. The Rust gate includes one additional skipped src/lib.rs module-wiring target required to declare the 400 behavioral modules. These synthetic gates complement the recorded per-repository corpus distributions.

Use alpha:check for the adapter-support milestone. release:check additionally covers packaging and installed-binary readiness.

The CI workflow keeps one stable Linux pr-gate: documentation-only changes run focused contract tests, normal changes run npm run alpha:check, and distribution-sensitive changes run npm run release:check. Windows runs only for runtime and portability changes; macOS runs only for Swift-sensitive changes. A merge to master runs the complete release gate on Linux, while manual dispatch runs the full release gate on all three operating systems.

The tests include golden audit and plan snapshots under evals/expected, driven by evals/fixtures.json, plus shared adapter-conformance checks for deterministic JSON, portable paths, evidence semantics, and downstream artifact agreement. JSON schemas and the signal registry for versioned artifacts live under schemas/.

Refresh snapshots after intentional audit behavior changes:

npm run eval:check
npm run eval:summary
npm run eval:test
npm run eval:update

Check model-consistency scenario locked fields against deterministic tool results:

npm run model-consistency:check
npm run model-consistency:json
npm run model-consistency:json -- --profile local-small
npm run model-consistency:compare -- baseline-summary.json candidate-summary.json
npm run model-consistency:stats

Node 20 or newer is required for the CLI. The default smoke check is portable across platforms:

npm run smoke

If Node is not available yet, the repository still includes a PowerShell smoke check:

powershell -ExecutionPolicy Bypass -File ./scripts/smoke.ps1

Check package contents before publishing:

npm run pack:check
npm run bin:check
npm run installed-package:check
npm run distribution:check
npm run release:check

distribution:check validates packaging and MCP metadata preparation. The stricter distribution:check:publish verifies that the public npm and MCP Registry identities are aligned before a release. See Distribution.

Shape

src/
  core/
    audit-model.ts
    audit-phase-timing.js
    plan-execution-hints.js
    plan-execution-hints.ts
    repository-text-files.js
    report.js
    report.ts
  diagnostics/
    diagnostics.js
  adapters/
    csharp/
      audit.js
    javascript/
      audit.js
      audit.ts
    kotlin/
      audit.js
    python/
      audit.js
    rust/
      audit.js
    swift/
      audit.js
  cli/
    index.js
examples/
  csharp-sdk-project-pair/
  csharp-sdk-unique-pair/
  csharp-sdk-xunit-basic/
  node-vitest-basic/
  express-supertest/
  react-testing-library/
  kotlin-junit-basic/
  kotlin-gradle-groovy-junit/
  kotlin-gradle-module-graph-junit/
  kotlin-maven-junit/
  kotlin-maven-reactor-junit/
  kotlin-maven-wrapper-junit4/
  kotlin-gradle-aggregate-kotest/
  kotlin-gradle-spock/
  kotlin-maven-testng/
  python-pytest-service/
  python-uv-pytest/
  python-poetry-pytest/
  rust-cargo-basic/
  rust-cargo-workspace-basic/
  swift-spm-xctest/
  swift-spm-swift-testing/
  swift-spm-quick-nimble/
  swift-spm-custom-paths/
  swift-spm-alternate-roots/
  swift-bazel-xctest/
  swift-xcode-test-plans/
  vapor-service-tests/
  vapor-mongodb-boundaries/
evals/
  expected/
  model-consistency/
schemas/

JavaScript/TypeScript, PHP, Python, Ruby, Swift, bounded Kotlin/JVM modules, bounded Go modules, bounded C# SDK project shapes, and bounded Rust Cargo packages are supported adapter proof points. PHP support covers the bounded Composer/PSR-4/PHPUnit ownership, command-withholding, and evidence rules in PHP Alpha Support. Ruby support covers the bounded Bundler/Minitest/RSpec ownership and evidence rules in Ruby Alpha Support. Rust support includes literal repository-contained workspace members, exact package commands, built-in test ownership, literal module graphs, exact test-only module exclusion, direct logical-module imports, inherent associated calls, and exact unconditional crate-root symbol re-exports as defined in Rust Alpha Support. C# support covers one conventional SDK-style test project or one unique literal production/test project edge, including bounded native xUnit MTP-v2 and MSTest.Sdk v4 ownership, exact literal or one-hop root-aliased target membership, one repository-contained direct *.cs compile include, finite target-conditioned package predicates, and a pair amid unrelated projects, with bounded nearest-file build metadata and static central package versions, exact test-project commands, runnable-body-owned direct type calls, bounded concrete-local or immutable test-field receivers, one-hop stable direct-call, receiver-call, or inline out var result assertions, bounded exception assertions, and one same-class private-static test-helper hop while solution ownership remains excluded. Go support includes literal repository-contained go.work members, explicit static build-target selection, bounded standard-library/Testify assertion usage, parser-scoped receiver identity through concrete local and test-helper bindings, and callable-body-owned source evidence as defined in Go Alpha Support. Kotlin/JVM support is limited to conventional Gradle/Maven modules and directly declared aggregate graphs, JUnit, the documented Kotest common-spec and Spock feature variants, or method-level TestNG, and standard source sets as defined in Kotlin/JVM Alpha Support.

Important runtime surfaces:

  • CLI: src/cli/index.js

  • MCP tool definitions: src/mcp/tool-definitions.js

  • stdio MCP SDK server: src/mcp/stdio.js

  • local invoke harness: src/mcp/invoke.js

  • release gate: scripts/check-release-readiness.js

Docs

Available Tools

20 tools
analyze_project_test_placementAnalyze Project Test PlacementA
Read-onlyIdempotent

Derive advisory test-placement findings across audited projects while preserving project identity, from a project-audits/v1 artifact or, with repoRoot, from a fresh audit. Use analyze_test_placement for one project. Does not execute tests or create, move, or modify files.

Inputs: goTarget, repoRoot, changedPaths, projectAudits, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/test-placeme…

analyze_repositoryAnalyze RepositoryA
Read-onlyIdempotent

Return the complete repository-analysis/v1 bundle: every project audit with per-target test evidence plus the derived summary, findings, ranking, plan, execution hints, and stats. The result grows with repository size and can exceed client limits on large monorepos, so prefer review_repository first and use this only when the complete bundle is explicitly needed or the repository is small.

Inputs: repoRoot (required), goTarget, changedPaths, excludeProjectRoots. Returns: Top-level shape of this artifact. The complete contract is schemas/repository-a…

analyze_test_placementAnalyze Test PlacementA
Read-onlyIdempotent

Derive advisory test-placement findings for one project; use analyze_project_test_placement for multiple audited projects. Pass an existing audit/v1 artifact, or pass repoRoot plus projectRoot to audit that project deterministically. Does not execute tests or create, move, or modify files.

Inputs: audit, owner, goTarget, repoRoot, +2 more. Returns: Top-level shape of this artifact. The complete contract is schemas/test-placeme…

audit_projectsAudit ProjectsA
Read-onlyIdempotent

Return raw per-project audit artifacts for all detected supported roots, report unsupported roots, and list roots whose adapter failed in failedProjects. Use when a downstream specialist tool needs project-audits/v1; for a general first-pass review, prefer review_repository. The result can be large; specialist tools also accept repoRoot directly, so the artifact rarely needs to be passed back.

Inputs: repoRoot (required), goTarget, changedPaths, excludeProjectRoots. Returns: Top-level shape of this artifact. The complete contract is schemas/project-audi…

audit_repoAudit RepositoryA
Read-onlyIdempotent

Audit one explicitly selected project root and return audit/v1. Use only when the caller selected a single adapter or project boundary; adapterId defaults to javascript. For an unfamiliar repository or a general review, use review_repository.

Inputs: repoRoot (required), goTarget, adapterId, changedPaths. Returns: Top-level shape of this artifact. The complete contract is schemas/audit-v1.sch…

collect_project_findingsCollect Project FindingsA
Read-onlyIdempotent

Collect concise top findings from an existing project-audits/v1 artifact. review_repository returns a bounded version of this result; pass repoRoot here for the complete artifact.

Inputs: goTarget, repoRoot, changedPaths, projectAudits, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/project-find…

collect_project_statsCollect Project StatsA
Read-onlyIdempotent

Aggregate coverage, counts, risk and signal distributions, frameworks, and adapter usage from a project-audits/v1 artifact or, with repoRoot, from a fresh audit. Use this for separate reporting or comparisons; review_repository already includes the same stats. Returns project-stats/v1 without executing tests or writing files.

Inputs: goTarget, repoRoot, changedPaths, projectAudits, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/project-stat…

detect_projectsDetect ProjectsA
Read-onlyIdempotent

Discover project roots, support status, and matching adapters without auditing source targets. Use this when project boundaries are needed before a specialized workflow; use review_repository for a general review. Reads local repository markers and returns project-detection/v1 without executing tests or writing files.

Inputs: repoRoot (required), excludeProjectRoots. Returns: Top-level shape of this artifact. The complete contract is schemas/project-dete…

explain_targetExplain Audit TargetA
Read-onlyIdempotent

Explain the evidence, risk, testability, and recommendation for one audited target, including its complete existing-test evidence. Use this after review_repository when one target needs detail: pass repoRoot plus the projectRoot and targetId from the review, or pass an existing audit/v1 artifact. Returns target-explanation/v1 without executing tests or writing files.

Inputs: targetId (required), audit, goTarget, repoRoot, +2 more. Returns: Top-level shape of this artifact. The complete contract is schemas/target-expla…

generate_project_test_planGenerate Project Test PlanA
Read-onlyIdempotent

Generate a project-aware plan from an existing project-audits/v1 artifact. review_repository returns a bounded version of this result; pass repoRoot here for the complete artifact.

Inputs: goTarget, repoRoot, changedPaths, projectAudits, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/project-test…

generate_selected_testGenerate Selected Test (Deferred)A
Read-onlyIdempotent

Return a structured deferred result. This tool does not generate or write test code while native generation remains disabled.

Inputs: planItemId (required). Returns: Top-level shape of this artifact. The complete contract is schemas/generation-d…

generate_test_planGenerate Test PlanA
Read-onlyIdempotent

Create a deterministic plan/v1 for one project, optionally selecting one exact plan item; use generate_project_test_plan for multiple audited projects. Pass an existing audit/v1 artifact, or pass repoRoot plus projectRoot to audit that project deterministically. Does not execute tests or generate or write test code.

Inputs: audit, itemId, goTarget, repoRoot, +2 more. Returns: Top-level shape of this artifact. The complete contract is schemas/plan-v1.sche…

get_audit_graphGet Audit GraphA
Read-onlyIdempotent

Return one project's audit/v1 artifact: validate and return a saved audit unchanged, or pass repoRoot plus projectRoot to audit that detected project. Use audit_repo when the adapter is selected explicitly, and review_repository for a general review.

Inputs: audit, goTarget, repoRoot, projectRoot, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/audit-v1.sch…

get_plan_execution_hintsGet Plan Execution HintsA
Read-onlyIdempotent

Derive provider-neutral execution, context, parallel-safety, and repository-reasoning hints from a plan without invoking models or subagents. Pass an existing plan/v1 or project-test-plan/v1 artifact, or pass repoRoot to derive hints for the project-aware plan of that repository.

Inputs: plan, itemId, goTarget, repoRoot, +2 more. Returns: Top-level shape of this artifact. The complete contract is schemas/plan-executi…

list_adaptersList AdaptersA
Read-onlyIdempotent

List registered language adapters available to audit repositories.

Inputs: no named parameters. Returns: Top-level shape of this artifact. The complete contract is schemas/adapter-regi…

list_project_detection_rulesList Project Detection RulesA
Read-onlyIdempotent

List deterministic project marker rules and ignored directories used during project detection.

Inputs: no named parameters. Returns: Top-level shape of this artifact. The complete contract is schemas/project-dete…

rank_project_candidatesRank Project Test CandidatesA
Read-onlyIdempotent

Rank candidates from an existing project-audits/v1 artifact while preserving project identity. review_repository returns a bounded version of this result; pass repoRoot here for the complete artifact.

Inputs: goTarget, repoRoot, changedPaths, projectAudits, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/project-cand…

rank_test_candidatesRank Test CandidatesA
Read-onlyIdempotent

Rank testable audit targets of one project by risk reduction and maintenance cost. Pass an existing audit/v1 artifact, or pass repoRoot plus projectRoot to audit that project deterministically.

Inputs: audit, goTarget, repoRoot, projectRoot, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/candidate-ra…

review_repositoryReview RepositoryA
Read-onlyIdempotent

Start here for an unfamiliar repository or a general test-architecture review. Detect and audit all project roots once, then return a bounded deterministic review: summary counts, blockers, top findings, the top-ranked candidates and plan items with execution hints, verification commands, and stats. limit caps the ranked lists (default 25) and per-test evidence is reduced to counts, so the result stays small on large monorepos. Use explain_target with repoRoot and projectRoot for one target's evidence, and analyze_repository only when the complete bundle is explicitly needed.

Inputs: repoRoot (required), limit, goTarget, changedPaths, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/repository-r…

summarize_project_auditsSummarize Project AuditsA
Read-onlyIdempotent

Summarize an existing project-audits/v1 artifact. Use only when a compact coverage view is needed separately; review_repository returns a bounded version of this result; pass repoRoot here for the complete artifact.

Inputs: goTarget, repoRoot, changedPaths, projectAudits, +1 more. Returns: Top-level shape of this artifact. The complete contract is schemas/project-audi…

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 20 tools

    Disambiguation3/5

    There is a clear effort to distinguish tools via descriptions (e.g. review_repository vs analyze_repository bounded-vs-complete, single-project vs multi-project variants), but the surface contains many near-parallel families: audit_repo vs get_audit_graph vs audit_projects, and rank_test_candidates vs rank_project_candidates, etc. An agent must read carefully to select the right tool, and several boundaries (audit_repo/get_audit_graph in particular) remain genuinely fuzzy.

    Naming Consistency4/5

    Names are uniformly snake_case and overwhelmingly follow a verb_noun pattern (list_adapters, review_repository, generate_project_test_plan, analyze_test_placement). Minor deviations exist where a noun precedes a qualifier (get_audit_graph, explain_target), and the project_ infix is inconsistently applied as a scoping hint, but the overall convention is predictable.

    Tool Count3/5

    Twenty tools is on the heavy side for the domain, and much of the count comes from redundant project-level vs single-project variants of the same operations. The breadth is defensible given the layered workflow (detect, audit, review, rank, plan, explain), but it feels over-expanded rather than tightly scoped.

    Completeness4/5

    The lifecycle for a read-only test-architecture review is well covered: detection, audit, bounded and full analysis, summarization, ranking, planning, placement, stats, and execution hints. The one notable dead end is generate_selected_test, which is a structured stub that generates nothing, but the core analysis surface has no glaring gaps.

    Maintenance

    ActivityActive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Local-first MCP server that scans a repository once and answers architecture questions from an evidence-backed graph, enabling dependency analysis, impact analysis, and codebase exploration without re-reading the source tree.
      8
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      A local-first MCP server that scores your codebase's Build Readiness by reading code and running tests on your machine, outputting a diligence-grade score and risk register without uploading your source.
      5
      Apache 2.0
    • A
      license
      A
      quality
      B
      maintenance
      A secure, local-first MCP server for read-only inspection and troubleshooting of development environments, exposing narrow, typed, auditable capabilities for repository inspection, log summarization, Docker review, and security scanning without granting unrestricted machine access.
      8
      MIT