nabla-cli 0.8.0__tar.gz → 0.9.0__tar.gz

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.8.0
+Version: 0.9.0
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11
@@ -182,14 +182,35 @@ output doesn't contain.
 
 ### `nabla push`
 
-Sends built artifacts to the nabla backend: every `<site>.profile.json`
-and `<site>.jeremy.json` found for the repo's supported sites (narrow
-with `--site`, or push exact files with `--artifact`). Each artifact is
-POSTed as `{"site", "kind", "artifact"}`.
-
-The endpoint defaults to the local dev server and is meant to change
-later — resolution order: `--endpoint` flag, then `NABLA_PUSH_ENDPOINT`,
-then `push_endpoint` in `~/.nabla/config.json`, then the default.
+Hands built artifacts to the backend dispatcher, which runs the
+seed-generation agent pool against them: every `<site>.profile.json` and
+`<site>.jeremy.json` found for the repo's supported sites (narrow with
+`--site`, or push exact files with `--artifact`). Artifacts are
+translated into the dispatcher's contract — `{goal, examples,
+student_system_prompt, student_goal}` — where `student_system_prompt` is
+the site's own production system prompt. A push runs the full pool
+server-side and may take minutes.
+
+The endpoint defaults to the local dispatcher
+(`http://127.0.0.1:8000/run-task`; start it from `backend/` with
+`langgraph dev` and `uvicorn seed_generator.server:app --port 8000`) and
+is meant to change later — resolution order: `--endpoint` flag, then
+`NABLA_PUSH_ENDPOINT`, then `push_endpoint` in `~/.nabla/config.json`,
+then the default.
+
+### `nabla pull` (preview)
+
+The loop-closer: fetches ready fine-tuned deployments and rewrites each
+harvested call site to run on your model — client `base_url` +
+`model` swap with env-wired credentials, rollback via one `unset`.
+Dry-run by default (diff only); `--apply` performs the edits and
+verifies the site live against the new endpoint, then prints the
+before/after cost and latency.
+
+Currently a full UX simulation while the deployments API is built:
+every run renders the real intended flow (diffs come from your repo's
+actual source) but writes nothing — each run ends with an explicit
+"simulation — nothing was written" line.
 
 ## Providers
 

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/README.md

@@ -168,14 +168,35 @@ output doesn't contain.
 
 ### `nabla push`
 
-Sends built artifacts to the nabla backend: every `<site>.profile.json`
-and `<site>.jeremy.json` found for the repo's supported sites (narrow
-with `--site`, or push exact files with `--artifact`). Each artifact is
-POSTed as `{"site", "kind", "artifact"}`.
-
-The endpoint defaults to the local dev server and is meant to change
-later — resolution order: `--endpoint` flag, then `NABLA_PUSH_ENDPOINT`,
-then `push_endpoint` in `~/.nabla/config.json`, then the default.
+Hands built artifacts to the backend dispatcher, which runs the
+seed-generation agent pool against them: every `<site>.profile.json` and
+`<site>.jeremy.json` found for the repo's supported sites (narrow with
+`--site`, or push exact files with `--artifact`). Artifacts are
+translated into the dispatcher's contract — `{goal, examples,
+student_system_prompt, student_goal}` — where `student_system_prompt` is
+the site's own production system prompt. A push runs the full pool
+server-side and may take minutes.
+
+The endpoint defaults to the local dispatcher
+(`http://127.0.0.1:8000/run-task`; start it from `backend/` with
+`langgraph dev` and `uvicorn seed_generator.server:app --port 8000`) and
+is meant to change later — resolution order: `--endpoint` flag, then
+`NABLA_PUSH_ENDPOINT`, then `push_endpoint` in `~/.nabla/config.json`,
+then the default.
+
+### `nabla pull` (preview)
+
+The loop-closer: fetches ready fine-tuned deployments and rewrites each
+harvested call site to run on your model — client `base_url` +
+`model` swap with env-wired credentials, rollback via one `unset`.
+Dry-run by default (diff only); `--apply` performs the edits and
+verifies the site live against the new endpoint, then prints the
+before/after cost and latency.
+
+Currently a full UX simulation while the deployments API is built:
+every run renders the real intended flow (diffs come from your repo's
+actual source) but writes nothing — each run ends with an explicit
+"simulation — nothing was written" line.
 
 ## Providers
 

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/nabla/__init__.py

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

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/nabla/cli.py

