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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.6.3
+Version: 0.7.0
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11
@@ -162,6 +162,23 @@ returns a goal description, implicit constraints, and difficulty
 dimensions with cited evidence. That's the goal line printed above, and
 it's what lands in the profile's `goal` block.
 
+### `nabla jeremy`
+
+An alternative to `build` with the same inputs and site handling: instead
+of the full site profile, it emits `<site>.jeremy.json` — a seed spec for
+a problem generator:
+
+```json
+{
+  "goal": "You are generating new problems to test and eventually fine-tune a small student model on the following task: ...",
+  "system_prompt": "<the site's own system prompt>",
+  "examples": [ {"problem": "...", "solution": "..."}, ... ]
+}
+```
+
+The goal text is composed deterministically from the same inferred goal
+and constraints that `build` uses; the examples are the captured pairs.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

{nabla_cli-0.6.3 → nabla_cli-0.7.0}/README.md

@@ -148,6 +148,23 @@ returns a goal description, implicit constraints, and difficulty
 dimensions with cited evidence. That's the goal line printed above, and
 it's what lands in the profile's `goal` block.
 
+### `nabla jeremy`
+
+An alternative to `build` with the same inputs and site handling: instead
+of the full site profile, it emits `<site>.jeremy.json` — a seed spec for
+a problem generator:
+
+```json
+{
+  "goal": "You are generating new problems to test and eventually fine-tune a small student model on the following task: ...",
+  "system_prompt": "<the site's own system prompt>",
+  "examples": [ {"problem": "...", "solution": "..."}, ... ]
+}
+```
+
+The goal text is composed deterministically from the same inferred goal
+and constraints that `build` uses; the examples are the captured pairs.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

{nabla_cli-0.6.3 → nabla_cli-0.7.0}/nabla/__init__.py

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

nabla_cli-0.7.0/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.7.0}/nabla/cli.py

@@ -132,6 +132,29 @@ def _build_parser() -> argparse.ArgumentParser:
     p_profile.add_argument("--out", default=None,
                            help="output path (default: <site>.profile.json)")
 
+    p_jeremy = sub.add_parser(
+        "jeremy",
+        help="assemble a seed spec (goal + system_prompt + problem/solution examples)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "an alternative to `build`: same inputs, but emits <site>.jeremy.json —\n"
+            "a generator-framed goal, the site's system prompt, and the captured\n"
+            "pairs as {problem, solution} reference examples.\n\n"
+            "examples:\n"
+            "  nabla jeremy                       auto: pick site, find <site>.captured.jsonl\n"
+            "  nabla jeremy path/to/repo --site extract_invoice --captured captured.jsonl\n"
+        ),
+    )
+    p_jeremy.add_argument("repo", nargs="?", default=".", help="path to target repo (default: current directory)")
+    p_jeremy.add_argument(
+        "--site",
+        help="site symbol (auto-picked when omitted and the repo has exactly one supported call site)",
+    )
+    p_jeremy.add_argument("--captured", "--examples", dest="examples",
+                          help="captured JSONL from `nabla capture` (default: <site>.captured.jsonl)")
+    p_jeremy.add_argument("--out", default=None,
+                          help="output path (default: <site>.jeremy.json)")
+
     return parser
 
 
@@ -193,6 +216,7 @@ def main(argv: list[str] | None = None) -> int:
         "record": _cmd_record,    # legacy alias
         "build": _cmd_profile,
         "profile": _cmd_profile,  # legacy alias
+        "jeremy": lambda a: _cmd_profile(a, mode="jeremy"),
     }
     try:
         return commands[args.command](args)
@@ -264,9 +288,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 +301,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}")
 
@@ -772,21 +802,23 @@ def _find_captured_file(site) -> Path | None:
     )
 
 
-def _cmd_profile(args) -> int:
+def _cmd_profile(args, mode: str = "profile") -> int:
     from .ui import rail, rail_end, rail_start
 
-    rail_start(_out, "nabla build")
+    command = "jeremy" if mode == "jeremy" else "build"
+    noun = "seed spec(s)" if mode == "jeremy" else "profile(s)"
+    rail_start(_out, f"nabla {command}")
     sites = scan(args.repo)
 
-    # Multi-site: no --site/--captured, several supported sites — build a
-    # profile for every site that has captured pairs on disk.
+    # Multi-site: no --site/--captured, several supported sites — build the
+    # artifact for every site that has captured pairs on disk.
     if args.site is None and args.examples is None:
         supported = [s for s in sites
                      if is_supported(resolve_schema(s, args.repo)[1], s.flags)]
         if len(supported) > 1:
             with_captures = [s for s in supported if _find_captured_file(s) is not None]
             if not with_captures:
-                print(f"nabla build: no captured pairs found for any of the "
+                print(f"nabla {command}: no captured pairs found for any of the "
                       f"{len(supported)} supported sites. Run first: nabla capture {args.repo}",
                       file=sys.stderr)
                 return 2
@@ -795,11 +827,11 @@ def _cmd_profile(args) -> int:
             for i, site in enumerate(with_captures):
                 if i:
                     rail(_out)
-                rc = _build_one(args, site) or rc
+                rc = _build_one(args, site, mode=mode) or rc
             if skipped:
                 rail(_out, f"skipped (no captured pairs): {', '.join(skipped)}", style="yellow")
             rail(_out)
-            rail_end(_out, f"done — built {len(with_captures)} profile(s)", style="green")
+            rail_end(_out, f"done — built {len(with_captures)} {noun}", style="green")
             return rc
 
     site, err = _resolve_site(args, sites)
@@ -807,16 +839,32 @@ def _cmd_profile(args) -> int:
         return err
     if args.site:
         rail(_out, f"site {site.symbol} · {site.file}")
-    rc = _build_one(args, site, final_rail=True)
+    rc = _build_one(args, site, final_rail=True, mode=mode)
     return rc
 
 
-def _build_one(args, site, final_rail: bool = False) -> int:
+def _compose_seed_goal(goal) -> str:
+    """Generator-framed goal text for the seed spec, composed in pure Python
+    from the induced GoalBlock — no extra LLM call, no invented facts."""
+    parts = [
+        "You are generating new problems to test and eventually fine-tune a "
+        "small student model on the following task: " + goal.description.rstrip(".") + "."
+    ]
+    if goal.constraints:
+        parts.append("Every generated problem's solution must satisfy: "
+                     + " ".join(c.rstrip(".") + "." for c in goal.constraints))
+    parts.append("Match the style, difficulty range, and output format of the "
+                 "reference examples below.")
+    return " ".join(parts)
+
+
+def _build_one(args, site, final_rail: bool = False, mode: str = "profile") -> 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
 
+    command = "jeremy" if mode == "jeremy" else "build"
     examples_path = args.examples
     if examples_path is None:
         found = _find_captured_file(site) or (
@@ -825,7 +873,7 @@ def _build_one(args, site, final_rail: bool = False) -> int:
             capture_cmd = f"nabla capture {args.repo}"
             if args.site:
                 capture_cmd += f" --site {site.symbol}"
-            print(f"nabla build: no captured pairs found ({site.symbol}.captured.jsonl). "
+            print(f"nabla {command}: no captured pairs found ({site.symbol}.captured.jsonl). "
                   f"Run first: {capture_cmd}", file=sys.stderr)
             return 2
         examples_path = str(found)
@@ -851,21 +899,37 @@ def _build_one(args, site, final_rail: bool = False) -> int:
     else:
         goal = induce(template, schema, examples)
 
-    profile = build_profile(site, args.repo, examples, goal, recorded_from=recorded_from)
-    out = (args.out if final_rail else None) or f"{site.symbol}.profile.json"
-    Path(out).write_text(json.dumps(profile, indent=2), encoding="utf-8")
-    supported = profile["classification"]["supported"]
-    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])
-    rail(_out, f"difficulty   {dims}")
+    if mode == "jeremy":
+        seed = {
+            "goal": _compose_seed_goal(goal),
+            "system_prompt": template.system_prompt or "",
+            "examples": [
+                {"problem": e.prompt, "solution": e.completion} for e in examples
+            ],
+        }
+        out = (args.out if final_rail else None) or f"{site.symbol}.jeremy.json"
+        Path(out).write_text(json.dumps(seed, indent=2), encoding="utf-8")
+        rail(_out)
+        rail_ok(_out, f"wrote {out}")
+        rail(_out, f"site         {site.symbol}")
+        rail(_out, f"examples     {len(examples)} ({recorded_from})")
+        rail(_out, f"goal         {seed['goal'][:90]}")
+    else:
+        profile = build_profile(site, args.repo, examples, goal, recorded_from=recorded_from)
+        out = (args.out if final_rail else None) or f"{site.symbol}.profile.json"
+        Path(out).write_text(json.dumps(profile, indent=2), encoding="utf-8")
+        supported = profile["classification"]["supported"]
+        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])
+        rail(_out, f"difficulty   {dims}")
     if len(examples) < 20:
         rail(_out, f"only {len(examples)} examples (< 20) — enough for a look, but a "
-                   "handoff-quality profile wants 20+ real-traffic pairs", style="yellow")
+                   "handoff-quality artifact wants 20+ real-traffic pairs", style="yellow")
     if final_rail:
         rail(_out)
         rail_end(_out, f"done — {out} is the handoff artifact", style="green")

{nabla_cli-0.6.3 → nabla_cli-0.7.0}/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.7.0}/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.7.0}/nabla_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.6.3
+Version: 0.7.0
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11
@@ -162,6 +162,23 @@ returns a goal description, implicit constraints, and difficulty
 dimensions with cited evidence. That's the goal line printed above, and
 it's what lands in the profile's `goal` block.
 
+### `nabla jeremy`
+
+An alternative to `build` with the same inputs and site handling: instead
+of the full site profile, it emits `<site>.jeremy.json` — a seed spec for
+a problem generator:
+
+```json
+{
+  "goal": "You are generating new problems to test and eventually fine-tune a small student model on the following task: ...",
+  "system_prompt": "<the site's own system prompt>",
+  "examples": [ {"problem": "...", "solution": "..."}, ... ]
+}
+```
+
+The goal text is composed deterministically from the same inferred goal
+and constraints that `build` uses; the examples are the captured pairs.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

{nabla_cli-0.6.3 → nabla_cli-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nabla-cli"
-version = "0.6.3"
+version = "0.7.0"
 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_cli-0.7.0}/tests/test_cli_ux.py

@@ -517,3 +517,72 @@ def test_scan_skips_build_and_dist_dirs(tmp_path, monkeypatch, capsys):
     out = capsys.readouterr().out
     assert "1 call site found" in out
     assert "copy_of_site" not in out
+
+
+# ---------------------------------------------------------------------------
+# nabla jeremy — seed-spec sibling of build
+# ---------------------------------------------------------------------------
+
+def _fake_goal(*a, **k):
+    from nabla.contract import GoalBlock
+
+    return GoalBlock(
+        description="Solve a grade-school word problem step by step.",
+        constraints=["final answer is a bare number", "no invented constants"],
+        difficulty_dimensions=[{"name": "d", "levels": ["a", "b"], "evidence": "e"}],
+    )
+
+
+def test_jeremy_single_site_writes_seed_spec(tmp_path, monkeypatch, capsys):
+    repo = _make_single_site_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    pair = {"input_slots": {"ocr_text": "r"}, "prompt": "A farmer has 6 crates...",
+            "completion": "The answer is 57.",
+            "tokens": {"in": 5, "out": 5}, "latency_ms": 10, "_source_kind": "samples"}
+    (tmp_path / "extract_receipt.captured.jsonl").write_text(
+        json.dumps(pair) + "\n", encoding="utf-8")
+    monkeypatch.setattr("nabla.induce.induce", _fake_goal)
+
+    rc = main(["jeremy", str(repo)])
+
+    assert rc == 0
+    seed = json.loads((tmp_path / "extract_receipt.jeremy.json").read_text(encoding="utf-8"))
+    assert set(seed) == {"goal", "system_prompt", "examples"}
+    assert seed["goal"].startswith("You are generating new problems")
+    assert "grade-school word problem" in seed["goal"]
+    assert "final answer is a bare number" in seed["goal"]
+    assert "Extract the receipt fields" in seed["system_prompt"]
+    assert seed["examples"] == [
+        {"problem": "A farmer has 6 crates...", "solution": "The answer is 57."}
+    ]
+    assert "extract_receipt.jeremy.json" in capsys.readouterr().out
+
+
+def test_jeremy_multi_site(tmp_path, monkeypatch, capsys):
+    repo = _make_two_site_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    pair = {"input_slots": {}, "prompt": "p", "completion": "s",
+            "tokens": {"in": 1, "out": 1}, "latency_ms": 1, "_source_kind": "samples"}
+    for symbol in ("extract_receipt", "extract_menu"):
+        (tmp_path / f"{symbol}.captured.jsonl").write_text(
+            json.dumps(pair) + "\n", encoding="utf-8")
+    monkeypatch.setattr("nabla.induce.induce", _fake_goal)
+
+    rc = main(["jeremy", str(repo)])
+
+    assert rc == 0
+    assert (tmp_path / "extract_receipt.jeremy.json").exists()
+    assert (tmp_path / "extract_menu.jeremy.json").exists()
+    assert "built 2 seed spec(s)" in capsys.readouterr().out
+
+
+def test_jeremy_without_captures_points_at_capture(tmp_path, monkeypatch, capsys):
+    repo = _make_single_site_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    rc = main(["jeremy", str(repo)])
+
+    assert rc == 2
+    err = capsys.readouterr().err
+    assert "nabla jeremy" in err
+    assert "nabla capture" in err

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()