boost-skill-cli 1.2.133__tar.gz → 1.2.134__tar.gz

{boost_skill_cli-1.2.133 → boost_skill_cli-1.2.134}/CLAUDE.md

@@ -83,14 +83,19 @@ can't flake the build, tight enough to catch a collapse. Regression-vs-baseline
 stays relaxed (`--regression-eps 1`), so the absolute floors are the real gate.
 
 **Every row of `taps.txt` pins a commit SHA**, and `scripts/eval_corpus.py`
-checks each clone out at it — the corpus is 10,731 entries, of which one
-third-party repo is 6,634 (62%), so an unpinned list left a required check
-hostage to someone else's push. CI and `make eval` must invoke the gate with
-identical arguments, not just identical floors — `-k` decides what two of them
-measure; `tests/unit/test_eval_corpus.py` parses both calls and fails the build
-if they diverge, which they had (CI floored recall alone at 0.85 against a
-measured 0.863 — a buffer of 1.15 queries out of 91 — and applied none of the
-other three). Moving a pin means regenerating the baseline; the file says how.
+checks each clone out at it — most of the corpus is one third-party repo, so an
+unpinned list left a required check hostage to someone else's push. The size
+and that share are stated once, in a block at the top of `taps.txt` that
+`--relock` and `--refresh` write from the rows; the sizes and the twenty-repo
+scores quoted above (and in the `Makefile` and `docs/eval.html`) are checked
+against the rows and `baseline.json` by `tests/unit/test_corpus_prose.py`,
+because the monthly refresh moves both and nothing else would notice. CI and
+`make eval` must invoke the gate with identical arguments, not just identical
+floors — `-k` decides what two of them measure; `tests/unit/test_eval_corpus.py`
+parses both calls and fails the build if they diverge, which they had (CI
+floored recall alone at 0.85 against a measured 0.863 — a buffer of 1.15
+queries out of 91 — and applied none of the other three). Moving a pin means
+regenerating the baseline; the file says how.
 
 **Baselines are keyed by query set** (`name@content-digest`), so one file holds
 both `golden.jsonl` and `golden-natural.jsonl` without either overwriting the
@@ -631,7 +636,15 @@ backend, built store) is missing — or `disabled`, a fourth state that is no
 missing link at all but the `BOOST_NO_EMBED` kill switch, which sits **first**
 in the ladder (`embed.provider()` reads it before any key, so every other
 remedy is a measured no-op under it) and is excluded from `degraded`, so a
-deliberate opt-out never moves doctor's exit code. `dense.fix_hint()` maps
+deliberate opt-out never moves doctor's exit code. `model-unavailable` is the
+**last** rung: the store matches, but the local model could not be fetched or
+loaded. `status()` reads a record of that failure and never probes, because
+the probe *is* the 133 MB fetch. `core/localembed.py` keeps the record in
+memory and in `cache/models/<rev>/unavailable.json`, and holds back the next
+attempt for an hour (`RETRY_AFTER`): measured on a 5-chunk store, each search
+paid one failed fetch (~3.6 s against 0.1 s) while doctor said "active".
+`boost reindex --dense` retries at once, because it is the remedy the hint
+names. `dense.ready()` still answers for the store alone. `dense.fix_hint()` maps
 whichever state it is to the one next action — `boost doctor`, `boost search`,
 the MCP `SEARCH ENGINE` line and both shard surfaces (`reindex --fetch-shards`,
 `update --shards`) all read that same table, so they can't give contradictory

{boost_skill_cli-1.2.133/boost_skill_cli.egg-info → boost_skill_cli-1.2.134}/PKG-INFO

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

{boost_skill_cli-1.2.133 → boost_skill_cli-1.2.134}/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.133'
-__version_tuple__ = version_tuple = (1, 2, 133)
+__version__ = version = '1.2.134'
+__version_tuple__ = version_tuple = (1, 2, 134)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.133 → boost_skill_cli-1.2.134}/boost_cli/cli.py

@@ -82,7 +82,7 @@ COMMANDS = [
     ("preview",     "info", "info", "Render a SKILL.md with rich formatting"),
     ("explain",     "info", "info", "Explain what a skill does in plain English"),
     ("log",         "info", "info", "Git log for a skill, or boost's activity log"),
-    ("home",        "info", "info", "Open a skill's GitHub page in the browser"),
+    ("home",        "info", "info", "Open an item's GitHub page in the browser"),
     ("deps",        "info", "info", "Show dependency & conflict relationships"),
     ("tag",         "info", "info", "Custom labels for organizing skills"),
     # Registry (Taps) (5)
@@ -113,7 +113,7 @@ COMMANDS = [
     ("decay",       "chk", "quality", "Flag skills irrelevant to your current stack"),
     ("heal",        "chk", "quality", "Self-diagnose & repair the boost environment"),
     ("conflict",    "chk", "quality", "Detect contradictory rules between skills"),
-    ("changelog",   "chk", "quality", "Show a skill's upstream change history"),
+    ("changelog",   "chk", "quality", "Show an item's upstream change history"),
     ("attest",      "chk", "safety", "Display/verify the install record for skills"),
     ("health",      "chk", "quality", "Dashboard of skill-environment health"),
     ("trust",       "chk", "quality", "Manage signing keys & verify tap provenance"),

{boost_skill_cli-1.2.133 → boost_skill_cli-1.2.134}/boost_cli/commands/discovery.py

@@ -473,7 +473,7 @@ def _fetch_shards(args) -> int:
     why = shards.incompatible(manifest)
     if why:
         raise BoostError("published shards cannot serve this machine — %s" % why,
-                        hint=dense.fix_hint(dense.status().get("reason", "")))
+                        hint=shards.remedy(manifest))
     commits = rag._tap_commits()
     stored = dense.tap_commits()
     by_name = {t.name: commits.get(t.safe_name, "") for t in registry.list_taps()}
@@ -620,12 +620,28 @@ def cmd_reindex(argv):
                      wrap=True)
         else:
             failed = dense_stats.get("failed") or []
