boost-skill-cli 1.0.332__py3-none-any.whl → 1.0.334__py3-none-any.whl

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.332'
-__version_tuple__ = version_tuple = (1, 0, 332)
+__version__ = version = '1.0.334'
+__version_tuple__ = version_tuple = (1, 0, 334)
 
 __commit_id__ = commit_id = None

boost_cli/commands/discovery.py

@@ -194,6 +194,38 @@ def _hint_semantic_search(engine: str) -> None:
         out.info(out.role(line, "muted"))
 
 
+def _shard_io(args) -> int:
+    """`--export-shard` / `--import-shard`, the two halves of a prebuilt shard.
+
+    Embedding is ~1.2 s/chunk on CPU — 74 minutes for 743 entries — so without
+    a way to move vectors between machines the keyless tier is available in
+    principle and unreachable in practice. Import validates rather than trusts;
+    see `dense.import_shard` for why a mismatched shard must be refused instead
+    of merged.
+    """
+    from ..core import dense
+    if args.export_shard:
+        shard = dense.export_shard(args.export_shard)
+        if not shard.get("chunks"):
+            raise BoostError("no vectors for %r" % args.export_shard,
+                            hint="build them first with `boost reindex --dense`")
+        print(json.dumps(shard))
+        return 0
+    path = Path(args.import_shard)
+    try:
+        shard = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise BoostError("cannot read shard %s: %s" % (path, exc)) from exc
+    tap = str(shard.get("tap") or "")
+    commit = rag._tap_commits().get(tap.replace("/", "__"), "")
+    ok, reason = dense.import_shard(shard, commit=commit)
+    if not ok:
+        raise BoostError("shard refused — %s" % reason,
+                        hint="`boost reindex --dense` embeds it locally instead")
+    out.ok("%s: %s" % (tap, reason))
+    return 0
+
+
 def cmd_reindex(argv):
     """Build/refresh the full-content (RAG) search index over tapped items."""
     p = cliparse.parser(
@@ -203,10 +235,19 @@ def cmd_reindex(argv):
                    help="reindex every tap, ignoring cached commits")
     p.add_argument("--dense", action="store_true",
                    help="also embed chunks into the opt-in dense vector store "
-                        "(needs the `rag` extra and an embeddings API key)")
+                        "(needs the `rag` extra; no API key required)")
+    p.add_argument("--export-shard", metavar="TAP",
+                   help="write TAP's prebuilt vectors to stdout as JSON, for "
+                        "publishing so others need not re-embed them")
+    p.add_argument("--import-shard", metavar="FILE",
+                   help="merge a prebuilt vector shard, skipping the embed "
+                        "cost; refused unless it matches this store's backend "
+                        "and the tap's current commit")
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
     args = p.parse_args(argv)
+    if args.export_shard or args.import_shard:
+        return _shard_io(args)
     if not registry.list_taps():
         raise BoostError("no taps configured — nothing to index",
                         hint="add the recommended registries with `boost tap --defaults`")

boost_cli/core/dense.py

