boost-skill-cli 1.2.194__tar.gz → 1.2.196__tar.gz

{boost_skill_cli-1.2.194 → boost_skill_cli-1.2.196}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.194
+Version: 1.2.196
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -451,6 +451,7 @@ on the left, the selected item's detail on the right.
 | `→` `←` | into and out of the detail pane, where `↑`/`↓` scroll it |
 | `⇥` | select, and multi-select for a batch install |
 | `^T` | cycle the match toggles without leaving the results |
+| `^G` | pick a category — counts per category, type a letter to jump, `↵` applies, `esc` cancels |
 | `↵` | install, in place, without leaving the browser |
 | `esc` | quit |
 
@@ -458,6 +459,19 @@ The query splits on spaces and every token must match, so `code review` narrows
 where `code` alone would not. Selection lives on `⇥` rather than space for
 exactly that reason, and `q` stays a character so `quality` is searchable.
 
+Matching is aligned, not just found. A token can skip letters, but the browser
+prefers runs and word starts: `bmadarch` reads as `bmad` + `arch` in
+`bmad-agent-architect`, not one letter fished out of each word, and that is what
+lights up and what ranks. In the name any such spelling still matches — `gitwf`
+finds `git-workflow` first — while in a description every piece must start a
+word and be three letters or more (`codrev` meets "code review"; `crv` does
+not), because over a long sentence letters scattered one per word match nearly
+everything.
+
+`^G` narrows to one category and the active one rides in the query as
+`#testing`; `boost browse --category testing` opens there, and `boost browse
+--categories` lists every category with its count.
+
 Duplicates are collapsed. Registries render one skill into `.claude/`,
 `.cursor/`, `.gemini/` and a plugin root, so on a real 60,047-entry catalogue
 22,535 rows (37%) are duplicates. Rows whose name and description match, or are

{boost_skill_cli-1.2.194 → boost_skill_cli-1.2.196}/README.md

@@ -409,6 +409,7 @@ on the left, the selected item's detail on the right.
 | `→` `←` | into and out of the detail pane, where `↑`/`↓` scroll it |
 | `⇥` | select, and multi-select for a batch install |
 | `^T` | cycle the match toggles without leaving the results |
+| `^G` | pick a category — counts per category, type a letter to jump, `↵` applies, `esc` cancels |
 | `↵` | install, in place, without leaving the browser |
 | `esc` | quit |
 
@@ -416,6 +417,19 @@ The query splits on spaces and every token must match, so `code review` narrows
 where `code` alone would not. Selection lives on `⇥` rather than space for
 exactly that reason, and `q` stays a character so `quality` is searchable.
 
+Matching is aligned, not just found. A token can skip letters, but the browser
+prefers runs and word starts: `bmadarch` reads as `bmad` + `arch` in
+`bmad-agent-architect`, not one letter fished out of each word, and that is what
+lights up and what ranks. In the name any such spelling still matches — `gitwf`
+finds `git-workflow` first — while in a description every piece must start a
+word and be three letters or more (`codrev` meets "code review"; `crv` does
+not), because over a long sentence letters scattered one per word match nearly
+everything.
+
+`^G` narrows to one category and the active one rides in the query as
+`#testing`; `boost browse --category testing` opens there, and `boost browse
+--categories` lists every category with its count.
+
 Duplicates are collapsed. Registries render one skill into `.claude/`,
 `.cursor/`, `.gemini/` and a plugin root, so on a real 60,047-entry catalogue
 22,535 rows (37%) are duplicates. Rows whose name and description match, or are

{boost_skill_cli-1.2.194 → boost_skill_cli-1.2.196}/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.194'
-__version_tuple__ = version_tuple = (1, 2, 194)
+__version__ = version = '1.2.196'
+__version_tuple__ = version_tuple = (1, 2, 196)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.194 → boost_skill_cli-1.2.196}/boost_cli/commands/discovery.py

@@ -8,6 +8,7 @@ Also exports detect_stack(), shared with the Quality commands.
 from __future__ import annotations
 
 import contextlib
+import gc
 import json
 import operator
 import os
