crapkit 0.4.5__tar.gz → 0.4.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.4.5
+Version: 0.4.7
 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.7
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -225,6 +227,33 @@ ceiling. It adds no files to your repo, and it needs the crapkit CLI on PATH.
 A repo with no `crapkit.toml` costs a silent sub-50 ms no-op per edit. Other agent
 runtimes have no marketplace: copy `plugin/skills/*` into their skills directory instead.
 
+The hook registers on `Edit|Write`, which is every write that names a file. An agent that
+writes its source through a shell heredoc names none, so a `Bash` event is judged off the
+working tree instead. That half is yours to register, because it costs two
+git spawns per shell call. Add a second PostToolUse entry to your own settings, same
+command, matcher `Bash`:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          { "type": "command", "command": "crapkit claude-hook --protocol 1", "timeout": 20 }
+        ]
+      }
+    ]
+  }
+}
+```
+
+The cost is one `git rev-parse --show-toplevel` and one `git status --porcelain -z -uall`
+per shell call in any git repo, whether or not crapkit measures it: about 30 ms together
+on crapkit's own checkout, and more on a bigger tree. What comes back is the dirty or
+untracked `*.py` files written in the last 12 seconds, 25 at most, each judged the way an
+edit is. Python only, so a TypeScript or Go repo pays the two spawns and hears nothing.
+
 ## Languages
 
 14 languages, two coverage parsers. Coverage joins where a parser exists; everything else
@@ -344,7 +373,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.7
     hooks:
       - id: crapkit-gate
 ```
@@ -486,7 +515,7 @@ crapkit: error: argument command: invalid choice: '/path/to/repo' (choose from '
 | `mutate [--files F ...] [--max-mutants N] [--drop-pool] [--json]` | Diff-scoped mutation testing: flips comparisons, boundary shifts, boolean connectives and boolean literals on changed lines, runs `mutation_command` per mutant, lists survivors. `--files` replaces diff scope with the whole file. `--max-mutants` (default 100) caps the run and the cap warning goes to stderr only, so `mutants` in `--json` is the capped count. Shell and PowerShell files are refused by name on stderr rather than mutated: `<` and `>` are redirections there, not comparisons. With `mutation_workers > 1` the worker worktrees are kept at `.crapkit/mutate-pool/` and re-prepared per run (30.6 s to build four on a 31,459-file repo, 0.46 s to re-prepare them); `--drop-pool` removes them and exits. |
 | `test-scoped FILE ...` | Runs each owning scope's `[crapkit.scoped_tests]` template on the files (quoted, longest-prefix scope wins). A template with no `{files}` runs as written, which is how a scope whose tests live outside its own paths runs its whole suite. Exit code only; a nonzero runner exits 1. |
 | `hook-precommit` | The cc-only gate on staged blobs. No coverage, no snapshot, no repo-wide cache. Exit 6 on a violation. |
-| `claude-hook [--protocol N]` | Reads one Claude Code PostToolUse payload from stdin and judges the file it edited: ccn against the scope ceiling, on functions the edit changed, minus functions a ratchet mark already covers. Advisory only. The edit has landed, nothing is blocked, and `hook-precommit` stays the enforcement point. Exit 2 with three lines on stderr is the only thing it ever says: no `crapkit.toml` above the edited file, an unscoped file, mid-rebase or mid-merge, a `--protocol` other than 1, source that parses to no functions, or any internal failure all exit 0 in silence. Takes no `--repo`, because the root is the first `crapkit.toml` above the edited file and the upward walk stops at a `.git` entry, so a worktree never borrows its parent's config. It opens no snapshot and writes nothing. |
+| `claude-hook [--protocol N]` | Reads one Claude Code PostToolUse payload from stdin and judges the file it edited: ccn against the scope ceiling, on functions the edit changed, minus functions a ratchet mark already covers. Advisory only: the edit has landed, and `hook-precommit` stays the enforcement point. Exit 2 and an advisory on stderr is the only thing it ever says, one block per judged file (a head line, one line per breaching function, a closing line): no `crapkit.toml` above the edited file, an unscoped file, mid-rebase or mid-merge, a `--protocol` other than 1, source that parses to no functions, or any internal failure all exit 0 in silence. The root is the first `crapkit.toml` above the edited file; the walk stops at a `.git` entry, so a worktree never borrows its parent's config. A `Bash` event names no file, so it judges the working tree instead: the dirty or untracked `*.py` files touched in the last 12 seconds, 25 at most, each through the same ladder, and silence for a clean tree or a cwd outside any repo. That half fires only where you register a `Bash` matcher ([The Claude Code plugin](#the-claude-code-plugin)). It opens no snapshot and writes nothing. |
 | `watch [--interval SECONDS] [--cycles N]` | Rescores tracked files as they change (mtime polling, default 2s, subprocess-isolated so a half-saved syntax error never kills the watcher). `--cycles N` polls exactly N times and exits 0; without it the loop runs until ctrl-c. |
 | `mcp` | A dependency-free stdio MCP server (newline JSON-RPC 2.0) exposing nine read-only tools. Every tool shells to the CLI's own `--json` surface, so the MCP view cannot drift from what the CLI reports. Answering from a kept in-process store was benchmarked and rejected: a packet's `source` would go stale behind the edit it describes. See [docs/agent-json.md](docs/agent-json.md#mcp-server). |
 
@@ -614,7 +643,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 that produced no artifact, one that measured a different tree, one that measured this tree and reported it in absolute paths (the join is root-relative, so those match nothing either; the refusal names the runner's own switch, `relative_files = true` under `[tool.coverage.run]` for a coveragepy lane, the reporter's `cwd`/`root` option for an istanbul one), a lane that timed out past its retries, an override alert command that 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 +676,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 +693,14 @@ 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, and those
+carry the same launcher, so uncommenting one cannot hand the bare `python` back. 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 +860,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.7}/README.md

@@ -106,7 +106,7 @@ changing crapkit.
 
 ```
 $ crapkit --version
-crapkit 0.4.5
+crapkit 0.4.7
 ```
 
 `python -m crapkit` works identically to the console script and is what to use from a
@@ -188,6 +188,33 @@ ceiling. It adds no files to your repo, and it needs the crapkit CLI on PATH.
 A repo with no `crapkit.toml` costs a silent sub-50 ms no-op per edit. Other agent
 runtimes have no marketplace: copy `plugin/skills/*` into their skills directory instead.
 
+The hook registers on `Edit|Write`, which is every write that names a file. An agent that
+writes its source through a shell heredoc names none, so a `Bash` event is judged off the
+working tree instead. That half is yours to register, because it costs two
+git spawns per shell call. Add a second PostToolUse entry to your own settings, same
+command, matcher `Bash`:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          { "type": "command", "command": "crapkit claude-hook --protocol 1", "timeout": 20 }
+        ]
+      }
+    ]
+  }
+}
+```
+
+The cost is one `git rev-parse --show-toplevel` and one `git status --porcelain -z -uall`
+per shell call in any git repo, whether or not crapkit measures it: about 30 ms together
+on crapkit's own checkout, and more on a bigger tree. What comes back is the dirty or
+untracked `*.py` files written in the last 12 seconds, 25 at most, each judged the way an
+edit is. Python only, so a TypeScript or Go repo pays the two spawns and hears nothing.
+
 ## Languages
 
 14 languages, two coverage parsers. Coverage joins where a parser exists; everything else
@@ -307,7 +334,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.7
     hooks:
       - id: crapkit-gate
 ```
