boost-skill-cli 1.2.202__tar.gz → 1.2.203__tar.gz

{boost_skill_cli-1.2.202 → boost_skill_cli-1.2.203}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.202
+Version: 1.2.203
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -451,7 +451,7 @@ on the left, the selected item's detail on the right.
 | `→` `←` | into and out of the detail pane, where `↑`/`↓` scroll it |
 | `⇥` | select, and multi-select for a batch install |
 | `^T` | cycle the match toggles without leaving the results |
-| `^G` | pick a category — counts per category, type a letter to jump, `↵` applies, `esc` cancels |
+| `^G` `^R` `^K` | filter by category, tap or kind — see below |
 | `↵` | install, in place, without leaving the browser |
 | `esc` | quit |
 
@@ -468,9 +468,19 @@ word and be three letters or more (`codrev` meets "code review"; `crv` does
 not), because over a long sentence letters scattered one per word match nearly
 everything.
 
-`^G` narrows to one category and the active one rides in the query as
-`#testing`; `boost browse --category testing` opens there, and `boost browse
---categories` lists every category with its count.
+`^G`, `^R` and `^K` open one picker for three filters: category, tap and kind.
+Its rows run A–Z with `all` first and `uncategorized` last, each with a count;
+`^T` toggles to largest-first. Typing filters the rows with the same matching
+the list uses for names (`as` finds `anthropics/skills`), `↑`/`↓` move, `↵`
+applies, `⇥` or `←`/`→` switch to the next filter, and `esc` clears what you
+typed before it closes the picker. Filters combine with each other and with
+the query, and each rides in the query row as a chip: `#testing
+@acme/quality kind:rule`. A picker's counts are taken under the *other*
+active filters, so each number is what picking that row would leave; they
+ignore the text query, which would mean re-indexing the catalogue on every
+open. `boost browse --category testing` opens on a category, and `boost
+browse --categories` lists every category with its count, A–Z
+(`--by-count` for largest first).
 
 Duplicates are collapsed. Registries render one skill into `.claude/`,
 `.cursor/`, `.gemini/` and a plugin root, so on a real 60,047-entry catalogue

{boost_skill_cli-1.2.202 → boost_skill_cli-1.2.203}/README.md

@@ -409,7 +409,7 @@ on the left, the selected item's detail on the right.
 | `→` `←` | into and out of the detail pane, where `↑`/`↓` scroll it |
 | `⇥` | select, and multi-select for a batch install |
 | `^T` | cycle the match toggles without leaving the results |
-| `^G` | pick a category — counts per category, type a letter to jump, `↵` applies, `esc` cancels |
+| `^G` `^R` `^K` | filter by category, tap or kind — see below |
 | `↵` | install, in place, without leaving the browser |
 | `esc` | quit |
 
@@ -426,9 +426,19 @@ word and be three letters or more (`codrev` meets "code review"; `crv` does
 not), because over a long sentence letters scattered one per word match nearly
 everything.
 
-`^G` narrows to one category and the active one rides in the query as
-`#testing`; `boost browse --category testing` opens there, and `boost browse
---categories` lists every category with its count.
+`^G`, `^R` and `^K` open one picker for three filters: category, tap and kind.
+Its rows run A–Z with `all` first and `uncategorized` last, each with a count;
+`^T` toggles to largest-first. Typing filters the rows with the same matching
+the list uses for names (`as` finds `anthropics/skills`), `↑`/`↓` move, `↵`
+applies, `⇥` or `←`/`→` switch to the next filter, and `esc` clears what you
+typed before it closes the picker. Filters combine with each other and with
+the query, and each rides in the query row as a chip: `#testing
+@acme/quality kind:rule`. A picker's counts are taken under the *other*
+active filters, so each number is what picking that row would leave; they
+ignore the text query, which would mean re-indexing the catalogue on every
+open. `boost browse --category testing` opens on a category, and `boost
+browse --categories` lists every category with its count, A–Z
+(`--by-count` for largest first).
 
 Duplicates are collapsed. Registries render one skill into `.claude/`,
 `.cursor/`, `.gemini/` and a plugin root, so on a real 60,047-entry catalogue