@@ -1610,7 +1611,7 @@ def _install_targets() -> dict[str, str]:
     }
 
 
-def _browse_tui(curses, entries, install=None):
+def _browse_tui(curses, entries, install=None, category=""):
     """Run the curses UI. Returns the list of entries picked for install
     (one or more, via multi-select), or None if the user quit without picking.
 
@@ -1619,6 +1620,9 @@ def _browse_tui(curses, entries, install=None):
     it. Matches are ranked (:func:`browse.rank`). All of the geometry and all
     of the matching come from :mod:`core.browse`, which is where they can be
     tested — this function only draws and dispatches keys.
+
+    ``category`` opens the browser already narrowed to one category; ^G
+    switches it, or clears it, from inside.
     """
     state: dict[str, Any] = {"picks": None}
     categories = _tap_categories()
@@ -1635,6 +1639,12 @@ def _browse_tui(curses, entries, install=None):
     copies = {id(e): n for e, n in deduped}
     unique_entries = [e for e, _n in deduped]
     hidden = len(entries) - len(unique_entries)
+    # Everything allocated so far lives as long as the browser does, and the
+    # collector would otherwise walk all of it — every catalogue dict — on
+    # each gen-2 pass, which the ranking's per-keystroke tuples trigger.
+    # Measured over a 61,801-entry catalogue: a one-letter query 122 ms
+    # unfrozen, 52 ms frozen. Undone on the way out (see the finally below).
+    gc.freeze()
     # name -> (state, message). Item 1: an install runs without leaving the
     # browser, and the detail pane reports it. Threaded so the draw loop keeps
     # answering keys while files are written — an install that freezes the UI
@@ -1733,18 +1743,33 @@ def _browse_tui(curses, entries, install=None):
         filt, sel, detail = "", 0, True
         focus, scope, dscroll = "list", browse.SCOPES[0], 0
         collapse = True
+        cat = category
+        picker: dict | None = None     # {"rows", "sel"} while ^G is open
         selected: set = set()
         # One haystack per entry per scope, built on first use and reused for
         # every keystroke: re-deriving it inside the filter cost 125 ms per key
         # over 71,700 entries, which is slower than the draw poll.
         index: dict = {}
+        pools: dict = {}
+        # The result list, recomputed only when something it depends on
+        # changes. The loop wakes every 80 ms to redraw a finished lazy-load;
+        # re-filtering 42,000 rows on each of those ticks spent the CPU on
+        # an answer it already had.
+        memo: tuple = (None, [])
         while True:
             _h, _w = scr.getmaxyx()
-            pool = unique_entries if collapse else entries
-            key = (scope, collapse)
+            if (collapse, cat) not in pools:
+                pools[(collapse, cat)] = [
+                    e for e in (unique_entries if collapse else entries)
+                    if browse.in_category(e, cat, categories)]
+            pool = pools[(collapse, cat)]
+            key = (scope, collapse, cat)
             if key not in index:
                 index[key] = browse.index_entries(pool, scope, categories)
-            found = browse.matches_indexed(index[key], filt)
+            if memo[0] != (key, filt):
+                memo = ((key, filt),
+                        browse.matches_indexed(index[key], filt, scope))
+            found = memo[1]
             sel = max(0, min(sel, len(found) - 1))
             lay = browse.layout(_w, _h, detail=detail)
             try:
@@ -1752,15 +1777,20 @@ def _browse_tui(curses, entries, install=None):
                 # status.copy(): the worker thread owns the mapping; a shallow
                 # copy keeps the fold safe from a mid-iteration mutation.
                 _draw_frame(put, th, lay, focus)
-                _draw_status(put, th, lay, focus,
+                _draw_status(put, th, lay, "picker" if picker else focus,
                              browse.session_summary(status.copy()))
                 _draw_query(put, th, lay, filt, focus, len(found), len(pool),
-                            len(selected), hidden if collapse else 0)
+                            len(selected), hidden if collapse else 0, cat)
                 _draw_scopes(put, th, lay, scope, focus)
