boost-skill-cli 1.0.407__tar.gz → 1.0.409__tar.gz

{boost_skill_cli-1.0.407 → boost_skill_cli-1.0.409}/PKG-INFO

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

{boost_skill_cli-1.0.407 → boost_skill_cli-1.0.409}/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.407'
-__version_tuple__ = version_tuple = (1, 0, 407)
+__version__ = version = '1.0.409'
+__version_tuple__ = version_tuple = (1, 0, 409)
 
 __commit_id__ = commit_id = None

boost_skill_cli-1.0.409/boost_cli/commands/_common.py

@@ -0,0 +1,80 @@
+"""Helpers shared across the split quality/health command modules.
+
+These were private helpers inside ``quality.py`` when it held every check
+command; lifting the two that both ``quality`` and ``safety`` need into one
+place lets the modules split without either importing back into the other.
+"""
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+from ..core import lockfile
+from ..errors import BoostError
+
+
+def _s(n: int) -> str:
+    """Plural suffix: "" for one, "s" otherwise."""
+    return "" if n == 1 else "s"
+
+
+def _iter_installed(names: Optional[List[str]] = None) -> List[Tuple[str, dict]]:
+    """[(name, lock_entry)] — all installed skills, or the given names.
+
+    A named item that exists in another lock section is declined with the
+    truth ("X is a rule — this command applies to skills") instead of the
+    "not installed" every skill-only accessor used to answer — the user can
+    see it in `boost list`, so denying it exists reads as data loss.
+    """
+    skills = lockfile.installed()
+    if names:
+        missing, other_kind = [], []
+        for n in names:
+            if n in skills:
+                continue
+            found = lockfile.find_any(n)
+            if found is not None:
+                other_kind.append((n, found[0]))
+            else:
+                missing.append(n)
+        if other_kind:
+            raise BoostError(
+                "; ".join("%s is a %s — this command applies to skills"
+                          % (n, kind) for n, kind in other_kind),
+                hint="rules and workflows are governed by pin / quarantine / "
+                     "verify / update")
+        if missing:
+            raise BoostError("not installed: %s" % ", ".join(missing),
+                            hint="see what is with `boost list`")
+        return [(n, skills[n]) for n in names]
+    return sorted(skills.items())
+
+
+def _shadowed_kinds(name: str, acted_kind: str) -> List[str]:
+    """Other lock sections also holding ``name``.
+
+    `find_any` resolves a bare name skill-first, which is right for reads but
+    silently wrong for governance: acting on the skill while a same-named rule
+    stays live in CLAUDE.md must at least be *said*. Callers warn with this.
+    """
+    return [k for k, section in lockfile.all_installed().items()
+            if k != acted_kind and name in section]
+
+
+def _iter_installed_all(
+        names: Optional[List[str]] = None) -> List[Tuple[str, str, dict]]:
+    """[(kind, name, lock_entry)] across every section, or the given names."""
+    if names:
+        out, missing = [], []
+        for n in names:
+            found = lockfile.find_any(n)
+            if found is None:
+                missing.append(n)
+            else:
+                out.append((found[0], n, found[1]))
+        if missing:
+            raise BoostError("not installed: %s" % ", ".join(missing),
+                            hint="see what is with `boost list`")
+        return out
+    return [(kind, n, e)
+            for kind, section in lockfile.all_installed().items()
+            for n, e in sorted(section.items())]

{boost_skill_cli-1.0.407 → boost_skill_cli-1.0.409}/boost_cli/commands/configuration.py

