boost-skill-cli 1.0.290__tar.gz → 1.0.291__tar.gz

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/PKG-INFO

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

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/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.290'
-__version_tuple__ = version_tuple = (1, 0, 290)
+__version__ = version = '1.0.291'
+__version_tuple__ = version_tuple = (1, 0, 291)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/boost_cli/commands/discovery.py

@@ -79,6 +79,9 @@ def _ai_rank(query: str, scored):
     return [by_name[n] for n in names] + rest
 
 
+_ENGINE_LABEL = {"BM25 full-content": "full-content BM25"}
+
+
 def cmd_search(argv):
     """Search the tap catalogs, optionally AI-reranked with --smart."""
     p = cliparse.parser(
@@ -104,9 +107,13 @@ def cmd_search(argv):
     if not use_rag:
         with spin.Spinner("building the search index (first run)"):
             use_rag = rag.ensure()
+    engine = ""
     if use_rag:
-        scored = [(h["entry"], h["score"])
-                  for h in rag.retrieve(query, k=max(60, args.limit * 4))]
+        # retrieve_any, not retrieve: this picks the dense backend when one is
+        # built and floors to BM25 otherwise, so the CLI and the MCP server
+        # answer from the same engine instead of the CLI being BM25-only.
+        hits, engine = rag.retrieve_any(query, k=max(60, args.limit * 4))
+        scored = [(h["entry"], h["score"]) for h in (hits or [])]
     else:
         scored = catalog.search(query)
     if args.as_json:
@@ -116,7 +123,10 @@ def cmd_search(argv):
         out.info("no matches for %r" % query)
         out.info(out.role("try `boost discover %s` to search all of GitHub" % query, "muted"))
         return 0
-    ranker = "full-content BM25" if use_rag else "heuristic relevance"
+    # The CLI's long-standing wording for the BM25 engine differs from the label
+    # rag/eval use ("BM25 full-content"), and both are load-bearing: the latter
+    # is pinned in tests/eval/baseline.json. Map instead of moving either.
+    ranker = _ENGINE_LABEL.get(engine, engine) if use_rag else "heuristic relevance"
     if args.smart:
         if ai.available():
             with spin.Spinner("ranking %d matches with Claude" % len(scored)):
@@ -190,8 +200,24 @@ def cmd_reindex(argv):
         if dense_stats is None:
             out.warn("dense index skipped — %s" % embed.fallback_note())
         else:
-            out.ok("embedded %d passages (%s) into the dense vector store"
-                   % (dense_stats["chunks"], dense_stats["provider"]))
+            failed = dense_stats.get("failed") or []
+            if failed:
+                out.warn("embedding failed for %d tap(s) — %d passages stored. "
+                         "The provider rejected those batches (rate limit, "
+                         "quota, or oversized input); their commits were not "
+                         "recorded, so a rerun retries them."
+                         % (len(failed), dense_stats["chunks"]))
+            elif not dense_stats["chunks"]:
+                # Reporting success with an empty store sent a real user chasing
+                # the wrong cause: a stale run can mark every tap "built", so the
+                # reuse path skips everything and stores nothing.
+                out.warn("the dense vector store is empty — %d tap(s) were "
+                         "reused as already-built. Rebuild with "
+                         "`boost reindex --dense --force`."
+                         % len(dense_stats["reused"]))
+            else:
+                out.ok("embedded %d passages (%s) into the dense vector store"
+                       % (dense_stats["chunks"], dense_stats["provider"]))
     journal.log("reindex", "%d passages" % stats["docs"],
                 entries=stats["entries"])
     return 0

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/boost_cli/core/dense.py

@@ -115,6 +115,12 @@ def ready() -> bool:
             return False
         if meta.get("provider") != embed.provider():
             return False
+        # Model, not just provider+dim: two models from one provider can share
+        # a dimension and still be different embedding spaces (voyage-3 and
+        # voyage-4 are both 1024-d), so serving stale vectors would silently
+        # mix spaces rather than fail loudly.
+        if meta.get("model") != embed.model():
+            return False
         if meta.get("dim") != embed.dimension():
             return False
         try:
@@ -147,7 +153,9 @@ def build(entries: Optional[List[dict]] = None,
         return None
     try:
         meta = _read_meta(con)
-        same_backend = (meta.get("provider") == prov and meta.get("dim") == dim)
+        same_backend = (meta.get("provider") == prov
+                        and meta.get("model") == mdl
+                        and meta.get("dim") == dim)
         if force or not same_backend:
             _wipe(con)
         _ensure_schema(con, dim)
@@ -172,9 +180,16 @@ def build(entries: Optional[List[dict]] = None,
         removed_taps = sorted(_indexed_taps(con) - {e["tap"] for e in entries})
         _delete_taps(con, changed_taps + removed_taps)
 
-        added = _embed_and_store(con, fresh, tap_paths)
+        added, failed_taps = _embed_and_store(con, fresh, tap_paths)
+        # Only record a commit for a tap whose chunks actually landed. Recording
+        # one for a tap that stored nothing makes every later non-forced run
+        # treat it as already built and skip it — one transient rate limit would
+        # otherwise leave the store permanently empty until `--force`.
+        failed_safe = {t.replace("/", "__") for t in failed_taps}
+        recorded = {safe: c for safe, c in commits.items()
+                    if safe not in failed_safe}
         _write_meta(con, {"version": INDEX_VERSION, "provider": prov,
-                          "model": mdl, "dim": dim, "commits": commits})
+                          "model": mdl, "dim": dim, "commits": recorded})
         con.commit()
         total = con.execute("SELECT COUNT(*) FROM chunks").fetchone()[0]
         return {
@@ -185,6 +200,7 @@ def build(entries: Optional[List[dict]] = None,
             "reindexed": changed_taps,
             "pruned": removed_taps,
             "reused": sorted(reused),
+            "failed": sorted(failed_taps),
             "provider": prov,
             "model": mdl,
         }
@@ -210,19 +226,31 @@ def _delete_taps(con: sqlite3.Connection, taps: List[str]) -> None:
 
 
 def _embed_and_store(con: sqlite3.Connection, entries: List[dict],
-                     tap_paths: Optional[Dict[str, Path]]) -> int:
+                     tap_paths: Optional[Dict[str, Path]]
+                     ) -> Tuple[int, set]:
+    """Embed every chunk of ``entries``; returns ``(added, failed_taps)``.
+
+    A batch the provider rejects (rate limit, quota, oversized input) yields no
+    vectors. Its taps are reported back rather than silently dropped, so the
+    caller can avoid recording a commit for a tap that stored nothing.
+    """
     mod = _load()
     if mod is None:          # [rag] extra absent — nothing to serialize into
-        return 0             # (callers fall back to BM25; see module docstring)
+        # Report every tap as failed so the caller records no commits: marking
+        # them built with zero vectors stored is what leaves the store
+        # permanently empty. (callers fall back to BM25; see module docstring)
+        return 0, {e["tap"] for e in entries}
     rows: List[Tuple[dict, int, str]] = []   # (entry, chunk_ix, text)
     for e in entries:
         for ci, text in enumerate(_chunk_texts(e, tap_paths)):
             rows.append((e, ci, text))
     added = 0
+    failed_taps: set = set()
     for start in range(0, len(rows), _BATCH):
         batch = rows[start:start + _BATCH]
         vecs = embed.embed([t for _e, _c, t in batch], input_type="document")
         if not vecs or len(vecs) != len(batch):
+            failed_taps.update(e["tap"] for e, _c, _t in batch)
             continue
         for (e, ci, text), vec in zip(batch, vecs):
             cur = con.execute(
@@ -233,7 +261,7 @@ def _embed_and_store(con: sqlite3.Connection, entries: List[dict],
             con.execute("INSERT INTO vec_chunks (rowid, embedding) VALUES (?, ?)",
                         (cur.lastrowid, mod.serialize_float32(vec)))
             added += 1
-    return added
+    return added, failed_taps
 
 
 def retrieve(query: str, k: int = 60, kind: Optional[str] = None,

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/boost_cli/core/embed.py

@@ -23,7 +23,10 @@ OPENAI_URL = "https://api.openai.com/v1/embeddings"
 
 # model -> output dimension. Stored in the vector index so a provider/model
 # switch is detected and forces a clean rebuild instead of mixing spaces.
-VOYAGE_MODEL = "voyage-3"
+# voyage-4 over voyage-3: same 1024-d default and same $/token, but the
+# voyage-4 generation carries a 200M-token complimentary allowance where
+# voyage-3 has none — so a full index build of a large corpus is free.
+VOYAGE_MODEL = "voyage-4"
 OPENAI_MODEL = "text-embedding-3-small"
 _DIMS = {VOYAGE_MODEL: 1024, OPENAI_MODEL: 1536}
 

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/boost_cli/core/rag.py

@@ -421,13 +421,17 @@ def rerank(query: str, hits: List[Hit], limit: int = 10) -> Tuple[List[Hit], str
     return (picked + rest)[:limit], "Claude relevance"
 
 
-def _retrieve_any(query: str, k: int, kind: Optional[str],
-                  entries: Optional[List[dict]]
-                  ) -> Tuple[Optional[List[Hit]], str]:
+def retrieve_any(query: str, k: int = 60, kind: Optional[str] = None,
+                 entries: Optional[List[dict]] = None
+                 ) -> Tuple[Optional[List[Hit]], str]:
     """Prefer the opt-in dense backend, floor to BM25.
 
     Returns ``(hits, engine_label)``; ``hits`` is ``None`` only when no index of
     any kind exists so the caller can fall back to ``catalog.search``.
+
+    Public because every retrieval entry point must make the same engine
+    choice: `cmd_search` calling ``retrieve`` directly meant the CLI could
+    never use a built dense index, while the MCP path could.
     """
     from . import dense
     if dense.ready():
@@ -454,7 +458,7 @@ def search(query: str, limit: int = 10, kind: Optional[str] = None,
     Returns ``(hits, ranker_label)``, or ``None`` when no index exists yet so
     the caller can fall back to ``catalog.search``.
     """
-    hits, engine = _retrieve_any(query, max(60, limit * 4), kind, entries)
+    hits, engine = retrieve_any(query, max(60, limit * 4), kind, entries)
     if hits is None:
         return None
     if smart:

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/tests/functional/test_cli_discovery.py

@@ -1106,3 +1106,54 @@ class TestReindex:
         assert data["dense"]["chunks"] >= 1
         assert data["dense"]["provider"] == "openai"
         assert dense.ready() is True
+
+    def test_cli_search_uses_dense_when_the_vector_store_is_built(
+            self, boost, tapped, monkeypatch):
+        """`boost search` must answer from the same engine the MCP server does.
+
+        It previously called ``rag.retrieve`` directly, so a built dense index
+        served the MCP path while the CLI stayed BM25-only.
+        """
+        if not _vec_loadable():
+            pytest.skip("sqlite-vec extension not loadable here")
+        from boost_cli.core import dense, embed
+
+        def toy(texts, input_type=None, timeout=60):
+            return [[1.0, 2.0, 3.0] for _ in texts]
+        monkeypatch.setattr(embed, "embed", toy)
+        monkeypatch.setattr(embed, "available", lambda: True)
+        monkeypatch.setattr(embed, "provider", lambda: "openai")
+        monkeypatch.setattr(embed, "model", lambda: "toy-3")
+        monkeypatch.setattr(embed, "dimension", lambda: 3)
+        boost("reindex", "--dense")
+        assert dense.ready() is True
+        r = boost("search", "brainstorming")
+        assert "ranked by dense vectors" in r.out
+        assert "full-content BM25" not in r.out
+
+    def test_empty_store_warns_instead_of_reporting_success(
+            self, boost, tapped, monkeypatch):
+        """A store left empty by an earlier run must not print a green check.
+
+        Reporting success on an empty store cost a real user a long debugging
+        detour: every tap reads as already-built, so the reuse path skips
+        everything and stores nothing.
+        """
+        if not _vec_loadable():
+            pytest.skip("sqlite-vec extension not loadable here")
+        from boost_cli.core import dense, embed
+
+        def toy(texts, input_type=None, timeout=60):
+            return [[1.0, 2.0, 3.0] for _ in texts]
+        monkeypatch.setattr(embed, "embed", toy)
+        monkeypatch.setattr(embed, "available", lambda: True)
+        monkeypatch.setattr(embed, "provider", lambda: "openai")
+        monkeypatch.setattr(embed, "model", lambda: "toy-3")
+        monkeypatch.setattr(embed, "dimension", lambda: 3)
+        # Records every tap commit while storing nothing — the exact state a
+        # rate-limited pre-fix run left behind.
+        dense.build(entries=[], force=True)
+        r = boost("reindex", "--dense")
+        assert "dense vector store is empty" in r.out
+        assert "--force" in r.out
+        assert dense.ready() is False

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/tests/unit/test_dense.py

@@ -203,6 +203,27 @@ class TestIncremental:
         monkeypatch.setattr(embed, "dimension", lambda: 4)
         assert dense.ready() is False
 
+    def test_model_switch_invalidates(self, dense_env, monkeypatch):
+        # Same provider, same dimension, different model — voyage-3 -> voyage-4
+        # is exactly this shape. provider+dim alone cannot catch it.
+        dense.build(entries=_ENTRIES, force=True)
+        assert dense.ready() is True
+        monkeypatch.setattr(embed, "model", lambda: "toy-4")
+        assert dense.ready() is False
+
+    def test_model_switch_reembeds_instead_of_reusing(self, dense_env,
+                                                      monkeypatch):
+        # The tap commit is unchanged, so only the model check can stop the
+        # reuse path from serving vectors from the previous embedding space.
+        dense.build(entries=_ENTRIES, force=True)
+        monkeypatch.setattr(embed, "model", lambda: "toy-4")
+        stats = dense.build(entries=_ENTRIES)
+        assert stats["reused"] == []
+        assert stats["model"] == "toy-4"
+        assert stats["added"] == len(_ENTRIES)
+        assert stats["chunks"] == len(_ENTRIES)   # wiped, not appended
+        assert dense.ready() is True
+
     def test_added_and_chunks_on_reindex(self, dense_env, monkeypatch):
         dense.build(entries=_ENTRIES, force=True)
         monkeypatch.setattr(rag, "_tap_commits", lambda: {"acme__skills": "c2"})

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/tests/unit/test_dense_fallback.py

@@ -150,13 +150,15 @@ class TestReadyGuards:
         monkeypatch.setattr(dense, "db_path", lambda: dbfile)
         monkeypatch.setattr(embed, "available", lambda: True)
         monkeypatch.setattr(embed, "provider", lambda: "openai")
+        monkeypatch.setattr(embed, "model", lambda: "toy-3")
         monkeypatch.setattr(embed, "dimension", lambda: 3)
         return monkeypatch
 
     def _use(self, monkeypatch, con):
         monkeypatch.setattr(dense, "_connect", lambda: con)
 
-    _GOOD: ClassVar[dict] = {"version": dense.INDEX_VERSION, "provider": "openai", "dim": 3}
+    _GOOD: ClassVar[dict] = {"version": dense.INDEX_VERSION,
+                             "provider": "openai", "model": "toy-3", "dim": 3}
 
     def test_true_when_everything_matches(self, wired):
         self._use(wired, self._seed(self._GOOD, rows=1))
@@ -182,6 +184,17 @@ class TestReadyGuards:
         self._use(wired, self._seed({**self._GOOD, "dim": 99}))
         assert dense.ready() is False
 
+    def test_false_on_model_mismatch(self, wired):
+        # provider and dim still match — only the model moved (voyage-3 ->
+        # voyage-4 is this exact case, both 1024-d under provider "voyage")
+        self._use(wired, self._seed({**self._GOOD, "model": "toy-4"}))
+        assert dense.ready() is False
+
+    def test_false_when_model_absent_from_meta(self, wired):
+        meta = {k: v for k, v in self._GOOD.items() if k != "model"}
+        self._use(wired, self._seed(meta))
+        assert dense.ready() is False
+
     def test_false_when_chunks_table_missing(self, wired):
         self._use(wired, self._seed(self._GOOD, with_chunks=False))
         assert dense.ready() is False
@@ -485,12 +498,57 @@ class TestBuildWithoutExtension:
         assert stats["reused"] == []
         assert stats["provider"] == "voyage"
 
+    def test_model_switch_wipes_and_rebuilds(self, store):
+        # provider and dim unchanged, only the model moved — the voyage-3 ->
+        # voyage-4 case. Without the model term in `same_backend` the unchanged
+        # tap commit would reuse vectors from the old embedding space.
+        dense.build(entries=_ENTRIES, force=True)
+        store.setattr(embed, "model", lambda: "toy-4")
+        stats = dense.build(entries=_ENTRIES)              # no force needed
+        assert stats["reused"] == []
+        assert stats["model"] == "toy-4"
+        assert stats["added"] == 2
+        assert stats["chunks"] == 2                        # wiped, not appended
+
     def test_batch_count_mismatch_drops_that_batch(self, store):
         store.setattr(embed, "embed", lambda texts, **k: [[1.0, 2.0, 3.0]])
         stats = dense.build(entries=_ENTRIES, force=True)
         assert stats["added"] == 0
         assert stats["chunks"] == 0
 
+    def test_failed_batch_is_reported_not_swallowed(self, store):
+        store.setattr(embed, "embed", lambda texts, **k: None)   # provider 429s
+        stats = dense.build(entries=_ENTRIES, force=True)
+        assert stats["added"] == 0
+        assert stats["failed"] == ["acme/skills"]
+
+    def test_failed_tap_commit_is_not_recorded(self, store):
+        # A rate-limited run must not mark the tap "built at c1" — otherwise the
+        # next non-forced run reuses it and the store stays empty forever.
+        store.setattr(embed, "embed", lambda texts, **k: None)
+        dense.build(entries=_ENTRIES, force=True)
+        con = sqlite3.connect(str(dense.db_path()))
+        meta = dense._read_meta(con)
+        con.close()
+        assert meta["commits"] == {}
+
+    def test_rerun_after_failure_retries_instead_of_reusing(self, store):
+        store.setattr(embed, "embed", lambda texts, **k: None)
+        dense.build(entries=_ENTRIES, force=True)         # fails, stores nothing
+        store.setattr(embed, "embed", _toy_embed)         # provider recovers
+        stats = dense.build(entries=_ENTRIES)             # no --force needed
+        assert stats["reused"] == []
+        assert stats["failed"] == []
+        assert stats["added"] == 2
+        assert stats["chunks"] == 2
+
+    def test_successful_tap_commit_is_recorded(self, store):
+        dense.build(entries=_ENTRIES, force=True)
+        con = sqlite3.connect(str(dense.db_path()))
+        meta = dense._read_meta(con)
+        con.close()
+        assert meta["commits"] == {"acme__skills": "c1"}
+
     def test_empty_entries_builds_nothing(self, store):
         stats = dense.build(entries=[], force=True)
         assert stats["chunks"] == 0

{boost_skill_cli-1.0.290 → boost_skill_cli-1.0.291}/tests/unit/test_embed.py

@@ -51,6 +51,19 @@ class TestProviderSelection:
         assert embed.dimension() == 1024
         assert embed.available() is True
 
+    def test_every_selectable_model_has_a_dimension(self, sandbox, monkeypatch):
+        """A model bump that forgets ``_DIMS`` would hand ``dense`` a None dim.
+
+        ``dense.build`` bails out on a None dimension, so the vector store would
+        silently never build rather than fail loudly.
+        """
+        for env in ("VOYAGE_API_KEY", "OPENAI_API_KEY"):
+            monkeypatch.delenv("VOYAGE_API_KEY", raising=False)
+            monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+            monkeypatch.setenv(env, "k")
+            assert embed.model() in embed._DIMS
+            assert isinstance(embed.dimension(), int)
+
     def test_openai_when_only_openai(self, sandbox, monkeypatch):
         monkeypatch.setenv("OPENAI_API_KEY", "o")
         assert embed.provider() == "openai"