Skip to content
Back to search

supercov

Coverage, security and code quality for coding agents

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/supercorp-ai/supercov with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/supercorp-ai/supercov'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/supercorp-ai--supercov/badge.svg)](/listings/supercorp-ai--supercov)

HTML

<a href="/listings/supercorp-ai--supercov"><img src="/api/listings/supercorp-ai--supercov/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Measuring a project should not start by installing another language. The same binary, at the same version, from one release:

npx supercov -- npm test                                 # npm
uvx --from supercov-cli supercov -- pytest               # PyPI
gem install supercov && supercov -- bundle exec rspec    # RubyGems
cargo binstall supercov && supercov -- cargo test        # crates.io
go run github.com/supercorp-ai/supercov/cmd/supercov@latest -- go test ./...   # Go
brew install supercorp-ai/tap/supercov && supercov -- ./gradlew test           # Homebrew

`pip install supercov-cli` and `gem install supercov` install a wheel or gem that carries the binary for your platform; nothing is compiled. `cargo binstall` downloads that same binary from the GitHub release, while plain `cargo install supercov` builds it from source and needs Rust 1.95.

A Go project needs Go and nothing else. Like any `go run` with a version suffix it resolves by module path and ignores the `go.mod` in your current directory, so it neither needs nor touches your module.

Java and Kotlin have no registry of their own here, so a JVM project takes the binary directly -- Homebrew above, `npx` if Node is already present, or the platform archive from the [latest release](https://github.com/supercorp-ai/supercov/releases/latest). Maven and Gradle are driven as your test command, not as a plugin. Supercov adds the JUnit Platform launcher its measurement needs to the build file inside its own isolated workspace copy -- your `pom.xml` or `build.gradle` is never edited.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "supercov",
  3. "description": "Supercov plugins for Claude Code.",
  4. "owner": {
  5. "name": "Supercorp",
  6. "url": "https://supercorp.ai"
  7. },
  8. "plugins": [
  9. {
  10. "name": "supercov",
  11. "source": "./plugins/supercov",
  12. "description": "Coverage, security and code quality for coding agents."
  13. }
  14. ]
  15. }
README.md · README · 415 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ![Coverage, security and code quality for coding agents](https://raw.githubusercontent.com/supercorp-ai/supercov/main/supercov.jpg)
  2. **Coverage, security and code quality for coding agents**
  3. **Supercov tells your coding agent what to fix and what to test.** It scores your code quality and flags security risks with [Jev](https://typesafe.ai), runs the test command you already use, and turns uncovered paths into small, actionable queries. Your agent picks a target, writes a focused test or a focused refactor, proves what improved, and keeps going.
  4. Paste this to your coding agent to start:
  5. ```text supercov-prompt
  6. Measure code quality with npx supercov.
  7. ```
  8. Scoring needs a [TypeSafe AI](https://typesafe.ai) API key, and your coding agent will usually ask you for it. It costs about a cent per megabyte of source. Coverage needs no account, config file, import, custom reporter, or hosted service. Supercov is local, free, open source, and MIT licensed.
  9. [Website](https://supercov.com) · [Documentation](https://supercov.com/docs) · [npm](https://www.npmjs.com/package/supercov) · [GitHub](https://github.com/supercorp-ai/supercov) · [Discord](https://discord.gg/CudcAH53yF)
  10. Supported languages: [JavaScript](https://supercov.com/docs/javascript) · [TypeScript](https://supercov.com/docs/javascript) · [Rust](https://supercov.com/docs/rust) · [Python](https://supercov.com/docs/python) · [Ruby](https://supercov.com/docs/ruby) · [Go](https://supercov.com/docs/go) · [Java](https://supercov.com/docs/java) · [Kotlin](https://supercov.com/docs/kotlin).
  11. In Claude Code, Codex and Gemini CLI you can also [install it as a plugin](#give-supercov-a-job).
  12. Supported by [Supercorp](https://supercorp.ai).
  13. [Agent workflow](https://supercov.com/docs/agent-loop): ask your coding agent
  14. to add a test in your own project, with a recorded example to follow along.
  15. ## Score your code
  16. ```bash
  17. export TYPESAFE_API_KEY=... # get one at https://typesafe.ai
  18. npx supercov quality
  19. ```
  20. No arguments and no configuration. It finds your source, asks Jev a set of
  21. yes/no questions about each file, and does the arithmetic itself, so every part
  22. of a score is a claim you can check against the file.
  23. ```
  24. Quality weak (3.8/10) over 163 files.
  25. 11 good, 52 fair, 100 weak.
  26. Weakest:
  27. weak runtime/python/supercov_runtime.py
  28. long_method 0.96, deep_nesting 0.92, complex_conditional 0.89, +9 more
  29. weak crates/supercov-engine/src/assertion_store.rs
  30. long_method 0.96, deep_nesting 0.91, complex_conditional 0.86, +8 more
  31. ```
  32. Narrow to what fired, read one file in full, or review a change:
  33. ```bash
  34. npx supercov quality gaps
  35. npx supercov quality file src/server.ts
  36. npx supercov quality patch # your uncommitted work, or your branch
  37. npx supercov quality patch --annotate github # workflow annotations, no token
  38. ```
  39. Jev charges for what it reads and nothing for what it writes, so a megabyte of
  40. source costs a little over a cent. Answers are cached by content, so a second
  41. run pays only for what changed. See [Understanding quality](docs/quality.md).
  42. ## Find security risks
  43. ```bash
  44. npx supercov security
  45. npx supercov security patch # what a change introduced
  46. ```
  47. Twelve security checks asked of every file with the same key, from injection
  48. and secrets in source to paths and redirects taken from a request. Nothing is
  49. averaged: a file is clean, or it names what fired, with the line and the code on
  50. it where Jev confirms one. See [Security surface](docs/security.md).
  51. ## Start with the suite you already have
  52. ```bash
  53. npx supercov -- npm test
  54. ```
  55. Other ways in, all the same binary at the same version: `brew install
  56. supercorp-ai/tap/supercov`, or for a Go project `go run
  57. github.com/supercorp-ai/supercov/cmd/supercov@latest`.
  58. Everything after `--` is your test command. Supercov runs it without changing your source, tests, runner configuration, or normal build output.
  59. Then read the result and ask what is still uncovered:
  60. ```bash
  61. npx supercov runs latest
  62. ```
  63. ```
  64. run run_7fc676ba671d42be
  65. command: npm test
  66. Coverage
  67. Lines 100.00% (5/5)
  68. Branches 66.67% (4/6)
  69. MC/DC 33.33% (1/3)
  70. ```
  71. ```bash
  72. npx supercov runs latest gaps --limit 10
  73. ```
  74. ```
  75. Coverage gaps — only files with unresolved obligations
  76. src/pricing.js
  77. uncovered: lines 0 statements 1 functions 0 branch outcomes 0 MC/DC conditions 2
  78. ```
  79. After your agent adds a test, rerun the complete suite and prove the gain:
  80. ```bash
  81. npx supercov -- npm test
  82. npx supercov diff <previous-run-id> latest
  83. ```
  84. Want to hand the evidence to a person? Generate one private, interactive file:
  85. ```bash
  86. npx supercov report
  87. ```
  88. The report opens in your browser with up to ten recent runs in a visual history.
  89. Selecting a run compares it with the previous snapshot automatically. It has no
  90. server, external assets, account, or file picker. It is written to
  91. `.supercov/reports/`, where the store's own `.gitignore` keeps it out of git.
  92. You can attach that one file directly to a pull request; a reviewer downloads
  93. it and double-clicks it.
  94. Use whichever complete test command the repository already trusts:
  95. ```bash
  96. npx supercov -- npx playwright test
  97. npx supercov -- pnpm test:e2e
  98. npx supercov -- cargo test
  99. npx supercov -- cargo nextest run
  100. npx supercov -- pytest
  101. npx supercov -- python -m unittest
  102. npx supercov -- bundle exec rspec
  103. ```
  104. ## See what the tests assert
  105. Coverage says which code ran; assertion coverage says which of it the tests
  106. would catch breaking. Supercov asks [Jev](https://typesafe.ai), test by test,
  107. whether changing each statement the test ran would make it fail:
  108. ```sh
  109. npx supercov -- npm test
  110. TYPESAFE_API_KEY=... npx supercov runs latest assertions assess
  111. npx supercov runs latest assertions # the share asserted and what is not
  112. ```
  113. Answers are reused across runs whenever the question is the same, so after a
  114. commit only what changed is asked again. Every language Supercov measures. See
  115. [assertion coverage](docs/assertions.md).
  116. ## Give Supercov a job
  117. Paste one of these prompts into Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, or any coding agent that can run terminal commands.
  118. Or install the agent skill, and your agent reaches for Supercov on its own when you ask for tests, coverage, refactoring or a security scan. In Claude Code:
  119. ```text
  120. /plugin marketplace add supercorp-ai/supercov
  121. /plugin install supercov@supercov
  122. ```
  123. In Codex:
  124. ```bash
  125. codex plugin marketplace add supercorp-ai/supercov
  126. codex plugin add supercov@supercov
  127. ```
  128. In Gemini CLI:
  129. ```bash
  130. gemini extensions install https://github.com/supercorp-ai/supercov
  131. ```
  132. For Cursor, GitHub Copilot and other agents that read skills: `npx skills add supercorp-ai/supercov`.
  133. The Claude Code plugin and the Gemini CLI extension also add four commands you can type:
  134. | Command | What it does |
  135. | --- | --- |
  136. | `/supercov:coverage [test command]` | Writes one test for code no test reaches, and reports coverage before and after |
  137. | `/supercov:security [patch]` | Scans the repository, or a change, for security vulnerabilities |
  138. | `/supercov:quality [patch]` | Ranks files by code smells, or checks what a change introduced |
  139. | `/supercov:review [--base ref]` | Checks a branch or uncommitted change for security and quality problems |
  140. ### Write the first useful test
  141. ```text
  142. Measure code coverage with `npx supercov`. Use the coverage evidence to choose
  143. one useful missing test. Only edit tests. Run the repository's complete test
  144. suite through Supercov again and report what improved.
  145. ```
  146. ### Use leftover tokens on coverage
  147. ```text
  148. Measure code coverage with `npx supercov` and write tests til 100%. Only edit
  149. tests. Keep going while useful gaps remain.
  150. Run the repository's complete test suite through Supercov. Use
  151. `npx supercov runs latest gaps --limit 5` to choose one useful target at a
  152. time. Write a focused test, rerun the same complete suite, and use
  153. `npx supercov diff <previous-run-id> latest` to verify the gain.
  154. Never weaken assertions or change application code to make coverage easier.
  155. Stop if the suite fails, the evidence is incomplete, or no useful gaps remain.
  156. ```
  157. ## The agent loop
  158. 1. **Run the real suite.** Supercov executes the command after `--` in an isolated workspace.
  159. 2. **Find one useful gap.** Short, paginated queries show uncovered files, lines, branches, decisions, and value paths without loading a large HTML report into context.
  160. 3. **Write one focused test.** The coding agent changes tests—not application code or coverage configuration.
  161. 4. **Rerun and prove the gain.** `diff` shows exactly what the new test covered.
  162. 5. **Repeat while useful gaps remain.** Failed tests, incomplete evidence, or ambiguous scope stay visible instead of being rounded away.
  163. Supercov supplies the coverage signal and evidence. It does not host, schedule, or replace your coding agent.
  164. ## Use leftover tokens on coverage
  165. Before a reset—or overnight—turn idle agent time into coverage that stays with the repository. Each pass closes a small number of useful gaps and finishes with evidence that the tests still pass and coverage improved.
  166. ## Use it in a software factory
  167. Add Supercov as a repeatable quality loop in an automated software factory. Your factory schedules the work; Supercov gives each agent a bounded next task and an immutable record of the result.
  168. Every pass runs the real suite, chooses an uncovered path, writes a focused test, reruns, and proves the gain. Fresh executable evidence lets agents keep iterating around the clock while failed tests and regressions stop the loop before they ship.
  169. ## Coverage agents can act on
  170. From lines and branches to MC/DC, every gap becomes a concrete test target. Supercov measures:
  171. - lines, statements, functions, and branches;
  172. - MC/DC independence witnesses;
  173. - optional-chain, default-value, and logical-assignment paths;
  174. - `try`/`catch` and zero-iteration control-flow paths; and
  175. - per-test provenance where the runner exposes exact test boundaries.
  176. The denominator comes from source structure before the run, so adding or removing tests cannot silently change what 100% means. Ambiguous source scope, uninstrumented code, and missing evidence remain visible as completeness blockers.
  177. ## Install for your language
  178. Measuring a project should not start by installing another language. The same binary, at the same version, from one release:
  179. ```bash
  180. npx supercov -- npm test # npm
  181. uvx --from supercov-cli supercov -- pytest # PyPI
  182. gem install supercov && supercov -- bundle exec rspec # RubyGems
  183. cargo binstall supercov && supercov -- cargo test # crates.io
  184. go run github.com/supercorp-ai/supercov/cmd/supercov@latest -- go test ./... # Go
  185. brew install supercorp-ai/tap/supercov && supercov -- ./gradlew test # Homebrew
  186. ```
  187. `pip install supercov-cli` and `gem install supercov` install a wheel or gem that carries the binary for your platform; nothing is compiled. `cargo binstall` downloads that same binary from the GitHub release, while plain `cargo install supercov` builds it from source and needs Rust 1.95.
  188. A Go project needs Go and nothing else. Like any `go run` with a version suffix it resolves by module path and ignores the `go.mod` in your current directory, so it neither needs nor touches your module.
  189. Java and Kotlin have no registry of their own here, so a JVM project takes the binary directly -- Homebrew above, `npx` if Node is already present, or the platform archive from the [latest release](https://github.com/supercorp-ai/supercov/releases/latest). Maven and Gradle are driven as your test command, not as a plugin. Supercov adds the JUnit Platform launcher its measurement needs to the build file inside its own isolated workspace copy -- your `pom.xml` or `build.gradle` is never edited.
  190. ## Supported languages
  191. | Language | Status | Install | Start with |
  192. | --- | --- | --- | --- |
  193. | [JavaScript](https://supercov.com/docs/javascript) | Available | nothing, `npx` fetches it | `npx supercov -- npm test` |
  194. | [TypeScript](https://supercov.com/docs/javascript) | Available | nothing, `npx` fetches it | `npx supercov -- npm test` |
  195. | [Rust](https://supercov.com/docs/rust) | Available | `cargo install supercov` | `supercov -- cargo test` |
  196. | [Python](https://supercov.com/docs/python) | Available | `python -m pip install supercov-cli` | `supercov -- python -m pytest` |
  197. | [Ruby](https://supercov.com/docs/ruby) | Available | `gem install supercov` | `supercov -- bundle exec rspec` |
  198. | [Go](https://supercov.com/docs/go) | Available | nothing, `go run` fetches it | `go run github.com/supercorp-ai/supercov/cmd/supercov@latest -- go test ./...` |
  199. | [Java](https://supercov.com/docs/java) | Available | `brew install supercorp-ai/tap/supercov` | `supercov -- mvn test` |
  200. | [Kotlin](https://supercov.com/docs/kotlin) | Available | `brew install supercorp-ai/tap/supercov` | `supercov -- ./gradlew test` |
  201. | Zig | Coming soon | — | — |
  202. | PHP | Coming soon | — | — |
  203. | C | Coming soon | — | — |
  204. The `npx` path requires Node.js 22 or newer; the other installs need no Node. Rust support currently uses Rust 1.95; cargo-nextest 0.9.138 and newer are supported. Python support requires CPython 3.9 or newer and measures pytest and unittest runs. Ruby support requires Ruby 3.3 or newer (3.4 or newer for full measurement) and measures RSpec, Minitest, test-unit and Cucumber runs. Go support requires Go 1.22 or newer and measures `go test`. Java and Kotlin support requires a JDK 17 or newer with Maven or Gradle, and measures every JUnit Platform engine -- JUnit 5, JUnit 4 through Vintage, Kotest and Spock -- as well as TestNG.
  205. ## Supported operating systems and architectures
  206. The CLI is a single native binary. `npx supercov` selects the build for the machine it runs on; nothing is compiled during installation.
  207. | Operating system | Architectures | Notes |
  208. | --- | --- | --- |
  209. | macOS | arm64 (Apple silicon), x64 (Intel) | macOS 11 or newer |
  210. | Linux | arm64, x64 | glibc 2.28 or newer (Debian 10, Ubuntu 18.10, RHEL 8 and later), or musl (Alpine); chosen automatically |
  211. | Windows | arm64, x64 | Windows 10 or newer |
  212. JavaScript, TypeScript, Python, Ruby, Rust, Go, Java and Kotlin suites are verified on Linux, macOS and Windows -- CPython 3.9 through 3.14 (on arm64 Windows, 3.9 and 3.10 as the x64 builds, since python.org publishes no arm64 build before 3.11), Ruby 3.3, 3.4 and 4.0, and Go 1.22, 1.25, 1.26 and 1.27 on every one, and JDK 17 and 21 on every one that has them (Temurin publishes no 17 for arm64 Windows, so that pairing is 21 alone). Containers, VMs, and remote executors run the same Linux builds. Every release publishes the same binaries to npm, PyPI (`supercov-cli`, a wheel per platform) and RubyGems (`supercov`, a gem per platform except arm64 Windows, which Ruby has no platform for), and the source to crates.io (`supercov`).
  213. ## Supported test suites
  214. Supercov uses exact per-test attribution where an adapter is available. For other supported runners, it reports aggregate structural coverage instead of guessing which test covered a path.
  215. | Runner | Coverage attribution |
  216. | --- | --- |
  217. | Playwright | Exact per test, worker, retry, outcome, action, and assertion phase |
  218. | Vitest | Exact per test, with setup execution kept separate |
  219. | Jest | Exact per test, including parameterized tests |
  220. | `node:test` | Exact per test |
  221. | Mocha | Exact per test and retry, `--parallel` included |
  222. | AVA | Exact per test, concurrent tests included |
  223. | node-tap 15 and newer | Exact per subtest |
  224. | Cargo's standard libtest runner | Exact test, attempt, and passing-assertion identity |
  225. | rustdoc doctests | Exact per doctest |
  226. | cargo-nextest | Exact test, attempt, retry, and binary identity |
  227. | RSpec | Exact example and before/example/after phase identity |
  228. | Minitest and test-unit | Exact test and setup/test/teardown identity |
  229. | Cucumber | Exact scenario and hook-phase identity |
  230. Supercov works with Vite, Next, Turbopack, Webpack, esbuild, SWC, and projects with no build step. One command can collect evidence from several supported runners into a single run.
  231. See [Supported languages and test suites](https://supercov.com/docs/supported-suites) for exact compatibility and attribution boundaries.
  232. ## Read the result
  233. ```bash
  234. # Recent runs and the latest summary
  235. npx supercov runs --limit 5
  236. npx supercov runs latest
  237. # The most useful open coverage obligations
  238. npx supercov runs latest gaps --limit 10
  239. # Details for a file or source location
  240. npx supercov runs latest file app/checkout/session.ts
  241. npx supercov runs latest decision app/checkout/session.ts:64
  242. npx supercov runs latest line app/checkout/session.ts:64
  243. # What changed between two runs
  244. npx supercov diff <previous-run-id> latest
  245. # A portable interactive report for a person
  246. npx supercov report
  247. ```
  248. Collections accept `--limit` and `--offset` and print a copyable next-page command. Machine-readable output is available with `--json` when an integration needs it.
  249. ## Comment on pull requests
  250. In GitHub Actions, one step runs your tests and tells the pull request which
  251. changed lines no test ran:
  252. ```yaml
  253. permissions:
  254. contents: read
  255. pull-requests: write
  256. steps:
  257. - uses: actions/checkout@v6
  258. - run: npm ci
  259. - uses: supercorp-ai/supercov@v4
  260. with:
  261. command: npm test
  262. ```
  263. It works with every supported language, keeps one comment up to date, marks the
  264. lines in the diff, and can fail the job below a floor (`min-changed-lines: 90`).
  265. No account, no upload token and no server: the report never leaves the runner.
  266. See [Comment on a pull request](docs/cli.md#comment-on-a-pull-request).
  267. ## Local, private, and zero-edit
  268. Everything Supercov writes lives under one hidden `.supercov/` directory: run evidence in `.supercov/runs/<run-id>/` and the isolated build cache in `.supercov/workspaces/`. It ignores itself in Git, so there is nothing to add to your `.gitignore`.
  269. The Supercov CLI does not contact a Supercov service during a coverage run. Package tools such as `npx` may contact the npm registry to download Supercov when it is not already cached.
  270. Supercov does not rewrite your source files, tests, imports, reporter list, runner configuration, dependency tree, or normal build output. An existing user-created `supercov/` directory is never adopted.
  271. ```bash
  272. npx supercov runs clean --dry-run # preview cleanup
  273. npx supercov runs clean --keep 20 # keep the 20 newest runs
  274. npx supercov runs clean # remove all runs and the build cache
  275. ```
  276. ## Documentation
  277. - [Getting started](https://supercov.com/docs/getting-started)
  278. - [Understanding quality](https://supercov.com/docs/quality)
  279. - [Agent workflow](https://supercov.com/docs/agent-loop)
  280. - [Understanding assertions](docs/assertions.md)
  281. - [Troubleshooting](https://supercov.com/docs/troubleshooting)
  282. - [CLI reference](https://supercov.com/docs/cli)
  283. - [Supported languages and test suites](https://supercov.com/docs/supported-suites)
  284. - [Understanding coverage](https://supercov.com/docs/coverage-model)
  285. - [Runs and evidence](https://supercov.com/docs/evidence)
  286. - [Portable HTML reports](https://supercov.com/docs/reports)
  287. - [Files, privacy, and cleanup](https://supercov.com/docs/workspace-isolation)
  288. - [Trusting a result](https://supercov.com/docs/verification)
  289. - [Speed and storage](https://supercov.com/docs/performance)
  290. ## Free and open source
  291. [MIT licensed](LICENSE). Inspect, extend, and run it anywhere.
  292. ## Community
  293. Ask questions, share what you measured, and talk to the people building Supercov on [Discord](https://discord.gg/CudcAH53yF).
  294. ## Contributors
  295. - [@DaVinciTachyon](https://github.com/DaVinciTachyon)
  296. - [@Uhbif2](https://github.com/Uhbif2)
  297. - [@maik-intellicoach](https://github.com/maik-intellicoach)
  298. - [@untitaker](https://github.com/untitaker)
  299. - [@artile](https://github.com/artile)
  300. - [@Fidasek009](https://github.com/Fidasek009)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.