-                rows = _draw_rows(put, th, lay, found, sel, selected, filt,
-                                  focus, describe, categories, installed_names,
-                                  copies if collapse else None, status,
-                                  scope, hidden if collapse else 0)
+                if picker:
+                    rows = _draw_picker(put, th, lay, picker["rows"],
+                                        picker["sel"], cat)
+                else:
+                    rows = _draw_rows(put, th, lay, found, sel, selected,
+                                      filt, focus, describe, categories,
+                                      installed_names,
+                                      copies if collapse else None, status,
+                                      scope, hidden if collapse else 0, cat)
                 if lay.has_detail and found:
                     dscroll = _draw_detail(
                         put, th, lay, found[sel], dscroll, focus,
@@ -1773,6 +1803,36 @@ def _browse_tui(curses, entries, install=None):
             key = scr.getch()
             if key == -1:                                 # poll tick, no key
                 continue
+            if picker is not None:
+                # The picker owns every key while it is open: Esc closes it
+                # rather than quitting the browser behind it.
+                n = len(picker["rows"])
+                if key in (27, 7):                        # ESC / ^G: cancel
+                    picker = None
+                elif key in (10, 13, curses.KEY_ENTER):
+                    cat = picker["rows"][picker["sel"]][0]
+                    picker, sel, dscroll = None, 0, 0
+                elif key == curses.KEY_UP:
+                    picker["sel"] = max(0, picker["sel"] - 1)
+                elif key == curses.KEY_DOWN:
+                    picker["sel"] = min(n - 1, picker["sel"] + 1)
+                elif key == curses.KEY_PPAGE:
+                    picker["sel"] = max(0, picker["sel"] - max(1, rows))
+                elif key == curses.KEY_NPAGE:
+                    picker["sel"] = min(n - 1, picker["sel"] + max(1, rows))
+                elif 33 <= key <= 126:
+                    picker["sel"] = browse.picker_jump(picker["rows"],
+                                                       picker["sel"], chr(key))
+                continue
+            if key == 7:                                  # ^G: category
+                # Counted over the rows the browser is showing — collapsed or
+                # not — before any category, so every count is what picking
+                # it would leave.
+                rows_ = browse.picker_rows(
+                    unique_entries if collapse else entries, categories)
+                picker = {"rows": rows_,
+                          "sel": browse.picker_index(rows_, cat)}
+                continue
             if key == 9 and found:                        # TAB: multi-select
                 selected.symmetric_difference_update({_desc_key(found[sel])})
                 continue
@@ -1833,7 +1893,10 @@ def _browse_tui(curses, entries, install=None):
                 filt, sel, dscroll = filt + chr(key), 0, 0
                 focus = "search" if focus == "search" else focus
 
-    curses.wrapper(ui)  # wrapper guards drawing with try/finally endwin()
+    try:
+        curses.wrapper(ui)  # wrapper guards drawing with try/finally endwin()
+    finally:
+        gc.unfreeze()
     # Join before returning. The workers are daemons so the draw loop can exit
     # promptly, but a daemon dies with the process — quitting right after Enter
     # would abandon an install mid-write. `store.install` stages atomically, so
@@ -1926,21 +1989,28 @@ def _draw_status(put, th, lay, focus, summary=None):
         put(lay.status_y, x, text, th.get(role) or th.get("ok") or 0)
 
 
-def _draw_query(put, th, lay, filt, focus, n_found, n_all, n_sel, hidden=0):
-    """The query row: chevron, text, cursor when focused, right-aligned count.
+def _draw_query(put, th, lay, filt, focus, n_found, n_all, n_sel, hidden=0,
+                category=""):
+    """The query row: chevron, category chip, text, cursor when focused,
+    right-aligned count.
 
     ``hidden`` is stated, never implied: a browser that quietly drops a third of
     the catalogue and shows a smaller total is indistinguishable from one with a
-    broken filter.
+    broken filter. The category chip sits where the query starts for the same
+    reason — it narrows as much as the text does, so it reads as part of it.
     """
     active = focus == "search"
     put(1, 2, "❯", th["prompt"] if active else th["border"])
-    put(1, 4, filt or "type to filter…",
+    chip = browse.query_chip(category)
+    qx = 4 + (len(chip) + 1 if chip else 0)
+    if chip:
+        put(1, 4, chip, th["category"])
+    put(1, qx, filt or "type to filter…",
         th["query"] if filt else th["help"])
     if active:
-        put(1, 4 + len(filt), "▏", th["prompt"])
+        put(1, qx + len(filt), "▏", th["prompt"])
     tail = browse.count_tail(n_found, n_all, n_sel, hidden)
-    put(1, max(4 + len(filt) + 2, lay.w - 2 - len(tail)), tail, th["count"])
+    put(1, max(qx + len(filt) + 2, lay.w - 2 - len(tail)), tail, th["count"])
 
 
 def _draw_scopes(put, th, lay, scope, focus):
@@ -1972,7 +2042,7 @@ def _draw_scopes(put, th, lay, scope, focus):
 
 def _draw_rows(put, th, lay, found, sel, selected, filt, focus,
                describe, categories, installed_names, copies=None,
-               status=None, scope="all", hidden=0):
+               status=None, scope="all", hidden=0, category=""):
     """The result list. Returns how many rows fit, for page-up/down.
 
     Columns inside the pane: the ``▌`` selection bar, the ✓ multi-select
@@ -1987,7 +2057,7 @@ def _draw_rows(put, th, lay, found, sel, selected, filt, focus,
         # A silent void is indistinguishable from a hung draw; the pane says
         # what happened and which keys widen the net (see browse.empty_lines).
         for i, (role, text) in enumerate(browse.empty_lines(filt, scope,
-                                                            hidden)):
+                                                            hidden, category)):
             y = lay.body_y + 1 + i
             if y >= bottom:
                 break