@@ -22,6 +22,7 @@ from ..core import (
     frontmatter,
     gitutil,
     installscan,
+    integrity,
     journal,
     lockfile,
     mcp,
@@ -331,27 +332,47 @@ def cmd_policy(argv) -> int:
 
     # check
     pol = policy.load()
-    installed = lockfile.installed()
+    everything = lockfile.all_installed()
     min_score = int(pol.get("min_quality_score") or 0)
-    violations = []  # (skill, problem)
-    for name, entry in sorted(installed.items()):
-        tap = entry.get("tap", "local")
-        if name in pol["blocked_skills"]:
-            violations.append((name, "on the blocklist"))
-        if tap in pol["blocked_taps"]:
-            violations.append((name, "tap %s is blocked" % tap))
-        if pol["allowed_taps"] and tap not in pol["allowed_taps"] and tap != "local":
-            violations.append((name, "tap %s is not on the allowlist" % tap))
-        if min_score:
-            score, _notes = util.score_skill(store.skill_store_dir(name))
-            if score < min_score:
-                violations.append(
-                    (name, "quality score %d < required %d" % (score, min_score)))
-    unpinned = sorted(n for n, e in installed.items() if not e.get("pinned"))
+    violations = []  # (name, problem)
+    total = 0
+    for kind, section in everything.items():
+        for name, entry in sorted(section.items()):
+            total += 1
+            label = name if kind == "skill" else "%s (%s)" % (name, kind)
+            tap = entry.get("tap", "local")
+            if name in pol["blocked_skills"]:
+                violations.append((label, "on the blocklist"))
+            if tap in pol["blocked_taps"]:
+                violations.append((label, "tap %s is blocked" % tap))
+            if pol["allowed_taps"] and tap not in pol["allowed_taps"] and tap != "local":
+                violations.append((label, "tap %s is not on the allowlist" % tap))
+            # Quality scoring reads a store directory, which only skills have.
+            if min_score and kind == "skill":
+                score, _notes = util.score_skill(store.skill_store_dir(name))
+                if score < min_score:
+                    violations.append(
+                        (label, "quality score %d < required %d" % (score, min_score)))
+    unpinned = sorted(
+        n if k == "skill" else "%s (%s)" % (n, k)
+        for k, section in everything.items()
+        for n, e in section.items() if not e.get("pinned"))
+    counts = {kind: len(section) for kind, section in everything.items()}
+    # The breakdown appears exactly when it carries information (same
+    # convention as `boost count`): a skills-only environment keeps the exact
+    # summary line it always had.
+    summary = ("%d skills" % counts["skill"]
+               if not counts["rule"] and not counts["workflow"]
+               else ", ".join("%d %s%s" % (n, kind, "s" if n != 1 else "")
+                              for kind, n in counts.items()))
 
     if args.json:
         print(json.dumps({
-            "skills": len(installed),
+            # "skills" keeps its original meaning — the skill count — with the
+            # other kinds beside it rather than silently folded in.
+            "skills": counts["skill"],
+            "counts": counts,
+            "total": total,
             "violations": [{"skill": s, "violation": v} for s, v in violations],
             "pin_only": bool(pol["pin_only"]),
             "unpinned": unpinned if pol["pin_only"] else [],
@@ -360,16 +381,16 @@ def cmd_policy(argv) -> int:
 
     if pol["pin_only"]:
         out.info("pin-only mode is on — installs/updates are frozen"
-                 + (" (%d unpinned skill(s): %s)"
+                 + (" (%d unpinned item(s): %s)"
                     % (len(unpinned), ", ".join(unpinned)) if unpinned else ""))
     if violations:
-        out.table(violations, headers=("SKILL", "VIOLATION"))
+        out.table(violations, headers=("ITEM", "VIOLATION"))
         print()
-        out.err("%d policy violation(s) across %d installed skill(s)"
-                % (len(violations), len(installed)),
+        out.err("%d policy violation(s) across %d installed item(s)"
+                % (len(violations), total),
                 hint="adjust with `boost policy set` or remove the offenders")
         return 1
-    out.ok("policy check passed (%d skills)" % len(installed))
+    out.ok("policy check passed (%s)" % summary)
     return 0
 
 
@@ -876,32 +897,51 @@ def _tool_search(args: dict):
 
 
 def _tool_list(args: dict):
-    skills = lockfile.installed()
-    if not skills:
-        return "no skills installed", False
-    return "\n".join("%s v%s (%s)%s"
-                     % (n, e.get("version", "?"), e.get("tap", "?"),
-                        " [pinned]" if e.get("pinned") else "")
-                     for n, e in sorted(skills.items())), False
+    # All three lock sections: "no skills installed" while `boost list` shows
+    # a rule is the exact disagreement this surface must not have.
+    everything = lockfile.all_installed()
+    if not any(everything.values()):
+        return "nothing installed", False
+    lines = []
+    for kind, section in everything.items():
+        for n, e in sorted(section.items()):
+            lines.append("%s v%s (%s)%s%s"
+                         % (n, e.get("version", "?"), e.get("tap", "?"),
+                            "" if kind == "skill" else " [%s]" % kind,
+                            " [pinned]" if e.get("pinned") else ""))
+    return "\n".join(lines), False
 
 
 def _tool_info(args: dict):
     name = str(args.get("name", ""))
-    entry = lockfile.get_skill(name)
+    found = lockfile.find_any(name)
+    kind, entry = found if found is not None else ("skill", None)
     matches = catalog.find(name)
     if not entry and not matches:
         return "no skill named %r (installed or in any tap)" % name, True
     src = matches[0] if matches else {}
-    lines = ["name: " + name,
-             "version: %s" % (entry or src).get("version", "?"),
-             "tap: %s" % (entry or src).get("tap", "?")]
+    kind_label = kind if entry else src.get("kind", "skill")
+    lines = ["name: " + name]
+    if kind_label != "skill":
+        lines.append("kind: %s" % kind_label)
+    lines.extend(("version: %s" % (entry or src).get("version", "?"),
+                  "tap: %s" % (entry or src).get("tap", "?")))
     if src.get("description"):
         lines.append("description: %s" % src["description"])
     if entry:
+        if kind == "skill":
+            agents_s = ", ".join(entry.get("agents") or []) or "none"
+        else:
+            # Materialized kinds record their reach per materialization.
+            agents_s = ", ".join(sorted(
+                {m.get("agent", "?")
+                 for m in entry.get("materializations") or []})) or "none"
         lines.extend(("installed: yes (%s)" % entry.get("installed_at", "?"),
-                      "agents: %s" % (", ".join(entry.get("agents") or []) or "none")))
+                      "agents: %s" % agents_s))
         if entry.get("pinned"):
             lines.append("pinned: yes")
+        if entry.get("quarantined"):
+            lines.append("quarantined: yes")
     else:
         lines.append("installed: no")
     return "\n".join(lines), False
@@ -943,14 +983,30 @@ def _tool_doctor(args: dict):
     plan = store.sync_plan()
     issues = sum(len(v) for v in plan.values())
     taps = registry.list_taps()
-    lines = ["installed skills: %d" % len(lockfile.installed()),
+    everything = lockfile.all_installed()
+    lines = ["installed skills: %d" % len(everything["skill"]),
+             "installed rules: %d · workflows: %d"
+             % (len(everything["rule"]), len(everything["workflow"])),
              "taps: %d (%d skills available)" % (len(taps), len(catalog.all_entries()))]
     for key, vals in plan.items():
         if vals:
             lines.append("%s: %s" % (key, ", ".join(str(v) for v in vals)))
-    lines.append("healthy — no issues found" if issues == 0
-                 else "%d issue(s) — run `boost sync` to fix" % issues)
-    return "\n".join(lines), issues > 0
+    # sync_plan already reports MISSING rule/workflow materializations; the
+    # digest check adds the drift sync cannot see — content edited in place.
+    mat_issues = ["%s %s: modified since install" % (kind, n)
+                  for kind in ("rule", "workflow")
+                  for n, e in sorted(everything[kind].items())
+                  if (integrity.materialized_status(n, e)
+                      == integrity.STATUS_MODIFIED)]
+    lines.extend(mat_issues)
+    total = issues + len(mat_issues)
+    if total == 0:
+        lines.append("healthy — no issues found")
+    elif mat_issues:
+        lines.append("%d issue(s) — run `boost doctor` for details" % total)
+    else:
+        lines.append("%d issue(s) — run `boost sync` to fix" % issues)
+    return "\n".join(lines), total > 0
 
 
 def _tool_discover_github(args: dict):

{boost_skill_cli-1.0.407 → boost_skill_cli-1.0.409}/boost_cli/commands/discovery.py

@@ -855,8 +855,11 @@ def _browse_tui(curses, entries):
                 title = " boost browse"
                 put(0, 6, title, th["title"])
                 rx = 6 + len(title) + 1
+                # strict=False: a terminal narrower than the 3-color palette
+                # yields fewer segments, and the extra attrs go unused.
                 for (start, length), attr in zip(
-                        _grad_segments(max(0, _w - 1 - rx)), th["rule"]):
+                        _grad_segments(max(0, _w - 1 - rx)), th["rule"],
+                        strict=False):
                     put(0, rx + start, "─" * length, attr)
                 # prompt line: cyan chevron, query, cursor, right-aligned count
                 put(1, 0, "❯", th["prompt"])
@@ -905,8 +908,11 @@ def _browse_tui(curses, entries):
                 if pane and matches:
                     e = matches[sel]
                     y0 = _h - pane
+                    # strict=False: same narrow-terminal truncation as the
+                    # titlebar rule above.
                     for (start, length), attr in zip(
-                            _grad_segments(_w - 1), th["rule"]):
+                            _grad_segments(_w - 1), th["rule"],
+                            strict=False):
                         put(y0, start, "─" * length, attr)
                     tags = "  ".join("#" + str(t) for t in
                                      (e.get("meta", {}).get("tags") or []))
@@ -1036,7 +1042,9 @@ def cmd_stats(argv):
                    help="machine-readable output")
     args = p.parse_args(argv)
     name = args.name
-    lock = lockfile.get_skill(name)
+    # find_any: a rule's lock facts are the answer, not "no skill named X".
+    found = lockfile.find_any(name)
+    kind, lock = found if found is not None else ("skill", None)
     matches = catalog.find(name)
     cat = matches[0] if matches else None
     if not lock and not cat:
@@ -1044,6 +1052,28 @@ def cmd_stats(argv):
                         hint="try `boost search %s`" % name)
     acts = {a: len(journal.events(action=a, subject=name))
             for a in ("install", "update", "uninstall")}
+    if lock is not None and kind != "skill":
+        # Materialized kinds have no store dir or agent symlinks; the lock
+        # facts and journal activity are their whole stats surface.
+        if args.as_json:
+            print(json.dumps({"name": name, "kind": kind, "installed": True,
+                              "lock": lock, "activity": acts}))
+            return 0
+        out.heading("%s (%s)" % (name, kind))
+        out.kv("version", lock.get("version", "?"))
+        out.kv("tap", lock.get("tap", "?"))
+        out.kv("installed", util.rel_time(lock.get("installed_at", "")))
+        out.kv("updated", util.rel_time(lock.get("updated_at", "")))
+        out.kv("agents", ", ".join(sorted(
+            {m.get("agent", "?") for m in lock.get("materializations") or []}))
+            or "none")
+        out.kv("pinned", "yes" if lock.get("pinned") else "no")
+        if lock.get("quarantined"):
+            out.kv("quarantined", "yes")
+        out.kv("sha256", str(lock.get("sha256", ""))[:12])
+        out.kv("activity", "%d installs · %d updates · %d uninstalls"
+               % (acts["install"], acts["update"], acts["uninstall"]))
+        return 0
     latest = cat["version"] if cat else None
     upstream = None
     if cat:
@@ -1098,7 +1128,9 @@ def cmd_count(argv):
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
     args = p.parse_args(argv)
-    installed_n = len(lockfile.installed())
+    by_kind = {kind: len(section)
+               for kind, section in lockfile.all_installed().items()}
+    installed_n = sum(by_kind.values())
     taps_n = len(registry.list_taps())
     available_n = len(catalog.all_entries())
     discovery = None
@@ -1109,11 +1141,20 @@ def cmd_count(argv):
         except (json.JSONDecodeError, OSError):
             discovery = None
     if args.as_json:
-        print(json.dumps({"installed": installed_n, "available": available_n,
+        print(json.dumps({"installed": installed_n,
+                          "skills": by_kind["skill"], "rules": by_kind["rule"],
+                          "workflows": by_kind["workflow"],
+                          "available": available_n,
                           "taps": taps_n, "discovery": discovery}))
         return 0
-    summary = ("installed %d · available %d (across %d tap%s) · discovery index %s"
-               % (installed_n, available_n, taps_n, "" if taps_n == 1 else "s",
+    # The breakdown appears exactly when it carries information: with only
+    # skills installed, "installed 2" already means two skills.
+    detail = ("" if not (by_kind["rule"] or by_kind["workflow"])
+              else " (%d skills · %d rules · %d workflows)"
+              % (by_kind["skill"], by_kind["rule"], by_kind["workflow"]))
+    summary = ("installed %d%s · available %d (across %d tap%s) · discovery index %s"
+               % (installed_n, detail, available_n, taps_n,
+                  "" if taps_n == 1 else "s",
                   discovery if discovery is not None else "not built"))
     print(out.panel(summary, title="inventory"))
     return 0