nabla-cli 0.3.0__tar.gz → 0.4.1__tar.gz

{nabla_cli-0.3.0 → nabla_cli-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.3.0
+Version: 0.4.1
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11

{nabla_cli-0.3.0 → nabla_cli-0.4.1}/nabla/__init__.py

@@ -1,3 +1,3 @@
 """nabla — call-site harvester CLI (pre-Phase-0)."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.1"

nabla_cli-0.4.1/nabla/branding.py

@@ -0,0 +1,74 @@
+"""nabla terminal branding: the ∇ logo and startup banner.
+
+The banner prints only on a real terminal — piped output, tests, and
+--json consumers never see it. Block glyphs render via the Windows
+console's UTF-16 writer, so no legacy-codepage fallback is needed on an
+interactive console.
+"""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.text import Text
+
+from . import __version__
+
+# Uniform thick strokes like the wordmark: solid bar, solid diagonals,
+# single-block apex. Terminal cells are ~2:1 tall, so 6 rows x 11 cols
+# reads close to the mark's near-equilateral proportions.
+_LOGO = [
+    "█▀▀▀▀▀▀▀▀▀█",
+    " █       █",
+    "  █     █",
+    "   █   █",
+    "    █ █",
+    "     █",
+]
+
+_BRAND_STYLE = "bold cyan"
+
+
+def banner_lines() -> list[tuple[str, str, str]]:
+    """(logo_line, tagline, tagline_style) triples; outer rows have no tagline."""
+    taglines = [
+        ("", ""),
+        ("nabla", "bold"),
+        (f"v{__version__} · OpenAI call-site harvester", ""),
+        ("scan · record · profile", "cyan"),
+        ("", ""),
+        ("", ""),
+    ]
+    return [(logo, text, style) for logo, (text, style) in zip(_LOGO, taglines)]
+
+
+def _compose(reveal: int | None = None, with_taglines: bool = True) -> Text:
+    frame = Text()
+    for logo_line, tagline, tag_style in banner_lines():
+        segment = logo_line if reveal is None else logo_line[:reveal]
+        frame.append(f"  {segment:<14}", style=_BRAND_STYLE)
+        if with_taglines and tagline:
+            frame.append(tagline, style=tag_style)
+        frame.append("\n")
+    return frame
+
+
+def print_banner(console: Console | None = None, animate: bool = False) -> None:
+    console = console or Console()
+    if not console.is_terminal:
+        return
+    console.print()
+    if animate:
+        import time
+
+        from rich.live import Live
+
+        width = max(len(line) for line, _, _ in banner_lines())
+        with Live(console=console, refresh_per_second=60, transient=False) as live:
+            # The mark draws itself in, left to right; the words arrive last.
+            for cut in range(width + 1):
+                live.update(_compose(reveal=cut, with_taglines=False))
+                time.sleep(0.028)
+            live.update(_compose())
+    else:
+        console.print(_compose(), end="")
+    console.print()

{nabla_cli-0.3.0 → nabla_cli-0.4.1}/nabla/cli.py

@@ -191,15 +191,41 @@ def main(argv: list[str] | None = None) -> int:
     return commands[args.command](args)
 
 
+def _clipboard_text() -> str:
+    """Windows clipboard contents (CF_UNICODETEXT), or "" on any failure."""
+    try:
+        import ctypes
+
+        CF_UNICODETEXT = 13
+        user32, kernel32 = ctypes.windll.user32, ctypes.windll.kernel32
+        if not user32.OpenClipboard(0):
+            return ""
+        try:
+            handle = user32.GetClipboardData(CF_UNICODETEXT)
+            if not handle:
+                return ""
+            locked = kernel32.GlobalLock(handle)
+            if not locked:
+                return ""
+            try:
+                return ctypes.c_wchar_p(locked).value or ""
+            finally:
+                kernel32.GlobalUnlock(handle)
+        finally:
+            user32.CloseClipboard()
+    except Exception:
+        return ""
+
+
 def _read_api_key(prompt: str) -> str:
     """Read a secret with visible masking: one `*` per character, backspace
-    supported, pasting shows a `*` per pasted character — so the user can
-    see that their input (typed or pasted) actually arrived. Falls back to
-    fully hidden input where character-level reading isn't available."""
+    supported, and Ctrl+V pastes from the clipboard (classic consoles don't
+    translate Ctrl+V into keystrokes, which silently swallowed pastes).
+    Falls back to fully hidden input where character reading isn't available."""
     if sys.platform == "win32" and sys.stdin.isatty():
         import msvcrt
 
-        print(prompt, end="", flush=True)
+        print(f"{prompt}(paste with Ctrl+V or right-click) ", end="", flush=True)
         chars: list[str] = []
         while True:
             ch = msvcrt.getwch()
@@ -208,7 +234,13 @@ def _read_api_key(prompt: str) -> str:
                 break
             if ch == "\x03":  # Ctrl+C
                 raise KeyboardInterrupt
-            if ch == "\b":
+            if ch == "\x16":  # Ctrl+V — classic console gives us the raw control char
+                pasted = _clipboard_text().strip()
+                for c in pasted:
+                    if c >= " ":
+                        chars.append(c)
+                print("*" * len(pasted), end="", flush=True)
+            elif ch == "\b":
                 if chars:
                     chars.pop()
                     print("\b \b", end="", flush=True)
@@ -220,24 +252,24 @@ def _read_api_key(prompt: str) -> str:
 
 
 def _cmd_init(args) -> int:
-    print_banner(_out)
+    from .ui import RAIL, rail, rail_end, rail_ok, rail_start, select
+
+    print_banner(_out, animate=True)
+    rail_start(_out, "nabla init")
+    rail(_out)
+
     provider = args.provider
     if provider is None:
         names = list(PROVIDERS)
-        _out.print("Pick a provider:", style="bold")
-        for i, name in enumerate(names, start=1):
-            _out.print(f"  [cyan]{i})[/cyan] [bold]{name}[/bold] — "
-                       f"{_PROVIDER_DESCRIPTIONS.get(name, '')}")
-        choice = input("> ").strip()
-        if choice.isdigit() and 1 <= int(choice) <= len(names):
-            provider = names[int(choice) - 1]
-        else:
-            provider = choice
+        options = [(name, _PROVIDER_DESCRIPTIONS.get(name, "")) for name in names]
+        provider = names[select(_out, "Provider", options)]
+    else:
+        rail(_out, f"Provider  {provider}")
 
     api_key = args.api_key
     if api_key is None:
         key_env = PROVIDERS.get(provider, {}).get("api_key_env", "API key")
-        api_key = _read_api_key(f"Paste your {key_env}: ")
+        api_key = _read_api_key(f"{RAIL} {key_env}  ")
 
     if not api_key:
         _fail("nabla init: no API key given")
@@ -250,12 +282,14 @@ def _cmd_init(args) -> int:
         return 2
 
     masked = f"...{api_key[-4:]}" if len(api_key) >= 4 else "..."
-    _ok(f"nabla init: saved to {path} (key: {masked})")
+    rail(_out)
+    rail_ok(_out, f"saved to {path} (key: {masked})")
     try:
         _ensure_scripts_on_path()
     except Exception:
         pass  # PATH help is best-effort; setup itself already succeeded
-    _next_step("nabla scan  (run it from inside the repo you want to harvest)")
+    rail(_out)
+    rail_end(_out, "next: nabla scan — run it from inside the repo you want to harvest")
     return 0
 
 
@@ -330,7 +364,9 @@ def _cmd_scan(args) -> int:
     for col in ("SYMBOL", "FILE", "KIND", "VERIFIABILITY", "HARVESTABLE", "FLAGS"):
         table.add_column(col, overflow="fold")
     supported_count = 0
-    for r in rows:
+    # Harvestable sites first — the reader's question is "what can I use?"
+    keyed = sorted(rows, key=lambda r: not is_supported(Verifiability(r["verifiability"]), r["flags"]))
+    for r in keyed:
         verif = r["verifiability"]
         harvestable = is_supported(Verifiability(verif), r["flags"])
         if harvestable:
@@ -342,12 +378,13 @@ def _cmd_scan(args) -> int:
         else:
             verif_color = "dim"
         table.add_row(
-            Text(r["symbol"], style="cyan"),
+            Text(r["symbol"], style="cyan" if harvestable else "dim"),
             r["file"],
             r["kind"],
             Text(verif, style=verif_color),
             Text("yes", style="green") if harvestable else Text("no", style="dim"),
             ",".join(r["flags"]) or "-",
+            style=None if harvestable else "dim",
         )
     _out.print(table)
     noun = "call site" if len(rows) == 1 else "call sites"
@@ -389,8 +426,8 @@ def _resolve_site(args, sites):
 
     if len(supported) == 1:
         site = supported[0]
-        _out.print(f"nabla: using site {site.symbol} (the only supported call site)",
-                   style="dim", markup=False)
+        from .ui import rail
+        rail(_out, f"using site {site.symbol} (the only supported call site)")
         return site, None
 
     candidates = supported or sites
@@ -410,10 +447,15 @@ def _resolve_site(args, sites):
 
 
 def _cmd_record(args) -> int:
+    from .ui import make_progress, rail, rail_end, rail_ok, rail_start
+
+    rail_start(_out, "nabla record")
     sites = scan(args.repo)
     site, err = _resolve_site(args, sites)
     if err is not None:
         return err
+    if args.site:
+        rail(_out, f"site {site.symbol} · {site.file}", style="dim")
 
     if _unconfigured():
         _warn(
@@ -432,7 +474,7 @@ def _cmd_record(args) -> int:
     else:
         conventional = Path(f"{site.symbol}.samples.jsonl")
         if conventional.exists():
-            print(f"nabla record: using {conventional} (found by convention; pass --samples to override)")
+            rail(_out, f"using {conventional} (found by convention; pass --samples to override)")
             source = RecordSource(kind="samples", samples_file=str(conventional))
         else:
             source, err = _generate_samples_source(args, site, conventional)
@@ -440,24 +482,48 @@ def _cmd_record(args) -> int:
                 return err
             source_kind = "generated_samples"
 
+    on_progress = None
+    progress = None
+    if _out.is_terminal and source.kind == "samples":
+        progress = make_progress(_out)
+        task_ref: list = []
+
+        def on_progress(done: int, total: int) -> None:
+            if not task_ref:
+                task_ref.append(progress.add_task("recording", total=total))
+            progress.update(task_ref[0], completed=done)
+
     try:
-        examples = record(site, source, args.repo)
+        if progress is not None:
+            with progress:
+                examples = record(site, source, args.repo, on_progress=on_progress)
+        else:
+            examples = record(site, source, args.repo)
     except ZeroTrafficError as exc:
         _fail(f"nabla record: {exc}")
         return 1
+    except RuntimeError as exc:
+        message = str(exc)
+        _fail(f"nabla record: {message[:400]}")
+        if "invalid_api_key" in message or "Invalid API Key" in message or "401" in message:
+            _warn("the configured provider rejected your API key — rerun `nabla init` "
+                  "and paste it again (the input shows one * per character, including pastes)")
+        return 1
     out = args.out or f"{site.symbol}.recorded.jsonl"
     with open(out, "w", encoding="utf-8") as f:
         for ex in examples:
             f.write(json.dumps({**ex.to_dict(), "_source_kind": source_kind or source.kind}) + "\n")
-    _ok(f"recorded {len(examples)} (prompt, completion) pairs from "
-        f"site {site.symbol} -> {out}")
+    rail(_out)
+    rail_ok(_out, f"recorded {len(examples)} (prompt, completion) pairs from "
+                  f"site {site.symbol} -> {out}")
     if source_kind == "generated_samples":
-        _warn(f"inputs were synthetic — edit {site.symbol}.samples.jsonl with real "
-              "data and rerun for a higher-fidelity harvest")
+        rail(_out, f"inputs were synthetic — edit {site.symbol}.samples.jsonl with real "
+                   "data and rerun for a higher-fidelity harvest", style="yellow")
+    rail(_out)
     if args.out is None and args.site is None:
-        _next_step(f"nabla profile{'' if args.repo == '.' else ' ' + args.repo}")
+        rail_end(_out, f"next: nabla profile{'' if args.repo == '.' else ' ' + args.repo}")
     else:
-        _next_step(f"nabla profile {args.repo} --site {site.symbol} --examples {out}")
+        rail_end(_out, f"next: nabla profile {args.repo} --site {site.symbol} --examples {out}")
     return 0
 
 
@@ -482,8 +548,9 @@ def _generate_samples_source(args, site, out_path: Path):
         )
         return None, 1
     out_path.write_text("\n".join(json.dumps(item) for item in items) + "\n", encoding="utf-8")
-    print(f"nabla record: no samples given — generated {len(items)} synthetic inputs -> {out_path} "
-          "(edit this file and rerun to use realistic inputs)")
+    from .ui import rail
+    rail(_out, f"no samples given — generated {len(items)} synthetic inputs -> {out_path} "
+               "(edit this file and rerun to use realistic inputs)", style="dim")
     return RecordSource(kind="samples", samples_file=str(out_path)), None
 
 
@@ -491,11 +558,15 @@ def _cmd_profile(args) -> int:
     from .induce import induce
     from .prompt_recon import reconstruct
     from .schema_resolver import resolve_schema as _resolve
+    from .ui import rail, rail_end, rail_ok, rail_start
 
+    rail_start(_out, "nabla profile")
     sites = scan(args.repo)
     site, err = _resolve_site(args, sites)
     if err is not None:
         return err
+    if args.site:
+        rail(_out, f"site {site.symbol} · {site.file}", style="dim")
 
     examples_path = args.examples
     if examples_path is None:
@@ -512,7 +583,7 @@ def _cmd_profile(args) -> int:
             print(f"nabla profile: no recorded examples found ({conventional} or recorded.jsonl). "
                   f"Run first: {record_cmd}", file=sys.stderr)
             return 2
-        print(f"nabla profile: using {examples_path}")
+        rail(_out, f"using {examples_path}")
 
     examples, recorded_from = [], "samples"
     for line in Path(examples_path).read_text(encoding="utf-8").splitlines():
@@ -528,22 +599,29 @@ def _cmd_profile(args) -> int:
 
     template = reconstruct(site, args.repo)
     schema, _ = _resolve(site, args.repo)
-    goal = induce(template, schema, examples)
+    if _out.is_terminal:
+        with _out.status(f"inferring goal from {len(examples)} examples", spinner="dots"):
+            goal = induce(template, schema, examples)
+    else:
+        goal = induce(template, schema, examples)
 
     profile = build_profile(site, args.repo, examples, goal, recorded_from=recorded_from)
     out = args.out or f"{site.symbol}.profile.json"
     Path(out).write_text(json.dumps(profile, indent=2), encoding="utf-8")
     supported = profile["classification"]["supported"]
-    _ok(f"wrote {out} — the handoff artifact for site {site.symbol}")
-    _out.print(f"  site id      {profile['site_id'][:16]}…", markup=False)
-    _out.print(f"  supported    {supported}", markup=False)
-    _out.print(f"  examples     {len(examples)} ({recorded_from})", markup=False)
-    _out.print(f"  goal         {goal.description[:90]}", markup=False)
+    rail(_out)
+    rail_ok(_out, f"wrote {out}")
+    rail(_out, f"site         {site.symbol} · {profile['site_id'][:16]}…")
+    rail(_out, f"supported    {supported}")
+    rail(_out, f"examples     {len(examples)} ({recorded_from})")
+    rail(_out, f"goal         {goal.description[:90]}")
     dims = ", ".join(d["name"] for d in goal.difficulty_dimensions[:4])
-    _out.print(f"  difficulty   {dims}", markup=False)
+    rail(_out, f"difficulty   {dims}")
     if len(examples) < 20:
-        _warn(f"only {len(examples)} examples (< 20) — enough for a look, "
-              "but a handoff-quality profile wants 20+ real-traffic pairs")
+        rail(_out, f"only {len(examples)} examples (< 20) — enough for a look, but a "
+                   "handoff-quality profile wants 20+ real-traffic pairs", style="yellow")
+    rail(_out)
+    rail_end(_out, f"done — {out} is the handoff artifact", style="green")
     return 0
 
 

{nabla_cli-0.3.0 → nabla_cli-0.4.1}/nabla/recorder.py

@@ -415,13 +415,18 @@ def _run_site_in_subprocess(site: RawSite, repo_path: str, input_slots: dict, en
     timeout = int(os.environ.get("NABLA_SAMPLE_TIMEOUT", "300"))
     proc = subprocess.run(args, cwd=repo_path, env=env, capture_output=True, text=True, timeout=timeout)
     if proc.returncode != 0:
+        # The last stderr lines carry the actual exception; the rest is
+        # traceback scaffolding that buries it.
+        lines = [l for l in (proc.stderr or proc.stdout or "").splitlines() if l.strip()]
+        detail = " | ".join(lines[-2:]) if lines else "no output"
         raise RuntimeError(
             f"Sample invocation of {site.symbol!r} in {site.file!r} failed "
-            f"(exit {proc.returncode}): {proc.stderr.strip() or proc.stdout.strip()}"
+            f"(exit {proc.returncode}): {detail}"
         )
 
 
-def _record_samples(site: RawSite, source: RecordSource, repo_path: str) -> list[Example]:
+def _record_samples(site: RawSite, source: RecordSource, repo_path: str,
+                    on_progress=None) -> list[Example]:
     if not source.samples_file:
         raise ValueError("RecordSource.kind='samples' requires samples_file")
     sample_lines = _read_jsonl(source.samples_file)
@@ -466,8 +471,11 @@ def _record_samples(site: RawSite, source: RecordSource, repo_path: str) -> list
                 new_captures = list(proxy.captured[before:])
             for capture in new_captures:
                 examples.append(_capture_to_example(capture, input_slots))
-            print(f"nabla record: sample {i + 1}/{total} -> {len(new_captures)} capture(s)",
-                  file=sys.stderr)
+            if on_progress is not None:
+                on_progress(i + 1, total)
+            else:
+                print(f"nabla record: sample {i + 1}/{total} -> {len(new_captures)} capture(s)",
+                      file=sys.stderr)
     finally:
         proxy.stop()
 
@@ -544,15 +552,19 @@ def _record_logs(site: RawSite, source: RecordSource, repo_path: str) -> list[Ex
 # Public interface
 # ---------------------------------------------------------------------------
 
-def record(site: RawSite, source: RecordSource, repo_path: str) -> list[Example]:
+def record(site: RawSite, source: RecordSource, repo_path: str,
+           on_progress=None) -> list[Example]:
     """Capture real (prompt, completion, tokens, latency) pairs for site.
 
     Must: attribute captured requests back to the site (template match),
     populate token counts and latency, raise ZeroTrafficError on an empty
     proxy run instead of returning [].
+
+    ``on_progress(done, total)`` (samples path only) replaces the default
+    per-sample stderr lines — used by the CLI to drive a progress bar.
     """
     if source.kind == "samples":
-        return _record_samples(site, source, repo_path)
+        return _record_samples(site, source, repo_path, on_progress=on_progress)
     if source.kind == "proxy":
         return _record_proxy(site, source, repo_path)
     if source.kind == "logs":

nabla_cli-0.4.1/nabla/ui.py

@@ -0,0 +1,171 @@
+"""nabla's terminal design system.
+
+One visual language across commands:
+
+- a rail (``┌ │ └``) threads each multi-step flow so the user always sees
+  where they are in the sequence — structure as information, not decoration;
+- selection is pointer-driven (arrow keys) on an interactive Windows
+  console, with a numbered fallback everywhere else;
+- progress fills with the nabla glyph itself — the one flourish;
+- color carries meaning only: cyan = brand/interactive, green = done,
+  yellow = caution, red = failure, dim = structure.
+
+Glyphs are box-drawing / geometric only — never emoji.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from rich.console import Console
+from rich.progress import Progress, ProgressColumn, TextColumn
+from rich.text import Text
+
+RAIL = "│"
+_POINTER = "❯"
+_ON = "●"
+_OFF = "○"
+
+
+# ---------------------------------------------------------------------------
+# Rail primitives
+# ---------------------------------------------------------------------------
+
+def rail_start(console: Console, title: str) -> None:
+    line = Text("┌ ", style="dim")
+    line.append(title, style="bold")
+    console.print(line)
+
+
+def rail(console: Console, text: str = "", style: str | None = None) -> None:
+    line = Text(RAIL, style="dim")
+    if text:
+        line.append(" " + text, style=style or "")
+    console.print(line)
+
+
+def rail_ok(console: Console, text: str) -> None:
+    line = Text(f"{RAIL} ", style="dim")
+    line.append("✓ ", style="green")
+    line.append(text)
+    console.print(line)
+
+
+def rail_end(console: Console, text: str, style: str = "cyan") -> None:
+    line = Text("└ ", style="dim")
+    line.append(text, style=style)
+    console.print(line)
+
+
+# ---------------------------------------------------------------------------
+# Selection
+# ---------------------------------------------------------------------------
+
+def select(console: Console, label: str, options: list[tuple[str, str]],
+           default: int = 0) -> int:
+    """Pick one of ``options`` ([(name, description), ...]); returns the index.
+
+    Interactive Windows console: arrow keys + enter, pointer rendering,
+    menu collapses to a single confirmation line after the choice.
+    Anywhere else: numbered prompt.
+    """
+    interactive = (
+        sys.platform == "win32"
+        and console.is_terminal
+        and sys.stdin.isatty()
+    )
+    if not interactive:
+        rail(console, label, style="bold")
+        for i, (name, desc) in enumerate(options, start=1):
+            rail(console, f"  {i}) {name} — {desc}")
+        choice = input(f"{RAIL} > ").strip()
+        if choice.isdigit() and 1 <= int(choice) <= len(options):
+            return int(choice) - 1
+        for i, (name, _) in enumerate(options):
+            if name == choice:
+                return i
+        return default
+
+    import msvcrt
+
+    from .term import init_terminal
+
+    init_terminal()
+    idx = default
+    name_width = max(len(name) for name, _ in options)
+    hint = "↑ ↓ move · enter chooses"
+    lines_drawn = 0
+
+    def draw() -> None:
+        nonlocal lines_drawn
+        if lines_drawn:
+            sys.stdout.write(f"\x1b[{lines_drawn}A\x1b[0J")
+        header = Text(f"{RAIL} ", style="dim")
+        header.append(label, style="bold")
+        header.append(f"   {hint}", style="dim")
+        console.print(header)
+        for i, (name, desc) in enumerate(options):
+            row = Text(f"{RAIL} ", style="dim")
+            if i == idx:
+                row.append(f"  {_POINTER} {_ON} ", style="cyan")
+                row.append(f"{name:<{name_width}}", style="bold cyan")
+            else:
+                # Unselected is quieter, never grey — grey reads as disabled.
+                row.append(f"    {_OFF} ", style="dim")
+                row.append(f"{name:<{name_width}}")
+            row.append(f"   {desc}", style="dim")
+            console.print(row)
+        lines_drawn = len(options) + 1
+
+    draw()
+    while True:
+        ch = msvcrt.getwch()
+        if ch in ("\r", "\n"):
+            break
+        if ch == "\x03":
+            raise KeyboardInterrupt
+        if ch in ("\xe0", "\x00"):
+            arrow = msvcrt.getwch()
+            if arrow == "H":
+                idx = (idx - 1) % len(options)
+            elif arrow == "P":
+                idx = (idx + 1) % len(options)
+            draw()
+
+    # Collapse the menu into one confirmation line.
+    sys.stdout.write(f"\x1b[{lines_drawn}A\x1b[0J")
+    chosen = Text(f"{RAIL} ", style="dim")
+    chosen.append(f"{label}  ", style="bold")
+    chosen.append(options[idx][0], style="cyan")
+    console.print(chosen)
+    return idx
+
+
+# ---------------------------------------------------------------------------
+# Progress: the ∇ bar
+# ---------------------------------------------------------------------------
+
+class NablaBar(ProgressColumn):
+    """A bar that fills with the nabla glyph — brand as instrument."""
+
+    def __init__(self, width: int = 28):
+        super().__init__()
+        self.width = width
+
+    def render(self, task) -> Text:
+        total = task.total or 1
+        filled = int(self.width * min(task.completed / total, 1.0))
+        bar = Text()
+        bar.append("∇" * filled, style="cyan")
+        bar.append("·" * (self.width - filled), style="dim")
+        return bar
+
+
+def make_progress(console: Console, unit: str = "samples") -> Progress:
+    return Progress(
+        TextColumn(RAIL, style="dim"),
+        NablaBar(),
+        TextColumn(f"{{task.completed}}/{{task.total}} {unit}", style="dim"),
+        console=console,
+        transient=True,
+    )

{nabla_cli-0.3.0 → nabla_cli-0.4.1}/nabla_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.3.0
+Version: 0.4.1
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11

{nabla_cli-0.3.0 → nabla_cli-0.4.1}/nabla_cli.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ nabla/samplegen.py
 nabla/scanner.py
 nabla/schema_resolver.py
 nabla/term.py
+nabla/ui.py
 nabla/schemas/site_profile.schema.json
 nabla_cli.egg-info/PKG-INFO
 nabla_cli.egg-info/SOURCES.txt

{nabla_cli-0.3.0 → nabla_cli-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nabla-cli"
-version = "0.3.0"
+version = "0.4.1"
 description = "Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles"
 readme = "README.md"
 license = { text = "MIT" }

nabla_cli-0.3.0/nabla/branding.py

@@ -1,50 +0,0 @@
-"""nabla terminal branding: the ∇ logo and startup banner.
-
-The banner prints only on a real terminal — piped output, tests, and
---json consumers never see it. Block glyphs render via the Windows
-console's UTF-16 writer, so no legacy-codepage fallback is needed on an
-interactive console.
-"""
-
-from __future__ import annotations
-
-from rich.console import Console
-from rich.text import Text
-
-from . import __version__
-
-_LOGO = [
-    "▛▀▀▀▀▀▀▀▜",
-    " ▚     ▞",
-    "  ▚   ▞",
-    "   ▚ ▞",
-    "    ▘",
-]
-
-_BRAND_STYLE = "bold cyan"
-
-
-def banner_lines() -> list[tuple[str, str]]:
-    """(logo_line, tagline) pairs; taglines are empty on the outer rows."""
-    taglines = [
-        "",
-        f"nabla v{__version__}",
-        "OpenAI call-site harvester",
-        "scan · record · profile",
-        "",
-    ]
-    return list(zip(_LOGO, taglines))
-
-
-def print_banner(console: Console | None = None) -> None:
-    console = console or Console()
-    if not console.is_terminal:
-        return
-    console.print()
-    for logo_line, tagline in banner_lines():
-        row = Text()
-        row.append(f"  {logo_line:<12}", style=_BRAND_STYLE)
-        if tagline:
-            row.append(tagline, style="bold" if tagline.startswith("nabla") else "dim")
-        console.print(row)
-    console.print()