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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.6.3
+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.3 → nabla_cli-0.6.4}/nabla/__init__.py

@@ -1,3 +1,3 @@
 """nabla — call-site harvester CLI (pre-Phase-0)."""
 
-__version__ = "0.6.3"
+__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.3 → 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}")
 

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

@@ -167,6 +167,14 @@ def _forward_to_openai_responder(body: dict, headers: dict) -> dict:
                     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)",

{nabla_cli-0.6.3 → 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,46 +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
+
+
+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.3 → 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.3
+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.3 → nabla_cli-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nabla-cli"
-version = "0.6.3"
+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.3/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()