boost-skill-cli 1.2.199__tar.gz → 1.2.201__tar.gz

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/PKG-INFO

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

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/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.199'
-__version_tuple__ = version_tuple = (1, 2, 199)
+__version__ = version = '1.2.201'
+__version_tuple__ = version_tuple = (1, 2, 201)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/boost_cli/cli.py

@@ -307,7 +307,8 @@ def _complete_candidates(argv: list[str]) -> int:
     errors and a traceback here would land in the line the user is typing.
     """
     from .core import complete
-    for candidate in complete.candidates(argv.copy(), COMMANDS):
+    for candidate in complete.candidates(argv.copy(), COMMANDS,
+                                         frozenset(_GLOBAL_FLAGS)):
         print(candidate)
     return 0
 
@@ -368,6 +369,10 @@ def _seal_broken_stdout() -> None:
 def _route(argv: list[str]) -> int:
     try:
         if not argv or argv[0] in ("-h", "--help"):
+            # `boost --help install` is `boost help install`, as in git and
+            # brew — it used to print the index and drop the command unsaid.
+            if len(argv) > 1:
+                return print_command_help(argv[1])
             print_help()
             return 0
         if argv[0] in ("-V", "--version", "version"):

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/boost_cli/commands/bmad.py

@@ -163,9 +163,26 @@ def _on_off(value) -> str:
     return "on" if value else "off"
 
 
+def _project_root() -> Path:
+    """The directory project-scope personas, hooks and state all belong to.
+
+    The same root ``cs.settings_path("project")`` writes hooks under: the
+    enclosing repo when there is one. Personas and state used to follow the
+    raw cwd while hooks followed the repo root, so ``bmad on --scope project``
+    from ``src/deep`` split one install across two directories and ``doctor``
+    at the root and in the subdirectory disagreed about it. The cwd fallback
+    only answers in ``$HOME``, where a project write refuses anyway.
+
+    BMAD's skills and ``_bmad/`` are not routed here: ``npx bmad-method
+    install`` lays them out under the cwd it is given, and ``_skills_dir``
+    has to look where the installer put them.
+    """
+    return cs.project_base() or Path.cwd()
+
+
 def _agents_dir(scope) -> Path:
     """Where Claude Code reads subagent definitions for a scope."""
-    base = paths.home() if scope == "global" else Path.cwd()
+    base = paths.home() if scope == "global" else _project_root()
     return base / ".claude" / "agents"
 
 
@@ -219,6 +236,12 @@ def _hook_hosts(scope: str, requested=None, force: bool = False) -> list[str]:
     `on` installs two hooks, and a host list that decided itself twice said
     "skipping Codex CLI" twice for one decision.
     """
+    # A path computation that refuses project scope with no project, asked
+    # for Claude because every branch below writes somewhere: the other hosts
+    # are only probed when they are candidates, and an explicit `--host`
+    # never probed at all, so `on --scope project` from $HOME wrote personas
+    # into ~/.claude/agents before `add_hook` refused.
+    cs.settings_path(scope, host=hookhost.CLAUDE)
     if requested not in (None, "auto"):
         cs.refuse_escape(scope, str(requested), force=force)
         return [str(requested)]
@@ -845,7 +868,7 @@ def _doctor() -> int:
                % (_on_off(live), personas, _where(router_hosts), briefing))
         out.kv("  workflows", "skills=%d  installed=%s"
                % (_count_skills(_skills_dir(scope)), _on_off(st.get("installed"))))
-    out.dim("  project = %s" % Path.cwd())
+    out.dim("  project = %s" % _project_root())
     if not any(_get_scope_state(s).get("autopilot") for s in ("global", "project")):
         out.dim("  turn it on with `boost bmad on`", wrap=True)
     return 0
@@ -969,7 +992,7 @@ def _sessions_write(sessions: dict) -> None:
 
 
 def _proj_key(project=None) -> str:
-    return str(Path(project or Path.cwd()).resolve())
+    return str(Path(project or _project_root()).resolve())
 
 
 def _get_scope_state(scope, project=None) -> dict:

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/boost_cli/commands/configuration.py

@@ -130,6 +130,10 @@ def cmd_config(argv) -> int:
                                  "`boost config unset` it first") from e
         val = config.get(args.key)
         journal.log("config", args.key, op="set")
+        # stderr: the write stands either way, and `--json` keeps its stdout.
+        warning = config.unknown_key_warning(args.key)
+        if warning:
+            out.warn(warning, stream=sys.stderr, wrap=True)
         if args.json:
             print(json.dumps({"key": args.key, "value": val}))
             return 0
@@ -523,10 +527,12 @@ def cmd_create(argv) -> int:
                    help="install the new skill immediately")
     args = p.parse_args(argv)
 
-    name = util.resolve_slug(args.name)
+    name = util.resolve_slug(args.name, what="skill name")
     parent = paths.expand(args.dir) if args.dir else Path.cwd()
     target = parent / name
-    skill_md = target / "SKILL.md"
+    # The name was checked by resolve_slug; this is for a --dir whose own
+    # components are too long, which `exists()` would raise on.
+    skill_md = util.check_path_length(target / "SKILL.md", what="--dir path")
     if skill_md.exists():
         raise BoostError("%s already exists" % _tilde(skill_md),
                         hint="pick another name or --dir, or edit the existing file")
@@ -1678,10 +1684,17 @@ def _tool_doctor(args: dict):
                 "`boost replay` restores the lock that knows whose they are"
                 % (n, "" if n == 1 else "s", ", ".join(names))]
 
+    # Right after `boost replay rollback` over a corrupt lock, an unrecorded
+    # store dir may be what the lock's last change installed, so `boost sync`
+    # adopting it as `local` is the wrong fix (lockfile.unrestored_corrupt).
+    backup = (lockfile.unrestored_corrupt() if plan.get("adoptable_store")
+              else None)
     worded = {
-        "adoptable_store": lambda names: [
-            "%s was added outside boost — `boost sync` records it as a local "
-            "skill and links it" % n for n in names],
+        "adoptable_store": lambda names: (
+            [lockfile.unrestored_line(len(names), ", ".join(names), backup)]
+            if backup else
+            ["%s was added outside boost — `boost sync` records it as a local "
+             "skill and links it" % n for n in names]),
         "unreadable_store": lambda rows: [store.unreadable_line(rows)],
         "foreign_store": store.foreign_store_lines,
         "plugin_duplicates": lambda rows: (store.plugin_duplicate_lines(rows)
@@ -1774,12 +1787,13 @@ def _tool_doctor(args: dict):
         # Not `boost sync`: an unresolvable agent dir makes sync refuse too.
         lines.append("%d issue(s) — run `boost doctor` for details" % total)
     else:
-        lines.append(_doctor_verdict(plan, total, lock_bad, lost))
+        lines.append(_doctor_verdict(plan, total, lock_bad, lost,
+                                     unrestored=backup is not None))
     return "\n".join(lines), total > 0
 
 
 def _doctor_verdict(plan: dict[str, list], total: int, lock_bad: bool,
-                    lost: bool) -> str:
+                    lost: bool, *, unrestored: bool = False) -> str:
     """The MCP doctor's last line: which issues `boost sync` fixes.
 
     It said "run `boost sync` to fix" over a lock only `boost replay` restores
@@ -1787,12 +1801,15 @@ def _doctor_verdict(plan: dict[str, list], total: int, lock_bad: bool,
     saw nothing change, and was told the same again. Three kinds, and the
     line names each one present: what sync fixes, what only `--prune` does
     (the user's call, since it deletes or unlinks), and what is the user's
-    to change.
+    to change. ``unrestored`` moves the skills added outside boost into the
+    user's share: the lock was just rolled back, and the record of what they
+    are is in the ``.corrupt`` backup, which sync cannot read.
     """
     repos = sum(1 for r in plan.get("foreign_store", ()) if store.is_repo_copy(r))
     user = (lock_bad + len(plan.get("blocked_links", ()))
             + len(plan.get("unreadable_store", ())) + repos
-            + (0 if lost else len(plan.get("unrecorded_store", ()))))
+            + (0 if lost else len(plan.get("unrecorded_store", ())))
+            + (len(plan.get("adoptable_store", ())) if unrestored else 0))
     prune = (len(plan.get("foreign_store", ())) - repos
              + len(plan.get("out_of_scope_links", ()))
              + sum(1 for r in plan.get("plugin_duplicates", ())

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/boost_cli/commands/discovery.py

@@ -165,6 +165,9 @@ def cmd_search(argv):
         scored = [(h["entry"], h["score"]) for h in hits]
     else:
         scored = catalog.search(query)
+    # Whether the query matched before --category narrowed it: an empty list
+    # the filter produced is a different answer from one the query did.
+    matched_before_filter = len(scored)
     if args.category:
         scored = [(e, s) for e, s in scored
                  if catalog.matches_category(e, args.category)]
@@ -190,6 +193,26 @@ def cmd_search(argv):
                 "no searchable terms in %r" % query,
                 "a term needs 2 or more ASCII letters or digits — %s"
                 % _quoted(dropped)))
