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

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

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

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

{boost_skill_cli-1.0.264 → 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.264 → 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))
@@ -540,6 +544,26 @@ def cmd_explain(argv):
     return 0
 
 
+def _diag_line(line: str) -> str:
+    """Render one stored log line for display, whether it is text or JSON.
+
+    ``BOOST_LOG_FORMAT=json`` makes the file JSONL, which is the point — but
+    this command is the *human* view of that same file, and raw JSONL is not
+    it. Anything that is not a boost log object passes through untouched, so a
+    file whose format changed mid-life still reads end to end.
+    """
+    if not line.startswith("{"):
+        return line
+    try:
+        rec = json.loads(line)
+    except ValueError:
+        return line
+    if not isinstance(rec, dict) or "msg" not in rec:
+        return line
+    return "%s %-7s %s: %s" % (rec.get("ts", ""), rec.get("level", ""),
+                               rec.get("logger", ""), rec["msg"])
+
+
 def _show_diagnostics(limit):
     lp = logs.log_path()
     if not lp.exists():
@@ -548,7 +572,7 @@ def _show_diagnostics(limit):
     lines = lp.read_text(encoding="utf-8", errors="replace").splitlines()
     out.heading("diagnostic log — %s" % lp)
     for line in lines[-limit:]:
-        out.info(line)
+        out.info(_diag_line(line))
     return 0
 
 
@@ -695,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(
@@ -749,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.264 → 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.264 → 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.264 → boost_skill_cli-1.0.266}/boost_cli/core/config.py

@@ -30,6 +30,10 @@ DEFAULTS = {
         # See core/logs.py and docs/DEBUGGING.md.
         "level": "OFF",
         "file": True,  # set false (or BOOST_NO_LOG=1) to disable the log file
+        # "text" (default) or "json". json emits one JSON object per line —
+        # the same fields, but readable by jq or a log collector without a
+        # regex. Overridden by BOOST_LOG_FORMAT.
+        "format": "text",
     },
 }
 

{boost_skill_cli-1.0.264 → boost_skill_cli-1.0.266}/boost_cli/core/logs.py

@@ -28,10 +28,21 @@ to disable the file.
 Each invocation bookends the trail with an ``invoke:`` line and a ``done:`` line
 that carries the exit code and wall-clock duration, so the log doubles as a
 lightweight timing record for spotting slow commands after the fact.