@@ -449,7 +476,7 @@ crapkit: error: argument command: invalid choice: '/path/to/repo' (choose from '
 | `mutate [--files F ...] [--max-mutants N] [--drop-pool] [--json]` | Diff-scoped mutation testing: flips comparisons, boundary shifts, boolean connectives and boolean literals on changed lines, runs `mutation_command` per mutant, lists survivors. `--files` replaces diff scope with the whole file. `--max-mutants` (default 100) caps the run and the cap warning goes to stderr only, so `mutants` in `--json` is the capped count. Shell and PowerShell files are refused by name on stderr rather than mutated: `<` and `>` are redirections there, not comparisons. With `mutation_workers > 1` the worker worktrees are kept at `.crapkit/mutate-pool/` and re-prepared per run (30.6 s to build four on a 31,459-file repo, 0.46 s to re-prepare them); `--drop-pool` removes them and exits. |
 | `test-scoped FILE ...` | Runs each owning scope's `[crapkit.scoped_tests]` template on the files (quoted, longest-prefix scope wins). A template with no `{files}` runs as written, which is how a scope whose tests live outside its own paths runs its whole suite. Exit code only; a nonzero runner exits 1. |
 | `hook-precommit` | The cc-only gate on staged blobs. No coverage, no snapshot, no repo-wide cache. Exit 6 on a violation. |
-| `claude-hook [--protocol N]` | Reads one Claude Code PostToolUse payload from stdin and judges the file it edited: ccn against the scope ceiling, on functions the edit changed, minus functions a ratchet mark already covers. Advisory only. The edit has landed, nothing is blocked, and `hook-precommit` stays the enforcement point. Exit 2 with three lines on stderr is the only thing it ever says: no `crapkit.toml` above the edited file, an unscoped file, mid-rebase or mid-merge, a `--protocol` other than 1, source that parses to no functions, or any internal failure all exit 0 in silence. Takes no `--repo`, because the root is the first `crapkit.toml` above the edited file and the upward walk stops at a `.git` entry, so a worktree never borrows its parent's config. It opens no snapshot and writes nothing. |
+| `claude-hook [--protocol N]` | Reads one Claude Code PostToolUse payload from stdin and judges the file it edited: ccn against the scope ceiling, on functions the edit changed, minus functions a ratchet mark already covers. Advisory only: the edit has landed, and `hook-precommit` stays the enforcement point. Exit 2 and an advisory on stderr is the only thing it ever says, one block per judged file (a head line, one line per breaching function, a closing line): no `crapkit.toml` above the edited file, an unscoped file, mid-rebase or mid-merge, a `--protocol` other than 1, source that parses to no functions, or any internal failure all exit 0 in silence. The root is the first `crapkit.toml` above the edited file; the walk stops at a `.git` entry, so a worktree never borrows its parent's config. A `Bash` event names no file, so it judges the working tree instead: the dirty or untracked `*.py` files touched in the last 12 seconds, 25 at most, each through the same ladder, and silence for a clean tree or a cwd outside any repo. That half fires only where you register a `Bash` matcher ([The Claude Code plugin](#the-claude-code-plugin)). It opens no snapshot and writes nothing. |
 | `watch [--interval SECONDS] [--cycles N]` | Rescores tracked files as they change (mtime polling, default 2s, subprocess-isolated so a half-saved syntax error never kills the watcher). `--cycles N` polls exactly N times and exits 0; without it the loop runs until ctrl-c. |
 | `mcp` | A dependency-free stdio MCP server (newline JSON-RPC 2.0) exposing nine read-only tools. Every tool shells to the CLI's own `--json` surface, so the MCP view cannot drift from what the CLI reports. Answering from a kept in-process store was benchmarked and rejected: a packet's `source` would go stale behind the edit it describes. See [docs/agent-json.md](docs/agent-json.md#mcp-server). |
 
@@ -577,7 +604,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 that produced no artifact, one that measured a different tree, one that measured this tree and reported it in absolute paths (the join is root-relative, so those match nothing either; the refusal names the runner's own switch, `relative_files = true` under `[tool.coverage.run]` for a coveragepy lane, the reporter's `cwd`/`root` option for an istanbul one), a lane that timed out past its retries, an override alert command that 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 +637,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 +654,14 @@ 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, and those
+carry the same launcher, so uncommenting one cannot hand the bare `python` back. 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 +821,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.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "crapkit"
-version = "0.4.5"
+version = "0.4.7"
 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.7}/src/crapkit/__init__.py

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

{crapkit-0.4.5 → crapkit-0.4.7}/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.7}/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)
@@ -279,9 +350,16 @@ def _warn_missing_pytest_cov(lanes: tuple) -> None:
     """The first-run trap, caught where it starts. The py lane shells out to
     `pytest --cov`, and the --cov flags come from pytest-cov — a package of the
     REPO's interpreter, so a crapkit dependency could only ever cover installs
-    sharing the suite's venv. Probe the python the lane will actually run and
-    say the fix now, instead of `coverage` exiting 5 with a lane log the first
-    run has to decode."""
+    sharing the suite's venv. Say the fix now, instead of `coverage` exiting 5
+    with a lane log the first run has to decode.
+
+    Only a lane whose pytest segment starts with a python is probed at all. A
+    lane an environment manager heads is not: `uv run` and its siblings create
+    or sync the project environment before running anything, so probing one
+    would provision an environment to ask a question about it. Such a lane
+    still earns the two notes ahead of the probe, a manager PATH does not carry
+    and a first word the shell cannot start.
+    """
     for lane in _probed_lanes(lanes):
         note = _lane_first_run_note(lane)
         if note:
@@ -315,9 +393,12 @@ def cmd_init(args: argparse.Namespace) -> int:
         raise ConfigError(_no_scopes_reason(root))
     # 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())
-    text = starter_toml(scopes, lanes)
+    # The interpreter goes to both: a repo with no pytest marker file gets no
+    # lane to read it back off, and its commented template is what the reader
+    # uncomments.
+    interpreter = _interpreter(root)
+    lanes = detect_lanes(_present_markers(root), _package_json(root), interpreter=interpreter)
+    text = starter_toml(scopes, lanes, interpreter=interpreter)
     load_config_text(text)  # self-check: never write a config crapkit cannot read back
     toml_path.write_text(text, encoding="utf-8", newline="\n")
     _print_init_summary(scopes, lanes)