+        elif matched_before_filter and hit_cap:
+            # The filter only ever saw the top k: retrieval stopped at its
+            # cap, so a match in the category may sit past it, and "it
+            # matches outside that category" would be a claim about the
+            # whole catalogue made from one page of it.
+            print(out.empty_state(
+                "none of the top %d matches for %r are in category %r"
+                % (matched_before_filter, query, args.category),
+                "narrow the query so the category's items rank higher, or "
+                "drop --category"))
+            _note_dropped_terms(dropped)
+        elif matched_before_filter:
+            # The query matched; only the filter emptied the list. "no
+            # matches" plus a `boost discover` hint sent the user to GitHub
+            # for something already on disk, never naming the filter.
+            print(out.empty_state(
+                "no matches for %r in category %r" % (query, args.category),
+                "it matches outside that category — drop --category, or "
+                "`boost browse --categories` lists them"))
+            _note_dropped_terms(dropped)
         else:
             # The standardized ○/→ empty state, so "nothing here" reads the same
             # as every other command's; both wordings are pinned by tests.
@@ -2315,15 +2338,24 @@ def cmd_trending(argv):
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
     args = p.parse_args(argv)
-    evs = journal.events(action="install")
+    # New installs only: `boost update` and `boost reinstall` journal an
+    # "install" per refresh, and counting them ranked an item by how often its
+    # tap moved rather than by how often anyone chose it.
+    evs = [ev for ev in journal.events(action="install")
+           if journal.is_new_install(ev)]
     # setdefault, not a dict comprehension: a comprehension keeps the LAST
     # entry per name (whichever tap sorts last in catalog.all_entries()),
     # while cmd_recommend's equivalent aggregation (agg.setdefault) keeps the
     # first — so the two commands showed different descriptions for a name
     # shipped by more than one tap. First-wins here matches that convention.
     by_name: dict[str, dict] = {}
+    # (tap, name) too: a ranked row was installed from one particular tap,
+    # which its journal event names, and that tap's entry is the one to
+    # describe. First-wins is only the fallback for an event with no tap.
+    by_tap_name: dict[tuple[str, str], dict] = {}
     for e in catalog.all_entries():
         by_name.setdefault(e["name"], e)
+        by_tap_name.setdefault((e["tap"], e["name"]), e)
     if not evs:
         curated = sorted((e for e in by_name.values() if e.get("curated")),
                          key=operator.itemgetter("name"))[:args.limit]
@@ -2356,9 +2388,12 @@ def cmd_trending(argv):
     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", "")})
+        rec = agg.setdefault(name, {"count": 0, "last": ev.get("ts", ""),
+                                    "tap": ev.get("tap")})
         rec["count"] += 1
     ranked = sorted(agg.items(), key=lambda kv: (-kv[1]["count"], kv[0]))
+    entry_for = {name: by_tap_name.get((rec["tap"], name))
+                 or by_name.get(name, {}) for name, rec in ranked}
     if args.as_json:
         # `kind` is carried so rules and workflows stay distinguishable —
         # the prose table shows it, and a payload that dropped it would make
@@ -2366,15 +2401,15 @@ def cmd_trending(argv):
         print(json.dumps(
             {"source": "installs", "items": [
                 {"name": name, "installs": rec["count"], "last": rec["last"],
-                 "kind": by_name.get(name, {}).get("kind", "skill"),
-                 "description": by_name.get(name, {}).get("description", "")}
+                 "kind": entry_for[name].get("kind", "skill"),
+                 "description": entry_for[name].get("description", "")}
                 for name, rec in ranked[:args.limit]]}, indent=2))
         return 0
     # reserve name/installs/last/kind columns
     descw = max(out.term_width() - 54, 24)
     out.table([(name, str(rec["count"]), util.rel_time(rec["last"]),
-                by_name.get(name, {}).get("kind", "skill"),
-                out.truncate(by_name.get(name, {}).get("description", ""), descw))
+                entry_for[name].get("kind", "skill"),
+                out.truncate(entry_for[name].get("description", ""), descw))
                for name, rec in ranked[:args.limit]],
               headers=("name", "installs", "last", "kind", "description"),
               whole=("name",))  # `boost install <name>`

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/boost_cli/commands/hooks.py

@@ -66,6 +66,10 @@ def cmd_hooks(argv) -> int:
     p.add_argument("--force", action="store_true",
                    help="write even when $CODEX_HOME points outside this $HOME")
     args = p.parse_args(argv)
+    # Trimmed once, here, so the name this command echoes back is the one
+    # stored and compared (`cs.clean_name` trims again as the core backstop);
+    # an all-whitespace name then meets the "needs --name" refusal below.
+    args.name = (args.name or "").strip()
 
     if args.action == "list":
         return _list(args.scope, args.host, args.event, args.as_json)

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/boost_cli/commands/info.py

@@ -14,7 +14,6 @@ import shlex
 import subprocess
 import sys
 import webbrowser
-from itertools import chain
 from pathlib import Path
 
 from .. import cliparse
@@ -35,6 +34,7 @@ from ..core import (
     logs,
     mcpdecl,
     paths,
+    prereq,
     projectlock,
     registry,
     rules,
@@ -197,9 +197,17 @@ def _as_list(v) -> list:
     return [s.strip() for s in str(v).split(",") if s.strip()]
 
 
-def _skill_meta(name: str):
-    """Frontmatter for a named skill — installed store preferred, else tap."""
+def _skill_meta(name: str, project: dict | None = None, pbase=None):
+    """Frontmatter for a named skill — installed copy preferred, else tap.
+
+    ``project``/``pbase`` are the current repo's lock and base: a project-only
+    skill has no store dir, so its copy in the repo is the installed one.
+    """
     p = store.skill_store_dir(name) / "SKILL.md"
+    if not p.exists() and project and name in project:
+        pdir = integrity.project_skill_dir(project[name], pbase)
+        if pdir is not None:
+            p = pdir / "SKILL.md"
     if not p.exists():
         matches = catalog.find(name)
         if not matches:
@@ -548,11 +556,7 @@ def cmd_info(argv):
     sdir = store.skill_store_dir(name)
     skill_dir = sdir if lock and sdir.is_dir() else None
     if skill_dir is None and plock:
-        for m in plock.get("materializations") or []:
-            cand = scopes.resolve_in_base(pbase, m.get("path"))
-            if cand is not None and cand.is_dir():
-                skill_dir = cand
-                break
+        skill_dir = integrity.project_skill_dir(plock, pbase)
     if skill_dir is None and cat:
         try:
             skill_dir = store.source_dir_for(cat)
@@ -1237,7 +1241,11 @@ def cmd_deps(argv):
     # `requires:`/`conflicts:` name an installed item, not a kind — a
     # requirement met by an installed rule or workflow is met, and denying it
     # ("✗ not installed" while `boost list` shows it) was the section-blind lie.
-    have = set(chain.from_iterable(lockfile.all_installed().values()))
+    # The repo's own lock counts too: a requirement installed `--local` beside
+    # its dependent is met, and the old hint to `boost install` it again would
+    # have added a second, user-scope copy.
+    pbase, project = integrity.project_skills()
+    have = set(prereq.installed_names(pbase))
 
     if args.name:
         text, _kind, _lock, _cat = _resolve_text(args.name)
@@ -1245,7 +1253,8 @@ def cmd_deps(argv):
         requires = deps.requirement_names(meta)
         conflicts = deps.conflict_names(meta)
         req_rows = [deps.requirement_row(
-                        r, have, deps.requirement_names(_skill_meta(r) or {}))
+                        r, have, deps.requirement_names(
+                            _skill_meta(r, project, pbase) or {}))
                     for r in requires]
         conflict_rows = [deps.conflict_row(c, have) for c in conflicts]
         _qualifier, bare = catalog.split_name(args.name)
