jitcatch 0.2.0__tar.gz → 0.2.1__tar.gz

{jitcatch-0.2.0 → jitcatch-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jitcatch
-Version: 0.2.0
+Version: 0.2.1
 Summary: Just-in-Time catching test generation: LLM-generated tests that fail on risky code changes, with rule-based and LLM-judge false-positive filtering.
 Author: Ahmad Waqar
 License: MIT
@@ -56,8 +56,8 @@ before it merges. JiTCatch then filters out false positives and asks the author
 
 | Language | Runner | Generated test location |
 |---|---|---|
-| Python | pytest | next to the related existing test (else next to the source): `test_jitcatch_<id>.py` |
-| TypeScript / JavaScript | Jest or Vitest (auto-detected per `package.json`) | `<name>.jitcatch-<id>.test.<ext>` |
+| Python | pytest, in the project's `.venv` (see below) | next to the related existing test (else next to the source): `test_jitcatch_<id>.py` |
+| TypeScript / JavaScript | Jest or Vitest, detected from `package.json`; files in packages using other runners (e.g. Playwright only) are skipped | `<name>.jitcatch-<id>.test.<ext>` |
 | Java | JUnit 4/5 via Maven or Gradle (wrappers preferred) | `src/test/java/<pkg>/<Class>JitcatchTest<ID>.java` |
 | Go | `go test` | `<name>_jitcatch_<id>_test.go`, functions `TestJitcatch<ID>…` |
 
@@ -80,10 +80,17 @@ Inside any git project, run:
 jitcatch
 ```
 
-The first time, it asks at most three questions (provider, model, API key) and saves the answers in
-`~/.config/jitcatch/` for every project. Questions whose answer is already known are skipped; for example,
-the key isn't asked for if `ZAI_API_KEY` / `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` is already set.
-Run `jitcatch setup --reset` to change provider or model.
+The first time, it asks at most three questions and saves the answers in `~/.config/jitcatch/` for every
+project:
+
+1. provider: Z.ai GLM Coding Plan, Anthropic, OpenAI, or Ollama (local, no key);
+2. model: Enter accepts the suggested default (`glm-5.3-flash`, `claude-sonnet-5-5`, `gpt-5`, `qwen2.5-coder:32b`);
+3. API key: input is hidden, and the key is stored in `~/.config/jitcatch/credentials.toml`, readable only by you.
+
+Questions whose answer is already known are skipped. For example, the key isn't asked for if
+`ZAI_API_KEY` / `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` is set, and nothing is asked once setup is complete.
+Without a terminal (CI, git hooks) jitcatch never prompts; it says what is missing.
+Run `jitcatch setup` to set up ahead of time, or `jitcatch setup --reset` to change provider or model.
 
 What gets tested is picked automatically:
 
@@ -91,8 +98,12 @@ What gets tested is picked automatically:
 2. otherwise, commits on your branch that aren't on the default branch yet;
 3. otherwise, the last commit.
 
-Nothing in your checkout is modified. Uncommitted work is snapshotted with a throwaway index, and run
-artifacts in `.jitcatch/` are hidden through `.git/info/exclude`. To compare specific revisions:
+Nothing in your checkout is modified. Uncommitted work is snapshotted with a throwaway index, generated
+tests run in temporary git worktrees, and run artifacts in `.jitcatch/` are hidden through
+`.git/info/exclude`. Each step is logged as it happens (`risk 2/3: generating mutant…`,
+`model replied in 41s`). Ctrl-C stops cleanly and removes the temporary worktrees.
+
+To compare specific revisions:
 
 ```bash
 jitcatch run --base origin/main --head HEAD
@@ -104,10 +115,40 @@ tests run in the project's `.venv` so its dependencies are importable; if that e
 jitcatch installs a private copy into `~/.cache/jitcatch/` and leaves your project untouched.
 `jitcatch doctor --ping` checks configuration, keys, toolchains and provider round-trips.
 
-**GitHub Action** – copy `examples/github-workflow.yml`. It needs `fetch-depth: 0`,
-`permissions: pull-requests: write`, your project's normal setup steps, and API keys as secrets.
-It posts one sticky PR comment (updated on each push), writes a job summary, and exposes
-`catches` / `weak-catches` outputs. jitcatch is installed in its own venv so it never shadows your toolchain.
+| Command | What it does |
+|---|---|
+| `jitcatch` | Same as `jitcatch run`: test the current change, running first-time setup if needed |
+| `jitcatch run [--base REV] [--head REV]` | Test a change; `--json`, `--markdown`, `--fail-on-catch`, `--force` |
+| `jitcatch setup [--reset]` | Choose provider, model and API key (once per machine) |
+| `jitcatch doctor [--ping]` | Check config, keys and toolchains; `--ping` sends a tiny request to each provider |
+| `jitcatch init` | Write a full `.jitcatch.toml` into the repository (see Configuration) |
+| `jitcatch install-hook` / `uninstall-hook` | Manage the git pre-push hook |
+| `jitcatch github` | Run inside GitHub Actions on a `pull_request` event (used by the action) |
+
+## Configuration
+
+Settings are layered: built-in defaults, then your user settings from `jitcatch setup`
+(`~/.config/jitcatch/config.toml`), then a repository `.jitcatch.toml` if one exists. API keys come from
+the environment variable named by the provider, falling back to the key saved by `jitcatch setup`.
+
+A repository `.jitcatch.toml` is optional for local use. You need one for CI, where there are no user
+settings, or to change the pipeline per project. `jitcatch init` writes a commented starter file. It
+defines a Claude generator and a Claude + GLM judge ensemble, so edit `[providers]`/`[roles]` to match the
+keys you have. Every option is documented in [`examples/jitcatch.toml`](https://github.com/khawjaahmad/jitcatch/blob/main/examples/jitcatch.toml), e.g.
+`max_target_files`, `max_risks_per_file`, `report_threshold`, and `[adapters.python] python = ...` to force an
+interpreter.
+
+GLM-5.x models always think. The `zai-coding*` presets use Z.ai's documented defaults (`max_tokens = 65536`,
+`temperature = 1.0`). To trade depth for speed and Coding Plan quota, add
+`extra_body = { reasoning_effort = "high" }` (or `"low"`) to the provider.
+
+## CI and hooks
+
+**GitHub Action**: commit a `.jitcatch.toml` and copy [`examples/github-workflow.yml`](https://github.com/khawjaahmad/jitcatch/blob/main/examples/github-workflow.yml). It needs
+`fetch-depth: 0`, `permissions: pull-requests: write`, your project's normal setup steps, and the API keys
+named in your config as secrets. It posts one sticky PR comment (updated on each push), writes a job
+summary, and exposes `catches` / `weak-catches` outputs. jitcatch is installed in its own venv so it never
+shadows your toolchain.
 
 **Pre-push hook**
 
@@ -138,14 +179,16 @@ The combined score is a weighted mean of the available scores (`assessors.weight
 
 ## Output
 
-`.jitcatch/runs/<timestamp>-<sha>/` contains `report.json` (everything: intent, risks, mutants, every test with
-its runs on parent / mutant / change, all assessor details), `report.md`, `weak_catches/` and `hardening/`
-(tests that pass on both revisions; candidates to add to your suite).
+The Markdown report is printed to stdout. `.jitcatch/runs/<timestamp>-<sha>/` contains `report.json`
+(everything: intent, risks, mutants, every test with its runs on parent / mutant / change, all assessor
+details), `report.md`, `weak_catches/`, and `hardening/` when there are any (tests that pass on both
+revisions; candidates to add to your suite).
 
 ## Cost and safety notes
 
 * LLM calls per changed file are about 1 intent call (shared) + 2 × risks (mutant + test) + dodgy tests +
-  repairs, plus judges for each weak catch that is not auto-discarded. Bound it with `max_target_files`,
+  repairs, plus judges for each weak catch that is not auto-discarded. That is typically 10–20 calls, so
+  with thinking models a run takes several minutes. Bound it with `max_target_files`,
   `max_risks_per_file`, `dodgy_tests_per_file`, `max_fix_attempts`, `min_risk_score`.
 * **Generated tests are LLM-written code executed on the machine** (CI runner or, with the hook, your laptop).
   Run it where that is acceptable.

{jitcatch-0.2.0 → jitcatch-0.2.1}/README.md

@@ -26,8 +26,8 @@ before it merges. JiTCatch then filters out false positives and asks the author
 
 | Language | Runner | Generated test location |
 |---|---|---|
-| Python | pytest | next to the related existing test (else next to the source): `test_jitcatch_<id>.py` |
-| TypeScript / JavaScript | Jest or Vitest (auto-detected per `package.json`) | `<name>.jitcatch-<id>.test.<ext>` |
+| Python | pytest, in the project's `.venv` (see below) | next to the related existing test (else next to the source): `test_jitcatch_<id>.py` |
+| TypeScript / JavaScript | Jest or Vitest, detected from `package.json`; files in packages using other runners (e.g. Playwright only) are skipped | `<name>.jitcatch-<id>.test.<ext>` |
 | Java | JUnit 4/5 via Maven or Gradle (wrappers preferred) | `src/test/java/<pkg>/<Class>JitcatchTest<ID>.java` |
 | Go | `go test` | `<name>_jitcatch_<id>_test.go`, functions `TestJitcatch<ID>…` |
 
@@ -50,10 +50,17 @@ Inside any git project, run:
 jitcatch
 ```
 
-The first time, it asks at most three questions (provider, model, API key) and saves the answers in
-`~/.config/jitcatch/` for every project. Questions whose answer is already known are skipped; for example,
-the key isn't asked for if `ZAI_API_KEY` / `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` is already set.
-Run `jitcatch setup --reset` to change provider or model.
+The first time, it asks at most three questions and saves the answers in `~/.config/jitcatch/` for every
+project:
+
+1. provider: Z.ai GLM Coding Plan, Anthropic, OpenAI, or Ollama (local, no key);
+2. model: Enter accepts the suggested default (`glm-5.3-flash`, `claude-sonnet-5-5`, `gpt-5`, `qwen2.5-coder:32b`);
+3. API key: input is hidden, and the key is stored in `~/.config/jitcatch/credentials.toml`, readable only by you.
+
+Questions whose answer is already known are skipped. For example, the key isn't asked for if
+`ZAI_API_KEY` / `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` is set, and nothing is asked once setup is complete.
+Without a terminal (CI, git hooks) jitcatch never prompts; it says what is missing.
+Run `jitcatch setup` to set up ahead of time, or `jitcatch setup --reset` to change provider or model.
 
 What gets tested is picked automatically:
 
@@ -61,8 +68,12 @@ What gets tested is picked automatically:
 2. otherwise, commits on your branch that aren't on the default branch yet;
 3. otherwise, the last commit.
 
-Nothing in your checkout is modified. Uncommitted work is snapshotted with a throwaway index, and run
-artifacts in `.jitcatch/` are hidden through `.git/info/exclude`. To compare specific revisions:
+Nothing in your checkout is modified. Uncommitted work is snapshotted with a throwaway index, generated
+tests run in temporary git worktrees, and run artifacts in `.jitcatch/` are hidden through
+`.git/info/exclude`. Each step is logged as it happens (`risk 2/3: generating mutant…`,
+`model replied in 41s`). Ctrl-C stops cleanly and removes the temporary worktrees.
+
+To compare specific revisions:
 
 ```bash
 jitcatch run --base origin/main --head HEAD
@@ -74,10 +85,40 @@ tests run in the project's `.venv` so its dependencies are importable; if that e
 jitcatch installs a private copy into `~/.cache/jitcatch/` and leaves your project untouched.
 `jitcatch doctor --ping` checks configuration, keys, toolchains and provider round-trips.
 
-**GitHub Action** – copy `examples/github-workflow.yml`. It needs `fetch-depth: 0`,
-`permissions: pull-requests: write`, your project's normal setup steps, and API keys as secrets.
-It posts one sticky PR comment (updated on each push), writes a job summary, and exposes
-`catches` / `weak-catches` outputs. jitcatch is installed in its own venv so it never shadows your toolchain.
+| Command | What it does |
+|---|---|
+| `jitcatch` | Same as `jitcatch run`: test the current change, running first-time setup if needed |
+| `jitcatch run [--base REV] [--head REV]` | Test a change; `--json`, `--markdown`, `--fail-on-catch`, `--force` |
+| `jitcatch setup [--reset]` | Choose provider, model and API key (once per machine) |
+| `jitcatch doctor [--ping]` | Check config, keys and toolchains; `--ping` sends a tiny request to each provider |
+| `jitcatch init` | Write a full `.jitcatch.toml` into the repository (see Configuration) |
+| `jitcatch install-hook` / `uninstall-hook` | Manage the git pre-push hook |
+| `jitcatch github` | Run inside GitHub Actions on a `pull_request` event (used by the action) |
+
+## Configuration
+
+Settings are layered: built-in defaults, then your user settings from `jitcatch setup`
+(`~/.config/jitcatch/config.toml`), then a repository `.jitcatch.toml` if one exists. API keys come from
+the environment variable named by the provider, falling back to the key saved by `jitcatch setup`.
+
+A repository `.jitcatch.toml` is optional for local use. You need one for CI, where there are no user
+settings, or to change the pipeline per project. `jitcatch init` writes a commented starter file. It
+defines a Claude generator and a Claude + GLM judge ensemble, so edit `[providers]`/`[roles]` to match the
+keys you have. Every option is documented in [`examples/jitcatch.toml`](https://github.com/khawjaahmad/jitcatch/blob/main/examples/jitcatch.toml), e.g.
+`max_target_files`, `max_risks_per_file`, `report_threshold`, and `[adapters.python] python = ...` to force an
+interpreter.
+
+GLM-5.x models always think. The `zai-coding*` presets use Z.ai's documented defaults (`max_tokens = 65536`,
+`temperature = 1.0`). To trade depth for speed and Coding Plan quota, add
+`extra_body = { reasoning_effort = "high" }` (or `"low"`) to the provider.
+
+## CI and hooks
+
+**GitHub Action**: commit a `.jitcatch.toml` and copy [`examples/github-workflow.yml`](https://github.com/khawjaahmad/jitcatch/blob/main/examples/github-workflow.yml). It needs
+`fetch-depth: 0`, `permissions: pull-requests: write`, your project's normal setup steps, and the API keys
+named in your config as secrets. It posts one sticky PR comment (updated on each push), writes a job
+summary, and exposes `catches` / `weak-catches` outputs. jitcatch is installed in its own venv so it never
+shadows your toolchain.
 
 **Pre-push hook**
 
@@ -108,14 +149,16 @@ The combined score is a weighted mean of the available scores (`assessors.weight
 
 ## Output
 
-`.jitcatch/runs/<timestamp>-<sha>/` contains `report.json` (everything: intent, risks, mutants, every test with
-its runs on parent / mutant / change, all assessor details), `report.md`, `weak_catches/` and `hardening/`
-(tests that pass on both revisions; candidates to add to your suite).
+The Markdown report is printed to stdout. `.jitcatch/runs/<timestamp>-<sha>/` contains `report.json`
+(everything: intent, risks, mutants, every test with its runs on parent / mutant / change, all assessor
+details), `report.md`, `weak_catches/`, and `hardening/` when there are any (tests that pass on both
+revisions; candidates to add to your suite).
 
 ## Cost and safety notes
 
 * LLM calls per changed file are about 1 intent call (shared) + 2 × risks (mutant + test) + dodgy tests +
-  repairs, plus judges for each weak catch that is not auto-discarded. Bound it with `max_target_files`,
+  repairs, plus judges for each weak catch that is not auto-discarded. That is typically 10–20 calls, so
+  with thinking models a run takes several minutes. Bound it with `max_target_files`,
   `max_risks_per_file`, `dodgy_tests_per_file`, `max_fix_attempts`, `min_risk_score`.
 * **Generated tests are LLM-written code executed on the machine** (CI runner or, with the hook, your laptop).
   Run it where that is acceptable.

{jitcatch-0.2.0 → jitcatch-0.2.1}/jitcatch/__init__.py

@@ -1,2 +1,2 @@
 """JiTCatch: Just-in-Time catching test generation (after Becker et al., FSE '26)."""
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{jitcatch-0.2.0 → jitcatch-0.2.1}/jitcatch/templates.py

@@ -1,5 +1,7 @@
 CONFIG_TEMPLATE = '''\
-# JiTCatch configuration. API keys are read from the environment variables named below.
+# JiTCatch repository configuration (optional locally; needed in CI). It overrides the user settings
+# saved by `jitcatch setup`. API keys come from the environment variables named below, falling back to
+# keys saved by `jitcatch setup`.
 
 # ---------------------------------------------------------------- LLM providers
 # type: "anthropic" | "openai_chat" | "openai_responses"   (or use a preset)

{jitcatch-0.2.0 → jitcatch-0.2.1}/jitcatch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jitcatch
-Version: 0.2.0
+Version: 0.2.1
 Summary: Just-in-Time catching test generation: LLM-generated tests that fail on risky code changes, with rule-based and LLM-judge false-positive filtering.
 Author: Ahmad Waqar
 License: MIT
@@ -56,8 +56,8 @@ before it merges. JiTCatch then filters out false positives and asks the author
 
 | Language | Runner | Generated test location |
 |---|---|---|
-| Python | pytest | next to the related existing test (else next to the source): `test_jitcatch_<id>.py` |
-| TypeScript / JavaScript | Jest or Vitest (auto-detected per `package.json`) | `<name>.jitcatch-<id>.test.<ext>` |
+| Python | pytest, in the project's `.venv` (see below) | next to the related existing test (else next to the source): `test_jitcatch_<id>.py` |
+| TypeScript / JavaScript | Jest or Vitest, detected from `package.json`; files in packages using other runners (e.g. Playwright only) are skipped | `<name>.jitcatch-<id>.test.<ext>` |
 | Java | JUnit 4/5 via Maven or Gradle (wrappers preferred) | `src/test/java/<pkg>/<Class>JitcatchTest<ID>.java` |
 | Go | `go test` | `<name>_jitcatch_<id>_test.go`, functions `TestJitcatch<ID>…` |
 
@@ -80,10 +80,17 @@ Inside any git project, run:
 jitcatch
 ```
 
-The first time, it asks at most three questions (provider, model, API key) and saves the answers in
-`~/.config/jitcatch/` for every project. Questions whose answer is already known are skipped; for example,
-the key isn't asked for if `ZAI_API_KEY` / `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` is already set.
-Run `jitcatch setup --reset` to change provider or model.
+The first time, it asks at most three questions and saves the answers in `~/.config/jitcatch/` for every
+project:
+
+1. provider: Z.ai GLM Coding Plan, Anthropic, OpenAI, or Ollama (local, no key);
+2. model: Enter accepts the suggested default (`glm-5.3-flash`, `claude-sonnet-5-5`, `gpt-5`, `qwen2.5-coder:32b`);
+3. API key: input is hidden, and the key is stored in `~/.config/jitcatch/credentials.toml`, readable only by you.
+
+Questions whose answer is already known are skipped. For example, the key isn't asked for if
+`ZAI_API_KEY` / `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` is set, and nothing is asked once setup is complete.
+Without a terminal (CI, git hooks) jitcatch never prompts; it says what is missing.
+Run `jitcatch setup` to set up ahead of time, or `jitcatch setup --reset` to change provider or model.
 
 What gets tested is picked automatically:
 
@@ -91,8 +98,12 @@ What gets tested is picked automatically:
 2. otherwise, commits on your branch that aren't on the default branch yet;
 3. otherwise, the last commit.
 
-Nothing in your checkout is modified. Uncommitted work is snapshotted with a throwaway index, and run
-artifacts in `.jitcatch/` are hidden through `.git/info/exclude`. To compare specific revisions:
+Nothing in your checkout is modified. Uncommitted work is snapshotted with a throwaway index, generated
+tests run in temporary git worktrees, and run artifacts in `.jitcatch/` are hidden through
+`.git/info/exclude`. Each step is logged as it happens (`risk 2/3: generating mutant…`,
+`model replied in 41s`). Ctrl-C stops cleanly and removes the temporary worktrees.
+
+To compare specific revisions:
 
 ```bash
 jitcatch run --base origin/main --head HEAD
@@ -104,10 +115,40 @@ tests run in the project's `.venv` so its dependencies are importable; if that e
 jitcatch installs a private copy into `~/.cache/jitcatch/` and leaves your project untouched.
 `jitcatch doctor --ping` checks configuration, keys, toolchains and provider round-trips.
 
-**GitHub Action** – copy `examples/github-workflow.yml`. It needs `fetch-depth: 0`,
-`permissions: pull-requests: write`, your project's normal setup steps, and API keys as secrets.
-It posts one sticky PR comment (updated on each push), writes a job summary, and exposes
-`catches` / `weak-catches` outputs. jitcatch is installed in its own venv so it never shadows your toolchain.
+| Command | What it does |
+|---|---|
+| `jitcatch` | Same as `jitcatch run`: test the current change, running first-time setup if needed |
+| `jitcatch run [--base REV] [--head REV]` | Test a change; `--json`, `--markdown`, `--fail-on-catch`, `--force` |
+| `jitcatch setup [--reset]` | Choose provider, model and API key (once per machine) |
+| `jitcatch doctor [--ping]` | Check config, keys and toolchains; `--ping` sends a tiny request to each provider |
+| `jitcatch init` | Write a full `.jitcatch.toml` into the repository (see Configuration) |
+| `jitcatch install-hook` / `uninstall-hook` | Manage the git pre-push hook |
+| `jitcatch github` | Run inside GitHub Actions on a `pull_request` event (used by the action) |
+
+## Configuration
+
+Settings are layered: built-in defaults, then your user settings from `jitcatch setup`
+(`~/.config/jitcatch/config.toml`), then a repository `.jitcatch.toml` if one exists. API keys come from
+the environment variable named by the provider, falling back to the key saved by `jitcatch setup`.
+
+A repository `.jitcatch.toml` is optional for local use. You need one for CI, where there are no user
+settings, or to change the pipeline per project. `jitcatch init` writes a commented starter file. It
+defines a Claude generator and a Claude + GLM judge ensemble, so edit `[providers]`/`[roles]` to match the
+keys you have. Every option is documented in [`examples/jitcatch.toml`](https://github.com/khawjaahmad/jitcatch/blob/main/examples/jitcatch.toml), e.g.
+`max_target_files`, `max_risks_per_file`, `report_threshold`, and `[adapters.python] python = ...` to force an
+interpreter.
+
+GLM-5.x models always think. The `zai-coding*` presets use Z.ai's documented defaults (`max_tokens = 65536`,
+`temperature = 1.0`). To trade depth for speed and Coding Plan quota, add
+`extra_body = { reasoning_effort = "high" }` (or `"low"`) to the provider.
+
+## CI and hooks
+
+**GitHub Action**: commit a `.jitcatch.toml` and copy [`examples/github-workflow.yml`](https://github.com/khawjaahmad/jitcatch/blob/main/examples/github-workflow.yml). It needs
+`fetch-depth: 0`, `permissions: pull-requests: write`, your project's normal setup steps, and the API keys
+named in your config as secrets. It posts one sticky PR comment (updated on each push), writes a job
+summary, and exposes `catches` / `weak-catches` outputs. jitcatch is installed in its own venv so it never
+shadows your toolchain.
 
 **Pre-push hook**
 
@@ -138,14 +179,16 @@ The combined score is a weighted mean of the available scores (`assessors.weight
 
 ## Output
 
-`.jitcatch/runs/<timestamp>-<sha>/` contains `report.json` (everything: intent, risks, mutants, every test with
-its runs on parent / mutant / change, all assessor details), `report.md`, `weak_catches/` and `hardening/`
-(tests that pass on both revisions; candidates to add to your suite).
+The Markdown report is printed to stdout. `.jitcatch/runs/<timestamp>-<sha>/` contains `report.json`
+(everything: intent, risks, mutants, every test with its runs on parent / mutant / change, all assessor
+details), `report.md`, `weak_catches/`, and `hardening/` when there are any (tests that pass on both
+revisions; candidates to add to your suite).
 
 ## Cost and safety notes
 
 * LLM calls per changed file are about 1 intent call (shared) + 2 × risks (mutant + test) + dodgy tests +
-  repairs, plus judges for each weak catch that is not auto-discarded. Bound it with `max_target_files`,
+  repairs, plus judges for each weak catch that is not auto-discarded. That is typically 10–20 calls, so
+  with thinking models a run takes several minutes. Bound it with `max_target_files`,
   `max_risks_per_file`, `dodgy_tests_per_file`, `max_fix_attempts`, `min_risk_score`.
 * **Generated tests are LLM-written code executed on the machine** (CI runner or, with the hook, your laptop).
   Run it where that is acceptable.

{jitcatch-0.2.0 → jitcatch-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jitcatch"
-version = "0.2.0"
+version = "0.2.1"
 description = "Just-in-Time catching test generation: LLM-generated tests that fail on risky code changes, with rule-based and LLM-judge false-positive filtering."
 readme = "README.md"
 requires-python = ">=3.11"