crapkit 0.2.0__tar.gz → 0.3.0__tar.gz

{crapkit-0.2.0/src/crapkit.egg-info → crapkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.2.0
+Version: 0.3.0
 Summary: Deterministic CRAP-score framework: per-function complexity x coverage risk, worklists, ratchets, refactor verification
 Author: Jean-Francois Gagne
 License: MIT
@@ -28,9 +28,10 @@ Dynamic: license-file
 
 crapkit scores every function in your repo on complexity times uncovered risk, ranks the
 worst ones by how often the file changes, and blocks commits that add more. It reads
-TypeScript, TSX, JavaScript and Python through [lizard](https://github.com/terryyin/lizard),
+TypeScript, TSX, JavaScript, Python, Swift and Go through [lizard](https://github.com/terryyin/lizard),
 and joins per-function branch coverage from istanbul or coverage.py artifacts your own test
-command already produces. Every read-side command speaks JSON with a pinned schema, because
+command already produces. Swift and Go have no coverage parser: declare those scopes
+`coverage_optional` and they score on complexity alone. Every read-side command speaks JSON with a pinned schema, because
 half the callers are coding agents.
 
 ```
@@ -76,7 +77,7 @@ Check the install:
 
 ```
 $ crapkit --version
-crapkit 0.2.0
+crapkit 0.3.0
 ```
 
 `python -m crapkit` works identically to the `crapkit` console script, and is what to use
@@ -130,7 +131,7 @@ paths = ["calc"]
 languages = ["python"]
 
 [exclude]
-globs = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/vendor/**", "**/*.test.*", "**/*.spec.*", "**/test_*.py", "**/*_test.py", "**/conftest.py", "*.config.ts", "*.config.js", "*.config.mts", "**/*.config.ts", "**/*.config.js", "**/*.config.mts"]
+globs = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/vendor/**", "**/*.test.*", "**/*.spec.*", "**/test_*.py", "**/*_test.py", "**/conftest.py", "**/*_test.go", "*.config.ts", "*.config.js", "*.config.mts", "**/*.config.ts", "**/*.config.js", "**/*.config.mts"]
 
 [[lane]]
 name = "py"
@@ -761,6 +762,7 @@ crapkit: error: argument command: invalid choice: '/path/to/repo' (choose from '
 | `overrides [--json]` | The override audit trail: who granted what, when, and why. |
 | `trend [--json]` | Totals per trusted run: functions, over-target count, CRAP load, average, per-scope rollup. |
 | `digest [--alert]` | The delta between the two newest runs with identical lane sets. Silent when nothing changed. `--alert` pipes the body to `alert_command` on stdin. Plain lines, never JSON. |
+| `report [--out PATH]` | One self-contained HTML page written to `.crapkit/report.html` (or `--out PATH`, repo-relative), with the path printed on stdout. It renders what `worklist --json` and `trend --json` already answer at their defaults: the ranked worklist capped at `worklist_top`, the per-scope grades off the newest run, the trend series, and a banner naming every stale lane. It measures nothing, opens no network connection, and carries no per-function CRAP or coverage, because no repo-wide payload has them; each row prints the `crapkit explain` call that does. |
 | `duplication [--min-lines N] [--similarity F] [--top N] [--json]` | Near-duplicate functions by normalized line shingles with containment scoring. Defaults: `--min-lines 8`, `--similarity 0.8`, `--top 50`. `--top` truncates the list. |
 | `coupling [--min-support N] [--min-confidence F] [--top N] [--json]` | File pairs that keep landing in the same commits. Defaults: `--min-support 5` shared commits, `--min-confidence 0.5` max-direction ratio, `--top 50`. Bulk commits never couple pairs, and a young repo returns nothing at the default support. |
 | `mutate [--files F ...] [--max-mutants N] [--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. |

{crapkit-0.2.0 → crapkit-0.3.0}/README.md

@@ -2,9 +2,10 @@
 
 crapkit scores every function in your repo on complexity times uncovered risk, ranks the
 worst ones by how often the file changes, and blocks commits that add more. It reads
-TypeScript, TSX, JavaScript and Python through [lizard](https://github.com/terryyin/lizard),
+TypeScript, TSX, JavaScript, Python, Swift and Go through [lizard](https://github.com/terryyin/lizard),
 and joins per-function branch coverage from istanbul or coverage.py artifacts your own test
-command already produces. Every read-side command speaks JSON with a pinned schema, because
+command already produces. Swift and Go have no coverage parser: declare those scopes
+`coverage_optional` and they score on complexity alone. Every read-side command speaks JSON with a pinned schema, because
 half the callers are coding agents.
 
 ```
@@ -50,7 +51,7 @@ Check the install:
 
 ```
 $ crapkit --version
-crapkit 0.2.0
+crapkit 0.3.0
 ```
 
 `python -m crapkit` works identically to the `crapkit` console script, and is what to use
@@ -104,7 +105,7 @@ paths = ["calc"]
 languages = ["python"]
 
 [exclude]
-globs = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/vendor/**", "**/*.test.*", "**/*.spec.*", "**/test_*.py", "**/*_test.py", "**/conftest.py", "*.config.ts", "*.config.js", "*.config.mts", "**/*.config.ts", "**/*.config.js", "**/*.config.mts"]
+globs = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/vendor/**", "**/*.test.*", "**/*.spec.*", "**/test_*.py", "**/*_test.py", "**/conftest.py", "**/*_test.go", "*.config.ts", "*.config.js", "*.config.mts", "**/*.config.ts", "**/*.config.js", "**/*.config.mts"]
 
 [[lane]]
 name = "py"
@@ -735,6 +736,7 @@ crapkit: error: argument command: invalid choice: '/path/to/repo' (choose from '
 | `overrides [--json]` | The override audit trail: who granted what, when, and why. |
 | `trend [--json]` | Totals per trusted run: functions, over-target count, CRAP load, average, per-scope rollup. |
 | `digest [--alert]` | The delta between the two newest runs with identical lane sets. Silent when nothing changed. `--alert` pipes the body to `alert_command` on stdin. Plain lines, never JSON. |
+| `report [--out PATH]` | One self-contained HTML page written to `.crapkit/report.html` (or `--out PATH`, repo-relative), with the path printed on stdout. It renders what `worklist --json` and `trend --json` already answer at their defaults: the ranked worklist capped at `worklist_top`, the per-scope grades off the newest run, the trend series, and a banner naming every stale lane. It measures nothing, opens no network connection, and carries no per-function CRAP or coverage, because no repo-wide payload has them; each row prints the `crapkit explain` call that does. |
 | `duplication [--min-lines N] [--similarity F] [--top N] [--json]` | Near-duplicate functions by normalized line shingles with containment scoring. Defaults: `--min-lines 8`, `--similarity 0.8`, `--top 50`. `--top` truncates the list. |
 | `coupling [--min-support N] [--min-confidence F] [--top N] [--json]` | File pairs that keep landing in the same commits. Defaults: `--min-support 5` shared commits, `--min-confidence 0.5` max-direction ratio, `--top 50`. Bulk commits never couple pairs, and a young repo returns nothing at the default support. |
 | `mutate [--files F ...] [--max-mutants N] [--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. |

{crapkit-0.2.0 → crapkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "crapkit"
-version = "0.2.0"
+version = "0.3.0"
 description = "Deterministic CRAP-score framework: per-function complexity x coverage risk, worklists, ratchets, refactor verification"
 readme = "README.md"
 license = { text = "MIT" }

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/__init__.py

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

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/_pygdefer.py

@@ -6,7 +6,7 @@ importlib.metadata, email, zipfile and socket. Measured on this box: 42ms with
 pygments, 16ms without, paid by every process that touches the analysis stack,
 the pre-commit hook included.
 
-crapkit analyzes five languages (typescript, tsx, javascript, python, swift).
+crapkit analyzes six languages (typescript, tsx, javascript, python, swift, go).
 Erlang is not one of them and no scope can name it. The readers that need
 pygments are still SHIPPED, not removed: `deferred_pygments()` puts proxies in
 sys.modules for the duration of the lizard import, so the readers bind stand-ins

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/analyze.py

@@ -27,7 +27,7 @@ _POOL_THRESHOLD = 16
 # Bump whenever analysis semantics change (merge rules, extension set, record
 # extraction): the fingerprint must invalidate cached records produced by older
 # logic even when file content and tool versions are identical.
-ANALYSIS_VERSION = 3  # 3: cognitive complexity column joined the standard pass
+ANALYSIS_VERSION = 4  # 4: cognitive stopped reading 0 for every Swift and Kotlin function
 
 # The three tokens lizard's modified rule reacts to. Membership is checked before
 # anything else runs, so the common token pays one frozenset lookup.
@@ -69,12 +69,39 @@ class _ModifiedDelta:
             yield token
 
 
-# Built once per process, not once per file: 14k files paid 14k chain builds.
-# Every extension in it keeps its state in the generator frame __call__ opens,
-# so one chain serves every file. Cognitive comes FIRST because lizard's own
-# preprocessors strip the whitespace tokens its python rules read; the delta
-# comes last, where the modified pass used to sit.
-_EXTENSIONS = [_Cognitive()] + lizard.get_extensions(["ND"]) + [_ModifiedDelta()]
+def _chain(cognitive_index: int) -> list:
+    """lizard's standard extensions with cognitive spliced in at one index.
+
+    Index 0 puts cognitive ahead of lizard's own `preprocessing`, which is where
+    it has to sit for Python: `preprocessing` strips the whitespace tokens the
+    python indent rules read, and behind it a 6-branch function scores 6 instead
+    of 10. The delta comes last either way, where the modified pass used to sit.
+    """
+    extensions = lizard.get_extensions(["ND"])
+    extensions.insert(cognitive_index, _Cognitive())
+    return extensions + [_ModifiedDelta()]
+
+
+# Two chains, built once per process each, not once per file: 14k files paid 14k
+# chain builds. Every extension keeps its state in the generator frame __call__
+# opens, so one chain serves every file of its kind.
+_EXTENSIONS = _chain(0)
+_PREPROCESSED_EXTENSIONS = _chain(1)
+
+# lizard's SwiftReplaceLabel.preprocess RETURNS a list where the other seven
+# preprocessors YIELD: it runs list() over its input, so every extension AHEAD of
+# `preprocessing` is drained to exhaustion before lizard has split the file into
+# functions. An extension at index 0 counts the whole file against one
+# placeholder FunctionInfo, and every real function comes out at 0. SwiftReader
+# and KotlinReader are the only two of lizard's 27 readers that inherit that
+# preprocessor, so only these suffixes take the second chain.
+_DRAINED_READER_SUFFIXES = (".swift", ".kt", ".kts")
+
+
+def _extensions_for(rel_path: str) -> list:
+    if rel_path.lower().endswith(_DRAINED_READER_SUFFIXES):
+        return _PREPROCESSED_EXTENSIONS
+    return _EXTENSIONS
 
 
 def _record(rel_path: str, fn) -> FunctionRecord:
@@ -98,7 +125,7 @@ def _record(rel_path: str, fn) -> FunctionRecord:
 def analyze_one(args: tuple[str, str]) -> tuple[str, list[FunctionRecord]]:
     abs_path, rel_path = args
     try:
-        analysis = lizard.FileAnalyzer(_EXTENSIONS)(abs_path)
+        analysis = lizard.FileAnalyzer(_extensions_for(rel_path))(abs_path)
         return rel_path, [_record(rel_path, fn) for fn in analysis.function_list]
     except Exception as exc:  # loud, with the file named
         raise ToolError(f"lizard failed on {rel_path}: {exc}") from exc
@@ -110,10 +137,11 @@ def analyze_source(rel_path: str, code: str) -> list[FunctionRecord]:
     analyze_source_code is what FileAnalyzer.__call__ runs once it has read the
     file, so nothing about the analysis depends on whether the source arrived
     from the disk or from a git blob the caller already holds; rel_path picks
-    the language exactly as the path on disk did.
+    the language, and with it the extension chain, exactly as the path on disk did.
     """
     try:
-        analysis = lizard.FileAnalyzer(_EXTENSIONS).analyze_source_code(rel_path, code)
+        analyzer = lizard.FileAnalyzer(_extensions_for(rel_path))
+        analysis = analyzer.analyze_source_code(rel_path, code)
         return [_record(rel_path, fn) for fn in analysis.function_list]
     except Exception as exc:  # loud, with the file named
         raise ToolError(f"lizard failed on {rel_path}: {exc}") from exc

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/cli/__init__.py

@@ -188,7 +188,10 @@ _OWNER = {
     "_records_by_scope": "scoring",
     "_release_claims": "verifying",
     "_release_target": "queue",
+    "_report_lanes": "reports",
+    "_report_payload": "reports",
     "_report_verify": "verifying",
+    "_report_worklist": "reports",
     "_require_ancestor": "verifying",
     "_rescore_analyze": "scoring",
     "_rescore_gate": "scoring",
@@ -226,6 +229,7 @@ _OWNER = {
     "_taint_note": "verifying",
     "_traced_lane": "scoring",
     "_tracked_files": "scoring",
+    "_trend_payload": "reports",
     "_trend_row": "reports",
     "_tsv_baseline": "verifying",
     "_unclaimed": "queue",
@@ -257,6 +261,7 @@ _OWNER = {
     "_worklist_marks": "queue",
     "_worklist_payload": "queue",
     "_worklist_print": "queue",
+    "_write_report": "reports",
     "_write_tsv": "_shared",
     "build_parser": "parser",
     "cmd_brief": "queue",
@@ -275,6 +280,7 @@ _OWNER = {
     "cmd_next_item": "queue",
     "cmd_overrides": "reports",
     "cmd_ratchet": "ratchet_cmds",
+    "cmd_report": "reports",
     "cmd_rescore": "scoring",
     "cmd_runs": "reports",
     "cmd_test_scoped": "verifying",

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/cli/parser.py

@@ -247,6 +247,14 @@ def build_parser() -> argparse.ArgumentParser:
     trd.add_argument("--json", action="store_true", help="print as JSON")
     trd.set_defaults(func=_Handler("reports", "cmd_trend"))
 
+    rep = sub.add_parser("report", help="one self-contained HTML page: the ranked worklist, "
+                                        "the per-scope grades, the trend, and a staleness banner")
+    rep.add_argument("--repo", default=".", help="consuming repo root (default: cwd)")
+    rep.add_argument("--out", default=".crapkit/report.html", metavar="PATH",
+                     help="where to write the page, relative to the repo "
+                          "(default: .crapkit/report.html); the path is printed on stdout")
+    rep.set_defaults(func=_Handler("reports", "cmd_report"))
+
     tsc = sub.add_parser("test-scoped", help="run the configured isolated test command for the files' scope")
     tsc.add_argument("files", nargs="+", help="repo-relative test files")
     tsc.add_argument("--repo", default=".", help="consuming repo root (default: cwd)")

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/cli/reports.py

@@ -114,19 +114,101 @@ def _print_trend(as_json: bool, rows_out: list, target: int) -> None:
               f"{r['over_target']} over target, load {r['crap_load']}, avg {r['avg']}")
 
 
-def cmd_trend(args: argparse.Namespace) -> int:
+def _trend_payload(cfg, store: SnapshotStore) -> dict:
+    """The whole series, shaped once. `trend --json` prints it and `report`
+    renders it, so the page and the payload cannot describe the same run
+    differently."""
     from ..store import trusted_runs
 
-    root = Path(args.repo).resolve()
-    cfg = _load_repo_config(root)
-    store = _open_store(root)
     # one GROUP BY for the whole history; this used to build every ScoredRow of
     # every trusted run to add up three numbers per run
     agg = store.run_totals(target=cfg.target, scope_targets=cfg.scope_targets)
     by_scope = store.run_scope_totals(target=cfg.target, scope_targets=cfg.scope_targets)
-    rows_out = [_trend_row(run, agg.get(run["id"], (0, 0, 0.0)), by_scope.get(run["id"], {}))
-                for run in trusted_runs(store)]
-    _print_trend(args.json, rows_out, cfg.target)
+    return {"target": cfg.target,
+            "runs": [_trend_row(run, agg.get(run["id"], (0, 0, 0.0)),
+                                by_scope.get(run["id"], {}))
+                     for run in trusted_runs(store)]}
+
+
+def cmd_trend(args: argparse.Namespace) -> int:
+    root = Path(args.repo).resolve()
+    cfg = _load_repo_config(root)
+    payload = _trend_payload(cfg, _open_store(root))
+    _print_trend(args.json, payload["runs"], cfg.target)
+    return 0
+
+
+# --- the static page ---------------------------------------------------------
+#
+# `report` measures nothing. It collects the payloads `worklist --json` and
+# `trend --json` already answer, at their defaults, adds the per-lane staleness
+# `load_uncovered` computes, and hands the lot to a pure renderer. Everything
+# below is collection; the markup lives in crapkit.report.
+
+def _report_worklist(root: Path, cfg, store: SnapshotStore) -> dict:
+    """The ranked queue through the SAME shaping `worklist --json` prints.
+
+    Reassembling it here would let the page rank one function first and the
+    command another, off one run.
+    """
+    from ..churn_cache import load_churn
+    from ..gitio import head_commit
+    from ..report import report_top
+    from ..worklist import build_worklist
+    from .queue import _pushdown_floor, _worklist_marks, _worklist_payload, _worklist_run
+
+    latest = _worklist_run(root, store)
+    rows = store.read_rows(latest["id"], min_ccn=_pushdown_floor(cfg), scopes=[])
+    wl = build_worklist(rows, load_churn(root, cfg.churn_window_months),
+                        floor=cfg.worklist_floor, top=report_top(cfg.worklist_top),
+                        marks=_worklist_marks(store, cfg, latest["id"], []))
+    return _worklist_payload(wl, latest, cfg, latest["commit"] != head_commit(root), None)
+
+
+def _report_lanes(root: Path, cfg) -> list[dict]:
+    """Per-lane staleness, the detail the joined note throws away."""
+    from ..uncovered import lane_states
+
+    return [{"name": name, "note": note} for name, note in lane_states(root, cfg)]
+
+
+def _report_payload(root: Path, cfg, store: SnapshotStore) -> dict:
+    from datetime import datetime, timezone
+
+    return {"generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "lanes": _report_lanes(root, cfg),
+            "repo": root.name,
+            "target": cfg.target,
+            "trend": _trend_payload(cfg, store),
+            "worklist": _report_worklist(root, cfg, store)}
+
+
+def _write_report(root: Path, out: str, page: str) -> Path:
+    """Write the page and say where it went.
+
+    `--out` is repo-relative, like `--export` and `--sarif`: a path that climbs
+    out of the tree writes somewhere nobody asked for. LF endings, because the
+    page is an artifact people diff and publish.
+    """
+    base = root.resolve()
+    path = (base / out).resolve()
+    if base not in path.parents:
+        raise ConfigError(f"report --out stays inside {base}, got {out!r}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(page, encoding="utf-8", newline="\n")
+    print(path)
+    return path
+
+
+def cmd_report(args: argparse.Namespace) -> int:
+    """One self-contained page: the ranked worklist, the per-scope grades, the
+    trend series, and a banner when stale artifacts make them untrustworthy."""
+    from ..report import render_report
+
+    root = Path(args.repo).resolve()
+    cfg = _load_repo_config(root)
+    payload = _report_payload(root, cfg, _open_store(root))
+    _write_report(root, args.out, render_report(payload))
     return 0
 
 

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/cli/verifying.py

@@ -17,14 +17,15 @@ from ._shared import (_analysis_tools, _dirty_tag, _emit_findings, _gate_line,
 from .scoring import _scored_run
 
 
-def _emit_verify_findings(root: Path, args, verdict) -> None:
+def _emit_verify_findings(root: Path, args, verdict, uncovered: list) -> None:
     if not (args.sarif or args.github):
         return
-    from ..sarif import gate_results, regression_results
+    from ..sarif import diff_uncovered_results, gate_results, regression_results
 
     _emit_findings(root, args.sarif, args.github,
                    gate_results(verdict.gate_violations)
-                   + regression_results(verdict.ratchet_regressions))
+                   + regression_results(verdict.ratchet_regressions)
+                   + diff_uncovered_results(uncovered))
 
 
 def _no_baseline(root: Path) -> str:
@@ -366,7 +367,7 @@ def cmd_verify(args: argparse.Namespace) -> int:
     verdict, overridden = _apply_verify_override(store, run_id, root, cfg, verdict, args.override)
     _settle_verify(store, run_id, verdict, overridden, ratchet_path, ratchet, scored, cfg)
     _release_claims(store, git, cfg, scored)
-    _emit_verify_findings(root, args, verdict)
+    _emit_verify_findings(root, args, verdict, uncovered)
 
     _report_verify(args.json,
                    {**_verify_result(verdict, overridden, run_id, baseline, commit, ranges, uncovered),

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/config.py

@@ -6,11 +6,14 @@ from typing import NamedTuple
 
 from .errors import ConfigError
 
-SUPPORTED_LANGUAGES = frozenset({"typescript", "tsx", "javascript", "python", "swift"})
+SUPPORTED_LANGUAGES = frozenset({"typescript", "tsx", "javascript", "python", "swift", "go"})
 SUPPORTED_PARSERS = frozenset({"istanbul", "coveragepy"})
 DEFAULT_TARGET = 6
 
-_SOURCE_SUFFIXES = (".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs", ".py")
+# Only what a vitest command line can carry: this tuple guards istanbul lane
+# commands against a positional file filter, and no .swift or .go path appears
+# in one.
+_SOURCE_SUFFIXES = (".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs", ".cjs", ".py")
 
 
 class Scope(NamedTuple):

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/discover.py

@@ -217,11 +217,15 @@ def _indent(line: str) -> int:
 
 
 def _def_pattern(identifier: str) -> re.Pattern[str]:
-    """A line that DEFINES the name: the keyword forms of both language
-    families, plus the method shorthand a class body uses."""
+    """A line that DEFINES the name: the keyword forms of every language family
+    crapkit reads, plus the method shorthand a class body uses.
+
+    `function` sits before `func` and `fun` in the alternation so a JavaScript
+    definition never matches on a prefix of its own keyword.
+    """
     name = re.escape(identifier)
     return re.compile(r"^\s*" + _DEF_MODIFIERS
-                      + r"(?:(?:def|class|function|const|let|var)\s+" + name + r"\b"
+                      + r"(?:(?:def|class|function|func|fun|const|let|var)\s+" + name + r"\b"
                       + r"|" + name + r"\s*\([^)]*\)\s*[:{])")
 
 

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/lizardcognitive.py

@@ -1,7 +1,7 @@
 """Cognitive complexity (Sonar spec) as a lizard token-stream extension.
 
-Rides lizard's language-aware tokenizers, so TS/TSX/JS/Python all pay the same
-rules with no second parse and no new dependency:
+Rides lizard's language-aware tokenizers, so TS/TSX/JS/Python/Swift all pay the
+same rules with no second parse and no new dependency:
   +1 and +nesting for if / ternary / switch / loops / catch-except
   +1 flat for else / elif (an else-if chain costs one per link, no deepening)
   +1 per boolean-operator run, +1 each time the operator alternates
@@ -13,6 +13,12 @@ Attribution follows lizard's function splitting (a nested arrow's tokens are
 the arrow's), exactly as ccn is attributed today. Ternary branches do not
 deepen nesting (a structure inside a ternary arm is rare enough to accept).
 
+Where this extension sits in lizard's chain is load-bearing and differs by
+reader: the python rules read whitespace tokens that lizard's own
+`preprocessing` strips, while SwiftReader and KotlinReader drain the stream
+inside their `preprocess` and starve anything placed ahead of it. analyze._chain
+owns that placement.
+
 The whitepaper's worked examples in tests/unit/test_cognitive.py are the spec.
 """
 from __future__ import annotations

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/mutate.py

@@ -32,8 +32,10 @@ _OPS = {
                    "&&": ("||",), "||": ("&&",), "true": ("false",), "false": ("true",)},
 }
 # a short token matching INSIDE one of these is not that operator (== in ===,
-# > in => arrows, < in <=): skip the occurrence entirely
-_PROTECT = ("===", "!==", "==", "!=", "<=", ">=", "=>", "->")
+# > in => arrows, < in <=, < in a Swift half-open range): skip the occurrence
+# entirely. `0..<b` mutated to `0..<=b` does not compile, so the mutant dies on
+# the compiler and reads as killed by a test that never ran.
+_PROTECT = ("===", "!==", "==", "!=", "<=", ">=", "=>", "->", "..<", "...")
 _COMMENT_PREFIXES = ("#", "//", "/*", "*")
 _STRING_RE = re.compile(r"'[^']*'|\"[^\"]*\"|`[^`]*`")
 

crapkit-0.3.0/src/crapkit/report.py

@@ -0,0 +1,414 @@
+"""One static HTML page for a scored run: the ranked worklist, the per-scope
+grades, the trend series, and a banner when the artifacts behind them are stale.
+
+The whole module is a pure function from two payloads the CLI already answers to
+a string. It measures nothing and reads no file, so the page can never say
+something `crapkit worklist --json` and `crapkit trend --json` do not.
+
+Three decisions are load-bearing.
+
+The page renders the worklist AT ITS DEFAULT, `worklist_top` rows. Rendering
+every admitted row was measured: 46,567 rows of openclaw came to 9.85 MB of HTML
+and 46,567 DOM rows, which is a page that hangs the tab rather than one a
+teammate opens. `report_top` refuses anything past REPORT_ROW_CEILING.
+
+There is no per-function drill-down, because no --json surface carries
+per-function CRAP or coverage repo-wide: a worklist row has `risk` and `weight`,
+not `crap` and `cov`. Each row prints `crapkit explain PATH NAME` instead, so the
+detail is one command away and the file stays in the tens of KB.
+
+Every value that reaches the page goes through `_esc`. A function name is source
+text, not markup: `read_chunk( path , max_bytes = 1 < < 20 )` is a real recorded
+signature, and unescaped its `<` opens a tag that swallows the rest of the row.
+
+The palette is the handbook's, copied verbatim so the tool has one look; the
+contract test compares the two.
+"""
+from __future__ import annotations
+
+from html import escape
+
+from .errors import ConfigError
+
+# Measured at 46,567 rows / 9.85 MB. A few thousand rows is already a page
+# nobody scrolls; past that it is a page nobody opens.
+REPORT_ROW_CEILING = 2000
+
+_CHART_W = 660
+_CHART_H = 130
+
+_WORKLIST_COLUMNS = ("Risk", "CCN", "nloc", "Churn", "Scope", "Function",
+                     "Verdict", "Drill down")
+_SCOPE_COLUMNS = ("Scope", "Functions", "Over target", "CRAP load", "Grade")
+_TREND_COLUMNS = ("Run", "Commit", "When", "Functions", "Over target",
+                  "CRAP load", "Average")
+
+_EMPTY_RUN = {"run_id": 0, "commit": "", "created_at": "", "functions": 0,
+              "over_target": 0, "crap_load": 0.0, "avg": 0.0, "by_scope": {}}
+
+
+def report_top(worklist_top: int) -> int:
+    """The row cap, or a refusal naming the knob that set it.
+
+    A refusal beats a 10 MB page: the reader can lower `worklist_top` and get a
+    page, and cannot un-hang a tab.
+    """
+    if worklist_top > REPORT_ROW_CEILING:
+        raise ConfigError(
+            f"report renders at most {REPORT_ROW_CEILING} rows and worklist_top is "
+            f"{worklist_top}: lower [crapkit] worklist_top, or read the whole "
+            "ranking with `crapkit worklist --json`")
+    return worklist_top
+
+
+def render_report(payload: dict) -> str:
+    """The whole page.
+
+    `payload` carries `repo`, `generated_at`, `target`, `lanes` (name and the
+    note saying why its artifact cannot name line numbers, "" when it can), and
+    the `worklist` and `trend` payloads verbatim.
+    """
+    body = [_header(payload), _banner(payload), _scopes(payload),
+            _worklist(payload), _trend(payload), _footer(payload)]
+    return (f"{_DOC_OPEN}<title>crapkit report: {_esc(payload['repo'])}</title>\n"
+            f"<style>{_STYLE}</style>\n</head>\n<body>\n<div class=\"shell\">\n"
+            + "\n".join(body) + "\n</div>\n</body>\n</html>\n")
+
+
+def _esc(value) -> str:
+    """Every value on the page passes through here. Paths, signatures, scope
+    names and lane notes are all source text somebody else wrote."""
+    return escape(str(value), quote=True)
+
+
+# --- the page's parts --------------------------------------------------------
+
+def _header(payload: dict) -> str:
+    wl = payload["worklist"]
+    return (f'<header class="hero"><p class="kicker">crapkit report &middot; '
+            f'self-contained &middot; generated {_esc(payload["generated_at"])}</p>'
+            f'<h1>{_esc(payload["repo"])}</h1>'
+            f'<p class="standfirst">Run {_esc(wl["run_id"])} at '
+            f'<code>{_esc(wl["commit"][:11])}</code>, target ccn {_esc(payload["target"])}. '
+            f'Every number here comes from <code>crapkit worklist --json</code> and '
+            f'<code>crapkit trend --json</code> at their defaults.</p></header>')
+
+
+def _footer(payload: dict) -> str:
+    wl = payload["worklist"]
+    return (f'<footer>Ranked by risk (ccn times recency-weighted churn) over a '
+            f'{_esc(wl["churn_window_months"])}-month window, admitted at '
+            f'ccn &gt;= {_esc(wl["floor"])}. Per-function CRAP and coverage are not on this '
+            f'page: no repo-wide payload carries them. Run the drill-down command on a row '
+            f'to get them.</footer>')
+
+
+# --- the banner --------------------------------------------------------------
+
+def _banner(payload: dict) -> str:
+    """Loud when anything makes the numbers below untrustworthy, quiet otherwise.
+
+    Three separate faults read the same on the surface and want the same move,
+    so they stack into one block rather than competing for the top of the page.
+    """
+    lanes = payload["lanes"]
+    reasons = (_no_lane_reason(lanes) + _stale_lane_reason(lanes)
+               + _behind_head_reason(payload["worklist"]))
+    if reasons:
+        return ('<div class="banner stale"><p class="shout">Read this before the '
+                'numbers below</p>' + "".join(reasons) + "</div>")
+    return (f'<div class="banner fresh"><p>All {len(lanes)} lane artifact(s) still '
+            f'describe this working tree, and the run sits on HEAD.</p></div>')
+
+
+def _no_lane_reason(lanes: list[dict]) -> list[str]:
+    if lanes:
+        return []
+    return ["<p>This repo declares no [[lane]], so no artifact can say which lines "
+            "any test ran. Coverage reads 0 by default here, not by measurement.</p>"]
+
+
+def _stale_lane_reason(lanes: list[dict]) -> list[str]:
+    """The blackout, stated at its real size.
+
+    A single stale lane makes `load_uncovered` return no line numbers for ANY
+    path, not just that lane's. Uncommitted edits count, which is the normal
+    state of a tree somebody generates a report from.
+    """
+    stale = [lane for lane in lanes if lane["note"]]
+    if not stale:
+        return []
+    return [f"<p><b>{len(stale)} of {len(lanes)} lanes are stale.</b> One stale lane "
+            "blacks out line-level coverage repo-wide, not just its own scopes. "
+            "Commit or revert the edits, then rerun <code>crapkit coverage</code>.</p>"
+            + _lane_list(stale)]
+
+
+def _lane_list(stale: list[dict]) -> str:
+    items = "".join(f'<li><b>{_esc(lane["name"])}</b>: {_esc(lane["note"])}</li>'
+                    for lane in stale)
+    return f'<ul class="lanes">{items}</ul>'
+
+
+def _behind_head_reason(wl: dict) -> list[str]:
+    if not wl["stale"]:
+        return []
+    return [f'<p>The snapshot is run {_esc(wl["run_id"])} at '
+            f'<code>{_esc(wl["commit"][:11])}</code> and HEAD has moved on. Fresh '
+            f'artifacts do not rescue a run measured at another commit: rerun '
+            f'<code>crapkit coverage</code>.</p>']
+
+
+# --- per-scope grades --------------------------------------------------------
+
+def _newest_run(trend: dict) -> dict:
+    """The run the grades describe. An empty history grades nothing rather than
+    raising: a repo with one inventory run still gets a page."""
+    runs = trend["runs"]
+    return runs[-1] if runs else _EMPTY_RUN
+
+
+def _scopes(payload: dict) -> str:
+    newest = _newest_run(payload["trend"])
+    rows = "".join(_scope_row(name, block)
+                   for name, block in sorted(newest["by_scope"].items()))
+    return _section("scopes", "Grades by scope",
+                    _table(_SCOPE_COLUMNS, rows or _empty_row(len(_SCOPE_COLUMNS),
+                                                              "no scored run yet")))
+
+
+def _scope_row(name: str, block: dict) -> str:
+    return (f'<tr data-scope="{_esc(name)}"><td class="mono">{_esc(name)}</td>'
+            f'<td class="mono">{_esc(block["functions"])}</td>'
+            f'<td class="mono">{_esc(block["over_target"])}</td>'
+            f'<td class="mono">{_esc(block["crap_load"])}</td>'
+            f'<td>{_grade_chip(block["grade"])}</td></tr>')
+
+
+def _grade_chip(grade: str) -> str:
+    return f'<span class="chip {_grade_tone(grade)}">{_esc(grade)}</span>'
+
+
+def _grade_tone(grade: str) -> str:
+    """One letter, one colour. `score.grade` answers A+, A, B, C, D or F: green
+    through B, amber at C, red at D and F."""
+    if grade.startswith(("A", "B")):
+        return "o"
+    if grade.startswith("C"):
+        return "w"
+    return "a"
+
+
+# --- the worklist ------------------------------------------------------------
+
+def _worklist(payload: dict) -> str:
+    wl = payload["worklist"]
+    rows = "".join(_worklist_row(entry) for entry in wl["active"])
+    table = _table(_WORKLIST_COLUMNS,
+                   rows or _empty_row(len(_WORKLIST_COLUMNS), "nothing admitted"))
+    return _section("worklist", f'Worklist: {len(wl["active"])} ranked, '
+                                f'{_esc(wl["dormant_count"])} dormant', table)
+
+
+def _worklist_row(entry: dict) -> str:
+    """One ranked function. `risk` prints as the payload carries it, so a number
+    read off the page and one read off `worklist --json` are the same number."""
+    return (f'<tr class="wl"><td class="mono">{_esc(entry["risk"])}</td>'
+            f'<td class="mono">{_esc(entry["ccn"])}</td>'
+            f'<td class="mono">{_esc(entry["nloc"])}</td>'
+            f'<td class="mono">{_esc(entry["commits"])}c/{_esc(entry["authors"])}a</td>'
+            f'<td class="mono">{_esc(entry["scope"])}</td>'
+            f'<td>{_function_cell(entry)}</td>'
+            f'<td>{_verdict_cell(entry)}</td>'
+            f'<td><code>{_drill_down(entry)}</code></td></tr>')
+
+
+def _function_cell(entry: dict) -> str:
+    return (f'<div class="fn mono">{_esc(entry["function"])}</div>'
+            f'<div class="loc">{_esc(entry["path"])}:{_esc(entry["start"])}</div>')
+
+
+def _verdict_cell(entry: dict) -> str:
+    """`flag` and `remedy` are the run's own verdict, null on an inventory run."""
+    chips = [_chip(entry["flag"], _flag_tone(entry["flag"])),
+             _chip(entry["remedy"], _remedy_tone(entry["remedy"]))]
+    return "".join(c for c in chips if c)
+
+
+def _chip(text, tone: str) -> str:
+    return "" if text is None else f'<span class="chip {tone}">{_esc(text)}</span>'
+
+
+def _flag_tone(flag) -> str:
+    return "i" if flag == "measured" else "w"
+
+
+def _remedy_tone(remedy) -> str:
+    return "o" if remedy == "ok" else "a"
+
+
+def _drill_down(entry: dict) -> str:
+    """The command that answers what this page deliberately does not carry."""
+    return _esc(f'crapkit explain {entry["path"]} "{entry["function"]}"')
+
+
+# --- the trend series --------------------------------------------------------
+
+def _trend(payload: dict) -> str:
+    runs = payload["trend"]["runs"]
+    rows = "".join(_trend_row(run) for run in runs)
+    table = _table(_TREND_COLUMNS, rows or _empty_row(len(_TREND_COLUMNS), "no scored run yet"))
+    return _section("trend", f"Trend: {len(runs)} scored run(s)", _chart(runs) + table)
+
+
+def _trend_row(run: dict) -> str:
+    return (f'<tr data-run="{_esc(run["run_id"])}">'
+            f'<td class="mono">{_esc(run["run_id"])}</td>'
+            f'<td class="mono">{_esc(run["commit"][:11])}</td>'
+            f'<td class="mono">{_esc(run["created_at"])}</td>'
+            f'<td class="mono">{_esc(run["functions"])}</td>'
+            f'<td class="mono">{_esc(run["over_target"])}</td>'
+            f'<td class="mono">{_esc(run["crap_load"])}</td>'
+            f'<td class="mono">{_esc(run["avg"])}</td></tr>')
+
+
+def _chart(runs: list[dict]) -> str:
+    """CRAP load per run as one polyline. Two runs is the smallest series with a
+    direction; one run is a dot nobody can read a trend off."""
+    loads = [run["crap_load"] for run in runs]
+    if len(loads) < 2:
+        return ""
+    points = " ".join(f"{x},{y}" for x, y in _chart_points(loads))
+    return (f'<figure class="panel"><svg viewBox="0 0 {_CHART_W} {_CHART_H}" role="img" '
+            f'aria-label="CRAP load across {len(loads)} runs">'
+            f'<polyline class="series" points="{points}"/></svg>'
+            f'<figcaption>CRAP load across {len(loads)} scored runs, oldest at the left. '
+            f'Peak {_esc(max(loads))}. Down is better.</figcaption></figure>')
+
+
+def _chart_points(loads: list[float]) -> list[tuple[float, float]]:
+    """Load scaled to the box, oldest first. A flat-zero series draws along the
+    floor rather than dividing by nothing."""
+    top = max(loads) or 1.0
+    step = _CHART_W / (len(loads) - 1)
+    return [(round(i * step, 1), round(_CHART_H - 8 - (value / top) * (_CHART_H - 16), 1))
+            for i, value in enumerate(loads)]
+
+
+# --- markup helpers ----------------------------------------------------------
+
+def _section(anchor: str, title: str, body: str) -> str:
+    return f'<section id="{anchor}">\n<h2>{title}</h2>\n{body}\n</section>'
+
+
+def _table(columns: tuple[str, ...], rows: str) -> str:
+    head = "".join(f"<th>{column}</th>" for column in columns)
+    return (f'<div class="tw"><table><thead><tr>{head}</tr></thead>'
+            f"<tbody>{rows}</tbody></table></div>")
+
+
+def _empty_row(width: int, text: str) -> str:
+    return f'<tr><td colspan="{width}" class="empty">{_esc(text)}</td></tr>'
+
+
+_DOC_OPEN = ('<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n'
+             '<meta name="viewport" content="width=device-width, initial-scale=1">\n')
+
+# Copied from docs/handbook.html so the tool has one look. The contract test
+# compares every colour token here against that page.
+_STYLE = """
+  :root {
+    --paper: #FAF8F4; --ink: #211C17; --muted: #6E6459; --faint: #94897C;
+    --line: #E5DFD5; --card: #FFFFFF; --card-line: #EAE4DA;
+    --accent: #A6391F; --accent-soft: #F7E9E4;
+    --ok: #2E7D46; --ok-soft: #E7F2EA;
+    --warn: #A66A00; --warn-soft: #F8EFDC;
+    --info: #3B5B8C; --info-soft: #E8EEF7;
+    --data1: #A6391F; --data2: #B8860B; --data3: #3E6B8F; --data4: #2E7D46;
+    --code-bg: #F1EDE5; --grid: #E9E3D8;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --paper: #17140F; --ink: #EAE4DB; --muted: #A79C8D; --faint: #7E7466;
+      --line: #322C24; --card: #1F1B15; --card-line: #373128;
+      --accent: #E0714F; --accent-soft: #33211B;
+      --ok: #6FBF8A; --ok-soft: #1E2E23;
+      --warn: #D9A250; --warn-soft: #302716;
+      --info: #8AA8D4; --info-soft: #1E2634;
+      --data1: #E0714F; --data2: #D9A250; --data3: #7FA3C8; --data4: #6FBF8A;
+      --code-bg: #262119; --grid: #2C271F;
+    }
+  }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: var(--paper); color: var(--ink);
+         font: 16px/1.62 system-ui, "Segoe UI", Roboto, "Helvetica Neue", sans-serif; }
+  .shell { max-width: 1080px; margin: 0 auto; padding: 40px 24px 90px; }
+  code, .mono { font-family: ui-monospace, Consolas, "Cascadia Mono", Menlo, monospace; }
+  code { font-size: .85em; background: var(--code-bg); padding: 1px 5px; border-radius: 3px;
+         white-space: nowrap; }
+
+  header.hero { padding: 30px 0 24px; border-bottom: 3px solid var(--accent);
+                position: relative; overflow: hidden; }
+  header.hero::after { content: "ccn2"; position: absolute; right: -10px; top: -30px;
+    font: 700 170px/1 Charter, Cambria, Georgia, serif; color: var(--accent);
+    opacity: .06; pointer-events: none; user-select: none; }
+  .kicker { font: 600 12px/1 system-ui, sans-serif; letter-spacing: .16em;
+            text-transform: uppercase; color: var(--accent); margin: 0 0 16px; }
+  h1 { font-family: Charter, "Bitstream Charter", Cambria, Georgia, serif;
+       font-size: clamp(38px, 6vw, 56px); font-weight: 700; line-height: 1.02;
+       letter-spacing: -.015em; margin: 0 0 14px; }
+  .standfirst { max-width: 66ch; font-size: 17px; color: var(--muted); margin: 0; }
+  h2 { font-family: Charter, "Bitstream Charter", Cambria, Georgia, serif;
+       font-size: 28px; font-weight: 700; margin: 56px 0 10px; padding-top: 20px;
+       border-top: 1px solid var(--line); }
+  p { max-width: 72ch; margin: 0 0 12px; }
+
+  .banner { margin: 24px 0 0; padding: 16px 20px; border-radius: 8px;
+            border-left: 5px solid var(--ok); background: var(--ok-soft); }
+  .banner p { margin: 0 0 8px; font-size: 14.5px; }
+  .banner p:last-child { margin-bottom: 0; }
+  .banner.stale { border-left-color: var(--accent); background: var(--accent-soft); }
+  .banner.stale .shout { font: 700 15px/1.3 system-ui, sans-serif;
+                         text-transform: uppercase; letter-spacing: .05em;
+                         color: var(--accent); }
+  ul.lanes { margin: 6px 0 0; padding-left: 22px; font-size: 13.5px; color: var(--muted); }
+  ul.lanes li { margin-bottom: 5px; }
+  ul.lanes b { color: var(--ink); font-family: ui-monospace, Consolas, monospace; }
+
+  .tw { overflow-x: auto; border: 1px solid var(--card-line); border-radius: 8px;
+        background: var(--card); margin: 16px 0; }
+  table { border-collapse: collapse; width: 100%; min-width: 720px; font-size: 14px; }
+  th { font: 700 11px/1.3 system-ui, sans-serif; letter-spacing: .09em;
+       text-transform: uppercase; text-align: left; color: var(--muted);
+       padding: 11px 14px 9px; border-bottom: 2px solid var(--line); }
+  td { padding: 9px 14px; border-bottom: 1px solid var(--line); vertical-align: top; }
+  tr:last-child td { border-bottom: none; }
+  tbody tr:hover td { background: color-mix(in srgb, var(--accent) 4%, transparent); }
+  td.mono { white-space: nowrap; font-size: 13px; }
+  td.empty { color: var(--faint); font-style: italic; }
+  .fn { font-size: 13px; word-break: break-word; }
+  .loc { font-size: 12px; color: var(--faint); font-family: ui-monospace, Consolas, monospace; }
+
+  .chip { display: inline-block; font: 700 10.5px/1 system-ui, sans-serif;
+          letter-spacing: .07em; text-transform: uppercase; padding: 4px 8px 3px;
+          border-radius: 3px; white-space: nowrap; margin: 0 4px 3px 0; }
+  .chip.a { background: var(--accent-soft); color: var(--accent); }
+  .chip.o { background: var(--ok-soft); color: var(--ok); }
+  .chip.w { background: var(--warn-soft); color: var(--warn); }
+  .chip.i { background: var(--info-soft); color: var(--info); }
+
+  figure.panel { margin: 18px 0; background: var(--card); border: 1px solid var(--card-line);
+                 border-radius: 10px; padding: 16px 18px 10px; overflow-x: auto; }
+  figcaption { font-size: 13px; color: var(--faint); margin-top: 8px; }
+  svg { display: block; max-width: 100%; height: auto; }
+  svg .series { fill: none; stroke: var(--data1); stroke-width: 2.5;
+                stroke-linejoin: round; stroke-linecap: round; }
+
+  footer { margin-top: 60px; padding-top: 20px; border-top: 1px solid var(--line);
+           color: var(--faint); font-size: 13.5px; max-width: 76ch; }
+  ::selection { background: var(--accent-soft); }
+  @media (max-width: 640px) { .shell { padding: 28px 16px 60px; }
+    header.hero::after { display: none; } }
+  @media print { body { background: #fff; color: #111; }
+    header.hero::after { display: none; } .tw, figure { break-inside: avoid; } }
+"""

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/sarif.py

@@ -14,6 +14,8 @@ _RULES = (
      "shortDescription": {"text": "touched function over the complexity gate"}},
     {"id": "crapkit/ratchet-regression",
      "shortDescription": {"text": "a recorded CRAP mark got worse"}},
+    {"id": "crapkit/diff-uncovered",
+     "shortDescription": {"text": "a changed line no lane ever ran"}},
 )
 
 
@@ -54,6 +56,19 @@ def regression_results(regressions) -> list[dict]:
             for r in regressions]
 
 
+def diff_uncovered_results(uncovered) -> list[dict]:
+    """One finding per changed line no lane ran, from verify's own list.
+
+    A warning, not an error: the count is what `diff_uncovered_max` gates on,
+    and a single dark line is not a refusal by itself. Before this, these lines
+    reached stderr and nothing else, so the output a code-scanning UI reads
+    dropped every one of them.
+    """
+    return [_result("crapkit/diff-uncovered", "warning", path, line,
+                    "changed line has no coverage: no lane ran it")
+            for path, line in uncovered]
+
+
 def sarif_document(results: list[dict]) -> dict:
     return {
         "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/"

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/scaffold.py

@@ -11,6 +11,9 @@ _EXT_LANGUAGE = {ext: lang for lang, exts in LANGUAGE_EXTENSIONS.items() for ext
 DEFAULT_EXCLUDES = (
     "**/node_modules/**", "**/dist/**", "**/build/**", "**/vendor/**",
     "**/*.test.*", "**/*.spec.*", "**/test_*.py", "**/*_test.py", "**/conftest.py",
+    # Go puts its tests beside the source, so the test-directory rule never
+    # fires on them and every _test.go file would score as production code
+    "**/*_test.go",
     # runner config files the docs themselves tell users to create; globs are
     # whole-path, so the root form and the nested form are both required
     "*.config.ts", "*.config.js", "*.config.mts",

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/uncovered.py

@@ -70,23 +70,36 @@ def _absent_note(path: str, flag: str) -> str:
             f"nothing for it; write the first test that imports {path})")
 
 
+def _parse_missing(lane, root: Path, artifact: Path) -> dict[str, set[int]]:
+    """One lane's missing lines, read off the file.
+
+    Off the file, not out of a string: every declared lane's artifact would
+    otherwise be decoded whole, one after another, on one heap.
+
+    An unrecognised parser raises, in the same words `lanes._read_and_parse`
+    uses. This dispatch used to fall through to the coverage.py reader, so the
+    day a third parser joins SUPPORTED_PARSERS its lane would land here and
+    blame a perfectly good artifact for being unparseable.
+    """
+    from . import covstream
+    from .errors import ToolError
+
+    if lane.parser == "istanbul":
+        return covstream.parse_istanbul_missing_file(artifact, repo_root=str(root))
+    if lane.parser == "coveragepy":
+        return covstream.parse_coveragepy_missing_file(artifact, path_prefix=lane.path_prefix)
+    raise ToolError(f"lane {lane.name!r}: parser {lane.parser!r} not implemented yet")
+
+
 def missing_by_path(root: Path, cfg) -> dict[str, set[int]]:
     """Union of the lanes' line-level truth; a file two lanes measured keeps a
     line dead only when NO lane ran it."""
-    from . import covstream
-
     missing: dict[str, set[int]] = {}
     for lane in cfg.lanes:
         artifact = root / lane.artifact
         if not artifact.is_file():
             continue
-        # Off the file, not out of a string: every declared lane's artifact
-        # would otherwise be decoded whole, one after another, on one heap.
-        parsed = (covstream.parse_istanbul_missing_file(artifact, repo_root=str(root))
-                  if lane.parser == "istanbul"
-                  else covstream.parse_coveragepy_missing_file(
-                      artifact, path_prefix=lane.path_prefix))
-        for path, lines in parsed.items():
+        for path, lines in _parse_missing(lane, root, artifact).items():
             missing[path] = missing[path] & lines if path in missing else set(lines)
     return missing
 
@@ -104,10 +117,25 @@ def _artifact_state(root: Path, lane, scope_paths: dict, git) -> str:
     return ""
 
 
+def lane_states(root: Path, cfg, git=None) -> list[tuple[str, str]]:
+    """(lane name, why its line numbers are unusable) for every declared lane,
+    "" for a lane whose artifact still describes the tree.
+
+    `load_uncovered` joins these into one note and throws the per-lane detail
+    away, which is the right shape for "no lines for any path" and the wrong one
+    for a reader who wants to know WHICH lane to rerun. The report's staleness
+    banner reads this list; the joined note is built from it, so a lane cannot be
+    fresh in one and stale in the other.
+    """
+    from .gitio import GitFacts
+
+    facts = git if git is not None else GitFacts(root)
+    return [(lane.name, _artifact_state(root, lane, cfg.scope_paths, facts))
+            for lane in cfg.lanes]
+
+
 def _staleness_note(root: Path, cfg, git) -> str:
-    return "; ".join(state for state in
-                     (_artifact_state(root, lane, cfg.scope_paths, git) for lane in cfg.lanes)
-                     if state)
+    return "; ".join(note for _, note in lane_states(root, cfg, git) if note)
 
 
 def load_uncovered(root: Path, cfg, git=None) -> MissingLines:

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit/universe.py

@@ -19,6 +19,7 @@ LANGUAGE_EXTENSIONS = {
     "javascript": (".js", ".jsx", ".mjs", ".cjs"),
     "python": (".py",),
     "swift": (".swift",),
+    "go": (".go",),
 }
 
 # Test directories are excluded case-insensitively: Swift convention capitalizes Tests/.

{crapkit-0.2.0 → crapkit-0.3.0/src/crapkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crapkit
-Version: 0.2.0
+Version: 0.3.0
 Summary: Deterministic CRAP-score framework: per-function complexity x coverage risk, worklists, ratchets, refactor verification
 Author: Jean-Francois Gagne
 License: MIT
@@ -28,9 +28,10 @@ Dynamic: license-file
 
 crapkit scores every function in your repo on complexity times uncovered risk, ranks the
 worst ones by how often the file changes, and blocks commits that add more. It reads
-TypeScript, TSX, JavaScript and Python through [lizard](https://github.com/terryyin/lizard),
+TypeScript, TSX, JavaScript, Python, Swift and Go through [lizard](https://github.com/terryyin/lizard),
 and joins per-function branch coverage from istanbul or coverage.py artifacts your own test
-command already produces. Every read-side command speaks JSON with a pinned schema, because
+command already produces. Swift and Go have no coverage parser: declare those scopes
+`coverage_optional` and they score on complexity alone. Every read-side command speaks JSON with a pinned schema, because
 half the callers are coding agents.
 
 ```
@@ -76,7 +77,7 @@ Check the install:
 
 ```
 $ crapkit --version
-crapkit 0.2.0
+crapkit 0.3.0
 ```
 
 `python -m crapkit` works identically to the `crapkit` console script, and is what to use
@@ -130,7 +131,7 @@ paths = ["calc"]
 languages = ["python"]
 
 [exclude]
-globs = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/vendor/**", "**/*.test.*", "**/*.spec.*", "**/test_*.py", "**/*_test.py", "**/conftest.py", "*.config.ts", "*.config.js", "*.config.mts", "**/*.config.ts", "**/*.config.js", "**/*.config.mts"]
+globs = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/vendor/**", "**/*.test.*", "**/*.spec.*", "**/test_*.py", "**/*_test.py", "**/conftest.py", "**/*_test.go", "*.config.ts", "*.config.js", "*.config.mts", "**/*.config.ts", "**/*.config.js", "**/*.config.mts"]
 
 [[lane]]
 name = "py"
@@ -761,6 +762,7 @@ crapkit: error: argument command: invalid choice: '/path/to/repo' (choose from '
 | `overrides [--json]` | The override audit trail: who granted what, when, and why. |
 | `trend [--json]` | Totals per trusted run: functions, over-target count, CRAP load, average, per-scope rollup. |
 | `digest [--alert]` | The delta between the two newest runs with identical lane sets. Silent when nothing changed. `--alert` pipes the body to `alert_command` on stdin. Plain lines, never JSON. |
+| `report [--out PATH]` | One self-contained HTML page written to `.crapkit/report.html` (or `--out PATH`, repo-relative), with the path printed on stdout. It renders what `worklist --json` and `trend --json` already answer at their defaults: the ranked worklist capped at `worklist_top`, the per-scope grades off the newest run, the trend series, and a banner naming every stale lane. It measures nothing, opens no network connection, and carries no per-function CRAP or coverage, because no repo-wide payload has them; each row prints the `crapkit explain` call that does. |
 | `duplication [--min-lines N] [--similarity F] [--top N] [--json]` | Near-duplicate functions by normalized line shingles with containment scoring. Defaults: `--min-lines 8`, `--similarity 0.8`, `--top 50`. `--top` truncates the list. |
 | `coupling [--min-support N] [--min-confidence F] [--top N] [--json]` | File pairs that keep landing in the same commits. Defaults: `--min-support 5` shared commits, `--min-confidence 0.5` max-direction ratio, `--top 50`. Bulk commits never couple pairs, and a young repo returns nothing at the default support. |
 | `mutate [--files F ...] [--max-mutants N] [--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. |

{crapkit-0.2.0 → crapkit-0.3.0}/src/crapkit.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ src/crapkit/override.py
 src/crapkit/packet.py
 src/crapkit/ratchet.py
 src/crapkit/ratchet_report.py
+src/crapkit/report.py
 src/crapkit/sarif.py
 src/crapkit/sarifio.py
 src/crapkit/scaffold.py