+
+Line *format* is resolved separately from verbosity, same precedence shape:
+
+  1. ``BOOST_LOG_FORMAT=json|text``
+  2. config ``logging.format`` (default ``text``)
+
+``json`` emits one JSON object per line — the same fields the text formatter
+renders — so ``~/.boost/logs/boost.log`` pipes straight into ``jq`` or a log
+collector instead of needing a regex. It is the same JSONL shape
+``core.journal`` already writes for the pulse feed.
 """
 from __future__ import annotations
 
 import contextlib
+import json
 import logging
 import logging.handlers
 import os
@@ -51,6 +62,9 @@ BACKUP_COUNT = 3       # … times (N+1) files kept = ~4 MB ceiling
 KEEP_CRASH_REPORTS = 20
 
 _LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
+_FORMATS = ("text", "json")
+_TEXT_FMT = "%(asctime)s %(levelname)-7s %(name)s: %(message)s"
+_DATE_FMT = "%Y-%m-%dT%H:%M:%SZ"
 
 # Set by configure(); read by main()'s exception handler to decide whether to
 # print a full traceback or a friendly one-liner.
@@ -98,6 +112,54 @@ def _console_level(verbose: bool, debug: bool, quiet: bool) -> Optional[int]:
     return getattr(logging, cfg) if cfg in _LEVELS else None
 
 
+class JsonFormatter(logging.Formatter):
+    """One JSON object per line, carrying the text formatter's own fields.
+
+    Hand-rolled rather than pulled from a dependency: the runtime is
+    stdlib-only, ``core.journal`` already writes JSONL by hand for the pulse
+    feed, and a formatter that can raise is a formatter that loses the trail it
+    exists to keep — hence ``default=str``, so an unexpected object in a record
+    degrades to its repr instead of killing the handler.
+
+    ``converter`` is set on the instance by :func:`_formatter`, not here: as a
+    class attribute mypy binds it as a method and the signature stops matching
+    the base class's.
+    """
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload = {
+            "ts": self.formatTime(record, _DATE_FMT),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+        }
+        if record.exc_info:
+            payload["exc"] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=False, default=str)
+
+
+def log_format() -> str:
+    """Resolve the log line format: env first, then config, else ``text``."""
+    env = (os.environ.get("BOOST_LOG_FORMAT") or "").strip().lower()
+    if env in _FORMATS:
+        return env
+    from . import config
+    cfg = str(config.get("logging.format", "text") or "text").strip().lower()
+    return cfg if cfg in _FORMATS else "text"
+
+
+def _formatter(fmt_name: str) -> logging.Formatter:
+    """Build the formatter both handlers share."""
+    fmt: logging.Formatter = (JsonFormatter() if fmt_name == "json"
+                              else logging.Formatter(_TEXT_FMT,
+                                                     datefmt=_DATE_FMT))
+    # Both stamp a literal ``Z`` (UTC) suffix, so the timestamp has to be
+    # rendered in UTC — otherwise it uses local time and every line is
+    # mislabelled by the machine's offset. gmtime keeps it honest.
+    fmt.converter = time.gmtime
+    return fmt
+
+
 def _file_enabled() -> bool:
     if os.environ.get("BOOST_NO_LOG"):
         return False
@@ -141,14 +203,10 @@ def configure(verbose: bool = False, debug: bool = False,
         return logger
     _configured = True
 
-    fmt = logging.Formatter(
-        "%(asctime)s %(levelname)-7s %(name)s: %(message)s",
-        datefmt="%Y-%m-%dT%H:%M:%SZ",
-    )
-    # datefmt stamps a literal ``Z`` (UTC) suffix, so the timestamp must be
-    # rendered in UTC — otherwise ``%(asctime)s`` uses local time and every
-    # line is mislabelled by the machine's offset. gmtime keeps it honest.
-    fmt.converter = time.gmtime
+    # One formatter for both handlers: a user who asked for JSON asked for it
+    # everywhere, and a file/console split would make `--debug` disagree with
+    # the file it is meant to be showing.
+    fmt = _formatter(log_format())
 
     # File handler — always DEBUG, best-effort (never break the CLI over a log).
     if _file_enabled():

{boost_skill_cli-1.0.264 → 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.264
+Version: 1.0.266
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.264 → boost_skill_cli-1.0.266}/docs/DEBUGGING.md

@@ -80,6 +80,33 @@ BOOST_NO_LOG=1 boost install foo      # this run writes no file
 boost config set logging.file false   # permanently
 ```
 
+### Structured (JSON) log lines
+
+The trail is plain text by default. `json` emits **one JSON object per line**
+carrying the same fields, so the file pipes straight into `jq` or a log
+collector instead of needing a regex:
+
+```bash
+BOOST_LOG_FORMAT=json boost install foo    # this run
+boost config set logging.format json       # permanently
+
+jq -r 'select(.level=="WARNING") | .msg' ~/.boost/logs/boost.log
+```
+
+| Field | Meaning |
+|-------|---------|
+| `ts` | UTC timestamp, `2026-07-27T14:03:11Z` |
+| `level` | `DEBUG` … `CRITICAL` |
+| `logger` | always `boost` today |
+| `msg` | the formatted message, arguments already interpolated |
+| `exc` | the traceback — present only on records logged with an exception |
+
+The format applies to the console channel too, so `--debug` shows the same
+shape the file is recording. `boost log --diagnostics` renders JSON lines back
+as text, so switching format doesn't cost you the built-in viewer, and a file
+whose format changed mid-life still reads end to end. An unrecognised value
+falls back to `text` rather than failing the run.
+
 ---
 
 ## Crash reports
@@ -149,6 +176,7 @@ Everything that changes boost's runtime behaviour, in one place:
 | `BOOST_AGENTS_STORE` | override `~/.agents/skills` (the canonical store) |
 | `BOOST_DEBUG` | `=1` → console `DEBUG` + tracebacks |
 | `BOOST_LOG_LEVEL` | explicit console diagnostic level |
+| `BOOST_LOG_FORMAT` | `text` (default) or `json` — one JSON object per log line |
 | `BOOST_NO_LOG` | `=1` → don't write the diagnostic log file |
 | `BOOST_NO_AI` | `=1` → disable all AI calls (offline / deterministic) |
 | `BOOST_ASSUME_YES` | `=1` → auto-confirm prompts (also `--yes`/`-y`) |

{boost_skill_cli-1.0.264 → 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.264 → 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