@@ -1289,8 +1298,9 @@ def cmd_deps(argv):
     unmet: list[dict] = []
     pairs: list[dict] = []
     seen: set = set()
-    for name in sorted(inst):
-        meta = _skill_meta(name) or {}
+    names = sorted(set(inst) | set(project))
+    for name in names:
+        meta = _skill_meta(name, project, pbase) or {}
         unmet.extend(
             {"skill": name, "requires": deps.requirement_row(r, have)}
             for r in deps.requirement_names(meta)
@@ -1305,7 +1315,7 @@ def cmd_deps(argv):
     if args.json:
         print(json.dumps({"unmet": unmet, "conflicts": pairs}, indent=2))
         return 1 if unmet or pairs else 0
-    if not inst:
+    if not names:
         print(out.empty_state("no skills installed",
                               hint="boost install <skill> to start"))
         return 0
@@ -1318,7 +1328,7 @@ def cmd_deps(argv):
                                out.role("conflicts with", "danger"), out.c(pair["b"], out.BOLD)))
     if not unmet and not pairs:
         out.ok("no unmet requirements or conflicts across %d skill%s"
-               % (len(inst), "" if len(inst) == 1 else "s"))
+               % (len(names), "" if len(names) == 1 else "s"))
         return 0
     if unmet:
         missing = sorted({u["requires"]["name"] for u in unmet})

{boost_skill_cli-1.2.199 → boost_skill_cli-1.2.201}/boost_cli/commands/intelligence.py

@@ -187,6 +187,7 @@ def _write_generated(dest: Path, text: str, yes: bool = False) -> bool:
 
     ``yes`` — see :func:`_install_generated`.
     """
+    util.check_path_length(dest, what="output path")
     if dest.exists() and not (yes or out.confirm("overwrite %s?" % _tilde(dest))):
         out.info("aborted — %s left untouched" % _tilde(dest))
         return False
@@ -1157,7 +1158,7 @@ def cmd_focus(argv: list[str]) -> int:
                                   wrap=True))
         return 0
 
-    names = list(dict.fromkeys(args.skills))
+    names = list(dict.fromkeys(store.installed_name(n) for n in args.skills))
     inst = lockfile.installed()
     for name in names:
         entry = inst.get(name)
@@ -1211,6 +1212,7 @@ def cmd_impact(argv: list[str]) -> int:
 
     inst = lockfile.installed()
     if args.name:
+        args.name = store.installed_name(args.name)
         if args.name not in inst:
             found = lockfile.find_any(args.name)
             if found is not None: