boost-skill-cli 1.2.198__tar.gz → 1.2.200__tar.gz

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/PKG-INFO

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

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/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.198'
-__version_tuple__ = version_tuple = (1, 2, 198)
+__version__ = version = '1.2.200'
+__version_tuple__ = version_tuple = (1, 2, 200)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/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.198 → boost_skill_cli-1.2.200}/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")

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/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.198 → boost_skill_cli-1.2.200}/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

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/boost_cli/commands/pkg.py

@@ -1440,7 +1440,46 @@ def _confirm_risky_materialized(kind: str, name: str, lk: dict,
     return _show_and_confirm("%s %s" % (kind, name), diff, name)
 
 
-def _update_materialized(kind: str, installed: dict[str, dict], results) -> int:
+def _hold_update(label: str, name: str, lk: dict, kind: str, old_v: str,
+                 new_v: str, discard_edits: bool,
+                 allow_downgrade: bool) -> tuple[bool, bool]:
+    """Apply `staleness.update_hold` for one item: ``(held, edited)``.
+
+    A held item is named with the way past it, because each remedy is a
+    deliberate act: `boost reinstall` discards one item's edits,
+    `--discard-edits` every edited item's this run, and `--allow-downgrade`
+    follows a rewound tap. `--force` releases neither; it moves pinned taps.
+    ``edited`` lets a released refresh say what it threw away.
+    """
+    edited = integrity.locally_edited(kind, name, lk)
+    hold = staleness.update_hold(edited, old_v, new_v, discard_edits,
+                                 allow_downgrade)
+    if hold == staleness.HOLD_LOCAL_EDITS:
+        out.warn("%s has local edits — update skipped; `boost reinstall %s` "
+                 "discards them, or `boost update --discard-edits` for every "
+                 "edited item" % (label, name), wrap=True)
+    elif hold == staleness.HOLD_DOWNGRADE:
+        out.warn("%s: upstream is at v%s, behind your v%s — update skipped; "
+                 "`boost update --allow-downgrade` downgrades"
+                 % (label, new_v, old_v), wrap=True)
+    return hold is not None, edited
+
+
+def _refresh_line(label: str, old_v: str, new_v: str, edited: bool,
+                  bumped: bool) -> str:
+    """The success line for a refresh, saying which way the version moved."""
+    if bumped:
+        msg = "upgraded %s v%s → v%s" % (label, old_v, new_v)
+    elif new_v and util.semver_gt(old_v, new_v):
+        msg = "downgraded %s v%s → v%s" % (label, old_v, new_v)
+    else:
+        msg = "refreshed %s v%s (source changed)" % (label, new_v or old_v)
+    return msg + (" — local edits discarded" if edited else "")
+
+
+def _update_materialized(kind: str, installed: dict[str, dict], results,
+                         discard_edits: bool = False,
+                         allow_downgrade: bool = False) -> tuple[int, int]:
     """Re-materialize installed rules/workflows whose tap source moved.
 
     Mirrors the skill upgrade loop: for each installed item from a refreshed
@@ -1448,10 +1487,12 @@ def _update_materialized(kind: str, installed: dict[str, dict], results) -> int:
     changed — behind the same risky-diff gate the skill loop uses, and behind
     the same pin/quarantine skips: a pinned rule stays put, and refreshing a
     quarantined one would re-materialize the very content quarantine removed.
-    Returns how many were refreshed.
+    An edited or downgraded item is held unless its flag releases it
+    (`_hold_update`).
+    Returns ``(refreshed, held)``.
     """
     import hashlib
-    n = 0
+    n = held = 0
     for name, lk in sorted(installed.items()):
         tapname = lk.get("tap")
         if lk.get("pinned") or lk.get("quarantined"):
@@ -1492,6 +1533,12 @@ def _update_materialized(kind: str, installed: dict[str, dict], results) -> int:
                      "the record" % (kind, name, _tilde(Path(lk["base"])),
                                      name), wrap=True)
             continue
+        hold, edited = _hold_update("%s %s" % (kind, name), name, lk, kind,
+                                    old_v, str(entry.get("version") or ""),
+                                    discard_edits, allow_downgrade)
+        if hold:
+            held += 1
+            continue
         try:
             new_raw = (registry.get(tapname).path
                        / entry.get("skill_md", "")).read_text(
@@ -1507,14 +1554,15 @@ def _update_materialized(kind: str, installed: dict[str, dict], results) -> int:
             # A dir that refused the refresh is named here, as for a skill.
             _warn_unwritable(store.install(
                 entry, force=True,
-                scope=lk.get("scope", "user"), base=lk.get("base")))
+                scope=lk.get("scope", "user"), base=lk.get("base"),
+                via="update"))
         except BoostError as err:
             out.warn("%s: %s" % (name, err.message))
             continue
