Open source · MIT · Go · single binary

Code quality control,
enforced at every commit.

Go Quality Gate is a single binary with no runtime dependencies that detects your project's languages and runs the right linters, formatters and security checks on every commit or push. Point it at a repo with Go, Python, Node.js — or all three at once.

Go install
$go install github.com/dmux/go-quality-gate/cmd/quality-gate@latest
Docker
$docker run --rm ghcr.io/dmux/go-quality-gate:latest --version

Prefer a binary? Grab the latest release for your OS, then run quality-gate --init && quality-gate --install.

Go Quality Gate gopher mascot
Detects & runs
Go Python Node.js / TypeScript Docker GitHub Actions MCP agents
4+languages auto-detected in the same repository
20+linters, formatters & security tools orchestrated
0runtime dependencies — one static binary
$0cost — fully local, no account, no telemetry
Why Go Quality Gate

Everything a quality gate needs. Nothing it doesn't.

No Python, no Node.js runtime, no account — just a binary that knows how to run the tools you already trust, and get out of the way.

Single binary

Zero runtime dependencies — no Python, Node.js or external tools required. Download it and run it.

Zero deps

Automatic setup

Detects your project's languages and installs and configures the right quality tools automatically.

Auto-detected

Multi-language support

Go, Python, JavaScript, TypeScript and more — in the same repository, with per-language detection.

Language-agnostic

Enhanced observability

Spinners, execution timing, real-time feedback, and structured JSON output ready for CI/CD.

Real-time

Built-in security

Automatic secret scanning with Gitleaks plus Python dependency audit with pip-audit, wired straight into your commit and push workflow to prevent leaks.

Gitleaks + pip-audit

Native performance

Instant execution without interpreters — built with Go for maximum speed and efficiency.

Compiled

Auto-fix support

Automatically fixes formatting and linting issues in place with a single --fix flag.

--fix

CI/CD ready

Clean JSON output and predictable exit codes, built for automation pipelines and GitHub Actions.

JSON output

Git hooks integration

Seamless integration with pre-commit and pre-push hooks — quality checks run themselves.

pre-commit

Commit watermark

Commits that passed the gates carry a Quality-Gate trailer bound to their exact content.

New in v1.3.0

CI enforcement

quality-gate verify and a ready-made GitHub Action reject commits that skipped the gates.

Required check

Doctor & global install

doctor spots missing or tampered hooks; --install --global gates every repo on a machine.

Setup health
New in v1.3.0

Know which commits actually passed the gate.

Git hooks can be skipped with --no-verify. Now every commit that passed your checks is watermarked with a trailer bound to its exact content — and CI can refuse the ones that were not.

  • pre-commit runs your checks. A failure blocks the commit; on success, the hash of the staged content and of quality.yml is stored.
  • You write the message — with -m or your editor, as usual.
  • commit-msg confirms nothing changed since the checks ran and appends the Quality-Gate trailer.
  • CI verifies every commit of the pull request with quality-gate verify and re-runs the checks.
terminal
# once per repository: pre-commit, commit-msg and pre-push
quality-gate --install
quality-gate doctor

git commit -m "feat: add login"
# ✅ Gitleaks passed (41ms)
# 🔏 Commit watermarked by quality-gate.

git log -1 --format='%(trailers)'
# Quality-Gate: v1.4.0; tree=db228f6d…; config=sha256:4feac6c2…; checks=3/3

quality-gate verify --range origin/main..HEAD
# ✅ 85490328cede attested
# All 1 commit(s) passed the quality gate.
SituationWhat happens
git commit --no-verifyNo hook runs, so the commit has no watermark. verify reports missing.
QG_SKIP="prod hotfix" git commitChecks are skipped, but the commit records Quality-Gate-Skipped: prod hotfix. Accepted only with --policy allow-skip.
git commit --amendHooks run again and the watermark is replaced. With --no-verify, the old one no longer matches: tree-mismatch.
Rebase or cherry-pick that changes contentThe old watermark no longer matches (tree-mismatch). Recommit with hooks enabled.
Staged files change after the checksNo watermark, with a warning. Commit again to re-run the checks.
Commit made by an AI agent via MCPrun_quality_checks records the watermark too.

The watermark stops casual bypasses and leaves an audit trail, but a trailer can be typed by hand. Make the quality-gate CI job a required status check — it re-runs the gates, and that is what makes them mandatory. See the usage guide for the full walkthrough.

New in v1.2.3

See your quality habits, not just pass/fail.

Every run, and every --fix, is appended to a local history log. Two new commands turn that history into something you'll actually want to look at — with nothing ever leaving your machine.

  • Streaks. Days since the build last broke, tracked per hook type.
  • Achievements. Unlockable milestones for consistency and auto-fixing.
  • Quality evolution. A 7/30-day chart of your pass rate, right in quality-gate ui.
  • Slowest & flakiest hooks. A leaderboard built from real run durations and failures.
