boost-skill-cli 1.0.67__tar.gz → 1.0.69__tar.gz

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/PKG-INFO

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

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/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.67'
-__version_tuple__ = version_tuple = (1, 0, 67)
+__version__ = version = '1.0.69'
+__version_tuple__ = version_tuple = (1, 0, 69)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/boost_cli/commands/configuration.py

@@ -1147,14 +1147,21 @@ def cmd_self_update(argv) -> int:
         raise BoostError("boost is not running from a git checkout",
                         hint="git clone the boost repo and symlink bin")
     old = __version__
+    before = gitutil.head_commit(root)
     gitutil.run(["-C", str(root), "pull", "--ff-only"], timeout=120)
-    new = old
-    m = re.search(r"__version__\s*=\s*[\"']([^\"']+)[\"']",
-                  (root / "boost_cli" / "__init__.py").read_text())
-    if m:
-        new = m.group(1)
-    journal.log("self-update", new, previous=old)
-    if new != old:
+    after = gitutil.head_commit(root)
+    # The version is setuptools-scm derived — there is no `__version__ = "…"`
+    # literal to grep, and the build-time _version.py / installed metadata are
+    # stale until a reinstall. Ask git for the freshly-pulled version directly
+    # (mirrors boost_cli._detect_version()'s git-checkout fallback), and treat a
+    # moved HEAD as the unambiguous "an update landed" signal — independent of
+    # how the two version strings happen to be formatted.
+    new = gitutil.run(
+        ["-C", str(root), "describe", "--tags", "--always", "--dirty"],
+        check=False, timeout=10).stdout.strip().lstrip("v") or old
+    updated = bool(after) and after != before
+    journal.log("self-update", new if updated else old, previous=old)
+    if updated:
         out.ok("boost v%s → v%s" % (old, new))
     else:
         out.ok("already up to date (v%s)" % old)

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/boost_cli/commands/discovery.py

@@ -544,6 +544,140 @@ def _browse_plain(entries, why: str):
     return 0
 
 
