nabla-cli 0.6.2__tar.gz → 0.6.4__tar.gz

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/PKG-INFO

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

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/nabla/__init__.py

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

nabla_cli-0.6.4/nabla/branding.py

@@ -0,0 +1,139 @@
+"""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 · capture · build", "cyan"),
+        ("", ""),
+        ("", ""),
+    ]
+    return [(logo, text, style) for logo, (text, style) in zip(_LOGO, taglines)]
+
+
+def _compose() -> Text:
+    """The complete banner, final form."""
+    frame = Text()
+    for logo_line, tagline, tag_style in banner_lines():
+        frame.append(f"  {logo_line:<14}", style=_BRAND_STYLE)
+        if tagline:
+            frame.append(tagline, style=tag_style)
+        frame.append("\n")
+    return frame
+
+
+def _stroke_frames() -> list[set[tuple[int, int]]]:
+    """Reveal order that traces the mark like a pen: the top bar sweeps
+    left to right, then the two diagonals descend together to the apex."""
+    frames: list[set[tuple[int, int]]] = []
+    mask: set[tuple[int, int]] = set()
+    top_cells = [(0, c) for c, ch in enumerate(_LOGO[0]) if ch != " "]
+    for i in range(0, len(top_cells), 2):
+        mask.update(top_cells[i:i + 2])
+        frames.append(set(mask))
+    for r in range(1, len(_LOGO)):
+        mask.update((r, c) for c, ch in enumerate(_LOGO[r]) if ch != " ")
+        frames.append(set(mask))
+    return frames
+
+
+def print_banner(console: Console | None = None) -> None:
+    """Print the complete banner instantly. Animation, when wanted, happens
+    afterwards via animate_in_place() — over this already-rendered region —
+    so downstream UI (rails, menus) is on screen before a single frame."""
+    console = console or Console()
+    if not console.is_terminal:
+        return
+    console.print()
+    console.print(_compose(), end="")
+    console.print()
+
+
+# Raw ANSI for the in-place replay: rich Live owns whole-screen regions,
+# but here the cursor must slip above content that is already printed
+# below the banner, so escape codes are driven directly.
+_ANSI = {"brand": "\x1b[1;36m", "bold": "\x1b[1m", "cyan": "\x1b[36m",
+         "": "", "reset": "\x1b[0m"}
+
+
+def _ansi_row(r: int, mask: set[tuple[int, int]]) -> str:
+    logo_line, tagline, tag_style = banner_lines()[r]
+    revealed = "".join(
+        ch if ch == " " or (r, c) in mask else " "
+        for c, ch in enumerate(logo_line)
+    )
+    row = f"  {_ANSI['brand']}{revealed:<14}{_ANSI['reset']}"
+    if tagline:
+        row += f"{_ANSI[tag_style]}{tagline}{_ANSI['reset']}"
+    return row + "\x1b[0K"  # clear any residue right of the rewritten text
+
+
+def animate_in_place(console: Console, lines_below: int) -> None:
+    """Replay the logo's stroke-order draw over the banner already on
+    screen. ``lines_below`` = rows printed after the banner's trailing
+    blank line (rails, menu, ...); the cursor is assumed to sit at the
+    start of the row just below them. Everything is rewritten line-for-line
+    (taglines included), so the layout cannot shift."""
+    if not console.is_terminal:
+        return
+    import sys as _sys
+    import time
+
+    up = len(_LOGO) + 1 + lines_below  # +1: banner's trailing blank line
+    write = _sys.stdout.write
+    try:
+        for mask in _stroke_frames():
+            write(f"\x1b[s\x1b[{up}A")          # save cursor, jump to logo top
+            for r in range(len(_LOGO)):
+                write("\r" + _ansi_row(r, mask))
+                if r < len(_LOGO) - 1:
+                    write("\x1b[1B")            # down one row
+            write("\x1b[u")                     # restore cursor
+            _sys.stdout.flush()
+            time.sleep(0.09)
+    except Exception:  # noqa: BLE001 - cosmetic replay must never break init
+        pass
+    finally:
+        # Terminal state is guaranteed sane: land on the finished mark.
+        try:
+            full = {(r, c) for r, line in enumerate(_LOGO)
+                    for c, ch in enumerate(line) if ch != " "}
+            write(f"\x1b[s\x1b[{up}A")
+            for r in range(len(_LOGO)):
+                write("\r" + _ansi_row(r, full))
+                if r < len(_LOGO) - 1:
+                    write("\x1b[1B")
+            write("\x1b[u")
+            _sys.stdout.flush()
+        except Exception:  # noqa: BLE001
+            pass

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/nabla/cli.py

@@ -264,9 +264,12 @@ def _read_api_key(prompt: str) -> str:
 
 
 def _cmd_init(args) -> int:
+    from .branding import animate_in_place
     from .ui import RAIL, rail, rail_end, rail_ok, rail_start, select
 
-    print_banner(_out, animate=True)
+    # Everything renders first — banner (final form), rail, menu — then the
+    # logo replays its stroke-order draw in place. Nothing ever shifts.
+    print_banner(_out)
     rail_start(_out, "nabla init")
     rail(_out)
 
@@ -274,7 +277,10 @@ def _cmd_init(args) -> int:
     if provider is None:
         names = list(PROVIDERS)
         options = [(name, _PROVIDER_DESCRIPTIONS.get(name, "")) for name in names]
-        provider = names[select(_out, "Provider", options)]
+        provider = names[select(
+            _out, "Provider", options,
+            on_first_draw=lambda menu_lines: animate_in_place(_out, menu_lines + 2),
+        )]
     else:
         rail(_out, f"Provider  {provider}")
 
@@ -493,19 +499,9 @@ def _cmd_record(args) -> int:
     elif args.proxy_cmd:
         source = RecordSource(kind="proxy", proxy_command=args.proxy_cmd.split())
     else:
-        conventional = next(
-            (p for p in (Path(f"{site.symbol}.inputs.jsonl"),
-                         Path(f"{site.symbol}.samples.jsonl"))  # legacy name
-             if p.exists()),
-            None,
-        )
-        if conventional is not None:
-            rail(_out, f"using {conventional} (found by convention; pass --inputs to override)")
-            source = RecordSource(kind="samples", samples_file=str(conventional))
-        else:
-            source, source_kind, err = _resolve_inputs_interactively(args, site)
-            if err is not None:
-                return err
+        source, source_kind, err = _resolve_inputs_interactively(args, site)
+        if err is not None:
+            return err
 
     from .ui import make_progress, rail_end, rail_ok
 
@@ -554,46 +550,60 @@ def _cmd_record(args) -> int:
     return 0
 
 
-def _inputs_menu(label: str) -> tuple[str, object]:
-    """The interactive inputs menu. Returns ("file", path) or ("generate", n)."""
-    from .ui import prompt_text, select
+def _inputs_menu(label: str, existing: Path | None = None) -> tuple[str, object]:
+    """The interactive inputs menu — shown every capture, so reusing a
+    previous inputs file is a choice, not an ambush. Returns ("file", path)
+    or ("generate", n)."""
+    from .ui import prompt_digits, prompt_text, select
 
-    options = [
+    options = []
+    if existing is not None:
+        try:
+            count = sum(1 for line in existing.read_text(encoding="utf-8").splitlines()
+                        if line.strip())
+        except OSError:
+            count = "?"
+        options.append(("use existing", f"{existing} · {count} inputs"))
+    options += [
         ("generate 5", "synthetic inputs — quick look, fewest credits"),
         ("generate 10", "synthetic inputs — balanced"),
         ("generate 20", "synthetic inputs — handoff floor, most credits"),
         ("custom count", "type how many synthetic inputs to generate"),
         ("my own file", "type a path to your JSONL of inputs"),
     ]
+    shift = 1 if existing is not None else 0
     choice = select(_out, label, options)
-    if choice == 3:
-        while True:
-            typed = prompt_text(_out, "How many", default="5")
-            if typed.isdigit() and int(typed) > 0:
-                return "generate", int(typed)
-            _warn("enter a positive number")
-    if choice == 4:
+    if existing is not None and choice == 0:
+        return "file", str(existing)
+    if choice == shift + 3:
+        return "generate", prompt_digits(_out, "How many", default=5)
+    if choice == shift + 4:
         while True:
             typed = prompt_text(_out, "Path to JSONL")
             if typed and Path(typed).exists():
                 return "file", typed
             _warn(f"{typed or '(empty)'} not found — try again, or Ctrl+C to abort")
-    return "generate", (5, 10, 20)[choice]
+    return "generate", (5, 10, 20)[choice - shift]
 
 
 def _resolve_inputs_interactively(args, site):
-    """No --inputs given and no conventional file found. Interactively, ask
-    where inputs come from (generate N / custom count / own file); otherwise
-    generate the default quietly. Returns (source, source_kind, exit_code)
-    with exit_code None on success."""
-    n = args.num_samples
-    if n is None and _out.is_terminal and sys.stdin.isatty():
-        kind, value = _inputs_menu("Inputs")
+    """No --inputs given. Interactively, ask where inputs come from (existing
+    file / generate N / custom count / own file); otherwise use an existing
+    conventional file or generate the default quietly. Returns
+    (source, source_kind, exit_code) with exit_code None on success."""
+    conventional = _find_conventional_inputs(site)
+
+    if args.num_samples is None and _out.is_terminal and sys.stdin.isatty():
+        kind, value = _inputs_menu("Inputs", existing=conventional)
         if kind == "file":
             return RecordSource(kind="samples", samples_file=value), None, None
         n = value
-    elif n is None:
-        n = 5
+    elif conventional is not None and args.num_samples is None:
+        from .ui import rail
+        rail(_out, f"using {conventional} (found by convention; pass --inputs to override)")
+        return RecordSource(kind="samples", samples_file=str(conventional)), None, None
+    else:
+        n = args.num_samples or 5
 
     source, err = _generate_samples_source(args, site, Path(f"{site.symbol}.inputs.jsonl"), n)
     if err is not None:
@@ -637,25 +647,27 @@ def _capture_many(args, supported) -> int:
         rail(_out, f"capturing all {len(targets)} supported call sites")
 
     # Phase 1 — decide inputs per site, sequentially (menus can't overlap).
+    # The menu is shown every time; an existing inputs file is offered as
+    # the default option, never silently assumed.
     plans: list[dict] = []
     for site in targets:
         conventional = _find_conventional_inputs(site)
-        if conventional is not None:
+        if args.num_samples is None and interactive:
+            kind, value = _inputs_menu(f"Inputs · {site.symbol}", existing=conventional)
+            if kind == "file":
+                plans.append({"site": site, "kind": "file", "path": value,
+                              "source_kind": "samples"})
+            else:
+                plans.append({"site": site, "kind": "generate", "n": value,
+                              "source_kind": "generated_samples"})
+            continue
+        if conventional is not None and args.num_samples is None:
             rail(_out, f"{site.symbol}: using {conventional}")
             plans.append({"site": site, "kind": "file", "path": str(conventional),
                           "source_kind": "samples"})
             continue
-        if args.num_samples is not None or not interactive:
-            plans.append({"site": site, "kind": "generate",
-                          "n": args.num_samples or 5, "source_kind": "generated_samples"})
-            continue
-        kind, value = _inputs_menu(f"Inputs · {site.symbol}")
-        if kind == "file":
-            plans.append({"site": site, "kind": "file", "path": value,
-                          "source_kind": "samples"})
-        else:
-            plans.append({"site": site, "kind": "generate", "n": value,
-                          "source_kind": "generated_samples"})
+        plans.append({"site": site, "kind": "generate",
+                      "n": args.num_samples or 5, "source_kind": "generated_samples"})
 
     # Phase 2 — run all captures in parallel.
     progress = make_progress(_out) if _out.is_terminal else None

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/nabla/recorder.py

@@ -131,42 +131,64 @@ def _forward_to_openai_responder(body: dict, headers: dict) -> dict:
     model_override = os.environ.get("NABLA_UPSTREAM_MODEL")
     if model_override:
         body = {**body, "model": model_override}
-    req = urllib.request.Request(
-        f"{base_url}/chat/completions",
-        data=json.dumps(body).encode("utf-8"),
-        method="POST",
-        headers={
-            "Content-Type": "application/json",
-            "Authorization": auth,
-            # Some providers' CDNs (e.g. Cloudflare in front of Groq) reject
-            # urllib's default Python-urllib User-Agent with a 403.
-            "User-Agent": "nabla-recorder/0.1",
-        },
-    )
+    request_headers = {
+        "Content-Type": "application/json",
+        "Authorization": auth,
+        # Some providers' CDNs (e.g. Cloudflare in front of Groq) reject
+        # urllib's default Python-urllib User-Agent with a 403.
+        "User-Agent": "nabla-recorder/0.1",
+    }
     # Rate limits (429) and transient upstream errors are expected during a
     # long record run, especially on free-tier stand-in oracles: back off and
-    # retry, honoring Retry-After when the upstream sends one.
+    # retry, honoring Retry-After when the upstream sends one. A stand-in
+    # that rejects the site's json_schema outright (some providers support a
+    # narrower schema dialect, e.g. no type arrays) gets one retry in
+    # json_object mode — the production schema in the profile is unaffected.
     delays = [5, 10, 20, 30, 45]
-    for attempt, delay in enumerate([*delays, None]):
+    attempt = 0
+    fell_back = False
+    while True:
+        req = urllib.request.Request(
+            f"{base_url}/chat/completions",
+            data=json.dumps(body).encode("utf-8"),
+            method="POST",
+            headers=request_headers,
+        )
         try:
             with urllib.request.urlopen(req, timeout=60) as resp:
                 return json.loads(resp.read().decode("utf-8"))
         except urllib.error.HTTPError as exc:
-            if delay is None or exc.code not in (429, 500, 502, 503):
-                # Surface the upstream's error body — "HTTP 400" alone is
-                # undiagnosable (e.g. Groq's json_validate_failed).
-                try:
-                    detail = exc.read().decode("utf-8", "replace")[:500]
-                except Exception:  # noqa: BLE001 - body read is best-effort
-                    detail = ""
+            try:
+                detail = exc.read().decode("utf-8", "replace")[:500]
+            except Exception:  # noqa: BLE001 - body read is best-effort
+                detail = ""
+            rf = body.get("response_format")
+            if (exc.code == 400 and model_override and not fell_back
+                    and isinstance(rf, dict) and rf.get("type") == "json_schema"
+                    and ("schema" in detail.lower() or "invalid" in detail.lower())):
+                body = {**body, "response_format": {"type": "json_object"}}
+                # Providers require the word "json" in the messages to use
+                # json_object mode. This nudge goes only to the stand-in —
+                # the proxy captured the original request before forwarding,
+                # so the recorded prompt is untouched.
+                messages = list(body.get("messages", []))
+                if "json" not in json.dumps(messages).lower():
+                    messages.append({"role": "system", "content": "Respond in JSON."})
+                    body = {**body, "messages": messages}
+                fell_back = True
+                print("nabla capture: stand-in oracle rejected this site's json_schema — "
+                      "retrying in json_object mode (the profile still carries the real schema)",
+                      file=sys.stderr)
+                continue
+            if attempt >= len(delays) or exc.code not in (429, 500, 502, 503):
                 raise RuntimeError(f"upstream HTTP {exc.code}: {detail or exc.reason}") from exc
             retry_after = exc.headers.get("Retry-After") if exc.headers else None
             try:
-                wait = max(float(retry_after), delay) if retry_after else delay
+                wait = max(float(retry_after), delays[attempt]) if retry_after else delays[attempt]
             except ValueError:
-                wait = delay
+                wait = delays[attempt]
             time.sleep(min(wait, 60))
-    raise RuntimeError("unreachable")
+            attempt += 1
 
 
 def _default_responder() -> Responder:
@@ -415,10 +437,10 @@ 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.
+        # The last stderr line carries the actual exception; everything above
+        # it is traceback scaffolding that buries the signal.
         lines = [l for l in (proc.stderr or proc.stdout or "").splitlines() if l.strip()]
-        detail = " | ".join(lines[-2:]) if lines else "no output"
+        detail = lines[-1].strip() if lines else "no output"
         raise RuntimeError(
             f"Sample invocation of {site.symbol!r} in {site.file!r} failed "
             f"(exit {proc.returncode}): {detail}"

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/nabla/scanner.py

@@ -40,7 +40,8 @@ from .contract import (
     RawSiteRef,
 )
 
-_SKIP_DIR_NAMES = {".git", "node_modules", "__pycache__", ".venv", "venv"}
+_SKIP_DIR_NAMES = {".git", "node_modules", "__pycache__", ".venv", "venv",
+                   "build", "dist", ".eggs", ".tox", ".mypy_cache"}
 
 _VISION_MARKERS = {"image_url", "input_image"}
 

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/nabla/ui.py

@@ -67,9 +67,13 @@ def rail_end(console: Console, text: str, style: str = "cyan") -> None:
 # ---------------------------------------------------------------------------
 
 def select(console: Console, label: str, options: list[tuple[str, str]],
-           default: int = 0) -> int:
+           default: int = 0, on_first_draw=None) -> int:
     """Pick one of ``options`` ([(name, description), ...]); returns the index.
 
