rush
Rush is an MCP server that gives AI coding agents fast, local, agentic code-quality, testing, security, and context tools, plus release and collaboration helpers.
Code quality & review: heuristic/LLM review, lint, format (check-only), typecheck, dead code, complexity, AI-slop detection, and safe auto-fixes for Python/JS/TS, Markdown, YAML, SQL, Dockerfiles, Terraform, templates, and CI workflows.
Testing & verification: unit/E2E tests, mutation, property-based, fuzz, load, contract, snapshot, coverage, CodeQL, and flaky-test healing with permission-gated slow/build/browser/network operations.
Security & supply chain: dependency vulnerability scanning, secret scanning (redacted), SBOM generation, license matrix, IAM audit, SLSA attestation, and secret/security findings as artifacts.
Agent safety & collaboration: destructive-command guard, multi-agent file locks, 3-way AST merge, session checkpoints/continuity, coordination, and failure-ledger-driven mistake prevention.
Memory & context economy: typed per-project memory store, token-saving context packing, AST outlines, blast-radius analysis, API diff detection, architecture boundary checks, and requirement traceability.
Release & governance: pre-flight release gate (ship gate), environment variable audit, PR synthesis, governance sync for multi-IDE rules, and environment/toolchain diagnostics via doctor.
Provides linting and static analysis for JavaScript/TypeScript code via ESLint.
Provides package management, script execution, and dependency auditing via npm.
Provides code formatting and style enforcement via Prettier.
Provides unit testing for Python code via pytest.
Provides linting and static analysis for Python code via the Ruff linter.
Provides unit testing for JavaScript/TypeScript code via Vitest.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@rush Lint my current project and run the test suite"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Rush
Give your agents more than a prompt. Rush is local-first infrastructure for coding agents: project memory they can query, code context they can use, and controls for how they act. Available through a Python CLI and stdio MCP server.
Keep decisions across sessions. Bring relevant code into the next task. Put permissions and isolation around supported operations. Review, lint, tests, and security checks supply feedback along the way.
Install · Quickstart · Connect an AI agent · What it does · Configuration · Contributing
Why Rush
Your project has a history. Your agent needs a way to use it. Rush gives coding agents the tools to retrieve prior decisions, find relevant code, and execute within explicit boundaries:
Remember the work — store and retrieve typed project memories and session checkpoints instead of relying on a chat transcript.
Find the signal — pack context, inspect AST outlines, and consume compact results within a working context budget.
Act with boundaries — permission checks, command guards, and isolated Git worktrees bound supported operations.
Close the loop — review, lint, format, test, and security tools return structured findings agents can act on.
Rush discovers optional quality/security engines from your environment. Use rush capabilities . to inspect what's available before running a workflow.
Related MCP server: mcp-lint-tools
Install
The fastest way to get rush on your machine is the install script — it downloads a checksum-verified, self-contained binary. No Python, no uv, no repo checkout required.
macOS / Linux:
curl -fsSL https://raw.githubusercontent.com/jamesdsizemore/rush-cli/main/scripts/install.sh | shWindows (PowerShell):
irm https://raw.githubusercontent.com/jamesdsizemore/rush-cli/main/scripts/install.ps1 | iexThis installs rush to a user-owned directory, adds it to your shell (or tells you how to), and automatically connects any supported coding agent it finds on your machine (Claude Desktop, Claude Code, Windsurf, Zed, Codex CLI). Once installed, re-run the rush install command directly any time you want different flags, upgrade, repair, or connect a specific project:
# Skip agent connection / memory consent entirely
rush install --agents none --memory off
# Connect a specific project instead of leaving selection pending
rush install --agents all --memory on --project /path/to/your/projectFor a fully guided route straight to a working Claude Code or Codex CLI connection, pass --setup (with --agent and --project) to the same install script — it installs the binary, connects no agent itself, then runs rush setup for that project/agent and asks for consent on the terminal:
curl -fsSL https://raw.githubusercontent.com/jamesdsizemore/rush-cli/main/scripts/install.sh | sh -s -- --setup --agent claude --project /path/to/your/projectIf you install without --setup (or decline setup's prompt), the result prints the exact command to resume it later: rush setup /path/to/your/project --agent claude.
Windows on ARM64 isn't available yet — a dependency (
cryptography) doesn't currently publish a prebuilt wheel for that platform. Every other combination (macOS Intel/Apple Silicon, Linux x86_64/ARM64, Windows x86_64) is fully supported.
Verify it worked:
rush --version
rush doctor # checks your environment and toolchain healthgit clone https://github.com/jamesdsizemore/rush-cli.git
cd rush-cli
# with uv (recommended for development)
uv sync --all-extras --frozen
uv run rush --version
# or with pip
python -m venv .venv
source .venv/bin/activate # .venv\Scripts\activate on Windows
pip install -e ".[dev]"Quickstart
# Set up a project: writes a rush.toml tailored to your stack
rush init .
# Sync one set of rules to every IDE/agent config you use
rush governance sync
# Review the codebase — deterministic AST checks, no network calls
rush review .
# Preview safe auto-fixes (formatting + lint) without touching files
rush fix . --dry-run
# Run the full pre-flight release gate: tests, coverage, lint, security, drift
rush ship gateEvery command prints a consistent result — status, findings, and a one-line summary — whether you're reading it in a terminal or an agent is parsing it as JSON (--json on most commands).
Connect an AI agent (MCP)
Rush speaks MCP over stdio, so any MCP-capable agent can call its tools directly instead of shelling out.
Claude Desktop — add to claude_desktop_config.json:
{
"mcpServers": {
"rush": {
"command": "rush",
"args": ["mcp", "serve"]
}
}
}Windsurf (~/.codeium/windsurf/mcp_config.json) uses the same shape:
{
"mcpServers": {
"rush": {
"command": "rush",
"args": ["mcp", "serve"]
}
}
}If your client can't resolve rush from PATH, point command at the absolute path rush doctor reports. For every other client, see the MCP client setup guide. The full tool list — schemas included — is always available live from the running server (tools/list) and documented in the MCP reference; a few of the most-used tools:
Tool | What it does |
| Packs the relevant symbols and AST skeletons for a task into a token budget |
| Reports what a change would affect — files, routes, tests |
| Checks that an agent's proposed imports actually exist in the codebase |
| Looks up whether a similar approach already failed before |
| Cooperative file locks for multiple agents working the same repo |
| Investigates a flaky test in an isolated sandbox |
What it does
Rush ships as one CLI with a lot of focused tools behind it (rush --help for the full list). Grouped by what you'd actually reach for:
Code quality
review · lint · format · fix · typecheck · dead · complexity · simplify · slop (AI hallucination/placeholder detector) · tdd
Testing
test · e2e · mutation · pbt (property-based) · flaky · coverage · contract · fuzz · load · test-heal
Security & supply chain
security (dependency vulnerabilities) · secrets (with automatic redaction) · sbom · codeql · attest (draft SLSA provenance) · license-matrix · iam-audit
Agent safety
guard (blocks destructive commands like git reset --hard/rm -rf) · isolated git-worktree sandboxes for patch attempts · swarm-merge (3-way AST merge for concurrent agents) · a failure ledger that stops agents from retrying known-bad fixes
Memory
memory write / recall / ask — a typed store (.rush/memory.db, one per project, WAL-mode SQLite) across 7 kinds: episodic, preference, failure, architectural decisions, domain knowledge, skill patterns, and active context. Nothing an agent writes is trusted outright — memory promote runs it through a corroboration gate that also screens for instruction-override/exfiltration patterns before anything is treated as fact. context mistakes mines actual git-revert history so an agent doesn't retry a fix that was already tried and reverted. session save/restore and continuity checkpoint a working session and resume it later. The rush_memory MCP tool bridges a bounded handoff between agents instead of each one keeping its own siloed context.
Static analysis feeds directly into it: memory plan-checks ranks which checks actually matter for a change using real evidence pulled from memory — a prior test that failed against this exact code, measured coverage, a blast-radius/api-diff structural relation, a version-bound security finding — never a fabricated "this is covered" from a check that only ever ran in config. memory last-success-diagnose compares a current failure against the last time this code path actually passed. Scan results themselves become typed memory artifacts on handoff, so a finding an agent hands off is a durable, queryable record, not just terminal output that evaporates.
Token economy & context
context pack (AST-aware, budget-constrained context) · context align-prompt (prompt-cache-friendly formatting) · context gain (live token/cost savings HUD) · token count · blast-radius
Governance & multi-IDE
governance sync — compile one AGENTS.md into .windsurfrules, .clinerules, and Claude Code config in one command
Dashboards
dashboard — a local, authenticated web UI · ui — the same views as a terminal app (Rich TUI), both backed by the same project data (scans, findings, memory, token use, git history)
Every one of these has real engines behind it where a standard tool exists (Ruff, ESLint, pytest, Gitleaks, Syft, and dozens more) and a deterministic built-in fallback where it doesn't. rush capabilities . shows exactly what's usable in your environment before you run anything. A couple of honest gaps: rush hook run exists today, but hook install/hook verify aren't wired up yet, and dead-asset reports candidates without a --prune flag to delete them for you.
Configuration
Rush reads rush.toml from your project root — rush init . generates one tailored to your stack. Everything is optional; sensible defaults apply if you skip it:
log_level = "warn"
[project]
src = ["src"]
test = ["tests"]
exclude = ["**/.venv/**", "**/node_modules/**"]
[review]
max_file_lines = 400
scaffold_markers = ["TODO", "FIXME", "HACK"]
[tools.lint]
check = trueFull field reference: docs/CONFIGURATION.md.
Safety notes
Rush never installs packages or runs network calls on its own — quality/security engines are discovered from your
PATH; you decide what's installed.Destructive git operations (rewriting history, force-pushing, tagging, publishing) never happen implicitly — only when you explicitly ask.
The stdio MCP server keeps
stdoutreserved for JSON-RPC; all logging goes tostderr.Full threat model and guarantees:
docs/SAFETY.md.
Contributing
uv run --python 3.12 --extra dev ruff check src tests scriptsandruff format --checkshould both pass.New engines/tools need tests under
tests/test_<name>.py.See
docs/developer/contributor-onboarding.mdfor the full guide.
License
Available Tools
79 toolsrush_actionsA
Check GitHub Actions workflows without rewriting; missing actionlint returns status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_agent_connectionC
Discover, connect, and diagnose local coding agents
Inputs: request (required). Returns: object
rush_ai_evalC
Evaluate LLM prompts, agent workflows, and safety guardrails. Requires explicit permissions for live inference runs.
Inputs: path (required), allow_slow, allow_build, allow_browser, +4 more. Returns: raw, tool, engine, status, +9 more
rush_api_diffA
Detect breaking public API changes against base Git ref
Inputs: base. Returns: result
rush_arch_guardB
Validate codebase against clean architecture layer boundaries
Inputs: no named parameters. Returns: result
rush_attestC
Generate in-toto Statement v1 SLSA provenance unsigned draft for build artifacts.
Inputs: path (required), verify, allow_slow, builder_id, +11 more. Returns: raw, tool, engine, status, +9 more
rush_attest_generateB
Deprecated alias for rush_attest
Inputs: path (required), verify, allow_slow, builder_id, +11 more. Returns: raw, tool, engine, status, +9 more
rush_benchmarkB
Compare performance samples against baseline thresholds at ; baseline recording requires --allow-cache-write. Returns {status, findings[], summary}.
Inputs: path (required), options (required), record, samples, +10 more. Returns: raw, tool, engine, status, +9 more
rush_blast_radiusA
Calculate downstream transitive blast radius for a changed file
Inputs: path (required), depth. Returns: result
rush_ciA
Inspect local CI workflow configuration without accessing credentials or remote status.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_codeqlC
Import a local CodeQL SARIF report or run CodeQL analysis under --allow-build.
Inputs: path (required), allow_slow, allow_build, report_path, +5 more. Returns: raw, tool, engine, status, +9 more
rush_cold_startB
Audit import overhead and cold-start latency at ; dynamic -X importtime requires --allow-slow. Returns {status, findings[], summary}.
Inputs: path (required), options (required), dynamic, allow_slow, +7 more. Returns: raw, tool, engine, status, +9 more
rush_commit_msgC
Validate supplied Conventional Commit messages without modifying Git history.
Inputs: path (required), message, allow_slow, allow_build, +5 more. Returns: raw, tool, engine, status, +9 more
rush_complexityA
Measure Python and JS/TS complexity at . Uses radon or jscpd; missing engines return status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_containerfileA
Check container files without rewriting; missing hadolint returns status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_context_gain_statsB
Get real-time token economy savings and cost metrics
Inputs: no named parameters. Returns: result
rush_context_mistakes_checkB
Check git revert history for past mistakes and anti-patterns
Inputs: no named parameters. Returns: result
rush_context_packC
Pack graph-pruned context outline under a strict token budget
Inputs: path (required), budget, symbol, allow_cache_write.
rush_context_retrieveC
Retrieve uncompressed content from CCR chunk store by hash
Inputs: chunk_hash (required), path.
rush_continuityC
Save, list, or restore a local Rush session checkpoint. Returns {status, findings[], summary}; saving requires explicit cache-write permission.
Inputs: path (required), name, as_v1, files, +20 more. Returns: result
rush_contractC
Import a local Pact report or run local contract verifications under --allow-slow.
Inputs: path (required), options (required), allow_slow, pact_files, +9 more. Returns: raw, tool, engine, status, +9 more
rush_coverageC
Import a local coverage report or run coverage analysis under --allow-slow.
Inputs: path (required), allow_slow, allow_build, report_path, +5 more. Returns: raw, tool, engine, status, +9 more
rush_db_driftB
Audit ORM models against migrations to detect schema drift
Inputs: no named parameters. Returns: result
rush_deadA
Find unused Python and JS/TS code at . Uses vulture or knip; missing engines return status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_dead_assetA
Detect unreferenced images, fonts, and media assets under (strictly read-only). Returns {status, findings[], summary}; export manifest requires --allow-artifact-write.
Inputs: path (required), export_manifest, allow_artifact_write. Returns: raw, tool, engine, status, +9 more
rush_doctorA
Diagnose environment health, toolchain integrity, and binary resolution at . Returns {status, findings[], summary}.
Inputs: path. Returns: raw, tool, engine, status, +9 more
rush_e2eC
Run configured E2E tests only with --allow-browser.
Inputs: path (required), options (required), allow_slow, allow_build, +5 more. Returns: raw, tool, engine, status, +9 more
rush_error_catalogB
Extract Python, TypeScript, and Rust exceptions at , generate RFC 7807 problem catalog; export markdown requires --allow-artifact-write.
Inputs: path (required), export_path, allow_artifact_write. Returns: raw, tool, engine, status, +9 more
rush_fixB
Safely auto-remediate formatting and linter issues at . Returns {status, findings[], summary}. Enforces strict path confinement.
Inputs: path, force, dry_run, allow_artifact_write. Returns: raw, tool, engine, status, +9 more
rush_flakyC
Import a local JUnit report or run duplicate test analysis under --allow-slow.
Inputs: path (required), allow_slow, allow_build, report_path, +5 more. Returns: raw, tool, engine, status, +9 more
rush_formatA
Format Python/JS/TS files at . Returns {status, findings[], summary}. Engines: ruff format (Python), prettier (JS/TS). Always check-only in v0.1.
Inputs: path (required), check. Returns: raw, tool, engine, status, +9 more
rush_fuzzC
Import a local fuzz report or execute local fuzz tests under --allow-slow.
Inputs: path (required), options (required), seed, corpus, +11 more. Returns: raw, tool, engine, status, +9 more
rush_hallu_guardB
Audit code imports against installed packages and stdlib
Inputs: path. Returns: result
rush_iacB
Check Terraform without rewriting; missing local engines return status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_iam_auditC
Audit cloud SDK calls in code, inspect Terraform HCL2 policies for wildcards, and synthesize minimal least-privilege IAM policies. Returns {status, findings[], summary}.
Inputs: path (required), allow_slow, allow_build, allow_browser, +5 more. Returns: raw, tool, engine, status, +9 more
rush_license_matrixC
Audit open-source dependencies for license risks and copyleft compliance. Returns {status, findings[], summary}.
Inputs: path (required), allow_slow, allow_build, allow_browser, +6 more. Returns: raw, tool, engine, status, +9 more
rush_lintA
Lint Python/JS/TS files at . Returns {status, findings[], summary}. Engines: ruff (Python), eslint (JS/TS). status='skipped' means engine not on PATH.
Inputs: path (required), engine_args. Returns: raw, tool, engine, status, +9 more
rush_loadC
Import a local load report or execute load traffic under --allow-network.
Inputs: path (required), options (required), vus, script, +11 more. Returns: raw, tool, engine, status, +9 more
rush_markdownA
Check Markdown at without rewriting files; missing markdownlint-cli returns status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_media_optC
Audit media assets for CLS and SVG security at ; writes optimized assets with --allow-artifact-write. Returns {status, findings[], summary}.
Inputs: path (required), options (required), optimize, sanitize, +7 more. Returns: raw, tool, engine, status, +9 more
rush_memoryC
Query, write, or promote a cross-tool memory artifact in the typed artifact store. Returns {status, findings[], summary}; write/promote/maintain/verify_attempt require explicit permissions.
Inputs: path (required), task, query, source, +18 more. Returns: raw, tool, engine, status, +9 more
rush_mem_profileB
Audit memory usage and unclosed resources at ; dynamic probe requires --allow-slow. Returns {status, findings[], summary}.
Inputs: path (required), options (required), dynamic, allow_slow, +7 more. Returns: raw, tool, engine, status, +9 more
rush_mesh_acquire_lockC
Acquire non-blocking multi-agent file lock
Inputs: path (required), agent_id (required), capability. Returns: result
rush_mesh_release_lockB
Release multi-agent file lock
Inputs: path (required), agent_id (required), capability. Returns: result
rush_mutationC
Import a local mutation report or run mutation testing under --allow-slow.
Inputs: path (required), options (required), allow_slow, test_paths, +9 more. Returns: raw, tool, engine, status, +9 more
rush_offline_reviewA
Run air-gapped code review using external local LLM (ollama/llama-cli) on PATH; returns skipped if no local runner is found. Returns {status, findings[], summary}.
Inputs: path (required), options (required), model, allow_slow, +7 more. Returns: raw, tool, engine, status, +9 more
rush_patch_applyA
Verify a contained unified diff in an isolated checkout. Defaults to dry-run; promotion requires artifact-write permission. Returns status, findings, summary.
Inputs: patch_file (required), path, dry_run, circuit_breaker, +1 more. Returns: raw, tool, engine, status, +9 more
rush_pbtC
Import a local property-test report or run property tests under --allow-slow.
Inputs: path (required), allow_slow, allow_build, report_path, +5 more. Returns: raw, tool, engine, status, +9 more
rush_projectD
Register, discover, select, and configure Rush projects
Inputs: request (required). Returns: object
rush_prompt_evalC
Evaluate recorded prompt runs against golden task criteria at . Returns {status, findings[], summary}.
Inputs: path (required), options (required), records, allow_slow, +10 more. Returns: raw, tool, engine, status, +9 more
rush_provenance_aiC
Analyze git commit trailers for AI attribution, calculate empirical code survival curves (30/60/90d), and compute defect correlation. Returns {status, findings[], summary}.
Inputs: path (required), allow_slow, allow_build, allow_browser, +4 more. Returns: raw, tool, engine, status, +9 more
rush_pr_synthesizeA
Synthesize semantic PR markdown card from git diff and evidence at ; export requires --allow-artifact-write.
Inputs: path (required), base_ref, export_path, allow_artifact_write. Returns: raw, tool, engine, status, +9 more
rush_releaseB
Create a dry-run release plan; publishing requires explicit confirmation.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_reviewA
Review code at for size, TODO density, missing docstrings, naming, complexity. Returns {status, findings[], summary}. Default: heuristic. Pass use_llm=true to call configured model.
Inputs: path (required), use_llm, use_graft, changed_files. Returns: raw, tool, engine, status, +9 more
rush_sbomB
Generate an SBOM only to a safe explicit output path; missing cdxgen returns status='skipped'.
Inputs: path (required), overwrite, allow_slow, allow_build, +6 more. Returns: raw, tool, engine, status, +9 more
rush_scanC
Plan, run, and check status of a full-project scan
Inputs: request (required). Returns: object
rush_scan_handoffC
Prepare, dispatch, and acknowledge a bounded agent handoff of scan findings
Inputs: request (required). Returns: object
rush_secretsA
Scan for secrets without exposing values; missing gitleaks returns status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_securityC
Scan deps at for known vulnerabilities. Returns {status, findings[], summary}. Engines: pip-audit (Python), npm audit (JS/TS). status='skipped' means engine not on PATH.
Inputs: path (required), allow_slow, allow_build, allow_browser, +4 more. Returns: raw, tool, engine, status, +9 more
rush_semantic_driftB
Semantic drift detection comparing rendered DOM/accessibility against baseline. Requires both --allow-browser and --allow-slow.
Inputs: path (required), allow_slow, allow_build, allow_browser, +4 more. Returns: raw, tool, engine, status, +9 more
rush_ship_cleanB
Clean scratch directories and build caches before release
Inputs: path, apply, allow_artifact_write. Returns: object
rush_ship_envA
Audit codebase environment variable usage against .env.example
Inputs: no named parameters. Returns: result
rush_ship_gateC
Run 7-vector pre-flight release readiness cockpit
Inputs: no named parameters. Returns: result
rush_simplifyB
Decompose high-complexity functions into modular helpers
Inputs: file (required), max_complexity. Returns: result
rush_slopB
Detect Python AI slop and deterministic JS/TS noise at ; missing sloppylint returns status='skipped' when no JS/TS fallback applies.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_snapshotC
Import a local snapshot comparison or run snapshot tests under --allow-slow.
Inputs: path (required), options (required), accept, allow_slow, +7 more. Returns: raw, tool, engine, status, +9 more
rush_sqlB
Check SQL without rewriting; missing sqlfluff returns status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_strictifyC
Synthesize runtime type guards for unvalidated parameters
Inputs: file (required). Returns: result
rush_swarm_mergeC
Execute 3-way AST merge conflict resolution
Inputs: base_code (required), ours_code (required), theirs_code (required). Returns: result
rush_tddC
Verify Test-Driven Development (TDD) compliance at . Returns {status, findings[], summary}.
Inputs: path (required), options (required), allow_slow, allow_build, +5 more. Returns: raw, tool, engine, status, +9 more
rush_templatesA
Check templates without rewriting; missing djlint returns status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_testA
Run tests for project at . Returns {status, findings[], summary}. Engines: pytest (Python), vitest/npm (JS/TS). status='skipped' means engine not on PATH.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_test_healC
Diagnose flaky test race conditions and suggest fixes
Inputs: target (required), runs, seed, dry_run, +3 more. Returns: result
rush_token_outlineB
Generate token-efficient AST skeleton outline of a code file
Inputs: path (required), focus_symbol. Returns: result
rush_traceB
Scan codebase and specs to output requirement traceability matrix
Inputs: no named parameters. Returns: result
rush_tui_diffC
Compute Git commit and quality findings deltas at ; renders Rich tables in CLI. Returns {status, findings[], summary}.
Inputs: path (required), options (required), base_ref, allow_slow, +8 more. Returns: raw, tool, engine, status, +9 more
rush_typecheckA
Type-check Python and JS/TS at . Uses mypy or tsc; missing engines return status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
rush_visualB
Check visual baselines; updates require --accept.
Inputs: path (required), options (required), allow_slow, allow_build, +5 more. Returns: raw, tool, engine, status, +9 more
rush_yamlA
Check YAML without rewriting; missing spectral returns status='skipped'.
Inputs: path (required). Returns: raw, tool, engine, status, +9 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 79 tools
Many tools fall into the same broad audit/scan bucket, such as rush_review, rush_lint, rush_slop, rush_dead, and rush_complexity, making selection genuinely ambiguous. Test-related tools like rush_test, rush_e2e, rush_snapshot, and rush_visual also blur together, and the deprecated rush_attest_generate alias adds extra confusion.
All tools share the rush_ prefix and snake_case, which keeps the naming readable. However, the operation part is inconsistent: some are nouns, some are verbs, and some are long descriptive phrases, so there is no predictable verb_noun or noun_verb convention.
With 79 tools, this is an extreme over-scoped MCP surface and far exceeds the threshold where a tool set remains navigable. Many related scanners could be consolidated into a single parameterized scan/audit tool, and the sheer count severely harms discoverability.
The inferred domain is a broad engineering-quality and release-readiness assistant, and the tool set covers static analysis, testing, security, release planning, AI evaluation, context management, and agent coordination. Some gaps remain—many findings can only be remediated by rush_fix and several tools depend on external engines—but agents can generally work around these.
Maintenance
Related MCP Connectors
Enforces architectural invariants and code quality rules inside your AI agent's edit loop.
Real-time chat for AI agents. Claude Code, Cursor, Cline and Codex join channels over MCP.
Real-time chat hub for AI agents — Claude Code, Cursor, Cline, Codex over MCP or REST.
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Related MCP Servers
- -licenseNot gradedqualityNot gradedmaintenanceProvides comprehensive code quality tools including linting, security scanning, TypeScript checking, and testing through a single MCP server. Integrates multiple quality analysis tools like Biome, ESLint, and Playwright for streamlined development workflows.-
- AlicenseNot gradedqualityDmaintenanceCode linting and style checking tools for AI agents, exposed as an MCP server. Supports style checks, naming conventions, complexity analysis, dead code detection, and import analysis.45 npmMIT
- AlicenseNot gradedqualityBmaintenanceAutonomous spec-to-product coding-agent CLI. Its MCP server exposes 34 tools over stdio: project state and task-queue ops, memory retrieve/store, code search, quality and verification reports, repo hotspots/co-changes, and structured findings/learnings.12,934 npm1,120Business Source 1.1
- AlicenseNot gradedqualityDmaintenanceAnalyzes codebases to produce structured quality health reports with risk-scored modules based on git churn, test coverage, and test-to-source mapping, acting as an MCP server for AI coding agents and a standalone CLI.MIT