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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nabla-cli
-Version: 0.7.2
+Version: 0.8.0
 Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
 License: MIT
 Requires-Python: >=3.11
@@ -180,6 +180,17 @@ 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`
+
+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.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

nabla_cli-0.7.2/PKG-INFO → nabla_cli-0.8.0/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: nabla-cli
-Version: 0.7.2
-Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
-License: MIT
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: jsonschema
-Requires-Dist: pydantic>=2
-Requires-Dist: openai>=1.40
-Requires-Dist: rich>=13.0
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-
 # nabla — OpenAI call-site harvester
 
 `nabla` finds the OpenAI call sites in a Python repo, records real
@@ -180,6 +166,17 @@ 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`
+
+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.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

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

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

{nabla_cli-0.7.2 → nabla_cli-0.8.0}/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 nabla backend",
+        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,71 @@ 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 backend running at {endpoint}? "
+                       "override with --endpoint or 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.0/nabla/pusher.py

@@ -0,0 +1,68 @@
+"""`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]

nabla_cli-0.7.2/README.md → nabla_cli-0.8.0/nabla_cli.egg-info/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.4
+Name: nabla-cli
+Version: 0.8.0
+Summary: Call-site harvester: scan OpenAI call sites, record real traffic, emit site profiles
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: jsonschema
+Requires-Dist: pydantic>=2
+Requires-Dist: openai>=1.40
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
 # nabla — OpenAI call-site harvester
 
 `nabla` finds the OpenAI call sites in a Python repo, records real
@@ -166,6 +180,17 @@ 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`
+
+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.
+
 ## Providers
 
 `nabla init` supports three providers. Pick whichever you have a key

{nabla_cli-0.7.2 → nabla_cli-0.8.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/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.0}/pyproject.toml

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

nabla_cli-0.8.0/tests/test_push.py

@@ -0,0 +1,119 @@
+"""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