quelltest on npm or PyPI? A Guide to Picking the Right Package

TL;DR. Pick by the language of the code you want to check. If your code is JavaScript or TypeScript, use the npm package, which verifies and gates tests with mutation. If your code is Python, use the PyPI package, which writes verified pytest tests from your docstrings and Pydantic models. They are separate products with different licences and different commands.

Versions in this post: npm quelltest 0.3.1 and PyPI quelltest 2.0.0, both read from the registries on 2026-10-20.

Why are there two packages with the same name?

They started from the same idea: a test is only worth having if it can be shown to fail when the code is wrong. They solve it in the way that fits each language.

The Python package came first. It extracts requirements from specs that already exist in your code and proves each generated test through five gates. The npm package is newer and is built around one question for agent-written code: would this test fail if the code were broken, and did this change weaken the suite?

The two share a name and a command name, quell, but not a code base.

Which package should I use?

If you have both languages in one repository, use both, in separate steps, and install the npm package locally per project (npx quell) rather than globally. Both packages name their executable quell, so installing both globally can make one shadow the other on your PATH.

What does the npm package do?

It is "the free, offline gate for AI-written tests". Four commands carry most of the weight:

npm install --save-dev quelltest
npx quell verify tests/pay.test.js --source src/pay.js --min-score 60   # would this test catch a bug?
npx quell gate --diff origin/main                                       # did this change weaken the tests?
npx quell find src --diff origin/main --coverage coverage/lcov.info     # risky edges with no real test
npx quell generate src --write --verify                                 # tests the rules can derive, notes otherwise

It also has quell mcp for coding agents and quell mocks for checking stubs against recorded examples. Start with the npm docs, the quickstart and the introduction to 0.3.

What does the PyPI package do?

It reads the guard clauses, docstrings and Pydantic models already in your Python code, extracts each testable requirement, checks which have no test, and writes a pytest test for each gap that passes five gates: syntax and imports, originality, security, passes on correct code, and fails on code with the requirement violated.

pip install quelltest
quell find src/
quell find src/ --fix
quell score src/

Results land in three buckets: WRITTEN (all five gates passed), SCAFFOLDED (structure written, you finish the assertion) and FLAGGED (cannot auto-test, with a reason and a location). quell score reports a Production Readiness Score. Start with the Python quickstart, installation and how it works, and read the five-gate pipeline post.

Do the two packages overlap?

Only in philosophy. If your question is "did the agent weaken my Jest tests", only the npm package answers it. If your question is "which of my docstring promises have no pytest test", only the PyPI package answers it. Neither package analyses the other language.

There is a related mutation tool for each ecosystem too. For JavaScript, Stryker produces a full-suite mutation score, which quelltest does not; the npm README says to choose Stryker when you want that, and to put quelltest verify and gate in front of LLM-generated tests. For Python, the Python package's own README compares itself with Copilot, Qodo and Hypothesis. Read those comparisons at the source instead of relying on our summary.

What are the limits of each?

npm package

• It checks whether your tests notice changes in your code, not whether your mocks match real services. quell mocks narrows the gap.
• Generation covers simple guards. Express handlers, React components and most real code become notes.
• verify runs your tests once per mutant, so it is slower than one run.
• verify uses node:test unless you pass --runner; see the runner post.
• The full list is at /docs/npm/limits.

PyPI package

• It needs Python 3.11 or newer.
• Some cases are flagged, not tested, for example code that depends on an external API or on object state.
• Its output depends on specs existing in your code. Undocumented, unannotated code gives it little to read.
• The scoring is its own scale, the PRS, and is a review aid, not a quality guarantee.

Release notes for both are on the changelog page.

FAQ

Can I use quelltest on a TypeScript project from PyPI?

No. The PyPI package analyses Python. Use the npm package for TypeScript.

Which one is open source and under which licence?

Both are open source. npm quelltest is under Apache-2.0 and PyPI quelltest is under MIT.

Do either of them send my code to a server?

The npm package sends no code to any service. The Python package's rule engine runs locally, and code is sent only to the LLM provider you configure when its rules are insufficient. Read each package's privacy notes before using it on private code.

Do I need both for a full-stack repository?

Only if you want both kinds of checking. They run independently.

Where do I report problems?

On GitHub: quelltest-npm and quelltest-lib.

Sources

• npm package: npmjs.com/package/quelltest (Apache-2.0, engines.node >=20 at 0.3.1)
• PyPI package: pypi.org/project/quelltest (MIT, Python 3.11+)
• npm repository and README, including its comparison table: github.com/quelltest/quelltest-npm
• Python repository and README: github.com/quelltest/quelltest-lib
• npm changelog: CHANGELOG.md
• Python releases: github.com/quelltest/quelltest-lib/releases
• Licences: Apache-2.0, MIT
• StrykerJS: stryker-mutator.io