@@ -2064,6 +2134,33 @@ def _draw_rows(put, th, lay, found, sel, selected, filt, focus,
     return rows
 
 
+def _draw_picker(put, th, lay, rows, sel, category):
+    """The ^G category picker, drawn over the list pane. Returns how many rows
+    fit, for page-up/down.
+
+    Over the list rather than in a window of its own: the query, the count and
+    the detail pane stay where they were, so picking a category reads as
+    changing a filter, not as leaving the browser.
+    """
+    lw = lay.list_w
+    put(lay.body_y, lay.list_x + 2, "category", th["head"])
+    visible = max(1, lay.bottom - lay.body_y - 2)
+    top = browse.picker_top(sel, len(rows), visible)
+    for i, (cat, n) in enumerate(rows[top:top + visible]):
+        y = lay.body_y + 2 + i
+        if y >= lay.bottom:
+            break
+        chosen = top + i == sel
+        line = browse.picker_line(cat, n, max(0, lw - 3),
+                                  cat == category.strip().lower())
+        if chosen:
+            put(y, lay.list_x, " " * lw, th["row_sel"])
+            put(y, lay.list_x, "▌", th["sel_bar"])
+        put(y, lay.list_x + 2, line,
+            th["row_sel_name"] if chosen else th["value"])
+    return visible
+
+
 #: Detail-pane role -> theme key, for roles whose names differ.
 _DETAIL_ROLE_KEYS = {"title": "detail_name", "desc": "value", "ok": "ok_line"}
 
@@ -2108,31 +2205,58 @@ def _draw_detail(put, th, lay, entry, dscroll, focus, installed_names,
     return dscroll
 
 
+def _print_categories(entries, categories) -> int:
+    """``boost browse --categories``: each category and its item count, over
+    the deduplicated catalogue — the numbers the ^G picker shows."""
+    unique = [e for e, _n in browse.dedupe(entries)]
+    out.heading("%d categories · %s items" % (
+        len(browse.category_counts(unique, categories)),
+        format(len(unique), ",")))
+    out.table([(c, format(n, ",")) for c, n in
+               browse.category_counts(unique, categories)],
+              headers=("category", "items"), whole=("category",))
+    out.info(out.c("open one with `boost browse --category <name>`", out.DIM))
+    return 0
+
+
 def cmd_browse(argv):
     """Full-screen fuzzy browser over every catalog entry."""
     p = cliparse.parser(
         prog="boost browse",
         description="Interactive full-screen TUI with fuzzy search")
     p.add_argument("--category", default="",
-                   help="only browse entries whose category matches (case-insensitive)")
+                   help="open on one category (case-insensitive); ^G switches")
+    p.add_argument("--categories", action="store_true",
+                   help="list the categories and how many items each holds")
     args = p.parse_args(argv)
     entries = sorted(catalog.all_entries(), key=operator.itemgetter("name"))
-    if args.category:
-        entries = catalog.filter_by_category(entries, args.category)
-        if not entries:
-            raise BoostError("no entries in category %r" % args.category,
-                            hint="try `boost browse` with no --category to see them all")
-    elif not entries:
+    if not entries:
         raise BoostError("no skills available to browse",
                         hint="add registries with `boost tap --defaults`")
+    categories = _tap_categories()
+    if args.categories:
+        return _print_categories(entries, categories)
+    narrowed = entries
+    if args.category:
+        # browse.in_category, not catalog.filter_by_category: the browser files
+        # an entry by its stamped category *or* its tap's, and a flag that
+        # disagreed with the chips it opens on would reject a category the
+        # ^G picker lists.
+        narrowed = [e for e in entries
+                    if browse.in_category(e, args.category, categories)]
+        if not narrowed:
+            raise BoostError("no entries in category %r" % args.category,
+                            hint="`boost browse --categories` lists them")
     if not (sys.stdin.isatty() and sys.stdout.isatty()):
-        return _browse_plain(entries, "interactive mode needs a TTY")
+        return _browse_plain(narrowed, "interactive mode needs a TTY")
     try:
         import curses
     except ImportError:
-        return _browse_plain(entries, "curses is unavailable on this Python")
+        return _browse_plain(narrowed, "curses is unavailable on this Python")
     try:
-        picked = _browse_tui(curses, entries)
+        # The whole catalogue, not `narrowed`: the category is a filter the
+        # browser can lift, so it needs the rows outside it too.
+        picked = _browse_tui(curses, entries, category=args.category)
     except curses.error as e:
         # An fd that claims isatty() but isn't a real pty (IDE run consoles,
         # `script`, TERM=dumb) can fail deep inside curses.wrapper's own
@@ -2140,7 +2264,7 @@ def cmd_browse(argv):
         # already ran its finally block (endwin() included), so the screen is
         # restored by the time this is caught — printing here lands on a
         # normal terminal, not a hosed one.
-        return _browse_plain(entries,
+        return _browse_plain(narrowed,
                              "the terminal does not support curses (%s)" % e)
     if not picked:
         return 0

{boost_skill_cli-1.2.194 → boost_skill_cli-1.2.196}/boost_cli/commands/quality.py

@@ -987,6 +987,17 @@ def cmd_doctor(argv):
                     ", …" if len(missing) > 5 else "",
                     prereq.install_hint(prereq_rows)), wrap=True)
 
+    stars = registry.overstarred()
+    if stars:
+        # One issue, not one per tap: a machine that tapped the catalogue
+        # before the ★ was narrowed holds ~420 of these, and the same remedy.
+        bad("curated", "%d tap%s %s a ★ the catalogue no longer gives (%s%s)"
+            " — `boost heal` clears %s"
+            % (len(stars), _s(len(stars)),
+               "carries" if len(stars) == 1 else "carry", ", ".join(stars[:3]),
+               ", …" if len(stars) > 3 else "",
+               "it" if len(stars) == 1 else "them"), wrap=True)
+
     for dup in (store.duplicate_discovery() if agents_ok else ()):
         # An agent that reads the canonical store natively, holding its own
         # entry for a skill that store already carries. Boost did not put it
@@ -1585,6 +1596,25 @@ def cmd_heal(argv):
             out.warn("%s is no longer a symlink into the store — left alone"
                      % _tilde(dup.path))
 
+    # A ★ the catalogue no longer gives. Cleared before the cache loop below,
+    # which rebuilds every cloned tap's cache: the flag is stamped onto each
+    # entry at scan time, so flipping config alone would leave browse and the
+    # curated fallback reading the old star. One line, not one per tap — a
+    # catalogue machine has ~420 of them.
+    stars = registry.overstarred()
+    if stars:
+        shown = ", ".join(stars[:3]) + (", …" if len(stars) > 3 else "")
+        if dry:
+            out.info("would clear the ★ on %d tap%s the catalogue does not "
+                     "curate (%s)" % (len(stars), _s(len(stars)), shown),
+                     wrap=True)
+            actions.append("unstar %d" % len(stars))
+        else:
+            cleared = registry.unstar(stars)
+            out.ok("cleared the ★ on %d tap%s the catalogue does not curate "
+                   "(%s)" % (len(cleared), _s(len(cleared)), shown))
+            actions.append("unstar %d" % len(cleared))
+
     # A dir that refuses writes, or a missing one whose parent refuses the
     # mkdir. A missing one heal CAN create is not stuck: the real run creates
     # it above, so a preview that called it unwritable would exit 1 where the

