boost-skill-cli 1.0.262__tar.gz → 1.0.264__tar.gz

{boost_skill_cli-1.0.262 → boost_skill_cli-1.0.264}/PKG-INFO

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

{boost_skill_cli-1.0.262 → boost_skill_cli-1.0.264}/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.262'
-__version_tuple__ = version_tuple = (1, 0, 262)
+__version__ = version = '1.0.264'
+__version_tuple__ = version_tuple = (1, 0, 264)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.262 → boost_skill_cli-1.0.264}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.262 → boost_skill_cli-1.0.264}/scripts/build_roadmap.py

@@ -265,6 +265,40 @@ def build_design() -> tuple[Path, str]:
     return DESIGN_HTML, html
 
 
+_CARD_ID = re.compile(r'<article class="(?:cap rcard|ritem)" id="([^"]+)"')
+
+
+def diagnose(path, committed: str, fresh: str) -> list[str]:
+    """Explain *why* a board drifted, in the terms the reader needs.
+
+    The common cause is not a hand-edit. It is a rebase: another PR's card
+    merges in as a clean new ``docs/roadmap/items/*.md``, git merges the
+    generated HTML textually and succeeds, and the board is silently missing
+    that card. The old message said only "out of date", so a PR that changed no
+    Python at all went red across lint and every test leg with nothing in the
+    log pointing at the actual cause.
+    """
+    was = _CARD_ID.findall(committed)
+    now = _CARD_ID.findall(fresh)
+    missing = [i for i in now if i not in set(was)]
+    extra = [i for i in was if i not in set(now)]
+    lines = []
+    if missing:
+        lines.append("  missing %d card(s) present in docs/roadmap/items/: %s"
+                     % (len(missing), ", ".join(missing[:8])
+                        + (" …" if len(missing) > 8 else "")))
+        lines.append("  ↳ almost always a rebase: someone else's card landed on "
+                     "main and the generated HTML merged textually.")
+    if extra:
+        lines.append("  %d card(s) in the HTML have no item file: %s"
+                     % (len(extra), ", ".join(extra[:8])
+                        + (" …" if len(extra) > 8 else "")))
+    if not missing and not extra:
+        lines.append("  the same cards, rendered differently — an item file's "
+                     "fields or body changed, or the generator did.")
+    return lines
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description="Regenerate the roadmap boards.")
     parser.add_argument(
@@ -277,21 +311,29 @@ def main(argv: list[str] | None = None) -> int:
     drift = []
     for path, fresh in targets:
         if args.check:
-            if path.read_text(encoding="utf-8") != fresh:
-                drift.append(path)
+            committed = path.read_text(encoding="utf-8")
+            if committed != fresh:
+                drift.append((path, committed, fresh))
         else:
             path.write_text(fresh, encoding="utf-8")
             print("wrote %s" % path)
 
     if args.check:
         if drift:
-            print(
-                "ERROR: roadmap HTML is out of date — regenerate with\n"
-                "    python3 scripts/build_roadmap.py\n"
-                "and commit the result (see CONTRIBUTING.md):\n  %s"
-                % "\n  ".join(str(p) for p in drift),
-                file=sys.stderr,
-            )
+            report = ["ERROR: the roadmap board is stale — regenerate with",
+                      "    python3 scripts/build_roadmap.py",
+                      "and commit the result (see CONTRIBUTING.md).",
+                      ""]
+            for path, committed, fresh in drift:
+                report.append("%s" % path)
+                report.extend(diagnose(path, committed, fresh))
+            print("\n".join(report), file=sys.stderr)
+            # One annotation so the cause is visible on the checks tab without
+            # opening a log: this failure lands on every matrix leg at once and
+            # reads as a broken build rather than a stale generated file.
+            print("::error::roadmap board is stale — run "
+                  "`python3 scripts/build_roadmap.py` and commit "
+                  "(usually needed after a rebase)")
             return 1
         print("roadmap boards are up to date.")
     return 0

boost_skill_cli-1.0.264/tests/unit/test_roadmap_fresh.py

@@ -0,0 +1,151 @@
+"""Committed roadmap HTML stays in lockstep with its item source files.
+
+The roadmap boards are generated from ``docs/roadmap/items/*.md`` by
+``scripts/build_roadmap.py`` and injected into the marker regions of the
+hand-authored pages. This test — the in-suite twin of the
+``build_roadmap.py --check`` CI step — fails if the committed HTML drifts from a
+fresh render, so a stale board can't merge.
+
+Skips when the repo-root files aren't reachable (e.g. the mutation sandbox,
+which only copies ``boost_cli/``).
+"""
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+_ROOT = Path(__file__).resolve().parents[2]
+_SCRIPT = _ROOT / "scripts" / "build_roadmap.py"
+_ITEMS = _ROOT / "docs" / "roadmap" / "items"
+
+
+def _load_builder():
+    spec = importlib.util.spec_from_file_location("build_roadmap", _SCRIPT)
+    assert spec and spec.loader
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
+                    reason="repo-root files not reachable (e.g. mutation sandbox)")
+def test_roadmap_html_is_regenerated():
+    builder = _load_builder()
+    path, fresh = builder.build_code()
+    committed = path.read_text(encoding="utf-8")
+    # Reuse the script's own diagnosis rather than restating "out of date".
+    # This assertion fires on all nine test legs at once, so what it says is
+    # what nine failures say — and the cause is a rebase far more often than a
+    # hand-edit.
+    assert committed == fresh, "\n".join(
+        ["docs/roadmap.html is stale — regenerate with",
+         "    python3 scripts/build_roadmap.py",
+         "and commit the result (see CONTRIBUTING.md).",
+         *builder.diagnose(path, committed, fresh)])
+
+
+@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
+                    reason="repo-root files not reachable (e.g. mutation sandbox)")
+def test_design_roadmap_html_is_regenerated():
+    builder = _load_builder()
+    path, fresh = builder.build_design()
+    committed = path.read_text(encoding="utf-8")
+    assert committed == fresh, "\n".join(
+        ["docs/design-roadmap.html is stale — regenerate with",
+         "    python3 scripts/build_roadmap.py",
+         "and commit the result (see CONTRIBUTING.md).",
+         *builder.diagnose(path, committed, fresh)])
+
+
+@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
+                    reason="repo-root files not reachable (e.g. mutation sandbox)")
+def test_check_flag_passes_on_fresh_tree():
+    builder = _load_builder()
+    assert builder.main(["--check"]) == 0
+
+
+@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
+                    reason="repo-root files not reachable (e.g. mutation sandbox)")
+def test_every_code_item_has_required_fields():
+    builder = _load_builder()
+    for item in builder.load_items("code"):
+        for field in ("id", "section", "status", "title"):
+            assert item.get(field), "%s: missing %r" % (item["_file"], field)
+        assert item["status"] in builder.STATUS_LABEL, (
+            "%s: bad status %r" % (item["_file"], item["status"]))
+
+
+@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
+                    reason="repo-root files not reachable (e.g. mutation sandbox)")
+def test_every_design_item_has_required_fields():
+    builder = _load_builder()
+    for item in builder.load_items("design"):
+        for field in ("id", "track", "status", "title"):
+            assert item.get(field), "%s: missing %r" % (item["_file"], field)
+        assert item["status"] in builder.DESIGN_STATUS, (
+            "%s: bad status %r" % (item["_file"], item["status"]))
+        assert str(item.get("impact", "")).lower() in builder.IMPACT_LABEL, (
+            "%s: bad impact %r" % (item["_file"], item.get("impact")))
+
+
+# ── the diagnosis itself ─────────────────────────────────────────────────────
+#
+# The failure above lands on lint and on all nine test legs simultaneously, for
+# a PR that may have changed no Python at all. Whether it reads as "the build is
+# broken" or as "regenerate the board after your rebase" is entirely down to
+# what these strings say, so they are tested rather than trusted.
+
+CARD = '<article class="cap rcard" id="%s">body</article>'
+
+
+@pytest.mark.skipif(not _SCRIPT.exists(), reason="repo-root files not reachable")
+class TestDiagnose:
+    def _lines(self, committed, fresh):
+        return _load_builder().diagnose(Path("docs/roadmap.html"),
+                                        committed, fresh)
+
+    def test_a_card_missing_from_the_html_names_it_and_blames_the_rebase(self):
+        # THE case this exists for: another PR's item file merged in cleanly,
+        # the generated HTML merged textually, and the card is simply absent.
+        lines = self._lines(CARD % "old-one",
+                            (CARD % "old-one") + (CARD % "someone-elses-card"))
+        text = "\n".join(lines)
+        assert "someone-elses-card" in text
+        assert "rebase" in text
+        assert "missing 1 card" in text
+
+    def test_several_missing_cards_are_summarised_not_dumped(self):
+        fresh = "".join(CARD % ("card-%d" % i) for i in range(20))
+        text = "\n".join(self._lines("", fresh))
+        assert "missing 20 card(s)" in text
+        assert text.count("card-") <= 9, "8 named plus the ellipsis"
+        assert "…" in text
+
+    def test_a_card_with_no_item_file_is_called_out_separately(self):
+        lines = self._lines(CARD % "deleted-item", "")
+        text = "\n".join(lines)
+        assert "no item file" in text
+        assert "deleted-item" in text
+        assert "rebase" not in text, "nothing is missing — different cause"
+
+    def test_same_cards_rendered_differently_says_so(self):
+        # A field or body edit, or a generator change — not a rebase.
+        lines = self._lines('<article class="cap rcard" id="a">old</article>',
+                            '<article class="cap rcard" id="a">new</article>')
+        text = "\n".join(lines)
+        assert "rendered differently" in text
+        assert "missing" not in text
+
+    def test_the_design_board_shape_is_recognised_too(self):
+        # design-roadmap.html uses <article class="ritem" …>, not "cap rcard".
+        fresh = ('<article class="ritem" id="BOOST-D99" data-track="x" '
+                 'data-impact="y">body</article>')
+        assert "BOOST-D99" in "\n".join(self._lines("", fresh))
+
+    def test_it_never_returns_nothing(self):
+        # An empty diagnosis would leave the assertion message ending on a
+        # colon with no explanation — worse than the message it replaced.
+        for committed, fresh in (("", ""), ("x", "y"), (CARD % "a", CARD % "a")):
+            assert self._lines(committed, fresh)

{boost_skill_cli-1.0.262 → boost_skill_cli-1.0.264}/tests/unit/test_toolchain_lock.py

@@ -21,7 +21,12 @@ REQS = ROOT / "requirements"
 GROUPS = ("lint-tools", "test-tools", "mutation-tools", "coverage-tools",
           "release-tools")
 
+# The extras group is not optional decoration: without it, `coverage[toml]==7.15.2`
+# matches `name=coverage`, then `spec` fails because the next character is `[`,
+# and the pin invariant below reports a perfectly pinned line as unpinned.
+# uv and pip-tools emit `name[extra]==version` routinely.
 _REQ = re.compile(r"^(?P<name>[A-Za-z0-9][A-Za-z0-9._-]*)"
+                  r"(?P<extras>\[[^\]]+\])?"
                   r"(?P<spec>==[^\s;\\]+)?(?P<rest>.*)$")
 
 
@@ -91,7 +96,8 @@ class TestLockInvariants:
                 m = _REQ.match(line.strip())
                 assert m, "unparseable requirement in %s: %r" % (stem, line)
                 assert m.group("spec"), \
-                    "%s is not pinned with == in %s" % (m.group("name"), stem)
+                    "%s is not pinned with == in %s: %r" % (
+                        m.group("name"), stem, line)
 
     def test_every_pin_carries_hashes(self):
         # This is the whole point: pip implies --require-hashes when any hash is
@@ -124,6 +130,60 @@ class TestLockInvariants:
             assert str(ROOT) not in text, stem
 
 
+class TestRequirementPattern:
+    """The pattern itself, against literal lines.
+
+    Everything else in this file runs `_REQ` over whatever `requirements/*.txt`
+    happens to contain today, so a form the lock does not currently use is a
+    form the pattern is never tested against. That is exactly how the extras
+    case got here: nothing in the lock carries an extra, so `coverage[toml]==…`
+    reading as *unpinned* stayed invisible until a Dependabot PR regenerated
+    the lock and the gate rejected a valid pin with a message naming the wrong
+    problem.
+    """
+
+    @staticmethod
+    def _parsed(line):
+        m = _REQ.match(line)
+        assert m, "unparseable: %r" % line
+        return m
+
+    def test_a_plain_pin(self):
+        m = self._parsed("hypothesis==6.140.3")
+        assert m.group("name") == "hypothesis"
+        assert m.group("extras") is None
+        assert m.group("spec") == "==6.140.3"
+
+    def test_a_pin_carrying_an_extra(self):
+        # THE BUG: this used to come back with spec=None.
+        m = self._parsed("coverage[toml]==7.15.2")
+        assert m.group("name") == "coverage"
+        assert m.group("extras") == "[toml]"
+        assert m.group("spec") == "==7.15.2"
+
+    def test_a_pin_carrying_several_extras(self):
+        m = self._parsed("ruff[all,dev]==0.16.0")
+        assert m.group("extras") == "[all,dev]"
+        assert m.group("spec") == "==0.16.0"
+
+    def test_a_pin_with_an_environment_marker(self):
+        m = self._parsed("coverage[toml]==7.10.7 ; python_full_version < '3.10'")
+        assert m.group("name") == "coverage"
+        assert m.group("spec") == "==7.10.7", "the marker must not eat the pin"
+
+    def test_names_with_dots_dashes_and_digits(self):
+        for line, name in (("zope.interface==7.0", "zope.interface"),
+                           ("ruff-lsp==0.1", "ruff-lsp"),
+                           ("s3transfer==0.10", "s3transfer")):
+            assert self._parsed(line).group("name") == name
+
+    def test_an_unpinned_requirement_still_reports_unpinned(self):
+        # The fix must not make everything look pinned.
+        for line in ("hypothesis", "hypothesis>=6", "coverage[toml]>=7.15",
+                     "coverage[toml]~=7.15"):
+            assert self._parsed(line).group("spec") is None, line
+
+
 class TestEvalExtraStaysOut:
     def test_langchain_stack_is_not_locked(self):
         # The [eval] extra deliberately pins the old langchain 0.3 stack (ragas