+    ``on_first_draw(lines_drawn)`` fires once after the menu is fully on
+    screen, before the first key is read — the hook that lets a banner
+    animation replay above an already-complete layout.
+
     Interactive Windows console: arrow keys + enter, pointer rendering,
     menu collapses to a single confirmation line after the choice.
     Anywhere else: numbered prompt.
@@ -123,6 +127,11 @@ def select(console: Console, label: str, options: list[tuple[str, str]],
         lines_drawn = len(options) + 1
 
     draw()
+    if on_first_draw is not None:
+        try:
+            on_first_draw(lines_drawn)
+        except Exception:  # noqa: BLE001 - a cosmetic hook must never break input
+            pass
     while True:
         ch = msvcrt.getwch()
         if ch in ("\r", "\n"):
@@ -267,3 +276,46 @@ def make_progress(console: Console, unit: str = "samples") -> Progress:
         console=console,
         transient=True,
     )
+
+
+def prompt_digits(console: Console, label: str, default: int) -> int:
+    """Numeric input that cannot go wrong: on an interactive Windows console
+    it reads keys raw — digits echo, backspace works, everything else
+    (arrows, brackets, console line-editing artifacts) is ignored. Elsewhere
+    it strips non-digits from a plain input()."""
+    prompt = Text(f"{RAIL} ", style=_RAIL_STYLE)
+    prompt.append(label, style="bold")
+    prompt.append(f" [{default}]", style="cyan")
+    prompt.append("  ")
+
+    interactive = (
+        sys.platform == "win32"
+        and console.is_terminal
+        and sys.stdin.isatty()
+    )
+    if not interactive:
+        console.print(prompt, end="")
+        raw = "".join(ch for ch in input() if ch.isdigit())
+        return int(raw) if raw else default
+
+    import msvcrt
+
+    console.print(prompt, end="")
+    chars: list[str] = []
+    while True:
+        ch = msvcrt.getwch()
+        if ch in ("\r", "\n"):
+            print()
+            break
+        if ch == "\x03":
+            raise KeyboardInterrupt
+        if ch == "\b":
+            if chars:
+                chars.pop()
+                print("\b \b", end="", flush=True)
+        elif ch.isdigit():
+            chars.append(ch)
+            print(ch, end="", flush=True)
+        elif ch in ("\xe0", "\x00"):
+            msvcrt.getwch()  # swallow the arrow/function-key payload
+    return int("".join(chars)) if chars else default

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/nabla_cli.egg-info/PKG-INFO

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

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/pyproject.toml

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