{boost_skill_cli-1.2.202 → boost_skill_cli-1.2.203}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.202'
-__version_tuple__ = version_tuple = (1, 2, 202)
+__version__ = version = '1.2.203'
+__version_tuple__ = version_tuple = (1, 2, 203)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.202 → boost_skill_cli-1.2.203}/boost_cli/commands/_common.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 import difflib
 from itertools import chain
 
-from ..core import lockfile, store
+from ..core import integrity, lockfile, store
 from ..errors import BoostError
 
 
@@ -104,6 +104,41 @@ def _iter_installed(names: list[str] | None = None) -> list[tuple[str, dict]]:
     return sorted(skills.items())
 
 
+def _iter_installed_rows(
+        names: list[str] | None = None) -> list[integrity.InstalledSkill]:
+    """:func:`_iter_installed`, across both scopes, each row with its ``dir``.
+
+    For a command that *reads* skills — lint, test, conflict — where a skill
+    installed ``--local`` is read from the repo's copy rather than reported
+    "not installed" beside a ``boost list`` that shows it. ``None`` is every
+    row of both locks (:func:`integrity.installed_skills`); a name resolves
+    user scope first, then the current project (:func:`integrity.resolve_skill`),
+    and a name neither holds as a skill gets exactly :func:`_iter_installed`'s
+    error, since that is the one that tells "a rule" from "not installed".
+    """
+    if names is None:
+        return integrity.installed_skills()
+    rows, rest = [], []
+    for n in dict.fromkeys(names):
+        row = integrity.resolve_skill(n)
+        if row is None:
+            rest.append(n)
+        else:
+            rows.append(row)
+    if rest:
+        _iter_installed(rest)   # raises: not a user skill, not a project one
+    return rows
+
+
+def row_dir(row: integrity.InstalledSkill):
+    """The directory to read ``row`` from: its copy, else the store path.
+
+    A row whose copy is gone still needs a path for a reader to report
+    "missing SKILL.md" from rather than crash on None.
+    """
+    return row.dir if row.dir is not None else store.skill_store_dir(row.name)
+
+
 def _shadowed_kinds(name: str, acted_kind: str) -> list[str]:
     """Other lock sections also holding ``name``.
 

{boost_skill_cli-1.2.202 → boost_skill_cli-1.2.203}/boost_cli/commands/bmad.py

@@ -444,8 +444,10 @@ def _read_hook_stdin() -> dict:
     prints nothing, which reads like a broken install.)
     """
     try:
-        if sys.stdin.isatty():
-            return {}       # interactive: don't block waiting for an EOF
+        if out.stdin_is_tty() or sys.stdin is None:
+            # Interactive: don't block waiting for an EOF. None: fd 0 was
+            # closed at launch (`<&-`), so there is nothing to read.
+            return {}
         raw = sys.stdin.read().strip()
     except (OSError, ValueError, UnicodeDecodeError):
         return {}

{boost_skill_cli-1.2.202 → boost_skill_cli-1.2.203}/boost_cli/commands/configuration.py

@@ -8,7 +8,8 @@ import argparse
 import difflib
 import json
 import os
-import re
+import plistlib
+import shlex
 import shutil
 import subprocess
 import sys
@@ -16,6 +17,7 @@ import time
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from pathlib import Path
+from xml.parsers.expat import ExpatError
 
 from .. import __version__, cliparse
 from ..core import (
@@ -525,6 +527,9 @@ def cmd_create(argv) -> int:
                    help="parent directory (default: current directory)")
     p.add_argument("--install", action="store_true",
                    help="install the new skill immediately")
+    p.add_argument("-y", "--yes", action="store_true",
+                   help="with --install, replace an installed skill of the "
+                        "same name without asking")
     args = p.parse_args(argv)
 
     name = util.resolve_slug(args.name, what="skill name")
@@ -561,11 +566,11 @@ def cmd_create(argv) -> int:
     out.ok("created %s" % _tilde(skill_md))
     if args.install:
         owner = store.existing_skill_owner(name)
-        if owner and not out.confirm(
-                "%s is already installed from %s — replace it?" % (name, owner)):
+        if owner and not (args.yes or out.confirm(
+                "%s is already installed from %s — replace it?" % (name, owner))):
             out.warn("not installed: %s is already installed from %s" % (name, owner))
             out.dim("  next: edit it, then `boost import %s`" % _tilde(target), wrap=True)
-            return 0
+            return 1    # declined: the --install half of the request did not happen
         res = store.install_from_path(target, name=name)
         out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
         if res.linked:
@@ -674,54 +679,70 @@ def cmd_policy(argv) -> int:
     # check
     pol = policy.load()
     everything = lockfile.all_installed()
+    # The user lock's skills, plus the current project's: a skill installed
+    # `--local` is as installed as any other — `boost list` shows it — and a
+    # blocklisted one passing the check because it sat in the repo's lock
+    # was a hole in the one command whose job is to catch it.
+    skill_rows = integrity.installed_skills()
+    rows: list[tuple[str, str, dict, Path | None, bool]] = [
+        ("skill", r.name, r.entry, r.dir, r.is_project) for r in skill_rows]
+    rows += [(kind, name, entry, None, False)
+             for kind, section in everything.items() if kind != "skill"
+             for name, entry in sorted(section.items())]
     min_score = int(pol.get("min_quality_score") or 0)
     # name/kind are None for the one environment-level violation below;
     # every per-item row carries both.
     violations: list[tuple[str | None, str | None, str, str]] = []
     not_checked: set[str] = set()
     total = 0
+    # `max_skills` caps what `install` counts, which is the user lock.
     skill_count = len(everything.get("skill", {}))
-    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((name, kind, label, "on the blocklist"))
-            if tap in pol["blocked_taps"]:
-                violations.append((name, kind, label, "tap %s is blocked" % tap))
-            if pol["allowed_taps"] and tap not in pol["allowed_taps"] and tap != "local":
-                violations.append((name, kind, label,
-                                   "tap %s is not on the allowlist" % tap))
-            violations.extend(
-                (name, kind, label, msg)
-                for msg in policy.check_installed_version(entry))
-            # require_description and denied_capabilities need the item's
-            # own content, which only a skill has on disk (see
-            # store.read_skill_meta) — a rule or workflow lands in a shared
-            # agent file with no per-item body to check.
-            if kind == "skill" and (pol["require_description"] or pol["denied_capabilities"]):
-                meta_body = store.read_skill_meta(name)
-                if meta_body is None:
-                    not_checked.add(
-                        "require_description/denied_capabilities "
-                        "(store copy unreadable)")
-                else:
-                    meta, body = meta_body
-                    violations.extend(
-                        (name, kind, label, msg)
-                        for msg in policy.check_installed_meta(meta, body))
-            elif kind != "skill" and (pol["require_description"] or pol["denied_capabilities"]):
+    for kind, name, entry, sdir, in_project in rows:
+        total += 1
+        label = name if kind == "skill" else "%s (%s)" % (name, kind)
+        if in_project:
+            label += " (project)"
+        tap = entry.get("tap", "local")
+        if policy.is_blocked(name, tap, pol["blocked_skills"]):
+            violations.append((name, kind, label, "on the blocklist"))
+        if tap in pol["blocked_taps"]:
+            violations.append((name, kind, label, "tap %s is blocked" % tap))
+        if pol["allowed_taps"] and tap not in pol["allowed_taps"] and tap != "local":
+            violations.append((name, kind, label,
+                               "tap %s is not on the allowlist" % tap))
+        violations.extend(
+            (name, kind, label, msg)
+            for msg in policy.check_installed_version(entry))
+        # require_description and denied_capabilities need the item's
+        # own content, which only a skill has on disk (see
+        # store.read_skill_meta) — a rule or workflow lands in a shared
+        # agent file with no per-item body to check.
+        if kind == "skill" and (pol["require_description"] or pol["denied_capabilities"]):
+            meta_body = (store.read_skill_meta(name, sdir)
+                         if sdir is not None else None)
+            if meta_body is None:
                 not_checked.add(
-                    "require_description/denied_capabilities for %s items "
-                    "(no on-disk body to check)" % kind)
-            # 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(
-                        (name, kind, label,
-                         "quality score %d < required %d" % (score, min_score)))
+                    "require_description/denied_capabilities "
+                    "(store copy unreadable)")
+            else:
+                meta, body = meta_body
+                violations.extend(
+                    (name, kind, label, msg)
+                    for msg in policy.check_installed_meta(meta, body))
+        elif kind != "skill" and (pol["require_description"] or pol["denied_capabilities"]):
+            not_checked.add(
+                "require_description/denied_capabilities for %s items "
+                "(no on-disk body to check)" % kind)
+        # Quality scoring reads a skill directory, which only skills have.
+        # A project row with no copy on disk has nothing to score; a user
+        # row keeps scoring its store path, as it always has.
+        if min_score and kind == "skill" and not (in_project and sdir is None):
+            score, _notes = util.score_skill(
+                sdir if sdir is not None else store.skill_store_dir(name))
+            if score < min_score:
+                violations.append(
+                    (name, kind, label,
+                     "quality score %d < required %d" % (score, min_score)))
     max_skills_msg = policy.max_skills_violation(skill_count)
     if max_skills_msg:
         # Not an installed item — this one is about the environment as a
