slab-cli 0.5.0__tar.gz → 0.7.0__tar.gz

{slab_cli-0.5.0 → slab_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: CLI for the slab trading-card API — catalog, collect, and track your cards from the terminal.
 Author: dev_jeb
 Requires-Dist: slab-schemas>=0.1.0
@@ -56,11 +56,32 @@ to see a group's verbs.
 
 ## Configuration reference
 
-| Env var         | Purpose                                    | Default                          |
-| --------------- | ------------------------------------------ | -------------------------------- |
-| `SLAB_API_KEY`  | API key for authentication (**required**)  | —                                |
-| `SLAB_API_URL`  | Base URL of the slab API                   | `https://api.slab.dev-jeb.com`   |
-| `SLAB_COLLECTOR`| Active collector UUID, reused per command  | —                                |
+| Env var                | Purpose                                    | Default                          |
+| ---------------------- | ------------------------------------------ | -------------------------------- |
+| `SLAB_API_KEY`         | API key for authentication (**required**)  | —                                |
+| `SLAB_API_URL`         | Base URL of the slab API                   | `https://api.slab.dev-jeb.com`   |
+| `SLAB_COLLECTOR`       | Active collector UUID, reused per command  | —                                |
+| `SLAB_NO_UPDATE_CHECK` | Set to `1` to silence update checks        | —                                |
+
+## Staying up to date
+
+Nothing updates itself. At most once a day the CLI asks PyPI (in the background, while your command
+runs) whether there's a newer release, and if so prints one line after the output:
+
+```
+▍ slab-cli 0.7.0 is available — you have 0.6.0
+  Update when you like: slab update
+```
+
+```bash
+slab --version         # what you have
+slab update check      # ask PyPI right now; installs nothing
+slab update            # upgrade, after showing the command and asking
+```
+
+`slab update` runs the upgrade that matches how you installed slab — `pipx upgrade`,
+`uv tool upgrade`, or `pip install --upgrade` — and prints it first, so you can decline and run it
+yourself. To turn the whole thing off: `export SLAB_NO_UPDATE_CHECK=1`.
 
 ## What it depends on
 

{slab_cli-0.5.0 → slab_cli-0.7.0}/README.md

@@ -44,11 +44,32 @@ to see a group's verbs.
 
 ## Configuration reference
 
-| Env var         | Purpose                                    | Default                          |
-| --------------- | ------------------------------------------ | -------------------------------- |
-| `SLAB_API_KEY`  | API key for authentication (**required**)  | —                                |
-| `SLAB_API_URL`  | Base URL of the slab API                   | `https://api.slab.dev-jeb.com`   |
-| `SLAB_COLLECTOR`| Active collector UUID, reused per command  | —                                |
+| Env var                | Purpose                                    | Default                          |
+| ---------------------- | ------------------------------------------ | -------------------------------- |
+| `SLAB_API_KEY`         | API key for authentication (**required**)  | —                                |
+| `SLAB_API_URL`         | Base URL of the slab API                   | `https://api.slab.dev-jeb.com`   |
+| `SLAB_COLLECTOR`       | Active collector UUID, reused per command  | —                                |
+| `SLAB_NO_UPDATE_CHECK` | Set to `1` to silence update checks        | —                                |
+
+## Staying up to date
+
+Nothing updates itself. At most once a day the CLI asks PyPI (in the background, while your command
+runs) whether there's a newer release, and if so prints one line after the output:
+
+```
+▍ slab-cli 0.7.0 is available — you have 0.6.0
+  Update when you like: slab update
+```
+
+```bash
+slab --version         # what you have
+slab update check      # ask PyPI right now; installs nothing
+slab update            # upgrade, after showing the command and asking
+```
+
+`slab update` runs the upgrade that matches how you installed slab — `pipx upgrade`,
+`uv tool upgrade`, or `pip install --upgrade` — and prints it first, so you can decline and run it
+yourself. To turn the whole thing off: `export SLAB_NO_UPDATE_CHECK=1`.
 
 ## What it depends on
 

{slab_cli-0.5.0 → slab_cli-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slab-cli"
-version = "0.5.0"
+version = "0.7.0"
 description = "CLI for the slab trading-card API — catalog, collect, and track your cards from the terminal."
 readme = "README.md"
 authors = [{name = "dev_jeb"}]

slab_cli-0.7.0/src/slab_cli/browse.py

@@ -0,0 +1,386 @@
+"""An interactive, scrollable table — the browsable counterpart to a static `slab_table`.
+
+`browse(columns, rows, ...)` shows the same columns and cells a static table would, but as a
+keyboard-driven viewport: ↑/↓ (or j/k) move the highlight, PgUp/PgDn jump, `/` type-to-filters
+across every column, and q leaves — printing the plain table on the way out so the data
+survives in scrollback. Enter drills down: with a `detail` callback the highlighted row's
+detail view REPLACES the list as a scrollable page (Esc/q climbs back up to the list, same row
+highlighted); without one, Enter simply returns the row's item to the caller. Anywhere output
+isn't an interactive terminal (a pipe, CI, redirection, a platform without termios) it
+degrades to the static table, so `slab ... | grep` keeps working unchanged.
+
+This is THE tabular display for result lists: a command builds `(item, cells)` rows once and
+the same spec drives the interactive view, the static fallback, and the exit receipt.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any, Callable, Sequence
+
+from rich.console import Group
+from rich.live import Live
+from rich.text import Text
+
+from .theme import console, heading, slab_table
+
+# One row: the domain object Enter should act on, plus its cell markup strings (one per column).
+Row = tuple[Any, Sequence[str]]
+
+# The highlight bar — a slate a step brighter than the card border, so the selected row reads as
+# lit without fighting the cells' own foreground colors (markup styles set color only, never bg).
+_SELECTED_BG = "on #223052"
+
+
+# ---------------------------------------------------------------------------
+# Static rendering — the fallback, and the receipt printed when a browse ends
+# ---------------------------------------------------------------------------
+
+def print_table(
+    columns: list[tuple[str, dict]],
+    rows: list[Row],
+    *,
+    title: str,
+    note: str | None = None,
+    footer: str | None = None,
+) -> None:
+    """The classic non-interactive rendering: heading + slab_table + optional dim footer."""
+    table = slab_table(columns)
+    for _item, cells in rows:
+        table.add_row(*(str(c) for c in cells))
+    console.print(heading(title, note))
+    console.print(table)
+    if footer:
+        console.print(f"  [slab.dim]{footer}[/]")
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers (unit-tested offline)
+# ---------------------------------------------------------------------------
+
+def row_plain(cells: Sequence[str]) -> str:
+    """A row's cells flattened to lowercase plain text — what `/` filtering matches against."""
+    return Text.from_markup("  ".join(str(c) for c in cells)).plain.lower()
+
+
+def matches(query: str, plain: str) -> bool:
+    """Every whitespace-separated token of the query must appear somewhere in the row."""
+    return all(tok in plain for tok in query.lower().split())
+
+
+def scroll_top(sel: int, top: int, viewport: int, n: int) -> int:
+    """The first visible row index keeping `sel` inside a `viewport`-row window over `n` rows."""
+    if n <= viewport:
+        return 0
+    if sel < top:
+        top = sel
+    elif sel >= top + viewport:
+        top = sel - viewport + 1
+    return max(0, min(top, n - viewport))
+
+
+def pager_top(top: int, viewport: int, n: int) -> int:
+    """Clamp a pager's first visible line so the window never runs past the content."""
+    return max(0, min(top, n - viewport))
+
+
+_SEQUENCES = {
+    b"\x1b[A": "up", b"\x1b[B": "down",
+    b"\x1bOA": "up", b"\x1bOB": "down",          # application cursor mode
+    b"\x1b[5~": "pgup", b"\x1b[6~": "pgdn",
+    b"\x1b[H": "home", b"\x1b[F": "end",
+    b"\x1b[1~": "home", b"\x1b[4~": "end",
+    b"\x1b[D": "left", b"\x1bOD": "left",        # ← also climbs back up a level
+}
+
+
+def split_keys(data: bytes) -> list[str]:
+    """A raw input burst -> ordered key names ('up', 'enter', 'esc', …) and printable chars.
+
+    Terminals deliver fast typing, pastes, and escape sequences as multi-byte chunks; parsing
+    the whole burst (instead of assuming one read = one key) is what keeps a pasted filter
+    query intact and an arrow key from being mistaken for its component bytes."""
+    keys: list[str] = []
+    i = 0
+    while i < len(data):
+        if data[i:i + 1] == b"\x1b":
+            for seq, name in _SEQUENCES.items():
+                if data.startswith(seq, i):
+                    keys.append(name)
+                    i += len(seq)
+                    break
+            else:
+                if data[i + 1:i + 2] in (b"[", b"O"):
+                    # An escape sequence we don't drive anything with: swallow through its
+                    # final byte (0x40–0x7e) so its payload doesn't leak in as typed text.
+                    j = i + 2
+                    while j < len(data) and not 0x40 <= data[j] <= 0x7E:
+                        j += 1
+                    i = j + 1
+                else:
+                    i += 1  # bare Escape
+                keys.append("esc")
+            continue
+        j = data.find(b"\x1b", i)
+        run = data[i:] if j == -1 else data[i:j]
+        i = len(data) if j == -1 else j
+        for ch in run.decode(errors="ignore"):
+            if ch in ("\r", "\n"):
+                keys.append("enter")
+            elif ch in ("\x7f", "\x08"):
+                keys.append("backspace")
+            elif ch == "\x03":
+                keys.append("quit")  # Ctrl-C when ISIG doesn't get there first
+            elif ch.isprintable():
+                keys.append(ch)
+    return keys
+
+
+# ---------------------------------------------------------------------------
+# The interactive machinery
+# ---------------------------------------------------------------------------
+
+def _interactive_ok() -> bool:
+    """True when we can actually run a keyboard loop: a real terminal on a termios platform."""
+    if not (console.is_terminal and sys.stdin.isatty()):
+        return False
+    try:
+        import termios  # noqa: F401  (Unix-only; absent on Windows)
+        import tty  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
+def _read_keys(fd: int) -> list[str]:
+    return split_keys(os.read(fd, 64))
+
+
+def _frame(
+    columns: list[tuple[str, dict]],
+    view: list[Row],
+    sel: int,
+    top: int,
+    viewport: int,
+    *,
+    title: str,
+    note: str | None,
+    hint: str,
+    total: int,
+    query: str,
+    typing: bool,
+) -> Group:
+    """One rendered list frame: heading + the visible window of rows + the status footer."""
+    table = slab_table(columns)
+    for i in range(top, min(top + viewport, len(view))):
+        _item, cells = view[i]
+        first, rest = str(cells[0]), [str(c) for c in cells[1:]]
+        if i == sel:
+            table.add_row(f"[slab.foil]▸[/] {first}", *rest, style=_SELECTED_BG)
+        else:
+            table.add_row(f"  {first}", *rest)
+
+    pos = f"{sel + 1}/{len(view)}" if view else "0 matches"
+    if query and len(view) != total:
+        pos += f" [slab.muted](of {total})[/]"
+    if typing:
+        status = (f"  [slab.accent]/{query}▌[/][slab.dim]   {pos} · ⏎ done · esc clear[/]")
+    elif query:
+        status = (f"  [slab.dim]{pos} · [/][slab.accent]/{query}[/]"
+                  f"[slab.dim] · ↑↓ move · ⏎ {hint} · esc clear · q quit[/]")
+    else:
+        status = f"  [slab.dim]{pos} · ↑↓ move · ⏎ {hint} · / filter · q quit[/]"
+
+    return Group(heading(title, note), table, Text.from_markup(status))
+
+
+def _run_list(
+    fd: int,
+    columns: list[tuple[str, dict]],
+    rows: list[Row],
+    *,
+    title: str,
+    note: str | None,
+    hint: str,
+    start: int,
+) -> tuple[Any | None, int]:
+    """The list screen. Returns (chosen item, its index in `rows`) on Enter, or (None, last
+    highlighted index) on quit — the index lets a drill-down return to the same row."""
+    plains = [row_plain(cells) for _item, cells in rows]
+    query, typing = "", False
+    sel = min(max(start, 0), len(rows) - 1)
+    top = 0
+    pending: list[str] = []
+
+    def row_index(view_row: Row) -> int:
+        return next(i for i, r in enumerate(rows) if r is view_row)
+
+    with Live(console=console, transient=True, auto_refresh=False) as live:
+        while True:
+            view = ([r for r, p in zip(rows, plains) if matches(query, p)]
+                    if query else rows)
+            if sel >= len(view):
+                sel = max(0, len(view) - 1)
+            # Leave room for the shell prompt, heading, table chrome, and the footer.
+            viewport = max(3, min(len(view) or 1, console.size.height - 8))
+            top = scroll_top(sel, top, viewport, len(view))
+            live.update(
+                _frame(columns, view, sel, top, viewport, title=title, note=note,
+                       hint=hint, total=len(rows), query=query, typing=typing),
+                refresh=True,
+            )
+
+            if not pending:
+                pending = _read_keys(fd)
+            if not pending:
+                continue
+            key = pending.pop(0)
+
+            if key == "up" or (not typing and key == "k"):
+                sel = max(0, sel - 1)
+            elif key == "down" or (not typing and key == "j"):
+                sel = min(len(view) - 1, sel + 1) if view else 0
+            elif key == "pgup":
+                sel = max(0, sel - viewport)
+            elif key == "pgdn":
+                sel = min(len(view) - 1, sel + viewport) if view else 0
+            elif key == "home" or (not typing and key == "g"):
+                sel = 0
+            elif key == "end" or (not typing and key == "G"):
+                sel = max(0, len(view) - 1)
+            elif key == "enter":
+                if typing:
+                    typing = False  # keep the filter, back to moving
+                elif view:
+                    return view[sel][0], row_index(view[sel])
+            elif key == "esc":
+                if typing or query:
+                    typing, query = False, ""
+                else:
+                    return None, sel
+            elif key == "quit" or (not typing and key == "q"):
+                return None, (row_index(view[sel]) if view else 0)
+            elif typing:
+                if key == "backspace":
+                    if query:
+                        query = query[:-1]
+                    else:
+                        typing = False
+                elif len(key) == 1 and key.isprintable():
+                    query += key
+                    sel = 0  # a narrowed list re-anchors at its best (first) match
+            elif key == "/":
+                typing = True
+
+
+def _run_pager(fd: int, lines: list[Text], *, back_hint: str) -> None:
+    """The detail screen: a captured view as a scrollable page. Esc/q/←/backspace climbs back
+    up to the list; ↑↓, PgUp/PgDn, and space scroll when the content is taller than the
+    terminal. Returns when the user leaves."""
+    top = 0
+    pending: list[str] = []
+    with Live(console=console, transient=True, auto_refresh=False) as live:
+        while True:
+            viewport = max(3, console.size.height - 3)
+            top = pager_top(top, viewport, len(lines))
+            window: list[Any] = list(lines[top:top + viewport])
+            if len(lines) > viewport:
+                pos = f"{top + 1}–{min(top + viewport, len(lines))}/{len(lines)}"
+                status = f"  [slab.dim]{pos} · ↑↓ scroll · esc {back_hint}[/]"
+            else:
+                status = f"  [slab.dim]esc {back_hint}[/]"
+            window.append(Text.from_markup(status))
+            live.update(Group(*window), refresh=True)
+
+            if not pending:
+                pending = _read_keys(fd)
+            if not pending:
+                continue
+            key = pending.pop(0)
+
+            if key in ("up", "k"):
+                top -= 1
+            elif key in ("down", "j", "enter"):
+                top += 1
+            elif key in ("pgup",):
+                top -= viewport
+            elif key in ("pgdn", " "):
+                top += viewport
+            elif key in ("home", "g"):
+                top = 0
+            elif key in ("end", "G"):
+                top = len(lines)
+            elif key in ("esc", "q", "left", "backspace", "quit"):
+                return
+
+
+def _capture_lines(render: Callable[[], None]) -> list[Text]:
+    """Run a print-to-console renderer and capture its output as styled lines for the pager."""
+    with console.capture() as cap:
+        render()
+    lines = [Text.from_ansi(line) for line in cap.get().splitlines()]
+    while lines and not lines[-1].plain.strip():
+        lines.pop()
+    while lines and not lines[0].plain.strip():
+        lines.pop(0)
+    return lines or [Text.from_markup("[slab.dim]Nothing to show.[/]")]
+
+
+def browse(
+    columns: list[tuple[str, dict]],
+    rows: list[Row],
+    *,
+    title: str,
+    note: str | None = None,
+    hint: str = "open",
+    footer: str | None = None,
+    start: int = 0,
+    detail: Callable[[Any], None] | None = None,
+) -> Any | None:
+    """Browse `rows` interactively. `columns` is the same `(header, kwargs)` spec `slab_table`
+    takes; each row is `(item, cells)` with one markup string per column. `hint` names what
+    Enter does in the footer (e.g. "market view"); `start` pre-selects a row.
+
+    With a `detail` callback, Enter drills down: `detail(item)` runs (it may fetch and must
+    print to the console), its output replaces the list as a scrollable page, and leaving the
+    page returns to the list on the same row — the loop lives here, and browse returns None
+    when the user finally quits. Without `detail`, Enter returns the chosen item directly.
+
+    Quitting from the list prints the plain table (with `footer`) as a scrollback receipt. On
+    a non-interactive stdout/stdin the static table is printed instead and None returned.
+    """
+    if not rows:
+        return None
+    if not _interactive_ok():
+        print_table(columns, rows, title=title, note=note, footer=footer)
+        return None
+
+    import termios
+    import tty
+
+    fd = sys.stdin.fileno()
+    saved = termios.tcgetattr(fd)
+    picked: Any | None = None
+    sel = start
+    try:
+        tty.setcbreak(fd)
+        while True:
+            item, sel = _run_list(fd, columns, rows, title=title, note=note,
+                                  hint=hint, start=sel)
+            if item is None:
+                break
+            if detail is None:
+                picked = item
+                break
+            _run_pager(fd, _capture_lines(lambda: detail(item)), back_hint="back to list")
+    except KeyboardInterrupt:
+        pass
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, saved)
+
+    if picked is not None:
+        return picked
+    # Quit: leave the classic table behind so the results live on in scrollback.
+    print_table(columns, rows, title=title, note=note, footer=footer)
+    return None

{slab_cli-0.5.0 → slab_cli-0.7.0}/src/slab_cli/commands/breaks.py

@@ -10,7 +10,7 @@ from slab_schemas.enums import BreakType
 
 from ..client import SlabClient
 from ..context import ctx
-from ..display import console, print_breaks, render_break_pulls
+from ..display import browse_breaks, console, render_break_pulls
 from ..prompts import (
     ask_date,
     ask_decimal,
@@ -85,15 +85,11 @@ def create_break_interactive(client: SlabClient, collector: str) -> BreakOut | N
 
 
 def cmd_break_list(args: list[str]) -> None:
-    """`slab break list` — your breaks, then pick one to see what it delivered (value vs cost,
-    the top pulls, the rarest pulls). Skippable — the list stays on screen either way."""
+    """`slab break list` — your breaks as a scrollable list; Enter drills into what one
+    delivered (value vs cost, the top pulls, the rarest pulls), Esc climbs back, q leaves the
+    plain table behind. Piped output prints the plain table."""
     result = ctx.client.search_breaks(ctx.collector, BreakSearchQuery(limit=25))
-    print_breaks(result)
-    if not result.items:
-        return
-    choice = select_break(result, allow_new=False)
-    if isinstance(choice, BreakOut):
-        _show_break_pulls(choice)
+    browse_breaks(result, detail=_show_break_pulls)
 
 
 def _show_break_pulls(brk: BreakOut) -> None:

{slab_cli-0.5.0 → slab_cli-0.7.0}/src/slab_cli/commands/catalog.py

@@ -7,7 +7,14 @@ import re
 from slab_schemas.cards import CardSearchQuery, SetSearchQuery
 
 from ..context import ctx
-from ..display import console, print_cards, print_sets, render_community_board
+from ..display import (
+    browse_cards,
+    browse_sets,
+    console,
+    render_card_market,
+    render_community_board,
+    render_set_market,
+)
 from ..flags import CARD_SEARCH_FLAGS, SET_SEARCH_FLAGS, parse_flags
 from ..picker import pick_card
 from ..prompts import ask_text
@@ -31,6 +38,9 @@ def cmd_search(args: list[str]) -> None:
     Every flag combines with AND; repeat an any-of flag (--team, --brand, --finish…) to widen it.
 
     Sort keys: year, card_number, numbered, subject, brand, set (prefix - for descending).
+
+    In a terminal the results are a scrollable list — Enter drills into the highlighted
+    card's market view, Esc climbs back. Piped output prints the plain table.
     """
     if not args:
         args = [ask_text("Search cards:")]
@@ -38,7 +48,11 @@ def cmd_search(args: list[str]) -> None:
     values, q = parse_flags(args, CARD_SEARCH_FLAGS)
     values.setdefault("limit", 25)
     result = ctx.client.search_cards(CardSearchQuery(q=q, **values))
-    print_cards(result)
+
+    def market_view(c) -> None:
+        render_card_market(ctx.client.get_card_market(c.uuid))
+
+    browse_cards(result, detail=market_view)
 
 
 cmd_search.flags = CARD_SEARCH_FLAGS
@@ -47,6 +61,12 @@ cmd_search.flags = CARD_SEARCH_FLAGS
 def cmd_sets(args: list[str]) -> None:
     """Browse sets / products, optionally narrowed by brand, year, or sport.
 
+    In a terminal the results are a scrollable list: ↑↓ (or j/k) move, / type-to-filters
+    across every column, Enter drills into the highlighted set's market view (sealed FMV +
+    top cards) as its own page — Esc climbs back up to the list, same row — and q quits,
+    leaving the plain table behind. Piped or redirected output prints the plain table
+    directly, so scripting is unchanged.
+
     Examples:
       slab set search "sp authentic"
       slab set search --brand "Upper Deck" --year 2025
@@ -54,7 +74,13 @@ def cmd_sets(args: list[str]) -> None:
     values, q = parse_flags(args, SET_SEARCH_FLAGS)
     values.setdefault("limit", 25)
     result = ctx.client.search_sets(SetSearchQuery(q=q, **values))
-    print_sets(result)
+
+    def market_view(s) -> None:
+        sealed = ctx.client.get_set_sealed(s.uuid)
+        top = ctx.client.get_set_top_cards(s.uuid, limit=10)
+        render_set_market(s, sealed, top)
+
+    browse_sets(result, detail=market_view)
 
 
 cmd_sets.flags = SET_SEARCH_FLAGS

{slab_cli-0.5.0 → slab_cli-0.7.0}/src/slab_cli/commands/collection.py

@@ -22,10 +22,12 @@ from ..flags import COLLECTION_SEARCH_FLAGS, parse_flags
 from ..paging import fetch_all_pages
 from ..picker import pick_card
 from ..display import (
+    browse_collection,
     console,
     format_card_summary,
     format_grade_delta,
-    print_collection,
+    print_collection_summary,
+    render_card_market,
     render_dashboard,
 )
 from ..prompts import (
@@ -605,6 +607,9 @@ def cmd_search(args: list[str]) -> None:
 
     Sort keys: acquired_date, acquisition_cost, numbered, year, card_number, brand, set,
     fmv, unrealized, roi (prefix - for descending).
+
+    In a terminal the results are a scrollable list — Enter drills into the highlighted
+    copy's market view, Esc climbs back. Piped output prints the plain table.
     """
     if not args:
         total = ctx.client.search_collection(ctx.collector, CollectionSearchQuery(limit=1)).total
@@ -616,7 +621,15 @@ def cmd_search(args: list[str]) -> None:
     values, q = parse_flags(args, COLLECTION_SEARCH_FLAGS)
     values.setdefault("limit", 25)
     result = ctx.client.search_collection(ctx.collector, CollectionSearchQuery(q=q, **values))
-    print_collection(result)
+
+    def market_view(cp) -> None:
+        if cp.card is None:
+            console.print("[slab.dim]This copy isn't linked to a catalog card.[/]")
+            return
+        render_card_market(ctx.client.get_card_market(cp.card.uuid))
+
+    browse_collection(result, detail=market_view)
+    print_collection_summary(result)
 
 
 cmd_search.flags = COLLECTION_SEARCH_FLAGS

{slab_cli-0.5.0 → slab_cli-0.7.0}/src/slab_cli/commands/custom_sets.py

@@ -16,10 +16,10 @@ from slab_schemas.enums import CustomSetType, MatchMode, Visibility
 from ..client import SlabClient
 from ..context import ctx
 from ..display import (
+    browse_custom_sets,
     console,
     format_card_summary,
     print_custom_set_detail,
-    print_custom_sets,
 )
 from ..picker import search_and_pick_subject
 from ..prompts import (
@@ -348,10 +348,16 @@ def cmd_chase_edit(args: list[str]) -> None:
 # slab chase list — your custom sets
 # ---------------------------------------------------------------------------
 
+def _chase_detail(s) -> None:
+    """The drill-in for a browsed chase set: its full card list + completion, owner-aware."""
+    print_custom_set_detail(ctx.client.get_custom_set(s.uuid, ctx.collector))
+
+
 def cmd_chase_list(args: list[str]) -> None:
-    """List your custom sets (created + subscribed)."""
+    """List your custom sets (created + subscribed) as a scrollable list; Enter drills into a
+    set's cards + completion, Esc climbs back."""
     sets = ctx.client.collector_custom_sets(ctx.collector)
-    print_custom_sets(sets)
+    browse_custom_sets(sets, detail=_chase_detail)
 
 
 # ---------------------------------------------------------------------------
@@ -375,7 +381,7 @@ def cmd_chase_find(args: list[str]) -> None:
     if not sets:
         console.print("[yellow]No matching sets found.[/yellow]")
         return
-    print_custom_sets(sets)
+    browse_custom_sets(sets, detail=_chase_detail)
     console.print(
         "[dim]`slab chase subscribe` to track one · `slab chase view <uuid>` to see its cards.[/dim]"
     )