boost-skill-cli 1.2.49__tar.gz → 1.2.51__tar.gz

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/CLAUDE.md

@@ -534,6 +534,18 @@ Consequences for code you write here:
   the measured trade is **3.40 GB → 3.87 GB (+14%), in 1360 s**, peaking at
   ~2× while both copies coexist. Don't describe it as size-neutral — an earlier
   draft of this section did, from prediction rather than measurement.
+- **Embedding reports progress and commits as it goes.** `dense.build` takes
+  `on_progress(done, total)` and `_embed_and_store` commits every
+  `_COMMIT_EVERY` rows. Both are bug fixes, not polish: a full catalogue is
+  tens of thousands of distinct chunks under one fixed spinner label, which a
+  user reported as a hang after hours; and every row used to land in a single
+  transaction that committed after the last one, so an interrupt threw away the
+  whole build. Periodic commits are safe because `build` deletes each changed
+  tap's rows *before* re-inserting, so a partial store is replaced rather than
+  doubled. The total counts **distinct** texts, not rows — 42.9% of chunks on a
+  real install are repeats and are embedded once — so a progress total taken
+  from row count would over-report the work.
+
 - **Nothing on the search path may count `chunks`.** `SELECT COUNT(*)` scans the
   `chunks_tap` covering index — 8,419 pages / 34.5 MB, measured 1.94 s — and
   both `ready()` and `status()` did it on every search, the latter only to word

