bite-check 1.0.0__tar.gz → 1.0.2__tar.gz

{bite_check-1.0.0 → bite_check-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bite-check
-Version: 1.0.0
+Version: 1.0.2
 Summary: Checks whether the "fixed" in your coding agent's recent commits is actually true.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/connabyss/bite
@@ -39,6 +39,20 @@ Bite checks whether an AI coding agent's "fixed" is actually true.
 
 <img alt="bite --demo: one fix is noticed by a test, the other has no test at all" src="https://raw.githubusercontent.com/connabyss/bite/main/assets/bite-demo.svg" width="760">
 
+**Try it on your own repo in one line.** It's free, needs no key, and never changes your files:
+
+```
+cd your-repo
+uvx bite-check --free
+```
+
+No [uv](https://docs.astral.sh/uv/)? `pipx run bite-check --free` does the same with [pipx](https://pipx.pypa.io).
+If your commits never say "fix", add `--any` to check every recent change. To keep Bite installed, see
+[Try it in a minute](#try-it-in-a-minute).
+
+**Here for Hack Week or your first open-source PR?** These [good first issues](https://github.com/connabyss/bite/labels/good%20first%20issue)
+are small, and each one says where to look and when it's done. Comment on one to claim it.
+
 ## Why you need this
 
 When an AI fixes a bug for you, it often says "Fixed, and I added a test." If you don't read code, you can't tell
@@ -284,7 +298,7 @@ jobs:
       # install what your tests need here, e.g. for Python:
       - uses: actions/setup-python@v7
       - run: python -m pip install pytest -r requirements.txt
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
 ```
 
 Options go under `with:`: `args` (extra `bite` options, e.g. `--serious`), `max-commits` (default 20),
@@ -298,7 +312,7 @@ When no test noticed a change, Bite can write that test for you. Add your Anthro
 named `ANTHROPIC_API_KEY`, then:
 
 ```yaml
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
         with:
           write-tests: true
           anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -415,7 +429,7 @@ jobs:
         with:
           fetch-depth: 0
       # install what your tests need here, as in the pull request check
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
         with:
           badge-branch: bite-badge
           max-commits: 10

{bite_check-1.0.0 → bite_check-1.0.2}/README.md

@@ -13,6 +13,20 @@ Bite checks whether an AI coding agent's "fixed" is actually true.
 
 <img alt="bite --demo: one fix is noticed by a test, the other has no test at all" src="https://raw.githubusercontent.com/connabyss/bite/main/assets/bite-demo.svg" width="760">
 
+**Try it on your own repo in one line.** It's free, needs no key, and never changes your files:
+
+```
+cd your-repo
+uvx bite-check --free
+```
+
+No [uv](https://docs.astral.sh/uv/)? `pipx run bite-check --free` does the same with [pipx](https://pipx.pypa.io).
+If your commits never say "fix", add `--any` to check every recent change. To keep Bite installed, see
+[Try it in a minute](#try-it-in-a-minute).
+
+**Here for Hack Week or your first open-source PR?** These [good first issues](https://github.com/connabyss/bite/labels/good%20first%20issue)
+are small, and each one says where to look and when it's done. Comment on one to claim it.
+
 ## Why you need this
 
 When an AI fixes a bug for you, it often says "Fixed, and I added a test." If you don't read code, you can't tell
@@ -258,7 +272,7 @@ jobs:
       # install what your tests need here, e.g. for Python:
       - uses: actions/setup-python@v7
       - run: python -m pip install pytest -r requirements.txt
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
 ```
 
 Options go under `with:`: `args` (extra `bite` options, e.g. `--serious`), `max-commits` (default 20),
@@ -272,7 +286,7 @@ When no test noticed a change, Bite can write that test for you. Add your Anthro
 named `ANTHROPIC_API_KEY`, then:
 
 ```yaml
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
         with:
           write-tests: true
           anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -389,7 +403,7 @@ jobs:
         with:
           fetch-depth: 0
       # install what your tests need here, as in the pull request check
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
         with:
           badge-branch: bite-badge
           max-commits: 10

{bite_check-1.0.0 → bite_check-1.0.2}/bite.py

@@ -659,11 +659,30 @@ def locked_run(cfg: Config, cmd: str, cwd: Path, lane: str = ""):
     if why:
         return None, f"not run: {why}"
     try:
-        return run_cmd(contain(cfg, cmd, cwd), cwd, cfg.test_timeout)
+        return run_cmd(contain(cfg, cmd, cwd), cwd, run_limit(cfg))
     finally:
         lock.release()
 
 
+# A run with a change taken out that takes this many times as long as the run with it in (and at least
+# HANG_FLOOR seconds) is a hang: an unbounded loop the change had bounded, say. Waiting out test_timeout for it
+# (10 minutes by default, and the flaky rerun and the piece check wait again) stalled whole runs.
+HANG_TIMES, HANG_FLOOR = 5, 60
+
+
+def run_limit(cfg) -> int:
+    """How long one test run may take: test_timeout, or less once cap_hang has seen how long the tests take."""
+    cap = getattr(cfg, "hang_cap", 0)
+    return min(cfg.test_timeout, cap) if cap else cfg.test_timeout
+
+
+def cap_hang(cfg, now: dict) -> None:
+    """The tests took now["secs"] with the change in. Later runs on this copy (the change taken out) stop at
+    HANG_TIMES that, so a change whose removal makes the tests hang shows as noticed in a minute or two."""
+    if now.get("secs") is not None:
+        cfg.hang_cap = max(HANG_FLOOR, int(HANG_TIMES * now["secs"]) + 1)
+
+
 EXTRA_ENV = {}  # e.g. BITE_PERSONA and BITE_OUT for a crowd run
 
 
@@ -712,11 +731,14 @@ def exit_why(cmd: str, rc: int) -> str:
 
 def run_tests(cfg: Config, folder: Path) -> dict:
     cmd = tests_cmd(cfg).replace("{project}", str(folder)).replace("{seed}", SEED[0])
+    start = time.monotonic()
     rc, out = locked_run(cfg, cmd, folder)
+    secs = round(time.monotonic() - start, 1)
     if rc is None:
-        why = out if out.startswith("not run:") else f"timed out after {cfg.test_timeout}s (test_command must exit on its own)"
-        return {"ok": False, "why": why,
-                "fails": [], "count": None, "out": out}
+        hung = not out.startswith("not run:")
+        why = f"timed out after {run_limit(cfg)}s (test_command must exit on its own)" if hung else out
+        return {"ok": False, "why": why, "fails": [], "count": None, "out": out, "hung": hung,
+                "secs": secs if hung else None}
     fails = [ln.strip() for ln in out.splitlines() if re.search(cfg.fail_pattern, ln) and not PASSED_LINE.match(ln)]
     count = None
     if cfg.count_pattern:
@@ -726,7 +748,7 @@ def run_tests(cfg: Config, folder: Path) -> dict:
         count = auto_count(out)
     ok = rc in cfg.ok_codes and not fails and (count is None or count > 0)
     why = (exit_why(cmd, rc) if rc else "") or (fails[0][:160] if fails else "") or ("no tests ran" if count == 0 else "")
-    return {"ok": ok, "why": why, "fails": fails, "count": count, "out": out}
+    return {"ok": ok, "why": why, "fails": fails, "count": count, "out": out, "secs": secs}
 
 
 def safe_write(root: Path, target: Path, data: bytes):

{bite_check-1.0.0 → bite_check-1.0.2}/bite_check.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bite-check
-Version: 1.0.0
+Version: 1.0.2
 Summary: Checks whether the "fixed" in your coding agent's recent commits is actually true.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/connabyss/bite
@@ -39,6 +39,20 @@ Bite checks whether an AI coding agent's "fixed" is actually true.
 
 <img alt="bite --demo: one fix is noticed by a test, the other has no test at all" src="https://raw.githubusercontent.com/connabyss/bite/main/assets/bite-demo.svg" width="760">
 
+**Try it on your own repo in one line.** It's free, needs no key, and never changes your files:
+
+```
+cd your-repo
+uvx bite-check --free
+```
+
+No [uv](https://docs.astral.sh/uv/)? `pipx run bite-check --free` does the same with [pipx](https://pipx.pypa.io).
+If your commits never say "fix", add `--any` to check every recent change. To keep Bite installed, see
+[Try it in a minute](#try-it-in-a-minute).
+
+**Here for Hack Week or your first open-source PR?** These [good first issues](https://github.com/connabyss/bite/labels/good%20first%20issue)
+are small, and each one says where to look and when it's done. Comment on one to claim it.
+
 ## Why you need this
 
 When an AI fixes a bug for you, it often says "Fixed, and I added a test." If you don't read code, you can't tell
@@ -284,7 +298,7 @@ jobs:
       # install what your tests need here, e.g. for Python:
       - uses: actions/setup-python@v7
       - run: python -m pip install pytest -r requirements.txt
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
 ```
 
 Options go under `with:`: `args` (extra `bite` options, e.g. `--serious`), `max-commits` (default 20),
@@ -298,7 +312,7 @@ When no test noticed a change, Bite can write that test for you. Add your Anthro
 named `ANTHROPIC_API_KEY`, then:
 
 ```yaml
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
         with:
           write-tests: true
           anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -415,7 +429,7 @@ jobs:
         with:
           fetch-depth: 0
       # install what your tests need here, as in the pull request check
-      - uses: connabyss/bite@v1.0.0
+      - uses: connabyss/bite@v1.0.2
         with:
           badge-branch: bite-badge
           max-commits: 10

{bite_check-1.0.0 → bite_check-1.0.2}/bite_check.egg-info/SOURCES.txt

@@ -25,7 +25,9 @@ tests/test_copy_names.py
 tests/test_deleted_files.py
 tests/test_doctests.py
 tests/test_fail_comment.py
+tests/test_first_run.py
 tests/test_go_other_systems.py
+tests/test_hang.py
 tests/test_huge_files.py
 tests/test_java_kotlin.py
 tests/test_jobs_memory.py
@@ -44,6 +46,7 @@ tests/test_open_pr.py
 tests/test_passing_names.py
 tests/test_paste_paths.py
 tests/test_pr_checklist.py
+tests/test_progress.py
 tests/test_publish_badge.py
 tests/test_rust_doc_examples.py
 tests/test_rust_unit_tests.py

{bite_check-1.0.0 → bite_check-1.0.2}/bite_check.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 bite = recent:main
+bite-check = recent:main

{bite_check-1.0.0 → bite_check-1.0.2}/live.py

@@ -112,12 +112,14 @@ def check(root: Path, base: str = "HEAD") -> dict:
             return {**r, "status": "cant", "why": f"the tests fail with the change in ({now['why']})"}
         if recent.ran_nothing(bite.tests_cmd(fcfg), now["out"]):
             return {**r, "status": "cant", "why": "no tests ran"}
+        bite.cap_hang(fcfg, now)
         recent.take_out(root, {"code": code, "before": base}, folder)
         out = bite.run_tests(fcfg, folder)
         if out["ok"]:
             test_code = [n for n in tests if Path(n).suffix.lower() in repo.CODE_SUFFIXES]
             return {**r, "status": "tests_blind" if test_code else "unguarded", "test_code": test_code}
-        return {**r, "status": "guarded", "caught": recent.caught_by(out["out"])}
+        caught = recent.caught_by(out["out"])
+        return {**r, "status": "guarded", "caught": caught, "hang": "" if caught else recent.hang_note(out, now)}
     finally:
         shutil.rmtree(folder.parent, ignore_errors=True)
 
@@ -134,6 +136,9 @@ def say(r: dict) -> str:
         return "Bite: no code your tests run has changed, so there's nothing to check."
     if s == "cant":
         return f"Bite couldn't check this change: {r['why']}."
+    if s == "guarded" and r.get("hang"):
+        return (f"Bite ✅ the tests noticed: with the change to {files(r['code'])} taken out, they hang "
+                f"({r['hang']}).")
     if s == "guarded":
         who = f" ({r['caught']})" if r.get("caught") else ""
         return f"Bite ✅ a test noticed: with the change to {files(r['code'])} taken out, the tests fail{who}."

{bite_check-1.0.0 → bite_check-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bite-check"
-version = "1.0.0"
+version = "1.0.2"
 description = "Checks whether the \"fixed\" in your coding agent's recent commits is actually true."
 readme = "README.md"
 license = "MIT"
@@ -27,6 +27,7 @@ test = ["pytest", "pytest-xdist"]
 
 [project.scripts]
 bite = "recent:main"
+bite-check = "recent:main"  # so `uvx bite-check` and `pipx run bite-check` work with no --from
 
 [project.urls]
 Homepage = "https://github.com/connabyss/bite"

{bite_check-1.0.0 → bite_check-1.0.2}/recent.py

@@ -945,25 +945,43 @@ def tests_pass_at(root: Path, sha: str, cfg) -> tuple[bool, str]:
 JOBS = [1]  # --jobs N: how many commits are checked at the same time
 _GATE = threading.Condition()
 _BUSY = [0, False]  # test runs going on side by side, and whether one has the machine to itself
+_SHARED = {}  # each test run going on now: whether another ran beside it at any point
 
 
-def run_tests(fcfg, folder) -> dict:
+def run_tests(fcfg, folder, alone: bool = False, confirm: bool = True) -> dict:
     """bite.run_tests, and with --jobs, side by side with other commits' runs. Tests run side by side can trip over
     each other (the same port, the same database), and a failure caused by that would read as "a test noticed" and
-    hide a real gap. So with --jobs a failed run counts only if it fails again with the machine to itself."""
+    hide a real gap. So with --jobs a failed run that shared the machine with another run counts only if it fails
+    again with the machine to itself. A run that had the machine to itself anyway (one commit to check, or the
+    others already done) isn't run twice: that only doubled the time of every failing run.
+    alone: run it with the machine to itself straight away. confirm=False: return a failed shared run as it is
+    (marked "shared"), for a caller whose next run (alone) confirms it anyway."""
     if JOBS[0] <= 1:
         return bite.run_tests(fcfg, folder)
+    if alone:
+        return _run_alone(fcfg, folder)
+    me = object()
     with _GATE:
         _GATE.wait_for(lambda: not _BUSY[1])
         _BUSY[0] += 1
+        _SHARED[me] = bool(_SHARED)
+        for other in _SHARED:  # every run going on now shares the machine with this one
+            _SHARED[other] = _SHARED[other] or _SHARED[me]
     try:
         r = bite.run_tests(fcfg, folder)
     finally:
         with _GATE:
             _BUSY[0] -= 1
+            shared = _SHARED.pop(me)
             _GATE.notify_all()
-    if r["ok"]:
+    if r["ok"] or not shared:
         return r
+    if not confirm:
+        return {**r, "shared": True}
+    return _run_alone(fcfg, folder)
+
+
+def _run_alone(fcfg, folder) -> dict:
     with _GATE:
         _GATE.wait_for(lambda: not _BUSY[1] and not _BUSY[0])
         _BUSY[1] = True
@@ -1019,6 +1037,11 @@ def remember(root: Path, memo: dict) -> None:
     (proof_dir(root) / "checked.json").write_text(json.dumps(memo, indent=1), encoding="utf-8")
 
 
+def doing(c: dict, text: str) -> None:
+    """One line before each test run, so a slow check shows what it is doing instead of going quiet."""
+    print(f"    {c['sha'][:8]} {text}", flush=True)
+
+
 def undo_check(root: Path, c: dict, cfg) -> str:
     """check_undo, but a file Bite can't read or write in one commit's copy (a link, a locked file, a full disk)
     only stops the check of that commit, not the whole run: it shows as couldn't check, with the reason."""
@@ -1040,14 +1063,21 @@ def check_undo(root: Path, c: dict, cfg) -> str:
     if getattr(cfg, "free_cmd", ""):  # the faster subset, for this step only
         fcfg.test_cmd, fcfg.box_test_cmd = cfg.free_cmd, ""
     try:
+        doing(c, "running the tests with the change in...")
         now = run_tests(fcfg, folder)
         if not now["ok"]:
             c["why"] = fail_why(now)
             return "tests fail at this commit"
         if ran_nothing(bite.tests_cmd(fcfg), now["out"]):
             return "no tests ran at this commit"
+        bite.cap_hang(fcfg, now)
         take_out(root, c, folder)
-        undone = run_tests(fcfg, folder)
+        doing(c, f"running them with the change taken out (they took {took(now)} with it in)...")
+        # A failure beside another commit's run (--jobs) is confirmed by the next run, alone: the rerun below, or
+        # here when there is none. Confirming it straight away too ran every noticed change's tests twice more.
+        undone = run_tests(fcfg, folder, confirm=False)
+        if undone.get("shared") and (QUICK[0] or bite.load_failure(undone["out"])):
+            undone = run_tests(fcfg, folder, alone=True)
 
         def flag():  # would be flagged: first rule out the usual harmless reasons
             if c.get("skip"):
@@ -1065,11 +1095,15 @@ def check_undo(root: Path, c: dict, cfg) -> str:
         if not crashed and not QUICK[0]:
             # Once more: a test that fails now and then (flaky) can fail by luck. Only a test that fails every
             # time the change is out counts as noticing it.
-            again = run_tests(fcfg, folder)
+            doing(c, "a test failed: running them once more, to rule out a test that fails by luck"
+                     + (" (alone, so the other check running beside it can't be the cause)..." if undone.get("shared") else "..."))
+            again = run_tests(fcfg, folder, alone=bool(undone.get("shared")))
             if again["ok"]:
-                c["flaky"] = caught_by(undone["out"]) or "a test"
+                if not undone.get("shared"):  # beside another run, it may have been the other run's doing
+                    c["flaky"] = caught_by(undone["out"]) or "a test"
                 return flag()
         c["caught"] = caught_by(undone["out"])
+        hung = not c["caught"] and hang_note(undone, now)
         missed = unnoticed_part(root, c, folder, fcfg)
         if missed and c.get("skip"):
             return f"not flagged: {c['skip']}"
@@ -1091,6 +1125,9 @@ def check_undo(root: Path, c: dict, cfg) -> str:
                 c["caught"], c["gone"] = caught, gone
                 return "guard gone since"
             c["caught"] = caught
+        if hung:
+            c["hang"] = hung
+            return "guarded (tests hang without it)"
         return "guarded" if not crashed else "guarded (tests use the new code)"
     finally:
         shutil.rmtree(folder.parent, ignore_errors=True)
@@ -1229,7 +1266,7 @@ def unnoticed_part(root: Path, c: dict, folder: Path, fcfg) -> list:
         PART_RUNS[0] -= len(ps)
     news = {rel: repo.git(root, "cat-file", "blob", f"{c['sha']}:{rel}", raw=True) for rel in c["code"]}
     missed = []
-    for p in ps:
+    for n, p in enumerate(ps, 1):
         rel, undone = p[0], p[2]
         for r, b in news.items():  # the whole change back in
             if b is not None:
@@ -1238,6 +1275,7 @@ def unnoticed_part(root: Path, c: dict, folder: Path, fcfg) -> list:
             take_out(root, {**c, "code": [rel]}, folder)  # a file the commit created
         else:
             bite.safe_write(folder, folder / rel, undone)
+        doing(c, f"piece {n} of {len(ps)} ({p[1] + ' in ' if p[1] else ''}{p[0]}) taken out alone: does a test notice it?")
         run = run_tests(fcfg, folder)
         if run["ok"] and not ran_nothing(bite.tests_cmd(fcfg), run["out"]):
             missed.append(p)
@@ -1259,6 +1297,18 @@ def caught_by(out: str) -> str:
     return f"`{names[0]}`" + (f" and {len(names) - 1} more" if len(names) > 1 else "")
 
 
+def took(run: dict) -> str:
+    secs = round(run.get("secs") or 0)
+    return f"{secs // 60}m {secs % 60}s" if secs >= 60 else f"{secs}s"
+
+
+def hang_note(undone: dict, now: dict) -> str:
+    """When the tests hung with the change taken out (see bite.cap_hang), that is what noticed it, in words."""
+    if not undone.get("hung"):
+        return ""
+    return f"stopped after {round(undone['secs'])}s; they take {round(now['secs'])}s with it"
+
+
 def closed_since(root: Path, c: dict, cfg) -> bool:
     """A later commit may have closed the gap: on today's code, take this commit's change back out (if it still
     applies) and see whether today's tests now fail where they passed before."""
@@ -1316,14 +1366,18 @@ def today_notices(root: Path, c: dict, cfg):
             diff, flags = change_diff(root, c, 0), ["--unidiff-zero"]
         if not diff or not git_apply_ok(folder, diff, "-R", "--check", *flags):
             return None  # today's code moved on: can't tell
+        doing(c, "on today's code: running the tests with the change in...")
         now = run_tests(fcfg, folder)
         if not now["ok"] or ran_nothing(bite.tests_cmd(fcfg), now["out"]):
             return None
+        bite.cap_hang(fcfg, now)
         git_apply_ok(folder, diff, "-R", *flags)
+        doing(c, "on today's code: running them with the change taken out...")
         undone = run_tests(fcfg, folder)
         if undone["ok"]:
             return False
-        c["caught"] = caught_by(undone["out"])
+        hung = hang_note(undone, now)
+        c["caught"] = caught_by(undone["out"]) or (f"the tests hang without it: {hung}" if hung else "")
         return None if bite.load_failure(undone["out"]) else True
     finally:
         shutil.rmtree(folder.parent, ignore_errors=True)
@@ -1750,6 +1804,9 @@ def say(c: dict, newest: str = "") -> tuple[str, str, str]:
                 "today's code. **Next:** if that wasn't on purpose, put the fix back with a test that fails without it.")
     if u.startswith("closed since"):
         return "held", "✅ a later test notices", f"✅ A test added in a later commit notices it now{f' ({caught})' if caught else ''}."
+    if u == "guarded (tests hang without it)":
+        return ("held", "✅ tests hang without it", "✅ Without this change your tests hang"
+                f"{f' ({h})' if (h := c.get('hang')) else ''}, so they'd notice if it went.")
     if u == "guarded (tests use the new code)":
         return "held", "✅ tests crash without it", "✅ Without this change your tests crash, so they'd notice if it went."
     if u.startswith("guarded"):
@@ -2519,7 +2576,31 @@ def _newer(latest, current):
         return False
 
 
+def leave_own_python() -> None:
+    """Run the project's tests with the project's Python, not Bite's own. A tool runner like uvx
+    (`uvx --from bite-check bite --free`) puts Bite's private environment first on PATH, so "python3 -m pytest"
+    found a Python with no pytest and none of the project's packages. Drop that folder from PATH unless it's an
+    environment the user turned on (VIRTUAL_ENV) or one inside the project (uv run, poetry, .venv)."""
+    if sys.prefix == sys.base_prefix:
+        return  # Bite runs in a plain Python: nothing of its own to step around
+    own = Path(sys.prefix, "Scripts" if bite.WINDOWS else "bin")
+    parts = os.environ.get("PATH", "").split(os.pathsep)
+    same = lambda a, b: os.path.normcase(os.path.abspath(a)) == os.path.normcase(os.path.abspath(b))
+    if not parts or not parts[0] or not same(parts[0], own):
+        return  # pipx, pip install and the plugin leave PATH alone: their Python is found the usual way
+    if os.environ.get("VIRTUAL_ENV") and same(os.environ["VIRTUAL_ENV"], sys.prefix):
+        return
+    try:
+        Path.cwd().resolve().relative_to(Path(sys.prefix).resolve().parent)
+        return  # the project's own .venv, with Bite installed in it
+    except ValueError:
+        pass
+    os.environ["PATH"] = os.pathsep.join(p for p in parts if not (p and same(p, own)))
+
+
 def main(argv=None):
+    if argv is None:  # run from the command line (a test calling main() keeps its own PATH)
+        leave_own_python()
     argv = list(sys.argv[1:] if argv is None else argv)
     if "--json" in argv and argv[:1] not in (["live"], ["ask"], ["mcp"]) and not {"-h", "--help", "--version"} & set(argv):
         # Only the results go to stdout, so a program can read them; what Bite says along the way goes to stderr.
@@ -2624,6 +2705,7 @@ def main(argv=None):
         return 1
     t0 = time.time()
     cs = commits(root, opt("--last", 40), since)  # --all is still accepted: every commit is the default now
+    seen = len(cs)
     top = cs[0]["sha"] if cs else ""  # the newest commit of all, even one that changed no code
     for c in cs:
         files_of(root, c, cfg)
@@ -2639,7 +2721,11 @@ def main(argv=None):
               + ", ".join(c["sha"][:8] for c in other), flush=True)
     if not cs:
         thin = repo.shallow(root)  # --last can't help: the history isn't there
-        print(f"Nothing to check. {repo.SHALLOW}" if thin else "Nothing to check. Try a larger --last.")
+        whole = not since and seen < int(opt("--last", 40))  # git had fewer commits than asked for
+        print(f"Nothing to check. {repo.SHALLOW}" if thin else
+              f"Nothing to check: that was every commit in this repository ({seen}), and none changed code your "
+              f"tests run ({lang}). Make a change with a test, commit it, and run Bite again." if whole else
+              "Nothing to check. Try a larger --last.")
         write_comment(root, [], none=f"The code changed here isn't {lang}, and your tests only run {lang}, so they "
                                      "can't notice it." if other else repo.SHALLOW if thin else "")
         return 0
@@ -2669,7 +2755,8 @@ def main(argv=None):
         cs = [c for c in cs if c["test_code"]]
         print(f"No fix claims found in the last {opt('--last', 40)} commits, so there's nothing to hold them to"
               + (f". Checking the {len(cs)} that added tests: do those tests check the change?" if cs else
-                 ". (--any checks them anyway.)"), flush=True)
+                 ", and none of them added tests. To check every change anyway, run:\n    "
+                 + " ".join(["bite", *argv, "--any"])), flush=True)
         if not cs:
             write_comment(root, [], none="No commit in this pull request says it fixes something, so there's no claim to check.")
             return 0

bite_check-1.0.2/tests/test_first_run.py

@@ -0,0 +1,88 @@
+"""A newcomer's first run on their own small repo, walked through by hand (2026-11-02) before Hack Week. Three dead
+ends, each fixed here, and each test failed before its fix. No key, no network.
+
+1. `uvx --from bite-check bite --free` put Bite's own private Python first on PATH, so the tests ran with a Python
+   that has no pytest and none of the project's packages: "pytest isn't installed for this Python".
+2. A repo whose commits never say "fix" and never added tests ended with "(--any checks them anyway.)", and no
+   command to copy.
+3. A tiny repo whose few commits changed no code said "Try a larger --last", which can't help: Bite already saw
+   every commit there is."""
+
+import os
+import shutil
+import subprocess
+import sys
+import venv
+from pathlib import Path
+
+KIT = Path(__file__).resolve().parent.parent
+PY = sys.executable
+
+
+def git(root, *a):
+    return subprocess.run(["git", *a], cwd=root, check=True, capture_output=True, text=True).stdout
+
+
+def commit(root, msg):
+    git(root, "add", "-A")
+    git(root, "-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false", "commit", "-q", "-m", msg)
+
+
+def bite(root, *args, env=None, py=PY):
+    return subprocess.run([py, str(KIT / "recent.py"), *args], cwd=root, capture_output=True, text=True,
+                          timeout=300, env=env).stdout
+
+
+def shop(tmp_path, fix_msg="Fix total rounding"):
+    root = tmp_path / "shop"
+    (root / "tests").mkdir(parents=True)
+    git(root, "init", "-q")
+    (root / "shop.py").write_text("def total(xs):\n    return sum(xs)\n")
+    (root / "tests" / "test_shop.py").write_text("from shop import total\n\n\ndef test_total():\n"
+                                                 "    assert total([1, 2]) == 3\n")
+    commit(root, "start")
+    (root / "shop.py").write_text("def total(xs):\n    return round(sum(xs), 2)\n")
+    commit(root, fix_msg)
+    return root
+
+
+def test_run_through_uvx_uses_the_projects_python_not_bites_own(tmp_path):
+    root = shop(tmp_path)
+    own = tmp_path / "uv-cache" / "bite-env"  # stands in for uvx's private environment, which has no pytest
+    venv.create(own, with_pip=False)
+    bin_dir = own / ("Scripts" if os.name == "nt" else "bin")
+    own_py = next(p for p in (bin_dir / "python.exe", bin_dir / "python3", bin_dir / "python") if p.exists())
+    env = {k: v for k, v in os.environ.items() if k not in ("VIRTUAL_ENV", "PYTHONHOME", "PYTHONPATH")}
+    # uvx's PATH: its own bin first, then the user's (here: the Python that has pytest, as the project's would)
+    env["PATH"] = os.pathsep.join([str(bin_dir), str(Path(PY).parent), env.get("PATH", "")])
+    assert shutil.which("python", path=env["PATH"]) or shutil.which("python3", path=env["PATH"])
+    out = bite(root, "--free", env=env, py=str(own_py))
+    assert "isn't installed for this Python" not in out, out
+    assert "noticed" in out.lower(), out  # the check actually ran the tests
+
+
+def test_no_claims_and_no_new_tests_gives_the_command_to_check_anyway(tmp_path):
+    root = shop(tmp_path, fix_msg="round the total")
+    out = bite(root, "--free")
+    assert "bite --free --any" in out, out
+
+
+def test_a_tiny_repo_with_no_code_changes_doesnt_say_try_a_larger_last(tmp_path):
+    root = tmp_path / "notes"
+    (root / "tests").mkdir(parents=True)
+    git(root, "init", "-q")
+    (root / "notes.py").write_text("X = 1\n")
+    (root / "tests" / "test_notes.py").write_text("def test_x():\n    assert True\n")
+    (root / "README.md").write_text("# notes\n")
+    commit(root, "start")
+    (root / "README.md").write_text("# my notes\n")
+    commit(root, "Fix the title")
+    out = bite(root, "--free")
+    assert "Try a larger --last" not in out and "every commit in this repository" in out, out
+
+
+def test_the_package_name_is_also_a_command_so_uvx_bite_check_works():
+    # `uvx bite-check --free` and `pipx run bite-check --free` look for a command named after the package.
+    import re
+    scripts = (KIT / "pyproject.toml").read_text(encoding="utf-8").split("[project.scripts]", 1)[1].split("\n[", 1)[0]
+    assert re.search(r'^bite-check = "recent:main"', scripts, re.M), scripts

bite_check-1.0.2/tests/test_hang.py

@@ -0,0 +1,90 @@
+"""A fix that bounds a loop: with it taken out, the tests hang. That is the tests noticing, and Bite should say so
+in about a minute, not wait out test_timeout (10 minutes) for every run of the check. Found on Scrapling, whose
+"bound Cloudflare solver loops" fix stalled a free check for 25 minutes."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+import bite  # noqa: E402
+import live  # noqa: E402
+import recent  # noqa: E402
+
+HERE = str(Path(recent.__file__).resolve().parent)
+GIT = ["git", "-c", "user.name=t", "-c", "user.email=t@example.invalid", "-c", "commit.gpgsign=false"]
+
+LOOP = '''def first_ready(flags):
+    i = 0
+    while not flags[i % len(flags)]:
+        i += 1
+    return i % len(flags)
+'''
+BOUNDED = '''def first_ready(flags):
+    for i, ok in enumerate(flags):
+        if ok:
+            return i
+    return None
+'''
+TEST = ("from waiter import first_ready\n\n\ndef test_nothing_ready():\n    assert first_ready([False, False]) is None\n\n\n"
+        "def test_second_ready():\n    assert first_ready([False, True]) == 1\n")
+# Without the fix the hung run waits out this limit, so the time check below fails in two minutes, not ten.
+SETTINGS = "[bite]\ntest_command = python -m pytest -q -p no:cacheprovider\ntest_timeout_seconds = 120\n"
+
+
+def project() -> Path:
+    root = Path(tempfile.mkdtemp(prefix="bite_hang_"))
+    subprocess.run(["git", "init", "-q"], cwd=root, check=True)
+    steps = [("Start", {"waiter.py": LOOP, ".bite.ini": SETTINGS}),
+             ("Fix first_ready looping forever when nothing is ready", {"waiter.py": BOUNDED, "test_waiter.py": TEST})]
+    for subject, files in steps:
+        for name, text in files.items():
+            (root / name).write_text(text, encoding="utf-8", newline="\n")
+        subprocess.run([*GIT, "add", "-A"], cwd=root, check=True)
+        subprocess.run([*GIT, "commit", "-q", "-m", subject], cwd=root, check=True)
+    return root
+
+
+# A floor of 3 seconds instead of 60, so the test is quick; the rule (5 times the passing run) is the real one.
+RUN = ("import sys; sys.path.insert(0, sys.argv[1]); import bite; bite.HANG_FLOOR = 3; import recent; "
+       "sys.exit(recent.main(['--free', '--any', '--quick', '--json']))")
+
+
+def test_a_hang_with_the_fix_taken_out_counts_as_noticed_and_stops_early():
+    root = project()
+    start = time.monotonic()
+    p = subprocess.run([sys.executable, "-c", RUN, HERE], cwd=root, capture_output=True, text=True,
+                       encoding="utf-8", env={**os.environ, "PYTHONIOENCODING": "utf-8"})
+    took = time.monotonic() - start
+    assert p.stdout.strip(), p.stderr
+    r = next(c for c in json.loads(p.stdout)["commits"] if c["subject"].startswith("Fix first_ready"))
+    assert r["result"] == "noticed", r
+    assert "your tests hang" in r["detail"], r
+    assert took < 90, f"the hung run was not stopped early: {took:.0f}s"
+
+
+def test_the_cap_follows_the_passing_run():
+    cfg = type("Cfg", (), {"test_timeout": 600})()
+    assert bite.run_limit(cfg) == 600
+    bite.cap_hang(cfg, {"secs": 2.0})
+    assert bite.run_limit(cfg) == bite.HANG_FLOOR  # a quick suite: the floor
+    bite.cap_hang(cfg, {"secs": 40.0})
+    assert bite.run_limit(cfg) == 201
+    bite.cap_hang(cfg, {"secs": 500.0})
+    assert bite.run_limit(cfg) == 600  # never longer than test_timeout
+
+
+def test_the_live_check_stops_a_hang_early_too(monkeypatch):
+    root = project()
+    monkeypatch.setattr(bite, "HANG_FLOOR", 3)
+    subprocess.run([*GIT, "reset", "-q", "--soft", "HEAD~1"], cwd=root, check=True)  # the fix, not committed yet
+    start = time.monotonic()
+    r = live.check(root)
+    assert r["status"] == "guarded", r
+    assert r["hang"].startswith("stopped after"), r
+    assert "they hang" in live.say(r)
+    assert time.monotonic() - start < 90

bite_check-1.0.2/tests/test_progress.py

@@ -0,0 +1,81 @@
+"""The free check of one commit took over 8 minutes on Bite's own pull request check, with the log quiet after "free
+check of 1". Two fixes: with --jobs, a failing test run that had the machine to itself anyway isn't run a second
+time, and each test run gets a line in the log saying what it is."""
+
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+import recent  # noqa: E402
+
+RECENT = str(Path(recent.__file__))
+GIT = ["git", "-c", "user.name=t", "-c", "user.email=t@example.invalid", "-c", "commit.gpgsign=false"]
+
+
+def fake_runs(monkeypatch, secs=0.0):
+    calls = []
+
+    def run(fcfg, folder):
+        calls.append(folder)
+        time.sleep(secs)
+        return {"ok": False, "out": "", "why": "a test failed"}
+    monkeypatch.setattr(recent.bite, "run_tests", run)
+    monkeypatch.setattr(recent, "JOBS", [2])
+    return calls
+
+
+def test_a_failing_run_alone_on_the_machine_is_not_run_twice(monkeypatch):
+    calls = fake_runs(monkeypatch)
+    assert not recent.run_tests(None, "a")["ok"]
+    assert calls == ["a"]
+
+
+def test_a_failing_run_beside_another_is_run_again_alone(monkeypatch):
+    calls = fake_runs(monkeypatch, secs=0.3)
+    ts = [threading.Thread(target=recent.run_tests, args=(None, name)) for name in ("a", "b")]
+    for t in ts:
+        t.start()
+    for t in ts:
+        t.join()
+    assert sorted(calls) == ["a", "a", "b", "b"]
+
+
+def test_a_failing_run_beside_another_can_leave_the_confirming_to_the_next_run(monkeypatch):
+    calls = fake_runs(monkeypatch, secs=0.3)
+    out = {}
+    ts = [threading.Thread(target=lambda n=name: out.update({n: recent.run_tests(None, n, confirm=False)}))
+          for name in ("a", "b")]
+    for t in ts:
+        t.start()
+    for t in ts:
+        t.join()
+    assert sorted(calls) == ["a", "b"]  # not run again here: the flaky rerun, alone, confirms it
+    assert out["a"]["shared"] and out["b"]["shared"]
+    assert not recent.run_tests(None, "c", alone=True)["ok"]
+    assert sorted(calls) == ["a", "b", "c"]
+
+
+def test_the_log_says_what_each_test_run_is():
+    root = Path(tempfile.mkdtemp(prefix="bite_progress_"))
+    subprocess.run(["git", "init", "-q"], cwd=root, check=True)
+    steps = [("Start", {"price.py": "def total(a, b):\n    return a + b + 1\n",
+                        "test_price.py": "from price import total\n\n\ndef test_ok():\n    assert total(1, 1) >= 2\n"}),
+             ("Fix total adding one too many", {"price.py": "def total(a, b):\n    return a + b\n",
+                                                "test_price.py": "from price import total\n\n\n"
+                                                                 "def test_ok():\n    assert total(1, 1) == 2\n"})]
+    for subject, files in steps:
+        for name, text in files.items():
+            (root / name).write_text(text, encoding="utf-8", newline="\n")
+        subprocess.run([*GIT, "add", "-A"], cwd=root, check=True)
+        subprocess.run([*GIT, "commit", "-q", "-m", subject], cwd=root, check=True)
+    p = subprocess.run([sys.executable, RECENT, "--free", "--any"], cwd=root, capture_output=True, text=True,
+                       encoding="utf-8", env={**os.environ, "PYTHONIOENCODING": "utf-8"})
+    log = p.stdout + p.stderr
+    assert "running the tests with the change in..." in log, log
+    assert "with the change taken out" in log, log
+    assert "once more, to rule out a test that fails by luck" in log, log