@@ -158,7 +158,7 @@ def _build_parser() -> argparse.ArgumentParser:
 
     p_push = sub.add_parser(
         "push",
-        help="send build/jeremy artifacts to the nabla backend",
+        help="send build/jeremy artifacts to the backend dispatcher (seed generation)",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=(
             "pushes every <site>.profile.json / <site>.jeremy.json found for the\n"
@@ -178,6 +178,30 @@ def _build_parser() -> argparse.ArgumentParser:
     p_push.add_argument("--endpoint", default=None,
                         help="backend URL (default: local dev server; see epilog for resolution order)")
 
+    p_pull = sub.add_parser(
+        "pull",
+        help="swap harvested sites onto their fine-tuned models (simulation)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "fetches ready deployments and rewrites each harvested call site to run\n"
+            "on your fine-tuned model (base_url + model swap, env-wired credentials).\n"
+            "dry-run by default: shows the diff, writes nothing. --apply performs the\n"
+            "edits and verifies live. Currently a full UX simulation — the\n"
+            "deployments API is not live yet, and nothing is ever written.\n\n"
+            "examples:\n"
+            "  nabla pull\n"
+            "  nabla pull --site solve_problem --apply\n"
+        ),
+    )
+    p_pull.add_argument("repo", nargs="?", default=".", help="path to target repo (default: current directory)")
+    p_pull.add_argument("--site", help="only this site")
+    p_pull.add_argument("--apply", action="store_true",
+                        help="perform the edits (simulated) and run the live verify")
+    p_pull.add_argument("--no-verify", action="store_true",
+                        help="with --apply: skip the post-apply live check")
+    p_pull.add_argument("--endpoint", default=None,
+                        help="deployments API URL (default: local backend)")
+
     return parser
 
 
@@ -241,6 +265,7 @@ def main(argv: list[str] | None = None) -> int:
         "profile": _cmd_profile,  # legacy alias
         "jeremy": lambda a: _cmd_profile(a, mode="jeremy"),
         "push": _cmd_push,
+        "pull": _cmd_pull,
     }
     try:
         return commands[args.command](args)
@@ -1015,13 +1040,130 @@ def _cmd_push(args) -> int:
 
     rail(_out)
     if failed and not pushed:
-        rail_end(_out, f"push failed — is the backend running at {endpoint}? "
-                       "override with --endpoint or NABLA_PUSH_ENDPOINT", style="red")
+        rail_end(_out, f"push failed — is the dispatcher running at {endpoint}? "
+                       "start it from backend/ (langgraph dev, then uvicorn "
+                       "seed_generator.server:app --port 8000), or override with "
+                       "--endpoint / NABLA_PUSH_ENDPOINT", style="red")
         return 1
     summary = f"pushed {pushed} artifact(s)" + (f", {failed} failed" if failed else "")
     rail_end(_out, summary, style="green" if not failed else "yellow")
     return 0 if not failed else 1
 
 
+def _cmd_pull(args) -> int:
+    from rich import box as rich_box
+    from rich.table import Table
+    from rich.text import Text
+
+    from .profile import extract_sampling
+    from .puller import build_diff, mock_deployment, pace, resolve_endpoint
+    from .ui import make_progress, rail, rail_end, rail_ok, rail_start
+
+    interactive = _out.is_terminal
+    rail_start(_out, "nabla pull")
+    endpoint = resolve_endpoint(args.endpoint)
+    rail(_out, f"endpoint  {endpoint}")
+
+    sites = scan(args.repo)
+    supported = [s for s in sites
+                 if is_supported(resolve_schema(s, args.repo)[1], s.flags)]
+    if args.site:
+        supported = [s for s in supported if s.symbol == args.site]
+        if not supported:
+            _fail(f"nabla pull: no supported site named {args.site!r}")
+            return 2
+    if not supported:
+        _fail(f"nabla pull: no supported call sites in {args.repo!r}")
+        return 2
+
+    if interactive:
+        with _out.status("fetching deployments", spinner="dots"):
+            pace(0.6, interactive)
+    deployments = []
+    for site in supported:
+        replaces = extract_sampling(site, args.repo).get("model") or "unknown"
+        deployments.append((site, mock_deployment(site.symbol, replaces)))
+
+    rail(_out)
+    table = Table(box=rich_box.SIMPLE_HEAD, header_style="bold", pad_edge=False)
+    for col in ("SITE", "FINE-TUNED MODEL", "REPLACES", "PASS RATE", "STATUS"):
+        table.add_column(col, overflow="fold")
+    for site, dep in deployments:
+        table.add_row(
+            Text(site.symbol, style="cyan"),
+            dep["model"],
+            dep["replaces"],
+            f"{dep['pass_rate']:.0%}",
+            Text("ready", style="green"),
+        )
+    _out.print(table)
+
+    for site, dep in deployments:
+        rail(_out)
+        rail(_out, f"{site.symbol} · {site.file}", style="bold")
+        for style, line in build_diff(args.repo, site, dep):
+            color = {"add": "green", "del": "red", "hunk": "cyan",
+                     "head": "bold", "ctx": ""}[style]
+            rail(_out, line, style=color)
+
+    if not args.apply:
+        rail(_out)
+        rail_end(_out, "dry run — rerun with --apply to write these edits")
+        _out.print("simulation — nothing was written (deployments API not live yet)",
+                   style="dim", markup=False)
+        return 0
+
+    # --apply: simulated edits, then the live verify.
+    rail(_out)
+    for site, dep in deployments:
+        pace(0.35, interactive)
+        rail_ok(_out, f"{site.symbol}: 2 edits -> {site.file}")
+    pace(0.25, interactive)
+    rail_ok(_out, f"credentials -> .env ({len(deployments) * 2 + 1} vars, gitignored ✓)")
+
+    if not args.no_verify:
+        rail(_out)
+        rail(_out, "verifying against the fine-tuned endpoint", style="bold")
+        for site, dep in deployments:
+            inputs = Path(f"{site.symbol}.inputs.jsonl")
+            try:
+                total = sum(1 for l in inputs.read_text(encoding="utf-8").splitlines()
+                            if l.strip()) or 5
+            except OSError:
+                total = 5
+            if interactive:
+                progress = make_progress(_out, unit="checks")
+                with progress:
+                    task = progress.add_task(site.symbol, total=total)
+                    for i in range(total):
+                        pace(0.3, interactive)
+                        progress.update(task, completed=i + 1)
+            rail_ok(_out, f"{site.symbol}: {total}/{total} completions valid "
+                          "against output_schema")
+
+    rail(_out)
+    for site, dep in deployments:
+        profile_path = Path(f"{site.symbol}.profile.json")
+        before_cost, before_p50 = 0.00247, 1097
+        try:
+            baseline = json.loads(profile_path.read_text(encoding="utf-8"))["baseline"]
+            before_cost = baseline["cost_per_call_usd"] or before_cost
+            before_p50 = baseline["p50_latency_ms"] or before_p50
+        except (OSError, KeyError, json.JSONDecodeError):
+            pass
+        after_cost, after_p50 = before_cost / 11, int(before_p50 * 0.55)
+        rail(_out, f"{site.symbol}   cost/call  ${before_cost:.6f} -> ${after_cost:.6f} "
+                   f"(-{1 - after_cost / before_cost:.0%})")
+        rail(_out, f"{' ' * len(site.symbol)}   p50        {before_p50}ms -> {after_p50}ms")
+
+    rail(_out)
+    rollback = deployments[0][0].symbol.upper()
+    rail_end(_out, f"done — {len(deployments)} site(s) now run on your models "
+                   f"(rollback: unset NABLA_MODEL_{rollback} and restart)", style="green")
+    _out.print("simulation — nothing was written (deployments API not live yet)",
+               style="dim", markup=False)
+    return 0
+
+
 if __name__ == "__main__":
     sys.exit(main())

nabla_cli-0.9.0/nabla/puller.py

@@ -0,0 +1,119 @@
+"""`nabla pull` — UX simulation of the loop-closing command (cli-plan §7).
+
+The deployments API doesn't exist yet, so this module renders the full
+intended experience — deployment table, per-site diffs, apply + verify,
+before/after report — as a faithful simulation that NEVER writes anything:
+no file edits, no .env changes, no network calls. Diffs are built from the
+target repo's real source lines so the preview is true to life; deployment
+rows are fabricated deterministically from the site symbol.
+
+When the real backend lands, the fabrication points (_mock_deployments,
+the apply/verify steps) get replaced by API calls and real edits; the
+rendering stays.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from .config import load_config
+
+DEFAULT_ENDPOINT = "http://127.0.0.1:8000/deployments"
+_BASE_URL = "https://api.freesolo.ai/v1"
+_KEY_ENV = "NABLA_MODEL_API_KEY"
+
+
+def resolve_endpoint(flag_value: str | None = None) -> str:
+    if flag_value:
+        return flag_value
+    env = os.environ.get("NABLA_PULL_ENDPOINT")
+    if env:
+        return env
+    stored = load_config().get("pull_endpoint")
+    if stored:
+        return stored
+    return DEFAULT_ENDPOINT
+
+
+def mock_deployment(symbol: str, replaces: str) -> dict:
+    """A deterministic, plausible deployment row for one site."""
+    slug = symbol.replace("_", "-")
+    seed = sum(ord(c) for c in symbol)
+    return {
+        "symbol": symbol,
+        "status": "ready",
+        "model": f"freesolo/qwen3.5-0.8b-ft-{slug}",
+        "base_url": _BASE_URL,
+        "api_key_env": _KEY_ENV,
+        "replaces": replaces or "unknown",
+        "pass_rate": round(0.88 + (seed % 10) / 100, 2),
+        "schema_valid_rate": 1.0,
+    }
+
+
+def build_diff(repo: str, site, deployment: dict) -> list[tuple[str, str]]:
+    """(style, line) pairs for a unified diff of the intended rewrite,
+    grounded in the real source. Read-only."""
+    path = Path(repo) / site.file
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return []
+
+    env_suffix = site.symbol.upper()
+    out: list[tuple[str, str]] = [
+        ("head", f"--- a/{site.file}"),
+        ("head", f"+++ b/{site.file}"),
+    ]
+
+    # Hunk 1: client construction, if a literal OpenAI(...) line exists.
+    client_idx = next((i for i, l in enumerate(lines)
+                       if "OpenAI(" in l and "import" not in l), None)
+    if client_idx is not None:
+        old = lines[client_idx]
+        indent = old[: len(old) - len(old.lstrip())]
+        assign = old.split("OpenAI(", 1)[0]
+        out += [
+            ("hunk", f"@@ -{client_idx + 1},1 +{client_idx + 1},2 @@"),
+            ("del", f"-{old}"),
+            ("add", f"+{assign}OpenAI("),
+            ("add", f"+{indent}    base_url=os.environ.get(\"NABLA_BASE_URL\", "
+                    f"\"{deployment['base_url']}\"),"),
+            ("add", f"+{indent}    api_key=os.environ[\"{deployment['api_key_env']}\"],"),
+            ("add", f"+{indent})"),
+        ]
+
+    # Hunk 2: the model kwarg inside the call span.
+    start, end = site.span
+    model_idx = next((i for i in range(start - 1, min(end, len(lines)))
+                      if "model=" in lines[i] or "model =" in lines[i]), None)
+    if model_idx is not None:
+        old = lines[model_idx]
+        indent = old[: len(old) - len(old.lstrip())]
+        trailing = "," if old.rstrip().endswith(",") else ""
+        context = lines[model_idx - 1] if model_idx else ""
+        out += [
+            ("hunk", f"@@ -{model_idx},2 +{model_idx},2 @@"),
+            ("ctx", f" {context}"),
+            ("del", f"-{old}"),
+            ("add", f"+{indent}model=os.environ.get(\"NABLA_MODEL_{env_suffix}\", "
+                    f"\"{deployment['model']}\"){trailing}"),
+        ]
+
+    # Hunk 3: credentials, appended to the repo's .env.
+    out += [
+        ("head", "--- a/.env"),
+        ("head", "+++ b/.env"),
+        ("add", f"+{deployment['api_key_env']}=fsk-................ (provisioned by backend)"),
+        ("add", f"+NABLA_BASE_URL={deployment['base_url']}"),
+        ("add", f"+NABLA_MODEL_{env_suffix}={deployment['model']}"),
+    ]
+    return out
+
+
+def pace(seconds: float, interactive: bool) -> None:
+    """Small dramatic pause, interactive terminals only."""
+    if interactive:
+        time.sleep(seconds)

nabla_cli-0.9.0/nabla/pusher.py

@@ -0,0 +1,121 @@
+"""`nabla push` transport: hand build/jeremy artifacts to the backend
+dispatcher (backend/seed_generator/server.py, POST /run-task), which fires
+the Phase 0 seed-generation agents against them.
+
+The endpoint is deliberately swappable — the local dispatcher today, a
+hosted service later. Resolution order (first hit wins):
+
+  1. --endpoint flag
+  2. NABLA_PUSH_ENDPOINT env var
+  3. "push_endpoint" in ~/.nabla/config.json
+  4. DEFAULT_ENDPOINT (the local dispatcher)
+
+Both artifact kinds are translated into the dispatcher's RunTaskRequest
+contract before sending:
+
+  {"goal": str, "examples": [{"problem", "solution"}, ...],
+   "student_system_prompt": str, "student_goal": str}
+
+`goal` steers the authoring LLM; `student_system_prompt` is the site's own
+production system prompt — the persona the fine-tuned student will really
+be queried under. A run executes the full agent pool server-side and can
+take minutes; the timeout is sized accordingly (override via
+NABLA_PUSH_TIMEOUT seconds).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+from .config import load_config
+
+DEFAULT_ENDPOINT = "http://127.0.0.1:8000/run-task"
+DEFAULT_TIMEOUT = 900  # the dispatcher runs the whole agent pool before replying
+
+
+def resolve_endpoint(flag_value: str | None = None) -> str:
+    if flag_value:
+        return flag_value
+    env = os.environ.get("NABLA_PUSH_ENDPOINT")
+    if env:
+        return env
+    stored = load_config().get("push_endpoint")
+    if stored:
+        return stored
+    return DEFAULT_ENDPOINT
+
+
+def to_run_task(kind: str, artifact: dict) -> dict:
+    """Translate a build/jeremy artifact into the dispatcher's
+    RunTaskRequest shape. Pure rearrangement — nothing invented."""
+    if kind == "jeremy":
+        return {
+            "goal": artifact.get("goal", ""),
+            "examples": artifact.get("examples", []),
+            "student_system_prompt": artifact.get("system_prompt", "") or "",
+            "student_goal": artifact.get("goal", ""),
+        }
+    # profile: same information, different layout.
+    goal_block = artifact.get("goal", {}) or {}
+    goal_text = " ".join(
+        [str(goal_block.get("description", "")).rstrip(".") + "."]
+        + [str(c).rstrip(".") + "." for c in goal_block.get("constraints", [])]
+    ).strip()
+    return {
+        "goal": goal_text,
+        "examples": [
+            {"problem": e.get("prompt", ""), "solution": e.get("completion", "")}
+            for e in artifact.get("examples", [])
+        ],
+        "student_system_prompt": (artifact.get("prompt", {}) or {}).get("system_prompt") or "",
+        "student_goal": goal_text,
+    }
+
+
+def push_artifact(endpoint: str, site: str, kind: str, artifact: dict,
+                  timeout: int | None = None) -> tuple[bool, str]:
+    """Translate + POST one artifact. Returns (ok, detail) — never raises."""
+    if timeout is None:
+        timeout = int(os.environ.get("NABLA_PUSH_TIMEOUT", str(DEFAULT_TIMEOUT)))
+    payload = json.dumps(to_run_task(kind, artifact)).encode("utf-8")
+    req = urllib.request.Request(
+        endpoint,
+        data=payload,
+        method="POST",
+        headers={"Content-Type": "application/json", "User-Agent": "nabla-push/0.1"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            body = resp.read().decode("utf-8", "replace")
+            summary = _summarize_response(body)
+            return True, f"HTTP {resp.status}" + (f" · {summary}" if summary else "")
+    except urllib.error.HTTPError as exc:
+        try:
+            detail = exc.read().decode("utf-8", "replace")[:200]
+        except Exception:  # noqa: BLE001 - body read is best-effort
+            detail = ""
+        return False, f"HTTP {exc.code}" + (f" · {detail}" if detail else f" · {exc.reason}")
+    except urllib.error.URLError as exc:
+        return False, f"unreachable ({exc.reason})"
+    except Exception as exc:  # noqa: BLE001 - transport must never crash the CLI
+        return False, str(exc)[:200]
+
+
+def _summarize_response(body: str) -> str:
+    """One line from the dispatcher's (potentially large) run result."""
+    try:
+        data = json.loads(body)
+    except json.JSONDecodeError:
+        return body[:120].strip()
+    if isinstance(data, dict):
+        accepted = data.get("accepted")
+        dist = data.get("pool_distribution") or {}
+        if isinstance(accepted, list):
+            return f"{len(accepted)} seed task(s) accepted" + (
+                " · pool ok" if dist.get("ok") else ""
+            )
+        return json.dumps(data)[:120]
+    return body[:120].strip()

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/nabla_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.8.0
+Version: 0.9.0
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11
@@ -182,14 +182,35 @@ output doesn't contain.
 
 ### `nabla push`
 
-Sends built artifacts to the nabla backend: every `<site>.profile.json`
-and `<site>.jeremy.json` found for the repo's supported sites (narrow
-with `--site`, or push exact files with `--artifact`). Each artifact is
-POSTed as `{"site", "kind", "artifact"}`.
-
-The endpoint defaults to the local dev server and is meant to change
-later — resolution order: `--endpoint` flag, then `NABLA_PUSH_ENDPOINT`,
-then `push_endpoint` in `~/.nabla/config.json`, then the default.
+Hands built artifacts to the backend dispatcher, which runs the
+seed-generation agent pool against them: every `<site>.profile.json` and
+`<site>.jeremy.json` found for the repo's supported sites (narrow with
+`--site`, or push exact files with `--artifact`). Artifacts are
+translated into the dispatcher's contract — `{goal, examples,
+student_system_prompt, student_goal}` — where `student_system_prompt` is
+the site's own production system prompt. A push runs the full pool
+server-side and may take minutes.
+
+The endpoint defaults to the local dispatcher
+(`http://127.0.0.1:8000/run-task`; start it from `backend/` with
+`langgraph dev` and `uvicorn seed_generator.server:app --port 8000`) and
+is meant to change later — resolution order: `--endpoint` flag, then
+`NABLA_PUSH_ENDPOINT`, then `push_endpoint` in `~/.nabla/config.json`,
+then the default.
+
+### `nabla pull` (preview)
+
+The loop-closer: fetches ready fine-tuned deployments and rewrites each
+harvested call site to run on your model — client `base_url` +
+`model` swap with env-wired credentials, rollback via one `unset`.
+Dry-run by default (diff only); `--apply` performs the edits and
+verifies the site live against the new endpoint, then prints the
+before/after cost and latency.
+
+Currently a full UX simulation while the deployments API is built:
+every run renders the real intended flow (diffs come from your repo's
+actual source) but writes nothing — each run ends with an explicit
+"simulation — nothing was written" line.
 
 ## Providers
 

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/nabla_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ nabla/contract.py
 nabla/induce.py
 nabla/profile.py
 nabla/prompt_recon.py
