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

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

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

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

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

@@ -493,19 +493,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 +544,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 +641,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.3}/nabla/recorder.py

@@ -131,42 +131,56 @@ 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"}}
+                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 +429,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.3}/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.3}/nabla/ui.py

@@ -267,3 +267,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.3}/nabla_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.6.2
+Version: 0.6.3
 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.3}/pyproject.toml

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