Supercov
Give coding agents verifiable quality scores and precise coverage gaps to fix one useful target at a time.
Per-dimension scores and reasoning
Coverage is described as running in an isolated workspace without rewriting project files, and the shown CI grants only contents: read. However, the tool executes a user-supplied test command, while quality scoring sends source content to the external Jev/TypeSafe AI service, so least privilege is not comprehensive. The README distinguishes local coverage, package-manager network access, and the paid quality service, but does not specify uploaded fields, retention, deletion, or key-protection practices. Cleanup has a dry-run and retention option, yet there is no built-in rollback or per-edit confirmation for tests written by an agent. Dependencies mix exact pins with broad ranges, workflow actions use version tags rather than commit digests, and no lockfile, vulnerability scan, or supply-chain policy is supplied. Repository, organization, issue tracker, and contributor copyright attribution are present, but publisher identity remains unknown and responsibility is not tied to named maintainers.
The README, ecosystem manifests, CI workflows, and example broadly agree on version 1.0.1, invocation patterns, and the core test loop, with extensive static test scripts. A deduction applies because the Python metadata says Pre-Alpha while the documentation presents broad multi-language and multi-platform availability, creating tension about maturity. Dependencies and environment requirements are detailed and platform packages share a version, but registries, an external API, test frameworks, and several language toolchains remain availability dependencies without documented degradation behavior. The loop is said to stop on failed tests, incomplete evidence, or ambiguous scope, but no implemented error-message code or representative failure output is included, so failure handling is adequate rather than thorough.
The material directly addresses interactive coding agents, leftover-token or overnight loops, and automated software factories, with distinct quality, coverage, and assertion-mapping scenarios. Boundaries are explicit: Supercov supplies signals and evidence but does not host, schedule, or replace the agent, and account/network requirements differ between quality and coverage. Copyable prompts precisely constrain edits to tests, define stop conditions, select bounded targets, and require reruns and diffs. Detailed matrices cover languages, runners, operating systems, architectures, minimum versions, installation channels, and attribution boundaries, justifying full scores here.
The README has strong information hierarchy, progressive command examples, documentation links, and support matrices. Installation covers npm, PyPI, RubyGems, Cargo, Go, Homebrew, and release archives with prerequisites. Naming, module paths, and version 1.0.1 are consistent across Cargo, npm, and native optional packages. Examples are substantial and the tutorial has a three-platform workflow, but no actual FAQ content is supplied and the linked troubleshooting material is not included. Limitations, attribution differences, completeness blockers, and coming-soon languages are explicit. The full MIT text agrees with all manifests. A version and bump script exist, but no changelog, release history, or migration guidance is provided. An issue tracker and Supercorp support statement create an update path, though the copyright names only contributors and no specific maintainer or response commitment is identified.
Outputs are concise, paginated, and optionally JSON, and can resolve files, lines, decisions, gaps, and run-to-run differences; the examples show artifacts an agent could consume directly. Claimed marginal value includes structural gap queries, MC/DC, per-test attribution, assertion maps, and immutable run records, but those broad benefits are largely self-described and the supplied worked example covers only one small session branch. Cost disclosure includes an approximate per-megabyte quality charge, content caching, and free local coverage, but the supplied material contains no benchmarks, representative runtime overhead, or storage-growth measurements. Marginal value and cost-benefit therefore receive solid but not full scores.
Quality findings are described as traceable to files and questions, while coverage can be queried by run, source location, and diff; workflows, test scripts, and before/after tutorial tests corroborate part of the narrative. Broad claims about all languages, platforms, exact attribution, and identical cross-registry binaries are not individually backed by included implementation code, artifact digests, or test results, and CI configuration alone does not prove passing execution. Fact and inference are separated particularly well: the documentation labels assertion scoring as agent-assessed, distinguishes aggregate from exact attribution, separates the external quality service from local coverage, and preserves incomplete evidence as a blocker rather than presenting it as a successful result.
- Quality scoring sends source material to Jev/TypeSafe AI; before using proprietary or sensitive code, verify upload scope, retention, data-use terms, and deletion procedures.
- The tool executes the supplied full test command and invites coding agents to modify tests; run it in a constrained workspace, review commands and patches, and retain a version-control recovery point.
- Installation spans multiple registries and native binaries, but the supplied material shows no lockfile, artifact checksums, dependency vulnerability scan, or commit-pinned CI actions; high-assurance environments should perform an additional supply-chain review.
- Multi-platform and multi-language support is visible only through static documentation and configuration here and was not executed or independently reproduced in this assessment.
- The PyPI Pre-Alpha classifier coexists with version 1.0.1 and broad Available claims; validate the intended language, runner, and platform combination before adoption.
What does this agent do, and when should you use it?
Supercov is a local CLI that helps coding agents assess code quality, execute an existing test command, and turn missing coverage into actionable tasks. Its quality mode uses Jev to evaluate source files and produces scores backed by inspectable findings; this mode requires a TypeSafe AI API key and is billed by source volume read. Coverage runs the repository's normal test suite inside an isolated workspace without rewriting source, tests, dependencies, runner configuration, or ordinary build output, and stores evidence under `.supercov/`. It supports JavaScript, TypeScript, Rust, Python, Ruby, Go, Java, and Kotlin, with obligations ranging from lines and branches to MC/DC. An agent can select a target through `gaps`, add a focused test, and use `diff` to prove what changed; assertion maps can additionally record what individual assertions check. Supercov does not host or schedule an agent, so it fits projects that already have a terminal-capable coding agent and a trusted complete test command.
For quality analysis, npx supercov quality discovers source files, asks Jev a set of yes/no questions about each file, and calculates inspectable file and project scores. quality gaps, quality file, and quality patch expose triggered findings, a complete file review, or an assessment of uncommitted and branch changes. For coverage, supercov -- <test-command> runs the existing suite in an isolated workspace, derives obligations from source structure before execution, and collects evidence for lines, statements, functions, branches, MC/DC, optional chains, default values, logical assignments, and selected control-flow paths. runs latest gaps returns compact, paginated missing targets, while diff <previous-run-id> latest compares complete runs. Normal runs also create assertion maps; an agent may inspect an assertion and executed source, edit assertions.json, then use assertions validate and assertions check --require-mappings. Evidence is written to .supercov/runs/<run-id>/, with isolated build caches in .supercov/workspaces/.
- A team with a trusted test command wants Codex or Claude Code to add one evidence-driven test at a time instead of choosing targets speculatively.
- An engineer maintaining safety-sensitive or condition-heavy code needs MC/DC independence witnesses beyond ordinary line coverage.
- A codebase owner wants to screen many files consistently with Jev, then begin refactoring from the weakest files and named findings.
- An automated software factory needs bounded tasks for each coding-agent pass and immutable run evidence showing whether coverage improved.
- A test lead wants exact per-test attribution from supported runners such as Jest, Playwright, Vitest, Rust libtest, or RSpec, while accepting aggregate coverage for other supported runners.
- A team wants assertion maps that distinguish code execution from whether an assertion semantically checks the resulting behavior.
What are this agent's strengths and limitations?
- It wraps the complete test command a project already trusts, without requiring imports, custom reporters, configuration files, or a hosted coverage service.
- Coverage obligations are derived from source structure before execution, so adding or removing tests cannot silently redefine what 100% means; missing evidence and ambiguous scope remain visible.
- It measures detailed obligations including MC/DC, optional-chain paths, default values, logical assignments, and zero-iteration control flow in addition to lines and branches.
gapsanddiffgive coding agents bounded targets and before-and-after evidence suitable for repeated improvement loops.- One native CLI covers eight available languages across Linux, macOS, and Windows on arm64 and x64.
- Coverage evidence and workspaces remain under the local
.supercov/directory; coverage runs do not contact a Supercov service or rewrite project files.
- Quality scoring depends on TypeSafe AI and Jev, requires an API key, and incurs usage charges based on source read.
- The
npxroute requires Node.js 22 or newer, while other language paths have their own minimums, including CPython 3.12, Go 1.22, JDK 17, and Ruby 3.3. - Exact per-test attribution is not available for every runner; AVA and Mocha receive aggregate structural coverage.
- Semantic assertion mapping requires an agent to inspect assertions and source, fill mappings, and acknowledge expected-basis tokens.
- Zig, PHP, and C are listed as coming soon rather than currently available.
- Supercov does not host, schedule, or replace a coding agent; continuous execution must be supplied by the user's own agent or software factory.
How do you install or deploy this agent?
The shortest npm path requires Node.js 22 or newer and does not require a prior package installation: npx supercov -- npm test. Other documented ways to obtain or run the same native binary include uvx --from supercov-cli supercov -- pytest, gem install supercov && supercov -- bundle exec rspec, cargo binstall supercov && supercov -- cargo test, go run github.com/supercorp-ai/supercov/cmd/supercov@latest -- go test ./..., and brew install supercorp-ai/tap/supercov. Coverage needs no account or configuration file. Quality scoring requires a TypeSafe AI API key: obtain one, then run export TYPESAFE_API_KEY=.... Package tools such as npx may access their registry when the binary is not cached.
How do you use this agent?
Start with the repository's complete test command, for example npx supercov -- npm test. Inspect the result with npx supercov runs latest, then select a useful target using npx supercov runs latest gaps --limit 10. Have the coding agent change only tests and add one focused case, rerun the same complete suite, and verify the result with npx supercov diff <previous-run-id> latest. For quality analysis, set TYPESAFE_API_KEY and run npx supercov quality; use npx supercov quality gaps for findings or npx supercov quality patch for uncommitted work or the current branch. To enrich assertion semantics, run npx supercov runs latest assertions --json, pin the returned run ID, inspect assertions and executed source, edit assertions.json, and finish with assertions validate --json followed by assertions check --require-mappings --json.
How does this agent compare with similar options?
Compared with coverage workflows that make an agent load a large HTML report, Supercov exposes small, paginated gaps queries and verifies gains through diff. Compared with hosted coverage services, its coverage execution stays under the local .supercov/ directory and does not contact a Supercov service; quality scoring is separate and does depend on TypeSafe AI's Jev API. It is also neither a test runner nor an agent platform: it wraps an existing test command and supplies quality and coverage evidence.
FAQ
Does coverage require an account or payment?
What does quality scoring cost?
Will Supercov modify the repository?
What should happen if tests fail or evidence is incomplete?
Can every supported runner show coverage per individual test?
node:test, Rust runners, and RSpec provide exact attribution, while AVA and Mocha provide aggregate structural coverage.