{boost_skill_cli-1.2.194 → boost_skill_cli-1.2.196}/boost_cli/commands/quickstart.py

@@ -44,7 +44,8 @@ def _selection(catalog_scope: bool) -> list[dict]:
     """
     if not catalog_scope:
         return [d.copy() for d in config.DEFAULT_TAPS]
-    return [{"name": e["name"], "url": e["url"]}
+    return [{"name": e["name"], "url": e["url"],
+             "curated": bool(e.get("curated"))}
             for e in config.load_registry_catalog()
             if not e.get("list_only") and e.get("name") and e.get("url")]
 
@@ -90,8 +91,10 @@ def _tap_defaults(selection: list[dict], pins: dict[str, dict],
     # for work that takes ~2 s done together, and the first thing a new user
     # sees should not be a progress bar.
     with spin.Spinner("tapping %d registries" % len(names)):
-        results = registry.add_many([str(d["url"]) for d in selection],
-                                    curated=True, pins=commits)
+        results = registry.add_many(
+            [str(d["url"]) for d in selection], pins=commits,
+            curated_names=frozenset(str(d["name"]) for d in selection
+                                    if d.get("curated")))
     for res in results:
         name = res["name"]
         if res.get("skipped"):

{boost_skill_cli-1.2.194 → boost_skill_cli-1.2.196}/boost_cli/commands/taps.py

@@ -49,8 +49,13 @@ def _tap_catalog(args, tapped: list[tuple[str, int]] | None = None) -> int:
                 % (len(selection), sum(e.get("est_items") or 0 for e in selection)))
         return 0
     focus = {str(e["name"]): e.get("focus", "") for e in selection}
+    # The ★ follows the catalogue's own `curated` column, not the whole batch:
+    # stamping every row is what made it mark 463 registries. `--curated` still
+    # stars the lot, because that is the user saying so.
     return _tap_all([str(e["url"]) for e in selection], jobs=args.jobs,
-                    focus=focus, tapped=tapped)
+                    focus=focus, tapped=tapped, curated=args.curated,
+                    curated_names=frozenset(str(e["name"]) for e in selection
+                                            if e.get("curated")))
 
 
 def _print_dry_run(pairs: list[tuple[str, str]]) -> int:
@@ -89,7 +94,8 @@ def _tap_all(urls: list[str], jobs: int | None,
              focus: dict[str, str] | None = None,
              pins: dict[str, str] | None = None,
              curated: bool = True,
-             tapped: list[tuple[str, int]] | None = None) -> int:
+             tapped: list[tuple[str, int]] | None = None,
+             curated_names: frozenset[str] = frozenset()) -> int:
     """Clone many registries at once, then scan each one that arrived.
 
     The split is the whole optimisation. Cloning is network latency — 1.6 s per
@@ -98,7 +104,8 @@ def _tap_all(urls: list[str], jobs: int | None,
     its output can be printed in order and its errors belong to one tap.
     """
     focus = focus or {}
-    results = registry.add_many(urls, curated=curated, pins=pins, jobs=jobs)
+    results = registry.add_many(urls, curated=curated, pins=pins, jobs=jobs,
+                                curated_names=curated_names)
     rc = 0
     for res in results:
         name = res["name"]