nabla-cli 0.7.2__tar.gz → 0.8.1__tar.gz

{nabla_cli-0.7.2 → nabla_cli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.7.2
+Version: 0.8.1
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11
@@ -180,6 +180,24 @@ Same pipeline as `build` (captured pairs in, one goal-inference call) —
 only the output shape differs; nothing is added that `build`'s own
 output doesn't contain.
 
+### `nabla push`
+
+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.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

{nabla_cli-0.7.2 → nabla_cli-0.8.1}/README.md

@@ -166,6 +166,24 @@ Same pipeline as `build` (captured pairs in, one goal-inference call) —
 only the output shape differs; nothing is added that `build`'s own
 output doesn't contain.
 
+### `nabla push`
+
+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.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

{nabla_cli-0.7.2 → nabla_cli-0.8.1}/nabla/__init__.py

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

{nabla_cli-0.7.2 → nabla_cli-0.8.1}/nabla/cli.py

@@ -156,6 +156,28 @@ def _build_parser() -> argparse.ArgumentParser:
     p_jeremy.add_argument("--out", default=None,
                           help="output path (default: <site>.jeremy.json)")
 
+    p_push = sub.add_parser(
+        "push",
+        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"
+            "repo's supported sites (or one site with --site, or exact files with\n"
+            "--artifact). Endpoint resolution: --endpoint > NABLA_PUSH_ENDPOINT >\n"
+            "push_endpoint in ~/.nabla/config.json > local default.\n\n"
+            "examples:\n"
+            "  nabla push\n"
+            "  nabla push --site extract_invoice\n"
+            "  nabla push --artifact solve_problem.jeremy.json --endpoint https://api.example.com/profiles\n"
+        ),
+    )
+    p_push.add_argument("repo", nargs="?", default=".", help="path to target repo (default: current directory)")
+    p_push.add_argument("--site", help="only push this site's artifacts")
+    p_push.add_argument("--artifact", action="append", default=None,
+                        help="push this exact artifact file (repeatable; skips site discovery)")
+    p_push.add_argument("--endpoint", default=None,
+                        help="backend URL (default: local dev server; see epilog for resolution order)")
+
     return parser
 
 
@@ -218,6 +240,7 @@ def main(argv: list[str] | None = None) -> int:
         "build": _cmd_profile,
         "profile": _cmd_profile,  # legacy alias
         "jeremy": lambda a: _cmd_profile(a, mode="jeremy"),
+        "push": _cmd_push,
     }
     try:
         return commands[args.command](args)
@@ -934,5 +957,73 @@ def _build_one(args, site, final_rail: bool = False, mode: str = "profile") -> i
     return 0
 
 
+def _cmd_push(args) -> int:
+    from .pusher import push_artifact, resolve_endpoint
+    from .ui import rail, rail_end, rail_ok, rail_start
+
+    rail_start(_out, "nabla push")
+    endpoint = resolve_endpoint(args.endpoint)
+    rail(_out, f"endpoint  {endpoint}")
+
+    # Collect (site_symbol, kind, path) triples.
+    targets: list[tuple[str, str, Path]] = []
+    if args.artifact:
+        for raw in args.artifact:
+            path = Path(raw)
+            if not path.exists():
+                _fail(f"nabla push: {path} not found")
+                return 2
+            kind = "jeremy" if path.name.endswith(".jeremy.json") else "profile"
+            symbol = path.name.split(".")[0]
+            targets.append((symbol, kind, path))
+    else:
+        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 push: no supported site named {args.site!r}")
+                return 2
+        for site in supported:
+            for kind, name in (("profile", f"{site.symbol}.profile.json"),
+                               ("jeremy", f"{site.symbol}.jeremy.json")):
+                path = Path(name)
+                if path.exists():
+                    targets.append((site.symbol, kind, path))
+        if not targets:
+            print("nabla push: no artifacts found. Run first: nabla build or nabla jeremy",
+                  file=sys.stderr)
+            return 2
+
+    rail(_out)
+    pushed = failed = 0
+    for symbol, kind, path in targets:
+        try:
+            artifact = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            _fail(f"✗ {path}: unreadable ({str(exc)[:120]})")
+            failed += 1
+            continue
+        ok, detail = push_artifact(endpoint, symbol, kind, artifact)
+        if ok:
+            rail_ok(_out, f"{symbol} ({kind}) -> {detail}")
+            pushed += 1
+        else:
+            _fail(f"✗ {symbol} ({kind}): {detail}")
+            failed += 1
+
+    rail(_out)
+    if failed and not pushed:
+        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
+
+
 if __name__ == "__main__":
     sys.exit(main())

nabla_cli-0.8.1/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.7.2 → nabla_cli-0.8.1}/nabla_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.7.2
+Version: 0.8.1
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11
@@ -180,6 +180,24 @@ Same pipeline as `build` (captured pairs in, one goal-inference call) —
 only the output shape differs; nothing is added that `build`'s own
 output doesn't contain.
 
+### `nabla push`
+
+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.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

{nabla_cli-0.7.2 → nabla_cli-0.8.1}/nabla_cli.egg-info/SOURCES.txt

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

{nabla_cli-0.7.2 → nabla_cli-0.8.1}/pyproject.toml

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

nabla_cli-0.8.1/tests/test_push.py

@@ -0,0 +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_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