Skip to main content
Glama

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.

Release Python 3.12 MCP: stdio License: MIT Ruff

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 | sh

Windows (PowerShell):

irm https://raw.githubusercontent.com/jamesdsizemore/rush-cli/main/scripts/install.ps1 | iex

This 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/project

For 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/project

If 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 health
git 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 gate

Every 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

rush_context_pack

Packs the relevant symbols and AST skeletons for a task into a token budget

rush_blast_radius

Reports what a change would affect — files, routes, tests

rush_hallu_guard

Checks that an agent's proposed imports actually exist in the codebase

rush_context_mistakes_check

Looks up whether a similar approach already failed before

rush_mesh_acquire_lock / rush_mesh_release_lock

Cooperative file locks for multiple agents working the same repo

rush_test_heal

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 = true

Full 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 stdout reserved for JSON-RPC; all logging goes to stderr.

  • Full threat model and guarantees: docs/SAFETY.md.


Contributing

  1. uv run --python 3.12 --extra dev ruff check src tests scripts and ruff format --check should both pass.

  2. New engines/tools need tests under tests/test_<name>.py.

  3. See docs/developer/contributor-onboarding.md for the full guide.

License

MIT

Available Tools

79 tools
rush_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

    C2.6/5.0

    Scored across 79 tools

    Disambiguation2/5

    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.

    Naming Consistency3/5

    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.

    Tool Count1/5

    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.

    Completeness4/5

    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

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • -
      license
      Not graded
      quality
      Not graded
      maintenance
      Provides 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.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Code 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 npm
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Autonomous 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 npm
      1,120
      Business Source 1.1
    • A
      license
      Not graded
      quality
      D
      maintenance
      Analyzes 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