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

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

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

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

{boost_skill_cli-1.2.86 → boost_skill_cli-1.2.88}/boost_cli/commands/_common.py

@@ -8,6 +8,9 @@ place lets the modules split without either importing back into the other.
 """
 from __future__ import annotations
 
+import difflib
+from itertools import chain
+
 from ..core import lockfile, store
 from ..errors import BoostError
 
@@ -17,6 +20,28 @@ def _s(n: int) -> str:
     return "" if n == 1 else "s"
 
 
+def _not_installed_hint(missing: list[str], candidates: list[str]) -> str:
+    """The "see what is with `boost list`" hint, fronted by a close-match guess.
+
+    A typo one character off an installed name (``lint brainstormin`` with
+    only ``brainstorming`` installed) used to get the same bare hint as
+    genuinely nonsense input — the fixed pointer to ``boost list`` says
+    nothing a fuzzy match could have said directly. Checked against every
+    missing name so a multi-name call still surfaces a guess for the one that
+    has one, and deduplicated in case two misses guess the same candidate.
+    """
+    names = sorted(set(candidates))
+    close: list[str] = []
+    for n in missing:
+        for c in difflib.get_close_matches(n, names, n=3):
+            if c not in close:
+                close.append(c)
+    if not close:
+        return "see what is with `boost list`"
+    return ("closest matches: %s — see what is with `boost list`"
+            % ", ".join(close))
+
+
 def _require_lock_integrity() -> None:
     """Fail loudly, before iterating, if the lock file itself is broken.
 
@@ -71,8 +96,9 @@ def _iter_installed(names: list[str] | None = None) -> list[tuple[str, dict]]:
                 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`")
+            raise BoostError(
+                "not installed: %s" % ", ".join(missing),
+                hint=_not_installed_hint(missing, list(skills)))
         return [(n, skills[n]) for n in names]
     return sorted(skills.items())
 
@@ -100,8 +126,10 @@ def _iter_installed_all(
             else:
                 out.append((found[0], n, found[1]))
         if missing:
-            raise BoostError("not installed: %s" % ", ".join(missing),
-                            hint="see what is with `boost list`")
+            all_names = chain.from_iterable(lockfile.all_installed().values())
+            raise BoostError(
+                "not installed: %s" % ", ".join(missing),
+                hint=_not_installed_hint(missing, list(all_names)))
         return out
     return [(kind, n, e)
             for kind, section in lockfile.all_installed().items()

{boost_skill_cli-1.2.86 → boost_skill_cli-1.2.88}/boost_cli/commands/discovery.py

@@ -170,7 +170,7 @@ def cmd_search(argv):
             if reranked:
                 scored, ranker = reranked, "Claude Haiku relevance"
         else:
-            out.warn(ai.fallback_note(), wrap=True)
+            out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
     shown = scored[:args.limit]
     # The dot marks "a skill by this name is installed" — a name match, with
     # the known homonym caveat (13 real skills share `code-reviewer`). A lock

{boost_skill_cli-1.2.86 → boost_skill_cli-1.2.88}/boost_cli/commands/info.py

@@ -725,9 +725,10 @@ def cmd_explain(argv):
             # it and fall through to the grounded extractive summary below.
             out.warn("AI explanation looked ungrounded (%s) — showing the "
                      "extractive summary instead"
-                     % ", ".join(faithfulness.ungrounded_terms(reply, text)[:4]))
+                     % ", ".join(faithfulness.ungrounded_terms(reply, text)[:4]),
+                     stream=sys.stderr)
     else:
-        out.warn(ai.fallback_note(), wrap=True)
+        out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
     meta, body = frontmatter.parse(text)
     desc = str(meta.get("description") or "").strip()
     if desc:

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

@@ -14,6 +14,7 @@ import difflib
 import fnmatch
 import json
 import re
+import sys
 import tempfile
 import textwrap
 from collections import Counter
@@ -46,10 +47,16 @@ _warned_fallback = False
 
 
 def _note_fallback() -> None:
-    """Warn once per invocation that the AI path is unavailable."""
+    """Warn once per invocation that the AI path is unavailable.
+
+    Routed to stderr: `infer`/`absorb` write generated SKILL.md content to
+    stdout when neither `--install` nor `-o` is given, and this note used to
+    print as stdout's first line — `boost infer > SKILL.md` wrote a file
+    whose body opened with the warning instead of the frontmatter.
+    """
     global _warned_fallback
     if not _warned_fallback:
-        out.warn(ai.fallback_note(), wrap=True)
+        out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
         _warned_fallback = True
 
 
@@ -139,11 +146,7 @@ def _write_generated(dest: Path, text: str) -> bool:
 
 def _current_branch(cwd: Path | None = None) -> str | None:
     """Current git branch of cwd, or None when not in a repo / no git."""
-    if not gitutil.has_git():
-        return None
-    proc = gitutil.run(["rev-parse", "--abbrev-ref", "HEAD"],
-                       cwd=cwd or Path.cwd(), check=False)
-    return proc.stdout.strip() if proc.returncode == 0 else None
+    return gitutil.branch_state(cwd).branch
 
 
 # ---------------------------------------------------------------- distill
@@ -588,10 +591,14 @@ def cmd_absorb(argv: list[str]) -> int:
         return 0
 
     name = "absorbed-patterns"
-    out.heading("recurring patterns from %d history file(s)" % len(files))
+    # Without --install, stdout carries the generated SKILL.md (`boost absorb
+    # > SKILL.md`), so this report must not land ahead of it there.
+    report_stream = None if args.install else sys.stderr
+    out.heading("recurring patterns from %d history file(s)" % len(files),
+                stream=report_stream)
     out.table([(p, "%dx" % n) for p, n in patterns],
-              headers=("PATTERN", "SEEN"))
-    print()
+              headers=("PATTERN", "SEEN"), stream=report_stream)
+    print(file=report_stream)
 
     text = _absorb_ai(name, patterns) if ai.available() else None
     if text is None:
@@ -883,7 +890,8 @@ def cmd_context(argv: list[str]) -> int:
         return 0
     # apply
     if not state.get("enabled"):
-        out.warn("context is disabled (`boost context enable`) — applying anyway")
+        out.warn("context is disabled (`boost context enable`) — applying anyway",
+                 stream=sys.stderr)
     return _context_apply(state)
 
 
@@ -892,14 +900,19 @@ def _mentioned_skills(state: dict) -> set:
 
 
 def _context_status(state: dict, as_json: bool) -> int:
-    branch = _current_branch()
+    git = gitutil.branch_state()
+    branch = git.branch
     if as_json:
         print(json.dumps({"enabled": bool(state.get("enabled")),
-                          "branch": branch, "rules": state.get("rules", [])}))
+                          "branch": branch, "git": git.has_git,
+                          "rules": state.get("rules", [])}))
         return 0
     out.heading("branch-aware skill activation")
     out.kv("enabled", "yes" if state.get("enabled") else "no")
-    out.kv("branch", branch or "(not in a git repository)")
+    if not git.has_git:
+        out.kv("branch", "(git not found on PATH)")
+    else:
+        out.kv("branch", branch or "(not in a git repository)")
     rules = state.get("rules", [])
     if not rules:
         out.info("no rules — add one with `boost context map 'feature/*' "
@@ -913,9 +926,11 @@ def _context_status(state: dict, as_json: bool) -> int:
 
 
 def _context_apply(state: dict) -> int:
-    branch = _current_branch()
+    git = gitutil.branch_state()
+    branch = git.branch
     if branch is None:
-        out.info("not inside a git repository — nothing to apply")
+        out.info("git not found on PATH — nothing to apply" if not git.has_git
+                 else "not inside a git repository — nothing to apply")
         return 0
     rules = state.get("rules", [])
     matched = [r for r in rules if fnmatch.fnmatch(branch, r.get("pattern", ""))]
@@ -1052,6 +1067,10 @@ def cmd_impact(argv: list[str]) -> int:
     ap.add_argument("--json", action="store_true")
     args = ap.parse_args(argv)
 
+    git = gitutil.branch_state()
+    in_repo = git.in_repo
+    note = _IMPACT_NOTE if in_repo else _IMPACT_NOTE_NO_REPO
+
     inst = lockfile.installed()
     if args.name:
         if args.name not in inst:
@@ -1069,17 +1088,11 @@ def cmd_impact(argv: list[str]) -> int:
         names = sorted(inst)
         if not names:
             if args.json:
-                print(json.dumps({"note": _IMPACT_NOTE, "skills": []}))
+                print(json.dumps({"note": note, "git": git.has_git, "skills": []}))
             else:
                 out.info("no skills installed — nothing to measure")
             return 0
 
-    in_repo = False
-    if gitutil.has_git():
-        proc = gitutil.run(["rev-parse", "--is-inside-work-tree"],
-                           cwd=Path.cwd(), check=False)
-        in_repo = proc.returncode == 0 and proc.stdout.strip() == "true"
-
     rows, data = [], []
     for name in names:
         entry = inst[name]
@@ -1093,7 +1106,7 @@ def cmd_impact(argv: list[str]) -> int:
                      "events": events})
 
     if args.json:
-        print(json.dumps({"note": _IMPACT_NOTE, "skills": data}))
+        print(json.dumps({"note": note, "git": git.has_git, "skills": data}))
         return 0
     out.heading("impact" + ((" of %s" % args.name) if args.name else ""))
     out.table(rows, headers=("SKILL", "INSTALLED", "COMMITS SINCE", "EVENTS"))
@@ -1111,11 +1124,12 @@ def cmd_impact(argv: list[str]) -> int:
                 print(textwrap.indent(textwrap.fill(reply, width=76), "  "))
         else:
             _note_fallback()
-    out.dim("  " + _IMPACT_NOTE)
+    out.dim("  " + note)
     return 0
 
 
 _IMPACT_NOTE = "correlation, not causation — commits since install in this repo"
+_IMPACT_NOTE_NO_REPO = "not inside a git repository — commit counts unavailable"
 
 
 def _repo_activity(since: str) -> tuple[int | None, int | None]:

{boost_skill_cli-1.2.86 → boost_skill_cli-1.2.88}/boost_cli/commands/pkg.py

@@ -410,14 +410,7 @@ def cmd_install(argv: list[str]) -> int:
         multi = multi or len(entries) > 1
 
     if args.dry_run:
-        # TWO lists, because the three kinds do not reach the same agents.
-        # Rules and workflows materialize into every enabled agent's dotdir,
-        # Gemini included. A skill is symlinked only into the agents that take
-        # links — Gemini reads the canonical store directly and is deliberately
-        # never linked (see agents.linking_agents). One list for both is how
-        # `--dry-run` came to promise a `~/.gemini/skills` symlink that the real
-        # install has never created.
-        targets = [a for a in agents.enabled_agents() if not only or a in only]
+        from ..core import mcpdecl, mcphost
         link_targets = [a for a in agents.linking_agents()
                         if not only or a in only]
         native_targets = [a for a in agents.native_store_agents()
@@ -427,17 +420,36 @@ def cmd_install(argv: list[str]) -> int:
             raise BoostError(
                 "there is no project here to install into",
                 hint="cd into a repo, or drop --local to install for your user")
+        # materializing_agents(base), not enabled_agents(): a rule/workflow
+        # only reaches an agent whose file format is known (agents.py), and at
+        # project scope the *repo-local* dotdirs (agents_for_scope's project
+        # branch), not the user config every other scope writes into.
+        mbase = pbase if args.scope == scopes.SCOPE_PROJECT else None
+        mat_targets = [a for a in agents.materializing_agents(mbase)
+                       if not only or a in only]
+        offer_mcp = not args.no_mcp and not os.environ.get("BOOST_NO_MCP_OFFER")
+        mcp_hosts = [h for h in mcphost.hosts() if shutil.which(mcphost.cli(h))] \
+            or mcphost.hosts()
         for e in entries:
             if args.scope == scopes.SCOPE_PROJECT and e.get("kind", "skill") == "skill":
                 seen = projectlock.get_skill(pbase, e["name"])
                 out.info("would %s %s v%s from %s into %s"
                          % ("reinstall" if seen else "install", e["name"],
                             e["version"], e["tap"], _tilde(pbase)))
-                for agent_name, sdir in agents.enabled_agents().items():
+                # agents_for_scope(pbase), not enabled_agents(): project scope
+                # copies into each agent's *repo-local* dotdir, which excludes
+                # Antigravity CLI (its layout is two levels under ~/.gemini and
+                # has no known project-local path — see agents.project_agents).
+                for agent_name, sdir in agents.agents_for_scope(pbase).items():
                     if only and agent_name not in only:
                         continue
                     out.info("  copy  → %s"
                              % _tilde(scopes.skill_target(sdir, e["name"], base=pbase)))
+                if offer_mcp:
+                    for row in mcpdecl.registrable(
+                            store.declared_mcp_servers(store.source_dir_for(e))):
+                        out.info("  mcp   → record %s in %s"
+                                 % (row["name"], mcpdecl.SIDECAR))
                 continue
             if e.get("kind") in ("rule", "workflow"):
                 k = e["kind"]
@@ -450,7 +462,7 @@ def cmd_install(argv: list[str]) -> int:
                 out.info("would %s %s %s v%s from %s (%s)" % (verb, k, e["name"],
                                                               e["version"], e["tap"],
                                                               where))
-                out.info("  materialize → %s" % (" · ".join(targets)
+                out.info("  materialize → %s" % (" · ".join(mat_targets)
                                                  or "(no enabled agents)"))
                 continue
             verb = "upgrade" if lockfile.get_skill(e["name"]) else "install"
@@ -466,6 +478,12 @@ def cmd_install(argv: list[str]) -> int:
                 out.info("  available to %s (reads the store directly)"
                          % " · ".join(agents.display_name(a)
                                       for a in native_targets))
+            if offer_mcp:
+                for row in mcpdecl.registrable(
+                        store.declared_mcp_servers(store.source_dir_for(e))):
+                    out.info("  mcp   → offer to register %s with %s"
+                             % (row["name"], " · ".join(mcphost.label(h)
+                                                        for h in mcp_hosts)))
         out.info("dry run — nothing was changed")
         return 1 if failed else 0
 
@@ -1412,6 +1430,8 @@ def _import_root(root: Path, name: str | None, do_all: bool,
                 continue
             out.ok("imported %s v%s (score %d/100)" % (res.name, e["version"],
                                                        res.score))
+            _warn_injection(res)
+            _warn_secrets(res)
             imported += 1
         out.info("Imported %s" % _plural(imported, "skill"))
         return 1 if refused else 0
@@ -1652,6 +1672,8 @@ def cmd_export(argv: list[str]) -> int:
     ap.add_argument("-o", "--out", metavar="OUT", help="output archive path")
     ap.add_argument("--zip", action="store_true",
                     help="build a .zip instead of .tar.gz")
+    ap.add_argument("--force", action="store_true",
+                    help="overwrite OUT if it already exists")
     args = ap.parse_args(argv)
     installed = lockfile.installed()
     names = args.names or sorted(installed)
@@ -1683,6 +1705,10 @@ def cmd_export(argv: list[str]) -> int:
     ext = ".zip" if args.zip else ".tar.gz"
     dest = paths.expand(args.out) if args.out else Path(
         "boost-skills-%s%s" % (stamp, ext))
+    if dest.exists() and not args.force:
+        raise BoostError("%s already exists" % _tilde(dest),
+                        hint="pass --force to overwrite, or choose a "
+                             "different -o path")
     manifest = _boostfile_text(chosen, via="boost export")
     try:
         if args.zip:

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

@@ -13,6 +13,7 @@ import hashlib
 import json
 import os
 import re
+import sys
 from contextlib import suppress
 from datetime import UTC, datetime, timedelta
 from itertools import starmap
@@ -286,23 +287,42 @@ def _parse_ts(iso: str) -> datetime | None:
         return None
 
 
-def _fingerprint() -> tuple[str, list[str]]:
-    """(sha256 hexdigest, component lines). Deterministic: the same lock file
-    and tap commits always produce the same hash."""
-    comps = sorted("%s:%s" % (n, e.get("sha256", ""))
+def _q_suffix(e: dict) -> str:
+    # Quarantine de-arms a component (a poisoned rule stops being materialized,
+    # a skill's links are removed) without deleting its lock entry, so the
+    # digest must move too or a quarantined-then-released environment reads
+    # as unchanged. Suffixed rather than dropped: dropping the line would make
+    # quarantine indistinguishable from uninstall.
+    return ":q" if e.get("quarantined") else ""
+
+
+def _fingerprint() -> tuple[str, list[str], list[str]]:
+    """(sha256 hexdigest, component lines, uncloned tap names).
+
+    Deterministic: the same lock file and tap commits always produce the same
+    hash. An uncloned tap hashes as an empty commit rather than being skipped
+    silently — its name is returned separately so callers can say the digest
+    is incomplete instead of passing it off as a real measurement."""
+    comps = sorted("%s:%s%s" % (n, e.get("sha256", ""), _q_suffix(e))
                    for n, e in lockfile.installed().items())
     # Rules and workflows are part of the environment the agent runs on —
     # a poisoned CLAUDE.md rule must change the fingerprint. Kind-prefixed so
     # a skill-only environment's fingerprint is unchanged by this addition.
-    comps += sorted("%s/%s:%s" % (kind, n, e.get("sha256", ""))
+    comps += sorted("%s/%s:%s%s" % (kind, n, e.get("sha256", ""), _q_suffix(e))
                     for kind, section in lockfile.all_installed().items()
                     if kind != "skill" for n, e in section.items())
-    comps += sorted("%s:%s" % (t.name,
-                               gitutil.head_commit(t.path)
-                               if t.is_cloned and gitutil.has_git() else "")
-                    for t in registry.list_taps())
+    uncloned = []
+    tap_lines = []
+    for t in registry.list_taps():
+        if t.is_cloned and gitutil.has_git():
+            commit = gitutil.head_commit(t.path)
+        else:
+            commit = ""
+            uncloned.append(t.name)
+        tap_lines.append("%s:%s" % (t.name, commit))
+    comps += sorted(tap_lines)
     digest = hashlib.sha256("\n".join(comps).encode()).hexdigest()
-    return digest, comps
+    return digest, comps, sorted(uncloned)
 
 
 def _norm_token(tok: str) -> str:
@@ -906,10 +926,10 @@ def cmd_fingerprint(argv):
     ap.add_argument("--json", action="store_true")
     args = ap.parse_args(argv)
 
-    digest, comps = _fingerprint()
+    digest, comps, incomplete = _fingerprint()
     if args.json:
         print(json.dumps({"fingerprint": digest, "short": digest[:16],
-                          "components": comps}))
+                          "components": comps, "incomplete": incomplete}))
         return 0
     out.heading("environment fingerprint")
     print("  " + out.role(digest[:16], "accent", bold=True)
@@ -917,6 +937,9 @@ def cmd_fingerprint(argv):
     if args.verbose:
         out.table([tuple(line.split(":", 1)) for line in comps],
                   headers=("COMPONENT", "DIGEST/COMMIT"))
+    for name in incomplete:
+        out.warn("tap %s not cloned — fingerprint incomplete (boost update)"
+                 % name, stream=sys.stderr)
     return 0
 
 

{boost_skill_cli-1.2.86 → boost_skill_cli-1.2.88}/boost_cli/commands/safety.py

@@ -14,6 +14,7 @@ import json
 import re
 import time
 from contextlib import suppress
+from itertools import chain
 from pathlib import Path
 from typing import Any
 
@@ -39,6 +40,7 @@ from ..errors import BoostError
 from ._common import (
     _iter_installed,
     _iter_installed_all,
+    _not_installed_hint,
     _require_lock_integrity,
     _s,
     _shadowed_kinds,
@@ -357,8 +359,10 @@ def cmd_verify(argv):
         unknown = [n for n in args.names
                    if lockfile.find_any(n) is None and n not in pskills]
         if unknown:
+            candidates = list(chain.from_iterable(
+                lockfile.all_installed().values())) + list(pskills)
             raise BoostError("not installed: %s" % ", ".join(unknown),
-                            hint="see what is with `boost list`")
+                            hint=_not_installed_hint(unknown, candidates))
     user_names = [n for n in (args.names or [])
                   if lockfile.find_any(n) is not None]
 

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

@@ -98,14 +98,27 @@ def cmd_cohort(argv) -> int:
         for s in skills:
             if not catalog.find(s):
                 out.warn("skill %r not found in any tap (kept anyway)" % s)
-        cohorts[args.name] = {"skills": skills, "percent": args.percent,
-                              "created": util.now_iso(), "creator": user}
+        existing = cohorts.get(args.name)
+        cohorts[args.name] = {
+            "skills": skills, "percent": args.percent,
+            # A second `create` over an existing cohort is a replacement, not
+            # a new cohort — preserving `created` is what makes the "updated"
+            # wording below honest instead of resetting a rollout's history.
+            "created": existing["created"] if existing else util.now_iso(),
+            "creator": user}
         _save_cohorts(cohorts)
         journal.log("cohort", args.name, op="create", percent=args.percent)
         member = _is_member(user, args.name, args.percent)
-        out.ok("created cohort %s (%d%% rollout, %d skill%s) — you are %s"
-               % (args.name, args.percent, len(skills), _s(len(skills)),
-                  "IN" if member else "OUT"))
+        if existing:
+            out.ok("updated cohort %s (was %d%% / %d skill%s) — now %d%% "
+                   "rollout, %d skill%s — you are %s"
+                   % (args.name, existing["percent"], len(existing["skills"]),
+                      _s(len(existing["skills"])), args.percent, len(skills),
+                      _s(len(skills)), "IN" if member else "OUT"))
+        else:
+            out.ok("created cohort %s (%d%% rollout, %d skill%s) — you are %s"
+                   % (args.name, args.percent, len(skills), _s(len(skills)),
+                      "IN" if member else "OUT"))
         return 0
 
     if args.action == "delete":
@@ -268,6 +281,12 @@ def cmd_profile(argv) -> int:
 
     if args.action == "save":
         installed = lockfile.installed()
+        was = None
+        if _profile_path(args.name).exists():
+            try:
+                was = len(_load_profile(args.name).get("skills", {}))
+            except BoostError:
+                was = None   # unreadable old profile: still fine to replace
         profile = {"name": args.name, "saved": util.now_iso(), "user": util.user(),
                    "skills": {n: {"tap": e.get("tap", "local"),
                                   "version": e.get("version", "0.0.0")}
@@ -275,8 +294,12 @@ def cmd_profile(argv) -> int:
         paths.ensure_dirs()
         _profile_path(args.name).write_text(json.dumps(profile, indent=2) + "\n", encoding="utf-8")
         journal.log("profile", args.name, op="save", skills=len(installed))
-        out.ok("saved profile %s (%d skill%s)"
-               % (args.name, len(installed), _s(len(installed))))
+        if was is not None:
+            out.ok("updated profile %s (was %d skill%s, now %d skill%s)"
+                   % (args.name, was, _s(was), len(installed), _s(len(installed))))
+        else:
+            out.ok("saved profile %s (%d skill%s)"
+                   % (args.name, len(installed), _s(len(installed))))
         n_rules = len(lockfile.installed_rules())
         n_workflows = len(lockfile.installed_workflows())
         if n_rules or n_workflows:

{boost_skill_cli-1.2.86 → boost_skill_cli-1.2.88}/boost_cli/core/catalog.py

@@ -19,6 +19,7 @@ that ship in the same GitHub registries:
 """
 from __future__ import annotations
 
+import difflib
 import hashlib
 import json
 import operator
@@ -573,6 +574,22 @@ def _suggestions(scored, limit: int = 3) -> list[str]:
     return labels
 
 
+def _fuzzy_suggestions(query: str, entries: list[dict], limit: int = 3) -> list[str]:
+    """Edit-distance fallback for a miss ``search`` scored nothing for.
+
+    ``search`` needs a shared token or substring, so a one-character typo like
+    'brainstormng' for 'brainstorming' shares no aligned substring with it and
+    scores zero — the near-miss gets no hint while unrelated nonsense that
+    happens to share a token gets three. ``difflib`` grades whole-string
+    similarity instead, so it catches exactly the case token/substring scoring
+    misses. Names only, not the tap-qualifying dance ``_suggestions`` does for
+    scored hits: a query this close to nothing never produced a match to
+    qualify in the first place.
+    """
+    names = sorted({e["name"] for e in entries})
+    return difflib.get_close_matches(query, names, n=limit)
+
+
 def resolve_one(name: str, path: str | None = None) -> dict:
     """Find exactly one entry or raise with a helpful hint.
 
@@ -612,15 +629,41 @@ def resolve_one(name: str, path: str | None = None) -> dict:
                 hint="`tap:skill` picks the registry; to pick a copy inside "
                      "one, use --path: `boost install %s:%s --path %s`"
                      % (qualifier, bare.rsplit("/", 1)[-1], bare))
+        # A qualified miss searches the BARE name, restricted to the taps the
+        # qualifier actually selects — never the whole `tap:skill` string.
+        # Scoring the full string lets the tap's own tokens dominate (a typo'd
+        # `neolabhq/context-engineering-kit:brainstorm` scored on "context"
+        # and "engineering", never "brainstorm", which that tap ships) and,
+        # when the qualifier itself is wrong, misreports a missing *skill*
+        # instead of naming the tap that does not exist.
+        query, search_entries = name, None
+        if qualifier is not None:
+            known = [t.name for t in registry.list_taps()
+                     if tap_matches(t.name, qualifier)]
+            if not known:
+                shipped_by = sorted({e["tap"] for e in all_entries()
+                                     if e["name"] == bare})
+                raise BoostError(
+                    "no tap named %r" % qualifier,
+                    hint=("%r is shipped by: %s" % (bare, ", ".join(shipped_by))
+                          if shipped_by else None))
+            query = bare
+            search_entries = [e for e in all_entries() if e["tap"] in known]
         # The whole scored list, not a pre-sliced top 3 — see _suggestions:
         # slicing first collapses to one suggestion exactly when a registry
         # mirrors a skill per agent, which is the case it exists to handle.
-        scored = search(name)
+        scored = search(query, entries=search_entries)
         hint = None
         if scored:
             hint = "closest matches: " + ", ".join(_suggestions(scored))
-        elif not registry.list_taps():
-            hint = "no taps configured — start with `boost tap --defaults`"
+        else:
+            fuzzy = _fuzzy_suggestions(
+                query, search_entries if search_entries is not None
+                else all_entries())
+            if fuzzy:
+                hint = "closest matches: " + ", ".join(fuzzy)
+            elif not registry.list_taps():
+                hint = "no taps configured — start with `boost tap --defaults`"
         raise BoostError("no skill named %r in any tap" % name, hint=hint)
     if len(matches) > 1:
         # `name` may already be tap-qualified; hints must re-qualify the BARE