boost-skill-cli 1.0.396__tar.gz → 1.0.397__tar.gz

{boost_skill_cli-1.0.396 → boost_skill_cli-1.0.397}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.396
+Version: 1.0.397
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.396 → boost_skill_cli-1.0.397}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.396'
-__version_tuple__ = version_tuple = (1, 0, 396)
+__version__ = version = '1.0.397'
+__version_tuple__ = version_tuple = (1, 0, 397)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.396 → boost_skill_cli-1.0.397}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.396
+Version: 1.0.397
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.396 → boost_skill_cli-1.0.397}/scripts/check_required_checks.py

@@ -50,6 +50,30 @@ ROOT = Path(__file__).resolve().parent.parent
 WORKFLOWS = ROOT / ".github" / "workflows"
 CONFIG = ROOT / ".github" / "required-checks.txt"
 
+# `main` is protected TWICE: by a classic branch protection and by a repository
+# ruleset. They are independent objects with independent lists, and applying the
+# file to one leaves the other untouched — which is how the ruleset came to be
+# missing `bdd`, `evals` and `onnx-inference` while this script reported the
+# config clean. It was checking the file against the *workflows*, and emitting a
+# payload for the classic endpoint only; nothing here had ever heard of a
+# ruleset.
+#
+# Which mechanism actually binds is the part that made the gap expensive rather
+# than untidy. The classic protection sets `enforce_admins: false`, so it does
+# not apply to the identity that merges here; the ruleset carries
+# `bypass_actors: []`, so it applies to everyone. The three checks missing from
+# the ruleset were therefore the three that nothing enforced — among them
+# `evals`, the retrieval-quality floor, and `onnx-inference`, whose entry in
+# required-checks.txt says in as many words that the failure it catches is
+# silent.
+GITHUB_API = "https://api.github.com"
+REPO = "jonnyeclectic/boost"
+BRANCH = "main"
+# GitHub Actions' app id. A ruleset records which app must produce each context;
+# leaving it out lets any app satisfy a check by name, which is a weaker gate
+# than the one the file describes.
+ACTIONS_APP_ID = 15368
+
 # A job id line: exactly two spaces of indent, directly under `jobs:`.
 _JOB = re.compile(r"^  ([A-Za-z0-9][\w-]*):\s*$")
 # `    name: something` within a job block overrides the displayed check name.
@@ -238,29 +262,178 @@ def workflows_for(required: str, by_name: Dict[str, List[str]]) -> List[str]:
     return ["an unknown workflow"]
 
 