-        out.ok(("upgraded %s %s v%s → v%s" % (kind, name, old_v, new_v)) if bumped
-               else ("refreshed %s %s v%s (source changed)" % (kind, name, new_v)))
+        out.ok(_refresh_line("%s %s" % (kind, name), old_v,
+                             str(entry.get("version") or ""), edited, bumped))
         n += 1
-    return n
+    return n, held
 
 
 def _resync_vectors(moved: list[str]) -> None:
@@ -1687,6 +1735,12 @@ def cmd_update(argv: list[str]) -> int:
                     help="skip the confirmation prompt")
     ap.add_argument("--force", action="store_true",
                     help="move pinned taps too, clearing their pin")
+    ap.add_argument("--discard-edits", action="store_true",
+                    help="refresh locally edited skills, rules and workflows "
+                         "too, overwriting the edits")
+    ap.add_argument("--allow-downgrade", action="store_true",
+                    help="follow a tap whose upstream version is now older "
+                         "than the installed one")
     ap.add_argument("--shards", action="store_true",
                     help="refresh prebuilt vectors from the published "
                          "manifest, moving taps to the commits it names")
@@ -1746,7 +1800,7 @@ def cmd_update(argv: list[str]) -> int:
         # `boost update --taps-only` exists precisely to notice that morning.
         return 1 if failures and not results else 0
 
-    upgraded = 0
+    upgraded = held = 0
     for name, lk in sorted(lockfile.installed().items()):
         tapname = lk.get("tap")
         if (lk.get("pinned") or lk.get("quarantined")
@@ -1771,27 +1825,40 @@ def cmd_update(argv: list[str]) -> int:
                                            head, lk.get("sha256", ""), src_sha)
         if reason is None:
             continue
+        hold, edited = _hold_update(name, name, lk, "skill", old_v,
+                                    str(entry.get("version") or ""),
+                                    args.discard_edits, args.allow_downgrade)
+        if hold:
+            held += 1
+            continue
         if not _confirm_risky_update(name, entry):
             out.warn("%s: update skipped — review the diff, then `boost update "
                      "--yes` to apply" % name)
             continue
         try:
-            _warn_unwritable(store.install(entry, force=True))
+            _warn_unwritable(store.install(entry, force=True, via="update"))
         except BoostError as err:
             out.warn("%s: %s" % (name, err.message))
             continue
-        if reason == "version":
-            out.ok("upgraded %s v%s → v%s" % (name, old_v, new_v))
-        else:
-            out.ok("refreshed %s v%s (source changed)" % (name, new_v))
+        out.ok(_refresh_line(name, old_v, str(entry.get("version") or ""),
+                             edited, reason == staleness.VERSION))
         upgraded += 1
     # Rules and workflows refresh from the same tap update.
     # Skills installed before boost dated them, so a plugin's copy of the
     # same name can be weighed against them (store.serving_plugin).
     store.backfill_source_dates(results)
-    upgraded += _update_materialized("rule", lockfile.installed_rules(), results)
-    upgraded += _update_materialized("workflow", lockfile.installed_workflows(), results)
-    if not upgraded:
+    for kind, section in (("rule", lockfile.installed_rules()),
+                          ("workflow", lockfile.installed_workflows())):
+        n, h = _update_materialized(kind, section, results,
+                                    discard_edits=args.discard_edits,
+                                    allow_downgrade=args.allow_downgrade)
+        upgraded += n
+        held += h
+    if held:
+        # Never "everything up to date" over items it just declined to touch.
+        out.info(out.role("%d item%s held back — see above"
+                          % (held, "s" if held != 1 else ""), "muted"))
+    elif not upgraded:
         if pinned_skips and pinned_skips == len(results) and not failures:
             # Every tap was a pinned skip: nothing was actually checked over
             # the network, which "everything up to date" would misreport as
@@ -1868,7 +1935,7 @@ def cmd_reinstall(argv: list[str]) -> int:
             try:
                 res = store.install(entry, force=True,
                                     scope=lk.get("scope", "user"),
-                                    base=lk.get("base"))
+                                    base=lk.get("base"), via="reinstall")
             except BoostError as err:
                 # The hint too: a refusal to recreate a deleted repo is only
                 # useful with the `boost uninstall` that clears it.
