@jesdi/skills 0.0.9 → 0.0.11

package/skills/crap-gate/test_coverage.py

@@ -0,0 +1,88 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from crap_config import Target
+from crap_coverage import CoveragePyReport, IstanbulReport, load_report
+from crap_model import Func, ToolError
+
+COVERAGE_PY = {
+    "files": {
+        "services/x.py": {
+            "functions": {
+                "f": {"start_line": 3, "summary": {"percent_covered": 75.0}},
+                "K.m": {"start_line": 10, "summary": {"percent_covered": 0.0}},
+                "": {"start_line": 1, "summary": {"percent_covered": 100.0}},
+            }
+        }
+    }
+}
+
+
+def test_coverage_py_matches_by_start_line_and_prefixes_root():
+    r = CoveragePyReport(COVERAGE_PY, "backend")
+    assert r.has_file("backend/services/x.py")
+    assert not r.has_file("services/x.py")
+    assert r.function_coverage(Func("backend/services/x.py", "f", 3, 8, 2), []) == 0.75
+    assert r.function_coverage(Func("backend/services/x.py", "K.m", 10, 12, 2), []) == 0.0
+
+
+def test_coverage_py_falls_back_to_first_entry_inside_range_else_zero():
+    r = CoveragePyReport(COVERAGE_PY, "backend")
+    # decorated function: analyzer says def at 2, coverage.py says 3
+    assert r.function_coverage(Func("backend/services/x.py", "f", 2, 8, 2), []) == 0.75
+    assert r.function_coverage(Func("backend/services/x.py", "ghost", 20, 25, 2), []) == 0.0
+
+
+def istanbul(repo_root):
+    path = str(repo_root / "frontend/src/a.tsx")
+    return {
+        path: {
+            "path": path,
+            "statementMap": {
+                "0": {"start": {"line": 2, "column": 0}, "end": {"line": 2, "column": 10}},
+                "1": {"start": {"line": 3, "column": 0}, "end": {"line": 3, "column": 10}},
+                "2": {"start": {"line": 5, "column": 0}, "end": {"line": 5, "column": 10}},  # inside child
+                "3": {"start": {"line": 9, "column": 0}, "end": {"line": 9, "column": 10}},  # outside
+            },
+            "s": {"0": 1, "1": 0, "2": 0, "3": 1},
+            "branchMap": {
+                "0": {"loc": {"start": {"line": 3, "column": 4}, "end": {"line": 3, "column": 9}},
+                      "type": "cond-expr", "locations": [], "line": 3},
+            },
+            "b": {"0": [1, 0]},
+            "fnMap": {},
+            "f": {},
+        }
+    }
+
+
+def test_istanbul_counts_statements_and_branches_in_range_excluding_children(tmp_path):
+    r = IstanbulReport(istanbul(tmp_path), tmp_path)
+    assert r.has_file("frontend/src/a.tsx")
+    parent = Func("frontend/src/a.tsx", "P", 1, 7, 3)
+    child = Func("frontend/src/a.tsx", "P.c", 4, 6, 1)
+    # statements 0 (hit), 1 (miss) + branches [1, 0] → 2 of 4
+    assert r.function_coverage(parent, [child]) == 0.5
+    # child has one statement, missed
+    assert r.function_coverage(child, []) == 0.0
+
+
+def test_istanbul_function_without_statements_is_fully_covered(tmp_path):
+    r = IstanbulReport(istanbul(tmp_path), tmp_path)
+    assert r.function_coverage(Func("frontend/src/a.tsx", "T", 20, 21, 1), []) == 1.0
+
+
+def target(fmt, report, root="."):
+    return Target("t", ["**"], [], "python", ".", fmt, report, "", root)
+
+
+def test_load_report_dispatches_and_errors(tmp_path):
+    (tmp_path / "cov.json").write_text(json.dumps(COVERAGE_PY))
+    r = load_report(target("coverage.py", "cov.json", "backend"), tmp_path)
+    assert isinstance(r, CoveragePyReport)
+    (tmp_path / "ist.json").write_text(json.dumps(istanbul(tmp_path)))
+    assert isinstance(load_report(target("istanbul", "ist.json"), tmp_path), IstanbulReport)
+    with pytest.raises(ToolError, match="missing.json"):
+        load_report(target("istanbul", "missing.json"), tmp_path)

package/skills/crap-gate/test_git.py