+# --- Aurora palette for the curses browser -----------------------------------
+# The full-screen browser paints itself in the same Aurora tokens as the rest
+# of the CLI. curses can't reuse the ANSI escapes from core.output, so these
+# helpers translate the single-source palette (out.TOKENS) into curses colour
+# pairs, degrading to the 8 base colours — then to monochrome — when a terminal
+# (or the test fake) can't do better.
+
+def _curses_rgb1000():
+    """out.TOKENS scaled from 0..255 to curses' 0..1000 RGB range.
+
+    Parity-locked to the web palette: whatever style/boost.css defines, the
+    browser renders, so the TUI can never drift from the design system.
+    """
+    return {name: tuple(round(c / 255 * 1000) for c in rgb)
+            for name, rgb in out.TOKENS.items()}
+
+
+def _nearest_base(curses):
+    """Each Aurora token mapped to its closest of the 8 base curses colours.
+
+    Used when the terminal can't redefine colours (mirrors the 16-colour
+    fallback in core.output._AURORA).
+    """
+    return {"cyan": curses.COLOR_CYAN, "violet": curses.COLOR_MAGENTA,
+            "pink": curses.COLOR_MAGENTA, "green": curses.COLOR_GREEN,
+            "yellow": curses.COLOR_YELLOW}
+
+
+def _match_positions(needle, hay):
+    """Indices in hay consumed by a left-to-right subsequence match of needle.
+
+    Drives fuzzy-match highlighting; returns [] when needle isn't a
+    subsequence of hay (so nothing is highlighted).
+    """
+    positions, i = [], 0
+    for j, ch in enumerate(hay):
+        if i < len(needle) and ch == needle[i]:
+            positions.append(j)
+            i += 1
+    return positions if i == len(needle) else []
+
+
+def _scrollbar(total, rows, top):
+    """(thumb_start, thumb_len) for a rows-tall scrollbar; None when all fits."""
+    if rows <= 0 or total <= rows:
+        return None
+    thumb = max(1, rows * rows // total)
+    max_top = total - rows
+    start = round((rows - thumb) * top / max_top) if max_top else 0
+    return (start, thumb)
+
+
+def _grad_segments(width, n=3):
+    """Split a width-wide rule into n near-equal [(start, length)] runs.
+
+    Lets the browser paint a cyan -> violet -> pink gradient bar the same way
+    out.gradient() lerps the wordmark.
+    """
+    if width <= 0:
+        return []
+    n = min(n, width)
+    base, extra = divmod(width, n)
+    segs, pos = [], 0
+    for k in range(n):
+        length = base + (1 if k < extra else 0)
+        segs.append((pos, length))
+        pos += length
+    return segs
+
+
+def _aurora_pairs(curses):
+    """Allocate Aurora curses colour pairs; token-name -> attr int (0 if none)."""
+    names = ("cyan", "violet", "pink", "green", "yellow")
+    try:
+        custom = curses.can_change_color() and curses.COLORS >= 16 + len(names)
+    except curses.error:
+        custom = False
+    fg = dict(_nearest_base(curses))
+    if custom:
+        rgb = _curses_rgb1000()
+        for idx, nm in enumerate(names):
+            slot = 16 + idx
+            try:
+                curses.init_color(slot, *rgb[nm])
+                fg[nm] = slot
+            except curses.error:
+                pass
+    fg["red"] = curses.COLOR_RED
+    pairs = {}
+    for i, nm in enumerate(("cyan", "violet", "pink", "green", "yellow", "red"),
+                           start=1):
+        try:
+            curses.init_pair(i, fg[nm], -1)
+            pairs[nm] = curses.color_pair(i)
+        except curses.error:
+            pairs[nm] = 0
+    return pairs
+
+
+def _aurora_theme(curses):
+    """role -> curses attr. Monochrome baseline, upgraded to Aurora where able."""
+    t = {"title": curses.A_BOLD, "prompt": curses.A_BOLD, "query": curses.A_BOLD,
+         "count": curses.A_DIM, "help": curses.A_DIM, "star": curses.A_NORMAL,
+         "name": curses.A_NORMAL, "sel_bar": curses.A_REVERSE,
+         "sel_name": curses.A_BOLD, "match": curses.A_BOLD,
+         "version": curses.A_DIM, "tap": curses.A_NORMAL,
+         "rule": [curses.A_NORMAL, curses.A_NORMAL, curses.A_NORMAL],
+         "scroll": curses.A_DIM, "detail_name": curses.A_BOLD,
+         "detail_meta": curses.A_DIM, "detail_tag": curses.A_NORMAL,
+         "dot_r": curses.A_NORMAL, "dot_y": curses.A_NORMAL,
+         "dot_g": curses.A_NORMAL}
+    if not hasattr(curses, "start_color"):
+        return t
+    try:
+        curses.start_color()
+        curses.use_default_colors()
+    except curses.error:
+        return t
+    p = _aurora_pairs(curses)
+
+    def P(nm, bold=False):
+        a = p.get(nm, 0)
+        return (a | curses.A_BOLD) if bold else a
+
+    t.update({"title": P("cyan", True), "prompt": P("cyan", True),
+              "star": P("yellow"), "sel_bar": P("cyan", True),
+              "sel_name": P("cyan", True), "match": P("pink", True),
+              "tap": P("violet"), "rule": [P("cyan"), P("violet"), P("pink")],
+              "scroll": P("cyan"), "detail_name": P("cyan", True),
+              "detail_tag": P("pink"), "dot_r": P("red"), "dot_y": P("yellow"),
+              "dot_g": P("green")})
+    return t
+
+
 def _browse_tui(curses, entries):
     """Run the curses UI. Returns the entry picked for install, or None."""
     state = {"pick": None}
@@ -553,40 +687,83 @@ def _browse_tui(curses, entries):
             curses.curs_set(0)
         except curses.error:
             pass
+        th = _aurora_theme(curses)
+
+        def put(y, x, s, attr=0):  # clip-safe cell writer
+            if 0 <= y < _h and 0 <= x < _w - 1 and s:
+                try:
+                    scr.addnstr(y, x, s, _w - 1 - x, attr)
+                except curses.error:
+                    pass
+
         filt, sel, detail = "", 0, False
         while True:
             q = filt.lower()
             matches = [e for e in entries
                        if _subseq(q, (e["name"] + " " + e["tap"]).lower())]
             sel = max(0, min(sel, len(matches) - 1))
-            h, w = scr.getmaxyx()
+            _h, _w = scr.getmaxyx()
             pane = 6 if detail and matches else 0
             try:
                 scr.erase()
-                scr.addnstr(0, 0, "filter: " + filt, w - 1, curses.A_BOLD)
-                scr.addnstr(1, 0, "up/down move · enter detail · i install · "
-                            "q quit · %d/%d" % (len(matches), len(entries)),
-                            w - 1, curses.A_DIM)
-                rows = max(1, h - 3 - pane)
+                # titlebar: macOS traffic dots + wordmark + gradient rule
+                put(0, 0, "●", th["dot_r"])
+                put(0, 2, "●", th["dot_y"])
+                put(0, 4, "●", th["dot_g"])
+                title = " boost browse"
+                put(0, 6, title, th["title"])
+                rx = 6 + len(title) + 1
+                for (start, length), attr in zip(
+                        _grad_segments(max(0, _w - 1 - rx)), th["rule"]):
+                    put(0, rx + start, "─" * length, attr)
+                # prompt line: cyan chevron, query, cursor, right-aligned count
+                put(1, 0, "❯", th["prompt"])
+                put(1, 2, filt, th["query"])
+                put(1, 2 + len(filt), "▏", th["prompt"])
+                count = "%d/%d" % (len(matches), len(entries))
+                put(1, max(2 + len(filt) + 2, _w - 1 - len(count)), count,
+                    th["count"])
+                put(2, 0, "↑↓ move  ↵ detail  i install  q quit",
+                    th["help"])
+                rows = max(1, _h - 3 - pane)
                 top = max(0, sel - rows + 1)
-                for i, e in enumerate(matches[top:top + rows]):
-                    line = "%s %s  v%s  %s" % ("★" if e.get("curated") else " ",
-                                               e["name"], e["version"], e["tap"])
-                    attr = curses.A_REVERSE if top + i == sel else curses.A_NORMAL
-                    scr.addnstr(2 + i, 0, line.ljust(w - 1), w - 1, attr)
+                view = matches[top:top + rows]
+                namew = min(max((len(e["name"]) for e in view), default=4),
+                            max(4, _w - 26))
+                bar = _scrollbar(len(matches), rows, top)
+                for i, e in enumerate(view):
+                    y = 3 + i
+                    chosen = top + i == sel
+                    put(y, 0, "▎" if chosen else " ", th["sel_bar"])
+                    put(y, 1, "★" if e.get("curated") else " ", th["star"])
+                    nm = out.truncate(e["name"], namew)
+                    put(y, 3, nm.ljust(namew),
+                        th["sel_name"] if chosen else th["name"])
+                    for pos in _match_positions(q, nm.lower()):
+                        put(y, 3 + pos, nm[pos], th["match"])
+                    vx = 3 + namew + 2
+                    put(y, vx, "v" + e["version"], th["version"])
+                    put(y, vx + len(e["version"]) + 3, e["tap"], th["tap"])
+                    if bar:
+                        bstart, blen = bar
+                        put(y, _w - 2,
+                            "█" if bstart <= i < bstart + blen else "│",
+                            th["scroll"])
                 if pane and matches:
                     e = matches[sel]
-                    y0 = h - pane
-                    scr.hline(y0, 0, curses.ACS_HLINE, w - 1)
-                    tags = ", ".join(str(t) for t in
+                    y0 = _h - pane
+                    for (start, length), attr in zip(
+                            _grad_segments(_w - 1), th["rule"]):
+                        put(y0, start, "─" * length, attr)
+                    tags = "  ".join("#" + str(t) for t in
                                      (e.get("meta", {}).get("tags") or []))
-                    for j, ln in enumerate((
-                            "%s  v%s" % (e["name"], e["version"]),
-                            (e["description"] or "")[:w - 3],
-                            "tap: %s   dir: %s" % (e["tap"], e["rel_dir"]),
-                            "tags: %s" % (tags or "-"))):
-                        if y0 + 1 + j < h:
-                            scr.addnstr(y0 + 1 + j, 1, ln, w - 2)
+                    put(y0 + 1, 1, "%s  v%s" % (e["name"], e["version"]),
+                        th["detail_name"])
+                    put(y0 + 2, 1, out.truncate(e["description"] or "", _w - 3),
+                        th["name"])
+                    put(y0 + 3, 1, "tap %s   dir %s" % (e["tap"], e["rel_dir"]),
+                        th["detail_meta"])
+                    put(y0 + 4, 1, tags or "no tags", th["detail_tag"])
                 scr.refresh()
             except curses.error:
                 pass  # terminal too small mid-draw; retry on next key

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/boost_skill_cli.egg-info/SOURCES.txt

@@ -116,7 +116,6 @@ docs/roadmap/items/finish-mutation-hardening-across-core.md
 docs/roadmap/items/fix-self-update-version-detection-dead-branch.md
 docs/roadmap/items/frontmatter-scalar-over-coercion.md
 docs/roadmap/items/github-pages-deploy-is-broken-every-push.md
-docs/roadmap/items/guard-output-table-against-ragged-rows.md
 docs/roadmap/items/hash-pinned-reproducible-toolchain-uv-lock.md
 docs/roadmap/items/html-validation-html-validate.md
 docs/roadmap/items/integrity-verification-boost-verify.md

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/docs/design-roadmap.html

@@ -142,7 +142,7 @@
       <code>NO_COLOR</code> and non-TTY are always respected.
     </p>
     <div class="stats">
-      <div class="stat reveal"><b>25</b><span>Design opportunities</span></div>
+      <div class="stat reveal"><b>26</b><span>Design opportunities</span></div>
       <div class="stat reveal"><b>5</b><span>Design tracks</span></div>
       <div class="stat reveal"><b>0</b><span>New dependencies</span></div>
       <div class="stat reveal"><b>1:1</b><span>Web ↔ CLI parity goal</span></div>
@@ -395,7 +395,7 @@
         <div class="track-icon"></div>
         <div>
           <h3>Command-by-command Polish</h3>
-          <p>The screens users actually stare at — front door, doctor, list, info.</p>
+          <p>The screens users actually stare at — front door, doctor, list, info, browse.</p>
         </div>
         <span class="n"><!-- ROADMAP:count track=commands -->6 items<!-- /ROADMAP:count --></span>
       </div>
@@ -451,6 +451,14 @@
 </article>
       <!-- /ROADMAP:cards -->
 
+        <article class="ritem" data-track="commands" data-impact="high">
+          <div class="ritem-top"><span class="rid">BOOST-D26</span><span class="rstatus done">Shipped</span></div>
+          <h4><code>browse</code> — Aurora the full-screen TUI</h4>
+          <p>The interactive <code>browse</code> pane was the <b>last off-theme surface</b>: a curses screen drawn in raw <code>A_BOLD</code>/<code>A_DIM</code>/<code>A_REVERSE</code> — zero brand color while every other command spoke Aurora. Rebuilt it as a first-class TUI: a macOS <b>titlebar</b> (traffic-light dots + <code>boost browse</code> wordmark under a cyan→violet→pink gradient rule), an <code>❯</code> chevron prompt with a live cursor, <b>fuzzy-match highlighting</b> (matched chars glow pink as you type), a cyan selection bar, yellow curated <code>★</code>, violet tap labels, a right-edge scrollbar, and a gradient-topped detail pane. Colors come from the single-source <code>out.TOKENS</code> via <code>init_color</code> — parity-locked to <code>style/boost.css</code> — and degrade truecolor → 8-color → monochrome. Stdlib only.</p>
+          <div class="rmeta"><span class="m-cat">commands</span><span>Complexity L</span><span class="m-imp high">Impact High</span><span class="m-wow">★★★★★</span></div>
+          <div class="rref"><code>commands/discovery.py · _browse_tui / _aurora_theme</code></div>
+        </article>
+
       </div>
     </section>
 

boost_skill_cli-1.0.69/docs/roadmap/items/fix-self-update-version-detection-dead-branch.md

@@ -0,0 +1,25 @@
+---
+id: fix-self-update-version-detection-dead-branch
+board: code
+section: shipped
+status: shipped
+category: Correctness
+complexity: S
+impact: High
+wow: 3
+note: broken headline command, now works
+order: 7
+owner: loop/self-update-fix
+pr:
+title: Fix <code>self-update</code> version detection (dead branch)
+---
+<code>boost self-update</code> greped <code>__init__.py</code> for a
+           <code>__version__ = "…"</code> literal that setuptools-scm never
+           writes, so the regex never matched and it always reported
+           <b>"already up to date"</b> — even after a pull brought a newer tag.
+           The success path was <em>unreachable</em>. It now derives the pulled
+           version straight from git (<code>describe --tags</code>, mirroring
+           <code>_detect_version()</code>) and treats a moved <code>HEAD</code>
+           as the "an update landed" signal, so the version-bump path finally
+           fires. Regression tests cover both the up-to-date and update-landed
+           branches.

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/docs/roadmap.html

@@ -115,10 +115,10 @@
   <section class="block reveal">
     <div class="stats">
       <!-- ROADMAP:stats -->
-      <div class="stat"><b>6</b><span>Shipped</span></div>
+      <div class="stat"><b>7</b><span>Shipped</span></div>
       <div class="stat"><b>3</b><span>Next up</span></div>
       <div class="stat"><b>4</b><span>Planned</span></div>
-      <div class="stat"><b>84</b><span>Loop finds</span></div>
+      <div class="stat"><b>83</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -227,6 +227,27 @@
           <span class="m">Wow <b class="wow">★★★★</b></span>
         </div>
       </article>
+
+      <article class="cap rcard">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Correctness</span></div>
+        <h3>Fix <code>self-update</code> version detection (dead branch)</h3>
+        <p><code>boost self-update</code> greped <code>__init__.py</code> for a
+           <code>__version__ = "…"</code> literal that setuptools-scm never
+           writes, so the regex never matched and it always reported
+           <b>"already up to date"</b> — even after a pull brought a newer tag.
+           The success path was <em>unreachable</em>. It now derives the pulled
+           version straight from git (<code>describe --tags</code>, mirroring
+           <code>_detect_version()</code>) and treats a moved <code>HEAD</code>
+           as the "an update landed" signal, so the version-bump path finally
+           fires. Regression tests cover both the up-to-date and update-landed
+           branches.</p>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m hi">Impact <b>High</b></span>
+          <span class="m">Wow <b class="wow">★★★</b></span>
+          <span class="m">broken headline command, now works</span>
+        </div>
+      </article>
       <!-- /ROADMAP:cards -->
 
     </div>
@@ -377,17 +398,6 @@
         </div>
       </article>
 
-      <article class="cap rcard">
-        <div class="head"><span class="pill next">Next</span><span class="cat">Correctness</span></div>
-        <h3>Fix <code>self-update</code> version detection (dead branch)</h3>
-        <p><code>cmd_self_update</code> greps <code>__init__.py</code> for a <code>__version__ = "…"</code> literal (<code>commands/configuration.py:1090</code>), but the constant is <code>_detect_version()</code> (setuptools-scm — no literal). The regex never matches, so it reports <b>"already up to date"</b> even after a pull brings a newer tag. The success path is unreachable.</p>
-        <div class="meta">
-          <span class="m">Complexity <b>S</b></span>
-          <span class="m hi">Impact <b>High</b></span>
-          <span class="m">Wow <b class="wow">★★★</b></span>
-        </div>
-      </article>
-
       <article class="cap rcard">
         <div class="head"><span class="pill next">Next</span><span class="cat">Correctness</span></div>
         <h3>Consolidate skill-staleness / drift logic into core</h3>
@@ -564,17 +574,6 @@
         </div>
       </article>
 
-      <article class="cap rcard">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Robustness</span></div>
-        <h3>Guard <code>output.table</code> against ragged rows</h3>
-        <p>Column-width computation does <code>max(… for r in rows if i &lt; len(r))</code> (<code>core/output.py:300</code>), which raises <code>max() arg is empty</code> when a header column has no matching cell in any row. Add <code>default=0</code>.</p>
-        <div class="meta">
-          <span class="m">Complexity <b>S</b></span>
-          <span class="m">Impact <b>Low</b></span>
-          <span class="m">Wow <b class="wow">★</b></span>
-        </div>
-      </article>
-
       <article class="cap rcard">
         <div class="head"><span class="pill planned">Planned</span><span class="cat">Tech-debt</span></div>
         <h3>Reuse helpers; kill minor dead work</h3>

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/tests/functional/test_cli_configuration.py

@@ -809,20 +809,54 @@ class TestSelfUpdate:
         assert "boost is not running from a git checkout" in r.err
         assert "git clone the boost repo" in r.err
 
-    def test_git_path_pulls_and_reports(self, boost, sandbox, monkeypatch):
+    def _fake_git(self, monkeypatch, *, before, after, described):
+        """Stub gitutil so self-update sees a controlled HEAD move + describe.
+
+        ``rev-parse HEAD`` returns ``before`` until the pull runs, ``after``
+        afterwards; ``describe`` returns ``described``; ``pull`` is a no-op.
+        """
         calls = []
+        pulled = {"done": False}
         monkeypatch.setattr("boost_cli.core.gitutil.is_repo", lambda p: True)
 
         def fake_run(args, **kw):
             calls.append(list(args))
+            if "pull" in args:
+                pulled["done"] = True
+                return _proc(args, 0)
+            if "rev-parse" in args:
+                return _proc(args, 0, out=(after if pulled["done"] else before))
+            if "describe" in args:
+                return _proc(args, 0, out=described)
             return _proc(args, 0)
 
         monkeypatch.setattr("boost_cli.core.gitutil.run", fake_run)
+        return calls
+
+    def test_reports_already_up_to_date_when_head_unchanged(
+            self, boost, sandbox, monkeypatch):
+        # HEAD is identical before and after the pull -> nothing landed
+        calls = self._fake_git(monkeypatch, before="sha1\n", after="sha1\n",
+                               described="v2.3.3\n")
         r = boost("self-update")
         root = paths.repo_root()
-        assert calls == [["-C", str(root), "pull", "--ff-only"]]
         from boost_cli import __version__
+        assert ["-C", str(root), "pull", "--ff-only"] in calls
         assert ("already up to date (v%s)" % __version__) in r.out
+        assert "→" not in r.out
+        ev = journal.events(action="self-update")[0]
+        assert ev["subject"] == __version__ and ev["previous"] == __version__
+
+    def test_reports_new_version_when_pull_advances_head(
+            self, boost, sandbox, monkeypatch):
+        # the pull fast-forwards HEAD -> report the git-described new version.
+        # This path was unreachable before the fix (the old code grepped
+        # __init__.py for a __version__ literal setuptools-scm never writes).
+        self._fake_git(monkeypatch, before="oldsha\n", after="newsha\n",
+                       described="v9.9.9\n")
+        r = boost("self-update")
+        from boost_cli import __version__
+        assert ("boost v%s → v9.9.9" % __version__) in r.out
         ev = journal.events(action="self-update")[0]
-        assert ev["subject"] == __version__
+        assert ev["subject"] == "9.9.9"          # git-derived, not the stale const
         assert ev["previous"] == __version__

{boost_skill_cli-1.0.67 → boost_skill_cli-1.0.69}/tests/functional/test_cli_discovery.py

@@ -627,11 +627,117 @@ class TestBrowse:
                            FakeCurses.KEY_BACKSPACE, ord("i")])
         picked = discovery._browse_tui(fake, entries)
         assert picked["name"] == "brainstorming"
-        assert any(s.startswith("filter: t") for s in fake.drawn)
+        # the typed query is echoed after the "❯" prompt
+        assert "t" in fake.drawn
+        assert any("boost browse" in s for s in fake.drawn)
         # ESC quits without a pick
         assert discovery._browse_tui(FakeCurses([27]), entries) is None
 
 
+class TestBrowseAurora:
+    """The curses browser paints itself in the single-source Aurora palette."""
+
+    def test_curses_rgb1000_parity_with_tokens(self):
+        from boost_cli.commands import discovery
+        from boost_cli.core import output as out
+        rgb = discovery._curses_rgb1000()
+        assert set(rgb) == set(out.TOKENS)
+        # cyan #22d3ee scaled 0..255 -> 0..1000
+        r, g, b = out.TOKENS["cyan"]
+        assert rgb["cyan"] == (round(r / 255 * 1000), round(g / 255 * 1000),
+                               round(b / 255 * 1000))
+        for triple in rgb.values():
+            assert all(0 <= c <= 1000 for c in triple)
+
+    def test_nearest_base_covers_every_token(self):
+        import curses
+        from boost_cli.commands import discovery
+        from boost_cli.core import output as out
+        base = discovery._nearest_base(curses)
+        assert set(base) == set(out.TOKENS)
+        assert base["cyan"] == curses.COLOR_CYAN
+        assert base["violet"] == base["pink"] == curses.COLOR_MAGENTA
+
+    def test_match_positions(self):
+        from boost_cli.commands import discovery
+        assert discovery._match_positions("bs", "brainstorm") == [0, 5]
+        assert discovery._match_positions("", "anything") == []
+        assert discovery._match_positions("zzz", "brainstorm") == []
+        # left-to-right greedy: first 'o', then trailing 'm'
+        assert discovery._match_positions("om", "brainstorm") == [7, 9]
+
+    def test_scrollbar_math(self):
+        from boost_cli.commands import discovery
+        assert discovery._scrollbar(5, 10, 0) is None      # all fits
+        assert discovery._scrollbar(10, 0, 0) is None      # no rows
+        start, length = discovery._scrollbar(100, 10, 0)
+        assert start == 0 and 1 <= length <= 10
+        end_start, _ = discovery._scrollbar(100, 10, 90)   # scrolled to bottom
+        assert end_start == 10 - length
+
+    def test_grad_segments_partition(self):
+        from boost_cli.commands import discovery
+        assert discovery._grad_segments(0) == []
+        segs = discovery._grad_segments(10, 3)
+        assert [s[1] for s in segs] == [4, 3, 3]           # sums to width
+        assert sum(s[1] for s in segs) == 10
+        assert [s[0] for s in segs] == [0, 4, 7]           # contiguous
+        assert len(discovery._grad_segments(2, 3)) == 2    # n clamps to width
+
+    def test_theme_upgrades_to_colour(self):
+        from boost_cli.commands import discovery
+
+        class ColorCurses:
+            COLOR_CYAN, COLOR_MAGENTA, COLOR_GREEN = 6, 5, 2
+            COLOR_YELLOW, COLOR_RED = 3, 1
+            COLORS = 256
+            A_BOLD, A_DIM, A_REVERSE, A_NORMAL = 1, 2, 4, 0
+
+            class error(Exception):
+                pass
+
+            def __init__(self):
+                self.colors, self.pairs = {}, {}
+
+            def start_color(self):
+                pass
+
+            def use_default_colors(self):
+                pass
+
+            def can_change_color(self):
+                return True
+
+            def init_color(self, slot, r, g, b):
+                self.colors[slot] = (r, g, b)
+
+            def init_pair(self, i, fg, bg):
+                self.pairs[i] = (fg, bg)
+
+            def color_pair(self, i):
+                return i << 8
+
+        cc = ColorCurses()
+        th = discovery._aurora_theme(cc)
+        # custom colours were defined from the parity-locked palette
+        assert cc.colors[16] == discovery._curses_rgb1000()["cyan"]
+        # title carries a colour pair plus bold, not bare monochrome
+        assert th["title"] & cc.A_BOLD
+        assert th["title"] & ~cc.A_BOLD
+        assert len(th["rule"]) == 3
+        assert th["rule"][0] != th["rule"][1] != th["rule"][2]
+
+    def test_theme_falls_back_without_colour(self):
+        from boost_cli.commands import discovery
+
+        class MonoCurses:
+            A_BOLD, A_DIM, A_REVERSE, A_NORMAL = 1, 2, 4, 0
+        th = discovery._aurora_theme(MonoCurses)
+        assert th["title"] == MonoCurses.A_BOLD
+        assert th["sel_bar"] == MonoCurses.A_REVERSE
+        assert th["rule"] == [MonoCurses.A_NORMAL] * 3
+
+
 # ---------------------------------------------------------------- trending
 
 class TestTrending: