genesis-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{genesis_cli-0.2.0 → genesis_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: genesis-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Genesis Agent Workbench CLI — make any repo agent-ready and keep AI-generated changes governed.
 Project-URL: Homepage, https://github.com/Inceptium-ai/genesis-framework
 Project-URL: Repository, https://github.com/Inceptium-ai/genesis-framework
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.12
-Requires-Dist: genesis-gates>=0.2.0
+Requires-Dist: genesis-gates>=0.3.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Description-Content-Type: text/markdown

{genesis_cli-0.2.0 → genesis_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "genesis-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Genesis Agent Workbench CLI — make any repo agent-ready and keep AI-generated changes governed."
 readme = "README.md"
 license = "Apache-2.0"
@@ -30,7 +30,7 @@ dependencies = [
     # Must stay a REAL version requirement: `[tool.uv.sources]` below is a
     # dev-only workspace override and is not written into published metadata,
     # so this is what `pip install genesis-cli` resolves against on PyPI.
-    "genesis-gates>=0.2.0",
+    "genesis-gates>=0.3.0",
     "pyyaml>=6.0",
     # `genesis runner` talks to a Genesis server over HTTP.
     "httpx>=0.27",

{genesis_cli-0.2.0 → genesis_cli-0.3.0}/src/genesis_cli/runner/claude_driver.py

@@ -6,6 +6,12 @@ Runs `claude -p <prompt> --output-format stream-json` as an argv subprocess
 (never a shell) with cwd = the task workspace. The child env is a pass-through
 of the login environment with ANTHROPIC_API_KEY explicitly UNSET so the CLI
 uses the user's subscription auth and never silently bills an API key.
+
+Planning completions (0.3.0) use the same CLI in ONE-SHOT print mode —
+`claude -p <prompt> --output-format json --system-prompt <system> --tools ""
+--no-session-persistence` — run in a private empty directory with all tools
+disabled: a pure text-in/text-out LLM call, parsed from the single result
+JSON object (any non-JSON wrapper noise stripped).
 """
 
 from __future__ import annotations
@@ -15,6 +21,7 @@ import json
 import os
 import shutil
 import subprocess
+import tempfile
 import time
 from collections.abc import Callable
 from pathlib import Path
@@ -60,6 +67,56 @@ def _assistant_text(evt: dict) -> str:
     )
 
 
+def _flatten_messages(messages: list[dict]) -> str:
+    """One-shot print mode takes a single prompt, so a conversation (e.g. the
+    server's schema-repair retry: user, assistant, user) is flattened with
+    role tags. A single user message passes through untagged."""
+    if len(messages) == 1 and messages[0].get("role") == "user":
+        return str(messages[0].get("content") or "")
+    parts = []
+    for m in messages:
+        role = str(m.get("role") or "user").upper()
+        parts.append(f"[{role}]\n{m.get('content') or ''}")
+    return "\n\n".join(parts)
+
+
+def _final_json_object(stdout: str) -> dict | None:
+    """The result object from `--output-format json` stdout, tolerating any
+    non-JSON wrapper lines (update notices, MOTD) before or after it."""
+    text = stdout.strip()
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, dict):
+            return obj
+    except json.JSONDecodeError:
+        pass
+    # Line-wise, last parseable object wins (the result is printed last).
+    for line in reversed(text.splitlines()):
+        line = line.strip()
+        if not (line.startswith("{") and line.endswith("}")):
+            continue
+        try:
+            obj = json.loads(line)
+            if isinstance(obj, dict):
+                return obj
+        except json.JSONDecodeError:
+            continue
+    # Last resort: scan for embedded objects; the last decodable one wins.
+    dec = json.JSONDecoder()
+    best: dict | None = None
+    i = text.find("{")
+    while i != -1:
+        try:
+            obj, end = dec.raw_decode(text, i)
+        except json.JSONDecodeError:
+            i = text.find("{", i + 1)
+            continue
+        if isinstance(obj, dict):
+            best = obj
+        i = text.find("{", end)
+    return best
+
+
 def check_cli() -> tuple[bool, str]:
     """Preflight: is a working `claude` CLI on PATH?"""
     if not shutil.which("claude"):
@@ -183,3 +240,80 @@ class ClaudeDriver:
         usage["duration_s"] = time.monotonic() - started
         return {"status": status, "session_id": session_id,
                 "usage": usage, "error": error}
+
+    async def run_completion(self, *, system: str | None, messages: list[dict],
+                             max_tokens: int = 4096,
+                             timeout_s: float = 150.0) -> dict:
+        """One planning completion (T-047): run `claude` in one-shot print
+        mode and return {status, text, usage, error}. Verified invocation:
+        `claude -p <prompt> --output-format json --system-prompt <system>
+        --tools "" --no-session-persistence` — a single result JSON object on
+        stdout whose `result` field is the model's text. Tools are disabled
+        and cwd is a throwaway empty directory: a pure LLM call, nothing on
+        this machine is read or written. The CLI exposes no max-tokens flag;
+        the server bounds output through the prompt contract instead.
+        """
+        del max_tokens  # accepted for wire-payload symmetry; see docstring
+        started = time.monotonic()
+        prompt = _flatten_messages(messages)
+        argv = [
+            "claude", "-p", prompt,
+            "--output-format", "json",
+            "--tools", "",
+            "--no-session-persistence",
+        ]
+        if system:
+            argv += ["--system-prompt", system]
+        if self.model:
+            argv += ["--model", self.model]
+
+        usage: dict = {"input_tokens": 0, "output_tokens": 0, "duration_s": None}
+        with tempfile.TemporaryDirectory(prefix="genesis-completion-") as empty:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    *argv,
+                    cwd=empty,
+                    env=self._child_env(),
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    limit=_STREAM_LIMIT,
+                )
+            except FileNotFoundError:
+                return {"status": "failed", "text": None, "usage": usage,
+                        "error": "claude CLI not found"}
+            self._proc = proc
+            try:
+                out_b, err_b = await asyncio.wait_for(proc.communicate(),
+                                                      timeout=timeout_s)
+            except TimeoutError:
+                proc.kill()
+                await proc.wait()
+                return {"status": "failed", "text": None, "usage": usage,
+                        "error": f"completion timed out after {timeout_s:.0f}s"}
+            except asyncio.CancelledError:
+                proc.kill()
+                raise
+            finally:
+                self._proc = None
+
+        usage["duration_s"] = time.monotonic() - started
+        if self.killed:
+            return {"status": "interrupted", "text": None, "usage": usage,
+                    "error": "completion aborted on the runner"}
+
+        evt = _final_json_object(out_b.decode("utf-8", "replace"))
+        if evt is None:
+            err = err_b.decode("utf-8", "replace")[:500]
+            return {"status": "failed", "text": None, "usage": usage,
+                    "error": err or f"claude exited {proc.returncode} "
+                                    "with no result JSON"}
+        u = evt.get("usage") or {}
+        usage["input_tokens"] = int(u.get("input_tokens") or 0)
+        usage["output_tokens"] = int(u.get("output_tokens") or 0)
+        text = evt.get("result")
+        if evt.get("is_error") or evt.get("subtype") != "success" \
+                or not isinstance(text, str):
+            return {"status": "failed", "text": None, "usage": usage,
+                    "error": str(evt.get("result") or "cli error")[:500]}
+        return {"status": "completed", "text": text, "usage": usage,
+                "error": None}

{genesis_cli-0.2.0 → genesis_cli-0.3.0}/src/genesis_cli/runner/client.py

@@ -15,6 +15,12 @@ import httpx
 _CLAIM_TIMEOUT = httpx.Timeout(10.0, read=60.0)
 _IO_TIMEOUT = httpx.Timeout(10.0, read=300.0)
 
+# What this client can serve, advertised on every claim (0.3.0+). 'completion'
+# = one-shot planning LLM calls through the local `claude` CLI, no workspace.
+# Additive wire change: an 0.2.0 server has no body on /claim and ignores it;
+# an 0.3.0 server hands completion items only to claims that advertise it.
+CAPABILITIES = ("completion",)
+
 
 class RunnerAuthError(RuntimeError):
     """The server rejected the runner token (bad, rotated, or revoked)."""
@@ -49,7 +55,10 @@ class RunnerClient:
 
     async def claim(self) -> dict | None:
         """One long-poll. None = no work this window (poll again)."""
-        resp = await self._client.post("/api/runner/claim", timeout=_CLAIM_TIMEOUT)
+        resp = await self._client.post(
+            "/api/runner/claim", json={"capabilities": list(CAPABILITIES)},
+            timeout=_CLAIM_TIMEOUT,
+        )
         self._check_auth(resp)
         if resp.status_code == 204:
             return None

{genesis_cli-0.2.0 → genesis_cli-0.3.0}/src/genesis_cli/runner/loop.py

@@ -101,6 +101,15 @@ def status() -> int:
         _say(f"Auth   : unreachable ({exc})")
         return 1
     _say(f"Auth   : {'ok' if auth_ok else 'REJECTED — reconnect with a fresh token'}")
+    # Planning routing: the capability is advertised on every claim; there is
+    # no cheap server query for the ack, so report the client side honestly.
+    from .client import CAPABILITIES
+
+    if "completion" in CAPABILITIES:
+        _say("Planning: this runner advertises 'completion' — while "
+             "`genesis runner start` is running, the server routes your "
+             "planning calls here (needs a 0.3.0+ server; older servers "
+             "ignore it and use builds only).")
     return 0 if (ok and auth_ok) else 1
 
 
@@ -165,13 +174,51 @@ async def _start(cfg: dict) -> int:
                 continue
             if item is None:
                 continue
-            await _run_item(client, item, stop)
+            if item.get("kind") == "completion":
+                await _run_completion_item(client, item, stop)
+            else:
+                await _run_item(client, item, stop)
     finally:
         await client.aclose()
     _say("Runner stopped.")
     return 0
 
 
+async def _run_completion_item(client: RunnerClient, item: dict,
+                               stop: _Stop) -> None:
+    """One planning completion (0.3.0): no workspace in either direction —
+    run the local `claude` in one-shot print mode and post the text back."""
+    item_id = str(item.get("item_id"))
+    task = item.get("task") or {}
+    _say(f"▶ planning call (item {item_id[:12]}…) — running claude one-shot")
+    driver = ClaudeDriver()
+    stop.driver = driver
+    try:
+        result = await driver.run_completion(
+            system=str(task.get("system") or "") or None,
+            messages=list(task.get("messages") or []),
+            max_tokens=int(task.get("max_tokens") or 4096),
+        )
+    except Exception as exc:  # noqa: BLE001 — report, never crash the loop
+        result = {"status": "failed", "text": None, "usage": {},
+                  "error": f"runner error: {exc}"[:500]}
+    finally:
+        stop.driver = None
+    payload = {
+        "status": result.get("status", "failed"),
+        "text": result.get("text"),
+        "session_id": None,
+        "error": result.get("error"),
+        "usage": result.get("usage") or {},
+        "deleted": [],
+    }
+    try:
+        await client.post_result(item_id, payload)
+        _say(f"✓ planning call: {payload['status']}")
+    except (httpx.HTTPError, RunnerAuthError) as exc:
+        _say(f"✗ planning call: result upload failed ({exc.__class__.__name__})")
+
+
 async def _run_item(client: RunnerClient, item: dict, stop: _Stop) -> None:
     item_id = str(item.get("item_id"))
     task = item.get("task") or {}

{genesis_cli-0.2.0 → genesis_cli-0.3.0}/src/genesis_cli/runner/runner_cmd.py

@@ -27,9 +27,9 @@ def _cmd_status(args: argparse.Namespace) -> int:
 def add_runner_parser(sub: argparse._SubParsersAction) -> None:
     runner = sub.add_parser(
         "runner",
-        help="execute your Genesis builds' coding-agent tasks on THIS machine "
-             "with your local claude CLI (subscription) — the server keeps "
-             "orchestration, validation, gates, and billing",
+        help="execute your Genesis builds' coding-agent tasks AND planning "
+             "calls on THIS machine with your local claude CLI (subscription) "
+             "— the server keeps orchestration, validation, gates, and billing",
     )
     rsub = runner.add_subparsers(dest="runner_command", required=True)
 

genesis_cli-0.3.0/tests/test_runner_completion.py

@@ -0,0 +1,167 @@
+"""Planning completions on the runner (0.3.0): one-shot `claude -p` driving
+against a fake CLI on PATH, capability advertisement on claim, and the loop's
+completion-item round trip. Offline only — nothing here talks to a network.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+import textwrap
+from pathlib import Path
+
+import httpx
+import pytest
+from genesis_cli.runner.claude_driver import ClaudeDriver, _final_json_object
+from genesis_cli.runner.client import CAPABILITIES, RunnerClient
+
+
+@pytest.fixture
+def fake_claude(tmp_path: Path, monkeypatch):
+    """Install a stub `claude` on PATH. One-shot print mode records its argv
+    and env to $T047_RECORD (cwd is a throwaway dir the driver deletes)."""
+
+    def install(body: str) -> Path:
+        bin_dir = tmp_path / "bin"
+        bin_dir.mkdir(exist_ok=True)
+        script = bin_dir / "claude"
+        script.write_text("#!/usr/bin/env python3\n" + textwrap.dedent(body))
+        script.chmod(script.stat().st_mode | stat.S_IEXEC)
+        monkeypatch.setenv("PATH", f"{bin_dir}{os.pathsep}{os.environ['PATH']}")
+        record = tmp_path / "record.json"
+        monkeypatch.setenv("T047_RECORD", str(record))
+        return record
+
+    return install
+
+
+ONESHOT_BODY = """
+import json, os, sys
+args = sys.argv[1:]
+open(os.environ["T047_RECORD"], "w").write(json.dumps(
+    {"argv": args, "has_api_key": "ANTHROPIC_API_KEY" in os.environ,
+     "cwd": os.getcwd()}))
+# Wrapper noise before the result object must not break parsing.
+print("Update available! run claude update")
+print(json.dumps({"type": "result", "subtype": "success", "is_error": False,
+                  "result": '{"name": "zed"}', "session_id": "sess-1",
+                  "total_cost_usd": 0,
+                  "usage": {"input_tokens": 42, "output_tokens": 7}}))
+"""
+
+
+async def test_run_completion_oneshot_flags_and_parse(fake_claude, monkeypatch):
+    record = fake_claude(ONESHOT_BODY)
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-ant-should-not-leak")
+    out = await ClaudeDriver().run_completion(
+        system="You are a planner.",
+        messages=[{"role": "user", "content": "make zed"}])
+    assert out["status"] == "completed"
+    assert out["text"] == '{"name": "zed"}'
+    assert out["usage"]["input_tokens"] == 42
+    assert out["usage"]["output_tokens"] == 7
+    assert out["usage"]["duration_s"] is not None
+
+    rec = json.loads(record.read_text())
+    argv = rec["argv"]
+    # The verified one-shot invocation, exactly: print mode, single JSON
+    # result, no tools, no persisted session, explicit system prompt.
+    assert argv[:2] == ["-p", "make zed"]
+    assert argv[2:4] == ["--output-format", "json"]
+    assert argv[4:6] == ["--tools", ""]
+    assert argv[6] == "--no-session-persistence"
+    assert argv[7:9] == ["--system-prompt", "You are a planner."]
+    # Subscription hygiene + isolation: no API key, throwaway empty cwd.
+    assert rec["has_api_key"] is False
+    assert "genesis-completion-" in rec["cwd"]
+    assert not Path(rec["cwd"]).exists()  # cleaned up after the call
+
+
+async def test_run_completion_flattens_multi_turn(fake_claude):
+    record = fake_claude(ONESHOT_BODY)
+    await ClaudeDriver().run_completion(
+        system=None,
+        messages=[{"role": "user", "content": "go"},
+                  {"role": "assistant", "content": "{bad"},
+                  {"role": "user", "content": "fix it"}])
+    argv = json.loads(record.read_text())["argv"]
+    prompt = argv[1]
+    assert "[USER]\ngo" in prompt and "[ASSISTANT]\n{bad" in prompt
+    assert "--system-prompt" not in argv
+
+
+async def test_run_completion_error_result(fake_claude):
+    fake_claude("""
+import json
+print(json.dumps({"type": "result", "subtype": "success", "is_error": True,
+                  "result": "Not logged in", "usage": {}}))
+""")
+    out = await ClaudeDriver().run_completion(
+        system=None, messages=[{"role": "user", "content": "go"}])
+    assert out["status"] == "failed"
+    assert "Not logged in" in out["error"]
+
+
+async def test_run_completion_no_json_is_failed(fake_claude):
+    fake_claude("""
+import sys
+print("something went sideways")
+sys.exit(3)
+""")
+    out = await ClaudeDriver().run_completion(
+        system=None, messages=[{"role": "user", "content": "go"}])
+    assert out["status"] == "failed" and out["text"] is None
+
+
+def test_final_json_object_strips_wrappers():
+    noise = 'MOTD banner\n{"type": "result", "result": "ok"}\ntrailing text'
+    assert _final_json_object(noise)["result"] == "ok"
+    assert _final_json_object("no json here") is None
+    # Embedded (non-line-aligned) object still found; the last one wins.
+    assert _final_json_object('x {"a": 1} y {"b": 2} z') == {"b": 2}
+
+
+async def test_claim_advertises_capabilities(monkeypatch):
+    assert "completion" in CAPABILITIES
+    client = RunnerClient("http://test", "grt_x")
+    captured: dict = {}
+
+    async def fake_post(url, **kw):
+        captured["url"] = url
+        captured["json"] = kw.get("json")
+        return httpx.Response(204, request=httpx.Request("POST", f"http://test{url}"))
+
+    monkeypatch.setattr(client._client, "post", fake_post)
+    try:
+        assert await client.claim() is None
+    finally:
+        await client.aclose()
+    assert captured["url"] == "/api/runner/claim"
+    assert captured["json"] == {"capabilities": ["completion"]}
+
+
+async def test_loop_runs_completion_item_and_posts_text(fake_claude):
+    from genesis_cli.runner.loop import _run_completion_item, _Stop
+
+    fake_claude(ONESHOT_BODY)
+
+    class _FakeClient:
+        def __init__(self):
+            self.results: list[tuple[str, dict]] = []
+
+        async def post_result(self, item_id, payload, tar_path=None):
+            assert tar_path is None  # completions never upload an archive
+            self.results.append((item_id, payload))
+
+    client = _FakeClient()
+    await _run_completion_item(client, {
+        "item_id": "item-1", "kind": "completion",
+        "task": {"system": "sys", "max_tokens": 128,
+                 "messages": [{"role": "user", "content": "make zed"}]},
+    }, _Stop())
+    (item_id, payload), = client.results
+    assert item_id == "item-1"
+    assert payload["status"] == "completed"
+    assert payload["text"] == '{"name": "zed"}'
+    assert payload["deleted"] == [] and payload["session_id"] is None