Qodo Cover writes tests until the coverage number moves
Qodo-Cover: An AI-Powered Tool for Automated Test Generation and Code Coverage Enhancement! 💻🤖🧪🐞
At a glance
- What is it?
- Qodo Cover is a Python CLI that drives a coverage percentage upward by asking a language model for tests through four components, one file pair per run. It requires a Cobertura XML report, wants an OpenAI key, and the project now points you at your own fork.
- Who is it for?
- Use it when you have one file, one Cobertura report and an OpenAI key you are willing to spend on a loop you cannot preview before it runs. Leave it if you need a project that still ships releases, since 0.3.10 from 2025-05-21 is the newest tag and the project asks users to fork it.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Activity is slowing. The repository last received commits 7 months ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- qodo-ai/qodo-cover5,688 ★ · +37
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| qodo-ai/qodo-cover | 5.7k | 5.7k |
37 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Four moving parts sit between your test command and the model
The tool is built from four named components. A Test Runner executes your test command and produces a coverage report. A Coverage Parser reads that report and checks the percentage actually moved when a new test landed, so a test that only re-covers old lines gets thrown out instead of kept. A Prompt Builder gathers data from the codebase and assembles the prompt. An AI Caller sends the prompt to the model and takes the generated test back. Two flags decide when the loop ends: `--desired-coverage` is the number you want, given between 0 and 100, and `--max-iterations` caps how many times the loop may run. The parser is the part that matters most, because without it the run just collects more tests until the iteration cap, whether or not any of them touch a new line.
Cobertura XML has to exist before the agent starts
A Cobertura XML coverage report is required for the tool to work at all, so the sequence never changes: run the suite yourself with coverage output, keep the XML file, point `--code-coverage-report-path` at it, and name the format with `--coverage-type cobertura`. For Python that report comes out of pytest-cov run with the `--cov-report=xml` option. Contributors are pointed at `cover_agent/CoverageProcessor.py` and invited to open a pull request there, and the note next to it says work on adding more coverage types is still in progress, which makes that one file the place a new format would have to be taught. The same constraint rules out bootstrapping from a clean checkout: no report exists until a test run writes one, and `--test-command` with `--test-command-dir` exist so the agent can produce and reread that file on later passes.
One file pair, one percentage, one loop per command
The command line takes `--source-file-path`, `--test-file-path`, `--project-root` and an optional `--included-files` list. The bundled Python example aims it at a single FastAPI app and its single test file, and asks for 70 percent over at most 10 iterations.
cover-agent \
--source-file-path "templated_tests/python_fastapi/app.py" \
--test-file-path "templated_tests/python_fastapi/test_app.py" \
--project-root "templated_tests/python_fastapi" \
--code-coverage-report-path "templated_tests/python_fastapi/coverage.xml" \
--test-command "pytest --cov=. --cov-report=xml --cov-report=term" \
--test-command-dir "templated_tests/python_fastapi" \
--coverage-type "cobertura" \
--desired-coverage 70 \
--max-iterations 10cover-agent-full-repo is the second entry point in the package metadata
`pyproject.toml` registers three console scripts: `cover-agent = "cover_agent.main:main"`, `cover-agent-full-repo = "cover_agent.main_full_repo:main"` and `generate-report = "cover_agent.UnitTestDB:dump_to_report_cli"`. The full repo script is the answer to the single file limit. The behaviour announced for it in November 2024 is to scan a whole repository, identify the test files by itself, collect the context for each test file, and extend the suite with new tests. The write up behind that entry sits in `docs/repo_coverage.md`. A `stored_responses/` directory sits at the repository root, and the package holds a `settings/` directory of TOML files that the installer build globs into the binary. The file tree does not say what belongs in those TOML files.
OPENAI_API_KEY is required even though litellm is packaged
The stated requirement is one environment variable, `OPENAI_API_KEY`, described as required for calling the OpenAI API, and no second key is named in the setup notes. The dependency list nevertheless carries `litellm ^1.61.13` alongside `openai ^1.63.2` and `tiktoken ^0.8.0`, so more than one model path ships inside the wheel. The infrastructure dependencies are heavier than a pure command line tool needs: `boto3 ^1.36.25`, `google-cloud-aiplatform ^1.81.0`, `docker ^7.1.0` and `wandb ^0.17.9` for run tracking. `numpy` is held at `^1.26.4`, with a comment that earlier versions clash with google-cloud-aiplatform. All of it has to install cleanly on `python = ">=3.9.17,<3.14"` before a single test is written.
The version in pyproject.toml is a placeholder read from version.txt
`pyproject.toml` carries `version = "0.0.0"` with a comment saying it is a placeholder that dynamic versioning replaces. The `poetry-dynamic-versioning` plugin is enabled and reads the real number from `cover_agent/version.txt`, and the build backend is `poetry_dynamic_versioning.backend`, so the published wheel takes its version from that text file rather than from the TOML. The release tags tell the recent story: 0.3.8 on 2025-05-12, 0.3.9 on 2025-05-15, and 0.3.10 on 2025-05-21. The same file declares `license = "Apache 2.0"` and authors `QodoAI <[email protected]>`, while the repository itself is published under AGPL-3.0 and keeps a LICENSE file at the root. In a vendored copy, that disagreement is worth settling before anything ships.
Building the binary needs four global packages before PyInstaller runs
There are three ways in. The Pip route installs the package straight from the repository, and the source route runs poetry install from a checkout:
pip install git+https://github.com/qodo-ai/qodo-cover.git
poetry installA prebuilt executable runs with no Python on the machine at all, which is the point for a Docker container that has none, and it is downloaded from the project's release page. Building that executable yourself is the long road: the `Dockerfile` starts `FROM python:3.12-bookworm`, copies the tree, runs `make setup-installer` and `poetry install`, then `CMD ["make", "installer"]`. `setup-installer` is a single pip call for poetry, wandb, tree_sitter and diff-cover, and the `installer` target drives PyInstaller in `--onefile` mode, naming the result `cover-agent` while folding in every TOML file under `cover_agent/settings`.
The last release predates the unmaintained notice by a month
A dated entry near the top of the file, 2025-06-15, says the repository is no longer maintained and asks anyone who wants to continue to fork it. The repository is not marked archived and the last recorded push is 2026-04-05, so commits landed after that notice without a new release. The newest version on the release page is still 0.3.10 from 2025-05-21, a month before the notice. Two pointers lead away from the code itself: the December 2024 entry promotes a GitHub CI path, `qodo-ci`, described as in preview and free for a limited time for Python projects and using your own LLM key, and the badges still link to the older `Codium-ai/cover-agent` commit history. The two detail pages named in the run instructions, `docs/usage_examples.md` and `docs/repo_coverage.md`, are where the rest is written down.
Editorial conclusion
Use it when you have one file, one Cobertura report and an OpenAI key you are willing to spend on a loop you cannot preview before it runs. Leave it if you need a project that still ships releases, since 0.3.10 from 2025-05-21 is the newest tag and the project asks users to fork it.
Frequently asked questions
What does Qodo Cover need before it generates any tests?
Two things: `OPENAI_API_KEY` in the environment, and a Cobertura XML coverage report already on disk. For Python that report comes from pytest-cov run with the `--cov-report=xml` option, and `--coverage-type cobertura` tells the parser how to read it.
Can Qodo Cover work on a whole repository, or only on one file?
Both. The `cover-agent` command takes a single source file and a single test file. The `cover-agent-full-repo` entry point in pyproject.toml scans a repository, finds the test files, collects context for each and extends the suite, and its write up sits in `docs/repo_coverage.md`.
Is Qodo Cover still being maintained?
A notice dated 2025-06-15 says the repository is no longer maintained and asks you to fork it if you want to carry on. The repository is not archived and the last recorded push is 2026-04-05, but the newest release is 0.3.10 from 2025-05-21.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/qodo-ai-qodo-cover)Star history chart for your README
[](https://hysenlabs.com/projects/qodo-ai-qodo-cover)Was this useful?