{nabla_cli-0.6.2 → nabla_cli-0.6.4}/tests/test_cli_ux.py

@@ -466,3 +466,54 @@ def test_ctrl_c_is_one_quiet_line(monkeypatch, capsys):
     captured = capsys.readouterr()
     assert "cancelled" in captured.err
     assert "Traceback" not in captured.err + captured.out
+
+
+# ---------------------------------------------------------------------------
+# 0.6.3 fixes: digit prompt, always-shown menu, scan skips build dirs
+# ---------------------------------------------------------------------------
+
+def test_prompt_digits_noninteractive_strips_garbage(monkeypatch):
+    from rich.console import Console
+
+    from nabla.ui import prompt_digits
+
+    console = Console(width=100)
+    monkeypatch.setattr("builtins.input", lambda *a: "[1]")
+    assert prompt_digits(console, "How many", default=5) == 1
+
+    monkeypatch.setattr("builtins.input", lambda *a: "")
+    assert prompt_digits(console, "How many", default=5) == 5
+
+
+def test_inputs_menu_offers_existing_file(tmp_path, monkeypatch, capsys):
+    from nabla.cli import _inputs_menu
+
+    existing = tmp_path / "site.inputs.jsonl"
+    existing.write_text('{"input_slots": {"q": "x"}}\n' * 3, encoding="utf-8")
+    picked = {}
+
+    def fake_select(console, label, options):
+        picked["options"] = options
+        return 0  # choose "use existing"
+
+    monkeypatch.setattr("nabla.ui.select", fake_select)
+    kind, value = _inputs_menu("Inputs", existing=existing)
+
+    assert kind == "file"
+    assert value == str(existing)
+    assert picked["options"][0][0] == "use existing"
+    assert "3 inputs" in picked["options"][0][1]
+
+
+def test_scan_skips_build_and_dist_dirs(tmp_path, monkeypatch, capsys):
+    repo = _make_single_site_repo(tmp_path)
+    build_dir = repo / "build" / "lib"
+    build_dir.mkdir(parents=True)
+    (build_dir / "copy_of_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
+
+    rc = main(["scan", str(repo)])
+
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "1 call site found" in out
+    assert "copy_of_site" not in out

nabla_cli-0.6.2/nabla/branding.py

@@ -1,101 +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__
-
-# 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 · capture · build", "cyan"),
-        ("", ""),
-        ("", ""),
-    ]
-    return [(logo, text, style) for logo, (text, style) in zip(_LOGO, taglines)]
-
-
-def _compose(traced: set[tuple[int, int]] | None = None) -> Text:
-    """The full banner. With ``traced`` given, every glyph is still present
-    (no layout shift, ever) — untraced stroke cells just render quieter, and
-    the traced set brightens as the animation sweeps through."""
-    frame = Text()
-    for r, (logo_line, tagline, tag_style) in enumerate(banner_lines()):
-        frame.append("  ")
-        for c, ch in enumerate(f"{logo_line:<14}"):
-            if ch == " ":
-                frame.append(" ")
-            elif traced is None or (r, c) in traced:
-                frame.append(ch, style=_BRAND_STYLE)
-            else:
-                frame.append(ch, style="dim cyan")
-        if tagline:
-            frame.append(tagline, style=tag_style)
-        frame.append("\n")
-    return frame
-
-
-def _stroke_frames() -> list[set[tuple[int, int]]]:
-    """Reveal order that traces the mark like a pen: the top bar sweeps
-    left to right, then the two diagonals descend together to the apex."""
-    frames: list[set[tuple[int, int]]] = []
-    mask: set[tuple[int, int]] = set()
-    top_cells = [(0, c) for c, ch in enumerate(_LOGO[0]) if ch != " "]
-    for i in range(0, len(top_cells), 2):
-        mask.update(top_cells[i:i + 2])
-        frames.append(set(mask))
-    for r in range(1, len(_LOGO)):
-        mask.update((r, c) for c, ch in enumerate(_LOGO[r]) if ch != " ")
-        frames.append(set(mask))
-    return frames
-
-
-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
-
-        # Full-size first frame: the complete banner is on screen before a
-        # single animation tick, so the layout never shifts — the sweep only
-        # changes brightness along the stroke.
-        with Live(_compose(traced=set()), console=console,
-                  refresh_per_second=30, transient=False) as live:
-            time.sleep(0.12)
-            for traced in _stroke_frames():
-                live.update(_compose(traced=traced))
-                time.sleep(0.09)
-            live.update(_compose())
-    else:
-        console.print(_compose(), end="")
-    console.print()