@@ -734,6 +755,7 @@ def cmd_policy(argv) -> int:
         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()}
+    counts["skill"] = len(skill_rows)
     # 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.
@@ -933,6 +955,17 @@ def cmd_onboard(argv) -> int:
         if not shutil.which("gh"):
             raise BoostError("the `gh` CLI is required for --pr",
                             hint="brew install gh, or rerun without --pr")
+        # A branch left by an earlier run whose `gh pr create` failed: without
+        # this, the rerun wrote every file onto the current branch and then
+        # died on `checkout -b`, leaving them untracked with no hint.
+        if gitutil.run(["-C", str(repo), "rev-parse", "--verify", "--quiet",
+                        "refs/heads/" + _PR_BRANCH], check=False).returncode == 0:
+            raise BoostError("branch %s already exists in %s"
+                             % (_PR_BRANCH, _tilde(repo)),
+                             hint="open its PR with `git checkout %s && gh pr "
+                                  "create --fill`, or delete it with `git "
+                                  "branch -D %s` and rerun"
+                                  % (_PR_BRANCH, _PR_BRANCH))
 
     if args.dry_run:
         changes = 0
@@ -1130,24 +1163,41 @@ def _plist_path() -> Path:
     return paths.home() / "Library" / "LaunchAgents" / (_PLIST_LABEL + ".plist")
 
 
+def _schedule_env() -> dict[str, str]:
+    """The state the scheduled `boost update` must act on.
+
+    launchd and cron start the job with their own environment, so without
+    these the job updated ``~/.boost`` while its log went to the
+    ``$BOOST_HOME`` the user enabled it from.
+    """
+    return {"BOOST_HOME": str(paths.boost_home()), "HOME": str(paths.home())}
+
+
 def _plist_body(shim: Path, seconds: int) -> str:
-    log = paths.logs_dir() / "schedule.log"
-    return """<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key><string>%s</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>%s</string>
-    <string>update</string>
-  </array>
-  <key>StartInterval</key><integer>%d</integer>
-  <key>StandardOutPath</key><string>%s</string>
-  <key>StandardErrorPath</key><string>%s</string>
-</dict>
-</plist>
-""" % (_PLIST_LABEL, shim, seconds, log, log)
+    # plistlib, not string interpolation: an '&' or '<' in a path made the
+    # file invalid XML that launchd will not load.
+    log = str(paths.logs_dir() / "schedule.log")
+    return plistlib.dumps({
+        "Label": _PLIST_LABEL,
+        "ProgramArguments": [str(shim), "update"],
+        "EnvironmentVariables": _schedule_env(),
+        "StartInterval": seconds,
+        "StandardOutPath": log,
+        "StandardErrorPath": log,
+    }).decode("utf-8")
+
+
+def _cron_word(text: str) -> str:
+    # cron turns an unescaped '%' in the command into a newline.
+    return shlex.quote(text).replace("%", "\\%")
+
+
+def _cron_entry(spec: str, shim: Path) -> str:
+    env = " ".join("%s=%s" % (k, _cron_word(v))
+                   for k, v in _schedule_env().items())
+    return "%s %s %s update >> %s 2>&1 %s" % (
+        spec, env, _cron_word(str(shim)),
+        _cron_word(str(paths.logs_dir() / "schedule.log")), _CRON_MARK)
 
 
 def _crontab_lines():
