crapkit 0.4.5__tar.gz → 0.4.6__tar.gz

{crapkit-0.4.5/src/crapkit.egg-info → crapkit-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.4.5
+Version: 0.4.6
 Summary: Scores every function on complexity times uncovered risk, ranks the worst, and blocks commits that add more.
 Author: Jean-Francois Gagne
 License: MIT
@@ -31,8 +31,10 @@ Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: pytest-cov>=5; extra == "dev"
 Requires-Dist: pytest-xdist>=3; extra == "dev"
+Requires-Dist: coverage>=7.10.6; extra == "dev"
 Provides-Extra: py
 Requires-Dist: pytest-cov>=5; extra == "py"
+Requires-Dist: coverage>=7.10.6; extra == "py"
 Dynamic: license-file
 
 # crapkit
@@ -143,7 +145,7 @@ changing crapkit.
 
 ```
 $ crapkit --version
-crapkit 0.4.5
+crapkit 0.4.6
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -344,7 +346,7 @@ crapkit ships a `.pre-commit-hooks.yaml` declaring `id: crapkit-gate`. In your
 repos:
   - repo: https://github.com/JeanFrancoisGagne/crapkit
     # crapkit's release step rewrites this line to the tag it just cut
-    rev: v0.4.5
+    rev: v0.4.6
     hooks:
       - id: crapkit-gate
 ```
@@ -614,7 +616,7 @@ crapkit: run 3 is an inventory run (no coverage was measured) and cannot serve a
 | 2 | Usage error from argparse: unknown flag, missing positional. Raised before crapkit's own error handling. |
 | 3 | Config error: `crapkit.toml` missing or unparseable, an unknown language or parser, a lane command the shell that runs it reads as a narrowed suite, a ratchet metric-stamp mismatch ([Upgrading from 0.4.4](#upgrading-from-044)), a `test-scoped` file under no scope or under a scope with no template. |
 | 4 | Git error: not a repository, a baseline commit rewritten out of the history. |
-| 5 | Tool error: lizard not importable, a lane produced no artifact, a lane timed out past its retries, an override alert command failed. A `timeout_seconds` kills the whole process tree, so no orphan suite keeps running behind the failure. |
+| 5 | Tool error: lizard not importable, a lane produced no artifact or one that measured a different tree, a lane timed out past its retries, an override alert command failed. A `timeout_seconds` kills the whole process tree, so no orphan suite keeps running behind the failure. |
 | 6 | Gate violation. A function the diff touched is over its ceiling and past any ratchet mark it carries: an edit that leaves a marked function at or under its mark is the debt the repo signed for and is exempt. Also `rescore --gate`, which applies the same rule, and `hook-precommit`, which exempts on the mark's existence instead. |
 | 7 | Ratchet regression the diff never touched. A marked function scores worse than its recorded high-water mark; a touched one past its mark reports 6. |
 | 8 | New test failures against the baseline run. Failures the baseline already had do not count. |
@@ -647,6 +649,11 @@ pip install pytest-cov
 
 (`pip install "crapkit[py]"` pulls both at once when crapkit shares the suite's venv.)
 
+If your suite drives its own CLI through `subprocess.run`, add `[tool.coverage.run]
+patch = ["subprocess"]` to `pyproject.toml` and keep `coverage>=7.10.6`: pytest-cov 7.0.0
+dropped subprocess measurement, so without that key every entry point scores 0% and nothing
+warns. [docs/lanes.md](docs/lanes.md) has the whole rule.
+
 ### 1. Scaffold the config
 
 ```
@@ -659,9 +666,13 @@ added to .gitignore: .crapkit/, .coverage, __pycache__/
 `init` sniffs tracked source into one scope per top-level source directory, and detects a
 coverage lane from what the repo already has: a pytest marker file (`pyproject.toml`,
 `pytest.ini`, `setup.cfg`) writes a live `[[lane]]`, and so does a `test` script or
-`vitest`/`jest` in `package.json`. Whatever it detects, it also leaves commented templates
-for the runners it did not find. Every lane it writes reports into `.crapkit/cov/`, which
-is why the `.gitignore` list is so short: see
+`vitest`/`jest` in `package.json`. A lockfile beside them names the environment: `uv.lock`,
+`poetry.lock`, `pdm.lock` or `Pipfile.lock` makes the lane `uv run python -m pytest …` (and
+the matching `run` for the rest), because a bare `python` binds to whichever venv the shell
+has active rather than the one the repo pins — see
+[The interpreter a lane binds to](docs/lanes.md#the-interpreter-a-lane-binds-to). Whatever
+it detects, it also leaves commented templates for the runners it did not find. Every lane
+it writes reports into `.crapkit/cov/`, which is why the `.gitignore` list is so short: see
 [Where artifacts live](docs/lanes.md#where-artifacts-live).
 
 ```toml
@@ -821,7 +832,7 @@ exit 5:
 
 ```
 $ crapkit coverage
-crapkit: lane 'js' FAILED: lane 'js' produced no artifact at .crapkit/cov/js/coverage-final.json (command exit 1); last output: $ npm run test -- --coverage --coverage.reportsDirectory=.crapkit/cov/js --reporter=default --reporter=junit --outputFile=.crapkit/cov/js/junit.xml
+crapkit: lane 'js' FAILED: lane 'js' produced no artifact at .crapkit/cov/js/coverage-final.json (command exit 1); full log: /repo/.crapkit/lane-js.log; last output: $ npm run test -- --coverage --coverage.reportsDirectory=.crapkit/cov/js --reporter=default --reporter=junit --outputFile=.crapkit/cov/js/junit.xml
 
  MISSING DEPENDENCY  Cannot find dependency '@vitest/coverage-v8'
 

{crapkit-0.4.5 → crapkit-0.4.6}/README.md

@@ -106,7 +106,7 @@ changing crapkit.
 
 ```
 $ crapkit --version
-crapkit 0.4.5
+crapkit 0.4.6
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -307,7 +307,7 @@ crapkit ships a `.pre-commit-hooks.yaml` declaring `id: crapkit-gate`. In your
 repos:
   - repo: https://github.com/JeanFrancoisGagne/crapkit
     # crapkit's release step rewrites this line to the tag it just cut
-    rev: v0.4.5
+    rev: v0.4.6
     hooks:
       - id: crapkit-gate
 ```
@@ -577,7 +577,7 @@ crapkit: run 3 is an inventory run (no coverage was measured) and cannot serve a
 | 2 | Usage error from argparse: unknown flag, missing positional. Raised before crapkit's own error handling. |
 | 3 | Config error: `crapkit.toml` missing or unparseable, an unknown language or parser, a lane command the shell that runs it reads as a narrowed suite, a ratchet metric-stamp mismatch ([Upgrading from 0.4.4](#upgrading-from-044)), a `test-scoped` file under no scope or under a scope with no template. |
 | 4 | Git error: not a repository, a baseline commit rewritten out of the history. |
-| 5 | Tool error: lizard not importable, a lane produced no artifact, a lane timed out past its retries, an override alert command failed. A `timeout_seconds` kills the whole process tree, so no orphan suite keeps running behind the failure. |
+| 5 | Tool error: lizard not importable, a lane produced no artifact or one that measured a different tree, a lane timed out past its retries, an override alert command failed. A `timeout_seconds` kills the whole process tree, so no orphan suite keeps running behind the failure. |
 | 6 | Gate violation. A function the diff touched is over its ceiling and past any ratchet mark it carries: an edit that leaves a marked function at or under its mark is the debt the repo signed for and is exempt. Also `rescore --gate`, which applies the same rule, and `hook-precommit`, which exempts on the mark's existence instead. |
 | 7 | Ratchet regression the diff never touched. A marked function scores worse than its recorded high-water mark; a touched one past its mark reports 6. |
 | 8 | New test failures against the baseline run. Failures the baseline already had do not count. |
@@ -610,6 +610,11 @@ pip install pytest-cov
 
 (`pip install "crapkit[py]"` pulls both at once when crapkit shares the suite's venv.)
 
+If your suite drives its own CLI through `subprocess.run`, add `[tool.coverage.run]
+patch = ["subprocess"]` to `pyproject.toml` and keep `coverage>=7.10.6`: pytest-cov 7.0.0
+dropped subprocess measurement, so without that key every entry point scores 0% and nothing
+warns. [docs/lanes.md](docs/lanes.md) has the whole rule.
+
 ### 1. Scaffold the config
 
 ```
@@ -622,9 +627,13 @@ added to .gitignore: .crapkit/, .coverage, __pycache__/
 `init` sniffs tracked source into one scope per top-level source directory, and detects a
 coverage lane from what the repo already has: a pytest marker file (`pyproject.toml`,
 `pytest.ini`, `setup.cfg`) writes a live `[[lane]]`, and so does a `test` script or
-`vitest`/`jest` in `package.json`. Whatever it detects, it also leaves commented templates
-for the runners it did not find. Every lane it writes reports into `.crapkit/cov/`, which
-is why the `.gitignore` list is so short: see
+`vitest`/`jest` in `package.json`. A lockfile beside them names the environment: `uv.lock`,
+`poetry.lock`, `pdm.lock` or `Pipfile.lock` makes the lane `uv run python -m pytest …` (and
+the matching `run` for the rest), because a bare `python` binds to whichever venv the shell
+has active rather than the one the repo pins — see
+[The interpreter a lane binds to](docs/lanes.md#the-interpreter-a-lane-binds-to). Whatever
+it detects, it also leaves commented templates for the runners it did not find. Every lane
+it writes reports into `.crapkit/cov/`, which is why the `.gitignore` list is so short: see
 [Where artifacts live](docs/lanes.md#where-artifacts-live).
 
 ```toml
@@ -784,7 +793,7 @@ exit 5:
 
 ```
 $ crapkit coverage
-crapkit: lane 'js' FAILED: lane 'js' produced no artifact at .crapkit/cov/js/coverage-final.json (command exit 1); last output: $ npm run test -- --coverage --coverage.reportsDirectory=.crapkit/cov/js --reporter=default --reporter=junit --outputFile=.crapkit/cov/js/junit.xml
+crapkit: lane 'js' FAILED: lane 'js' produced no artifact at .crapkit/cov/js/coverage-final.json (command exit 1); full log: /repo/.crapkit/lane-js.log; last output: $ npm run test -- --coverage --coverage.reportsDirectory=.crapkit/cov/js --reporter=default --reporter=junit --outputFile=.crapkit/cov/js/junit.xml
 
  MISSING DEPENDENCY  Cannot find dependency '@vitest/coverage-v8'
 

{crapkit-0.4.5 → crapkit-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "crapkit"
-version = "0.4.5"
+version = "0.4.6"
 description = "Scores every function on complexity times uncovered risk, ranks the worst, and blocks commits that add more."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }
@@ -63,14 +63,19 @@ Source = "https://github.com/JeanFrancoisGagne/crapkit"
 # about 8 minutes serial against about 1m30 parallel on the same tree. Nothing
 # here needs pytest-timeout: no test takes a `--timeout` and none carries the
 # marker.
-dev = ["pytest>=8", "pytest-cov>=5", "pytest-xdist>=3"]
+dev = ["pytest>=8", "pytest-cov>=5", "pytest-xdist>=3", "coverage>=7.10.6"]
+# coverage>=7.10.6 in both extras is the floor `[tool.coverage.run] patch` needs,
+# and it is not decoration: coverage 7.9 answers an unrecognized `[run] patch=`
+# with a CoverageWarning that pytest-cov 6.2.0 and later file under
+# `once::CoverageWarning`, so an older coverage takes the key, says so once in a
+# warnings block nobody reads, and measures no subprocess at all.
 # The py lane's runtime half, for installs that share the suite's venv: the
 # lane init writes runs `pytest --cov`, and those flags come from pytest-cov.
 # An install elsewhere (pipx, uv tool) still needs pytest-cov beside the SUITE;
 # init probes the python that runs pytest, not its own, and names
 # `pip install "crapkit[py]"` when those are the same environment. Double
 # quotes: single ones do not survive cmd.exe.
-py = ["pytest-cov>=5"]
+py = ["pytest-cov>=5", "coverage>=7.10.6"]
 
 [project.scripts]
 crapkit = "crapkit.cli:main"
@@ -85,3 +90,15 @@ where = ["src"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-q --tb=short -p no:cacheprovider"
+
+# Every CLI entry point crapkit ships is exercised through `subprocess.run` by
+# tests/e2e and by nothing else, so without a subprocess measurement `cmd_init`
+# and its siblings read 0% and the gate fires on any `cmd_*` a diff touches.
+# pytest-cov 7.0.0 dropped the mechanism that used to do this (its own
+# `pytest-cov.pth` reading COV_CORE_*) and pointed at coverage's own patch
+# system, added in coverage 7.10. Measured on tests/e2e/test_init_doctor_e2e.py:
+# src/crapkit/cli/admin.py scores 0/498 statements under pytest-cov 7.1.0 with
+# this key absent, and 317/498 with it present, on 7.1.0 and 6.3.0 alike.
+# `parallel = true` follows automatically; .coverage* is already gitignored.
+[tool.coverage.run]
+patch = ["subprocess"]

{crapkit-0.4.5 → crapkit-0.4.6}/src/crapkit/__init__.py

@@ -1,2 +1,2 @@
 """crapkit: deterministic CRAP-score framework."""
-__version__ = "0.4.5"
+__version__ = "0.4.6"

{crapkit-0.4.5 → crapkit-0.4.6}/src/crapkit/cli/__init__.py

@@ -107,6 +107,7 @@ _OWNER = {
     "_extend_gitignore": "admin",
     "_fewer_tests_line": "verifying",
     "_file_sizer": "_shared",
+    "_first_word": "admin",
     "_flag_counts": "scoring",
     "_flake_retry": "verifying",
     "_gate_candidates": "scoring",
@@ -190,6 +191,7 @@ _OWNER = {
     "_plugin_json": "admin",
     "_plugins_dir": "admin",
     "_policy_findings": "ratchet_cmds",
+    "_present_lockfiles": "admin",
     "_present_markers": "admin",
     "_present_on_disk": "scoring",
     "_prior_crap": "verifying",
@@ -218,6 +220,7 @@ _OWNER = {
     "_pruned": "ratchet_cmds",
     "_pushdown_floor": "queue",
     "_pytest_cov_probe": "admin",
+    "_python_name": "admin",
     "_range_lines": "analyses",
     "_rankable": "queue",
     "_ratchet_entries": "_shared",

{crapkit-0.4.5 → crapkit-0.4.6}/src/crapkit/cli/admin.py

@@ -23,7 +23,13 @@ from ..universe import assign_files, scan_files
 from ._shared import _file_sizer, _load_repo_config, _print_json
 
 
-def _interpreter() -> str:
+def _present_lockfiles(root: Path) -> frozenset[str]:
+    from ..scaffold import LOCKFILE_RUNNERS
+
+    return frozenset(name for name, _ in LOCKFILE_RUNNERS if (root / name).is_file())
+
+
+def _python_name() -> str:
     """The interpreter name a committed config can call. sys.executable is this
     machine's absolute path and would not survive the repo reaching anyone else.
 
@@ -41,6 +47,25 @@ def _interpreter() -> str:
     return "python3"
 
 
+def _interpreter(root: Path) -> str:
+    """The python invocation a committed config can call.
+
+    A lockfile at the root wins: `uv run python` and its siblings resolve to the
+    environment the repo pins, while a bare `python` resolves to whichever venv
+    the shell happens to have active — which in two worktrees of one branch is
+    how a lane measures the OTHER checkout and scores this one untested.
+
+    The manager only PREFIXES the name; which name it prefixes is still
+    `_python_name`'s answer, so a Windows PATH carrying no `python` gets
+    `uv run py` rather than a word the shell cannot start.
+    """
+    from ..scaffold import lockfile_runner
+
+    runner = lockfile_runner(_present_lockfiles(root))
+    name = _python_name()
+    return f"{runner} {name}" if runner else name
+
+
 def _present_markers(root: Path) -> frozenset[str]:
     from ..scaffold import PYTEST_MARKERS
 
@@ -137,6 +162,14 @@ def _start_probe(word: str) -> int | None:
         return None
 
 
+def _first_word(command: str) -> str:
+    """The word the shell will try to start, read the way that shell reads the
+    line: a quoted interpreter path stays one word, where a whitespace split
+    would break it at its space. "" when the line holds no word at all."""
+    words = shell_words(command)
+    return words[0] if words else ""
+
+
 def _dead_first_word(command: str) -> tuple[str, int] | None:
     """The command's first word and the shell's verdict, when the shell cannot
     start it. None when it starts, and None when the word does not resolve on
@@ -144,11 +177,11 @@ def _dead_first_word(command: str) -> tuple[str, int] | None:
     proves nothing."""
     import shutil
 
-    words = shell_words(command)
-    if not words or shutil.which(words[0]) is None:
+    word = _first_word(command)
+    if not word or shutil.which(word) is None:
         return None
-    code = _start_probe(words[0])
-    return (words[0], code) if _could_not_run_it(code) else None
+    code = _start_probe(word)
+    return (word, code) if _could_not_run_it(code) else None
 
 
 def _probe_answered_no(returncode: int) -> bool:
@@ -189,7 +222,14 @@ def _probe_interpreter(command: str) -> str | None:
     """The python this lane runs pytest with, or None when no python runs it.
     `coverage run -m pytest` names no interpreter at all: the probe asked
     `coverage` to import pytest_cov, read its argument error as a missing
-    package, and printed the pip note on a machine where pytest_cov imports."""
+    package, and printed the pip note on a machine where pytest_cov imports.
+
+    An environment manager heads its segment for the same reason: `uv run` and
+    its siblings CREATE or sync the project environment before running anything,
+    so init has no business provisioning one to ask a question about it, and the
+    head word is not a python — `uv -c "import pytest_cov"` is not the probe it
+    looks like, and would have warned about the wrong gap on every uv repo.
+    """
     segment = _pytest_segment(command)
     if not segment or not _is_python(segment[0]):
         return None
@@ -202,7 +242,8 @@ def _pytest_cov_probe(command: str) -> bool:
     the lane will get (a .bat shim included), not the one CreateProcess finds.
     True too when the probe cannot run — only a clean "no" earns the warning,
     and a missing interpreter is doctor's finding, not this one's. True as well
-    when no python runs the suite: nothing here can be asked."""
+    when no python runs the suite, `uv run python -m pytest` included: nothing
+    here can be asked."""
     import shutil
 
     from ..procs import run_bounded
@@ -256,11 +297,41 @@ def _missing_pytest_cov_note(name: str) -> str:
             "then `crapkit coverage`")
 
 
+def _absent_manager(command: str) -> str | None:
+    """The environment manager heading this lane, when this machine's PATH
+    carries no such word. None when it resolves, and None when nothing manages
+    the lane at all.
+
+    A lockfile is a property of the REPO, so `init` writes `uv run python` off
+    its presence alone — right for the repo, and unrunnable on a checkout whose
+    owner installed the dependencies with pip. Nothing else catches it: the
+    start check skips a word that does not resolve, and the pytest-cov probe
+    refuses to provision an environment to ask a question about it.
+    """
+    import shutil
+
+    from ..scaffold import LOCKFILE_RUNNERS
+
+    managers = {runner.split()[0] for _, runner in LOCKFILE_RUNNERS}
+    head = _first_word(command)
+    return head if head in managers and shutil.which(head) is None else None
+
+
+def _missing_manager_note(name: str, manager: str) -> str:
+    return (f"note: lane {name!r} runs through `{manager}`, which this machine's PATH does "
+            f"not carry — install {manager}, or point the lane's command in crapkit.toml at "
+            f"an interpreter that resolves here, then `crapkit coverage`")
+
+
 def _lane_first_run_note(lane) -> str | None:
     """What init owes this lane before the first `crapkit coverage`, or None
-    when the lane will run. Two different gaps, and they are not the same
-    sentence: an interpreter that never started answered nothing about
-    pytest_cov, and `pip install pytest-cov` fixes none of it."""
+    when the lane will run. Three different gaps, and they are not the same
+    sentence: a manager that is not installed never gets as far as a python, and
+    an interpreter that never started answered nothing about pytest_cov, so
+    `pip install pytest-cov` fixes neither."""
+    manager = _absent_manager(lane.command)
+    if manager:
+        return _missing_manager_note(lane.name, manager)
     dead = _dead_first_word(lane.command)
     if dead:
         return _dead_interpreter_note(lane.name, *dead)
@@ -316,7 +387,7 @@ def cmd_init(args: argparse.Namespace) -> int:
     # A config whose lanes are all commented out scores every function no-lane,
     # so a fresh repo cannot rank anything until somebody hand-writes a lane.
     lanes = detect_lanes(_present_markers(root), _package_json(root),
-                         interpreter=_interpreter())
+                         interpreter=_interpreter(root))
     text = starter_toml(scopes, lanes)
     load_config_text(text)  # self-check: never write a config crapkit cannot read back
     toml_path.write_text(text, encoding="utf-8", newline="\n")

{crapkit-0.4.5 → crapkit-0.4.6}/src/crapkit/covstream.py

@@ -281,7 +281,14 @@ def parse_istanbul_missing_file(path: Path | str, *, repo_root: str,
         return _guarded(lambda: _istanbul_map(w, repo_root, _dead_lines), _BAD_ISTANBUL)
 
 
-def _prefix(path_prefix: str) -> str:
+def lane_prefix(path_prefix: str) -> str:
+    """The lane's `path_prefix` as it is actually glued onto a measured path.
+
+    Public because the lane layer has to take it back OFF: it judges whether a
+    measured path escaped the checkout, and that question is about the path the
+    runner wrote, not about the key crapkit built out of it. Spelling the join
+    twice let `backend/` turn `/other/checkout/a.py` into something that reads
+    relative, and the refusal went silent on every lane that sets the knob."""
     return (path_prefix.rstrip("/") + "/") if path_prefix else ""
 
 
@@ -334,7 +341,7 @@ def parse_coveragepy_file(path: Path | str, *, path_prefix: str, chunk: int = CH
     """Per-file function coverage plus the sha256 of the report's own bytes."""
     w, handle = _window(path, chunk)
     with handle:
-        per_file = _guarded(lambda: _coveragepy_functions(w, _prefix(path_prefix)),
+        per_file = _guarded(lambda: _coveragepy_functions(w, lane_prefix(path_prefix)),
                             _BAD_REPORT)
     return per_file, w.hasher.hexdigest()
 
@@ -352,4 +359,4 @@ def parse_coveragepy_missing_file(path: Path | str, *, path_prefix: str,
     """Per measured file, the lines coverage.py reports as never run."""
     w, handle = _window(path, chunk)
     with handle:
-        return _guarded(lambda: _coveragepy_missing(w, _prefix(path_prefix)), _BAD_REPORT)
+        return _guarded(lambda: _coveragepy_missing(w, lane_prefix(path_prefix)), _BAD_REPORT)

{crapkit-0.4.5 → crapkit-0.4.6}/src/crapkit/lanes.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import sys
 import time
 from pathlib import Path
@@ -20,12 +21,12 @@ from typing import IO, NamedTuple
 
 from .config import Lane
 from .coverage_istanbul import FnCoverage
-from .covstream import parse_coveragepy_file, parse_istanbul_both_file
+from .covstream import lane_prefix, parse_coveragepy_file, parse_istanbul_both_file
 from .errors import GitError, ToolError
 from .gitio import GitFacts
 from .procs import run_bounded
 from .uncovered import fold_dead_lines
-from .universe import owning_scope, path_matchers
+from .universe import ScopeMatch, owning_scope, path_matchers
 
 
 def _in_container() -> bool:
@@ -45,10 +46,72 @@ def _lane_log_path(root: Path, lane: Lane) -> Path:
     return log_path
 
 
-def _log_tail(log_path: Path) -> str:
+_TAIL_BUDGET = 500
+_CAUSE_LINES = 3
+_CAUSE_WIDTH = 200
+
+# Lines that name a cause rather than restate a count: pytest's `E   ` gutter, a
+# traceback header, a bare exception line. A run that died in collection ends
+# with a summary block of `ERROR path` lines saying WHICH files broke and never
+# why, so a plain tail spends its whole budget on filenames while the reason
+# scrolls off above it.
+_DIAGNOSTIC = re.compile(r"\s*(E\s|Traceback \(most recent call last\)|\w*(Error|Exception): )")
+
+
+def _log_lines(log_path: Path) -> list[str]:
     if not log_path.is_file():
-        return ""
-    return log_path.read_text(encoding="utf-8", errors="replace").strip()[-500:]
+        return []
+    return log_path.read_text(encoding="utf-8", errors="replace").strip().splitlines()
+
+
+def _tail_lines(lines: list[str], budget: int) -> list[str]:
+    """The last WHOLE lines that fit the budget. A tail cut on a byte count
+    starts mid-line, and the reader cannot tell that fragment from the real
+    start of the message: the report that prompted this opened on
+    "short test summary info ====" and read as the first thing the run said.
+    One line over budget on its own keeps its end behind an ellipsis, which at
+    least says so."""
+    kept: list[str] = []
+    left = budget
+    for line in reversed(lines):
+        left -= len(line) + 1
+        if left < 0:
+            break
+        kept.append(line)
+    if kept:
+        kept.reverse()
+        return kept
+    return ["..." + lines[-1][-budget:]] if lines else []
+
+
+def _cut_cause(line: str) -> str:
+    """One cause line inside the budget, cut from the LEFT and marked.
+
+    What identifies an ImportError is the path at the end of it — the OTHER
+    checkout's, in the report this came from — so a cut taken from the right
+    drops the half worth hoisting. `_tail_lines` marks its own unavoidable cut
+    for the same reason: an unmarked one reads as the whole message."""
+    return line if len(line) <= _CAUSE_WIDTH else "..." + line[-(_CAUSE_WIDTH - 3):]
+
+
+def _cause_lines(lines: list[str], tail: list[str]) -> list[str]:
+    """The last lines anywhere in the log that name a failure, when the tail
+    carries none. Nothing when the tail already says why — repeating it would
+    spend the message on the same words twice."""
+    if any(_DIAGNOSTIC.match(line) for line in tail):
+        return []
+    named = [_cut_cause(line.strip()) for line in lines if _DIAGNOSTIC.match(line)]
+    return named[-_CAUSE_LINES:]
+
+
+def _log_tail(log_path: Path) -> str:
+    """What the log says about its own failure: the reason lines first when the
+    end of the log does not carry one, then the last whole lines of output. The
+    ellipsis between them marks the output they skipped over."""
+    lines = _log_lines(log_path)
+    tail = _tail_lines(lines, _TAIL_BUDGET)
+    cause = _cause_lines(lines, tail)
+    return "\n".join([*cause, "...", *tail] if cause else tail)
 
 
 def _popen_kwargs(root: Path, lane: Lane) -> dict:
@@ -105,11 +168,15 @@ def _missing_plugin_hint(tail: str) -> str:
 
 
 def _raise_no_artifact(lane: Lane, log_path: Path, exit_code: int | None) -> None:
+    """The log PATH before the log's words. A tail is 500 characters of a file
+    that holds the whole story, and a reader who is not told where that file is
+    has to go looking for it — one reporter had to ask another agent to find
+    .crapkit/lane-py.log while ten collection tracebacks sat inside it."""
     detail = f" (command exit {exit_code})" if exit_code is not None else ""
     tail = _log_tail(log_path)
     hint = f"; last output: {tail}" if tail else ""
-    raise ToolError(f"lane {lane.name!r} produced no artifact at {lane.artifact}{detail}{hint}"
-                    f"{_missing_plugin_hint(tail)}")
+    raise ToolError(f"lane {lane.name!r} produced no artifact at {lane.artifact}{detail}"
+                    f"; full log: {log_path}{hint}{_missing_plugin_hint(tail)}")
 
 
 def _run_attempts(root: Path, lane: Lane) -> int | None:
@@ -216,6 +283,18 @@ def lane_order(root: Path, lanes: list[Lane]) -> list[Lane]:
     return sorted(lanes, key=lambda lane: -_stamp_seconds(stamps, lane))
 
 
+def _lane_matchers(lane: Lane, scope_paths: dict) -> tuple[ScopeMatch, ...]:
+    """Ownership over the scopes THIS lane names, read by universe's one predicate.
+
+    Both questions a lane asks about paths go through here: which of its scopes'
+    files moved since the artifact was stamped, and whether the artifact reached
+    any of them at all. A second hand-rolled prefix test would answer the exact
+    arm — a scope that declares a FILE rather than a directory — differently
+    from the rule that assigns files, and the two would drift.
+    """
+    return path_matchers({name: scope_paths.get(name, ()) for name in lane.scopes})
+
+
 def _scope_changes(git: GitFacts, lane: Lane, scope_paths: dict, since_commit: str) -> list[str]:
     """Committed or working-tree changes under this lane's scope paths since a commit.
 
@@ -225,7 +304,7 @@ def _scope_changes(git: GitFacts, lane: Lane, scope_paths: dict, since_commit: s
     shape crapkit's own tests/e2e/test_parallel_lanes_e2e.py writes — and
     editing that file read as no change at all.
     """
-    matchers = path_matchers({name: scope_paths.get(name, ()) for name in lane.scopes})
+    matchers = _lane_matchers(lane, scope_paths)
     if not matchers:
         return []
     changed = set(git.diff_names_since(since_commit)) | set(git.status_names())
@@ -292,6 +371,138 @@ def _read_and_parse(lane: Lane, root: Path,
     raise ToolError(f"lane {lane.name!r}: parser {lane.parser!r} not implemented yet")
 
 
+_SAMPLE_PATHS = 3
+
+# A path the runner could not write relative to this checkout: absolute, drive
+# lettered, or climbing out of the tree. Both parsers rebase a file INSIDE the
+# repo to a repo-relative path, so one that is not is a file somewhere else.
+_DRIVE = re.compile(r"[A-Za-z]:[\\/]")
+
+
+def _escapes_repo(path: str) -> bool:
+    return path.startswith(("/", "../")) or _DRIVE.match(path) is not None
+
+
+def _as_reported(lane: Lane, path: str) -> str:
+    """One coverage key with this lane's own `path_prefix` taken back off, which
+    is the path the runner actually wrote.
+
+    The coveragepy reader prepends the prefix to EVERY key, an absolute one
+    included, so `backend/` + `/other/checkout/a.py` starts with neither `/` nor
+    a drive letter. Asked of that key, `_escapes_repo` answers no on every lane
+    that declares the knob — the monorepo shape the check was written for."""
+    prefix = lane_prefix(lane.path_prefix)
+    return path[len(prefix):] if prefix and path.startswith(prefix) else path
+
+
+def _unreached_paths(lane: Lane, coverage: dict, scope_paths: dict) -> tuple[str, ...]:
+    """The paths this lane's scopes declare when NOTHING the artifact measured
+    reaches any of them, else (). Empty too when the lane's scopes declare no
+    path at all: nothing to compare against is not evidence.
+
+    `owning_scope` is the reach test, so "could a scope claim this path?" can
+    never drift from the rule that assigns files to scopes.
+
+    The DECLARED path, not the matcher's directory prefix: a scope may name an
+    individual file, and the prefix half of that is `src/faro/core.py/`, a path
+    that exists neither in the config the reader is about to open nor on disk.
+    """
+    matchers = _lane_matchers(lane, scope_paths)
+    if not matchers or any(owning_scope(path, matchers) for path in coverage):
+        return ()
+    return tuple(dict.fromkeys(m.path for m in matchers))
+
+
+def _outside_paths(lane: Lane, coverage: dict) -> list[str]:
+    """The measured files that are not in this checkout, spelled the way the
+    artifact spells them."""
+    reported = (_as_reported(lane, path) for path in coverage)
+    return sorted(path for path in reported if _escapes_repo(path))
+
+
+def _sample(paths) -> str:
+    """A few of them and a count of the rest. A lane scoped to forty declared
+    paths listed all forty, which pushed the sentence saying what to do off the
+    end of a line nobody reads that far into."""
+    ordered = sorted(paths)
+    shown = ", ".join(ordered[:_SAMPLE_PATHS])
+    rest = len(ordered) - _SAMPLE_PATHS
+    return f"{shown} and {rest} more" if rest > 0 else shown
+
+
+# What to do about it, which is not the same sentence for both readers. The
+# coveragepy reader takes path_prefix and takes no repo root, so its refusal is
+# about the environment the lane binds to and the prefix is a real knob. The
+# istanbul reader takes the root, rebases every path under it and never reads
+# path_prefix at all, so a path that stayed absolute came from another tree and
+# no key on the lane can rebase it.
+_COVERAGEPY_FIX = ("Point the lane at this checkout's own environment (a bare "
+                   "`python -m pytest` binds to whichever venv the shell has active — run "
+                   "it through the project's manager, `uv run python -m pytest ...`), or "
+                   "set path_prefix when the runner reports paths relative to a subdirectory")
+_ISTANBUL_FIX = ("The reader rebases every path under this checkout's root, so these were "
+                 "written against another one: rerun the suite here rather than reusing an "
+                 "artifact copied in or restored from a CI cache")
+
+_COVERAGEPY_MISS = "or the runner reports paths this lane needs path_prefix to rebase"
+_ISTANBUL_MISS = "or the suite measured a part of the tree these scopes do not name"
+
+
+def _wrong_tree_fix(lane: Lane) -> str:
+    return _COVERAGEPY_FIX if lane.parser == "coveragepy" else _ISTANBUL_FIX
+
+
+def _unmeasured_reading(lane: Lane) -> str:
+    return _COVERAGEPY_MISS if lane.parser == "coveragepy" else _ISTANBUL_MISS
+
+
+def _zero_overlap(lane: Lane, coverage: dict, declared) -> str:
+    """The finding both verdicts open on, written once: what the artifact
+    measured, and that none of it is in scope. The two messages part company
+    after it, and a sentence kept in two places is a sentence that drifts."""
+    return (f"lane {lane.name!r} measured {len(coverage)} file(s), none of them under the "
+            f"paths its scopes declare ({_sample(declared)})")
+
+
+def _wrong_tree_message(lane: Lane, coverage: dict, declared, outside: list[str]) -> str:
+    return (f"{_zero_overlap(lane, coverage, declared)}, and {len(outside)} of them "
+            f"outside this checkout entirely — {lane.artifact} describes a different tree, "
+            f"so joining it would score every function in those scopes untested; it reports "
+            f"paths like {_sample(outside)}. {_wrong_tree_fix(lane)}")
+
+
+def _unmeasured_message(lane: Lane, coverage: dict, declared) -> str:
+    reports = f"; it measured {_sample(coverage)}" if coverage else ""
+    return (f"{_zero_overlap(lane, coverage, declared)}, so every function in those "
+            f"scopes will score untested{reports} — either nothing in them is exercised yet, "
+            f"{_unmeasured_reading(lane)}")
+
+
+def _judge_artifact_scope(lane: Lane, coverage: dict, scope_paths: dict | None) -> None:
+    """Say something when a lane's artifact reaches none of the scopes it claims.
+
+    Coverage joins on path and nothing else, so such an artifact contributes
+    exactly nothing and every function in those scopes reads `untested` — a
+    confident "N untested, grade F" assembled out of a tooling mistake, which
+    is worse than the exit 5 a missing artifact earns because it looks like an
+    answer. Two worktrees of one branch reach it quietly: a venv whose editable
+    install points at the other checkout makes coverage.py measure that tree.
+
+    Two verdicts, because zero overlap has two readings and the paths tell them
+    apart. Measured files OUTSIDE this checkout can only be another tree, and
+    that fails the lane. In-tree paths that simply miss the scopes are the
+    greenfield shape as well — a suite that imports none of the scoped source
+    yet, which SHOULD score untested — so that one warns and scores on.
+    """
+    declared = _unreached_paths(lane, coverage, scope_paths or {})
+    if not declared:
+        return
+    outside = _outside_paths(lane, coverage)
+    if outside:
+        raise ToolError(_wrong_tree_message(lane, coverage, declared, outside))
+    print(f"crapkit: {_unmeasured_message(lane, coverage, declared)}", file=sys.stderr)
+
+
 def _results_provenance(root: Path, lane: Lane) -> dict:
     from .junitparse import suite_summary
 
@@ -399,9 +610,17 @@ def _run_or_reuse(root: Path, lane: Lane, git: GitFacts, scope_paths: dict | Non
 
 
 def _artifact_path(root: Path, lane: Lane) -> Path:
+    """The artifact, or the same refusal a run that wrote none raises.
+
+    Reuse is what reaches here — the run path refuses inside _run_attempts — and
+    it was the one lane refusal that named no log, on the reading that a reused
+    artifact had no run behind it. The previous run's log is usually sitting
+    there with the story, and a reader told to look for `full log:` on every
+    refusal has nowhere to go when one omits it.
+    """
     path = root / lane.artifact
     if not path.is_file():
-        raise ToolError(f"lane {lane.name!r} produced no artifact at {lane.artifact}")
+        _raise_no_artifact(lane, _lane_log_path(root, lane), None)
     return path
 
 
@@ -411,6 +630,7 @@ def run_lane(root: Path, lane: Lane, *, reuse_artifact: bool = False,
     _refuse_container_python(lane)
     exit_code, seconds = _run_or_reuse(root, lane, facts, scope_paths, reuse_artifact)
     coverage, digest = _read_and_parse(lane, root, _artifact_path(root, lane))
+    _judge_artifact_scope(lane, coverage, scope_paths)
     provenance = {
         "artifact_sha256": digest,
         "exit_code": exit_code,

{crapkit-0.4.5 → crapkit-0.4.6}/src/crapkit/scaffold.py

@@ -97,6 +97,29 @@ class LaneSpec(NamedTuple):
 
 PYTEST_MARKERS = ("pyproject.toml", "pytest.ini", "setup.cfg")
 
+# A lockfile is the repo saying it pins its own environment through a manager,
+# and only that manager's `run` binds a command to it. A bare `python` binds to
+# whatever venv the shell has active instead: the report this came from ran a
+# scaffolded lane in one worktree while the shell held another worktree's venv,
+# whose editable install pointed at the other checkout's sources, and pytest
+# collected ten ImportErrors. Detection is the same file-presence signal that
+# picks the lane itself, so nothing is executed to learn this.
+#
+# First match wins, so a repo carrying two lockfiles resolves the same way every
+# time rather than by dict order.
+LOCKFILE_RUNNERS = (("uv.lock", "uv run"), ("poetry.lock", "poetry run"),
+                    ("pdm.lock", "pdm run"), ("Pipfile.lock", "pipenv run"))
+
+
+def lockfile_runner(present: frozenset[str]) -> str:
+    """The manager prefix that pins a python invocation to THIS project's
+    environment, or "" when no lockfile in the repo names one."""
+    for name, runner in LOCKFILE_RUNNERS:
+        if name in present:
+            return runner
+    return ""
+
+
 _PY_LANGUAGES = ("python",)
 _JS_LANGUAGES = ("javascript", "tsx", "typescript")
 _JS_RUNNER_COMMAND = {"jest": "npx jest --coverage", "vitest": "npx vitest run --coverage"}
@@ -300,18 +323,49 @@ _TEMPLATES = {
 # is the runner that scope's language usually uses, and the whole block stays
 # commented because only the repo knows whether that command is the right one.
 _SCOPED_TEST_COMMANDS = {
-    "python": "python -m pytest {files} -q -p no:cacheprovider",
+    "python": "{python} -m pytest {files} -q -p no:cacheprovider",
     "javascript": "npx vitest run {files}",
     "tsx": "npx vitest run {files}",
     "typescript": "npx vitest run {files}",
 }
 _SCOPED_TEST_PLACEHOLDER = "<your test command> {files}"
+_DEFAULT_PYTHON = "python"
+
+
+# The shape that marks a detected lane as the pytest lane, read in one place:
+# the launcher and the confirmed-runner check spelled it two ways once, so a
+# command ending at `-m pytest` was the pytest lane to one and not the other,
+# and init wrote a commented template carrying a `uv run python` the same file
+# had just refused to confirm.
+_PYTEST_INVOCATION = " -m pytest "
+
+
+def _pytest_lane_launcher(lanes: tuple[LaneSpec, ...]) -> str | None:
+    """The python the lane that runs pytest runs it with, or None when no
+    detected lane runs pytest at all."""
+    for lane in lanes:
+        head, sep, _ = lane.command.partition(_PYTEST_INVOCATION)
+        if sep:
+            return head
+    return None
+
+
+def python_launcher(lanes: tuple[LaneSpec, ...]) -> str:
+    """The python invocation the detected pytest lane already settled on.
+
+    Read back off the lane rather than passed in beside it, so the scoped-tests
+    entry runs the suite the way the coverage lane runs it and the two cannot
+    drift: a `uv run python` lane with a bare `python` step 4 would measure one
+    environment and test another.
+    """
+    launcher = _pytest_lane_launcher(lanes)
+    return _DEFAULT_PYTHON if launcher is None else launcher
 
 
-def _scoped_test_command(languages: tuple[str, ...]) -> str:
+def _scoped_test_command(languages: tuple[str, ...], launcher: str) -> str:
     for language in languages:
         if language in _SCOPED_TEST_COMMANDS:
-            return _SCOPED_TEST_COMMANDS[language]
+            return _SCOPED_TEST_COMMANDS[language].replace("{python}", launcher)
     return _SCOPED_TEST_PLACEHOLDER
 
 
@@ -326,17 +380,19 @@ def _confirmed_languages(lanes: tuple[LaneSpec, ...]) -> frozenset[str]:
     `python -m pytest {files}` known-good. The js runners stay unconfirmed on
     purpose — which vitest or jest config a file-scoped run needs is exactly
     what presence detection cannot see."""
-    return frozenset({"python"} if any(" -m pytest " in ln.command for ln in lanes) else ())
+    return frozenset({"python"} if _pytest_lane_launcher(lanes) is not None else ())
 
 
-def _scoped_entry_lines(scopes: dict[str, tuple[str, ...]], live: bool) -> list[str]:
+def _scoped_entry_lines(scopes: dict[str, tuple[str, ...]], live: bool,
+                        launcher: str) -> list[str]:
     prefix = "" if live else "# "
-    return [f'{prefix}{name} = "{_scoped_test_command(languages)}"'
+    return [f'{prefix}{name} = "{_scoped_test_command(languages, launcher)}"'
             for name, languages in scopes.items()]
 
 
 def _scoped_tests_stub(scopes: dict[str, tuple[str, ...]],
-                       confirmed: frozenset[str] = frozenset()) -> list[str]:
+                       confirmed: frozenset[str] = frozenset(),
+                       launcher: str = _DEFAULT_PYTHON) -> list[str]:
     """The [crapkit.scoped_tests] block: live entries for scopes whose runner a
     detected lane proves, commented templates for the rest.
 
@@ -349,20 +405,22 @@ def _scoped_tests_stub(scopes: dict[str, tuple[str, ...]],
     rest = {n: l for n, l in scopes.items() if n not in live}
     intro = ["# `crapkit test-scoped FILES` runs one command per scope, with {files}",
              "# replaced by that scope's files, each quoted."]
-    return intro + _live_block(live) + _commented_block(rest, bool(live)) + [""]
+    return (intro + _live_block(live, launcher)
+            + _commented_block(rest, bool(live), launcher) + [""])
 
 
-def _live_block(live: dict[str, tuple[str, ...]]) -> list[str]:
+def _live_block(live: dict[str, tuple[str, ...]], launcher: str) -> list[str]:
     if not live:
         return []
-    return ["[crapkit.scoped_tests]"] + _scoped_entry_lines(live, True)
+    return ["[crapkit.scoped_tests]"] + _scoped_entry_lines(live, True, launcher)
 
 
-def _commented_block(rest: dict[str, tuple[str, ...]], has_live: bool) -> list[str]:
+def _commented_block(rest: dict[str, tuple[str, ...]], has_live: bool,
+                     launcher: str) -> list[str]:
     if not rest:
         return []
     header = ["# Uncomment what fits:"] + ([] if has_live else ["# [crapkit.scoped_tests]"])
-    return header + _scoped_entry_lines(rest, False)
+    return header + _scoped_entry_lines(rest, False, launcher)
 
 
 def _template_lines(covered: set[str], scopes: dict[str, tuple[str, ...]]) -> list[str]:
@@ -392,7 +450,8 @@ def starter_toml(scopes: dict[str, tuple[str, ...]], lanes: tuple[LaneSpec, ...]
     lines += _exclude_stanza()
     live, covered = _live_lanes(lanes, scopes)
     return "\n".join(lines + live + _template_lines(covered, scopes)
-                     + _scoped_tests_stub(scopes, _confirmed_languages(lanes)))
+                     + _scoped_tests_stub(scopes, _confirmed_languages(lanes),
+                                          python_launcher(lanes)))
 
 
 _STORE_IGNORE = ".crapkit/"

{crapkit-0.4.5 → crapkit-0.4.6/src/crapkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.4.5
+Version: 0.4.6
 Summary: Scores every function on complexity times uncovered risk, ranks the worst, and blocks commits that add more.
 Author: Jean-Francois Gagne
 License: MIT
@@ -31,8 +31,10 @@ Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: pytest-cov>=5; extra == "dev"
 Requires-Dist: pytest-xdist>=3; extra == "dev"
+Requires-Dist: coverage>=7.10.6; extra == "dev"
 Provides-Extra: py
 Requires-Dist: pytest-cov>=5; extra == "py"
+Requires-Dist: coverage>=7.10.6; extra == "py"
 Dynamic: license-file
 
 # crapkit
@@ -143,7 +145,7 @@ changing crapkit.
 
 ```
 $ crapkit --version
-crapkit 0.4.5
+crapkit 0.4.6
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -344,7 +346,7 @@ crapkit ships a `.pre-commit-hooks.yaml` declaring `id: crapkit-gate`. In your
 repos:
   - repo: https://github.com/JeanFrancoisGagne/crapkit
     # crapkit's release step rewrites this line to the tag it just cut
-    rev: v0.4.5
+    rev: v0.4.6
     hooks:
       - id: crapkit-gate
 ```
@@ -614,7 +616,7 @@ crapkit: run 3 is an inventory run (no coverage was measured) and cannot serve a
 | 2 | Usage error from argparse: unknown flag, missing positional. Raised before crapkit's own error handling. |
 | 3 | Config error: `crapkit.toml` missing or unparseable, an unknown language or parser, a lane command the shell that runs it reads as a narrowed suite, a ratchet metric-stamp mismatch ([Upgrading from 0.4.4](#upgrading-from-044)), a `test-scoped` file under no scope or under a scope with no template. |
 | 4 | Git error: not a repository, a baseline commit rewritten out of the history. |
-| 5 | Tool error: lizard not importable, a lane produced no artifact, a lane timed out past its retries, an override alert command failed. A `timeout_seconds` kills the whole process tree, so no orphan suite keeps running behind the failure. |
+| 5 | Tool error: lizard not importable, a lane produced no artifact or one that measured a different tree, a lane timed out past its retries, an override alert command failed. A `timeout_seconds` kills the whole process tree, so no orphan suite keeps running behind the failure. |
 | 6 | Gate violation. A function the diff touched is over its ceiling and past any ratchet mark it carries: an edit that leaves a marked function at or under its mark is the debt the repo signed for and is exempt. Also `rescore --gate`, which applies the same rule, and `hook-precommit`, which exempts on the mark's existence instead. |
 | 7 | Ratchet regression the diff never touched. A marked function scores worse than its recorded high-water mark; a touched one past its mark reports 6. |
 | 8 | New test failures against the baseline run. Failures the baseline already had do not count. |
@@ -647,6 +649,11 @@ pip install pytest-cov
 
 (`pip install "crapkit[py]"` pulls both at once when crapkit shares the suite's venv.)
 
+If your suite drives its own CLI through `subprocess.run`, add `[tool.coverage.run]
+patch = ["subprocess"]` to `pyproject.toml` and keep `coverage>=7.10.6`: pytest-cov 7.0.0
+dropped subprocess measurement, so without that key every entry point scores 0% and nothing
+warns. [docs/lanes.md](docs/lanes.md) has the whole rule.
+
 ### 1. Scaffold the config
 
 ```
@@ -659,9 +666,13 @@ added to .gitignore: .crapkit/, .coverage, __pycache__/
 `init` sniffs tracked source into one scope per top-level source directory, and detects a
 coverage lane from what the repo already has: a pytest marker file (`pyproject.toml`,
 `pytest.ini`, `setup.cfg`) writes a live `[[lane]]`, and so does a `test` script or
-`vitest`/`jest` in `package.json`. Whatever it detects, it also leaves commented templates
-for the runners it did not find. Every lane it writes reports into `.crapkit/cov/`, which
-is why the `.gitignore` list is so short: see
+`vitest`/`jest` in `package.json`. A lockfile beside them names the environment: `uv.lock`,
+`poetry.lock`, `pdm.lock` or `Pipfile.lock` makes the lane `uv run python -m pytest …` (and
+the matching `run` for the rest), because a bare `python` binds to whichever venv the shell
+has active rather than the one the repo pins — see
+[The interpreter a lane binds to](docs/lanes.md#the-interpreter-a-lane-binds-to). Whatever
+it detects, it also leaves commented templates for the runners it did not find. Every lane
+it writes reports into `.crapkit/cov/`, which is why the `.gitignore` list is so short: see
 [Where artifacts live](docs/lanes.md#where-artifacts-live).
 
 ```toml
@@ -821,7 +832,7 @@ exit 5:
 
 ```
 $ crapkit coverage
-crapkit: lane 'js' FAILED: lane 'js' produced no artifact at .crapkit/cov/js/coverage-final.json (command exit 1); last output: $ npm run test -- --coverage --coverage.reportsDirectory=.crapkit/cov/js --reporter=default --reporter=junit --outputFile=.crapkit/cov/js/junit.xml
+crapkit: lane 'js' FAILED: lane 'js' produced no artifact at .crapkit/cov/js/coverage-final.json (command exit 1); full log: /repo/.crapkit/lane-js.log; last output: $ npm run test -- --coverage --coverage.reportsDirectory=.crapkit/cov/js --reporter=default --reporter=junit --outputFile=.crapkit/cov/js/junit.xml
 
  MISSING DEPENDENCY  Cannot find dependency '@vitest/coverage-v8'
 

{crapkit-0.4.5 → crapkit-0.4.6}/src/crapkit.egg-info/requires.txt

@@ -4,6 +4,8 @@ lizard>=1.24.0
 pytest>=8
 pytest-cov>=5
 pytest-xdist>=3
+coverage>=7.10.6
 
 [py]
 pytest-cov>=5
+coverage>=7.10.6