boost_skill_cli-1.0.262/tests/unit/test_roadmap_fresh.py

@@ -1,86 +0,0 @@
-"""Committed roadmap HTML stays in lockstep with its item source files.
-
-The roadmap boards are generated from ``docs/roadmap/items/*.md`` by
-``scripts/build_roadmap.py`` and injected into the marker regions of the
-hand-authored pages. This test — the in-suite twin of the
-``build_roadmap.py --check`` CI step — fails if the committed HTML drifts from a
-fresh render, so a stale board can't merge.
-
-Skips when the repo-root files aren't reachable (e.g. the mutation sandbox,
-which only copies ``boost_cli/``).
-"""
-from __future__ import annotations
-
-import importlib.util
-from pathlib import Path
-
-import pytest
-
-_ROOT = Path(__file__).resolve().parents[2]
-_SCRIPT = _ROOT / "scripts" / "build_roadmap.py"
-_ITEMS = _ROOT / "docs" / "roadmap" / "items"
-
-
-def _load_builder():
-    spec = importlib.util.spec_from_file_location("build_roadmap", _SCRIPT)
-    assert spec and spec.loader
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
-                    reason="repo-root files not reachable (e.g. mutation sandbox)")
-def test_roadmap_html_is_regenerated():
-    builder = _load_builder()
-    path, fresh = builder.build_code()
-    committed = path.read_text(encoding="utf-8")
-    assert committed == fresh, (
-        "docs/roadmap.html is out of date — regenerate with\n"
-        "    python3 scripts/build_roadmap.py\n"
-        "and commit the result (see CONTRIBUTING.md)."
-    )
-
-
-@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
-                    reason="repo-root files not reachable (e.g. mutation sandbox)")
-def test_design_roadmap_html_is_regenerated():
-    builder = _load_builder()
-    path, fresh = builder.build_design()
-    committed = path.read_text(encoding="utf-8")
-    assert committed == fresh, (
-        "docs/design-roadmap.html is out of date — regenerate with\n"
-        "    python3 scripts/build_roadmap.py\n"
-        "and commit the result (see CONTRIBUTING.md)."
-    )
-
-
-@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
-                    reason="repo-root files not reachable (e.g. mutation sandbox)")
-def test_check_flag_passes_on_fresh_tree():
-    builder = _load_builder()
-    assert builder.main(["--check"]) == 0
-
-
-@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
-                    reason="repo-root files not reachable (e.g. mutation sandbox)")
-def test_every_code_item_has_required_fields():
-    builder = _load_builder()
-    for item in builder.load_items("code"):
-        for field in ("id", "section", "status", "title"):
-            assert item.get(field), "%s: missing %r" % (item["_file"], field)
-        assert item["status"] in builder.STATUS_LABEL, (
-            "%s: bad status %r" % (item["_file"], item["status"]))
-
-
-@pytest.mark.skipif(not (_SCRIPT.exists() and _ITEMS.exists()),
-                    reason="repo-root files not reachable (e.g. mutation sandbox)")
-def test_every_design_item_has_required_fields():
-    builder = _load_builder()
-    for item in builder.load_items("design"):
-        for field in ("id", "track", "status", "title"):
-            assert item.get(field), "%s: missing %r" % (item["_file"], field)
-        assert item["status"] in builder.DESIGN_STATUS, (
-            "%s: bad status %r" % (item["_file"], item["status"]))
-        assert str(item.get("impact", "")).lower() in builder.IMPACT_LABEL, (
-            "%s: bad impact %r" % (item["_file"], item.get("impact")))