boost-skill-cli 1.0.265__tar.gz → 1.0.266__tar.gz

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/PKG-INFO

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

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/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.265'
-__version_tuple__ = version_tuple = (1, 0, 265)
+__version__ = version = '1.0.266'
+__version_tuple__ = version_tuple = (1, 0, 266)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/boost_cli/commands/discovery.py

@@ -16,6 +16,7 @@ import threading
 import time
 import urllib.parse
 from pathlib import Path
+from typing import Any, Dict, List
 
 from .. import cliparse, spin
 from ..core import (
@@ -217,7 +218,8 @@ def cmd_index(argv):
     if not shutil.which("gh"):
         raise BoostError("the GitHub CLI (gh) is required to build the index",
                         hint="brew install gh && gh auth login")
-    items, total = [], 0
+    items: List[dict] = []
+    total = 0
     pages = min((max(1, args.limit) + 99) // 100, 10)  # code search caps at 1000
     for page in range(1, pages + 1):
         spin.progress(page, pages, "searching GitHub for SKILL.md")
@@ -399,7 +401,7 @@ def cmd_recommend(argv):
         raise BoostError("no skills in any tap to recommend from",
                         hint="add registries with `boost tap --defaults`")
     stack = detect_stack(target)
-    agg = {}
+    agg: Dict[str, Dict[str, Any]] = {}
     for kw in stack["keywords"]:
         for e, s in catalog.search(kw, entries):
             rec = agg.setdefault(e["name"], {"entry": e, "score": 0,
@@ -420,10 +422,15 @@ def cmd_recommend(argv):
     if stack["frameworks"]:
         line += " · frameworks: " + ", ".join(stack["frameworks"])
     out.info(out.role("%s  (%s)" % (line, _tilde(target)), "muted"))
-    shown = ranked[:args.limit]
+    shown: List[Dict[str, Any]] = ranked[:args.limit]
     if not shown:
-        shown = [{"entry": e, "score": 0, "because": {"curated"}}
-                 for e in entries if e.get("curated")][:args.limit]
+        # Annotated rather than inlined: an unannotated literal of mixed value
+        # types infers dict[str, object], which then makes every r["entry"][…]
+        # read below an error about indexing `object`.
+        curated: List[Dict[str, Any]] = [
+            {"entry": e, "score": 0, "because": {"curated"}}
+            for e in entries if e.get("curated")]
+        shown = curated[:args.limit]
         if not shown:
             out.info("no recommendations for this stack — try `boost search <keyword>`")
             return 0
@@ -680,7 +687,7 @@ def _browse_tui(curses, entries):
     """Run the curses UI. Returns the list of entries picked for install
     (one or more, via multi-select), or None if the user quit without picking.
     """
-    state = {"picks": None}
+    state: Dict[str, Any] = {"picks": None}
     categories = _tap_categories()
     desc_cache: dict = {}
     loading: set = set()
@@ -889,7 +896,7 @@ def cmd_trending(argv):
                     out.truncate(e["description"], descw))
                    for e in sorted(curated, key=operator.itemgetter("name"))[:args.limit]])
         return 0
-    agg = {}
+    agg: Dict[str, Any] = {}
     for ev in evs:  # most-recent-first, so first ts per subject is the latest
         name = ev.get("subject") or "?"
         rec = agg.setdefault(name, {"count": 0, "last": ev.get("ts", "")})
@@ -951,7 +958,7 @@ def cmd_stats(argv):
         out.kv("sha256", str(lock.get("sha256", ""))[:12])
         if size is not None:
             out.kv("size", util.human_size(size))
-    else:
+    elif cat:   # no lock means the guard above found a catalog entry
         out.kv("version", cat["version"])
         out.kv("tap", cat["tap"])
         out.kv("description", cat["description"])

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/boost_cli/commands/info.py

@@ -14,6 +14,7 @@ import sys
 import textwrap
 import webbrowser
 from pathlib import Path
+from typing import Dict, List
 
 from .. import cliparse
 from ..core import (
@@ -126,8 +127,8 @@ def _kind_table(heading, items, extra=None):
     ``(column, key)`` pair for a per-kind column (e.g. a workflow's slot); the
     count line reuses the heading's trailing noun (`installed rules` -> `rule`)."""
     out.heading(heading)
-    headers = ("NAME", "VERSION", "TAP", "AGENTS")
-    rows = []
+    headers: tuple = ("NAME", "VERSION", "TAP", "AGENTS")  # `extra` adds a 5th
+    rows: List[tuple] = []   # 4 columns, or 5 when `extra` adds one
     for name in sorted(items):
         e = items[name]
         row = [name, e.get("version", "?"), e.get("tap", "?"),
@@ -179,7 +180,7 @@ def cmd_list(argv):
         return 0
     if skills:
         out.heading("installed skills")
-        rows = []
+        rows: List[tuple] = []   # 5 columns here, 4 for project skills below
         for name in sorted(skills):
             e = skills[name]
             # Aurora-tinted flags — now that table() aligns by visible width,
@@ -227,7 +228,8 @@ def cmd_info(argv):
     if lock:
         matches = catalog.find(name)
         same_tap = [e for e in matches if e["tap"] == lock.get("tap")]
-        cat = (same_tap or matches or [None])[0]
+        candidates = same_tap or matches
+        cat = candidates[0] if candidates else None
     else:
         cat = catalog.resolve_one(name)   # raises if unknown anywhere
 
@@ -245,7 +247,7 @@ def cmd_info(argv):
         except BoostError:
             skill_dir = None
     desc = str((cat or {}).get("description") or "")
-    meta = {}
+    meta: dict = {}
     skill_text = ""
     if skill_dir and (skill_dir / "SKILL.md").exists():
         skill_text = _read(skill_dir / "SKILL.md")
@@ -308,11 +310,11 @@ def cmd_info(argv):
             out.kv("latest", out.role(latest, "warn", bold=True)
                    + out.role("  (update available)", "muted"))
     else:
-        out.kv("latest", str(cat.get("version", "?")))
-    out.kv("tap", (lock or cat).get("tap", "?"))
+        out.kv("latest", str((cat or {}).get("version", "?")))
+    out.kv("tap", (lock or cat or {}).get("tap", "?"))
     if lock and sdir.is_dir():
         out.kv("store", _tilde(sdir))
-    src = lock.get("source_dir") if lock else cat.get("rel_dir")
+    src = lock.get("source_dir") if lock else (cat or {}).get("rel_dir")
     if src:
         out.kv("source", _tilde(src))
     if lock:
@@ -343,7 +345,9 @@ def cmd_info(argv):
         # A skill that needs an MCP server is useless without it, so this belongs
         # next to capabilities: both answer "what does this expect of my setup?"
         out.kv("mcp servers", ", ".join(r["name"] for r in mcp_servers))
-    if score is not None:
+    # All three are set together under `if skill_dir` above; naming that here
+    # states the invariant instead of leaving it for a reader to reconstruct.
+    if score is not None and size is not None and files is not None:
         out.kv("quality", "%d/100" % score)
         out.kv("size", util.human_size(size))
         out.kv("files", str(files))
@@ -715,7 +719,9 @@ def cmd_deps(argv):
             out.info("  conflicts: %s %s" % (c_name, state))
         return 1 if problems else 0
 
-    unmet, pairs, seen = [], [], set()
+    unmet: List[dict] = []
+    pairs: List[list] = []   # JSON-dumped, so lists rather than tuples
+    seen: set = set()
     for name in sorted(inst):
         meta = _skill_meta(name) or {}
         unmet.extend(
@@ -769,7 +775,7 @@ def cmd_tag(argv):
     mods = operands[1:]
 
     if args.list_all:
-        mapping = {}
+        mapping: Dict[str, List[str]] = {}
         for name, e in sorted(lockfile.installed().items()):
             for t in e.get("tags") or []:
                 mapping.setdefault(t, []).append(name)

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/boost_cli/commands/quality.py

@@ -15,7 +15,7 @@ from contextlib import suppress
 from datetime import datetime, timedelta, timezone
 from itertools import starmap
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 from .. import cliparse
 from ..core import (
@@ -431,7 +431,7 @@ def cmd_lint(argv):
             out.info("nothing to lint")
         return 0
 
-    results = []
+    results: List[Dict[str, Any]] = []
     for name, sdir in targets:
         score, notes = util.score_skill(sdir)
         meta, _ = _read_skill(sdir)
@@ -679,8 +679,8 @@ def cmd_conflict(argv):
     args = ap.parse_args(argv)
 
     installed = _iter_installed()
-    rules = []   # (skill, line, polarity, stem set)
-    declared = []
+    rules: List[Tuple[str, str, str, set]] = []   # skill, line, polarity, stems
+    declared: List[Tuple[str, str]] = []           # skill, conflicting skill
     installed_names = {n for n, _e in installed}
     for name, _entry in installed:
         meta, body = _read_skill(store.skill_store_dir(name))
@@ -705,12 +705,16 @@ def cmd_conflict(argv):
             if stem:
                 rules.append((name, raw.strip(), polarity, stem))
 
-    pairs, seen = [], set()
+    pairs: List[Dict[str, str]] = []
+    seen: set = set()   # holds both key shapes below, declared and heuristic
     for da, db in declared:
-        key = (*tuple(sorted((da, db))), "declared")
-        if key in seen:
+        # Two different key SHAPES share `seen` — a flat triple here, a pair of
+        # (skill, line) pairs below. Distinct names because reusing one made the
+        # second `sorted()` type-check against the first one's element type.
+        dkey = (*tuple(sorted((da, db))), "declared")
+        if dkey in seen:
             continue
-        seen.add(key)
+        seen.add(dkey)
         pairs.append({"kind": "declared", "a": da, "b": db,
                       "a_line": "frontmatter declares conflicts: %s" % db,
                       "b_line": ""})
@@ -720,10 +724,10 @@ def cmd_conflict(argv):
                 continue
             small = min(len(a_stem), len(b_stem))
             if small and len(a_stem & b_stem) / small >= _CONFLICT_OVERLAP:
-                key = tuple(sorted(((a_skill, a_line), (b_skill, b_line))))
-                if key in seen:
+                hkey = tuple(sorted(((a_skill, a_line), (b_skill, b_line))))
+                if hkey in seen:
                     continue
-                seen.add(key)
+                seen.add(hkey)
                 pairs.append({"kind": "heuristic", "a": a_skill, "b": b_skill,
                               "a_line": a_line, "b_line": b_line})
 

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/boost_cli/commands/safety.py

@@ -12,6 +12,7 @@ import json
 import re
 import time
 from contextlib import suppress
+from typing import Any, Dict, List
 
 from .. import cliparse
 from ..core import (
@@ -299,7 +300,7 @@ def cmd_verify(argv):
                             hint="see what is with `boost list`")
     user_names = [n for n in (args.names or []) if n in lockfile.installed()]
 
-    results = []
+    results: List[Dict[str, Any]] = []
     for name, entry in _iter_installed(user_names or (None if not args.names else [])):
         missing_fields = [f for f in ("version", "tap", "sha256", "installed_at")
                           if not entry.get(f)]
@@ -381,13 +382,13 @@ def cmd_quarantine(argv):
 
     if args.list_mode:
         rows = []
-        for name, entry in _iter_installed():
-            if not entry.get("quarantined"):
+        for name, rec in _iter_installed():
+            if not rec.get("quarantined"):
                 continue
             evs = journal.events(action="quarantine", subject=name)
             since = util.rel_time(evs[0].get("ts", "")) if evs else "?"
-            rows.append((name, entry.get("version", "?"),
-                         entry.get("tap", "?"), since))
+            rows.append((name, rec.get("version", "?"),
+                         rec.get("tap", "?"), since))
         if not rows:
             out.info("no skills in quarantine")
             return 0

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/pyproject.toml

@@ -177,6 +177,15 @@ files = ["boost_cli"]
 module = "boost_cli._version"
 ignore_missing_imports = true
 
+# Every cmd_* function takes a bare `argv`, and mypy's default mode skips the
+# BODY of any function with an untyped parameter — so the required "zero mypy
+# errors" gate was checking almost none of the CLI's dispatch logic. This turns
+# body checking on for the command layer without demanding annotated signatures
+# (76 of them), which would be churn for no extra checking.
+[[tool.mypy.overrides]]
+module = "boost_cli.commands.*"
+check_untyped_defs = true
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-q -p no:cacheprovider"

{boost_skill_cli-1.0.265 → boost_skill_cli-1.0.266}/tests/functional/test_cli_discovery.py

@@ -986,6 +986,17 @@ class TestStats:
         assert "Sync commits and PRs to Jira tickets" in r.out
         assert "0 installs · 0 updates · 0 uninstalls" in r.out
 
+    def test_installed_but_no_longer_in_any_tap(self, boost, installed):
+        # The asymmetric case: `lock` exists, `cat` is None. cmd_stats guards
+        # "neither" and then relies on that guard two screens later — enabling
+        # check_untyped_defs on the command layer is what surfaced the reliance,
+        # so it gets a test rather than an implicit invariant.
+        boost("untap", "fixture-tap", "--force")
+        r = boost("stats", "brainstorming")
+        assert "1.4.0" in r.out              # version from the lock
+        assert "not installed" not in r.out
+        assert "0 installs" in r.out or "installs" in r.out
+
     def test_unknown(self, boost, tapped):
         r = boost("stats", "nope", expect=1)
         assert "no skill named 'nope' installed or in any tap" in r.err