jitcatch 0.2.0__tar.gz

jitcatch-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ahmad Waqar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jitcatch-0.2.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: jitcatch
+Version: 0.2.0
+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
+Project-URL: Homepage, https://github.com/khawjaahmad/jitcatch
+Project-URL: Repository, https://github.com/khawjaahmad/jitcatch
+Project-URL: Issues, https://github.com/khawjaahmad/jitcatch/issues
+Project-URL: Paper, https://arxiv.org/abs/2601.22832
+Keywords: testing,regression,llm,mutation-testing,test-generation,code-review
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# JiTCatch
+
+Just-in-Time **catching** test generation for any Git repository, modelled on
+Becker et al., *"Just-in-Time Catching Test Generation at Meta"* (FSE Companion '26, arXiv:2601.22832).
+
+Hardening tests pass today and guard the future. **Catching tests are generated for one specific change and
+are meant to fail on it**: they pass on the parent revision and fail on the change, exposing a regression
+before it merges. JiTCatch then filters out false positives and asks the author a plain question:
+*"`can_delete()` now returns False for a resource's owner. Is this expected?"*
+
+| Paper concept | Where it lives |
+|---|---|
+| Diff risk targeting (DRS) | `targeting.py` (transparent heuristic; `run.min_risk_score`) |
+| Intent-aware workflow: intent → risks → mutants of parent → tests that kill them | `engine.py` `_infer_intent`, `_make_mutant`, `_generate_test` |
+| Mutant must build and pass existing tests | `run.check_mutants_with_existing_tests` |
+| "Dodgy diff" workflow: treat the change itself as a mutant | `engine.py` `_dodgy_diff` |
+| Weak catch = passes on parent, fails on change | `models.GeneratedTest.is_weak_catch` |
+| RubFake rule-based assessor (Tables 2 & 3) | `assessors/rules.py` |
+| LLM-as-judge ensemble, High/Medium/Low → 1/0/−1, **median** | `assessors/llm_judge.py` |
+| Normalised token-probability Yes/No score | `assessors/llm_judge.py` `logprob_score` |
+| Score in [−1, 1], rank, threshold | `assessors/__init__.py`, `run.report_threshold` |
+| Low-friction "is this expected?" report | `report.py` (Markdown, JSON, PR comment) |
+| Coincidental hardening tests as a by-product | `.jitcatch/runs/<id>/hardening/` |
+
+## Supported stacks
+
+| 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>` |
+| 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>…` |
+
+LLM providers: **Anthropic Messages**, **OpenAI Chat Completions**, **OpenAI Responses**, and anything compatible
+with them, with presets for Z.ai GLM Coding Plan (`zai-coding` → `https://api.z.ai/api/coding/paas/v4`,
+`zai-coding-anthropic`, `zai-coding-responses`) and local servers (`ollama`, `lmstudio`, `vllm`).
+No third-party Python dependencies; Python ≥ 3.11.
+
+## Install
+
+```bash
+pipx install jitcatch        # or: uv tool install jitcatch   /   pip install jitcatch
+```
+
+## Use
+
+Inside any git project, run:
+
+```bash
+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.
+
+What gets tested is picked automatically:
+
+1. uncommitted changes (including new files), compared with the last commit;
+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:
+
+```bash
+jitcatch run --base origin/main --head HEAD
+jitcatch run --base main --head feature --json report.json --markdown report.md --fail-on-catch
+```
+
+The project's own toolchain must work (`node_modules`, Maven/Gradle dependencies, Go modules). For Python,
+tests run in the project's `.venv` so its dependencies are importable; if that environment has no pytest,
+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.
+
+**Pre-push hook**
+
+```bash
+jitcatch install-hook              # reports only
+jitcatch install-hook --blocking   # a reported catch blocks the push
+JITCATCH_SKIP=1 git push           # bypass once
+```
+
+Tool or provider failures never block a push.
+
+## How scoring works
+
+Every weak catch is scored by up to three assessors, each in [−1 (false positive), 1 (true positive)]:
+
+1. **rules**: deterministic false-positive patterns from the paper (broken runner, reflection, type
+   mismatch, mocks, private/protected members, NotImplemented, key ordering, undefined names, call-count
+   expectations, network down, flakiness) and true-positive patterns (unexpected key/index error, emptied
+   container, construction failure, flipped boolean, behaviour change in a refactor, dead-code removal or
+   additive change, unexpected null, RBAC). A **high** false-positive pattern discards the catch before any
+   judge is called (`assessors.discard_on_high_fp_rule`).
+2. **llm_bucket**: median of the judges' High/Medium/Low.
+3. **llm_logprob** (optional): P(Yes) vs P(No) for the first answer token from an `openai_chat` provider
+   with `logprobs = true`.
+
+The combined score is a weighted mean of the available scores (`assessors.weights`); catches at or above
+`run.report_threshold` are reported, best first. All judge rationales are kept individually.
+
+## 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).
+
+## 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`,
+  `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.
+* Targeting is a heuristic stand-in for Meta's learned risk model, which needs historical data.
+* Logprob judging only reads Chat Completions logprobs; whether a given server returns them varies
+  (`jitcatch doctor --ping` reports it).
+
+## Development
+
+```bash
+pip install -e '.[dev]' && pytest
+```
+
+The suite runs the full pipeline end-to-end with a scripted LLM against real pytest, Go, Vitest (TypeScript)
+and Jest (JavaScript) projects, and against HTTP fake servers for the provider and GitHub wire formats.
+Java/JUnit execution is covered by placement/classification unit tests only.

jitcatch-0.2.0/README.md

@@ -0,0 +1,134 @@
+# JiTCatch
+
+Just-in-Time **catching** test generation for any Git repository, modelled on
+Becker et al., *"Just-in-Time Catching Test Generation at Meta"* (FSE Companion '26, arXiv:2601.22832).
+
+Hardening tests pass today and guard the future. **Catching tests are generated for one specific change and
+are meant to fail on it**: they pass on the parent revision and fail on the change, exposing a regression
+before it merges. JiTCatch then filters out false positives and asks the author a plain question:
+*"`can_delete()` now returns False for a resource's owner. Is this expected?"*
+
+| Paper concept | Where it lives |
+|---|---|
+| Diff risk targeting (DRS) | `targeting.py` (transparent heuristic; `run.min_risk_score`) |
+| Intent-aware workflow: intent → risks → mutants of parent → tests that kill them | `engine.py` `_infer_intent`, `_make_mutant`, `_generate_test` |
+| Mutant must build and pass existing tests | `run.check_mutants_with_existing_tests` |
+| "Dodgy diff" workflow: treat the change itself as a mutant | `engine.py` `_dodgy_diff` |
+| Weak catch = passes on parent, fails on change | `models.GeneratedTest.is_weak_catch` |
+| RubFake rule-based assessor (Tables 2 & 3) | `assessors/rules.py` |
+| LLM-as-judge ensemble, High/Medium/Low → 1/0/−1, **median** | `assessors/llm_judge.py` |
+| Normalised token-probability Yes/No score | `assessors/llm_judge.py` `logprob_score` |
+| Score in [−1, 1], rank, threshold | `assessors/__init__.py`, `run.report_threshold` |
+| Low-friction "is this expected?" report | `report.py` (Markdown, JSON, PR comment) |
+| Coincidental hardening tests as a by-product | `.jitcatch/runs/<id>/hardening/` |
+
+## Supported stacks
+
+| 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>` |
+| 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>…` |
+
+LLM providers: **Anthropic Messages**, **OpenAI Chat Completions**, **OpenAI Responses**, and anything compatible
+with them, with presets for Z.ai GLM Coding Plan (`zai-coding` → `https://api.z.ai/api/coding/paas/v4`,
+`zai-coding-anthropic`, `zai-coding-responses`) and local servers (`ollama`, `lmstudio`, `vllm`).
+No third-party Python dependencies; Python ≥ 3.11.
+
+## Install
+
+```bash
+pipx install jitcatch        # or: uv tool install jitcatch   /   pip install jitcatch
+```
+
+## Use
+
+Inside any git project, run:
+
+```bash
+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.
+
+What gets tested is picked automatically:
+
+1. uncommitted changes (including new files), compared with the last commit;
+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:
+
+```bash
+jitcatch run --base origin/main --head HEAD
+jitcatch run --base main --head feature --json report.json --markdown report.md --fail-on-catch
+```
+
+The project's own toolchain must work (`node_modules`, Maven/Gradle dependencies, Go modules). For Python,
+tests run in the project's `.venv` so its dependencies are importable; if that environment has no pytest,
+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.
+
+**Pre-push hook**
+
+```bash
+jitcatch install-hook              # reports only
+jitcatch install-hook --blocking   # a reported catch blocks the push
+JITCATCH_SKIP=1 git push           # bypass once
+```
+
+Tool or provider failures never block a push.
+
+## How scoring works
+
+Every weak catch is scored by up to three assessors, each in [−1 (false positive), 1 (true positive)]:
+
+1. **rules**: deterministic false-positive patterns from the paper (broken runner, reflection, type
+   mismatch, mocks, private/protected members, NotImplemented, key ordering, undefined names, call-count
+   expectations, network down, flakiness) and true-positive patterns (unexpected key/index error, emptied
+   container, construction failure, flipped boolean, behaviour change in a refactor, dead-code removal or
+   additive change, unexpected null, RBAC). A **high** false-positive pattern discards the catch before any
+   judge is called (`assessors.discard_on_high_fp_rule`).
+2. **llm_bucket**: median of the judges' High/Medium/Low.
+3. **llm_logprob** (optional): P(Yes) vs P(No) for the first answer token from an `openai_chat` provider
+   with `logprobs = true`.
+
+The combined score is a weighted mean of the available scores (`assessors.weights`); catches at or above
+`run.report_threshold` are reported, best first. All judge rationales are kept individually.
+
+## 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).
+
+## 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`,
+  `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.
+* Targeting is a heuristic stand-in for Meta's learned risk model, which needs historical data.
+* Logprob judging only reads Chat Completions logprobs; whether a given server returns them varies
+  (`jitcatch doctor --ping` reports it).
+
+## Development
+
+```bash
+pip install -e '.[dev]' && pytest
+```
+
+The suite runs the full pipeline end-to-end with a scripted LLM against real pytest, Go, Vitest (TypeScript)
+and Jest (JavaScript) projects, and against HTTP fake servers for the provider and GitHub wire formats.
+Java/JUnit execution is covered by placement/classification unit tests only.

jitcatch-0.2.0/jitcatch/__init__.py

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

jitcatch-0.2.0/jitcatch/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

jitcatch-0.2.0/jitcatch/adapters/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .base import Adapter, TestPlacement
+from .golang import GoAdapter
+from .java import JavaAdapter
+from .javascript import TypeScriptAdapter
+from .python import PythonAdapter
+
+ADAPTER_CLASSES: dict[str, type[Adapter]] = {
+    "python": PythonAdapter,
+    "typescript": TypeScriptAdapter,
+    "java": JavaAdapter,
+    "go": GoAdapter,
+}
+
+
+def build_adapters(settings: dict[str, Any], repo: Path) -> list[Adapter]:
+    out = []
+    for name, cls in ADAPTER_CLASSES.items():
+        s = settings.get(name, {})
+        if s.get("enabled", True):
+            out.append(cls(s, repo))
+    return out
+
+
+def adapter_for(adapters: list[Adapter], rel_path: str) -> Adapter | None:
+    for a in adapters:
+        if a.handles(rel_path):
+            return a
+    return None
+
+
+__all__ = ["Adapter", "TestPlacement", "build_adapters", "adapter_for", "ADAPTER_CLASSES"]

jitcatch-0.2.0/jitcatch/adapters/base.py

@@ -0,0 +1,137 @@
+"""Language adapter interface: where generated tests go, how they run, and how outcomes are classified."""
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ..models import Outcome, TestRun
+
+SKIP_DIRS = {".git", ".jitcatch", "node_modules", ".venv", "venv", "target", "build", "dist", "__pycache__", "vendor"}
+
+
+@dataclass
+class TestPlacement:
+    __test__ = False
+    rel_path: str                 # repo-relative path of the generated test file
+    instructions: str             # language/framework-specific constraints for the LLM
+    test_name_prefix: str = ""    # e.g. Go test function prefix used to select the test
+
+
+class Adapter:
+    name: str = "base"
+    fence_langs: tuple[str, ...] = ()
+    source_exts: tuple[str, ...] = ()
+
+    def __init__(self, settings: dict[str, Any], repo: Path):
+        self.settings = settings
+        self.repo = repo
+
+    # -- classification ---------------------------------------------------------------
+    def handles(self, rel_path: str) -> bool:
+        return rel_path.endswith(self.source_exts) and not self.is_test_file(rel_path)
+
+    def is_test_file(self, rel_path: str) -> bool:
+        raise NotImplementedError
+
+    # -- placement & prompting --------------------------------------------------------
+    def placement(self, source_rel: str, test_id: str, source_text: str) -> TestPlacement:
+        raise NotImplementedError
+
+    def related_test(self, source_rel: str) -> str | None:
+        """Repo-relative path of an existing test that most likely tests `source_rel`."""
+        stem = Path(source_rel).stem.lower()
+        best: tuple[int, str] | None = None
+        src_dir = Path(source_rel).parent
+        for dirpath, dirnames, filenames in os.walk(self.repo):
+            dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
+            for fn in filenames:
+                rel = str(Path(dirpath, fn).relative_to(self.repo))
+                if not self.is_test_file(rel) or "jitcatch" in fn.lower():
+                    continue
+                name = fn.lower()
+                if stem and stem in name:
+                    # prefer tests closest to the source file
+                    distance = len(set(Path(rel).parent.parts) ^ set(src_dir.parts))
+                    score = distance
+                    if best is None or score < best[0]:
+                        best = (score, rel)
+        return best[1] if best else None
+
+    def any_test_example(self) -> str | None:
+        for dirpath, dirnames, filenames in os.walk(self.repo):
+            dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
+            for fn in sorted(filenames):
+                rel = str(Path(dirpath, fn).relative_to(self.repo))
+                if self.is_test_file(rel) and "jitcatch" not in fn.lower():
+                    return rel
+        return None
+
+    # -- execution --------------------------------------------------------------------
+    def run_test(self, worktree: Path, test_rel: str, placement: TestPlacement, timeout: float) -> TestRun:
+        raise NotImplementedError
+
+    def run_existing_tests(self, worktree: Path, source_rel: str, timeout: float) -> TestRun | None:
+        """Run the project's existing tests relevant to `source_rel`. None = unsupported."""
+        return None
+
+    def available(self) -> tuple[bool, str]:
+        """Is the toolchain usable? Returns (ok, reason)."""
+        return True, ""
+
+    def can_test(self, rel_path: str) -> tuple[bool, str]:
+        """Can this particular file be tested (e.g. its package has a supported runner)? Returns (ok, reason)."""
+        return True, ""
+
+
+# -- helpers ------------------------------------------------------------------------------
+
+def run_cmd(cmd: list[str], cwd: Path, timeout: float, env_extra: dict[str, str] | None = None) -> tuple[int, str, float, bool]:
+    """Run a command; returns (exit_code, combined_output, seconds, timed_out)."""
+    env = dict(os.environ)
+    env.update({"CI": "1", "NO_COLOR": "1", "FORCE_COLOR": "0", "PYTHONDONTWRITEBYTECODE": "1"})
+    if env_extra:
+        env.update(env_extra)
+    t0 = time.monotonic()
+    try:
+        proc = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, encoding="utf-8",
+                              errors="replace", timeout=timeout, env=env)
+        out = (proc.stdout or "") + ("\n" + proc.stderr if proc.stderr else "")
+        return proc.returncode, strip_ansi(out), time.monotonic() - t0, False
+    except subprocess.TimeoutExpired as e:
+        out = (e.stdout or b"")
+        out = out.decode("utf-8", "replace") if isinstance(out, bytes) else out
+        return -1, strip_ansi(out) + f"\n[jitcatch] TIMEOUT after {timeout}s", time.monotonic() - t0, True
+    except FileNotFoundError as e:
+        return -2, f"[jitcatch] command not found: {e}", time.monotonic() - t0, False
+
+
+_ANSI = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
+
+
+def strip_ansi(s: str) -> str:
+    return _ANSI.sub("", s)
+
+
+def make_run(outcome: Outcome, code: int, out: str, secs: float, cmd: list[str]) -> TestRun:
+    return TestRun(outcome=outcome, exit_code=code, output=truncate_output(out), duration_s=round(secs, 2), command=cmd)
+
+
+def truncate_output(out: str, head: int = 3000, tail: int = 12000) -> str:
+    if len(out) <= head + tail:
+        return out
+    return out[:head] + f"\n... [{len(out) - head - tail} chars truncated] ...\n" + out[-tail:]
+
+
+def nearest_dir_with(start: Path, stop: Path, names: tuple[str, ...]) -> Path | None:
+    d = start
+    while True:
+        if any((d / n).exists() for n in names):
+            return d
+        if d == stop or d.parent == d:
+            return None
+        d = d.parent

jitcatch-0.2.0/jitcatch/adapters/golang.py

@@ -0,0 +1,88 @@
+"""Go adapter (go test)."""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path, PurePosixPath
+
+from ..models import Outcome, TestRun
+from .base import Adapter, TestPlacement, make_run, nearest_dir_with, run_cmd
+
+_PKG_RE = re.compile(r"^\s*package\s+(\w+)", re.M)
+
+
+class GoAdapter(Adapter):
+    name = "go"
+    fence_langs = ("go", "golang")
+    source_exts = (".go",)
+
+    def is_test_file(self, rel_path: str) -> bool:
+        return rel_path.endswith("_test.go")
+
+    def handles(self, rel_path: str) -> bool:
+        return super().handles(rel_path) and "/vendor/" not in f"/{rel_path}" and "/testdata/" not in f"/{rel_path}"
+
+    def related_test(self, source_rel: str) -> str | None:
+        p = PurePosixPath(source_rel)
+        cand = p.with_name(p.stem + "_test.go")
+        if (self.repo / cand).exists():
+            return str(cand)
+        for f in sorted((self.repo / p.parent).glob("*_test.go")):
+            if "jitcatch" not in f.name:
+                return str(f.relative_to(self.repo))
+        return None
+
+    def available(self) -> tuple[bool, str]:
+        code, _, _, _ = run_cmd(["go", "version"], self.repo, 60)
+        return (code == 0, "" if code == 0 else "go not available")
+
+    def placement(self, source_rel: str, test_id: str, source_text: str) -> TestPlacement:
+        p = PurePosixPath(source_rel)
+        m = _PKG_RE.search(source_text)
+        pkg = m.group(1) if m else "main"
+        rel = str(p.parent / f"{p.stem}_jitcatch_{test_id}_test.go")
+        prefix = f"TestJitcatch{test_id.upper()}"
+        instr = (
+            f"Framework: Go's standard `testing` package. The file must start with `package {pkg}` (same package, "
+            f"so unexported identifiers are accessible) and every test function name must start with `{prefix}` "
+            f"(e.g. `func {prefix}Something(t *testing.T)`). Only import the standard library and modules already "
+            "in go.mod. Do not use network, sleeps, randomness or time.Now; avoid reflect."
+        )
+        return TestPlacement(rel_path=rel, instructions=instr, test_name_prefix=prefix)
+
+    def _module(self, base: Path, rel: str) -> Path:
+        return nearest_dir_with((base / rel).parent, base, ("go.mod",)) or base
+
+    def run_test(self, worktree: Path, test_rel: str, placement: TestPlacement, timeout: float) -> TestRun:
+        mod = self._module(worktree, test_rel)
+        pkg_dir = os.path.relpath(worktree / PurePosixPath(test_rel).parent, mod)
+        target = "./" + pkg_dir.replace(os.sep, "/") if pkg_dir != "." else "."
+        cmd = ["go", "test", target, "-run", f"^{placement.test_name_prefix}", "-count=1", "-v",
+               *self.settings.get("extra_args", [])]
+        code, out, secs, timed_out = run_cmd(cmd, mod, timeout)
+        return make_run(self._classify(code, out, timed_out), code, out, secs, cmd)
+
+    def run_existing_tests(self, worktree: Path, source_rel: str, timeout: float) -> TestRun | None:
+        mod = self._module(worktree, source_rel)
+        pkg_dir = os.path.relpath(worktree / PurePosixPath(source_rel).parent, mod)
+        target = "./" + pkg_dir.replace(os.sep, "/") if pkg_dir != "." else "."
+        cmd = ["go", "test", target, "-count=1"]
+        code, out, secs, timed_out = run_cmd(cmd, mod, timeout)
+        outcome = Outcome.PASS if code == 0 else self._classify(code, out, timed_out)
+        return make_run(outcome, code, out, secs, cmd)
+
+    @staticmethod
+    def _classify(code: int, out: str, timed_out: bool) -> Outcome:
+        if timed_out or code == -2:
+            return Outcome.INFRA
+        if re.search(r"\[(build|setup) failed\]|^# \S+|cannot find package|no required module provides", out, re.M):
+            return Outcome.ERROR
+        if code == 0:
+            if "no tests to run" in out or "[no test files]" in out:
+                return Outcome.NO_TESTS
+            return Outcome.PASS
+        if re.search(r"^--- FAIL|^panic:|^FAIL\s", out, re.M):
+            return Outcome.FAIL
+        if re.search(r"go: (downloading|error loading)|dial tcp|proxy\.golang\.org", out):
+            return Outcome.INFRA
+        return Outcome.ERROR