@@ -1196,18 +1246,27 @@ def _interval_label(seconds) -> str:
     return "%ss" % seconds
 
 
+def _read_plist(text: str) -> dict | None:
+    """The plist's top-level dict, or None when launchd could not load it."""
+    try:
+        data = plistlib.loads(text.encode("utf-8"))
+    except (plistlib.InvalidFileException, ExpatError, ValueError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
 def _plist_interval_seconds(text: str) -> int | None:
     """Parse a usable ``StartInterval`` out of plist ``text``.
 
-    None for both "no ``StartInterval`` key" and "``StartInterval`` present
-    but not positive" — a zero or negative interval can never fire, and
-    treating it as usable is what let the next-run loop in ``cmd_schedule``
-    spin forever advancing ``nxt`` by zero seconds each pass.
+    None for "not a valid plist", "no ``StartInterval`` key" and
+    "``StartInterval`` present but not positive" — a zero or negative
+    interval can never fire, and treating it as usable is what let the
+    next-run loop in ``cmd_schedule`` spin forever advancing ``nxt`` by zero
+    seconds each pass.
     """
-    m = re.search(r"<key>StartInterval</key>\s*<integer>(-?\d+)</integer>", text)
-    if not m:
+    secs = (_read_plist(text) or {}).get("StartInterval")
+    if isinstance(secs, bool) or not isinstance(secs, int):
         return None
-    secs = int(m.group(1))
     return secs if secs > 0 else None
 
 
@@ -1232,11 +1291,18 @@ def cmd_schedule(argv) -> int:
 
     if args.action == "status":
         present, interval, next_run = False, None, None
+        invalid = None
         if darwin:
             plist = _plist_path()
-            if plist.exists():
+            text = (plist.read_text(encoding="utf-8", errors="replace")
+                    if plist.exists() else None)
+            if text is not None and _read_plist(text) is None:
+                # launchd refuses a file it cannot parse, so it is not a
+                # schedule — saying "scheduled yes" here was the lie.
+                invalid = "%s is not a valid property list" % _tilde(plist)
+            elif text is not None:
                 present = True
-                secs = _plist_interval_seconds(plist.read_text(encoding="utf-8"))
+                secs = _plist_interval_seconds(text)
                 if secs is not None:
                     interval = _interval_label(secs)
                     nxt = datetime.fromtimestamp(plist.stat().st_mtime + secs)
@@ -1253,16 +1319,23 @@ def cmd_schedule(argv) -> int:
                                 spec)
                 next_run = _cron_next_run(spec)
         if args.json:
-            print(json.dumps({
+            doc = {
                 "platform": sys.platform,
                 "backend": "launchd" if darwin else "cron",
                 "scheduled": present,
                 "interval": interval,
                 "next_run": next_run.strftime("%Y-%m-%d %H:%M") if next_run else None,
-            }, indent=2))
+            }
+            if invalid:
+                doc["error"] = invalid
+            print(json.dumps(doc, indent=2))
             return 0
         out.kv("platform", "%s (%s)" % (sys.platform, "launchd" if darwin else "cron"))
         out.kv("scheduled", "yes" if present else "no")
+        if invalid:
+            out.warn(invalid, wrap=True)
+            out.dim("  rewrite it with `boost schedule enable`", wrap=True)
+            return 0
         if present:
             out.kv("interval", "every %s" % interval if interval is not None
                    else "unknown (plist has no usable StartInterval)")
@@ -1297,9 +1370,7 @@ def cmd_schedule(argv) -> int:
                 out.warn("launchctl unavailable — the agent loads at next login")
         else:
             lines = _crontab_lines()
-            entry = "%s %s update >> %s 2>&1 %s" % (
-                _CRON_SPECS[args.interval], shim,
-                paths.logs_dir() / "schedule.log", _CRON_MARK)
+            entry = _cron_entry(_CRON_SPECS[args.interval], shim)
             if lines is None:
                 out.warn("crontab is not available — add this line yourself:")
                 out.info(entry)