@@ -12,6 +12,7 @@ are the expensive step, so an unchanged tap is never re-embedded.
 """
 from __future__ import annotations
 
+import base64
 import json
 import sqlite3
 from pathlib import Path
@@ -345,6 +346,116 @@ def build(entries: Optional[List[dict]] = None,
         con.close()
 
 
+def export_shard(tap: str) -> dict:
+    """One tap's vectors plus the provenance needed to validate them later.
+
+    Embedding is the expensive half of the keyless tier — measured at ~1.2 s per
+    chunk on CPU, so 74 minutes for 743 entries — while querying is milliseconds.
+    A shard lets that cost be paid once in CI and downloaded by everyone else.
+
+    The provenance fields are not decoration: vectors are only comparable inside
+    the embedding space that produced them, so provider/model/dim have to travel
+    with the rows, and the registry commit has to travel too or a stale shard
+    would be indistinguishable from a current one.
+    """
+    # Plain sqlite3, NOT _connect: exporting reads `chunks`, `meta` and the
+    # stored embedding blobs, all ordinary tables. Routing through _connect
+    # would make export impossible without the sqlite-vec extension — the same
+    # trap `_recorded_meta` documents — and a machine that built vectors and
+    # then dropped the extra is exactly the one whose shard is worth having.
+    if not db_path().exists():
+        return {"tap": tap, "chunks": []}
+    try:
+        con = sqlite3.connect(str(db_path()))
+    except sqlite3.Error:
+        return {"tap": tap, "chunks": []}
+    try:
+        meta = _read_meta(con)
+        commits = meta.get("commits")
+        commit = ""
+        if isinstance(commits, dict):
+            commit = str(commits.get(tap.replace("/", "__")) or "")
+        chunks = []
+        for row in con.execute(
+                "SELECT c.name, c.tap, c.path, c.kind, c.cix, c.snip, v.embedding "
+                "FROM chunks c JOIN vec_chunks v ON v.rowid = c.id "
+                "WHERE c.tap = ? ORDER BY c.id", (tap,)):
+            name, ctap, path, kind, cix, snip, emb = row
+            chunks.append({
+                "name": name, "tap": ctap, "path": path, "kind": kind,
+                "cix": cix, "snip": snip,
+                # base64 so the shard is plain JSON and can be published as a
+                # release artifact without a binary format of its own.
+                "embedding": base64.b64encode(bytes(emb)).decode("ascii"),
+            })
+        return {"tap": tap, "commit": commit,
+                "provider": meta.get("provider"), "model": meta.get("model"),
+                "dim": meta.get("dim"), "version": INDEX_VERSION,
+                "chunks": chunks}
+    except sqlite3.Error:
+        return {"tap": tap, "chunks": []}
+    finally:
+        con.close()
+
+
+def import_shard(shard: dict, commit: str) -> Tuple[bool, str]:
+    """Merge a prebuilt shard into this machine's store. ``(ok, reason)``.
+
+    Refuses rather than degrades. A vector is only meaningful against others
+    from the same embedding space, so a shard from a different provider, model
+    or dimension cannot be mixed in: doing so would not raise, it would quietly
+    return nonsense rankings, which is the worse failure. A shard whose commit
+    does not match the tap as it stands now is refused for a different reason —
+    accepting it would let `build()` mark that tap "reused" and never re-embed
+    it, pinning the user to stale vectors indefinitely.
+    """
+    for field in ("provider", "model", "dim"):
+        if shard.get(field) in (None, ""):
+            return False, "shard is missing %s" % field
+    if str(shard.get("commit") or "") != commit:
+        return False, ("commit mismatch: shard %r, tap %r"
+                       % (shard.get("commit"), commit))
+    con = _connect()
+    if con is None:
+        return False, "no vector backend available"
+    try:
+        meta = _read_meta(con)
+        # An empty store has no opinion yet, so it adopts the shard's backend.
+        if meta.get("provider"):
+            for field in ("provider", "model", "dim"):
+                if meta.get(field) != shard.get(field):
+                    return False, ("%s mismatch: store %r, shard %r"
+                                   % (field, meta.get(field), shard.get(field)))
+        dim = int(shard["dim"])
+        _ensure_schema(con, dim)
+        # Replace, never append: re-importing must not double a tap's rows.
+        _delete_taps(con, [str(shard.get("tap") or "")])
+        mod = _load()
+        for c in shard.get("chunks") or []:
+            cur = con.execute(
+                "INSERT INTO chunks (name, tap, path, kind, cix, snip) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (c.get("name"), c.get("tap"), c.get("path"), c.get("kind"),
+                 c.get("cix"), c.get("snip")))
+            blob = base64.b64decode(c["embedding"])
+            con.execute("INSERT INTO vec_chunks (rowid, embedding) VALUES (?, ?)",
+                        (cur.lastrowid, blob))
+        commits = meta.get("commits")
+        commits = dict(commits) if isinstance(commits, dict) else {}
+        commits[str(shard.get("tap") or "").replace("/", "__")] = commit
+        _write_meta(con, {"version": INDEX_VERSION,
+                          "provider": shard.get("provider"),
+                          "model": shard.get("model"), "dim": dim,
+                          "commits": commits})
+        con.commit()
+        _ = mod          # extension loaded by _connect; kept for symmetry
+        return True, "imported %d chunks" % len(shard.get("chunks") or [])
+    except sqlite3.Error as exc:
+        return False, "store error: %s" % exc
+    finally:
+        con.close()
+
+
 def _indexed_taps(con: sqlite3.Connection) -> set:
     """Every tap name the vector index currently holds chunks for."""
     try:

boost_cli/core/rag.py

@@ -219,17 +219,33 @@ def _make_docs(entries: List[dict], tap_paths: Dict[str, Path]) -> List[dict]:
 
 
 def _postings_to_doc_tf(raw: dict) -> Dict[int, Dict[str, int]]:
-    """Invert persisted postings back to per-doc term frequencies."""
+    """Invert persisted postings back to per-doc term frequencies.
+
+    Pure: it inverts whatever ``raw`` carries and reads nothing. An earlier
+    version fell back to the SQLite store with ``or``, which made a caller
+    passing ``{}`` silently receive tens of thousands of postings from the live
+    index — invisible in CI, where no store exists, and wrong everywhere else.
+    Callers that need the store now say so; see :func:`_kept_docs`.
+    """
     doc_tf: Dict[int, Dict[str, int]] = defaultdict(dict)
-    for term, plist in (raw.get("postings") or _all_postings()).items():
+    for term, plist in (raw.get("postings") or {}).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)
+    """Recover cached docs (with term freqs) for taps that did not change.
+
+    Term frequencies live in the SQLite postings store since they left the JSON
+    index, so an index without an inline ``postings`` key is normal rather than
+    empty — this is the caller that reaches for the store, explicitly.
+    """
+    # Key ABSENCE, not falsiness: an index carrying an explicit empty
+    # `postings` is stating it has none, and must not be answered from the
+    # store. Only an index with no such key predates the SQLite move.
+    doc_tf = _postings_to_doc_tf(
+        raw if "postings" in raw else {"postings": _all_postings()})
     return [{**meta, "tf": doc_tf.get(doc_id, {})}
             for doc_id, meta in enumerate(raw.get("docs", []))
             if meta["t"].replace("/", "__") in keep_safe]

{boost_skill_cli-1.0.332.dist-info → boost_skill_cli-1.0.334.dist-info}/METADATA

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

{boost_skill_cli-1.0.332.dist-info → boost_skill_cli-1.0.334.dist-info}/RECORD

@@ -1,6 +1,6 @@
 boost_cli/__init__.py,sha256=e93dOJMl_tHyLowLz55AKh4ts4mzBiLdAezQcKIU3XU,1196
 boost_cli/__main__.py,sha256=40c3JGxDOKeEEdfKw5o6A8E_rhK9fFv8AYlmd-ngtcI,119
-boost_cli/_version.py,sha256=wO0IQXH4-Dp8_deWL43Rd61Ow1CrbbyoiHwdv8568Qc,524
+boost_cli/_version.py,sha256=HAkpyNl7P13QMLknzYBKsKEpdzqP5XJchWEGYPR5o7s,524
 boost_cli/cli.py,sha256=qjDgTkvrTbaqgc9LApvDtHENkewrzN3XT8TU3UloKh0,14071
 boost_cli/cliparse.py,sha256=LTm5giUv9EMpCHkP7pkQZrJufurJjxH51ZAPlL62rm4,1156
 boost_cli/errors.py,sha256=hrrbdy5MMlPo_N_BztyjKKRdOY3CyoNR7NoZbpeDoyI,319
@@ -9,7 +9,7 @@ boost_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 boost_cli/commands/_common.py,sha256=15IIIC-UoX3kImYjmv_k7Xjgiq51MGcxlGEM_It-LZY,1053
 boost_cli/commands/bmad.py,sha256=0o5L_WyEMDvQfMBER719NnjYi9X5AFEvTH-ISFVRIeA,14617
 boost_cli/commands/configuration.py,sha256=jKw5gbXbYpke0J6SHuCpuwvlHDokVVIiQPRt5wsqBU8,48584
-boost_cli/commands/discovery.py,sha256=7pieTNpx05oKd-VxbL20HklK8e4Q0Ul6gGtYfzgPH90,46311
+boost_cli/commands/discovery.py,sha256=huSkDUGOXTd3G0IMmCxtu2_KjGQtSv_G3ygF1YYJOxE,48249
 boost_cli/commands/hooks.py,sha256=3B-vBEQtPkZNNdFzTlhOXwYDwZ8oA4fi_uzOBhoKq3M,3709
 boost_cli/commands/info.py,sha256=ZUvum7AOSW6REuMl6znIVNj17uEkJIR3p8xACIZRSH0,33446
 boost_cli/commands/intelligence.py,sha256=ckiOTXt50JeNU5Iy4jFWq04hcgBWHnSA3jYD3nVJhKY,41361
@@ -27,7 +27,7 @@ boost_cli/core/capabilities.py,sha256=P37nPwWA9VLxHmydrNhLcC5Yql-goNBiPtPywpViJZ
 boost_cli/core/catalog.py,sha256=IdyqK__IjjlO4knb4DTAUzv02ySNb7MlQShga8DC3Zs,15362
 boost_cli/core/claude_settings.py,sha256=vyBEHzvBDdmAAjLGAl2HM3eyy2XgfjWEyRbdhI0yKuY,7203
 boost_cli/core/config.py,sha256=tq6cgwx1yP7N90S5DniBjCRCQ1mvRk3fImBrZXBLt04,7782
-boost_cli/core/dense.py,sha256=UbOzPlMhn8ZO8-FQt69QHxkYVCn_psgw01DTzTBrsHU,18911
+boost_cli/core/dense.py,sha256=rxr7g-EW31vO4YZ3wN74Mvp4D26TgOGUk0hBXwSXK6c,24306
 boost_cli/core/ed25519.py,sha256=bpYtV3Nah54JPVHC7h2JWqlEi1P7-hbEvQBKfnuxmgI,4356
 boost_cli/core/embed.py,sha256=e0ARIJHKkT_bl40ZqCjpgq2puIoJ1qBW0DEqltLusuQ,10127
 boost_cli/core/faithfulness.py,sha256=hVFyyvfdbrFmTLzQw1k95r8XkVZ04y2hU9QsEBMmuCk,5025
@@ -51,7 +51,7 @@ boost_cli/core/paths.py,sha256=2mxatbdoAjhYfqZG93AsiQpqA2bkWYejIqlblLt-txQ,5056
 boost_cli/core/policy.py,sha256=yhcdJMB_oiViJPzj3rbI-AO1RFJusflT_oDqv9s-wgY,4902
 boost_cli/core/projectlock.py,sha256=ca2F6BGQ86WQtbpnwIgVFGC_eX6yr7aI47Ha9-VkR2g,4145
 boost_cli/core/provenance.py,sha256=19yRALM-Qw8YrA-Ih_ifXw1BFFAPDpn_I2OdT1okmQc,6406
-boost_cli/core/rag.py,sha256=SNNvFmlMeGN2ZS7aqTndQa6S4sZMFL_dJwjE9AVQWtg,34158
+boost_cli/core/rag.py,sha256=mBGo6LAnX2_rfAE4HtKnyLuWaEABGhsCojvBnV6vA0M,35050
 boost_cli/core/registry.py,sha256=Y7ACBYfzhL4u4F3XfR9_kaGE1NvI-BidoEpgqhNzh0c,6236
 boost_cli/core/resolve.py,sha256=CgID8mLp7ND6r3wDPW5C_9vF8d-MiMJDfs5yrezjiGo,5949
 boost_cli/core/rules.py,sha256=x1QT1Egtbqwdb0yKvBnsSku4T6OfUDLiC_7-lKzI2RI,6541
@@ -68,9 +68,9 @@ boost_cli/core/updatediff.py,sha256=l75sqZOl3XjZUMaDxdVexZMix5Scpc7KXfhHZbtWNig,
 boost_cli/core/util.py,sha256=4zKmrfwzbn7hM08u1uxXi7bIOFJUPWMxTtAATtMMgYA,11636
 boost_cli/core/workflows.py,sha256=Ri1ieUWzHxPaSqFHHzLLTPqlfMlWxDg_ML3Qxz5XFeU,6761
 boost_cli/data/registries.json,sha256=PZaYT1ptBmn8U3eaO-neU9g0Idmu2BlqSSiMegYpfbE,167072
-boost_skill_cli-1.0.332.dist-info/licenses/LICENSE,sha256=U7k4Yv7aA3f8h2SW-CEvTi_kaucMxK5hXrUJjPXKjhs,35102
-boost_skill_cli-1.0.332.dist-info/METADATA,sha256=tiV70gYf25Uc5FXcicXabqBk_5bBDaJb9uXELi5sBpM,64715
-boost_skill_cli-1.0.332.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-boost_skill_cli-1.0.332.dist-info/entry_points.txt,sha256=PqQTs8HnTuDi8oeUyaAryqwhBWukqBNwYnEkgR6YzJw,45
-boost_skill_cli-1.0.332.dist-info/top_level.txt,sha256=RMTlws4vuWbyR6Xg8qEgPsS8xz9-ZYEK3RZ2_pOUKww,10
-boost_skill_cli-1.0.332.dist-info/RECORD,,
+boost_skill_cli-1.0.334.dist-info/licenses/LICENSE,sha256=U7k4Yv7aA3f8h2SW-CEvTi_kaucMxK5hXrUJjPXKjhs,35102
+boost_skill_cli-1.0.334.dist-info/METADATA,sha256=oESmfneD6tTuQ8Foaa2KhGC2vjdV70OcS2SFIRpydkY,64715
+boost_skill_cli-1.0.334.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+boost_skill_cli-1.0.334.dist-info/entry_points.txt,sha256=PqQTs8HnTuDi8oeUyaAryqwhBWukqBNwYnEkgR6YzJw,45
+boost_skill_cli-1.0.334.dist-info/top_level.txt,sha256=RMTlws4vuWbyR6Xg8qEgPsS8xz9-ZYEK3RZ2_pOUKww,10
+boost_skill_cli-1.0.334.dist-info/RECORD,,