{ "markdown": "# GateTest\n\n### One gate. 121 modules. Self-healing CI.\n\n**AI-powered code quality. Pay per scan via Stripe.**\n\n\n[![GateTest](https://gatetest.io/badge/crclabs-hq/GateTest)](https://gatetest.io)\n[![npm](https://img.shields.io/npm/v/@gatetest/cli.svg)](https://www.npmjs.com/package/@gatetest/cli)\n[![CI](https://github.com/crclabs-hq/GateTest/actions/workflows/ci.yml/badge.svg)](https://github.com/crclabs-hq/GateTest/actions/workflows/ci.yml)\n[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)\n[![Modules](https://img.shields.io/badge/modules-120-purple.svg)](#what-it-replaces)\n[![Tests](https://img.shields.io/badge/tests-6000%2B-brightgreen.svg)](#real-repo-proofs)\n[![Node](https://img.shields.io/badge/node-%E2%89%A520-339933.svg)](https://nodejs.org/)\n\n\n---\n\n## The 30-second pitch\n\n**GateTest is a single CLI plus a composite GitHub Action that runs 121 static-analysis modules against any codebase, then uses Claude to repair the findings it can.** It replaces SonarQube, Snyk, ESLint, Cypress, Lighthouse, axe, pa11y, and twenty-plus other tools with one config, one gate decision, and one report.\n\n**It is different because the cost trends to zero.** Deterministic AST and rule-based layers run first — these are free and ship the fix in milliseconds. Claude only runs on patterns nothing else has seen. Every Claude win is distilled into a reusable recipe, so the next time the same pattern appears anywhere in the network it is handled for free. The longer you run GateTest, the less of it is paid work.\n\n**What you get depends on the tier.** A pull request with the fixes, regression tests pinned to each fix, an architecture-shape critique, a cross-finding attack-chain analysis, and a CTO-readable executive summary — in whichever combination the tier you bought includes. One-time payment per scan via Stripe at checkout. No subscription, no auto-renew.\n\n---\n\n## Install & Usage — 30 seconds\n\n### GitHub Action — recommended for most users\n\nDrop this in `.github/workflows/gatetest.yml`:\n\n```yaml\nname: GateTest Quality Gate\non: [push, pull_request]\njobs:\n gate:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - uses: crclabs-hq/GateTest@v1.1.1\n with:\n suite: full\n auto-fix: ${{ github.event_name == 'pull_request' }}\n env:\n ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}\n```\n\nThe action is a composite — no Docker pull, no container build. It installs GateTest, runs the gate, and if `auto-fix: true` and `ANTHROPIC_API_KEY` is set, runs the AI repair loop on a blocking gate. See [`action.yml`](action.yml) for every input.\n\n**Your first full run passes.** Turning a gate on against an existing codebase would otherwise fail on years of backlog nobody wrote this week, so a full-repo run that finds no `.gatetest/baseline.json` snapshots what is already there and exits green. Commit that file and every run after it fails on **new** findings only — pull requests are judged on the files they change from the very first run. Details under [baseline mode](#onboarding-a-mature-repo--baseline-mode).\n\n### CLI — local development\n\n```bash\n# Install from npm:\nnpm install -g @gatetest/cli\ngatetest --suite quick\n\n# Or run against the current directory with no install:\nnpx github:crclabs-hq/GateTest --suite quick\n\n# Or clone and run from source:\ngit clone https://github.com/crclabs-hq/GateTest\ncd gatetest && npm install\nnode bin/gatetest.js --suite quick\n```\n\n### Pre-push sweep\n\nRun the full pre-merge sweep locally in one command:\n\n```bash\nnpm run sweep # ~30-60s — tests + build + gate + secrets + self-scan\n```\n\nThis runs the same seven checks that block a merge in CI. Verdict is green or red. Exit code is 0 or 1, matching CI exactly.\n\nFast path during iteration:\n\n```bash\nnpm run sweep -- --fast # skip tests + build, gate-only, ~3-5s\n```\n\nSee `gatetest sweep --help` for every flag.\n\n### Silencing a false positive — 10 seconds\n\nEvery scanner gets it wrong sometimes. When GateTest flags something you've judged safe, add one line to a `.gatetestignore` file at your repo root:\n\n```gitignore\n# Silence one rule from one module:\nsecrets:generic-api-key\n\n# Silence a whole module:\ndeadCode\n\n# Silence a rule everywhere it fires:\n*:trailing-whitespace\n\n# Scope a suppression to a path:\nsecrets:generic-api-key@tests/fixtures/**\n\n# Skip a path entirely:\nvendor/**\n```\n\nSuppressed findings are excluded from the gate decision and every failure count, but stay visible in a `suppressedChecks` list — nothing is silently hidden. Two more controls:\n\n- `gatetest --noise` — ranks your noisiest modules and prints the exact ignore line to copy. The same signal, aggregated across every opted-in scan, is published rule by rule at [gatetest.io/noise](https://gatetest.io/noise).\n- **Auto-softening** — a module you chronically dismiss stops blocking the gate on its own (never on thin evidence: it takes repeated dismissals at a high fire-rate).\n\n**The policy is reviewed as policy.** `.gatetest.json` and `.gatetestignore` are what\nevery later PR is judged by, so a PR that changes them says so: a suppression added\nto `.gatetestignore`, a module disabled, the gate set to report-only or the block\nthreshold raised in `.gatetest.json` each produce a `Gate policy changed` warning on\nthat PR — reported, never blocking, quiet on comments and on tightening. Every\nsigned report records the SHA-256 of both files (`gatetest verify-report` prints\nthem), so two reports that disagree can be told apart by policy, not only by\nengine.\n\nProject-wide options live in `.gatetest.json` (suites, per-module config, severity overrides) — run `gatetest --init` to scaffold one.\n\n### Onboarding a mature repo — baseline mode\n\nTurning a scanner on against a large existing codebase usually means drowning in a backlog you didn't write. GateTest's baseline mode grandfathers everything that exists today so the gate only ever fails on **new** findings — \"clean as you code.\"\n\n```bash\n# Snapshot every current finding into .gatetest/baseline.json — commit it:\ngatetest --baseline\n\n# From now on, normal runs pass on the pre-existing findings and only\n# block on NEW ones. Baselined findings stay visible, never hidden.\ngatetest --suite full\n```\n\nFix a baselined finding and it's gone for good; the count is tracked per file, so adding a *second* secret to a file that already had one baselined re-blocks the gate (you can't sneak a new problem in behind an old one). Refresh the snapshot after paying down debt with `gatetest --baseline`; delete `.gatetest/baseline.json` to see everything again.\n\n### Testing pages behind a login — authenticated crawl\n\nThe live crawler can carry a session so it reaches authed areas (`/dashboard/*`, account pages) instead of bouncing off the login redirect:\n\n```bash\n# A header (repeatable), a cookie, or an exported browser session —\n# values support ${ENV_VAR} so secrets stay out of committed config:\ngatetest --crawl https://app.example.com --crawl-header \"Authorization: Bearer ${TOKEN}\"\ngatetest --crawl https://app.example.com --crawl-cookie \"session=${SESSION}\"\ngatetest --crawl https://app.example.com --crawl-storage-state state.json\n```\n\nSession material is only ever sent to the target's own origin — never to third-party links, assets, or cross-origin redirects. Without a session, a crawl that hits a login wall tells you exactly which flag to add rather than silently skipping the protected pages. The hosted scanner at [gatetest.io](https://gatetest.io) accepts the same session auth.\n\n### Claude Code / MCP — give Claude eyes, ears & hands\n\nConnect GateTest directly to Claude Code (or any MCP-compatible AI) in one command:\n\n```bash\nclaude mcp add gatetest -- npx -y @gatetest/mcp-server\n```\n\n24 tools across five families:\n\n| Family | Tools | What it gives Claude |\n|--------|-------|----------------------|\n| **Engine** | `scan_local`, `run_module`, `fix_issue`, `verify_fix`, … | Scan + fix local code |\n| **👁 Eyes** | `capture_screenshot`, `get_visual_diff` | See the rendered page as a real image |\n| **👂 Ears** | `get_production_errors`, `run_live_checks` | Hear Sentry/Datadog/Rollbar errors + localhost runtime failures |\n| **🤝 Hands** | `verify_fix` | Hard ✅/❌ — prove the fix actually worked |\n| **🔬 Root Cause** | `resolve_stack_trace`, `blame_regression` | Resolve a minified stack trace to original file:line via source maps; find the git commit that introduced a specific line. Same engines are also CLI subcommands (`gatetest trace`, `gatetest blame`) — one implementation, both entry points |\n\nWorks with Claude Code, Cursor, Windsurf, Continue, and Cline. See [`packages/mcp-server/`](packages/mcp-server/) for the full tool reference and example prompts.\n\n### Website — no install at all\n\nVisit [gatetest.io/web](https://gatetest.io/web) and paste any URL. You get a free preview and a paid full report. For WordPress sites use [gatetest.io/wp](https://gatetest.io/wp).\n\n### Wire it into CI — GitHub, GitLab, or CircleCI\n\nDon't hand-write the pipeline. One command scaffolds a complete, conventional config:\n\n```bash\ngatetest --ci-init github # .github/workflows/gatetest.yml\ngatetest --ci-init gitlab # .gitlab-ci.yml\ngatetest --ci-init circleci # .circleci/config.yml\n```\n\nEach generated config gates the right thing at the right time rather than running\neverything everywhere: a **quick, diff-scoped** scan on merge requests and pull\nrequests, a **full** scan on the main branch, and a separate security stage. JUnit\nand SARIF are emitted to `.gatetest/reports/` and wired into the platform's native\ntest-reporting and artifact storage, so failures show up in the UI instead of only\nin the log.\n\nOn any other CI — Jenkins, Buildkite, Bitbucket, Drone — the CLI is the whole\nintegration:\n\n```bash\nnpx @gatetest/cli --suite full --junit --sarif\n```\n\nOnboarding an existing codebase? Pair this with **baseline mode** above so the gate\nonly fails on new findings.\n\n### Merge queues and monorepos\n\n**Merge queues.** The GitHub Action and the drop-in workflow handle the `merge_group`\nevent: each group is scanned diff-scoped against the *queue's* base (the event\npayload's `base_sha`, which the engine resolves through one shared base resolver —\nthe same one `--pr`, prSize and the fake-fix detector use, so no module measures a\ndifferent diff from another). Add `merge_group:` under `on:` in your workflow and\nnothing else changes.\n\n**Path filters.** In a monorepo, scope the gate to the packages it owns in\n`.gatetest.json`:\n\n```json\n{ \"paths\": { \"include\": [\"packages/api\", \"packages/shared/**\"], \"exclude\": [\"**/fixtures/**\"] } }\n```\n\nA bare directory means everything under it; `*` is one segment, `**` any depth;\nexclude wins. The filter applies at the one file walk every module shares, findings\nfrom modules with their own lookups are dropped at the runner, and every report says\nso — `Scope: .gatetest.json paths — include packages/api (3 finding(s) outside it\nnot shown)` — and carries it in the signed provenance. No `paths` key, no filter.\n\n### Replay a failing CI run locally\n\nReproduce any failing GitHub Actions run on your laptop in seconds:\n\n```bash\ngatetest replay https://github.com/owner/repo/actions/runs/12345\n```\n\nThis fetches the run, identifies which steps failed, and runs them locally\nagainst your current working tree. Output tells you whether the failure\nreproduces, doesn't reproduce (flaky CI), or hits a different error.\n\nAuthentication is optional — if you have a `GITHUB_TOKEN` set or `gh` CLI\ninstalled, replay can read private repo runs. Otherwise it uses the\nunauthenticated rate limit (60 req/hour, fine for a few replays).\n\nWhen a gate is blocked inside GitHub Actions, the log and the checks tab\nalready carry this command with the run's URL filled in.\n\n### Self-hosted and air-gapped\n\nThe engine is an npm package with four runtime dependencies that reads your tree and\nwrites to `.gatetest/`. By default the only thing that leaves the machine is the\nanonymized telemetry flush (module and rule ids with integer counts; opt out with\n`GATETEST_NO_TELEMETRY=1`); the AI-backed fix paths are opt-in and need\n`ANTHROPIC_API_KEY`. For an air-gapped runner, make that a stated promise:\n\n```bash\ngatetest --suite full --offline # or GATETEST_OFFLINE=1\n```\n\nUnder `--offline` nothing leaves the machine: no telemetry upload, no AI calls\n(`--fix` / `--auto-pr` are refused with a message, `gatetest fix` exits 2), no live\nAPI ping from `--doctor`. The console prints the mode, the summary carries\n`offline: true`, and the signed provenance records it — so a report produced inside\nthe perimeter can be verified outside it with `gatetest verify-report` and the key.\nThere is no licence server and no account; nothing expires.\n\n### Verify a scan report\n\nEvery JSON report (`.gatetest/reports/gatetest-report-latest.json`) carries a\n`provenance` block — engine version, runtime, which modules ran, which were\nskipped or deferred, the suppression state, and a SHA-256 digest of the\nfindings — and, when `GATETEST_REPORT_SIGNING_KEY` is set where the scan runs,\nan HMAC-SHA256 signature over it.\n\n```bash\ngatetest verify-report .gatetest/reports/gatetest-report-latest.json --key \"$GATETEST_REPORT_SIGNING_KEY\"\n```\n\n`VERIFIED` means the signature matches the provenance and the findings still\nmatch the digest — neither block can be edited without the other noticing.\nWithout a key the report says `signature.unsigned` explicitly rather than\ncarrying a decorative field.\n\n### Compliance evidence pack\n\n```bash\ngatetest --suite full --compliance\n```\n\nWrites `.gatetest/reports/gatetest-compliance-.json` and `.md`: every\nfinding filed under **OWASP Top 10 2021**, **SOC 2 Trust Services Criteria** and\n**CIS Controls v8**, control by control, with the raw results behind the tables\nand the same provenance + signature as the JSON report, so `gatetest verify-report`\nproves the pack was not edited after the scan. Three states, never two: a control is\n**PASS** only when a module mapped to it ran and found nothing; **NOT CHECKED**\nwhen no mapped module ran in that suite (and the report names which, and why);\n**NO MODULE** when nothing in the engine maps to it. Modules without a framework\nmapping are listed as unattributed rather than filed under a catch-all.\n\n### Root-cause a bug from the CLI\n\n```bash\n# Resolve a minified stack trace back to original file:line:column\ncat error.log | gatetest trace -\n\n# Find which commit introduced a specific line (read-only — never\n# checks out or mutates the working tree)\ngatetest blame src/app.js --line 42\n```\n\nBoth subcommands share the exact same engine as the MCP `resolve_stack_trace`\nand `blame_regression` tools — run them by hand or let Claude call them\nmid-fix-loop; the answer is identical either way. Run `gatetest trace --help`\nor `gatetest blame --help` for the full option list.\n\n---\n\n## The flywheel — why GateTest gets cheaper over time\n\n```\n ┌──────────────────────────┐\n CI BREAKS │ Failed workflow run │\n ──> └────────────┬─────────────┘\n │\n ┌────────────▼─────────────┐\n │ AI CI-fixer reads logs │\n │ + failing files │\n └────────────┬─────────────┘\n │\n ┌──────────────┼──────────────┐\n │ │ │\n ▼ ▼ ▼\n ┌────────┐ ┌────────┐ ┌────────┐\n │ AST │ → │ Rule │ → │ Recipe │ ─── ALL FREE ───\n └────┬───┘ └────┬───┘ └────┬───┘\n │ │ │ (none matched?)\n └─────────────┴─────────────┘\n │\n ▼\n ┌──────────────────────────┐\n │ Claude — paid, one shot │\n │ Result distilled into a │\n │ recipe for next time │\n └────────────┬─────────────┘\n │\n ▼\n ┌──────────────────────────┐\n │ PR opens with the fix │\n │ + regression test │\n └──────────────────────────┘\n```\n\n**First time we see a pattern: Claude. Every time after: free.** The longer you run GateTest, the cheaper it gets.\n\n---\n\n## What it replaces\n\nOne config, one bill, one gate decision. Twelve-plus tools dissolve into single CLI flags.\n\n| Their tool | GateTest module |\n| ------------------------------------------ | -------------------------------------------------- |\n| Snyk Code, Dependabot, npm audit | `security`, `dependencies` |\n| SonarQube | `codeQuality` + every other module |\n| ESLint, Stylelint | `lint` |\n| Cypress, BrowserStack, Sauce Labs | `e2e` |\n| Lighthouse | `performance` |\n| axe, pa11y | `accessibility` |\n| Percy, Chromatic | `visual` |\n| git-secrets, TruffleHog | `secrets`, `secretRotation` |\n| hadolint, dockle | `dockerfile` |\n| actionlint, zizmor, StepSecurity | `ciSecurity` |\n| tfsec, Checkov, Terrascan | `terraform` |\n| kube-score, kubeaudit, Polaris | `kubernetes` |\n| Stryker, Pitest | `mutation` |\n| broken-link-checker | `links` |\n| _(none — fragmented across ESLint rules)_ | `errorSwallow`, `nPlusOne`, `flakyTests` |\n| _(none — no static tool exists)_ | `redos`, `moneyFloat`, `logPii`, `tlsSecurity` |\n| _(none — runtime profilers only)_ | `resourceLeak`, `raceCondition`, `retryHygiene` |\n\n**Twelve-plus tools. One config. One bill.** Full module catalogue: run `node bin/gatetest.js --list` or read it on [gatetest.io](https://gatetest.io).\n\n---\n\n## Tiers and pricing\n\nScan tiers are one-time payments via Stripe at checkout — no auto-renew. Continuous and MCP are monthly subscriptions; manage or cancel them yourself at [gatetest.io/billing](https://gatetest.io/billing) (enter your checkout email, get a secure Stripe portal link by email — update your card, view invoices, change plan, or cancel). Refunds only at our discretion for scans that failed to start or crashed mid-way without producing a report (contact `hello@gatetest.ai`).\n\n| Tier | Price | What you get |\n| ----------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Quick Scan** | $29 | 4 modules — syntax, linting, secrets, code quality. Fastest path to a first signal. Scan-only — no auto-fix. |\n| **Full Scan** | $99 | The full engine suite (88 modules; mutation + chaos run via the GitHub Action or a nightly instead — they need a CI runner to execute your test suite, and mutation re-runs it once per mutant). Every scan prints what it deferred and where that work runs. SARIF + JUnit reports via the CLI / GitHub Action. Scan-only — auto-fix ships at the Scan + Fix tier. |\n| **Scan + Fix** | $199 | Everything in Full, plus a second-Claude pair-review critique on every fix and an architecture-shape design-observations report. |\n| **Forensic Scan** | $399 | Everything in Scan + Fix, plus real Claude diagnosis on every finding, cross-finding attack-chain correlation, board-ready CISO report (OWASP / SOC2 / CIS v8 / 30-60-90), and a CTO-readable executive summary. Mutation testing and chaos / fuzz pass are also available via the GitHub Action (`mutation: true` / `chaos: true`) — they need a CI runner to execute your test suite and a headless browser, so they ship with the Action rather than the website-only scan. |\n| **Continuous** | $49/mo | Scan every push via the GitHub App. Unlimited deterministic push scans plus a monthly Claude AI-review allowance. Fix PRs are a per-scan upsell. |\n| **MCP** | $29/mo | The **hosted** remote MCP endpoint — use GateTest from claude.ai web/mobile or locked-down machines, plus hosted scan history (`gtmcp_` key delivered by email after checkout). The **local** MCP server (`npx @gatetest/mcp-server`) is 100% free — every tool runs on your machine with your keys. |\n\nLive prices and Stripe checkout at [gatetest.io](https://gatetest.io).\n\n---\n\n## Honest limits\n\nGateTest is not magic. The things it does not yet do, said out loud:\n\n- **Headless-browser modules (`liveCrawler`, `runtimeErrors`, `explorer`, `chaos`) degrade gracefully on Vercel serverless.** Chromium cannot launch inside the function. The modules emit an info-level skip and the rest of the scan continues — full power requires the CLI, a worker, or local dev.\n- **Hosted website scans read up to 50 source files per scan** (prioritised by relevance). Most small-to-mid repos fit; a large monorepo gets a representative slice. The CLI and GitHub Action scan everything with no cap.\n\nThe full Known Issues table (with severity and status) lives in [CLAUDE.md](CLAUDE.md) — that file is the project's source of truth.\n\n---\n\n## Architecture\n\n**Static engine.** 121 modules, every one extending `BaseModule`. Each module is a self-contained scanner that emits checks at three severity levels (error blocks the gate, warning reports, info is informational). The runner is `EventEmitter`-based, supports parallel execution, diff-mode (`--diff` scans only git-changed files), watch mode, and five output formats (Console, JSON, HTML, SARIF for the GitHub Security tab, JUnit XML for any CI). The gate has four small runtime dependencies (`acorn`, `pngjs`, `pixelmatch`, and the MCP SDK) — `node bin/gatetest.js --list` runs anywhere Node 20+ runs.\n\n**Website and payments.** [gatetest.io](https://gatetest.io) is Next.js 16 with the App Router, Tailwind 4, and Stripe in per-scan upfront-charge mode. One-time payment per scan at checkout — no subscription, no auto-renew, no hold-then-capture flow. All scan state is persisted in Stripe metadata so the serverless functions stay stateless across requests — there is no shared in-memory state and no webhook is required for the critical user flow. The scan executes inside the function response and reports back directly.\n\n**AI layer.** Claude (Anthropic). On the GitHub Action the customer brings their own `ANTHROPIC_API_KEY` and pays Anthropic directly. On the website the key is managed and the cost is folded into the tier price. Every Claude success is distilled into a recipe by the flywheel orchestrator (see [`lib/`](lib/) and the AI CI-fixer at [`scripts/ai-ci-fixer.js`](scripts/ai-ci-fixer.js)) so subsequent runs on the same pattern are deterministic and free.\n\nThe codebase ships under MIT, the gate runs locally with no external calls, and every architectural decision is documented inline in [CLAUDE.md](CLAUDE.md).\n\n---\n\n## Real-repo proofs\n\nGateTest is dogfooded against itself on every push, and the team runs the full Forensic pipeline against external production codebases before shipping changes that touch the deeper tiers. The reports below are reproducible artifacts in this repo:\n\n- **AI CI-fixer end-to-end run** — full orchestrator path exercised (log → parse → Claude → patch → gate → commit → push → PR): [docs/proofs/ai-ci-fixer-real-run.md](docs/proofs/ai-ci-fixer-real-run.md)\n- **GateTest scanning itself** — quick-suite self-scan, 30 of 39 modules pass, 37 errors found and triaged: [docs/proofs/phase-1-self-scan.md](docs/proofs/phase-1-self-scan.md)\n- **Iterative fix loop on the live repo** — one-attempt fix on `src/runtime/alerts.js`, 8.5 seconds wall time, syntax gate green: [docs/proofs/phase-1-self-fix-real.md](docs/proofs/phase-1-self-fix-real.md)\n- **Forensic scan of Crontech.ai** — Bun + Turbo TypeScript monorepo, 754 errors found, 23 of 39 modules pass, two critical attack chains including a supply-chain CI takeover: [docs/proofs/phase-2-3-crontech-real-customer-grade.md](docs/proofs/phase-2-3-crontech-real-customer-grade.md)\n- **Forensic scan of Gluecron.com** — 649 errors and three chains (incl. an \"operational lock-in\" chain neither finding describes alone): [docs/proofs/phase-2-3-gluecron.md](docs/proofs/phase-2-3-gluecron.md)\n- **Pair-review and architecture annotator on the self-scan** — Phase 2 deliverables exercised end-to-end: [docs/proofs/phase-2-self-pair-review-and-architecture.md](docs/proofs/phase-2-self-pair-review-and-architecture.md)\n- **Full Forensic pipeline on the self-scan** — 12 of 12 findings diagnosed, four chains including a session-forgery vector: [docs/proofs/phase-3-self-nuclear.md](docs/proofs/phase-3-self-nuclear.md)\n\n---\n\n## Develop and contribute\n\n```bash\ngit clone https://github.com/crclabs-hq/GateTest\ncd gatetest\nnpm install\n(cd website && npm install)\nnode --test tests/*.test.js\nnode bin/gatetest.js --list\n```\n\nThe Bible — [CLAUDE.md](CLAUDE.md) — is required reading for contributors. It defines the architecture, the quality bar, the forbidden list, the protected platforms, and the authorization rules that apply to anything touching money, user data, or public-facing communication.\n\nBug reports and feature requests are welcome via [GitHub Issues](https://github.com/crclabs-hq/GateTest/issues). Small PRs that fix one thing and add a test are merged fastest. The pre-commit and pre-push hooks under [`src/hooks/`](src/hooks/) run the gate locally — running them before pushing keeps CI green.\n\n---\n\n## License\n\nMIT — see [LICENSE](LICENSE).\n\n---\n\n\nGateTest is built and maintained at gatetest.io.\nTalk to the team via the chat on the site. File bugs at GitHub Issues.\n\n", "bytes": 27042, "sha": "9f57a1df213abd512f71ec8636a4dff695302257e8ae651423c7a2a590d312cc", "repo_slug": "crclabs-hq/gatetest", "fonte": "repo", "truncated": false, "api": "https://agentalog.com/api/listings/mcp_ai_gatetest_www_gatetest_9befd1e7/readme" }