+            model_error = dense_stats.get("model_error")
+            if model_error:
+                # Before the per-tap line, and instead of its guess at a
+                # cause: "rate limit, quota" describes an API provider, and
+                # sent a local-model user looking for an account they lack.
+                # A load failure is not a network problem, so it is not told
+                # to find a better network.
+                tail = ("" if model_error.get("stage") == "load" else
+                        "; rerun `boost reindex --dense` on a network that "
+                        "reaches huggingface.co")
+                out.warn("%s — searches use BM25 until it works%s"
+                         % (embed.local_failure_text(model_error), tail),
+                         wrap=True)
             if failed:
-                out.warn("embedding failed for %d tap(s) — %d passages stored. "
+                cause = ("The local model could not be used"
+                         if model_error else
                          "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"]))
+                         "quota, or oversized input)")
+                out.warn("embedding failed for %d tap(s) — %d passages stored. "
+                         "%s; their commits were not recorded, so a rerun "
+                         "retries them." % (len(failed), dense_stats["chunks"],
+                                            cause))
             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
@@ -729,11 +745,21 @@ def _reindex_dense(force, spinner=None):
     # free — they re-encode and re-key what is already on disk — so a user gets
     # the disk back without having to know either word.
     collapsed = dense.deduplicate()
+    # This command is the remedy `dense.fix_hint` names for a local model that
+    # could not be fetched, so it must actually try: searches hold a retry
+    # back for an hour after a failure, and a build whose taps are all reused
+    # embeds nothing and would otherwise never touch the model at all.
+    embed.retry_local()
     stats = dense.build(force=force, on_progress=_embed_progress(spinner))
     if migrated and isinstance(stats, dict):
         stats = stats | {"quantized": migrated["chunks"]}
     if collapsed and isinstance(stats, dict) and collapsed["freed"]:
         stats = stats | {"deduplicated": collapsed["freed"]}
+    # Read after the build, not from the retry: a first build on a machine
+    # that cannot fetch the model has nothing to retry and fails inside it.
+    failure = embed.local_failure() if embed.provider() == "local" else None
+    if failure and isinstance(stats, dict):
+        stats = stats | {"model_error": failure}
     return stats
 
 

{boost_skill_cli-1.2.133 → boost_skill_cli-1.2.134}/boost_cli/commands/info.py

@@ -573,7 +573,11 @@ def cmd_info(argv):
     # one file this item actually is.
     src = lock.get("source_dir") if lock else (
         (cat or {}).get("skill_md") if kind != "skill" else (cat or {}).get("rel_dir"))
-    if src:
+    if lock and lock.get("source_url"):
+        # A URL import's source_dir is a path inside that repo, not on disk.
+        out.kv("source", str(lock["source_url"])
+               + ("" if src in (None, "", ".") else " (%s)" % src))
+    elif src:
         out.kv("source", _tilde(src))
     if lock:
         if lock.get("commit"):
@@ -1028,30 +1032,34 @@ def cmd_log(argv):
 
 def cmd_home(argv):
     ap = cliparse.parser(prog="boost home",
-                                 description="Open a skill's GitHub page in the browser")
+                                 description="Open an item's GitHub page in the browser")
     ap.add_argument("name")
     ap.add_argument("--print", dest="print_only", action="store_true",
                     help="print the URL without opening a browser")
     args = ap.parse_args(argv)
-    found = lockfile.find_any(args.name)
-    lock = found[1] if found else None
-    try:
-        entry = catalog.resolve_one(args.name)
-        tap_name, rel = entry["tap"], entry["rel_dir"]
-    except BoostError:
-        if not lock:
-            raise
-        tap_name = lock.get("tap", "local")
-        rel = lock.get("source_dir") or lock.get("source_file") or "."
+    # Lock first: the catalog guesses by name, the lock knows the copy that
+    # was installed. A rule or workflow is linked to its own file.
+    _bare, kind, tap_name, rel = store.upstream_source(args.name)
     try:
         tap = registry.get(tap_name)
     except BoostError:
-        out.info(_tilde(rel))   # local import — only a path to show
+        lock = store.resolve_lock_entry(args.name)[2]
+        home = str((lock or {}).get("source_url") or "")
+        if not home:
+            out.info(_tilde(rel))   # local import — only a path to show
+            return 0
+        # A URL import: the repo it was cloned from is its home.
+        out.info(home)
+        if (home.startswith(("http://", "https://")) and not args.print_only
+                and sys.stdout.isatty()):
+            webbrowser.open(home)
         return 0
     if not tap.url.startswith(("http://", "https://")):
         out.info(_tilde(Path(tap.url) if rel == "." else Path(tap.url) / rel))
         return 0
-    url = tap.url.rstrip("/") + ("" if rel == "." else "/tree/HEAD/" + rel)
+    # GitHub serves a directory under /tree/ and a file under /blob/.
+    view = "tree" if kind == "skill" else "blob"
+    url = tap.url.rstrip("/") + ("" if rel == "." else "/%s/HEAD/%s" % (view, rel))
     out.info(url)
     if not args.print_only and sys.stdout.isatty():
         webbrowser.open(url)