slab-cli 0.6.0__tar.gz → 0.8.0__tar.gz

{slab_cli-0.6.0 → slab_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.6.0
+Version: 0.8.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

{slab_cli-0.6.0 → slab_cli-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slab-cli"
-version = "0.6.0"
+version = "0.8.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.8.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.6.0 → slab_cli-0.8.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.6.0 → slab_cli-0.8.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.6.0 → slab_cli-0.8.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 (
@@ -140,7 +142,9 @@ def _collect_grade_details() -> tuple[str | None, str | None, str | None, str |
     grading_company = grade = cert_number = None
     if confirm("Is it professionally graded?", default=False):
         grading_company = select_grading_company()
-        grade = ask_text_optional("Pro grade (e.g. 10, 9.5, Authentic — enter to skip):")
+        # Required with the company: the (company, grade) pair is the copy's price key — the API
+        # rejects one without the other (a half-entered slab would price as RAW).
+        grade = ask_text("Pro grade (e.g. 10, 9.5, Authentic):")
         cert_number = ask_text_optional("Cert number (enter to skip):")
 
     return self_grade, grading_company, grade, cert_number
@@ -605,6 +609,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 +623,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.6.0 → slab_cli-0.8.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]"
     )

{slab_cli-0.6.0 → slab_cli-0.8.0}/src/slab_cli/commands/lots.py

@@ -12,7 +12,7 @@ from slab_schemas.collection import CollectionSearchQuery, LotCreate, LotOut, Lo
 
 from ..client import SlabClient
 from ..context import ctx
-from ..display import console, print_lots, render_lot_contents
+from ..display import browse_lots, console, render_lot_contents
 from ..prompts import ask_date, ask_decimal, confirm, select_lot
 from ..sources import pick_source
 
@@ -60,14 +60,11 @@ def create_lot_interactive(client: SlabClient, collector: str) -> LotOut | None:
 
 
 def cmd_lot_list(args: list[str]) -> None:
-    """`slab lot list` — your purchases, then pick one to see value vs cost + its cards."""
+    """`slab lot list` — your purchases as a scrollable list; Enter drills into one's value vs
+    cost + its cards, Esc climbs back, q leaves the plain table behind. Piped output prints
+    the plain table."""
     result = ctx.client.search_lots(ctx.collector, LotSearchQuery(limit=25))
-    print_lots(result)
-    if not result.items:
-        return
-    choice = select_lot(result, allow_new=False)
-    if isinstance(choice, LotOut):
-        _show_lot_contents(choice)
+    browse_lots(result, detail=_show_lot_contents)
 
 
 def _show_lot_contents(lot: LotOut) -> None:

{slab_cli-0.6.0 → slab_cli-0.8.0}/src/slab_cli/display.py

@@ -24,6 +24,7 @@ from slab_schemas.pricing import CardComps, CardMarket, PortfolioSummary, SetTop
 from slab_schemas.sealed import SealedPriceHistory, SealedProductOut
 from slab_schemas.timeseries import CardPriceHistory
 
+from .browse import browse
 from .theme import (
     bar,
     console,
@@ -88,162 +89,195 @@ def format_card_summary(card: CardOut) -> str:
     return f"{card.card_number}  {subjects} — {card.brand or ''} {card.set_name or ''} — {slot}{pr}{attrs}"
 
 
-def _more(shown: int, total: int, hint: str) -> None:
-    """Standard 'N of M shown' footer — one place so every list truncates the same way."""
-    if total > shown:
-        console.print(f"  [slab.dim]{shown} of {total} shown — {hint}[/]")
+def _shown_footer(shown: int, total: int, hint: str) -> str | None:
+    """Standard 'N of M shown' footer text — one place so every list truncates the same way."""
+    return f"{shown} of {total} shown — {hint}" if total > shown else None
 
 
-def print_cards(result: CardSearchResult) -> None:
-    if not result.items:
-        console.print("[slab.dim]No cards found.[/]")
-        return
+CARD_COLUMNS = [
+    ("Number", {"style": "slab.value"}),
+    ("Subject(s)", {}),
+    ("Set", {}),
+    ("Subset", {}),
+    ("Finish", {"style": "slab.accent"}),
+    ("Attrs", {"style": "slab.dim"}),
+    ("Run", {"justify": "right", "style": "slab.dim"}),
+    ("UUID", {"style": "slab.muted"}),
+]
 
-    table = slab_table([
-        ("Number", {"style": "slab.value"}),
-        ("Subject(s)", {}),
-        ("Set", {}),
-        ("Subset", {}),
-        ("Finish", {"style": "slab.accent"}),
-        ("Attrs", {"style": "slab.dim"}),
-        ("Run", {"justify": "right", "style": "slab.dim"}),
-        ("UUID", {"style": "slab.muted"}),
-    ])
 
-    for c in result.items:
-        subjects = ", ".join(s.name for s in c.subjects)
-        attrs = ", ".join(a.name for a in c.attributes)
-        finish = c.finish or "[slab.dim]Base[/]"
-        pr = f"/{c.print_run}" if c.print_run else ""
-        table.add_row(
-            c.card_number, subjects, c.set_name or "", c.subset or "",
-            finish, attrs, pr, c.uuid[:8],
-        )
+def card_cells(c: CardOut) -> list[str]:
+    """One catalog card as its CARD_COLUMNS cells."""
+    subjects = ", ".join(s.name for s in c.subjects)
+    attrs = ", ".join(a.name for a in c.attributes)
+    finish = c.finish or "[slab.dim]Base[/]"
+    pr = f"/{c.print_run}" if c.print_run else ""
+    return [c.card_number, subjects, c.set_name or "", c.subset or "", finish, attrs, pr, c.uuid[:8]]
 
-    console.print(heading("Cards", f"{result.total} total"))
-    console.print(table)
-    _more(len(result.items), result.total, "narrow your search, or `--limit N` to see more.")
 
+def browse_cards(result: CardSearchResult, *, detail=None) -> CardOut | None:
+    """Browse a card search. With `detail` (a `CardOut -> None` renderer), Enter drills into
+    that view as a page; Esc climbs back. Static table on non-interactive output."""
+    if not result.items:
+        console.print("[slab.dim]No cards found.[/]")
+        return None
+    return browse(
+        CARD_COLUMNS, [(c, card_cells(c)) for c in result.items],
+        title="Cards", note=f"{result.total} total", hint="market view",
+        footer=_shown_footer(len(result.items), result.total,
+                             "narrow your search, or `--limit N` to see more."),
+        detail=detail,
+    )
 
-def print_sets(result: SetSearchResult) -> None:
+
+SET_COLUMNS = [
+    ("Name", {"style": "slab.value"}),
+    ("Brand", {}),
+    ("Cards", {"justify": "right", "style": "slab.dim"}),
+    ("Priced", {"justify": "right"}),
+    ("Sales/90d", {"justify": "right", "style": "slab.dim"}),
+    ("Box FMV", {"justify": "right"}),
+]
+
+
+def set_cells(s: SetOut) -> list[str]:
+    """One set as its SET_COLUMNS cells — shared by the static table and the browse view."""
+    # Priced = printings with a sale in the past 90 days; the % against the full card
+    # count says how much of the set the market actually prices (color = health band).
+    priced = "[slab.dim]—[/]"
+    if s.priced_count:
+        pct = f" ({pct_coverage(100 * s.priced_count / s.card_count)})" if s.card_count else ""
+        priced = f"{s.priced_count:,}{pct}"
+    box = f"[slab.foil]{money(s.box_price)}[/]" if s.box_price is not None else "[slab.dim]—[/]"
+    return [
+        s.name or "", s.brand or "",
+        f"{s.card_count or 0:,}",
+        priced,
+        f"{s.sales_90d:,}" if s.sales_90d else "[slab.dim]—[/]",
+        box,
+    ]
+
+
+def _set_footer(result: SetSearchResult) -> str | None:
+    if result.total > len(result.items):
+        return (f"{len(result.items)} of {result.total} shown — "
+                "narrow with a query (e.g. `slab set search platinum`).")
+    return None
+
+
+def browse_sets(result: SetSearchResult, *, detail=None) -> SetOut | None:
+    """Browse a set search interactively. With `detail` (a `SetOut -> None` renderer), Enter
+    drills into that view as a page and Esc climbs back to the list; the loop lives inside
+    `browse`. Falls back to the static table on non-interactive output."""
     if not result.items:
         console.print("[slab.dim]No sets found.[/]")
-        return
+        return None
+    return browse(
+        SET_COLUMNS, [(s, set_cells(s)) for s in result.items],
+        title="Sets", note=f"{result.total} total", hint="market view",
+        footer=_set_footer(result), detail=detail,
+    )
 
-    table = slab_table([
-        ("Name", {"style": "slab.value"}),
-        ("Brand", {}),
-        ("Cards", {"justify": "right", "style": "slab.dim"}),
-        ("Priced", {"justify": "right"}),
-        ("Sales/90d", {"justify": "right", "style": "slab.dim"}),
-        ("Box FMV", {"justify": "right"}),
-    ])
 
-    for s in result.items:
-        # Priced = printings with a sale in the past 90 days; the % against the full card
-        # count says how much of the set the market actually prices (color = health band).
-        priced = "[slab.dim]—[/]"
-        if s.priced_count:
-            pct = f" ({pct_coverage(100 * s.priced_count / s.card_count)})" if s.card_count else ""
-            priced = f"{s.priced_count:,}{pct}"
-        box = f"[slab.foil]{money(s.box_price)}[/]" if s.box_price is not None else "[slab.dim]—[/]"
-        table.add_row(
-            s.name or "", s.brand or "",
-            f"{s.card_count or 0:,}",
-            priced,
-            f"{s.sales_90d:,}" if s.sales_90d else "[slab.dim]—[/]",
-            box,
-        )
+COLLECTION_COLUMNS = [
+    ("Card #", {"style": "slab.value"}),
+    ("Subject(s)", {}),
+    ("Set", {}),
+    ("Finish", {"style": "slab.accent"}),
+    ("Grade", {"style": "slab.dim"}),
+    ("Cost Basis", {"justify": "right"}),
+    ("FMV", {"justify": "right"}),
+    ("Gain/Loss", {"justify": "right"}),
+]
 
-    console.print(heading("Sets", f"{result.total} total"))
-    console.print(table)
-    _more(len(result.items), result.total, "narrow with a query (e.g. `slab set search platinum`).")
+
+def collection_cells(cp) -> list[str]:
+    """One owned copy as its COLLECTION_COLUMNS cells."""
+    card = cp.card
+    subjects = ", ".join(s.name for s in card.subjects) if card and card.subjects else "—"
+    set_name = (card.set_name or "") if card else ""
+    finish = ((card.finish if card else None) or "[slab.dim]Base[/]")
+    card_num = card.card_number if card else "—"
+    grade = _format_collection_grade(cp)
+    basis = money(cp.cost_basis) if cp.cost_basis is not None else "[slab.dim]—[/]"
+    fmv = "[slab.dim]—[/]"
+    gain = "[slab.dim]—[/]"
+    if cp.market and cp.market.fair_market_value is not None:
+        fmv = f"[slab.foil]{money(cp.market.fair_market_value)}[/]"
+        gain = signed_money(cp.market.unrealized_gain_loss)
+    return [card_num, subjects, set_name, finish, grade, basis, fmv, gain]
 
 
-def print_collection(result: CollectionResult) -> None:
+def print_collection_summary(result: CollectionResult) -> None:
+    """The financial totals line under a collection search — from the server's summary block."""
+    if not result.summary:
+        return
+    s = result.summary
+    parts = []
+    if s.total_acquisition_cost is not None:
+        parts.append(f"[slab.label]Acquisition[/] {money(s.total_acquisition_cost)}")
+    if s.total_additional_costs is not None:
+        parts.append(f"[slab.label]Additional[/] {money(s.total_additional_costs)}")
+    if s.total_cost_basis is not None:
+        parts.append(f"[slab.label]Cost Basis[/] {money(s.total_cost_basis)}")
+    if isinstance(s, PortfolioSummary) and s.portfolio_value is not None:
+        parts.append(f"[slab.label]FMV[/] [slab.foil]{money(s.portfolio_value)}[/]")
+        if s.total_unrealized_gain_loss is not None:
+            parts.append(f"[slab.label]Unrealized[/] {signed_money(s.total_unrealized_gain_loss)}")
+    if parts:
+        console.print("  " + "     ".join(parts))
+
+
+def browse_collection(result: CollectionResult, *, detail=None) -> None:
+    """Browse a collection search. With `detail` (a copy -> None renderer), Enter drills into
+    the copy's market view; Esc climbs back. Static table on non-interactive output."""
     if not result.items:
         console.print("[dim]No cards in your collection matching that search.[/dim]")
         if result.total == 0:
             console.print("  [dim]Use `slab collection add` to start cataloging cards.[/dim]")
         return
+    matches = f"{result.total} match{'' if result.total == 1 else 'es'}"
+    browse(
+        COLLECTION_COLUMNS, [(cp, collection_cells(cp)) for cp in result.items],
+        title="Collection", note=matches, hint="market view",
+        footer=_shown_footer(len(result.items), result.total,
+                             "narrow your search, or `slab export` for the full list."),
+        detail=detail,
+    )
 
-    table = slab_table([
-        ("Card #", {"style": "slab.value"}),
-        ("Subject(s)", {}),
-        ("Set", {}),
-        ("Finish", {"style": "slab.accent"}),
-        ("Grade", {"style": "slab.dim"}),
-        ("Cost Basis", {"justify": "right"}),
-        ("FMV", {"justify": "right"}),
-        ("Gain/Loss", {"justify": "right"}),
-    ])
 
-    for cp in result.items:
-        card = cp.card
-        subjects = ", ".join(s.name for s in card.subjects) if card and card.subjects else "—"
-        set_name = (card.set_name or "") if card else ""
-        finish = ((card.finish if card else None) or "[slab.dim]Base[/]")
-        card_num = card.card_number if card else "—"
-        grade = _format_collection_grade(cp)
-        basis = money(cp.cost_basis) if cp.cost_basis is not None else "[slab.dim]—[/]"
-        fmv = "[slab.dim]—[/]"
-        gain = "[slab.dim]—[/]"
-        if cp.market and cp.market.fair_market_value is not None:
-            fmv = f"[slab.foil]{money(cp.market.fair_market_value)}[/]"
-            gain = signed_money(cp.market.unrealized_gain_loss)
-        table.add_row(card_num, subjects, set_name, finish, grade, basis, fmv, gain)
+BREAK_COLUMNS = [
+    ("Set", {"style": "slab.value"}),
+    ("Type", {"style": "slab.dim"}),
+    ("Cost", {"justify": "right"}),
+    ("Cards", {"justify": "right", "style": "slab.dim"}),
+    ("$/Card", {"justify": "right", "style": "slab.dim"}),
+    ("Date", {"style": "slab.dim"}),
+    ("Source", {"style": "slab.dim"}),
+    ("UUID", {"style": "slab.muted"}),
+]
 
-    matches = f"{result.total} match{'' if result.total == 1 else 'es'}"
-    console.print(heading("Collection", matches))
-    console.print(table)
 
-    if result.summary:
-        s = result.summary
-        parts = []
-        if s.total_acquisition_cost is not None:
-            parts.append(f"[slab.label]Acquisition[/] {money(s.total_acquisition_cost)}")
-        if s.total_additional_costs is not None:
-            parts.append(f"[slab.label]Additional[/] {money(s.total_additional_costs)}")
-        if s.total_cost_basis is not None:
-            parts.append(f"[slab.label]Cost Basis[/] {money(s.total_cost_basis)}")
-        if isinstance(s, PortfolioSummary) and s.portfolio_value is not None:
-            parts.append(f"[slab.label]FMV[/] [slab.foil]{money(s.portfolio_value)}[/]")
-            if s.total_unrealized_gain_loss is not None:
-                parts.append(f"[slab.label]Unrealized[/] {signed_money(s.total_unrealized_gain_loss)}")
-        if parts:
-            console.print("  " + "     ".join(parts))
-
-    _more(len(result.items), result.total, "narrow your search, or `slab export` for the full list.")
-
-
-def print_breaks(result: BreakSearchResult) -> None:
+def break_cells(b) -> list[str]:
+    """One break as its BREAK_COLUMNS cells."""
+    cpc = money(b.cost_per_card) if b.cost_per_card is not None else "—"
+    return [b.set_name or "", b.break_type, money(b.total_cost), str(b.copy_count), cpc,
+            str(b.break_date or "—"), b.source or "—", b.uuid[:8]]
+
+
+def browse_breaks(result: BreakSearchResult, *, detail=None) -> None:
+    """Browse your breaks. With `detail` (a BreakOut -> None renderer), Enter drills into the
+    break's report card (value vs cost + top pulls); Esc climbs back."""
     if not result.items:
         console.print("[slab.dim]No breaks found.[/]")
         console.print("  [slab.dim]Use `slab break new` to record opening a pack, box, or case.[/]")
         return
-
-    table = slab_table([
-        ("Set", {"style": "slab.value"}),
-        ("Type", {"style": "slab.dim"}),
-        ("Cost", {"justify": "right"}),
-        ("Cards", {"justify": "right", "style": "slab.dim"}),
-        ("$/Card", {"justify": "right", "style": "slab.dim"}),
-        ("Date", {"style": "slab.dim"}),
-        ("Source", {"style": "slab.dim"}),
-        ("UUID", {"style": "slab.muted"}),
-    ])
-
-    for b in result.items:
-        cpc = money(b.cost_per_card) if b.cost_per_card is not None else "—"
-        table.add_row(
-            b.set_name or "", b.break_type, money(b.total_cost),
-            str(b.copy_count), cpc, str(b.break_date or "—"),
-            b.source or "—", b.uuid[:8],
-        )
-
-    console.print(heading("Breaks", f"{result.total} total"))
-    console.print(table)
-    _more(len(result.items), result.total, "refine with filters.")
+    browse(
+        BREAK_COLUMNS, [(b, break_cells(b)) for b in result.items],
+        title="Breaks", note=f"{result.total} total", hint="break report",
+        footer=_shown_footer(len(result.items), result.total, "refine with filters."),
+        detail=detail,
+    )
 
 
 def _pull_row(cp) -> tuple[str, str, str, str, str]:
@@ -322,31 +356,36 @@ def render_break_pulls(brk, result: CollectionResult) -> None:
     console.print()
 
 
-def print_lots(result: LotSearchResult) -> None:
+LOT_COLUMNS = [
+    ("Date", {"style": "slab.dim"}),
+    ("Cost", {"justify": "right"}),
+    ("Cards", {"justify": "right", "style": "slab.dim"}),
+    ("$/Card", {"justify": "right", "style": "slab.dim"}),
+    ("Source", {"style": "slab.dim"}),
+    ("UUID", {"style": "slab.muted"}),
+]
+
+
+def lot_cells(lot) -> list[str]:
+    """One purchase lot as its LOT_COLUMNS cells."""
+    cpc = money(lot.cost_per_card) if lot.cost_per_card is not None else "—"
+    return [str(lot.lot_date or "—"), money(lot.total_cost), str(lot.copy_count), cpc,
+            lot.source or "—", lot.uuid[:8]]
+
+
+def browse_lots(result: LotSearchResult, *, detail=None) -> None:
+    """Browse your purchases. With `detail` (a LotOut -> None renderer), Enter drills into the
+    purchase's report card (value vs cost + its cards); Esc climbs back."""
     if not result.items:
         console.print("[slab.dim]No purchases found.[/]")
         console.print("  [slab.dim]Use `slab lot new` to record a multi-card buy (an eBay bundle, a show pickup).[/]")
         return
-
-    table = slab_table([
-        ("Date", {"style": "slab.dim"}),
-        ("Cost", {"justify": "right"}),
-        ("Cards", {"justify": "right", "style": "slab.dim"}),
-        ("$/Card", {"justify": "right", "style": "slab.dim"}),
-        ("Source", {"style": "slab.dim"}),
-        ("UUID", {"style": "slab.muted"}),
-    ])
-
-    for lot in result.items:
-        cpc = money(lot.cost_per_card) if lot.cost_per_card is not None else "—"
-        table.add_row(
-            str(lot.lot_date or "—"), money(lot.total_cost),
-            str(lot.copy_count), cpc, lot.source or "—", lot.uuid[:8],
-        )
-
-    console.print(heading("Purchases", f"{result.total} total"))
-    console.print(table)
-    _more(len(result.items), result.total, "refine with filters.")
+    browse(
+        LOT_COLUMNS, [(lot, lot_cells(lot)) for lot in result.items],
+        title="Purchases", note=f"{result.total} total", hint="purchase report",
+        footer=_shown_footer(len(result.items), result.total, "refine with filters."),
+        detail=detail,
+    )
 
 
 def render_lot_contents(lot, result: CollectionResult) -> None:
@@ -724,34 +763,41 @@ def render_community_board(b: CommunityBoard) -> None:
 # Custom sets
 # ---------------------------------------------------------------------------
 
-def print_custom_sets(result: CustomSetSearchResult | list[CustomSetOut]) -> None:
+CUSTOM_SET_COLUMNS = [
+    ("Name", {"style": "slab.value"}),
+    ("Type", {"style": "slab.dim"}),
+    ("Vis", {"justify": "center"}),
+    ("Cards", {"justify": "right", "style": "slab.dim"}),
+    ("Subs", {"justify": "right", "style": "slab.dim"}),
+    ("Creator", {}),
+    ("UUID", {"style": "slab.muted"}),
+]
+
+
+def custom_set_cells(s: CustomSetOut) -> list[str]:
+    """One chase set as its CUSTOM_SET_COLUMNS cells."""
+    vis = "🔒" if s.visibility == "private" else "🌐"
+    sub_marker = " [slab.gain]✓[/]" if s.is_subscribed else ""
+    return [s.name, s.set_type, vis, str(s.card_count),
+            f"{s.subscriber_count}{sub_marker}", s.creator_name or "—", s.uuid[:8]]
+
+
+def browse_custom_sets(
+    result: CustomSetSearchResult | list[CustomSetOut], *, detail=None,
+) -> CustomSetOut | None:
+    """Browse chase sets. With `detail` (a CustomSetOut -> None renderer), Enter drills into
+    the set's card list + completion; Esc climbs back."""
     items = result.items if isinstance(result, CustomSetSearchResult) else result
     if not items:
         console.print("[dim]No custom sets found.[/dim]")
         console.print("  [dim]Use `slab chase create` to make one.[/dim]")
-        return
-
+        return None
     total = result.total if isinstance(result, CustomSetSearchResult) else len(items)
-    table = slab_table([
-        ("Name", {"style": "slab.value"}),
-        ("Type", {"style": "slab.dim"}),
-        ("Vis", {"justify": "center"}),
-        ("Cards", {"justify": "right", "style": "slab.dim"}),
-        ("Subs", {"justify": "right", "style": "slab.dim"}),
-        ("Creator", {}),
-        ("UUID", {"style": "slab.muted"}),
-    ])
-
-    for s in items:
-        vis = "🔒" if s.visibility == "private" else "🌐"
-        sub_marker = " [slab.gain]✓[/]" if s.is_subscribed else ""
-        table.add_row(
-            s.name, s.set_type, vis, str(s.card_count),
-            f"{s.subscriber_count}{sub_marker}", s.creator_name or "—", s.uuid[:8],
-        )
-
-    console.print(heading("Custom Sets", f"{total} total"))
-    console.print(table)
+    return browse(
+        CUSTOM_SET_COLUMNS, [(s, custom_set_cells(s)) for s in items],
+        title="Custom Sets", note=f"{total} total", hint="set detail",
+        detail=detail,
+    )
 
 
 def print_custom_set_detail(detail: CustomSetDetail) -> None: