boost-skill-cli 1.0.10__tar.gz → 1.0.12__tar.gz

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/PKG-INFO

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

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/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.10'
-__version_tuple__ = version_tuple = (1, 0, 10)
+__version__ = version = '1.0.12'
+__version_tuple__ = version_tuple = (1, 0, 12)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/boost_cli/cli.py

@@ -60,8 +60,9 @@ COMMANDS = [
     ("unpin",       "pkg", "pkg", "Allow a pinned skill to update again"),
     ("snapshot",    "pkg", "pkg", "Save & restore whole skill environments"),
     ("export",      "pkg", "pkg", "Package skills as shareable zip/tar archives"),
-    # Discovery & Search (8)
+    # Discovery & Search (9)
     ("search",      "find", "discovery", "Search skills across tap registries (AI-ranked)"),
+    ("reindex",     "find", "discovery", "Build/refresh the full-content search index"),
     ("discover",    "find", "discovery", "Browse & search the GitHub-wide skill discovery index"),
     ("recommend",   "find", "discovery", "Suggest skills based on your project's tech stack"),
     ("browse",      "find", "discovery", "Interactive full-screen TUI with fuzzy search"),

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/boost_cli/commands/configuration.py

@@ -20,7 +20,7 @@ from pathlib import Path
 
 from .. import __version__
 from ..core import agents, catalog, config, frontmatter, gitutil, journal
-from ..core import lockfile, paths, policy, registry, store, util
+from ..core import lockfile, paths, policy, rag, registry, store, util
 from ..core import output as out
 from ..errors import BoostError
 
@@ -895,11 +895,23 @@ _MCP_TOOLS = [
 def _mcp_tool(tool: str, args: dict):
     """Run one MCP tool -> (text, is_error). (None, _) for unknown tools."""
     if tool == "boost_search":
-        hits = catalog.search(str(args.get("query", "")))[:10]
-        if not hits:
-            return "no skills match %r" % args.get("query", ""), False
+        query = str(args.get("query", ""))
+        rag_result = rag.search(query, limit=10)
+        if rag_result is not None:  # full-content index is built
+            hits, _ranker = rag_result
+            if not hits:
+                return "no skills match %r" % query, False
+            return "\n".join(
+                "%s — %s (%s)" % (h["entry"]["name"],
+                                  h["entry"].get("description", ""),
+                                  h["entry"]["tap"])
+                for h in hits), False
+        # no index yet -> keep today's frontmatter search so nothing regresses
+        scored = catalog.search(query)[:10]
+        if not scored:
+            return "no skills match %r" % query, False
         return "\n".join("%s — %s (%s)" % (e["name"], e["description"], e["tap"])
-                         for e, _score in hits), False
+                         for e, _score in scored), False
     if tool == "boost_list":
         skills = lockfile.installed()
         if not skills:

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/boost_cli/commands/discovery.py

@@ -15,7 +15,7 @@ import sys
 import time
 from pathlib import Path
 
-from ..core import agents, ai, catalog, gitutil, journal, lockfile, paths, registry, store, util
+from ..core import agents, ai, catalog, gitutil, journal, lockfile, paths, rag, registry, store, util
 from ..core import output as out
 from ..errors import BoostError
 
@@ -184,7 +184,14 @@ def cmd_search(argv):
     if not registry.list_taps():
         raise BoostError("no taps configured — nothing to search",
                         hint="add the recommended registries with `boost tap --defaults`")
-    scored = catalog.search(query)
+    # Prefer the full-content (RAG) index when it exists; otherwise fall back
+    # to the frontmatter search so nothing regresses before `boost reindex`.
+    use_rag = rag.ready()
+    if use_rag:
+        scored = [(h["entry"], h["score"])
+                  for h in rag.retrieve(query, k=max(60, args.limit * 4))]
+    else:
+        scored = catalog.search(query)
     if args.as_json:
         print(json.dumps([dict(e, score=s) for e, s in scored[:args.limit]]))
         return 0
@@ -193,7 +200,7 @@ def cmd_search(argv):
         out.info(out.c("try `boost discover %s` to search all of GitHub" % query,
                        out.DIM))
         return 0
-    ranker = "heuristic relevance"
+    ranker = "full-content BM25" if use_rag else "heuristic relevance"
     if args.smart:
         if ai.available():
             reranked = _ai_rank(query, scored)
@@ -214,6 +221,37 @@ def cmd_search(argv):
     return 0
 
 
+def cmd_reindex(argv):
+    """Build/refresh the full-content (RAG) search index over tapped items."""
+    p = argparse.ArgumentParser(
+        prog="boost reindex",
+        description="Build or refresh the full-content search index")
+    p.add_argument("--force", action="store_true",
+                   help="reindex every tap, ignoring cached commits")
+    p.add_argument("--json", action="store_true", dest="as_json",
+                   help="machine-readable output")
+    args = p.parse_args(argv)
+    if not registry.list_taps():
+        raise BoostError("no taps configured — nothing to index",
+                        hint="add the recommended registries with `boost tap --defaults`")
+    stats = rag.build(force=args.force)
+    if args.as_json:
+        print(json.dumps(stats))
+        return 0
+    out.ok("indexed %d passages across %d items from %d tap%s"
+           % (stats["docs"], stats["entries"], stats["taps"],
+              "" if stats["taps"] == 1 else "s"))
+    if stats["reused"]:
+        out.info(out.c("reused %d unchanged tap%s; reindexed: %s"
+                       % (len(stats["reused"]),
+                          "" if len(stats["reused"]) == 1 else "s",
+                          ", ".join(stats["reindexed"]) or "none"),
+                       out.DIM))
+    journal.log("reindex", "%d passages" % stats["docs"],
+                entries=stats["entries"])
+    return 0
+
+
 def cmd_index(argv):
     """Build ~/.boost/cache/discovery.json via `gh api` code search."""
     p = argparse.ArgumentParser(

boost_skill_cli-1.0.12/boost_cli/core/rag.py

@@ -0,0 +1,394 @@
+"""Full-content retrieval over tapped skills/rules/workflows (RAG — Phase 1).
+
+Pure stdlib. Where `catalog.search` scores only an item's name + one-line
+description + frontmatter, this indexes the *whole* body of every item and
+ranks it with BM25, then optionally reranks the shortlist through the
+`core.ai` bridge. See docs/rag-architecture.md.
+
+The index is persisted at ``~/.boost/cache/rag_index.json`` and refreshed
+per-tap, keyed on the git commit each tap cache was built from, so the
+expensive step — reading and chunking thousands of files — happens once and
+again only when a tap actually changes.
+
+Everything degrades: no index -> callers fall back to ``catalog.search``;
+no AI -> the BM25 order is returned as-is.
+"""
+from __future__ import annotations
+
+import json
+import math
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+try:  # TypedDict lives in typing on 3.9+, kept optional for safety
+    from typing import TypedDict
+except ImportError:  # pragma: no cover - 3.9+ always has it
+    TypedDict = None  # type: ignore
+
+from . import ai, catalog, frontmatter, gitutil, paths, registry
+
+INDEX_VERSION = 1
+ENGINE = "bm25"
+
+# Chunking defaults (documented in docs/rag-architecture.md §4).
+CHUNK_CHARS = 1000
+OVERLAP = 150
+MAX_CHUNKS = 40
+
+# BM25 parameters (§6a). Exposed in the persisted `params` so they are
+# tunable without a format change.
+K1 = 1.2
+B = 0.75
+
+# A deliberately tiny stopword list — full-content indexing already dilutes
+# common words, so we only drop the most frequent glue.
+_STOPWORDS = frozenset({
+    "the", "a", "an", "and", "or", "of", "to", "for", "in", "on", "with",
+    "is", "are", "be", "this", "that", "it", "as", "at", "by", "from",
+    "your", "you", "can", "will", "if", "when", "how",
+})
+
+
+class Hit(TypedDict):  # type: ignore[misc]
+    entry: dict     # the live catalog entry (name, tap, kind, skill_md, ...)
+    score: float    # BM25 relevance (higher = better)
+    snippet: str    # best-matching passage, for display + rerank context
+
+
+# --------------------------------------------------------------- tokenizing
+
+def tokenize(text: str) -> List[str]:
+    """Lowercase, split on non-alphanumerics, drop stopwords and 1-char noise."""
+    return [t for t in re.split(r"[^a-z0-9]+", text.lower())
+            if len(t) >= 2 and t not in _STOPWORDS]
+
+
+def chunk(text: str, size: int = CHUNK_CHARS, overlap: int = OVERLAP,
+          cap: int = MAX_CHUNKS) -> List[str]:
+    """Split a body into passage-sized chunks on paragraph boundaries.
+
+    Paragraphs are packed up to ``size`` chars; an oversized paragraph is
+    hard-split with ``overlap`` carried across the cut so a match spanning a
+    boundary is not lost. At most ``cap`` chunks are returned.
+    """
+    text = text.strip()
+    if not text:
+        return []
+    paras = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
+    chunks: List[str] = []
+    cur = ""
+    for p in paras:
+        while len(p) > size:
+            chunks.append(p[:size])
+            if len(chunks) >= cap:
+                return chunks
+            p = p[size - overlap:]
+        if not cur:
+            cur = p
+        elif len(cur) + 1 + len(p) <= size:
+            cur += "\n" + p
+        else:
+            chunks.append(cur)
+            if len(chunks) >= cap:
+                return chunks
+            tail = cur[-overlap:] if overlap else ""
+            cur = (tail + "\n" + p) if tail else p
+    if cur and len(chunks) < cap:
+        chunks.append(cur)
+    return chunks
+
+
+# ------------------------------------------------------------ body reading
+
+def _tap_paths() -> Dict[str, Path]:
+    return {t.name: t.path for t in registry.list_taps()}
+
+
+def _tap_commits() -> Dict[str, str]:
+    """Map safe tap name -> the commit its cache was built from."""
+    commits: Dict[str, str] = {}
+    for t in registry.list_taps():
+        commit = ""
+        try:
+            data = json.loads(t.cache_file.read_text())
+            commit = str(data.get("commit") or "")
+        except (OSError, json.JSONDecodeError):
+            pass
+        if not commit and t.is_cloned:
+            commit = gitutil.head_commit(t.path) or ""
+        commits[t.safe_name] = commit
+    return commits
+
+
+def read_body(entry: dict, tap_paths: Optional[Dict[str, Path]] = None) -> str:
+    """Return an item's searchable text: name + description + prose body.
+
+    The frontmatter is stripped (reusing ``frontmatter.parse``); the name and
+    description are prepended so short items keep keyword parity with the old
+    search. Missing files degrade to just the catalog metadata.
+    """
+    paths_map = _tap_paths() if tap_paths is None else tap_paths
+    header = "%s\n%s" % (entry.get("name", ""), entry.get("description", ""))
+    base = paths_map.get(entry.get("tap", ""))
+    if base is None:
+        base = paths.repos_dir() / str(entry.get("tap", "")).replace("/", "__")
+    rel = entry.get("skill_md")
+    if not rel:
+        return header.strip()
+    try:
+        text = (base / rel).read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return header.strip()
+    _meta, body = frontmatter.parse(text)
+    return ("%s\n%s" % (header, body)).strip()
+
+
+# ----------------------------------------------------------------- build
+
+def index_path() -> Path:
+    return paths.cache_dir() / "rag_index.json"
+
+
+def _make_docs(entries: List[dict], tap_paths: Dict[str, Path]) -> List[dict]:
+    """Chunk + tokenize every entry into scored documents (one per chunk)."""
+    docs: List[dict] = []
+    for e in entries:
+        body = read_body(e, tap_paths)
+        pieces = chunk(body) or [body]
+        for ci, piece in enumerate(pieces):
+            tf: Dict[str, int] = defaultdict(int)
+            for tok in tokenize(piece):
+                tf[tok] += 1
+            if not tf:
+                continue
+            docs.append({
+                "n": e["name"], "t": e["tap"], "k": e.get("kind", "skill"),
+                "c": ci, "l": sum(tf.values()),
+                "snip": piece[:200].strip(),
+                "tf": dict(tf),
+            })
+    return docs
+
+
+def _postings_to_doc_tf(raw: dict) -> Dict[int, Dict[str, int]]:
+    """Invert persisted postings back to per-doc term frequencies."""
+    doc_tf: Dict[int, Dict[str, int]] = defaultdict(dict)
+    for term, plist in raw.get("postings", {}).items():
+        for doc_id, tf in plist:
+            doc_tf[doc_id][term] = tf
+    return doc_tf
+
+
+def _kept_docs(raw: dict, keep_safe: set) -> List[dict]:
+    """Recover cached docs (with term freqs) for taps that did not change."""
+    doc_tf = _postings_to_doc_tf(raw)
+    kept: List[dict] = []
+    for doc_id, meta in enumerate(raw.get("docs", [])):
+        if meta["t"].replace("/", "__") in keep_safe:
+            kept.append({**meta, "tf": doc_tf.get(doc_id, {})})
+    return kept
+
+
+def build(entries: Optional[List[dict]] = None, force: bool = False) -> dict:
+    """(Re)build the full-content index, reusing unchanged taps.
+
+    Returns stats: ``{"entries", "docs", "taps", "reindexed", "reused"}``.
+    """
+    entries = catalog.all_entries() if entries is None else entries
+    tap_paths = _tap_paths()
+    commits = _tap_commits()
+
+    old = _load_raw()
+    reused_safe: set = set()
+    if old is not None and not force:
+        old_commits = old.get("commits", {})
+        for safe, commit in commits.items():
+            if commit and old_commits.get(safe) == commit:
+                reused_safe.add(safe)
+
+    fresh = [e for e in entries
+             if e["tap"].replace("/", "__") not in reused_safe]
+    docs = _make_docs(fresh, tap_paths)
+    if old is not None and reused_safe:
+        docs = _kept_docs(old, reused_safe) + docs
+
+    _save(docs, commits)
+    reindexed = sorted({e["tap"] for e in fresh})
+    return {
+        "entries": len({(e["name"], e["tap"]) for e in entries}),
+        "docs": len(docs),
+        "taps": len(commits),
+        "reindexed": reindexed,
+        "reused": sorted(reused_safe),
+    }
+
+
+def _save(docs: List[dict], commits: Dict[str, str]) -> None:
+    postings: Dict[str, List[List[int]]] = defaultdict(list)
+    meta_docs: List[dict] = []
+    total_len = 0
+    for doc_id, d in enumerate(docs):
+        for term, tf in d["tf"].items():
+            postings[term].append([doc_id, tf])
+        total_len += d["l"]
+        meta_docs.append({"n": d["n"], "t": d["t"], "k": d["k"],
+                          "c": d["c"], "l": d["l"], "snip": d["snip"]})
+    payload = {
+        "version": INDEX_VERSION,
+        "engine": ENGINE,
+        "generated": _now(),
+        "commits": commits,
+        "params": {"chunk_chars": CHUNK_CHARS, "overlap": OVERLAP,
+                   "k1": K1, "b": B},
+        "stats": {"docs": len(docs),
+                  "avg_len": (total_len / len(docs)) if docs else 0.0},
+        "docs": meta_docs,
+        "postings": {t: p for t, p in postings.items()},
+    }
+    paths.ensure_dirs()
+    p = index_path()
+    p.write_text(json.dumps(payload))
+    # Drop the mtime-keyed cache so a reindex is visible to an immediately
+    # following query even when the filesystem mtime granularity is coarse.
+    _CACHE.pop(str(p), None)
+
+
+def _now() -> str:
+    from . import util
+    return util.now_iso()
+
+
+# ----------------------------------------------------------------- query
+
+_CACHE: Dict[str, object] = {}
+
+
+def _load_raw() -> Optional[dict]:
+    p = index_path()
+    key = str(p)
+    try:
+        mtime = p.stat().st_mtime
+    except OSError:
+        _CACHE.pop(key, None)
+        return None
+    cached = _CACHE.get(key)
+    if isinstance(cached, tuple) and cached[0] == mtime:
+        return cached[1]  # type: ignore[return-value]
+    try:
+        data = json.loads(p.read_text())
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(data, dict) or data.get("version") != INDEX_VERSION:
+        return None
+    _CACHE[key] = (mtime, data)
+    return data
+
+
+def ready() -> bool:
+    """True when a usable index exists on disk."""
+    raw = _load_raw()
+    return bool(raw and raw.get("docs"))
+
+
+def _bm25(query_terms: List[str], raw: dict) -> Dict[int, float]:
+    docs = raw["docs"]
+    n = len(docs)
+    avg = raw.get("stats", {}).get("avg_len") or 1.0
+    postings = raw["postings"]
+    scores: Dict[int, float] = defaultdict(float)
+    for term in set(query_terms):
+        plist = postings.get(term)
+        if not plist:
+            continue
+        df = len(plist)
+        idf = math.log(1 + (n - df + 0.5) / (df + 0.5))
+        for doc_id, tf in plist:
+            dl = docs[doc_id]["l"] or 1
+            denom = tf + K1 * (1 - B + B * dl / avg)
+            scores[doc_id] += idf * (tf * (K1 + 1)) / denom
+    return scores
+
+
+def retrieve(query: str, k: int = 60, kind: Optional[str] = None,
+             entries: Optional[List[dict]] = None) -> List[Hit]:
+    """Top-k full-content hits for ``query``. ``[]`` if the index is empty."""
+    raw = _load_raw()
+    if not raw or not raw.get("docs"):
+        return []
+    terms = tokenize(query)
+    if not terms:
+        return []
+    entries = catalog.all_entries() if entries is None else entries
+    live = {(e["name"], e["tap"]): e for e in entries}
+    docs = raw["docs"]
+    best: Dict[Tuple[str, str], Tuple[float, str]] = {}
+    for doc_id, score in _bm25(terms, raw).items():
+        d = docs[doc_id]
+        if kind is not None and d["k"] != kind:
+            continue
+        key = (d["n"], d["t"])
+        if key not in live:
+            continue
+        prev = best.get(key)
+        if prev is None or score > prev[0]:
+            best[key] = (score, d["snip"])
+    ranked = sorted(best.items(), key=lambda kv: (-kv[1][0], kv[0][0]))
+    hits: List[Hit] = []
+    for (name, tap), (score, snip) in ranked[:k]:
+        hits.append({"entry": live[(name, tap)], "score": score,
+                     "snippet": snip})  # type: ignore[typeddict-item]
+    return hits
+
+
+def rerank(query: str, hits: List[Hit], limit: int = 10) -> Tuple[List[Hit], str]:
+    """Reorder the shortlist with the LLM bridge; degrade to BM25 order."""
+    top = hits[:max(limit, 15)]
+    if not ai.available():
+        return hits[:limit], "BM25 full-content"
+    listing = "\n".join(
+        "- %s [%s]: %s" % (h["entry"]["name"], h["entry"].get("kind", "skill"),
+                           (h["snippet"] or h["entry"].get("description", ""))[:180])
+        for h in top)
+    reply = ai.ask(
+        "Task: %s\n\nCandidate skills (name, kind, best matching text):\n%s\n\n"
+        "Order the skill names best-match-first for the task. "
+        "Reply with ONLY a JSON array of names." % (query, listing),
+        system="You rank AI coding skills by how well they fit a task.",
+        max_tokens=400)
+    order = _json_array(reply)
+    if not order:
+        return hits[:limit], "BM25 full-content"
+    by_name = {h["entry"]["name"]: h for h in hits}
+    picked = [by_name[str(n)] for n in order if str(n) in by_name]
+    rest = [h for h in hits if h["entry"]["name"]
+            not in {str(n) for n in order}]
+    return (picked + rest)[:limit], "Claude relevance"
+
+
+def search(query: str, limit: int = 10, kind: Optional[str] = None,
+           smart: bool = True,
+           entries: Optional[List[dict]] = None) -> Optional[Tuple[List[Hit], str]]:
+    """Two-stage RAG search: BM25 retrieve -> optional LLM rerank.
+
+    Returns ``(hits, ranker_label)``, or ``None`` when no index exists yet so
+    the caller can fall back to ``catalog.search``.
+    """
+    if not ready():
+        return None
+    hits = retrieve(query, k=max(60, limit * 4), kind=kind, entries=entries)
+    if smart:
+        return rerank(query, hits, limit)
+    return hits[:limit], "BM25 full-content"
+
+
+def _json_array(text):
+    m = re.search(r"\[.*\]", text or "", re.S)
+    if not m:
+        return None
+    try:
+        data = json.loads(m.group(0))
+    except json.JSONDecodeError:
+        return None
+    return data if isinstance(data, list) else None

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/boost_skill_cli.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ boost_cli/core/logs.py
 boost_cli/core/output.py
 boost_cli/core/paths.py
 boost_cli/core/policy.py
+boost_cli/core/rag.py
 boost_cli/core/registry.py
 boost_cli/core/store.py
 boost_cli/core/util.py
@@ -79,6 +80,7 @@ tests/unit/test_mutation_hardening.py
 tests/unit/test_output.py
 tests/unit/test_paths.py
 tests/unit/test_policy.py
+tests/unit/test_rag.py
 tests/unit/test_registry.py
 tests/unit/test_store.py
 tests/unit/test_util.py

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/docs/index.html

@@ -420,11 +420,11 @@
     </p>
     <div class="cta-row">
       <a class="btn btn-grad" href="#workflow">See how it works →</a>
-      <a class="btn btn-ghost" href="#commands">Explore all 72 commands</a>
+      <a class="btn btn-ghost" href="#commands">Explore all 73 commands</a>
     </div>
     <div class="stats">
       <div class="stat reveal"><b>8,400+</b><span>Discoverable skills</span></div>
-      <div class="stat reveal"><b>72</b><span>Commands · 8 groups</span></div>
+      <div class="stat reveal"><b>73</b><span>Commands · 8 groups</span></div>
       <div class="stat reveal"><b>2</b><span>Pre-tapped registries</span></div>
       <div class="stat reveal"><b>3</b><span>AI agents supported</span></div>
     </div>
@@ -589,7 +589,7 @@ facilitate structured divergent thinking:
   <section id="commands">
     <div class="wrap">
       <span class="eyebrow">What It Can Do</span>
-      <h2 class="sec-title">72 commands, 8 groups</h2>
+      <h2 class="sec-title">73 commands, 8 groups</h2>
       <p class="sec-sub">From basic install/update to AI-powered authoring, governance,
         and team rollouts. Filter live to find what you need.</p>
 
@@ -788,6 +788,7 @@ const COMMANDS = [
   ["snapshot","pkg","Save & restore whole skill environments"],
   ["export","pkg","Package skills as shareable zip/tar archives"],
   ["search","find","Search skills across tap registries (AI-ranked)"],
+  ["reindex","find","Build/refresh the full-content search index"],
   ["discover","find","Browse & search the GitHub-wide skill discovery index"],
   ["recommend","find","Suggest skills based on your project's tech stack"],
   ["browse","find","Interactive full-screen TUI with fuzzy search"],

{boost_skill_cli-1.0.10 → boost_skill_cli-1.0.12}/tests/functional/test_cli_configuration.py

@@ -343,7 +343,7 @@ class TestCompletions:
                     if l.startswith('complete -W "'))
         names = set(line.split('"')[1].split())
         assert names == {n for n, _g, _m, _s in COMMANDS}
-        assert len(names) == 72
+        assert len(names) == 73
         assert "# install: boost completions bash >> ~/.bashrc" in r.out
 
     def test_zsh_compdef_with_summaries(self, boost, sandbox):
@@ -351,14 +351,14 @@ class TestCompletions:
         assert r.out.splitlines()[0] == "#compdef boost"
         assert "'install:Install a skill from a tap registry'" in r.out
         entries = [l for l in r.out.splitlines() if l.startswith("    '")]
-        assert len(entries) == 72
+        assert len(entries) == 73
         assert "_describe -t commands 'boost command' _boost_commands" in r.out
 
     def test_fish_complete_lines(self, boost, sandbox):
         r = boost("completions", "fish")
         lines = [l for l in r.out.splitlines()
                  if l.startswith("complete -c boost -n __fish_use_subcommand -a ")]
-        assert len(lines) == 72
+        assert len(lines) == 73
         assert ("complete -c boost -n __fish_use_subcommand -a install "
                 "-d 'Install a skill from a tap registry'") in lines
 
@@ -684,6 +684,25 @@ class TestMcp:
         lock = json.loads(paths.lockfile_path().read_text())
         assert "brainstorming" in lock["skills"]  # id 8 really installed
 
+    def test_boost_search_prefers_full_content_index(self, boost, tapped):
+        from boost_cli.commands import configuration
+        from boost_cli.core import rag
+        boost("reindex")
+        assert rag.ready() is True
+        text, is_err = configuration._mcp_tool(
+            "boost_search", {"query": "brainstorming"})
+        assert is_err is False
+        assert "brainstorming" in text
+        assert "(fixture-tap)" in text
+
+    def test_boost_search_indexed_no_match(self, boost, tapped):
+        from boost_cli.commands import configuration
+        boost("reindex")
+        text, is_err = configuration._mcp_tool(
+            "boost_search", {"query": "zzzznothing"})
+        assert is_err is False
+        assert "no skills match 'zzzznothing'" in text
+
     def test_register_without_claude_prints_manual_command(self, boost, sandbox,
                                                            monkeypatch):
         monkeypatch.setattr("boost_cli.commands.configuration.shutil.which",