+nabla/puller.py
 nabla/pusher.py
 nabla/recorder.py
 nabla/samplegen.py
@@ -28,6 +29,7 @@ tests/test_config.py
 tests/test_e2e_profile.py
 tests/test_induce.py
 tests/test_prompt_recon.py
+tests/test_pull.py
 tests/test_push.py
 tests/test_recorder.py
 tests/test_samplegen.py

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/pyproject.toml

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

nabla_cli-0.9.0/tests/test_pull.py

@@ -0,0 +1,76 @@
+"""Tests for the nabla pull simulation — its one hard guarantee: it never
+writes anything."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from nabla.cli import main
+
+from test_cli_ux import _SINGLE_SITE_SRC
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch, tmp_path):
+    monkeypatch.setattr("nabla.config.config_path", lambda: tmp_path / "no-config.json")
+    monkeypatch.delenv("NABLA_PULL_ENDPOINT", raising=False)
+
+
+def _snapshot(root):
+    return {p: p.read_bytes() for p in root.rglob("*") if p.is_file()}
+
+
+def test_pull_dry_run_prints_diff_and_writes_nothing(tmp_path, monkeypatch, capsys):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "single_call_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+    before = _snapshot(tmp_path)
+
+    rc = main(["pull", str(repo)])
+
+    assert rc == 0
+    assert _snapshot(tmp_path) == before  # nothing created or modified
+    out = capsys.readouterr().out
+    assert "freesolo/qwen3.5-0.8b-ft-extract-receipt" in out
+    assert "gpt-4o-mini" in out          # REPLACES column from real sampling
+    assert "--- a/single_call_site.py" in out
+    assert "+++ b/.env" in out
+    assert "dry run" in out
+    assert "simulation — nothing was written" in out
+
+
+def test_pull_apply_simulates_and_writes_nothing(tmp_path, monkeypatch, capsys):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "single_call_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
+    (tmp_path / "extract_receipt.profile.json").write_text(json.dumps(
+        {"baseline": {"cost_per_call_usd": 0.011, "p50_latency_ms": 2000,
+                      "calls_observed": 5}}), encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+    before = _snapshot(tmp_path)
+
+    rc = main(["pull", str(repo), "--apply"])
+
+    assert rc == 0
+    assert _snapshot(tmp_path) == before
+    out = capsys.readouterr().out
+    assert "2 edits -> single_call_site.py" in out
+    assert "completions valid" in out
+    assert "$0.011000 -> $0.001000" in out
+    assert "rollback: unset NABLA_MODEL_EXTRACT_RECEIPT" in out
+    assert "simulation — nothing was written" in out
+
+
+def test_pull_unknown_site_exits_2(tmp_path, monkeypatch, capsys):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "single_call_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+
+    rc = main(["pull", str(repo), "--site", "nope"])
+
+    assert rc == 2
+    assert "no supported site" in capsys.readouterr().err

{nabla_cli-0.8.0 → nabla_cli-0.9.0}/tests/test_push.py

@@ -1,119 +1,144 @@
-"""Tests for nabla push — offline via a local threaded HTTP server."""
-
-from __future__ import annotations
-
-import http.server
-import json
-import threading
-
-import pytest
-
-from nabla.cli import main
-from nabla.pusher import DEFAULT_ENDPOINT, push_artifact, resolve_endpoint
-
-from test_cli_ux import _SINGLE_SITE_SRC
-
-
-@pytest.fixture(autouse=True)
-def _clean_env(monkeypatch, tmp_path):
-    monkeypatch.setattr("nabla.config.config_path", lambda: tmp_path / "no-config.json")
-    monkeypatch.delenv("NABLA_PUSH_ENDPOINT", raising=False)
-
-
-class _Backend:
-    """Tiny in-process receiver capturing every POST body."""
-
-    def __init__(self, status: int = 200):
-        self.received: list[dict] = []
-        backend = self
-
-        class Handler(http.server.BaseHTTPRequestHandler):
-            def log_message(self, *a):
-                pass
-
-            def do_POST(self):
-                length = int(self.headers.get("Content-Length") or 0)
-                backend.received.append(json.loads(self.rfile.read(length)))
-                self.send_response(status)
-                self.send_header("Content-Length", "2")
-                self.end_headers()
-                self.wfile.write(b"ok")
-
-        self.server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
-        threading.Thread(target=self.server.serve_forever, daemon=True).start()
-
-    @property
-    def url(self) -> str:
-        return f"http://127.0.0.1:{self.server.server_address[1]}/api/profiles"
-
-    def stop(self):
-        self.server.shutdown()
-        self.server.server_close()
-
-
-def test_endpoint_resolution_order(monkeypatch, tmp_path):
-    assert resolve_endpoint() == DEFAULT_ENDPOINT
-    cfg = tmp_path / "config.json"
-    cfg.write_text(json.dumps({"push_endpoint": "http://cfg"}), encoding="utf-8")
-    monkeypatch.setattr("nabla.config.config_path", lambda: cfg)
-    assert resolve_endpoint() == "http://cfg"
-    monkeypatch.setenv("NABLA_PUSH_ENDPOINT", "http://env")
-    assert resolve_endpoint() == "http://env"
-    assert resolve_endpoint("http://flag") == "http://flag"
-
-
-def test_push_artifact_success_and_unreachable():
-    backend = _Backend()
-    try:
-        ok, detail = push_artifact(backend.url, "s", "profile", {"a": 1})
-        assert ok and "200" in detail
-        assert backend.received == [{"site": "s", "kind": "profile", "artifact": {"a": 1}}]
-    finally:
-        backend.stop()
-    ok, detail = push_artifact("http://127.0.0.1:9/none", "s", "profile", {}, timeout=2)
-    assert not ok and "unreachable" in detail
-
-
-def test_cmd_push_sweeps_site_artifacts(tmp_path, monkeypatch, capsys):
-    repo = tmp_path / "repo"
-    repo.mkdir()
-    (repo / "single_call_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
-    monkeypatch.chdir(tmp_path)
-    (tmp_path / "extract_receipt.profile.json").write_text('{"p": 1}', encoding="utf-8")
-    (tmp_path / "extract_receipt.jeremy.json").write_text('{"j": 1}', encoding="utf-8")
-
-    backend = _Backend()
-    try:
-        rc = main(["push", str(repo), "--endpoint", backend.url])
-    finally:
-        backend.stop()
-
-    assert rc == 0
-    kinds = {(r["site"], r["kind"]) for r in backend.received}
-    assert kinds == {("extract_receipt", "profile"), ("extract_receipt", "jeremy")}
-    assert "pushed 2 artifact(s)" in capsys.readouterr().out
-
-
-def test_cmd_push_no_artifacts_exits_2(tmp_path, monkeypatch, capsys):
-    repo = tmp_path / "repo"
-    repo.mkdir()
-    (repo / "single_call_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
-    monkeypatch.chdir(tmp_path)
-
-    rc = main(["push", str(repo)])
-
-    assert rc == 2
-    assert "nabla build" in capsys.readouterr().err
-
-
-def test_cmd_push_unreachable_backend_exits_1(tmp_path, monkeypatch, capsys):
-    monkeypatch.chdir(tmp_path)
-    (tmp_path / "x.profile.json").write_text('{"p": 1}', encoding="utf-8")
-
-    rc = main(["push", "--artifact", "x.profile.json",
-               "--endpoint", "http://127.0.0.1:9/none"])
-
-    assert rc == 1
-    captured = capsys.readouterr()
-    assert "unreachable" in captured.err
-    assert "NABLA_PUSH_ENDPOINT" in captured.out + captured.err
+"""Tests for nabla push — offline via a local threaded HTTP server."""
+
+from __future__ import annotations
+
+import http.server
+import json
+import threading
+
+import pytest
+
+from nabla.cli import main
+from nabla.pusher import DEFAULT_ENDPOINT, push_artifact, resolve_endpoint
+
+from test_cli_ux import _SINGLE_SITE_SRC
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch, tmp_path):
+    monkeypatch.setattr("nabla.config.config_path", lambda: tmp_path / "no-config.json")
+    monkeypatch.delenv("NABLA_PUSH_ENDPOINT", raising=False)
+
+
+class _Backend:
+    """Tiny in-process receiver capturing every POST body."""
+
+    def __init__(self, status: int = 200):
+        self.received: list[dict] = []
+        backend = self
+
+        class Handler(http.server.BaseHTTPRequestHandler):
+            def log_message(self, *a):
+                pass
+
+            def do_POST(self):
+                length = int(self.headers.get("Content-Length") or 0)
+                backend.received.append(json.loads(self.rfile.read(length)))
+                self.send_response(status)
+                self.send_header("Content-Length", "2")
+                self.end_headers()
+                self.wfile.write(b"ok")
+
+        self.server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+        threading.Thread(target=self.server.serve_forever, daemon=True).start()
+
+    @property
+    def url(self) -> str:
+        return f"http://127.0.0.1:{self.server.server_address[1]}/api/profiles"
+
+    def stop(self):
+        self.server.shutdown()
+        self.server.server_close()
+
+
+def test_endpoint_resolution_order(monkeypatch, tmp_path):
+    assert resolve_endpoint() == DEFAULT_ENDPOINT
+    cfg = tmp_path / "config.json"
+    cfg.write_text(json.dumps({"push_endpoint": "http://cfg"}), encoding="utf-8")
+    monkeypatch.setattr("nabla.config.config_path", lambda: cfg)
+    assert resolve_endpoint() == "http://cfg"
+    monkeypatch.setenv("NABLA_PUSH_ENDPOINT", "http://env")
+    assert resolve_endpoint() == "http://env"
+    assert resolve_endpoint("http://flag") == "http://flag"
+
+
+def test_push_artifact_translates_jeremy_to_run_task():
+    backend = _Backend()
+    try:
+        artifact = {"goal": "Solve problems.", "system_prompt": "You are a tutor.",
+                    "examples": [{"problem": "p", "solution": "s"}]}
+        ok, detail = push_artifact(backend.url, "s", "jeremy", artifact)
+        assert ok and "200" in detail
+        assert backend.received == [{
+            "goal": "Solve problems.",
+            "examples": [{"problem": "p", "solution": "s"}],
+            "student_system_prompt": "You are a tutor.",
+            "student_goal": "Solve problems.",
+        }]
+    finally:
+        backend.stop()
+
+
+def test_to_run_task_translates_profile():
+    from nabla.pusher import to_run_task
+
+    profile = {
+        "goal": {"description": "Extract fields", "constraints": ["null when absent"]},
+        "prompt": {"system_prompt": "You are precise."},
+        "examples": [{"prompt": "doc text", "completion": "{}", "tokens": {"in": 1, "out": 1}}],
+    }
+    body = to_run_task("profile", profile)
+    assert body["goal"] == "Extract fields. null when absent."
+    assert body["student_system_prompt"] == "You are precise."
+    assert body["examples"] == [{"problem": "doc text", "solution": "{}"}]
+    ok, detail = push_artifact("http://127.0.0.1:9/none", "s", "profile", {}, timeout=2)
+    assert not ok and "unreachable" in detail
+
+
+def test_cmd_push_sweeps_site_artifacts(tmp_path, monkeypatch, capsys):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "single_call_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "extract_receipt.profile.json").write_text(
+        '{"goal": {"description": "d", "constraints": []}, "prompt": {"system_prompt": "sp"}, "examples": []}',
+        encoding="utf-8")
+    (tmp_path / "extract_receipt.jeremy.json").write_text(
+        '{"goal": "g", "system_prompt": "sp", "examples": []}', encoding="utf-8")
+
+    backend = _Backend()
+    try:
+        rc = main(["push", str(repo), "--endpoint", backend.url])
+    finally:
+        backend.stop()
+
+    assert rc == 0
+    assert len(backend.received) == 2
+    assert all(set(r) == {"goal", "examples", "student_system_prompt", "student_goal"}
+               for r in backend.received)
+    assert "pushed 2 artifact(s)" in capsys.readouterr().out
+
+
+def test_cmd_push_no_artifacts_exits_2(tmp_path, monkeypatch, capsys):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "single_call_site.py").write_text(_SINGLE_SITE_SRC, encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+
+    rc = main(["push", str(repo)])
+
+    assert rc == 2
+    assert "nabla build" in capsys.readouterr().err
+
+
+def test_cmd_push_unreachable_backend_exits_1(tmp_path, monkeypatch, capsys):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "x.profile.json").write_text('{"p": 1}', encoding="utf-8")
+
+    rc = main(["push", "--artifact", "x.profile.json",
+               "--endpoint", "http://127.0.0.1:9/none"])
+
+    assert rc == 1
+    captured = capsys.readouterr()
+    assert "unreachable" in captured.err
+    assert "NABLA_PUSH_ENDPOINT" in captured.out + captured.err

nabla_cli-0.8.0/nabla/pusher.py

@@ -1,68 +0,0 @@
-"""`nabla push` transport: deliver build/jeremy artifacts to the backend.
-
-The endpoint is deliberately swappable — local Next.js dev server today, a
-hosted service later. Resolution order (first hit wins):
-
-  1. --endpoint flag
-  2. NABLA_PUSH_ENDPOINT env var
-  3. "push_endpoint" in ~/.nabla/config.json
-  4. DEFAULT_ENDPOINT (the local dev server)
-
-One POST per artifact:
-
-  {"site": "<symbol>", "kind": "profile" | "jeremy", "artifact": {...}}
-
-A 2xx response is success; anything else (or no listener at all) is
-reported per artifact without aborting the rest of the batch.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import urllib.error
-import urllib.request
-
-from .config import load_config
-
-DEFAULT_ENDPOINT = "http://localhost:3000/api/profiles"
-
-
-def resolve_endpoint(flag_value: str | None = None) -> str:
-    if flag_value:
-        return flag_value
-    env = os.environ.get("NABLA_PUSH_ENDPOINT")
-    if env:
-        return env
-    stored = load_config().get("push_endpoint")
-    if stored:
-        return stored
-    return DEFAULT_ENDPOINT
-
-
-def push_artifact(endpoint: str, site: str, kind: str, artifact: dict,
-                  timeout: int = 30) -> tuple[bool, str]:
-    """POST one artifact. Returns (ok, detail) — never raises."""
-    payload = json.dumps(
-        {"site": site, "kind": kind, "artifact": artifact}
-    ).encode("utf-8")
-    req = urllib.request.Request(
-        endpoint,
-        data=payload,
-        method="POST",
-        headers={"Content-Type": "application/json", "User-Agent": "nabla-push/0.1"},
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            body = resp.read().decode("utf-8", "replace")[:200]
-            return True, f"HTTP {resp.status}" + (f" · {body}" if body.strip() else "")
-    except urllib.error.HTTPError as exc:
-        try:
-            detail = exc.read().decode("utf-8", "replace")[:200]
-        except Exception:  # noqa: BLE001 - body read is best-effort
-            detail = ""
-        return False, f"HTTP {exc.code}" + (f" · {detail}" if detail else f" · {exc.reason}")
-    except urllib.error.URLError as exc:
-        return False, f"unreachable ({exc.reason})"
-    except Exception as exc:  # noqa: BLE001 - transport must never crash the CLI
-        return False, str(exc)[:200]