boost-skill-cli 1.2.88__tar.gz → 1.2.90__tar.gz

{boost_skill_cli-1.2.88/boost_skill_cli.egg-info → boost_skill_cli-1.2.90}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.88
+Version: 1.2.90
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/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.88'
-__version_tuple__ = version_tuple = (1, 2, 88)
+__version__ = version = '1.2.90'
+__version_tuple__ = version_tuple = (1, 2, 90)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/commands/configuration.py

@@ -394,8 +394,14 @@ def cmd_create(argv) -> int:
     journal.log("create", name, path=str(target))
     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)):
+            out.warn("not installed: %s is already installed from %s" % (name, owner))
+            out.dim("  next: edit it, then `boost import %s`" % _tilde(target))
+            return 0
         res = store.install_from_path(target, name=name)
-        out.ok("installed %s → %s" % (name, _tilde(res.dest)))
+        out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
         if res.linked:
             out.info("linked: " + ", ".join(agents.display_name(a) for a in res.linked))
     else:

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/commands/hooks.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 
 from .. import cliparse
 from ..core import claude_settings as cs
-from ..core import hookhost, journal
+from ..core import hookhost, journal, util
 from ..core import output as out
 from ..errors import BoostError
 
@@ -50,7 +50,7 @@ def cmd_hooks(argv) -> int:
                    help="settings scope (default: project; list shows both)")
     p.add_argument("-m", "--matcher",
                    help="Claude matcher, e.g. 'startup|resume|clear'")
-    p.add_argument("--timeout", type=int, default=10,
+    p.add_argument("--timeout", type=util.positive_int, default=10,
                    help="hook timeout in seconds (default: 10)")
     args = p.parse_args(argv)
 
@@ -129,12 +129,15 @@ def _add(args) -> int:
     if event not in hookhost.events(host):
         out.warn("'%s' is not a known %s hook event — adding anyway"
                  % (event, hookhost.event_label(host)))
-    cs.add_hook(scope, event, args.name, args.command,
-                matcher=args.matcher, timeout=args.timeout, host=host)
+    snapshot = cs.add_hook(scope, event, args.name, args.command,
+                           matcher=args.matcher, timeout=args.timeout,
+                           host=host)
     journal.log("hook-add", args.name, scope=scope, event=event, host=host)
     out.ok("added %s hook '%s' (%s) → %s"
            % (event, args.name, _where(host, scope), args.command))
     out.dim("  settings: %s" % cs.settings_path(scope, host=host))
+    if snapshot is not None:
+        out.dim("  backup:   %s" % snapshot)
     return 0
 
 

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/commands/intelligence.py

@@ -28,6 +28,7 @@ from ..core import (
     gitutil,
     imperative,
     journal,
+    jsonstate,
     lockfile,
     paths,
     registry,
@@ -95,17 +96,33 @@ def _bump_patch(v: str) -> str:
 
 def _load_state(fname: str, default: dict) -> dict:
     p = paths.state_dir() / fname
-    if not p.exists():
-        return json.loads(json.dumps(default))
-    try:
-        return json.loads(p.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
+    data, err = jsonstate.read_object(p)
+    if err:
+        # stderr unconditionally: some callers (`context status --json`) read
+        # this before deciding whether they're printing JSON to stdout, and a
+        # warning has no business inside that payload.
+        out.warn("%s — reading as the default; the file is left on disk but "
+                 "the next write here replaces it" % err, stream=sys.stderr)
+    if data is None:
         return json.loads(json.dumps(default))
+    return data
 
 
 def _save_state(fname: str, data: dict) -> None:
     paths.ensure_dirs()
-    (paths.state_dir() / fname).write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    p = paths.state_dir() / fname
+    if jsonstate.is_corrupt(p):
+        dest = jsonstate.quarantine(p)
+        out.warn("%s was corrupt and has been moved to %s before writing "
+                 "the new file" % (p, dest), stream=sys.stderr)
+    p.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
+def _save_generated_fallback(name: str, text: str, reason: str) -> None:
+    fallback = Path.cwd() / ("%s.SKILL.md" % name)
+    fallback.write_text(text, encoding="utf-8")
+    out.warn("not installed: %s" % reason)
+    out.info("generated skill saved to %s" % _tilde(fallback))
 
 
 def _install_generated(name: str, text: str) -> None:
@@ -115,7 +132,19 @@ def _install_generated(name: str, text: str) -> None:
     must not be allowed to propagate out of the ``with`` block and delete it —
     that would discard an LLM generation the user paid for, with nothing on disk
     to recover. On a refusal, save it beside the cwd and say where it went.
+
+    ``install_from_path`` refuses to overwrite a *pinned* name, but silently
+    replaces an unpinned one — the common case, since it doubles as the
+    ``boost import``/``reinstall`` path. Ask before doing that here, so
+    ``distill``/``infer``/``absorb --install`` don't quietly destroy an
+    existing install and relabel its lock provenance ``local``.
     """
+    owner = store.existing_skill_owner(name)
+    if owner and not out.confirm(
+            "%s is already installed from %s — replace it?" % (name, owner)):
+        _save_generated_fallback(
+            name, text, "%s is already installed from %s" % (name, owner))
+        return
     with tempfile.TemporaryDirectory(prefix="boost-gen-") as td:
         src = Path(td) / name
         src.mkdir()
@@ -123,12 +152,9 @@ def _install_generated(name: str, text: str) -> None:
         try:
             res = store.install_from_path(src, name=name, tap_label="local")
         except BoostError as err:
-            fallback = Path.cwd() / ("%s.SKILL.md" % name)
-            fallback.write_text(text, encoding="utf-8")
-            out.warn("not installed: %s" % err.message)
-            out.info("generated skill saved to %s" % _tilde(fallback))
+            _save_generated_fallback(name, text, err.message)
             return
-    out.ok("installed %s → %s" % (name, _tilde(res.dest)))
+    out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
     if res.linked:
         out.info(out.role("linked into: %s" % ", ".join(res.linked), "muted"))
 
@@ -560,7 +586,7 @@ def cmd_absorb(argv: list[str]) -> int:
         description="Turn recurring chat-history patterns into a skill")
     ap.add_argument("--history", metavar="PATH",
                     help="history .jsonl file or directory of them")
-    ap.add_argument("--limit", type=int, default=5, metavar="N",
+    ap.add_argument("--limit", type=util.positive_int, default=5, metavar="N",
                     help="max patterns to absorb (default: 5)")
     ap.add_argument("--install", action="store_true",
                     help="install the generated skill")
@@ -1195,7 +1221,7 @@ def cmd_chat(argv: list[str]) -> int:
         description="Ask about skills in plain language")
     ap.add_argument("question", nargs="*", metavar="QUESTION",
                     help="ask once and exit; omit for an interactive session")
-    ap.add_argument("-k", "--limit", type=int, default=chat_engine.TOP_K,
+    ap.add_argument("-k", "--limit", type=util.positive_int, default=chat_engine.TOP_K,
                     metavar="N", help="candidate skills to consider (default %d)"
                                       % chat_engine.TOP_K)
     ap.add_argument("--no-sources", action="store_true",

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/commands/quality.py

@@ -266,7 +266,7 @@ _DRIFT_ROLE = {"in-sync": "success", "local-edits": "warn",
                "quarantined": "muted"}
 
 
-def _drift_hint(name: str, status: str) -> str:
+def _drift_hint(name: str, status: str, tap: str = "") -> str:
     if status == "quarantined":
         return "boost quarantine --release %s to restore" % name
     if status == "upstream-moved":
@@ -274,7 +274,10 @@ def _drift_hint(name: str, status: str) -> str:
     if status == "local-edits":
         return "boost reinstall %s to discard local edits" % name
     if status == "source-missing":
-        return "boost update"
+        # `boost update` only refreshes configured taps. When the entry's
+        # tap has been untapped, that command is a guaranteed no-op — the
+        # only remedy that can actually restore the source is re-tapping it.
+        return "boost update" if registry.is_tapped(tap) else "boost tap %s" % tap
     if status == "store-missing":
         return "boost heal"
     return ""
@@ -758,8 +761,8 @@ def cmd_lint(argv):
                     help="installed skill name(s), or a path to a skill "
                          "directory / its SKILL.md")
     ap.add_argument("--tap", metavar="TAP", help="lint every skill in a tap's clone")
-    ap.add_argument("--min", type=int, default=40, dest="min_score", metavar="N",
-                    help="minimum passing score (default 40)")
+    ap.add_argument("--min", type=util.score_int, default=40, dest="min_score", metavar="N",
+                    help="minimum passing score, 0-100 (default 40)")
     ap.add_argument("--json", action="store_true")
     args = ap.parse_args(argv)
 
@@ -861,7 +864,7 @@ def cmd_drift(argv):
         status = (_drift_status(name, entry) if kind == "skill"
                   else _drift_status_materialized(kind, name, entry))
         rows.append({"name": name, "kind": kind, "status": status,
-                     "hint": _drift_hint(name, status)})
+                     "hint": _drift_hint(name, status, entry.get("tap", ""))})
     if args.json:
         print(json.dumps({"skills": rows}))
         return 0
@@ -1205,7 +1208,7 @@ def cmd_changelog(argv):
         prog="boost changelog",
         description="Show a skill's upstream change history")
     ap.add_argument("name", metavar="NAME")
-    ap.add_argument("-n", type=int, default=20, metavar="N",
+    ap.add_argument("-n", type=util.positive_int, default=20, metavar="N",
                     help="number of entries (default 20)")
     args = ap.parse_args(argv)
 

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/commands/taps.py

@@ -129,7 +129,7 @@ def cmd_tap(argv) -> int:
     p.add_argument("--type", choices=("skill", "rule", "workflow"),
                    help="with --catalog: restrict to one item type")
     p.add_argument("--category", help="with --catalog: restrict to one category")
-    p.add_argument("--limit", type=int, metavar="N",
+    p.add_argument("--limit", type=util.positive_int, metavar="N",
                    help="with --catalog: only the top N registries by est. size")
     p.add_argument("--include-lists", action="store_true",
                    help="with --catalog: also tap awesome-list/index repos")

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/commands/team.py

@@ -9,12 +9,14 @@ import platform
 import shutil
 import stat
 import urllib.parse
+from typing import Any
 
 from .. import cliparse
 from ..core import (
     catalog,
     complete,
     journal,
+    jsonstate,
     lockfile,
     paths,
     registry,
@@ -258,15 +260,20 @@ def cmd_profile(argv) -> int:
         p.error("%s needs a profile NAME" % args.action)
 
     if args.action == "list":
-        profiles = []
+        profiles: list[dict[str, Any]] = []
         for f in sorted(paths.profiles_dir().glob("*.json")):
-            try:
-                data = json.loads(f.read_text(encoding="utf-8"))
-            except (json.JSONDecodeError, OSError):
+            data, _err = jsonstate.read_object(f)
+            if data is None:
+                # Surfaced rather than skipped: a corrupt profile used to be
+                # invisible here yet still block `profile delete` (it parsed
+                # the file again as an existence check) — see `delete` below.
+                profiles.append({"name": f.stem, "skills": None,
+                                 "saved": None, "unreadable": True})
                 continue
             profiles.append({"name": data.get("name", f.stem),
                              "skills": len(data.get("skills", {})),
-                             "saved": data.get("saved", "?")})
+                             "saved": data.get("saved", "?"),
+                             "unreadable": False})
         if args.json:
             print(json.dumps(profiles, indent=2))
             return 0
@@ -274,8 +281,11 @@ def cmd_profile(argv) -> int:
             out.info("no profiles saved")
             out.info(out.role("snapshot the current setup: `boost profile save daily`", "muted"))
             return 0
-        rows = [(pr["name"], str(pr["skills"]), util.rel_time(pr["saved"]))
-                for pr in profiles]
+        rows = [(pr["name"],
+                str(pr["skills"]) if not pr["unreadable"] else "?",
+                util.rel_time(pr["saved"]) if not pr["unreadable"]
+                else out.role("(unreadable)", "danger"))
+               for pr in profiles]
         out.table(rows, headers=("PROFILE", "SKILLS", "SAVED"))
         return 0
 
@@ -347,7 +357,9 @@ def cmd_profile(argv) -> int:
         return 0
 
     if args.action == "delete":
-        _load_profile(args.name)  # existence check
+        if not _profile_path(args.name).exists():
+            raise BoostError("no profile named %s" % args.name,
+                            hint="list profiles with `boost profile list`")
         if not out.confirm("delete profile %s?" % args.name):
             out.info("cancelled")
             return 1

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/core/claude_settings.py

@@ -32,10 +32,11 @@ from __future__ import annotations
 
 import contextlib
 import json
+import sys
 from pathlib import Path
 
 from ..errors import BoostError
-from . import hookhost, paths, util
+from . import hookhost, jsonstate, output, paths, util
 
 SCOPES = ("global", "project")
 MARKER = "# boost:"
@@ -66,27 +67,39 @@ def _history_dir() -> Path:
 
 def load(scope: str, project_dir: Path | None = None,
          host: str = hookhost.CLAUDE) -> dict:
-    """Parse a scope's settings.json ({} if missing or corrupt)."""
+    """Parse a scope's settings.json ({} if missing or corrupt).
+
+    A file that exists but fails to parse is warned about by name: it stays
+    on disk untouched by this read, but `save` treats an empty `{}` as this
+    scope's *whole* settings from here on, so silently swallowing the error
+    is how a hooks-only settings.json used to eat the user's `permissions`
+    and `model` keys on the next `hooks add`.
+    """
     p = settings_path(scope, project_dir, host)
-    if not p.exists():
-        return {}
-    try:
-        data = json.loads(p.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        return {}
-    return data if isinstance(data, dict) else {}
+    data, err = jsonstate.read_object(p)
+    if err:
+        output.warn(
+            "%s — reading as empty; the file is left on disk but the next "
+            "write here replaces its contents (a snapshot lands in %s "
+            "first)" % (err, _history_dir()), stream=sys.stderr)
+    return data if data is not None else {}
 
 
 def save(scope: str, data: dict, project_dir: Path | None = None,
-         host: str = hookhost.CLAUDE) -> None:
+        host: str = hookhost.CLAUDE) -> Path | None:
     """Write a scope's settings.json, snapshotting the prior version first.
 
     Snapshots are named ``<host prefix><scope>-<stamp>.json``. Claude's prefix
     is empty, so its history filenames are exactly what they always were and a
     Gemini write cannot land on top of one.
+
+    Returns the snapshot path, or None when there was no prior file to
+    snapshot — callers that just replaced a scope's settings (`hooks add`)
+    use this to tell the user where the previous version went.
     """
     p = settings_path(scope, project_dir, host)
     p.parent.mkdir(parents=True, exist_ok=True)
+    dest = None
     if p.exists():
         hist = _history_dir()
         hist.mkdir(parents=True, exist_ok=True)
@@ -100,6 +113,7 @@ def save(scope: str, data: dict, project_dir: Path | None = None,
         dest.write_text(p.read_text(encoding="utf-8"), encoding="utf-8")
         _prune_history()
     p.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return dest
 
 
 def _prune_history() -> None:
@@ -135,7 +149,7 @@ def _hook_name(command: str) -> str | None:
 def add_hook(scope: str, event: str, name: str, command: str,
              matcher: str | None = None, timeout: int = 10,
              project_dir: Path | None = None,
-             host: str = hookhost.CLAUDE) -> None:
+             host: str = hookhost.CLAUDE) -> Path | None:
     """Idempotently install a boost-managed hook (replaces same-named entry).
 
     ``timeout`` is in **seconds** whatever the host; ``hookhost.hook_entry``
@@ -143,6 +157,9 @@ def add_hook(scope: str, event: str, name: str, command: str,
     must already be spelled the way ``host`` spells it — translating is the
     command layer's job, because a Claude event with no Gemini counterpart has
     to be refused out loud rather than silently dropped here.
+
+    Returns `save`'s snapshot path (or None) so the caller can tell the user
+    where the pre-edit settings.json went.
     """
     data = load(scope, project_dir, host)
     event_list = data.setdefault("hooks", {}).setdefault(event, [])
@@ -154,7 +171,7 @@ def add_hook(scope: str, event: str, name: str, command: str,
     block["hooks"] = [hookhost.hook_entry(host, _tag(command, name), timeout,
                                           name=name)]
     event_list.append(block)
-    save(scope, data, project_dir, host)
+    return save(scope, data, project_dir, host)
 
 
 def remove_hook(scope: str, event: str, name: str,

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/core/config.py

@@ -4,10 +4,11 @@
 from __future__ import annotations
 
 import json
+import sys
 from copy import deepcopy
 from typing import Any
 
-from . import paths, typedvalue, util
+from . import jsonstate, output, paths, typedvalue, util
 
 DEFAULTS = {
     "agents": {
@@ -201,13 +202,20 @@ def _stat_stamp(p: Any) -> tuple:
     return (str(p), st.st_mtime_ns, st.st_size)
 
 
+def _warn_corrupt(err: str) -> None:
+    output.warn(
+        "%s — reading as empty for this command; the file on disk is left "
+        "untouched, but the next `config set`/`config unset` will move it "
+        "aside to '<name>.corrupt' before writing a fresh one" % err,
+        stream=sys.stderr)
+
+
 def _read() -> dict:
     p = paths.config_path()
-    if not p.exists():
-        return deepcopy(DEFAULTS)
-    try:
-        user = json.loads(p.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
+    user, err = jsonstate.read_object(p)
+    if err:
+        _warn_corrupt(err)
+    if user is None:
         return deepcopy(DEFAULTS)
     return _merge(DEFAULTS, user)
 
@@ -217,16 +225,14 @@ def _read_raw() -> dict:
 
     A missing or corrupt file reads as no overrides — the same "absent" the
     merged view falls back to, so a caller walking this dict never has to
-    special-case the file not existing.
+    special-case the file not existing. Corruption is warned about, not
+    silenced: see :func:`_warn_corrupt`.
     """
     p = paths.config_path()
-    if not p.exists():
-        return {}
-    try:
-        data = json.loads(p.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        return {}
-    return data if isinstance(data, dict) else {}
+    data, err = jsonstate.read_object(p)
+    if err:
+        _warn_corrupt(err)
+    return data if data is not None else {}
 
 
 def _cached() -> dict:
@@ -249,10 +255,21 @@ def load() -> dict:
 
 
 def save(cfg: dict) -> None:
-    """Atomically write `cfg` to `~/.boost/config.json`, creating dirs first."""
+    """Atomically write `cfg` to `~/.boost/config.json`, creating dirs first.
+
+    A config.json that exists but fails to parse is quarantined to
+    `config.json.corrupt` first, so this never overwrites bytes the read path
+    already warned about with a fresh file built from an in-memory view that
+    silently dropped them — see `jsonstate.quarantine`.
+    """
     paths.ensure_dirs()
+    p = paths.config_path()
+    if jsonstate.is_corrupt(p):
+        dest = jsonstate.quarantine(p)
+        output.warn("%s was corrupt and has been moved to %s before writing "
+                     "the new config" % (p, dest), stream=sys.stderr)
     util.atomic_write_text(
-        paths.config_path(), json.dumps(cfg, indent=2, sort_keys=False) + "\n")
+        p, json.dumps(cfg, indent=2, sort_keys=False) + "\n")
 
 
 def get(dotted: str, default=None):

boost_skill_cli-1.2.90/boost_cli/core/jsonstate.py

@@ -0,0 +1,76 @@
+# Copyright the boost contributors.
+# SPDX-License-Identifier: Apache-2.0
+"""Corruption-aware read/quarantine for boost's small JSON state files.
+
+Several files under ``~/.boost`` and each agent's dotdir (``config.json``,
+``settings.json``, ``context.json``, a saved profile, ...) are read as "the
+merged view, or defaults/empty if the file is missing" and then, on the next
+write, replaced outright. Before this module every one of those read sites
+folded "missing" and "exists but fails to parse" into the same branch, so a
+truncated write or a hand-edited trailing comma degraded to an empty object
+with no warning — and the next save then overwrote the corrupt bytes with a
+fresh file built from that empty view, discarding whatever was still sitting
+on disk. :func:`read_object` keeps those two cases apart so a caller can warn
+on the one that means something was actually lost; :func:`quarantine` gives a
+writer a way to get the bad bytes out of the way, rather than over them,
+before it writes the replacement.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def read_object(path: Path) -> tuple[dict | None, str | None]:
+    """Parse `path` as a JSON object.
+
+    Returns ``(data, None)`` when the file is missing (``data`` is ``None``)
+    or holds a valid JSON object. Returns ``(None, message)`` when the file
+    exists but can't be read as one — unreadable, invalid JSON, or valid JSON
+    that isn't an object — where ``message`` names the file and the
+    underlying error so a caller can warn instead of quietly treating
+    corruption the same as "nothing here yet".
+    """
+    if not path.exists():
+        return None, None
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        return None, "%s: %s" % (path, exc)
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError as exc:
+        return None, "%s: invalid JSON (%s)" % (path, exc)
+    if not isinstance(data, dict):
+        return None, "%s: expected a JSON object, found %s" % (
+            path, type(data).__name__)
+    return data, None
+
+
+def is_corrupt(path: Path) -> bool:
+    """True when `path` exists but :func:`read_object` can't parse it.
+
+    A missing file is not corrupt — callers that only care about "is there a
+    bad file sitting here" (rather than the error text) use this instead of
+    unpacking the tuple.
+    """
+    _, err = read_object(path)
+    return err is not None
+
+
+def quarantine(path: Path) -> Path:
+    """Move a corrupt `path` aside so a fresh write can land on its name
+    without destroying the bad bytes underneath it.
+
+    Picks `<name>.corrupt`, or `<name>.corrupt.N` for the first `N >= 2` that
+    doesn't already exist, so repeated corruption never overwrites an earlier
+    quarantined copy. Returns the destination. Caller's job to have already
+    established `path` is worth quarantining; this itself doesn't parse it.
+    """
+    dest = path.with_name(path.name + ".corrupt")
+    n = 2
+    while dest.exists():
+        dest = path.with_name("%s.corrupt.%d" % (path.name, n))
+        n += 1
+    path.rename(dest)
+    return dest

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/core/registry.py

@@ -182,6 +182,18 @@ def get(name: str) -> Tap:
                     else "list taps with `boost taps`")
 
 
+def is_tapped(name: str) -> bool:
+    """True if `name` is a currently configured tap's exact ``Tap.name``.
+
+    Exact match only, unlike ``get()``'s shorthand/ambiguity tiering: a lock
+    entry's ``tap`` field always records the full ``owner/repo`` name a skill
+    was installed from, so callers checking "is this entry's tap still
+    tapped?" want a plain membership test, not a fuzzy lookup that could
+    raise on an unrelated ambiguous shorthand.
+    """
+    return any(t.name == name for t in list_taps())
+
+
 def add(spec: str, curated: bool = False, at: str | None = None) -> Tap:
     """Parse `spec`, shallow-clone it, and record the tap in config.
 

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/core/store.py

@@ -1250,6 +1250,23 @@ def install_from_path(src_dir: Path, name: str | None = None,
     return res
 
 
+def existing_skill_owner(name: str) -> str | None:
+    """Tap label of the skill already installed as ``name``, else None.
+
+    For the generated-install paths (``create``/``distill``/``infer``/``absorb``
+    ``--install``) to warn before silently replacing an *unpinned* install and
+    flipping its lock provenance to ``local`` — the loss ``list`` would
+    otherwise never show. ``install_from_path``'s own gate only refuses a
+    *pinned* name (its docstring: that refusal is deliberately not extended to
+    the unpinned case, since this is also the re-import path for ``boost
+    import`` / ``boost reinstall``). Callers that generate a brand-new skill,
+    rather than re-importing an existing one, use this to catch that gap
+    themselves.
+    """
+    existing = lockfile.get_skill(name)
+    return existing.get("tap") if existing else None
+
+
 def uninstall(name: str) -> dict:
     """Uninstall ``name`` whatever its kind (skill, rule, workflow).
 

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90}/boost_cli/core/util.py

@@ -167,6 +167,25 @@ def positive_int(s: str) -> int:
     return v
 
 
+def score_int(s: str) -> int:
+    """argparse ``type=`` for ``lint --min``: an int in [0, 100].
+
+    Scores are capped at 100 (``score_skill``), so a bare ``type=int`` let
+    ``--min 500`` through and failed every skill, and a negative ``--min``
+    passed every skill silently rather than being rejected as meaningless.
+    Unlike :func:`positive_int`, 0 is a legitimate value here — "fail nobody".
+    """
+    import argparse
+
+    try:
+        v = int(s)
+    except (TypeError, ValueError):
+        raise argparse.ArgumentTypeError("invalid int value: %r" % s) from None
+    if not 0 <= v <= 100:
+        raise argparse.ArgumentTypeError("must be between 0 and 100")
+    return v
+
+
 def now_iso() -> str:
     """Return UTC now as ``'2026-07-16T01:00:00Z'`` (what ``rel_time`` parses)."""
     return datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")

{boost_skill_cli-1.2.88 → boost_skill_cli-1.2.90/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.88
+Version: 1.2.90
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0