Go Quality Gate local web dashboard showing a 21-day streak, a quality-evolution chart, slowest/flakiest hooks, and achievements
Zero surprises

One binary, five things it does well.

The same engine backs the CLI, the Git hooks, CI and the MCP server — so what you see here is exactly what runs in each of them.

terminal
# 1. Download the binary for your platform (or `go install`, see Installation)
curl -fsSL -o quality-gate https://github.com/dmux/go-quality-gate/releases/latest/download/quality-gate-linux-amd64
chmod +x quality-gate && sudo mv quality-gate /usr/local/bin/quality-gate

# 2. Initialize — detects your languages and writes quality.yml
cd your-project
quality-gate --init

# 3. Install the Git hooks (pre-commit, commit-msg, pre-push) and check them
quality-gate --install
quality-gate doctor

# 4. That's it — checks run automatically and the commit is watermarked
git commit -m "feat: new feature"

# Once you've run it a few times:
quality-gate stats   # streaks, achievements, time saved
quality-gate ui      # local web dashboard
How it works

One binary, from your commit hook to your dashboard.

A single Go process detects your languages, runs the right hooks, and appends every result to a local history log — which is all the terminal stats and the web dashboard read from.

INPUTS quality.ymlyour tools & hook config Git hookspre-commit · pre-push CLI flags--fix · --output=json CI pipelineGitHub Actions and friends GO QUALITY GATE · ONE PROCESS quality-gate single Go binary Language & tool detection picks the right hooks Hook runner lint · format · scan · fix Local history log .git/quality-gate/*.jsonl OUTPUTS Terminal + JSONfor humans and CI statsstreaks & achievements uilocal web dashboard mcptools for AI agents
For AI agents

Give an agent a quality gate it can drive.

quality-gate mcp starts a real Model Context Protocol server over stdio, built on the official mark3labs/mcp-go SDK (v0.56.0). It reports the binary's own version (v1.2.3) as its MCP protocol version, and every tool call runs through the exact same QualityGateService the CLI and Git hooks use — not a wrapper, not a re-implementation.

  • run_quality_checks(hookType)runs every hook of that type and returns, per hook: command, SUCCESS/FAILURE status, duration and captured output
  • run_auto_fix(hookType)runs each hook's fix_command for that type and reports whether the fixes were applied

Both take the same hookType your quality.yml already defines — pre-commit, pre-push, or anything you've named — so an agent's result is exactly what a human running the binary would have seen.

register + use
# Start the server over stdio
quality-gate mcp

# Point your client at it — .mcp.json (Cursor), Claude
# Desktop's config, or any client that speaks MCP over stdio:
#   { "mcpServers": { "go-quality-gate":
#       { "command": "./quality-gate", "args": ["mcp"] } } }

# Then just ask:
#   "Run the pre-commit checks and auto-fix anything that fails."

# The agent calls, with no glue code:
#   run_quality_checks({"hookType": "pre-commit"})
#   -> "All quality checks passed successfully.
#
#       Hook: gofmt Check
#       Command: gofmt -l .
#       Status: SUCCESS
#       Duration: 42ms
#       ..."
#
#   run_auto_fix({"hookType": "pre-commit"})
#   -> "Auto-fix commands executed successfully."
Ecosystem

Every tool it knows how to run.

Detected automatically per language — and anything else is one quality.yml entry away.

EcosystemStatusTools
GoBuilt-ingofmt, goimports, golangci-lint, go vet, gosec
PythonBuilt-inruff, black, mypy, pytest, pip-audit
Node.jsBuilt-inprettier, eslint, npm audit, tsc
UniversalBuilt-ingitleaks, shellcheck, hadolint, yamllint
CustomConfig-onlyAny command-line tool that returns a proper exit code — wire it in through quality.yml
Straight talk

What Go Quality Gate is not.

Deliberate design decisions, not a backlog. It targets one job: run the right tools, locally, at the right time.

Not a linter itself

It orchestrates gofmt, ruff, eslint, gitleaks and friends — it doesn't reimplement them.

Not a hosted service

It runs where you run it: in a local hook, or as a step in your own CI. There's no server to sign up for.

Not opinionated about tools

Any tool with a command and an exit code can be wired into quality.yml.

No telemetry

stats and ui read a local JSONL log. Nothing is ever sent anywhere.

Being local by default is the point — a quality gate you have to trust with your source code shouldn't also ask you to trust it with a network connection.

Quality checks that run before you even push.

Free and MIT-licensed. No account, no API key, no cloud bill — just a binary and one YAML file.