+def classic_payload(required: List[str]) -> dict:
+    """The `PUT /branches/{branch}/protection` body for this required list."""
+    return {
+        "required_status_checks": {"strict": True, "contexts": list(required)},
+        # Deliberately null: the repo's working model is parallel loop/*
+        # branches self-merging, so requiring reviews would deadlock it.
+        "required_pull_request_reviews": None,
+        "enforce_admins": False,
+        "restrictions": None,
+    }
+
+
+def ruleset_rule(required: List[str]) -> dict:
+    """The `required_status_checks` RULE for a repository ruleset.
+
+    Shaped differently from the classic payload on purpose — this is not a
+    stylistic variant of the same thing. A ruleset names each context as an
+    object carrying the app that must produce it, and spells `strict` as
+    `strict_required_status_checks_policy`. Hand-translating between the two
+    forms is exactly the step that got skipped.
+    """
+    return {
+        "type": "required_status_checks",
+        "parameters": {
+            "strict_required_status_checks_policy": True,
+            "required_status_checks": [
+                {"context": c, "integration_id": ACTIONS_APP_ID} for c in required
+            ],
+        },
+    }
+
+
+def drift(required: List[str], remote: List[str]) -> Tuple[List[str], List[str]]:
+    """``(missing, extra)`` — how a live mechanism disagrees with the file.
+
+    Order-insensitive and duplicate-tolerant: GitHub returns contexts in its own
+    order, and a list that merely sorts differently is not drift.
+    """
+    want, have = set(required), set(remote)
+    return sorted(want - have), sorted(have - want)
+
+
+def _api(path: str, token: str) -> object:
+    import urllib.request
+    req = urllib.request.Request(  # noqa: S310  GITHUB_API is a hardcoded https constant
+        GITHUB_API + path,
+        headers={"Authorization": "Bearer " + token,
+                 "Accept": "application/vnd.github+json",
+                 "User-Agent": "boost-check-required-checks"})
+    with urllib.request.urlopen(req, timeout=30) as resp:  # noqa: S310  same
+        return json.load(resp)
+
+
+def ruleset_contexts(detail: dict) -> Tuple[bool, List[str]]:
+    """``(has_rule, contexts)`` for one ruleset's required-status-checks rule.
+
+    ``has_rule`` is returned separately from an empty list because the two mean
+    opposite things: a ruleset with no such rule requires nothing at all, which
+    is a much louder problem than one whose list has drifted.
+    """
+    for rule in detail.get("rules", []):
+        if rule.get("type") == "required_status_checks":
+            params = rule.get("parameters") or {}
+            return True, [c.get("context") for c in params.get("required_status_checks", [])]
+    return False, []
+
+
+def verify_remote(required: List[str], token: str) -> List[str]:
+    """Compare BOTH live mechanisms against the file. Returns problems."""
+    problems: List[str] = []
+
+    prot = _api("/repos/%s/branches/%s/protection" % (REPO, BRANCH), token)
+    contexts = ((prot or {}).get("required_status_checks") or {}).get("contexts", [])
+    missing, extra = drift(required, contexts)
+    if missing or extra:
+        problems.append(
+            "classic branch protection on %r disagrees with %s — missing %s, extra %s "
+            "(apply with `--print-api`)"
+            % (BRANCH, CONFIG.name, missing or "nothing", extra or "nothing"))
+
+    rulesets = _api("/repos/%s/rulesets" % REPO, token) or []
+    checked = 0
+    for summary in rulesets:
+        detail = _api("/repos/%s/rulesets/%s" % (REPO, summary["id"]), token)
+        includes = ((detail.get("conditions") or {}).get("ref_name") or {}).get("include", [])
+        # `~DEFAULT_BRANCH` is GitHub's alias for whatever the default branch is.
+        if not ({"refs/heads/" + BRANCH, "~DEFAULT_BRANCH"} & set(includes)):
+            continue
+        if detail.get("enforcement") != "active":
+            continue
+        checked += 1
+        has_rule, contexts = ruleset_contexts(detail)
+        if not has_rule:
+            problems.append(
+                "active ruleset %r targets %r but has no required_status_checks "
+                "rule at all — it gates nothing" % (detail.get("name"), BRANCH))
+            continue
+        missing, extra = drift(required, contexts)
+        if missing or extra:
+            problems.append(
+                "ruleset %r (id %s) disagrees with %s — missing %s, extra %s "
+                "(apply with `--print-ruleset`; send the WHOLE body, a partial "
+                "PUT drops the other rules)"
+                % (detail.get("name"), detail.get("id"), CONFIG.name,
+                   missing or "nothing", extra or "nothing"))
+
+    if not checked:
+        # Silence here would read as "the rulesets agree", which is the failure
+        # this whole function exists to stop being invisible.
+        problems.append(
+            "no active ruleset targets %r — if protection moved to rulesets, "
+            "this check is now blind; if it did not, one was deleted" % BRANCH)
+    return problems
+
+
 def main(argv: List[str]) -> int:
     ap = argparse.ArgumentParser(description=__doc__)
     ap.add_argument("--print-api", action="store_true",
-                    help="print the branch-protection API payload and exit")
+                    help="print the CLASSIC branch-protection payload and exit")
+    ap.add_argument("--print-ruleset", action="store_true",
+                    help="print the ruleset required_status_checks rule and exit")
+    ap.add_argument("--verify-remote", action="store_true",
+                    help="compare BOTH live mechanisms against the file "
+                         "(needs GITHUB_TOKEN; network — not part of `make lint`)")
     args = ap.parse_args(argv)
 
     by_name, on_pr, filtered, on_mg = collect()
     required = read_config()
 
     if args.print_api:
-        payload = {
-            "required_status_checks": {"strict": True, "contexts": required},
-            # Deliberately null: the repo's working model is parallel loop/*
-            # branches self-merging, so requiring reviews would deadlock it.
-            "required_pull_request_reviews": None,
-            "enforce_admins": False,
-            "restrictions": None,
-        }
         print("# apply with:")
         print("#   curl -X PUT -H \"Authorization: Bearer $GITHUB_TOKEN\" \\")
-        print("#     https://api.github.com/repos/jonnyeclectic/boost/branches/main/protection \\")
+        print("#     %s/repos/%s/branches/%s/protection \\" % (GITHUB_API, REPO, BRANCH))
         print("#     -d @payload.json")
-        print(json.dumps(payload, indent=2))
+        print("# NOTE: this is only HALF of `main`'s protection — see --print-ruleset.")
+        print(json.dumps(classic_payload(required), indent=2))
+        return 0
+
+    if args.print_ruleset:
+        print("# One rule out of a ruleset body. The ruleset PUT replaces the whole")
+        print("# object, so fetch it, swap ONLY this rule, and send it back — a")
+        print("# partial body silently drops deletion/non_fast_forward/code_scanning.")
+        print("#   curl %s/repos/%s/rulesets" % (GITHUB_API, REPO))
+        print(json.dumps(ruleset_rule(required), indent=2))
+        return 0
+
+    if args.verify_remote:
+        import os
+        token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+        if not token:
+            # A skip, not a pass: `make lint` never passes this flag, so the
+            # offline gate is unaffected, and a caller who asked for the remote
+            # check deserves to know it did not happen.
+            print("required-checks: --verify-remote skipped (no GITHUB_TOKEN)")
+            return 0
+        try:
+            remote_problems = verify_remote(required, token)
+        # A network fault is not drift: exit 2 (could not check) rather than 1
+        # (found a problem), so a caller can tell "GitHub was down" from "your
+        # protection is wrong" without reading the message.
+        except Exception as exc:
+            print("required-checks: --verify-remote could not reach GitHub (%s: %s)"
+                  % (type(exc).__name__, exc), file=sys.stderr)
+            return 2
+        if remote_problems:
+            print("required-checks: %d live-protection problem(s)"
+                  % len(remote_problems), file=sys.stderr)
+            for p in remote_problems:
+                print("  - %s" % p, file=sys.stderr)
+            return 1
+        print("required-checks: live protection matches %s on both mechanisms "
+              "(%d checks)." % (CONFIG.name, len(required)))
         return 0
 
     problems: List[str] = []

{boost_skill_cli-1.0.396 → boost_skill_cli-1.0.397}/tests/unit/test_required_checks.py

@@ -352,6 +352,173 @@ class TestPrintApi:
         assert payload["required_pull_request_reviews"] is None
 
 
