@jesdi/skills 0.0.9 → 0.0.11

package/skills/crap-gate/crap_model.py

@@ -0,0 +1,33 @@
+"""Dataclasses shared by every crap-gate module. Stdlib only."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+class ToolError(Exception):
+    """Configuration or tooling problem: the CLI exits 2 with the message."""
+
+
+@dataclass(frozen=True)
+class Func:
+    file: str   # repo-relative path with forward slashes
+    name: str   # qualified name: "outer.inner", "Class.method", "default"
+    start: int  # 1-based first line of the declaration
+    end: int    # 1-based last line, inclusive
+    cc: int     # cyclomatic complexity, anonymous descendants folded in
+
+    def contains(self, other: "Func") -> bool:
+        return other is not self and self.start <= other.start and other.end <= self.end
+
+
+@dataclass
+class Scored:
+    target: str
+    func: Func
+    coverage: float  # 0.0 .. 1.0
+    crap: float
+    kind: str        # "new" | "existing"
+    limit: float
+    status: str      # "FAIL" | "ok"
+    hint: str        # cheapest way to pass; "" when ok
+    note: str = ""   # e.g. "file absent from coverage report"

package/skills/crap-gate/crap_python.py

@@ -0,0 +1,69 @@
+"""Named functions and cyclomatic complexity for Python via `ast`. Stdlib only."""
+from __future__ import annotations
+
+import ast
+
+from crap_model import Func, ToolError
+
+_DEFS = (ast.FunctionDef, ast.AsyncFunctionDef)
+_SCOPES = (*_DEFS, ast.ClassDef)
+_BRANCHES = (
+    ast.If,
+    ast.For,
+    ast.AsyncFor,
+    ast.While,
+    ast.ExceptHandler,
+    ast.IfExp,
+    ast.match_case,
+)
+
+
+def functions(source: str, file: str) -> list[Func]:
+    try:
+        tree = ast.parse(source, filename=file)
+    except SyntaxError as exc:
+        raise ToolError(f"{file}: cannot parse: {exc.msg} (line {exc.lineno})") from exc
+    out: list[Func] = []
+    for node in tree.body:
+        _visit(node, "", out, file)
+    return out
+
+
+def _visit(node: ast.AST, prefix: str, out: list[Func], file: str) -> None:
+    if isinstance(node, _DEFS):
+        name = prefix + node.name
+        cc, nested = _complexity(node)
+        out.append(Func(file, name, node.lineno, node.end_lineno or node.lineno, cc))
+        for child in nested:
+            _visit(child, name + ".", out, file)
+    elif isinstance(node, ast.ClassDef):
+        for child in node.body:
+            _visit(child, prefix + node.name + ".", out, file)
+    else:
+        # Compound statements outside any function (if TYPE_CHECKING:, try:, …)
+        # may still hold defs; keep the same prefix.
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, (ast.stmt, ast.ExceptHandler)):
+                _visit(child, prefix, out, file)
+
+
+def _complexity(fn: ast.AST) -> tuple[int, list[ast.AST]]:
+    """CC of `fn` counting everything except nested named scopes, which are
+    returned (in source order) for separate scoring. Lambdas fold in."""
+    cc = 1
+    nested: list[ast.AST] = []
+    stack = list(ast.iter_child_nodes(fn))
+    while stack:
+        node = stack.pop()
+        if isinstance(node, _SCOPES):
+            nested.append(node)
+            continue
+        if isinstance(node, _BRANCHES):
+            cc += 1
+        elif isinstance(node, ast.BoolOp):
+            cc += len(node.values) - 1
+        elif isinstance(node, ast.comprehension):
+            cc += 1 + len(node.ifs)
+        stack.extend(ast.iter_child_nodes(node))
+    nested.sort(key=lambda n: n.lineno)
+    return cc, nested

package/skills/crap-gate/crap_report.py

@@ -0,0 +1,99 @@
+"""Text and JSON rendering of an engine Result. Stdlib only."""
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+
+from crap_model import Scored
+
+
+@dataclass
+class TargetRun:
+    name: str
+    report: str
+    ran: bool
+    seconds: float
+
+
+@dataclass
+class Result:
+    base: str
+    base_ref: str
+    thresholds: dict[str, float]
+    targets: list[TargetRun]
+    functions: list[Scored]
+    not_measured: list[str]
+
+    @property
+    def summary(self) -> dict[str, int]:
+        return {
+            "fail": sum(1 for s in self.functions if s.status == "FAIL"),
+            "ok": sum(1 for s in self.functions if s.status == "ok"),
+            "not_measured": len(self.not_measured),
+        }
+
+
+def _line(s: Scored) -> str:
+    text = (
+        f"{s.status:<4}  {s.func.file}:{s.func.start}  {s.func.name}  CC {s.func.cc}  "
+        f"cov {round(s.coverage * 100)}%  CRAP {s.crap:.1f}  limit {s.limit:g} ({s.kind})"
+    )
+    if s.hint:
+        text += f"  → {s.hint}"
+    if s.note:
+        text += f"  [{s.note}]"
+    return text
+
+
+def render_text(result: Result) -> str:
+    lines = [
+        f"CRAP gate  base {result.base[:7]} (merge-base HEAD..{result.base_ref})  "
+        f"limits: existing > {result.thresholds['existing']:g}, new > {result.thresholds['new']:g}"
+    ]
+    for t in result.targets:
+        state = f"ran, {t.seconds:.0f}s" if t.ran else "reused"
+        lines.append(f"{t.name:<9} report {t.report}  ({state})")
+    lines.append("")
+    if result.functions:
+        lines.extend(_line(s) for s in sorted(result.functions, key=lambda s: -s.crap))
+    else:
+        lines.append("no changed functions in scope")
+    if result.not_measured:
+        lines.append("")
+        lines.append("Not measured: " + ", ".join(result.not_measured))
+    summary = result.summary
+    lines.append("")
+    lines.append(f"Summary: {summary['fail']} FAIL, {summary['ok']} ok, {summary['not_measured']} not measured")
+    return "\n".join(lines) + "\n"
+
+
+def render_json(result: Result) -> str:
+    functions = []
+    for s in sorted(result.functions, key=lambda s: -s.crap):
+        functions.append(
+            {
+                "target": s.target,
+                "file": s.func.file,
+                "name": s.func.name,
+                "start": s.func.start,
+                "end": s.func.end,
+                "cc": s.func.cc,
+                "coverage": round(s.coverage, 4),
+                "crap": round(s.crap, 1),
+                "kind": s.kind,
+                "limit": s.limit,
+                "status": s.status,
+                "hint": s.hint,
+                "note": s.note,
+            }
+        )
+    payload = {
+        "base": result.base,
+        "base_ref": result.base_ref,
+        "thresholds": result.thresholds,
+        "targets": [asdict(t) for t in result.targets],
+        "functions": functions,
+        "not_measured": result.not_measured,
+        "summary": result.summary,
+    }
+    return json.dumps(payload, indent=2, ensure_ascii=False) + "\n"

package/skills/crap-gate/crap_score.py

@@ -0,0 +1,65 @@
+"""CRAP formula and threshold logic. Stdlib only."""
+from __future__ import annotations
+
+import math
+
+from crap_model import Func, Scored
+
+
+def crap_score(cc: int, coverage: float) -> float:
+    """CRAP = CC² · (1 − cov)³ + CC  (Savoia/Cunningham)."""
+    return cc * cc * (1.0 - coverage) ** 3 + cc
+
+
+def required_coverage(cc: int, limit: float) -> float | None:
+    """Smallest coverage at which crap_score(cc, cov) <= limit; None when
+    even 100% coverage cannot bring CC under the limit."""
+    if cc > limit:
+        return None
+    if cc == limit:
+        return 1.0
+    return max(0.0, 1.0 - ((limit - cc) / (cc * cc)) ** (1.0 / 3.0))
+
+
+def max_cc(coverage: float, limit: float) -> int:
+    """Largest CC that still passes at the given coverage."""
+    cc = 1
+    while crap_score(cc + 1, coverage) <= limit:
+        cc += 1
+    return cc
+
+
+def hint(cc: int, coverage: float, limit: float) -> str:
+    """The cheapest ways out for a failing function, as one short phrase."""
+    parts: list[str] = []
+    need = required_coverage(cc, limit)
+    if need is not None and need > coverage:
+        parts.append(f"cover ≥ {math.ceil(need * 100)}%")
+    ceiling = max_cc(coverage, limit)
+    if ceiling < cc:
+        parts.append(f"split to CC ≤ {ceiling}")
+    return " or ".join(parts)
+
+
+def score(
+    target: str,
+    func: Func,
+    coverage: float,
+    kind: str,
+    thresholds: dict[str, float],
+    note: str = "",
+) -> Scored:
+    limit = thresholds["new"] if kind == "new" else thresholds["existing"]
+    value = crap_score(func.cc, coverage)
+    failing = value > limit
+    return Scored(
+        target=target,
+        func=func,
+        coverage=coverage,
+        crap=value,
+        kind=kind,
+        limit=limit,
+        status="FAIL" if failing else "ok",
+        hint=hint(func.cc, coverage, limit) if failing else "",
+        note=note,
+    )

package/skills/crap-gate/crap_typescript.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+// Named functions + cyclomatic complexity for TS/TSX via the TypeScript
+// compiler API. Reads {"files":[{"path","label"}]} on stdin, writes a JSON
+// array of {file,name,start,end,cc} on stdout. `typescript` is resolved from
+// the --cwd directory's node_modules so the analyzer follows the project's
+// own compiler version and needs no install of its own.
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const cwdIndex = process.argv.indexOf('--cwd');
+const cwd = path.resolve(cwdIndex >= 0 ? process.argv[cwdIndex + 1] : process.cwd());
+let ts;
+try {
+  ts = createRequire(pathToFileURL(path.join(cwd, 'package.json')))('typescript');
+} catch (err) {
+  console.error(`cannot load typescript from ${cwd}/node_modules: ${err.message}`);
+  process.exit(3);
+}
+
+const K = ts.SyntaxKind;
+const BRANCH_KINDS = new Set([
+  K.IfStatement, K.ConditionalExpression, K.ForStatement, K.ForInStatement,
+  K.ForOfStatement, K.WhileStatement, K.DoStatement, K.CatchClause, K.CaseClause,
+]);
+const LOGICAL_OPERATORS = new Set([
+  K.AmpersandAmpersandToken, K.BarBarToken, K.QuestionQuestionToken,
+  K.AmpersandAmpersandEqualsToken, K.BarBarEqualsToken, K.QuestionQuestionEqualsToken,
+]);
+
+const scriptKind = (file) =>
+  file.endsWith('.tsx') ? ts.ScriptKind.TSX
+  : file.endsWith('.jsx') ? ts.ScriptKind.JSX
+  : file.endsWith('.js') || file.endsWith('.mjs') ? ts.ScriptKind.JS
+  : ts.ScriptKind.TS;
+
+const isFunctionLike = (n) =>
+  ts.isFunctionDeclaration(n) || ts.isFunctionExpression(n) || ts.isArrowFunction(n) ||
+  ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n) ||
+  ts.isGetAccessorDeclaration(n) || ts.isSetAccessorDeclaration(n);
+
+const hasDefaultModifier = (n) =>
+  (ts.canHaveModifiers(n) ? ts.getModifiers(n) ?? [] : []).some((m) => m.kind === K.DefaultKeyword);
+
+const memberName = (n) => (n.name && ts.isIdentifier(n.name) ? n.name.text : n.name?.getText() ?? '<computed>');
+
+// Direct naming (any depth): declarations, class members, direct initialisers.
+function directName(n, prefix) {
+  if (ts.isFunctionDeclaration(n)) return n.name ? prefix + n.name.text : hasDefaultModifier(n) ? prefix + 'default' : null;
+  if (ts.isConstructorDeclaration(n)) return prefix + 'constructor';
+  if (ts.isMethodDeclaration(n) || ts.isGetAccessorDeclaration(n) || ts.isSetAccessorDeclaration(n)) {
+    return ts.isClassLike(n.parent) ? prefix + memberName(n) : null; // object-literal methods fold
+  }
+  const p = n.parent;
+  if (ts.isVariableDeclaration(p) && ts.isIdentifier(p.name)) return prefix + p.name.text;
+  if (ts.isExportAssignment(p)) return prefix + 'default';
+  return null;
+}
+
+// Module-level only: `export const X = memo(forwardRef((p, r) => …))` is X.
+function wrapperName(n, prefix) {
+  let node = n;
+  for (;;) {
+    const p = node.parent;
+    if (!p) return null;
+    if (ts.isCallExpression(p) && p.arguments.includes(node)) { node = p; continue; }
+    if (ts.isParenthesizedExpression(p) || ts.isAsExpression(p) || ts.isSatisfiesExpression(p)) { node = p; continue; }
+    if (ts.isVariableDeclaration(p) && ts.isIdentifier(p.name) && p.initializer === node) return prefix + p.name.text;
+    if (ts.isExportAssignment(p)) return prefix + 'default';
+    return null;
+  }
+}
+
+function analyze(file, label) {
+  const text = readFileSync(file, 'utf8');
+  const sf = ts.createSourceFile(label, text, ts.ScriptTarget.Latest, true, scriptKind(file));
+  const line = (pos) => sf.getLineAndCharacterOfPosition(pos).line + 1;
+  const out = [];
+
+  function visit(node, prefix, current) {
+    if (BRANCH_KINDS.has(node.kind) || (ts.isBinaryExpression(node) && LOGICAL_OPERATORS.has(node.operatorToken.kind))) {
+      if (current) current.cc += 1;
+    }
+    if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+      const className = node.name ? node.name.text : '<class>';
+      ts.forEachChild(node, (c) => visit(c, prefix + className + '.', current));
+      return;
+    }
+    if (isFunctionLike(node)) {
+      const name = directName(node, prefix) ?? (current ? null : wrapperName(node, prefix));
+      if (name) {
+        const entry = { file: label, name, start: line(node.getStart(sf)), end: line(node.getEnd()), cc: 1 };
+        out.push(entry);
+        ts.forEachChild(node, (c) => visit(c, name + '.', entry));
+        return;
+      }
+      // anonymous: fold into `current` (or ignore when there is none)
+    }
+    ts.forEachChild(node, (c) => visit(c, prefix, current));
+  }
+
+  visit(sf, '', null);
+  return out;
+}
+
+const input = JSON.parse(readFileSync(0, 'utf8'));
+const results = [];
+for (const { path: file, label } of input.files) results.push(...analyze(file, label));
+process.stdout.write(JSON.stringify(results));

package/skills/crap-gate/crap_typescript.py

@@ -0,0 +1,30 @@
+"""Run crap_typescript.mjs and map its output to Func. Stdlib only."""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+from crap_model import Func, ToolError
+
+SCRIPT = Path(__file__).with_name("crap_typescript.mjs")
+
+
+def functions(files: list[tuple[Path, str]], cwd: Path) -> dict[str, list[Func]]:
+    """Analyse (path_on_disk, label) pairs in one node process; result keyed by label."""
+    if shutil.which("node") is None:
+        raise ToolError("node is required for the typescript analyzer but is not on PATH")
+    payload = json.dumps({"files": [{"path": str(p), "label": label} for p, label in files]})
+    proc = subprocess.run(
+        ["node", str(SCRIPT), "--cwd", str(cwd)],
+        input=payload,
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        raise ToolError(f"typescript analyzer failed (cwd {cwd}): {proc.stderr.strip()}")
+    result: dict[str, list[Func]] = {label: [] for _, label in files}
+    for item in json.loads(proc.stdout):
+        result[item["file"]].append(Func(item["file"], item["name"], item["start"], item["end"], item["cc"]))
+    return result

package/skills/crap-gate/test_cli.py

@@ -0,0 +1,152 @@
+import json
+import subprocess
+import textwrap
+from pathlib import Path
+
+import pytest
+
+import crap
+
+GIT = ["git", "-c", "user.name=t", "-c", "user.email=t@example.com", "-c", "commit.gpgsign=false"]
+
+# A stand-in for `pytest --cov`: writes a coverage.py-shaped report where
+# every function is 100% covered except those whose name starts with `un`.
+FAKE_COVERAGE = textwrap.dedent('''
+    import ast, json, sys
+    from pathlib import Path
+    files = {}
+    for p in Path("pkg").glob("*.py"):
+        fns = {}
+        for node in ast.walk(ast.parse(p.read_text())):
+            if isinstance(node, ast.FunctionDef):
+                pct = 0.0 if node.name.startswith("un") else 100.0
+                fns[node.name] = {"start_line": node.lineno, "summary": {"percent_covered": pct}}
+        files[p.as_posix()] = {"functions": fns}
+    Path(".crap").mkdir(exist_ok=True)
+    Path(".crap/coverage.json").write_text(json.dumps({"files": files}))
+''')
+
+CONFIG = {
+    "thresholds": {"existing": 15, "new": 9},
+    "base": "main",
+    "targets": [
+        {
+            "name": "backend",
+            "paths": ["pkg/**/*.py"],
+            "exclude": ["pkg/tests/**"],
+            "complexity": {"tool": "python"},
+            "coverage": {
+                "format": "coverage.py",
+                "root": ".",
+                "report": ".crap/coverage.json",
+                "command": "python3 fake_cov.py",
+            },
+        }
+    ],
+}
+
+BASE_SRC = "def f(x):\n    return x\n\n\ndef unloved(a, b):\n    if a:\n        return b\n    return a or b\n"
+
+
+def git(root, *args):
+    return subprocess.run([*GIT, *args], cwd=root, check=True, capture_output=True, text=True).stdout
+
+
+@pytest.fixture
+def repo(tmp_path, monkeypatch):
+    git(tmp_path, "init", "-q", "-b", "main")
+    (tmp_path / ".crap-gate.json").write_text(json.dumps(CONFIG))
+    (tmp_path / "fake_cov.py").write_text(FAKE_COVERAGE)
+    (tmp_path / ".gitignore").write_text(".crap/\n")
+    (tmp_path / "pkg").mkdir()
+    (tmp_path / "pkg" / "m.py").write_text(BASE_SRC)
+    git(tmp_path, "add", ".")
+    git(tmp_path, "commit", "-q", "-m", "base")
+    git(tmp_path, "switch", "-q", "-c", "feature")
+    monkeypatch.chdir(tmp_path)
+    return tmp_path
+
+
+def test_clean_branch_exits_zero(repo, capsys):
+    assert crap.main([]) == 0
+    out = capsys.readouterr().out
+    assert "no changed functions" in out
+    assert not (repo / ".crap" / "coverage.json").exists()  # nothing to measure → no run
+
+
+def test_new_untested_function_fails_with_new_limit_and_hint(repo, capsys):
+    (repo / "pkg" / "m.py").write_text(BASE_SRC + "\n\ndef unnew(p, q):\n    return p if q else (q if p else 0)\n")
+    assert crap.main([]) == 1
+    out = capsys.readouterr().out
+    assert "FAIL  pkg/m.py:11  unnew  CC 3  cov 0%  CRAP 12.0  limit 9 (new)  → cover ≥ 13% or split to CC ≤ 2" in out
+    assert "Summary: 1 FAIL, 0 ok, 0 not measured" in out
+
+
+def test_touching_existing_function_uses_existing_limit(repo, capsys):
+    src = BASE_SRC.replace("    return a or b", "    return a or b or 0")  # unloved: CC 4 → CRAP 20 > 15
+    (repo / "pkg" / "m.py").write_text(src)
+    assert crap.main(["--json"]) == 1
+    data = json.loads(capsys.readouterr().out)
+    fn = data["functions"][0]
+    assert (fn["name"], fn["kind"], fn["limit"], fn["status"], fn["cc"], fn["crap"]) == ("unloved", "existing", 15, "FAIL", 4, 20.0)
+    (run,) = data["targets"]
+    assert (run["name"], run["report"], run["ran"]) == ("backend", ".crap/coverage.json", True)
+    assert run["seconds"] >= 0
+    assert data["summary"] == {"fail": 1, "ok": 0, "not_measured": 0}
+
+
+def test_untouched_functions_are_not_reported(repo, capsys):
+    (repo / "pkg" / "m.py").write_text(BASE_SRC.replace("    return x", "    return x + 1"))
+    assert crap.main([]) == 0
+    out = capsys.readouterr().out
+    assert "ok    pkg/m.py:1  f  CC 1  cov 100%  CRAP 1.0  limit 15 (existing)" in out
+    assert "unloved" not in out
+
+
+def test_out_of_scope_code_files_are_listed_not_measured(repo, capsys):
+    (repo / "pkg" / "tests").mkdir()
+    (repo / "pkg" / "tests" / "test_m.py").write_text("def test_it():\n    assert True\n")
+    (repo / "README.md").write_text("hi\n")
+    assert crap.main([]) == 0
+    out = capsys.readouterr().out
+    assert "Not measured: pkg/tests/test_m.py" in out
+    assert "README.md" not in out
+
+
+def test_all_scores_everything_as_existing_and_flags_override(repo, capsys):
+    assert crap.main(["--all", "--threshold-existing", "2"]) == 1
+    out = capsys.readouterr().out
+    assert "FAIL  pkg/m.py:5  unloved  CC 3  cov 0%  CRAP 12.0  limit 2 (existing)" in out
+    assert "ok    pkg/m.py:1  f  CC 1" in out
+
+
+def test_no_run_without_report_is_a_tool_error(repo, capsys):
+    (repo / "pkg" / "m.py").write_text(BASE_SRC + "\n\ndef k():\n    return 1\n")
+    assert crap.main(["--no-run"]) == 2
+    assert "coverage.json" in capsys.readouterr().err
+
+
+def test_failing_coverage_command_that_still_writes_a_report_warns(repo, capsys):
+    cfg = json.loads((repo / ".crap-gate.json").read_text())
+    cfg["targets"][0]["coverage"]["command"] = "python3 fake_cov.py && exit 3"
+    (repo / ".crap-gate.json").write_text(json.dumps(cfg))
+    (repo / "pkg" / "m.py").write_text(BASE_SRC + "\n\ndef k():\n    return 1\n")
+    assert crap.main([]) == 0
+    assert "exited 3" in capsys.readouterr().err
+
+
+def test_unknown_base_is_a_tool_error(repo, capsys):
+    assert crap.main(["--base", "nope"]) == 2
+    assert "nope" in capsys.readouterr().err
+
+
+def test_config_not_at_git_toplevel_is_a_tool_error(tmp_path, monkeypatch, capsys):
+    git(tmp_path, "init", "-q", "-b", "main")
+    sub = tmp_path / "sub"
+    sub.mkdir()
+    (sub / ".crap-gate.json").write_text(json.dumps(CONFIG))
+    git(tmp_path, "add", ".")
+    git(tmp_path, "commit", "-q", "-m", "base")
+    monkeypatch.chdir(sub)
+    assert crap.main([]) == 2
+    assert "git repository root" in capsys.readouterr().err

package/skills/crap-gate/test_config.py

@@ -0,0 +1,94 @@
+import json
+
+import pytest
+
+from crap_config import CODE_SUFFIXES, Target, find_config, load, matches
+from crap_model import ToolError
+
+MINIMAL = {
+    "targets": [
+        {
+            "name": "backend",
+            "paths": ["backend/**/*.py"],
+            "exclude": ["backend/tests/**", "backend/seed_*.py"],
+            "complexity": {"tool": "python"},
+            "coverage": {
+                "format": "coverage.py",
+                "root": "backend",
+                "report": "backend/.crap/coverage.json",
+                "command": "true",
+            },
+        }
+    ]
+}
+
+
+def write(tmp_path, data):
+    p = tmp_path / ".crap-gate.json"
+    p.write_text(json.dumps(data))
+    return p
+
+
+def test_find_config_walks_up(tmp_path):
+    p = write(tmp_path, MINIMAL)
+    nested = tmp_path / "a" / "b"
+    nested.mkdir(parents=True)
+    assert find_config(nested) == p
+
+
+def test_find_config_raises_when_absent(tmp_path):
+    with pytest.raises(ToolError, match=r"\.crap-gate\.json"):
+        find_config(tmp_path)
+
+
+def test_defaults_and_overrides(tmp_path):
+    cfg = load(write(tmp_path, MINIMAL), {})
+    assert cfg.thresholds == {"existing": 15, "new": 9}
+    assert cfg.base == "origin/main"
+    assert cfg.root == tmp_path
+    cfg = load(write(tmp_path, MINIMAL), {"base": "main", "threshold_new": 5})
+    assert (cfg.base, cfg.thresholds["new"], cfg.thresholds["existing"]) == ("main", 5, 15)
+
+
+def test_target_fields(tmp_path):
+    t = load(write(tmp_path, MINIMAL), {}).targets[0]
+    assert t == Target(
+        name="backend",
+        paths=["backend/**/*.py"],
+        exclude=["backend/tests/**", "backend/seed_*.py"],
+        complexity_tool="python",
+        complexity_cwd=".",
+        coverage_format="coverage.py",
+        coverage_report="backend/.crap/coverage.json",
+        coverage_command="true",
+        coverage_root="backend",
+    )
+
+
+@pytest.mark.parametrize(
+    "bad, message",
+    [
+        ({"targets": []}, "at least one target"),
+        ({"targets": [{**MINIMAL["targets"][0], "complexity": {"tool": "lizard"}}]}, "complexity.tool"),
+        ({"targets": [{**MINIMAL["targets"][0], "coverage": {**MINIMAL["targets"][0]["coverage"], "format": "lcov"}}]}, "coverage.format"),
+        ({"targets": [MINIMAL["targets"][0], MINIMAL["targets"][0]]}, "duplicate target name"),
+        ({"thresholds": {"existing": "x"}, **MINIMAL}, "thresholds"),
+    ],
+)
+def test_validation(tmp_path, bad, message):
+    with pytest.raises(ToolError, match=message):
+        load(write(tmp_path, bad), {})
+
+
+def test_matches_globs_with_double_star_and_exclude(tmp_path):
+    t = load(write(tmp_path, MINIMAL), {}).targets[0]
+    assert matches(t, "backend/main.py")
+    assert matches(t, "backend/services/deep/x.py")
+    assert not matches(t, "backend/tests/test_x.py")
+    assert not matches(t, "backend/seed_securities.py")
+    assert not matches(t, "frontend/src/a.ts")
+    assert not matches(t, "backend/notes.md")
+
+
+def test_code_suffixes():
+    assert CODE_SUFFIXES == {".py", ".ts", ".tsx"}