boost-skill-cli 1.0.259__tar.gz → 1.0.261__tar.gz

{boost_skill_cli-1.0.259 → boost_skill_cli-1.0.261}/PKG-INFO

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

{boost_skill_cli-1.0.259 → boost_skill_cli-1.0.261}/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.259'
-__version_tuple__ = version_tuple = (1, 0, 259)
+__version__ = version = '1.0.261'
+__version_tuple__ = version_tuple = (1, 0, 261)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.259 → boost_skill_cli-1.0.261}/boost_cli/core/dense.py

@@ -163,7 +163,14 @@ def build(entries: Optional[List[dict]] = None,
         fresh = [e for e in entries
                  if e["tap"].replace("/", "__") not in reused]
         changed_taps = sorted({e["tap"] for e in fresh})
-        _delete_taps(con, changed_taps)
+        # Prune taps that are gone entirely, not only the ones that changed.
+        # `boost untap` removes a tap's entries, so it can never appear in
+        # `fresh` and its vectors survived every later incremental build —
+        # crowding the KNN pool on every query with rows `retrieve` then
+        # discards for not being live, which is how a dense search quietly
+        # returns fewer hits the longer an index has been in use.
+        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)
         _write_meta(con, {"version": INDEX_VERSION, "provider": prov,
@@ -176,6 +183,7 @@ def build(entries: Optional[List[dict]] = None,
             "added": added,
             "taps": len(commits),
             "reindexed": changed_taps,
+            "pruned": removed_taps,
             "reused": sorted(reused),
             "provider": prov,
             "model": mdl,
@@ -184,6 +192,14 @@ def build(entries: Optional[List[dict]] = None,
         con.close()
 
 
+def _indexed_taps(con: sqlite3.Connection) -> set:
+    """Every tap name the vector index currently holds chunks for."""
+    try:
+        return {r[0] for r in con.execute("SELECT DISTINCT tap FROM chunks")}
+    except sqlite3.OperationalError:
+        return set()          # no chunks table yet — nothing indexed, nothing stale
+
+
 def _delete_taps(con: sqlite3.Connection, taps: List[str]) -> None:
     for tap in taps:
         ids = [r[0] for r in

{boost_skill_cli-1.0.259 → boost_skill_cli-1.0.261}/boost_cli/core/rag.py

@@ -432,7 +432,14 @@ def _retrieve_any(query: str, k: int, kind: Optional[str],
     from . import dense
     if dense.ready():
         hits = dense.retrieve(query, k=k, kind=kind, entries=entries)
-        if hits is not None:
+        # An empty list is not the same answer as None. ``dense.retrieve``
+        # returns ``[]`` whenever every KNN neighbour was dropped for a kind
+        # mismatch or for no longer being live, which is a *thin index*, not a
+        # verdict on the query — and taking it as final short-circuits the
+        # documented "everything degrades to BM25" contract, so `boost search`
+        # answered "no results" while a perfectly good BM25 index sat unused.
+        # Only a non-empty dense result is final.
+        if hits:
             return hits, "dense vectors"
     if ready():
         return retrieve(query, k=k, kind=kind, entries=entries), "BM25 full-content"

{boost_skill_cli-1.0.259 → boost_skill_cli-1.0.261}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.259 → boost_skill_cli-1.0.261}/tests/unit/test_dense_fallback.py

@@ -439,6 +439,45 @@ class TestBuildWithoutExtension:
         assert stats["added"] == 2
         assert stats["chunks"] == 2                        # replaced, not dupe
 
+    def test_an_untapped_tap_is_pruned_from_the_index(self, store):
+        # THE GHOST-VECTOR BUG. `boost untap` removes a tap's entries, so it
+        # can never appear in `fresh` — the incremental path only ever deleted
+        # taps that CHANGED, and everything from a removed tap survived every
+        # later build, crowding the KNN pool that retrieve() then filters back
+        # out for not being live.
+        both = [*_ENTRIES, _e("gone", "from the other tap", tap="old/skills")]
+        store.setattr(rag, "_tap_commits",
+                      lambda: {"acme__skills": "c1", "old__skills": "c1"})
+        dense.build(entries=both, force=True)
+        con = sqlite3.connect(str(dense.db_path()))
+        assert con.execute("SELECT COUNT(*) FROM chunks WHERE tap = 'old/skills'"
+                           ).fetchone()[0] == 1
+        con.close()
+
+        # …the tap is removed: gone from the entry set and from the commit map.
+        store.setattr(rag, "_tap_commits", lambda: {"acme__skills": "c1"})
+        stats = dense.build(entries=_ENTRIES)
+
+        assert stats["pruned"] == ["old/skills"]
+        assert stats["reused"] == ["acme__skills"], "the surviving tap is untouched"
+        con = sqlite3.connect(str(dense.db_path()))
+        assert con.execute("SELECT COUNT(*) FROM chunks WHERE tap = 'old/skills'"
+                           ).fetchone()[0] == 0
+        assert con.execute("SELECT COUNT(*) FROM vec_chunks").fetchone()[0] == 2
+        con.close()
+
+    def test_nothing_is_pruned_when_every_tap_is_still_present(self, store):
+        dense.build(entries=_ENTRIES, force=True)
+        assert dense.build(entries=_ENTRIES)["pruned"] == []
+
+    def test_indexed_taps_is_empty_before_any_schema_exists(self, tmp_path):
+        # _indexed_taps runs against whatever connection build() has; on a
+        # database with no chunks table the answer is "nothing indexed", not a
+        # crash that takes the whole build down.
+        con = sqlite3.connect(str(tmp_path / "empty.sqlite"))
+        assert dense._indexed_taps(con) == set()
+        con.close()
+
     def test_provider_switch_wipes_and_rebuilds(self, store):
         dense.build(entries=_ENTRIES, force=True)
         store.setattr(embed, "provider", lambda: "voyage")

{boost_skill_cli-1.0.259 → boost_skill_cli-1.0.261}/tests/unit/test_rag.py

@@ -994,6 +994,43 @@ class TestEngineRouting:
         monkeypatch.setattr(dense_mod, "ready", lambda: False)
         assert rag.search("react", smart=False) is None
 
+    def test_dense_zero_hits_still_falls_through_to_bm25(self, sandbox,
+                                                        monkeypatch):
+        # THE BUG: `[]` is what dense.retrieve returns when every KNN neighbour
+        # was dropped for a kind mismatch or for no longer being live — a thin
+        # index, not a verdict on the query. Taking it as final answered "no
+        # results" with a perfectly good BM25 index sitting unused.
+        self._bm25_ready()
+        monkeypatch.setattr(dense_mod, "ready", lambda: True)
+        monkeypatch.setattr(dense_mod, "retrieve", lambda *a, **k: [])
+        result = rag.search("react", smart=False,
+                            entries=[_entry("a", tap="x/y")])
+        assert result is not None, "empty dense result must not end the search"
+        hits, label = result
+        assert label == "BM25 full-content"
+        assert [h["entry"]["name"] for h in hits] == ["a"]
+
+    def test_dense_zero_hits_with_no_bm25_index_falls_all_the_way_out(
+            self, sandbox, monkeypatch):
+        # Nothing left to try: the caller has to know to use catalog.search,
+        # which it only does when it gets None back.
+        monkeypatch.setattr(dense_mod, "ready", lambda: True)
+        monkeypatch.setattr(dense_mod, "retrieve", lambda *a, **k: [])
+        assert rag.search("react", smart=False) is None
+
+    def test_a_non_empty_dense_result_is_still_final(self, sandbox, monkeypatch):
+        # The fix must not turn into "always run BM25 too": a real dense hit
+        # ends the search, even with a BM25 index present that would rank
+        # something else first.
+        self._bm25_ready()
+        monkeypatch.setattr(dense_mod, "ready", lambda: True)
+        monkeypatch.setattr(dense_mod, "retrieve", lambda *a, **k: [
+            {"entry": {"name": "d", "tap": "x/y"}, "score": 9.0, "snippet": "D"}])
+        hits, label = rag.search("react", smart=False,
+                                 entries=[_entry("a", tap="x/y")])
+        assert label == "dense vectors"
+        assert [h["entry"]["name"] for h in hits] == ["d"]
+
 
 class TestAtomicIndexSave:
     """`_save` must route the index through util.atomic_write_text so a crash