@@ -1935,7 +2002,7 @@ def cmd_reinstall(argv: list[str]) -> int:
         if warning:
             out.warn(warning)
         try:
-            res = store.install(entry, force=True)
+            res = store.install(entry, force=True, via="reinstall")
         except BoostError as err:
             out.warn("%s: %s" % (name, err.message))
             failed += 1
@@ -2652,8 +2719,9 @@ def cmd_export(argv: list[str]) -> int:
     if format_warning:
         out.warn(format_warning)
     ext = ".zip" if use_zip else ".tar.gz"
-    dest = paths.expand(args.out) if args.out else Path(
-        "boost-skills-%s%s" % (stamp, ext))
+    dest = util.check_path_length(
+        paths.expand(args.out) if args.out else Path(
+            "boost-skills-%s%s" % (stamp, ext)), what="-o path")
     if dest.exists() and not args.force:
         raise BoostError("%s already exists" % _tilde(dest),
                         hint="pass --force to overwrite, or choose a "

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/boost_cli/commands/quality.py

@@ -48,6 +48,7 @@ from ..core import (
     util,
 )
 from ..core import output as out
+from ..core import rules as rule_blocks
 from ..errors import BoostError
 from ._common import _iter_installed, _iter_installed_all, _require_lock_integrity, _s
 
@@ -481,6 +482,22 @@ def _mat_remedy(off: list[tuple[str, str, str, str]]) -> str:
             "remove the artifact.%s" % (drop, tail))
 
 
+def _drifted(kind: str, name: str, entry: dict, bad) -> int:
+    """Name a rule/workflow whose written content no longer hashes to the
+    lock, and return the issue count it adds.
+
+    Doctor checked only that each materialization existed, so a hand edit
+    `boost verify` fails and `boost drift` calls a local edit left the verdict
+    "healthy". Asked through the function `verify` uses, so the two cannot
+    disagree about one file; only after the presence checks found nothing,
+    so a missing artifact is not reported twice.
+    """
+    if integrity.materialized_status(name, entry, kind) != integrity.STATUS_MODIFIED:
+        return 0
+    bad(kind, "%s %s modified since install — run `boost verify`" % (kind, name))
+    return 1
+
+
 def cmd_doctor(argv):
     ap = cliparse.parser(
         prog="boost doctor", description="Check installation health & report issues")
@@ -660,6 +677,18 @@ def cmd_doctor(argv):
     for name, entry in sorted(skills.items()):
         sdir = store.skill_store_dir(name)
         if not sdir.is_dir():
+            # A pin over a moved source is a repair heal declines, so naming
+            # heal sent the user round doctor -> heal -> doctor. Whether the
+            # source moved is a hash of the tap source, and reading that goes
+            # through `source_dir_for`, which widens a sparse clone and can
+            # fetch. Doctor stays read-only and offline, so it names the
+            # preview that answers instead of asking itself.
+            if entry.get("pinned") and not store.is_url_import(entry):
+                bad("skill", "skill %s missing from store — it is pinned, so "
+                    "`boost heal --dry-run` shows whether heal can restore it"
+                    % name, wrap=True)
+                skill_issues += 1
+                continue
             fix = ("boost reinstall %s" % name if store.is_url_import(entry)
                    else "boost heal")
             bad("skill", "skill %s missing from store — run `%s`" % (name, fix))
@@ -851,6 +880,7 @@ def cmd_doctor(argv):
                         % (kind, name, m.get("agent", "?"), why), wrap=True)
                     mat_issues += 1
     for name, entry in sorted(rules.items()):
+        before = mat_issues
         for m in entry.get("materializations") or []:
             p = Path(m.get("path", ""))
             if m.get("unwritable"):
@@ -859,10 +889,21 @@ def cmd_doctor(argv):
                 continue
             if m.get("mode") == "claude":
                 try:
-                    present = p.exists() and ("boost:rule:%s start" % name) in \
-                        p.read_text(encoding="utf-8")
+                    text = p.read_text(encoding="utf-8") if p.exists() else ""
                 except OSError:
-                    present = False
+                    text = ""
+                present = ("boost:rule:%s start" % name) in text
+                # The start marker alone counted as present, while `verify`
+                # reads the same block as missing and the next write appends
+                # a second block after the orphan rather than replacing it.
+                if present and rule_blocks.unclosed_block(text, name):
+                    bad("rule", "rule %s's block in %s has a start marker and "
+                        "no end marker — restore its `%s` line or delete the "
+                        "orphaned block, then run `boost reinstall %s`"
+                        % (name, _tilde(p), rule_blocks.markers(name)[1], name),
+                        wrap=True)
+                    mat_issues += 1
+                    continue
             else:
                 # ``os.path``: ``Path.is_file`` raises under a dotdir with no
                 # search bit on Python 3.12 and 3.13.
@@ -871,7 +912,10 @@ def cmd_doctor(argv):
                 bad("rule", "rule %s missing its %s materialization — run "
                     "`boost reinstall %s`" % (name, m.get("agent", "?"), name))
                 mat_issues += 1
+        if mat_issues == before:
+            mat_issues += _drifted("rule", name, entry, bad)
     for name, entry in sorted(workflows.items()):
+        before = mat_issues
         for m in entry.get("materializations") or []:
             if not store.materialization_is_written("workflow", entry, m):
                 continue
@@ -885,6 +929,8 @@ def cmd_doctor(argv):
                         "`boost reinstall %s`"
                         % (name, m.get("agent", "?"), name))
                 mat_issues += 1
+        if mat_issues == before:
+            mat_issues += _drifted("workflow", name, entry, bad)
     # A note, not an issue: the workflow works for every agent with a workflow
     # format. Only an agent that reads skills alone (Codex) misses it.
     unreached = store.workflows_without_skill_copy() if agents_ok else []
@@ -1671,13 +1717,18 @@ def cmd_heal(argv):
         # lock)" where the live run reinstalls, and previewed no rule or
         # workflow repair at all.
         for msg in store.sync_preview(plan):
-            out.info(msg.replace(str(paths.home()), "~"))
+            (out.warn if store.is_unrepaired(msg) else out.info)(
+                msg.replace(str(paths.home()), "~"))
             actions.append(msg)
     else:
         for msg in store.sync_apply(plan):
             (out.warn if store.is_unrepaired(msg) else out.ok)(
                 msg.replace(str(paths.home()), "~"))
             actions.append(msg)
+    # A repair heal will not make (a pin over a moved source, a URL import it
+    # cannot re-clone) fails the run like any other thing it left: exiting 0
+    # over a skill still missing is what kept doctor and heal in a loop.
+    unrepaired = any(store.is_unrepaired(a) for a in actions)
 
     # Opt-in, unlike everything above it. The rest of `heal` repairs what boost
     # itself created; these entries boost did not create, so deleting one on a
@@ -1870,7 +1921,7 @@ def cmd_heal(argv):
                if declined_duplicates or declined_copies else "nothing to heal")
     if actions and not dry:
         journal.log("heal", "%d actions" % len(actions))
-    return 1 if cfg_err or stuck else 0
+    return 1 if cfg_err or stuck or unrepaired else 0
 
 
 def cmd_conflict(argv):

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/boost_cli/commands/taps.py

@@ -79,12 +79,15 @@ def _skip_if_already_tapped(spec: str) -> bool:
     errored (exit 1), the second printed this muted line and exited 0. A
     spec that fails to parse is not "already tapped" — it falls through so
     the ordinary `registry.add` call raises its usual, more specific error.
+    Nor is a *different* repository under the same name: it falls through
+    too, and `registry.add` refuses it naming the URL that holds the name.
     """
     try:
-        name, _url = registry.parse_spec(spec)
+        name, url = registry.parse_spec(spec)
     except BoostError:
         return False
-    if not registry.is_tapped(name):
+    if not any(t.name == name and registry.same_source(t.url, url)
+               for t in registry.list_taps()):
         return False
     out.info(out.role("%s already tapped" % name, "muted"))
     return True
@@ -418,15 +421,18 @@ def cmd_taps(argv) -> int:
     return 0
 
 
-def _outdated_display(r: dict) -> str:
+def _outdated_display(r: dict, configured: frozenset[str] = frozenset()) -> str:
     """Table rendering of one `cmd_outdated` row's machine fields.
 
     ``reason``/``latest``/``latest_commit`` are the JSON-facing values;
     everything a human reads (the "(content changed)" wording, the short
     commit) is derived here so the two representations can't drift apart.
+    ``configured`` names the taps still configured: a missing row from one of
+    them was removed upstream, which is what the footer calls it too.
     """
     if r["reason"] == staleness.SOURCE_MISSING:
-        return staleness.OUTDATED_SOURCE_MISSING
+        return (staleness.OUTDATED_REMOVED_UPSTREAM if r["tap"] in configured
+                else staleness.OUTDATED_SOURCE_MISSING)
     latest = r["latest"] or "?"
     if r["reason"] == staleness.CONTENT:
         return ("%s (%s)" % (latest, r["latest_commit"])
@@ -543,16 +549,19 @@ def cmd_outdated(argv) -> int:
     if not results:
         out.ok("everything up to date")
         return 0
+    # A missing row whose tap is still configured lost the item upstream;
+    # re-tapping it would restore nothing, so it is worded and counted apart.
+    configured = frozenset(t.name for t in registry.list_taps())
     rows = [(r["name"] + ("" if r["kind"] == "skill" else " (%s)" % r["kind"]),
              r["installed"] + (" (pinned)" if r["pinned"] else ""),
-             _outdated_display(r), r["tap"]) for r in results]
+             _outdated_display(r, configured), r["tap"]) for r in results]
     # NAME is what `boost update`/`upgrade` take.
     out.table(rows, headers=("NAME", "INSTALLED", "LATEST", "TAP"),
               whole=("NAME",))
     print()
-    source_missing = sum(1 for r in results
-                         if r["reason"] == staleness.SOURCE_MISSING)
-    out.dim(staleness.outdated_footer(len(results), source_missing))
+    missing = [r for r in results if r["reason"] == staleness.SOURCE_MISSING]
+    removed = sum(1 for r in missing if r["tap"] in configured)
+    out.dim(staleness.outdated_footer(len(results), len(missing), removed))
     return 0
 
 

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/boost_cli/commands/team.py

@@ -263,7 +263,11 @@ def cmd_cohort(argv) -> int:
 # ---------------------------------------------------------------- profile
 
 def _profile_path(name: str):
-    return paths.profiles_dir() / (util.resolve_slug(name, what="profile name") + ".json")
+    # The file name is checked, not just the slug: a 251-255 byte slug is a
+    # legal name until ".json" pushes the component past the limit.
+    slug = util.resolve_slug(name, what="profile name")
+    return util.check_path_length(paths.profiles_dir() / (slug + ".json"),
+                                  what="profile file name")
 
 
 def _load_profile(name: str) -> dict:
@@ -1025,7 +1029,9 @@ def cmd_who(argv) -> int:
         u["events"] += 1
         if e.get("subject") and journal.is_expertise_event(e):
             u["skills"].add(e["subject"])
-        if e.get("action") == "install":
+        # New installs only, as `boost trending` counts them: an update or a
+        # reinstall journals "install" too, and is not one.
+        if journal.is_new_install(e):
             u["installs"] += 1
         u["last"] = max(u["last"], e.get("ts", ""))
     if args.json:

{boost_skill_cli-1.2.198 → boost_skill_cli-1.2.200}/boost_cli/core/complete.py

@@ -351,7 +351,8 @@ def _source_for(command: str, position: int, prior: tuple[str, ...],
     return None
 
 
-def candidates(words: list[str], commands: Registry) -> list[str]:
+def candidates(words: list[str], commands: Registry,
+               global_flags: frozenset[str] = frozenset()) -> list[str]:
     """Completions for ``words``, where the last element is the partial word.
 
     ``words`` is the command line as the shell split it, including ``boost``
@@ -360,15 +361,31 @@ def candidates(words: list[str], commands: Registry) -> list[str]:
 
     ``commands`` is ``cli.COMMANDS``, passed in rather than imported: ``core``
     is the bottom layer and must not reach up into ``cli`` (the import-linter
-    contract enforces it), so the registry arrives as data.
+    contract enforces it), so the registry arrives as data. ``global_flags``
+    is ``cli._GLOBAL_FLAGS`` for the same reason: ``cli.main`` peels those off
+    before the command name, so ``boost --debug install <TAB>`` is a real line
+    and completion has to peel them the same way.
     """
     try:
         if len(words) < 2:
             return []
+        # Only leading flags, and never the word being typed: `--debug<TAB>`
+        # is a partial word, not a flag already given.
+        lead = 1
+        while lead < len(words) - 1 and words[lead] in global_flags:
+            lead += 1
+        words = [words[0], *words[lead:]]
         current = words[-1]
         if len(words) == 2:                     # completing the command itself
             return [c for c in _command_names(commands) if c.startswith(current)]
         command = words[1]
+        if command in ("help", "-h", "--help"):
+            # The help pseudo-command is not a COMMANDS row, so no source
+            # knows it, yet the top-level usage line advertises it — and
+            # `cli._route` sends `--help <cmd>` / `-h <cmd>` the same way.
+            if len(words) != 3:
+                return []
+            return [c for c in _command_names(commands) if c.startswith(current)]
         if current.startswith("-"):
             return [f for f in _flags_for(command, commands) if f.startswith(current)]
         prior = tuple(words[2:-1])