{boost_skill_cli-1.2.49/boost_skill_cli.egg-info → boost_skill_cli-1.2.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.49
+Version: 1.2.51
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.49'
-__version_tuple__ = version_tuple = (1, 2, 49)
+__version__ = version = '1.2.51'
+__version_tuple__ = version_tuple = (1, 2, 51)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/boost_cli/commands/configuration.py

@@ -1450,30 +1450,46 @@ def _mcp_tool(tool: str, args: dict):
     return REGISTRY.call(tool, args)
 
 
-def _run_mcp_host(host: str, action: str, cmd) -> bool:
-    """Run one host's register/unregister argv. True if it actually ran.
+#: Substrings an agent CLI uses to say "this server is already registered".
+#: Registering twice is not a failure — it is the state the user asked for —
+#: and treating it as one is what made `--host auto` abort on host one and
+#: never reach host two on any machine where boost was already in Claude.
+_ALREADY = ("already exists", "already registered", "already configured")
 
-    A host whose CLI is not installed is *not* an error — most machines have
-    one agent CLI, not all of them — so the argv is printed for the user to run
-    later and the caller moves on to the next host. A CLI that is present and
-    fails is a real error and raises.
+
+def _run_mcp_host(host: str, action: str, cmd) -> tuple[str, str]:
+    """Run one host's register/unregister argv.
+
+    Returns ``(status, detail)`` where status is:
+
+    * ``"ran"``      — the CLI ran and succeeded;
+    * ``"already"``  — it reported the server is already in the state asked
+      for, which is success with a different wording;
+    * ``"missing"``  — the CLI is not installed. Not an error: most machines
+      have one agent CLI, not all of them;
+    * ``"failed"``   — it is installed and something else went wrong.
+
+    It **returns** rather than raises so one host cannot end the sweep. That
+    was the bug: a present CLI exiting non-zero raised straight out of the
+    loop, so with boost already registered in Claude, `--host auto` died on
+    "already exists" and never reached the second agent.
     """
     exe = mcphost.cli(host)
     if not shutil.which(exe):
-        return False
+        return "missing", ""
     try:
         proc = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
     except (OSError, subprocess.TimeoutExpired) as e:
-        raise BoostError("%s mcp %s failed: %s" % (exe, action, e),
-                        hint="run it yourself: " + " ".join(cmd)) from e
+        return "failed", str(e)
     for ln in (proc.stdout or "").strip().splitlines():
         out.info(ln)
-    if proc.returncode != 0:
-        tail = (proc.stderr or "").strip().splitlines()
-        raise BoostError("%s mcp %s failed: %s"
-                        % (exe, action, tail[-1] if tail else "unknown error"),
-                        hint="run it yourself: " + " ".join(cmd))
-    return True
+    if proc.returncode == 0:
+        return "ran", ""
+    blob = ((proc.stderr or "") + (proc.stdout or "")).lower()
+    if action == "register" and any(k in blob for k in _ALREADY):
+        return "already", ""
+    tail = (proc.stderr or "").strip().splitlines()
+    return "failed", tail[-1] if tail else "unknown error"
 
 
 def _seed_catalog_for_mcp(force: bool) -> None:
@@ -1627,11 +1643,18 @@ def cmd_mcp(argv) -> int:
     # `all`) always reports it, so a user setting up a machine can see the argv
     # for an agent CLI they have not installed yet.
     explicit = args.host not in (None, "", "auto")
-    done, missing = [], []
+    done, already, missing, failed = [], [], [], {}
     for host in targets:
         cmd = mcphost.argv(host, args.action, shim)
-        if _run_mcp_host(host, args.action, cmd):
+        status, detail = _run_mcp_host(host, args.action, cmd)
+        if status == "ran":
             done.append(host)
+        elif status == "already":
+            already.append(host)
+        elif status == "failed":
+            # Collected, not raised: the next host is a different agent on a
+            # different config file and has nothing to do with this failure.
+            failed[host] = detail
         else:
             missing.append(host)
             if explicit:
@@ -1643,7 +1666,23 @@ def cmd_mcp(argv) -> int:
     for host in done:
         out.ok("%sed boost as an MCP server for %s (scope: user)"
                % (verb, mcphost.label(host)))
-    if not done:
+    for host in already:
+        out.ok("already registered with %s — nothing to do"
+               % mcphost.label(host))
+    for host, detail in failed.items():
+        out.warn("%s: %s mcp %s failed — %s"
+                 % (mcphost.label(host), mcphost.cli(host), args.action,
+                    detail))
+        out.info(out.role("run it yourself: %s"
+                          % " ".join(mcphost.argv(host, args.action, shim)),
+                          "muted"))
+    settled = done + already
+    if not settled:
+        if failed:
+            # Every installed CLI failed. That is a real error — but only after
+            # each one has been tried and named.
+            journal.log("mcp", args.action, hosts="")
+            return 1
         # Nothing ran. Under `auto` nothing has been printed yet, so say which
         # CLIs were looked for rather than exiting silently on success.
         if not explicit:
@@ -1654,8 +1693,10 @@ def cmd_mcp(argv) -> int:
         journal.log("mcp", args.action, hosts="")
         return 0
     if args.action == "register":
-        _offer_boost_first(done)
-    journal.log("mcp", args.action, hosts=",".join(done))
+        _offer_boost_first(settled)
+    journal.log("mcp", args.action, hosts=",".join(settled))
+    # Same rule as `boost update` across taps: a partial sweep is a success
+    # with a warning, because the hosts that worked really did work.
     return 0
 
 

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/boost_cli/commands/discovery.py

@@ -388,8 +388,8 @@ def cmd_reindex(argv):
         # holds — count, stats, trending, plain search. See the import-budget
         # gate (scripts/import_budget.py).
         from ..core import embed
-        with spin.Spinner("embedding chunks into the dense store"):
-            dense_stats = _reindex_dense(args.force)
+        with spin.Spinner("embedding chunks into the dense store") as sp:
+            dense_stats = _reindex_dense(args.force, spinner=sp)
     if args.as_json:
         print(json.dumps({"bm25": stats, "dense": dense_stats}
                          if args.dense else stats))
@@ -434,7 +434,44 @@ def cmd_reindex(argv):
     return 0
 
 
-def _reindex_dense(force):
+def _embed_progress(spinner):
+    """A callback that rewrites the spinner's label with real numbers.
+
+    Embedding is the longest thing boost does — tens of thousands of distinct
+    chunks at roughly a second each for a full catalogue — and it ran under a
+    fixed label for hours. "embedding chunks into the dense store" is
+    indistinguishable from a hang, which is exactly how it was reported.
+
+    The rate comes from this run rather than a constant, because the two
+    backends differ by an order of magnitude and a local model's throughput
+    depends on the machine. Until a batch has finished there is nothing to
+    estimate from, so it says the total and nothing else rather than guessing.
+    """
+    started = time.monotonic()
+
+    def report(done: int, total: int) -> None:
+        if spinner is None or not total:
+            return
+        pct = 100.0 * done / total
+        # The bar first, because it is the part that answers the question the
+        # user actually has — "is this moving?" — at a glance, before any of
+        # the digits are read. `spin.bar` is the same determinate bar the rest
+        # of the CLI draws, so this looks like boost rather than like a
+        # second progress convention.
+        label = "embedding %s %d%% · %s/%s chunks" % (
+            spin.bar(done, total, width=16), int(pct),
+            format(done, ","), format(total, ","))
+        elapsed = time.monotonic() - started
+        if done and elapsed > 1:
+            remaining = (total - done) * (elapsed / done)
+            if remaining >= 1:
+                label += " · ~%s left" % util.human_duration(remaining)
+        spinner.label = label
+
+    return report
+
+
+def _reindex_dense(force, spinner=None):
     """Build the dense vector store; returns stats or None when unavailable."""
     # Local import: the dense/embedding engines are opt-in (`search --dense`),
     # so they stay out of startup for every other command in this module.
@@ -447,7 +484,7 @@ def _reindex_dense(force):
     # only what changed. Doing it after would quantize, then write float32 rows
     # into a store that no longer has a float32 table.
     migrated = dense.quantize()
-    stats = dense.build(force=force)
+    stats = dense.build(force=force, on_progress=_embed_progress(spinner))
     if migrated and isinstance(stats, dict):
         stats = stats | {"quantized": migrated["chunks"]}
     return stats

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/boost_cli/core/dense.py

@@ -25,6 +25,11 @@ from .rag import Hit, chunk, entry_key, read_body
 
 INDEX_VERSION = 2
 _BATCH = 128            # texts per embedding request
+
+#: Rows between commits while storing vectors. Small enough that an interrupted
+#: build keeps almost everything it embedded, large enough that the commits are
+#: not the cost — on a 750k-chunk store this is ~150 commits.
+_COMMIT_EVERY = 5000
 _POOL = 8              # chunk over-fetch factor for KNN before per-entry reduce
 
 
@@ -462,12 +467,20 @@ def ready() -> bool:
         con.close()
 
 
-def build(entries: list[dict] | None = None,
-          force: bool = False) -> dict | None:
+def build(entries: list[dict] | None = None, force: bool = False,
+          on_progress=None) -> dict | None:
     """(Re)embed and store chunk vectors, reusing unchanged taps.
 
     Returns stats, or ``None`` if the backend or an embeddings provider is
     unavailable (nothing is written in that case).
+
+    ``on_progress(done, total)`` is called before the first batch and after
+    each one. It exists because this is the longest-running thing boost does —
+    a full catalogue is tens of thousands of distinct chunks at roughly a
+    second each — and it used to run under a bare spinner that said "embedding
+    chunks into the dense store" for hours without a number. A user cannot
+    tell that apart from a hang, and the honest fix is to say how many there
+    are and how far in we got.
     """
     from .rag import _tap_commits, _tap_paths
     if not have_backend() or not embed.available():
@@ -517,7 +530,8 @@ def build(entries: list[dict] | None = None,
         removed_taps = sorted(_indexed_taps(con) - {e["tap"] for e in entries})
         _delete_taps(con, changed_taps + removed_taps)
 
-        added, failed_taps = _embed_and_store(con, fresh, tap_paths)
+        added, failed_taps = _embed_and_store(con, fresh, tap_paths,
+                                             on_progress=on_progress)
         # 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
@@ -743,8 +757,8 @@ def _delete_taps(con: sqlite3.Connection, taps: list[str]) -> None:
 
 
 def _embed_and_store(con: sqlite3.Connection, entries: list[dict],
-                     tap_paths: dict[str, Path] | None
-                     ) -> tuple[int, set]:
+                     tap_paths: dict[str, Path] | None,
+                     on_progress=None) -> tuple[int, set]:
     """Embed every chunk of ``entries``; returns ``(added, failed_taps)``.
 
     A batch the provider rejects (rate limit, quota, oversized input) yields no
@@ -778,15 +792,31 @@ def _embed_and_store(con: sqlite3.Connection, entries: list[dict],
             order.append(text)
 
     vec_of: dict[str, object] = {}
+    if on_progress is not None:
+        # Reported before the first request, so the size of the job is known
+        # up front rather than inferred from how long it has already taken.
+        on_progress(0, len(order))
     for start in range(0, len(order), _BATCH):
         batch = order[start:start + _BATCH]
         vecs = embed.embed(batch, input_type="document")
-        if not vecs or len(vecs) != len(batch):
-            continue     # taps are attributed per row below, not per batch
-        vec_of.update(zip(batch, vecs, strict=True))
+        if vecs and len(vecs) == len(batch):
+            vec_of.update(zip(batch, vecs, strict=True))
+        # else: taps are attributed per row below, not per batch — but the
+        # progress count still advances, or a run with a few rejected batches
+        # would appear to stall.
+        if on_progress is not None:
+            on_progress(min(start + _BATCH, len(order)), len(order))
 
     added = 0
     failed_taps: set = set()
+    # Durability, not speed. Every row used to land in one transaction that
+    # committed only after the last one, so interrupting a three-hour build —
+    # or losing the machine to a sleep or an OOM — threw away every vector it
+    # had paid for. Committing as the rows accumulate keeps the work, and
+    # re-running is still correct because `_delete_taps` has already removed
+    # each changed tap's old rows, so a partial store is replaced rather than
+    # doubled.
+    since_commit = 0
     for e, ci, text in rows:
         vec = vec_of.get(text)
         if vec is None:
@@ -801,6 +831,11 @@ def _embed_and_store(con: sqlite3.Connection, entries: list[dict],
              e.get("kind", "skill"), ci, text[:200].strip()))
         _store_vector(con, cur.lastrowid, mod.serialize_float32(vec))
         added += 1
+        since_commit += 1
+        if since_commit >= _COMMIT_EVERY:
+            con.commit()
+            since_commit = 0
+    con.commit()
     return added, failed_taps
 
 

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/boost_cli/core/util.py

@@ -168,6 +168,23 @@ def rel_time(iso: str) -> str:
     return then.strftime("%Y-%m-%d")
 
 
+def human_duration(seconds: float) -> str:
+    """A short, honest duration: ``'45s'``, ``'12m'``, ``'2h 5m'``.
+
+    Coarse on purpose. This labels an estimate that is extrapolated from a
+    partial run, so seconds of precision on a two-hour figure would claim an
+    accuracy the number does not have.
+    """
+    seconds = max(0, int(seconds))
+    if seconds < 60:
+        return "%ds" % seconds
+    minutes = seconds // 60
+    if minutes < 60:
+        return "%dm" % minutes
+    hours, minutes = divmod(minutes, 60)
+    return "%dh %dm" % (hours, minutes) if minutes else "%dh" % hours
+
+
 def human_size(n: int) -> str:
     """Format a byte count for humans: ``1536`` -> ``'1.5KB'``.
 

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.49
+Version: 1.2.51
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/boost_skill_cli.egg-info/SOURCES.txt

@@ -682,6 +682,7 @@ tests/unit/test_dense.py
 tests/unit/test_dense_embed_dedupe.py
 tests/unit/test_dense_fallback.py
 tests/unit/test_dense_fix_hint.py
+tests/unit/test_dense_progress.py
 tests/unit/test_dense_quantized.py
 tests/unit/test_dense_ready_order.py
 tests/unit/test_dense_shard_real_schema.py

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/tests/bdd/features/mcp.feature

@@ -53,7 +53,8 @@ Feature: boost mcp
     Given the "claude" CLI is on PATH but fails with "no auth"
     When I run "boost mcp register"
     Then the exit code should be 1
-    And the output should contain "claude mcp register failed: no auth"
+    And the output should contain "claude mcp register failed — no auth"
+    And the output should contain "run it yourself"
 
   Scenario: unregistering with no agent CLI prints both manual commands
     Given no agent CLI is on PATH

{boost_skill_cli-1.2.49 → boost_skill_cli-1.2.51}/tests/functional/test_cli_configuration.py

@@ -1470,6 +1470,73 @@ class TestMcp:
         assert "could not reach any default registry" in r.out + r.err
         assert "registered boost as an MCP server" in r.out
 
+    def _clis_with_results(self, monkeypatch, results):
+        """CLIs on PATH, each answering with (returncode, stderr).
+
+        Returns the list of CLI names actually invoked, which is the whole
+        question these tests ask: did the sweep reach the second host?
+        """
+        monkeypatch.setattr(
+            "boost_cli.commands.configuration.shutil.which",
+            lambda c: "/usr/local/bin/" + c if c in results else None)
+        seen = []
+
+        class _P:
+            def __init__(self, rc, err):
+                self.returncode, self.stderr, self.stdout = rc, err, ""
+
+        def fake_run(cmd, **kw):
+            seen.append(cmd[0])
+            return _P(*results[cmd[0]])
+
+        monkeypatch.setattr("boost_cli.commands.configuration.subprocess.run",
+                            fake_run)
+        return seen
+
+    def test_one_host_already_registered_does_not_end_the_sweep(
+            self, boost, sandbox, monkeypatch):
+        # The reported bug: with boost already in Claude, `--host auto` raised
+        # on "already exists" and never reached the second agent. Registering
+        # twice is the state the user asked for, not a failure.
+        seen = self._clis_with_results(monkeypatch, {
+            "claude": (1, "MCP server boost already exists in local config"),
+            "gemini": (0, ""),
+        })
+        r = boost("mcp", "register", "--no-seed")
+        assert seen == ["claude", "gemini"], seen
+        assert "already registered with Claude Code" in r.out
+        assert "registered boost as an MCP server for Gemini CLI" in r.out
+
+    def test_a_real_failure_on_one_host_still_reaches_the_next(
+            self, boost, sandbox, monkeypatch):
+        seen = self._clis_with_results(monkeypatch, {
+            "claude": (1, "connection refused"),
+            "gemini": (0, ""),
+        })
+        r = boost("mcp", "register", "--no-seed")
+        assert seen == ["claude", "gemini"], seen
+        both = r.out + r.err
+        # Named, with the argv to run by hand — and the host that worked still
+        # reported as working.
+        assert "connection refused" in both
+        assert "run it yourself" in both
+        assert "Gemini CLI" in both
+
+    def test_every_installed_host_failing_is_an_error(
+            self, boost, sandbox, monkeypatch):
+        # A partial sweep is a success with a warning; nothing working at all
+        # is not.
+        self._clis_with_results(monkeypatch, {"claude": (1, "boom")})
+        boost("mcp", "register", "--no-seed", expect=1)
+
+    def test_already_is_not_swallowed_for_unregister(
+            self, boost, sandbox, monkeypatch):
+        # "already exists" only means success when registering. On the way out
+        # it would be nonsense, so it stays a failure.
+        self._clis_with_results(monkeypatch,
+                                {"claude": (1, "already exists")})
+        boost("mcp", "unregister", expect=1)
+
     def test_an_unknown_host_fails_before_touching_the_network(
             self, boost, sandbox, monkeypatch):
         # Seeding used to run first, so a typo'd --host spent 14-45s and half
@@ -1647,11 +1714,15 @@ class TestMcp:
                             lambda c: "/usr/local/bin/" + c)
         monkeypatch.setattr("boost_cli.commands.configuration.subprocess.run",
                             lambda cmd, **kw: _proc(cmd, 1, err="no auth"))
+        # Every installed host failing is the one case that is still an error;
+        # the failure is now reported per host on stdout, with the argv, rather
+        # than raised out of the loop and killing the sweep.
         r = boost("mcp", "register", expect=1)
-        assert "claude mcp register failed: no auth" in r.err
+        assert "claude mcp register failed — no auth" in r.out
+        assert "run it yourself" in r.out
         # the failing host names itself — not a generic "an agent CLI failed"
         r = boost("mcp", "register", "--host", "gemini", expect=1)
-        assert "gemini mcp register failed: no auth" in r.err
+        assert "gemini mcp register failed — no auth" in r.out
 
 
 # ---------------------------------------------------------------- self-update