+class TestRulesetIsTheOtherHalf:
+    """`main` is protected twice, and this gate only ever saw one of them.
+
+    The classic branch protection and the repository ruleset are independent
+    objects with independent lists. Applying `--print-api` updates the classic
+    one and leaves the ruleset exactly as it was, which is how the ruleset came
+    to be missing `bdd`, `evals` and `onnx-inference` while this script reported
+    the config clean — it was comparing the file against the *workflows*, and
+    the workflows were fine.
+
+    The asymmetry is what made that expensive. Classic protection sets
+    `enforce_admins: false`, so it does not bind the identity that merges here;
+    the ruleset carries `bypass_actors: []`, so it binds everyone. The three
+    checks absent from the ruleset were therefore the three nothing enforced.
+    """
+
+    def _mod(self, tmp_path, monkeypatch):
+        workflow(tmp_path, "ci.yml", "  lint:\n    runs-on: ubuntu-latest\n")
+        config(tmp_path, "lint\n")
+        return load(monkeypatch, tmp_path)
+
+    def test_drift_reports_missing_and_extra(self, tmp_path, monkeypatch):
+        m = self._mod(tmp_path, monkeypatch)
+        missing, extra = m.drift(["a", "b", "c"], ["b", "z"])
+        assert missing == ["a", "c"] and extra == ["z"]
+
+    def test_drift_ignores_order(self, tmp_path, monkeypatch):
+        # GitHub returns contexts in its own order; a different sort is not drift.
+        m = self._mod(tmp_path, monkeypatch)
+        assert m.drift(["a", "b"], ["b", "a"]) == ([], [])
+
+    def test_the_ruleset_rule_is_not_the_classic_payload(self, tmp_path, monkeypatch):
+        # The two API shapes differ in ways a human retyping them gets wrong:
+        # a ruleset names each context as an object carrying the producing app,
+        # and spells `strict` differently. Pinning it here is what stops the
+        # translation step being done from memory.
+        m = self._mod(tmp_path, monkeypatch)
+        rule = m.ruleset_rule(["lint", "bdd"])
+        assert rule["type"] == "required_status_checks"
+        p = rule["parameters"]
+        assert p["strict_required_status_checks_policy"] is True
+        assert p["required_status_checks"] == [
+            {"context": "lint", "integration_id": m.ACTIONS_APP_ID},
+            {"context": "bdd", "integration_id": m.ACTIONS_APP_ID},
+        ]
+
+    def test_ruleset_rule_names_github_actions_as_the_producer(self, tmp_path, monkeypatch):
+        # Without integration_id any app could satisfy a check by name, which is
+        # a weaker gate than the one required-checks.txt describes.
+        m = self._mod(tmp_path, monkeypatch)
+        assert m.ACTIONS_APP_ID == 15368
+
+    def test_a_ruleset_with_no_status_check_rule_is_distinguishable(self, tmp_path, monkeypatch):
+        # "requires nothing" and "requires a drifted list" are different faults
+        # and get different messages; collapsing them to an empty list hides the
+        # louder one.
+        m = self._mod(tmp_path, monkeypatch)
+        assert m.ruleset_contexts({"rules": [{"type": "deletion"}]}) == (False, [])
+        has, ctx = m.ruleset_contexts({"rules": [
+            {"type": "required_status_checks",
+             "parameters": {"required_status_checks": [{"context": "lint"}]}}]})
+        assert has is True and ctx == ["lint"]
+
+    # ---- verify_remote, driven against a stubbed API ------------------------
+
+    def _stub(self, m, monkeypatch, *, classic, ruleset_ctx, has_rule=True,
+              enforcement="active", includes=("refs/heads/main",)):
+        rules = [{"type": "deletion"}]
+        if has_rule:
+            rules.append({"type": "required_status_checks", "parameters": {
+                "required_status_checks": [{"context": c} for c in ruleset_ctx]}})
+        detail = {"id": 1, "name": "main", "enforcement": enforcement,
+                  "conditions": {"ref_name": {"include": list(includes)}},
+                  "rules": rules}
+
+        def fake(path, token):
+            if path.endswith("/protection"):
+                return {"required_status_checks": {"contexts": list(classic)}}
+            if path.endswith("/rulesets"):
+                return [{"id": 1}]
+            return detail
+        monkeypatch.setattr(m, "_api", fake)
+
+    def test_it_catches_the_real_regression(self, tmp_path, monkeypatch):
+        # The exact production state: classic correct, ruleset short by three.
+        m = self._mod(tmp_path, monkeypatch)
+        want = ["lint", "bdd", "evals", "onnx-inference"]
+        self._stub(m, monkeypatch, classic=want, ruleset_ctx=["lint"])
+        problems = m.verify_remote(want, "t")
+        assert len(problems) == 1
+        assert "ruleset" in problems[0]
+        for name in ("bdd", "evals", "onnx-inference"):
+            assert name in problems[0]
+
+    def test_it_stays_quiet_when_both_agree(self, tmp_path, monkeypatch):
+        m = self._mod(tmp_path, monkeypatch)
+        want = ["lint", "bdd"]
+        self._stub(m, monkeypatch, classic=want, ruleset_ctx=list(reversed(want)))
+        assert m.verify_remote(want, "t") == []
+
+    def test_it_catches_classic_drift_too(self, tmp_path, monkeypatch):
+        m = self._mod(tmp_path, monkeypatch)
+        want = ["lint", "bdd"]
+        self._stub(m, monkeypatch, classic=["lint"], ruleset_ctx=want)
+        problems = m.verify_remote(want, "t")
+        assert len(problems) == 1 and "classic" in problems[0]
+
+    def test_a_ruleset_that_gates_nothing_is_loud(self, tmp_path, monkeypatch):
+        m = self._mod(tmp_path, monkeypatch)
+        want = ["lint"]
+        self._stub(m, monkeypatch, classic=want, ruleset_ctx=[], has_rule=False)
+        problems = m.verify_remote(want, "t")
+        assert any("gates nothing" in p for p in problems)
+
+    def test_no_active_ruleset_is_reported_rather_than_passing(self, tmp_path, monkeypatch):
+        # Silence here would read as "the rulesets agree" — the exact shape of
+        # invisibility this whole check exists to remove.
+        m = self._mod(tmp_path, monkeypatch)
+        want = ["lint"]
+        self._stub(m, monkeypatch, classic=want, ruleset_ctx=want,
+                   enforcement="disabled")
+        assert any("no active ruleset" in p for p in m.verify_remote(want, "t"))
+
+    def test_a_ruleset_for_another_branch_is_not_mistaken_for_main(self, tmp_path, monkeypatch):
+        m = self._mod(tmp_path, monkeypatch)
+        want = ["lint"]
+        self._stub(m, monkeypatch, classic=want, ruleset_ctx=["something-else"],
+                   includes=("refs/heads/release",))
+        problems = m.verify_remote(want, "t")
+        # It must not grade main against a release ruleset...
+        assert not any("disagrees" in p and "ruleset" in p for p in problems)
+        # ...but must still say main has no ruleset covering it.
+        assert any("no active ruleset" in p for p in problems)
+
+    def test_the_default_branch_alias_counts_as_main(self, tmp_path, monkeypatch):
+        # GitHub writes `~DEFAULT_BRANCH` rather than a literal ref when the
+        # ruleset was created through the UI's default-branch option.
+        m = self._mod(tmp_path, monkeypatch)
+        want = ["lint"]
+        self._stub(m, monkeypatch, classic=want, ruleset_ctx=want,
+                   includes=("~DEFAULT_BRANCH",))
+        assert m.verify_remote(want, "t") == []
+
+    def test_verify_remote_without_a_token_skips_rather_than_passes(
+            self, tmp_path, monkeypatch, capsys):
+        m = self._mod(tmp_path, monkeypatch)
+        monkeypatch.delenv("GITHUB_TOKEN", raising=False)
+        monkeypatch.delenv("GH_TOKEN", raising=False)
+        assert m.main(["--verify-remote"]) == 0
+        assert "skipped" in capsys.readouterr().out
+
+    def test_print_ruleset_emits_the_rule(self, tmp_path, monkeypatch, capsys):
+        import json
+        m = self._mod(tmp_path, monkeypatch)
+        assert m.main(["--print-ruleset"]) == 0
+        out = capsys.readouterr().out
+        rule = json.loads(out[out.index("{"):])
+        assert rule["parameters"]["required_status_checks"][0]["context"] == "lint"
+
+    def test_print_api_now_says_it_is_only_half(self, tmp_path, monkeypatch, capsys):
+        # The old output invited exactly the mistake that caused this: it read
+        # as though applying it made protection correct.
+        m = self._mod(tmp_path, monkeypatch)
+        assert m.main(["--print-api"]) == 0
+        assert "--print-ruleset" in capsys.readouterr().out
+
+
 class TestRealRepo:
     def test_the_committed_config_matches_the_real_workflows(self):
         import subprocess