boost-skill-cli 1.0.370__tar.gz → 1.0.372__tar.gz

{boost_skill_cli-1.0.370/boost_skill_cli.egg-info → boost_skill_cli-1.0.372}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.370
+Version: 1.0.372
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.370'
-__version_tuple__ = version_tuple = (1, 0, 370)
+__version__ = version = '1.0.372'
+__version_tuple__ = version_tuple = (1, 0, 372)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/boost_cli/commands/configuration.py

@@ -531,20 +531,42 @@ def _sq(s: str) -> str:
 
 
 def cmd_completions(argv) -> int:
-    """boost completions [bash|zsh|fish]"""
+    """boost completions [bash|zsh|fish] [--install|--uninstall] [--eval]"""
     p = cliparse.parser(
         prog="boost completions",
         description="Generate shell tab-completion scripts")
     p.add_argument("shell", nargs="?", choices=("bash", "zsh", "fish"),
                    default=None, help="target shell (default: from $SHELL)")
+    p.add_argument("--eval", action="store_true",
+                   help="print the variant safe to `eval` directly "
+                        "(what --install wires up)")
+    group = p.add_mutually_exclusive_group()
+    group.add_argument("--install", action="store_true",
+                       help="wire completions into the shell's rc file "
+                            "(bash/zsh — one-shot, no manual editing)")
+    group.add_argument("--uninstall", action="store_true",
+                       help="remove what --install wired up")
     args = p.parse_args(argv)
 
-    shell = args.shell or Path(os.environ.get("SHELL", "")).name
-    if shell not in ("bash", "zsh", "fish"):
-        shell = "bash"
+    detected = args.shell or Path(os.environ.get("SHELL", "")).name
+
+    if args.install or args.uninstall:
+        rc = (complete.install if args.install else complete.uninstall)(detected)
+        out.ok("%s boost completions %s %s"
+               % ("wired" if args.install else "removed",
+                  "into" if args.install else "from", _tilde(rc)))
+        if args.install:
+            out.dim("  restart your shell (or run `exec %s`) to pick it up"
+                    % detected)
+        return 0
+
+    shell = detected if detected in ("bash", "zsh", "fish") else "bash"
     # The script is a thin shim that calls `boost __complete`; the candidate
     # rules live in core/complete.py so all three shells share one tested
     # implementation instead of three hand-maintained static lists.
+    if args.eval:
+        print(complete.eval_script(shell).rstrip())
+        return 0
     print(complete.script(shell).rstrip())
     out.dim("# install: " + complete.INSTALL_HINT[shell])
     return 0

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/boost_cli/commands/pkg.py

@@ -19,6 +19,7 @@ from ..core import (
     adapters,
     agents,
     catalog,
+    complete,
     config,
     frontmatter,
     gitutil,
@@ -698,6 +699,9 @@ def cmd_update(argv: List[str]) -> int:
     for tname, summary in results.items():
         catalog.rebuild_tap(registry.get(tname))
         out.ok("%s: %s" % (tname, summary))
+    # A pulled tap can add, drop, or rename catalogue entries, so the
+    # completion name cache must not survive an update unrefreshed.
+    complete.refresh_names()
     journal.log("update", args.tap or "all")
     if args.taps_only:
         return 0
@@ -919,6 +923,8 @@ def _bundle_install(file: Optional[str]) -> int:
         else:
             out.warn("line %d: unrecognised: %s" % (lineno, line))
             failed += 1
+    if taps_added:
+        complete.refresh_names()
     journal.log("bundle-install", label, taps=taps_added, skills=installed_n)
     summary = "Installed %s" % _plural(installed_n, "skill")
     if taps_added:

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/boost_cli/commands/quality.py

@@ -22,6 +22,7 @@ from ..core import (
     agents,
     ai,
     catalog,
+    complete,
     frontmatter,
     gitutil,
     imperative,
@@ -717,6 +718,9 @@ def cmd_heal(argv):
                 out.ok("rebuilt catalog cache for %s" % tap.name)
                 actions.append("cache %s" % tap.name)
 
+    if not dry:
+        complete.refresh_names()
+
     if not journal.rotation_healthy():
         if dry:
             out.info("would rotate the journal")

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/boost_cli/commands/taps.py

@@ -8,6 +8,7 @@ from contextlib import suppress
 from .. import cliparse, spin
 from ..core import (
     catalog,
+    complete,
     config,
     gitutil,
     journal,
@@ -125,6 +126,9 @@ def cmd_tap(argv) -> int:
             entries = catalog.rebuild_tap(tap)
         journal.log("tap", tap.name)
         out.ok("Tapped %s (%d skills)" % (tap.name, len(entries)))
+    # Refresh the TAB-completion name cache so `boost install <TAB>` sees
+    # whatever this call just tapped instead of the pre-tap snapshot.
+    complete.refresh_names()
     return rc
 
 
@@ -151,6 +155,7 @@ def cmd_untap(argv) -> int:
             out.info("cancelled")
             return 1
     registry.remove(tap.name)
+    complete.refresh_names()
     journal.log("untap", tap.name)
     out.ok("untapped %s" % tap.name)
     return 0

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/boost_cli/commands/team.py

@@ -9,7 +9,16 @@ import stat
 import urllib.parse
 
 from .. import cliparse
-from ..core import catalog, journal, lockfile, paths, registry, store, util
+from ..core import (
+    catalog,
+    complete,
+    journal,
+    lockfile,
+    paths,
+    registry,
+    store,
+    util,
+)
 from ..core import output as out
 from ..errors import BoostError
 
@@ -379,6 +388,7 @@ def cmd_protocol(argv) -> int:
             return 1
         tap = registry.add(arg)
         entries = catalog.rebuild_tap(tap)
+        complete.refresh_names()
         journal.log("tap", tap.name, via="protocol")
         out.ok("tapped %s (%d skills)" % (tap.name, len(entries)))
         return 0

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/boost_cli/core/complete.py

@@ -26,10 +26,12 @@ nothing. Silence degrades; a stack trace corrupts the line the user is typing.
 """
 from __future__ import annotations
 
+import os
 import re
 from pathlib import Path
 from typing import Callable, Dict, List, Optional, Sequence, Tuple
 
+from ..errors import BoostError
 from . import catalog, paths, registry, store
 
 # cli.COMMANDS rows: (name, group, module, summary). Typed here rather than
@@ -159,20 +161,29 @@ _boost_complete() {
 complete -F _boost_complete boost
 """
 
-_ZSH = """#compdef boost
-# Delegates to `boost __complete` rather than embedding a static list, so
-# arguments complete too — the previous version fell through to _files, which
-# offered local filenames where a skill name belongs.
-_boost() {
+# The function body is shared between two different trailers (see
+# `eval_script` for why): one that self-invokes for zsh's fpath/autoload
+# machinery, one that self-registers for a direct `eval` into a running shell.
+_ZSH_FUNC = """_boost() {
   local -a reply
   # "${(@)...}" preserves the EMPTY current word. Unquoted, zsh drops it,
   # so `boost install <TAB>` arrives as two words and completes command
   # names instead of skills — the exact bug this rewrite is fixing.
   reply=( ${(f)"$(boost __complete "${(@)words[1,$CURRENT]}" 2>/dev/null)"} )
   compadd -- $reply
-}
+}"""
+
+_ZSH = """#compdef boost
+# Delegates to `boost __complete` rather than embedding a static list, so
+# arguments complete too — the previous version fell through to _files, which
+# offered local filenames where a skill name belongs.
+%s
 _boost "$@"
-"""
+""" % _ZSH_FUNC
+
+_ZSH_EVAL = """%s
+compdef _boost boost
+""" % _ZSH_FUNC
 
 _FISH = """# boost fish completion — delegates to `boost __complete`.
 # `-f` disables fish's filename fallback, which is what it offered previously
@@ -191,9 +202,111 @@ def script(shell: str) -> str:
     return _SCRIPTS.get(shell, _BASH)
 
 
+def eval_script(shell: str) -> str:
+    """The variant safe to ``eval`` directly into a *running* shell, e.g. from
+    an rc file — what ``boost completions --install`` wires up.
+
+    Bash's script is unconditional registration (``complete -F ... boost``),
+    so it behaves identically whether sourced from a file or eval'd inline —
+    the same script serves both, so this just returns :func:`script`.
+
+    zsh's shipped script instead *self-invokes* (``_boost "$@"``), which is
+    correct only when zsh's own fpath/autoload machinery is what calls it:
+    the first real TAB press is what swaps the autoload stub for this body,
+    so that trailing call answers *that* press. Eval'd inline at shell
+    startup there is no press to answer yet — it would fire once, uselessly,
+    against the shell's own startup arguments, and register nothing for
+    later. ``compdef _boost boost`` instead registers the function for zsh's
+    completion system to call on every subsequent TAB press.
+    """
+    return _ZSH_EVAL if shell == "zsh" else script(shell)
+
+
 INSTALL_HINT = {
-    "bash": "boost completions bash >> ~/.bashrc",
-    "zsh": "boost completions zsh > ~/.zfunc/_boost   "
-           "(with fpath+=~/.zfunc before compinit)",
+    "bash": "boost completions --install   (or by hand: boost completions bash >> ~/.bashrc)",
+    "zsh": "boost completions --install   (or by hand: boost completions zsh > ~/.zfunc/_boost, "
+           "with fpath+=~/.zfunc before compinit)",
     "fish": "boost completions fish > ~/.config/fish/completions/boost.fish",
 }
+
+# Shells `--install`/`--uninstall` know how to wire up, and the rc file each
+# writes to. Fish needs neither: `~/.config/fish/completions/*.fish` is
+# auto-discovered, so `boost completions fish > that path` is already one
+# shell command with nothing left to automate.
+RC_FILE = {"bash": ".bashrc", "zsh": ".zshrc"}
+
+# Shell-comment markers, not core.rules's HTML-comment ones: an rc file
+# executes as shell code, so `<!-- ... -->` there is a syntax error, not a
+# comment.
+_RC_START = "# >>> boost completions >>>"
+_RC_END = "# <<< boost completions <<<"
+
+
+def _rc_block(shell: str) -> str:
+    # Calls back into `boost completions <shell> --eval` at every shell
+    # startup, rather than embedding a frozen copy of the script, so an
+    # installed hook never drifts from whatever boost version is on PATH.
+    return ("%s\ncommand -v boost >/dev/null 2>&1 && "
+            "eval \"$(boost completions %s --eval)\"\n%s"
+            % (_RC_START, shell, _RC_END))
+
+
+def _merge_rc(text: str, block: str) -> str:
+    """Idempotently set ``block`` in ``text``: replace a prior boost block in
+    place, or append one after a single blank line. Mirrors
+    :func:`core.rules.merge_block`'s shape with rc-file-safe markers."""
+    i = text.find(_RC_START)
+    if i != -1:
+        j = text.find(_RC_END, i)
+        if j != -1:
+            j += len(_RC_END)
+            return (text[:i] + block + text[j:]).rstrip("\n") + "\n"
+    base = text.rstrip("\n")
+    return (base + "\n\n" + block + "\n") if base else block + "\n"
+
+
+def _strip_rc(text: str) -> str:
+    """Inverse of :func:`_merge_rc`: remove the managed block, if present."""
+    i = text.find(_RC_START)
+    if i == -1:
+        return text
+    j = text.find(_RC_END, i)
+    if j == -1:
+        return text  # no end marker: malformed, leave the file untouched
+    j += len(_RC_END)
+    before, after = text[:i].rstrip("\n"), text[j:].strip("\n")
+    parts = [p for p in (before, after) if p]
+    return "\n\n".join(parts) + "\n" if parts else ""
+
+
+def _rc_path(shell: str) -> Path:
+    if shell not in RC_FILE:
+        raise BoostError(
+            "no one-shot install for %s yet" % shell,
+            hint="fish needs none: boost completions fish > "
+                 "~/.config/fish/completions/boost.fish"
+            if shell == "fish" else "supported: %s" % ", ".join(RC_FILE))
+    return paths.expand("~/" + RC_FILE[shell])
+
+
+def install(shell: str) -> Path:
+    """Idempotently wire ``shell``'s rc file to eval boost's completions on
+    every startup. Returns the rc file path. Raises :class:`BoostError` for
+    a shell with no rc-file install path (currently anything but bash/zsh)."""
+    rc = _rc_path(shell)
+    text = rc.read_text(encoding="utf-8") if rc.exists() else ""
+    rc.write_text(_merge_rc(text, _rc_block(shell)), encoding="utf-8")
+    return rc
+
+
+def uninstall(shell: str) -> Path:
+    """Remove what :func:`install` wired up. A no-op if never installed."""
+    rc = _rc_path(shell)
+    if rc.exists():
+        rc.write_text(_strip_rc(rc.read_text(encoding="utf-8")), encoding="utf-8")
+    return rc
+
+
+def detect_shell() -> str:
+    """The caller's shell from ``$SHELL``, basename only (e.g. "zsh")."""
+    return Path(os.environ.get("SHELL", "")).name

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.370
+Version: 1.0.372
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/docs/commands.html

@@ -174,7 +174,7 @@
       <a class="cmd-link" href="#cmd-create" data-search="create scaffold a new skill from a template  --description description --dir dir --install name">create</a>
       <a class="cmd-link" href="#cmd-policy" data-search="policy manage &amp; enforce skill governance policies  --json {list,set,unset,check} key value">policy</a>
       <a class="cmd-link" href="#cmd-onboard" data-search="onboard add skill-tracker telemetry to a repo &amp; open a pr  --repo repo --pr --dry-run -f, --force">onboard</a>
-      <a class="cmd-link" href="#cmd-completions" data-search="completions generate shell tab-completion scripts  {bash,zsh,fish}">completions</a>
+      <a class="cmd-link" href="#cmd-completions" data-search="completions generate shell tab-completion scripts  --eval --install --uninstall {bash,zsh,fish}">completions</a>
       <a class="cmd-link" href="#cmd-schedule" data-search="schedule manage automatic skill-sync scheduling  --interval {6h,12h,daily} --json {status,enable,disable}">schedule</a>
       <a class="cmd-link" href="#cmd-serve" data-search="serve serve the skill catalog over http (port 8787)  --port port --host host">serve</a>
       <a class="cmd-link" href="#cmd-mcp" data-search="mcp register boost as an mcp server (claude code, gemini cli) register boost as an mcp server for your agent clis --host h --stdio {register,unregister}">mcp</a>
@@ -1013,14 +1013,20 @@
           <div class="arg"><code>-f, --force</code><span>overwrite existing files without confirming</span></div>
         </div>
       </section>
-      <section class="cmd" id="cmd-completions" data-search="completions generate shell tab-completion scripts  {bash,zsh,fish}">
+      <section class="cmd" id="cmd-completions" data-search="completions generate shell tab-completion scripts  --eval --install --uninstall {bash,zsh,fish}">
         <h3><span class="cname">completions</span><span class="gtag">cfg</span></h3>
         <p class="summary">Generate shell tab-completion scripts</p>
-        <pre class="syn">boost completions [{bash,zsh,fish}]</pre>
+        <pre class="syn">boost completions [--eval] [--install] [--uninstall] [{bash,zsh,fish}]</pre>
         <div class="args-h">Arguments</div>
         <div class="args">
           <div class="arg"><code>{bash,zsh,fish}</code><span>target shell (default: from $SHELL)</span></div>
         </div>
+        <div class="args-h">Options</div>
+        <div class="args">
+          <div class="arg"><code>--eval</code><span>print the variant safe to `eval` directly (what --install wires up)</span></div>
+          <div class="arg"><code>--install</code><span>wire completions into the shell&#x27;s rc file (bash/zsh — one-shot, no manual editing)</span></div>
+          <div class="arg"><code>--uninstall</code><span>remove what --install wired up</span></div>
+        </div>
       </section>
       <section class="cmd" id="cmd-schedule" data-search="schedule manage automatic skill-sync scheduling  --interval {6h,12h,daily} --json {status,enable,disable}">
         <h3><span class="cname">schedule</span><span class="gtag">cfg</span></h3>

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/tests/functional/test_cli_configuration.py

@@ -547,6 +547,60 @@ class TestCompletions:
         monkeypatch.setenv("SHELL", "/bin/weirdsh")
         assert "_boost_complete" in boost("completions").out
 
+    def test_eval_flag_prints_the_eval_safe_variant(self, boost, sandbox):
+        r = boost("completions", "zsh", "--eval")
+        assert r.out.rstrip().endswith("compdef _boost boost")
+        assert '_boost "$@"' not in r.out
+        assert "boost __complete" in r.out
+
+
+class TestCompletionsInstall:
+    """`boost completions --install` — the one-shot alternative to the
+    copy-paste-into-your-rc-file instructions `INSTALL_HINT` used to be.
+    """
+
+    def test_explicit_shell_wires_the_matching_rc_file(self, boost, sandbox):
+        r = boost("completions", "bash", "--install")
+        assert "wired boost completions into ~/.bashrc" in r.out
+        assert "restart your shell" in r.out
+        text = (sandbox / ".bashrc").read_text(encoding="utf-8")
+        assert 'eval "$(boost completions bash --eval)"' in text
+
+    def test_auto_detects_shell_from_env(self, boost, sandbox, monkeypatch):
+        monkeypatch.setenv("SHELL", "/usr/local/bin/zsh")
+        boost("completions", "--install")
+        assert (sandbox / ".zshrc").exists()
+        assert not (sandbox / ".bashrc").exists()
+
+    def test_running_install_twice_does_not_duplicate_the_block(self, boost,
+                                                                 sandbox):
+        boost("completions", "bash", "--install")
+        boost("completions", "bash", "--install")
+        text = (sandbox / ".bashrc").read_text(encoding="utf-8")
+        assert text.count("# >>> boost completions >>>") == 1
+
+    def test_preserves_the_users_existing_rc_content(self, boost, sandbox):
+        (sandbox / ".bashrc").write_text("export EDITOR=vim\n", encoding="utf-8")
+        boost("completions", "bash", "--install")
+        text = (sandbox / ".bashrc").read_text(encoding="utf-8")
+        assert text.startswith("export EDITOR=vim\n")
+
+    def test_uninstall_removes_exactly_what_install_added(self, boost, sandbox):
+        (sandbox / ".bashrc").write_text("export EDITOR=vim\n", encoding="utf-8")
+        boost("completions", "bash", "--install")
+        r = boost("completions", "bash", "--uninstall")
+        assert "removed boost completions from ~/.bashrc" in r.out
+        assert (sandbox / ".bashrc").read_text(encoding="utf-8") == "export EDITOR=vim\n"
+
+    def test_fish_has_no_one_shot_install_yet(self, boost, sandbox):
+        r = boost("completions", "fish", "--install", expect=1)
+        assert "no one-shot install for fish yet" in r.err
+        assert "boost completions fish" in r.err
+
+    def test_install_and_uninstall_are_mutually_exclusive(self, boost, sandbox):
+        r = boost("completions", "bash", "--install", "--uninstall", expect=2)
+        assert "not allowed with argument" in r.err
+
 
 class TestHiddenCompleter:
     def test_it_prints_one_candidate_per_line(self, boost, sandbox):

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/tests/functional/test_cli_pkg.py

@@ -345,6 +345,19 @@ class TestUpdate:
         assert "upgraded" not in r.out
         assert _lock()["brainstorming"]["version"] == "1.4.0"
 
+    def test_refreshes_the_completion_cache(self, boost, fixture_tap_src,
+                                            tmp_path):
+        from boost_cli.core import complete
+        tap_dir = _copy_tap(fixture_tap_src, tmp_path / "growing-tap")
+        boost("tap", tap_dir)
+        complete.refresh_names()
+        assert "brand-new-skill" not in complete._cached_names()
+        _add_and_commit(tap_dir, "skills/brand-new-skill/SKILL.md",
+                        "---\nname: brand-new-skill\ndescription: added upstream\n"
+                        "version: 1.0.0\n---\n\n# New\n", "add brand-new-skill")
+        boost("update")
+        assert "brand-new-skill" in complete._cached_names()
+
     def test_refreshes_rule_when_source_changes(self, boost, fixture_tap_src,
                                                 tmp_path):
         tap_dir = _copy_tap(fixture_tap_src, tmp_path / "rule-tap")
@@ -825,6 +838,18 @@ class TestBundleEdges:
         assert "installed brainstorming v1.4.0 (fixture-tap)" in r.out
         assert "Installed 1 skill, added 1 tap" in r.out
 
+    def test_readding_a_tap_refreshes_the_completion_cache(self, boost, installed,
+                                                            tmp_path):
+        from boost_cli.core import complete
+        bf = tmp_path / "Boostfile"
+        boost("bundle", "dump", bf)
+        boost("uninstall", "brainstorming")
+        boost("untap", "fixture-tap", "--force")
+        complete.refresh_names()
+        assert "brainstorming" not in complete._cached_names()
+        boost("bundle", "install", bf)
+        assert "brainstorming" in complete._cached_names()
+
     def test_dump_local_comment_and_lost_tap_url(self, boost, installed,
                                                  tmp_path):
         boost("import", _skill_dir(tmp_path, "local-thing"))

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/tests/functional/test_cli_quality.py

@@ -534,6 +534,21 @@ class TestHeal:
         assert (paths.store_dir() / "brainstorming" / "SKILL.md").is_file()
         assert _lock()["brainstorming"]["version"] == "1.4.0"
 
+    def test_refreshes_the_completion_cache(self, boost, tapped):
+        from boost_cli.core import complete
+        complete.refresh_names()
+        complete.names_file().write_text("", encoding="utf-8")  # gone stale
+        assert "brainstorming" not in complete._cached_names()
+        boost("heal")
+        assert "brainstorming" in complete._cached_names()
+
+    def test_dry_run_does_not_touch_the_completion_cache(self, boost, tapped):
+        from boost_cli.core import complete
+        complete.refresh_names()
+        complete.names_file().write_text("", encoding="utf-8")
+        boost("heal", "--dry-run")
+        assert "brainstorming" not in complete._cached_names()
+
 
 # ── conflict ─────────────────────────────────────────────────────────────
 

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/tests/functional/test_cli_taps.py

@@ -286,3 +286,28 @@ class TestOutdated:
         r = boost("outdated")
         assert "source missing" in r.out
         assert "1 outdated" in r.out
+
+
+# ── completion cache invalidation ───────────────────────────────────────
+
+class TestCompletionCacheStaysFresh:
+    """core/complete.py's module docstring promises the TAB-completion name
+    cache is refreshed "after anything that changes the catalogue (tap,
+    untap, update)" — these pin that promise against the commands that make
+    it. Without the refresh call, `boost install <TAB>` silently drifts from
+    whatever `boost taps` actually reports.
+    """
+
+    def test_tap_refreshes_the_completion_cache(self, boost, fixture_tap_src):
+        from boost_cli.core import complete
+        complete.refresh_names()          # snapshot before any tap: empty
+        assert "brainstorming" not in complete._cached_names()
+        boost("tap", fixture_tap_src)
+        assert "brainstorming" in complete._cached_names()
+
+    def test_untap_refreshes_the_completion_cache(self, boost, tapped):
+        from boost_cli.core import complete
+        complete.refresh_names()
+        assert "brainstorming" in complete._cached_names()
+        boost("untap", "fixture-tap", "--force")
+        assert "brainstorming" not in complete._cached_names()

{boost_skill_cli-1.0.370 → boost_skill_cli-1.0.372}/tests/functional/test_cli_team.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import getpass
 import hashlib
 import json
+import shutil
 import stat
 import sys
 
@@ -252,6 +253,19 @@ class TestProtocol:
         r = boost("protocol", "open", "boost://tap/owner/repo", expect=1)
         assert "cancelled" in r.out
 
+    def test_open_tap_refreshes_the_completion_cache(self, boost, sandbox,
+                                                      fixture_tap_src,
+                                                      monkeypatch):
+        from boost_cli.core import complete
+        monkeypatch.setattr(
+            "boost_cli.core.gitutil.clone_shallow",
+            lambda url, dest: shutil.copytree(fixture_tap_src, dest))
+        complete.refresh_names()
+        assert "brainstorming" not in complete._cached_names()
+        r = boost("protocol", "open", "boost://tap/owner/repo")
+        assert "tapped owner/repo" in r.out
+        assert "brainstorming" in complete._cached_names()
+
     def test_register_unregister_darwin(self, boost, sandbox, monkeypatch):
         monkeypatch.setattr("boost_cli.commands.team.platform.system",
                             lambda: "Darwin")