@@ -0,0 +1,71 @@
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from crap_git import changed_files, merge_base, show, toplevel, touched_lines, tracked_files
+from crap_model import ToolError
+
+GIT = ["git", "-c", "user.name=t", "-c", "user.email=t@example.com", "-c", "commit.gpgsign=false"]
+
+
+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):
+    git(tmp_path, "init", "-q", "-b", "main")
+    (tmp_path / "pkg").mkdir()
+    (tmp_path / "pkg" / "a.py").write_text("def f(x):\n    return x\n\n\ndef g(y):\n    return y\n")
+    (tmp_path / "pkg" / "old.py").write_text("def h():\n    return 1\n")
+    git(tmp_path, "add", ".")
+    git(tmp_path, "commit", "-q", "-m", "base")
+    git(tmp_path, "switch", "-q", "-c", "feature")
+    return tmp_path
+
+
+def test_toplevel_and_merge_base(repo):
+    assert toplevel(repo / "pkg") == repo
+    assert merge_base(repo, "main") == git(repo, "rev-parse", "main").strip()
+    with pytest.raises(ToolError, match="nope"):
+        merge_base(repo, "nope")
+
+
+def test_changed_files_covers_modified_added_renamed_untracked_and_skips_deleted(repo):
+    base = merge_base(repo, "main")
+    (repo / "pkg" / "a.py").write_text("def f(x):\n    return x + 1\n\n\ndef g(y):\n    return y\n")
+    git(repo, "mv", "pkg/old.py", "pkg/new.py")
+    (repo / "pkg" / "added.py").write_text("def k():\n    return 2\n")
+    git(repo, "add", "pkg/added.py")
+    git(repo, "commit", "-q", "-m", "work")
+    (repo / "pkg" / "untracked.py").write_text("def u():\n    return 3\n")
+    (repo / "pkg" / "gone.py").write_text("x = 1\n")
+    git(repo, "add", "pkg/gone.py")
+    git(repo, "commit", "-q", "-m", "add gone")
+    (repo / "pkg" / "gone.py").unlink()
+    assert changed_files(repo, base) == [
+        ("pkg/a.py", "pkg/a.py"),
+        ("pkg/added.py", None),
+        ("pkg/new.py", "pkg/old.py"),
+        ("pkg/untracked.py", None),
+    ]
+
+
+def test_touched_lines_include_pure_deletions(repo):
+    base = merge_base(repo, "main")
+    # change line 2, delete lines 5-6 (function g)
+    (repo / "pkg" / "a.py").write_text("def f(x):\n    return x * 2\n\n\n")
+    assert touched_lines(repo, base, "pkg/a.py") == [(2, 2), (4, 5)]
+
+
+def test_show_returns_base_content_or_none(repo):
+    base = merge_base(repo, "main")
+    assert show(repo, base, "pkg/old.py") == "def h():\n    return 1\n"
+    assert show(repo, base, "pkg/missing.py") is None
+
+
+def test_tracked_files_includes_untracked_and_excludes_deleted(repo):
+    (repo / "pkg" / "u.py").write_text("")
+    (repo / "pkg" / "old.py").unlink()
+    assert tracked_files(repo) == ["pkg/a.py", "pkg/u.py"]

package/skills/crap-gate/test_python.py

@@ -0,0 +1,94 @@
+import pytest
+
+from crap_model import Func, ToolError
+from crap_python import functions
+
+SRC = '''
+def simple(x):
+    return x
+
+def branchy(items, flag):
+    total = 0
+    for i in items:
+        if i and flag:
+            total += 1
+        elif i > 2:
+            total += 2
+    return total if total else -1
+
+class K:
+    def method(self, xs):
+        return [x for x in xs if x]
+
+def outer(f):
+    def inner(y):
+        return y if y else 0
+    handler = lambda z: z if z else 1
+    return inner(f) + handler(f)
+'''
+
+
+def by_name(funcs):
+    return {f.name: f for f in funcs}
+
+
+def test_named_functions_with_qualified_names_and_ranges():
+    got = by_name(functions(SRC, "m.py"))
+    assert set(got) == {"simple", "branchy", "K.method", "outer", "outer.inner"}
+    assert got["simple"] == Func("m.py", "simple", 2, 3, 1)
+    assert (got["branchy"].start, got["branchy"].end) == (5, 12)
+    assert (got["outer"].start, got["outer"].end) == (18, 22)
+    assert (got["outer.inner"].start, got["outer.inner"].end) == (19, 20)
+
+
+def test_cyclomatic_complexity_counts_branches_boolops_ternaries_comprehensions():
+    got = by_name(functions(SRC, "m.py"))
+    assert got["branchy"].cc == 6       # for, if, `and`, elif, ternary
+    assert got["K.method"].cc == 3      # comprehension for + if
+    assert got["outer"].cc == 2         # lambda's ternary folds into outer
+    assert got["outer.inner"].cc == 2   # its own ternary, not counted in outer
+
+
+def test_try_except_match_and_async():
+    src = '''
+async def fetch(url):
+    try:
+        return await get(url)
+    except ValueError:
+        return None
+    except KeyError:
+        return {}
+
+def route(cmd):
+    match cmd:
+        case "a":
+            return 1
+        case "b":
+            return 2
+    while True:
+        break
+'''
+    got = by_name(functions(src, "m.py"))
+    assert got["fetch"].cc == 3   # two except handlers
+    assert got["route"].cc == 4   # two cases + while
+
+
+def test_defs_under_module_level_if_and_decorators():
+    src = '''
+import typing
+if typing.TYPE_CHECKING:
+    def stub(a):
+        return a or 1
+
+@decorator
+def deco(b):
+    return b
+'''
+    got = by_name(functions(src, "m.py"))
+    assert got["stub"].cc == 2
+    assert got["deco"].start == 8   # the `def` line, not the decorator line
+
+
+def test_syntax_error_is_a_tool_error():
+    with pytest.raises(ToolError, match="m.py"):
+        functions("def (:", "m.py")

package/skills/crap-gate/test_score.py

@@ -0,0 +1,49 @@
+import math
+
+from crap_model import Func
+from crap_score import crap_score, hint, max_cc, required_coverage, score
+
+THRESHOLDS = {"existing": 15, "new": 9}
+
+
+def test_formula_matches_savoia_definition():
+    assert crap_score(22, 0.0) == 506
+    assert crap_score(9, 1.0) == 9
+    assert crap_score(5, 0.0) == 30
+    assert math.isclose(crap_score(41, 0.86), 41 * 41 * 0.14**3 + 41)
+
+
+def test_required_coverage_is_none_when_cc_alone_exceeds_limit():
+    assert required_coverage(10, 9) is None
+    assert required_coverage(16, 15) is None
+
+
+def test_required_coverage_at_the_edge_is_full():
+    assert required_coverage(9, 9) == 1.0
+
+
+def test_required_coverage_scales_with_cc():
+    assert required_coverage(2, 9) == 0.0
+    assert math.isclose(required_coverage(5, 9), 1 - (4 / 25) ** (1 / 3))
+
+
+def test_max_cc_is_largest_passing_complexity_at_given_coverage():
+    assert max_cc(0.0, 9) == 2      # CC 3 at 0% = 12 > 9
+    assert max_cc(1.0, 15) == 15
+    assert max_cc(1.0, 9) == 9
+
+
+def test_hint_offers_coverage_when_reachable_and_split_when_cc_too_high():
+    assert hint(5, 0.0, 9) == "cover ≥ 46% or split to CC ≤ 2"
+    assert hint(22, 0.0, 15) == "split to CC ≤ 3"
+    assert hint(9, 0.5, 9) == "cover ≥ 100% or split to CC ≤ 5"   # 25·0.125+5 = 8.1 ok, 36·0.125+6 = 10.5 not
+
+
+def test_score_uses_new_limit_for_new_functions():
+    f = Func("a.py", "f", 1, 5, 5)
+    new = score("backend", f, 0.0, "new", THRESHOLDS)
+    old = score("backend", f, 0.0, "existing", THRESHOLDS)
+    assert (new.limit, new.status) == (9, "FAIL")
+    assert (old.limit, old.status) == (15, "FAIL")
+    ok = score("backend", f, 1.0, "new", THRESHOLDS, note="n")
+    assert (ok.status, ok.hint, ok.note, ok.crap) == ("ok", "", "n", 5)

package/skills/crap-gate/test_typescript.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+
+import pytest
+
+from crap_model import Func, ToolError
+from crap_typescript import functions
+
+REPO_ROOT = Path(__file__).resolve().parents[2]  # has node_modules/typescript (devDependency)
+
+TSX = """import { memo, useMemo } from 'react';
+export function Plain(a: number) { return a; }
+export const Widget = ({ items, flag }: { items: number[]; flag?: boolean }) => {
+  const tiles = useMemo(() => items.filter((i) => i > 1 && flag), [items, flag]);
+  const onKey = (e: { key: string }) => (e.key === 'a' ? 1 : 0);
+  return <div>{flag ? tiles.map((t) => <span key={t}>{t}</span>) : null}</div>;
+};
+export default memo(({ x }: { x?: number }) => x ?? 0);
+class Store { get(k: string) { return k || 'x'; } }
+export const Wrapped = memo(function Inner({ n }: { n: number }) { return n?.toString() ?? ''; });
+button.addEventListener('click', () => { if (ready) go(); });
+"""
+
+
+def write(tmp_path, name, text):
+    p = tmp_path / name
+    p.write_text(text)
+    return p
+
+
+def by_name(funcs):
+    return {f.name: f for f in funcs}
+
+
+def test_named_functions_folding_and_cc(tmp_path):
+    p = write(tmp_path, "w.tsx", TSX)
+    got = by_name(functions([(p, "src/w.tsx")], REPO_ROOT)["src/w.tsx"])
+    assert set(got) == {"Plain", "Widget", "Widget.onKey", "default", "Store.get", "Wrapped"}
+    assert got["Plain"] == Func("src/w.tsx", "Plain", 2, 2, 1)
+    assert (got["Widget"].start, got["Widget"].end, got["Widget"].cc) == (3, 7, 3)  # `&&` in filter cb + ternary in JSX
+    assert got["Widget.onKey"].cc == 2
+    assert got["default"].cc == 2          # `??`
+    assert got["Store.get"].cc == 2        # `||`
+    assert got["Wrapped"].cc == 2          # `??`; optional chaining not counted
+    # the addEventListener callback has no named ancestor → ignored, not a function
+
+
+def test_switch_loops_catch_and_logical_assignment(tmp_path):
+    src = """export function f(k: string, xs: number[]) {
+  let n = 0;
+  switch (k) { case 'a': n = 1; break; case 'b': n = 2; break; default: n = 3; }
+  for (const x of xs) { while (x > n) { n++; } }
+  try { n ||= 4; } catch (e) { n &&= 5; }
+  do { n--; } while (n > 0);
+  return n;
+}
+"""
+    p = write(tmp_path, "f.ts", src)
+    got = by_name(functions([(p, "src/f.ts")], REPO_ROOT)["src/f.ts"])
+    assert got["f"].cc == 9  # 2 cases, for-of, while, catch, ||=, &&=, do-while
+
+
+def test_batch_returns_every_label_even_when_empty(tmp_path):
+    a = write(tmp_path, "a.ts", "export const n = 1;\n")
+    b = write(tmp_path, "b.ts", "export const g = () => 1;\n")
+    got = functions([(a, "a.ts"), (b, "b.ts")], REPO_ROOT)
+    assert got["a.ts"] == []
+    assert [f.name for f in got["b.ts"]] == ["g"]
+
+
+def test_missing_typescript_package_is_a_tool_error(tmp_path):
+    p = write(tmp_path, "a.ts", "export const g = () => 1;\n")
+    with pytest.raises(ToolError, match="typescript"):
+        functions([(p, "a.ts")], tmp_path)

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-07-31T14:48:08.872Z",
+  "generatedAt": "2026-08-30T22:42:44.950Z",
   "skills": [
     {
       "name": "backlog",
@@ -20,6 +20,12 @@
       "hash": "sha256-5f239c09fd46ba4c1887da88374a75e12e3df31ff18e93ed9367bdd06f3b386c",
       "description": "CEO/founder-mode plan review. Rethink the problem, find the 10-star product,\nchallenge premises, expand scope when it creates a better product. Four modes:\nSCOPE EXPANSION (dream big), SELECTIVE EXPANSION (hold scope + cherry-pick\nexpansions), HOLD SCOPE (maximum rigor), SCOPE REDUCTION (strip to essentials).\nUse when asked to \"think bigger\", \"expand scope\", \"strategy review\", \"rethink this\",\n\"what would you do differently\", or when reviewing project direction and goals.\nProduces a structured review document with analysis and recommendations.\n"
     },
+    {
+      "name": "crap-gate",
+      "version": "0.1.1",
+      "hash": "sha256-c4d66903f2d8b3d17b65e193f75ee0eea6dff9b8f47bd04a520a4f10778d895c",
+      "description": "Score every function a branch changed with CRAP (cyclomatic complexity × untested fraction), fail on existing functions > 15 and new functions > 9, and drive a fixer + independent reviewer loop until the gate passes. Use when implementation is done and before pushing, when the user says \"run the crap gate\", \"check CRAP\", \"is this change tested enough\", or when a push gate reports CRAP violations."
+    },
     {
       "name": "file-bug-issue",
       "version": "0.1.0",