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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: genesis-cli
-Version: 0.1.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,8 @@ 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.1.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.1.0 → genesis_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "genesis-cli"
-version = "0.1.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,8 +30,10 @@ 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.1.0",
+    "genesis-gates>=0.3.0",
     "pyyaml>=6.0",
+    # `genesis runner` talks to a Genesis server over HTTP.
+    "httpx>=0.27",
 ]
 
 [project.urls]

{genesis_cli-0.1.0 → genesis_cli-0.3.0}/src/genesis_cli/adopt.py

@@ -17,6 +17,7 @@ import genesis_gates.providers  # noqa: F401
 from genesis_gates import GateContext, GateRunner, get_gate, load_gate_config
 from genesis_gates.analysis import (
     analyze,
+    declared_env_vars,
     reconcile,
     repo_input,
     score_readiness,
@@ -56,7 +57,13 @@ def run_audit(repo: Path) -> dict:
     repo = repo.resolve()
     gate_results = run_gates(repo).get("gate_results", [])
     completeness = analyze(repo_input(repo))
-    reconciliation = reconcile(repo, stored_deps={})
+    # A brownfield audit has no stored dependency map, so the repo's own
+    # `.env.example`-family files ARE its declared config contract. Passing
+    # them makes env_hygiene measure "are env vars declared?"; with an empty
+    # map, every compose `${VAR}` without a default counted as an undeclared
+    # gap even when the repo documents it properly, which pinned the category
+    # near zero for any repo with an undefaulted compose reference.
+    reconciliation = reconcile(repo, stored_deps=declared_env_vars(repo))
     facts = structure_facts(repo)
     readiness = score_readiness(
         gate_results=gate_results, facts=facts,

{genesis_cli-0.1.0 → genesis_cli-0.3.0}/src/genesis_cli/init.py

@@ -104,6 +104,13 @@ kind: GateConfig
 #   dependency-scan:
 #     provider: trivy
 #     fail_on_severity: critical
+#     # Trees this repo does not author and is not accountable for: vendored
+#     # dependencies, generated output, packaged sample apps that are scanned
+#     # in their own right. Repo-relative, anchored at the root ("vendor" does
+#     # not match "packages/x/vendor"). This is SCOPE, not suppression — a
+#     # skipped directory is invisible to the gate, so justify each entry in a
+#     # comment and keep your own source, infra and CI in scope.
+#     skip_dirs: [vendor, third_party/generated]
 #   unit-tests:
 #     provider: command
 #     command: "npm test"

{genesis_cli-0.1.0 → genesis_cli-0.3.0}/src/genesis_cli/main.py

@@ -9,6 +9,12 @@ Commands:
   genesis init [path]    Scaffold a new/bare repo so agents start agent-ready:
                          AGENTS.md, .gitignore, .env.example, audit workflow,
                          gate config. Idempotent — never overwrites.
+  genesis runner …       Local runner for the Genesis platform: `connect` pairs
+                         this machine with a server (runner token), `start`
+                         executes your builds' coding-agent tasks here through
+                         your own `claude` CLI (your subscription), `status`
+                         shows the connection. The server keeps orchestration,
+                         validation, gates, evidence, and billing.
   genesis --version      Print the installed genesis-cli version.
 """
 
@@ -220,6 +226,11 @@ def main(argv: list[str] | None = None) -> int:
                       help="directory to scaffold (default: .; created if missing)")
     init.set_defaults(func=_cmd_init)
 
+    # Local runner (deferred imports: the subcommands import httpx lazily).
+    from .runner.runner_cmd import add_runner_parser
+
+    add_runner_parser(sub)
+
     args = parser.parse_args(argv)
     return args.func(args)
 

genesis_cli-0.3.0/src/genesis_cli/runner/__init__.py

@@ -0,0 +1,11 @@
+"""`genesis runner` — execute your Genesis coding-agent tasks locally.
+
+Connect this machine to a Genesis server with a runner token and your builds'
+agent tasks run HERE, through your own local `claude` CLI (your subscription)
+— while the server keeps all orchestration, validation, repair policy,
+commits, gates, evidence, and billing.
+
+Public package rule: this code never imports genesis_server or
+genesis_executor; the wire protocol (claim / workspace / events / result)
+is its only contract with the server.
+"""

genesis_cli-0.3.0/src/genesis_cli/runner/claude_driver.py

@@ -0,0 +1,319 @@
+"""Headless `claude` driver — the public runner-side reimplementation of the
+platform's stream-json adapter (same argv, same parsing, no shared code: this
+package never imports the commercial packages).
+
+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
+
+import asyncio
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+# stream-json emits one JSON object per line; a single line (a large tool
+# result or a long assistant turn) routinely exceeds asyncio's default 64 KB
+# StreamReader line cap, which would raise LimitOverrunError mid-task. We read
+# raw chunks and split on newlines ourselves (no per-line cap), and raise the
+# subprocess buffer limit so the transport isn't paused every 64 KB.
+_STREAM_LIMIT = 64 * 1024 * 1024  # 64 MB StreamReader buffer
+_READ_CHUNK = 256 * 1024  # 256 KB per read
+
+
+async def _iter_json_lines(stream: asyncio.StreamReader):
+    """Yield complete decoded lines via chunked reads — an oversized line can
+    never raise asyncio.LimitOverrunError."""
+    buf = bytearray()
+    while True:
+        chunk = await stream.read(_READ_CHUNK)
+        if not chunk:
+            break
+        buf.extend(chunk)
+        while True:
+            nl = buf.find(b"\n")
+            if nl == -1:
+                break
+            line = bytes(buf[:nl])
+            del buf[: nl + 1]
+            yield line
+    if buf:
+        yield bytes(buf)
+
+
+def _assistant_text(evt: dict) -> str:
+    msg = evt.get("message") or {}
+    parts = msg.get("content") or []
+    if isinstance(parts, str):
+        return parts
+    return "".join(
+        p.get("text", "")
+        for p in parts
+        if isinstance(p, dict) and p.get("type") == "text"
+    )
+
+
+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"):
+        return False, (
+            "The `claude` CLI is not on PATH. Install Claude Code "
+            "(https://claude.com/claude-code) and sign in with your "
+            "subscription, then run `genesis runner start` again."
+        )
+    try:
+        proc = subprocess.run(["claude", "--version"], capture_output=True,
+                              text=True, timeout=30)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return False, f"`claude --version` failed to run: {exc}"
+    if proc.returncode != 0:
+        return False, (f"`claude --version` exited {proc.returncode}: "
+                       f"{(proc.stderr or proc.stdout)[:200]}")
+    return True, (proc.stdout or "").strip()
+
+
+class ClaudeDriver:
+    """One task = one run(). kill() aborts the live subprocess (server-side
+    cancel or a second Ctrl-C)."""
+
+    def __init__(self, model: str | None = None):
+        self.model = model
+        self._proc: asyncio.subprocess.Process | None = None
+        self.killed = False
+
+    def kill(self) -> None:
+        self.killed = True
+        if self._proc is not None and self._proc.returncode is None:
+            self._proc.kill()
+
+    def _child_env(self) -> dict:
+        env = dict(os.environ)
+        # Force subscription auth: never let an API key take over accidentally.
+        env.pop("ANTHROPIC_API_KEY", None)
+        return env
+
+    async def run(self, prompt: str, *, workdir: Path,
+                  resume_session: str | None = None,
+                  on_text: Callable[[str], None] | None = None) -> dict:
+        """Run one task; returns {status, session_id, usage, error} parsed
+        from the CLI's final result message."""
+        started = time.monotonic()
+        argv = [
+            "claude", "-p", prompt,
+            "--output-format", "stream-json",
+            "--verbose",
+            "--add-dir", str(workdir),
+            "--permission-mode", "acceptEdits",
+        ]
+        if self.model:
+            argv += ["--model", self.model]
+        if resume_session:
+            argv += ["--resume", resume_session]
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *argv,
+                cwd=str(workdir),
+                env=self._child_env(),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                limit=_STREAM_LIMIT,
+            )
+        except FileNotFoundError:
+            return {"status": "failed", "session_id": None,
+                    "usage": {}, "error": "claude CLI not found"}
+        self._proc = proc
+
+        usage: dict = {"input_tokens": 0, "output_tokens": 0, "cost_usd": None,
+                       "estimated": False, "duration_s": None}
+        session_id: str | None = None
+        status = "failed"
+        error: str | None = None
+
+        assert proc.stdout is not None
+        try:
+            async for raw in _iter_json_lines(proc.stdout):
+                line = raw.decode("utf-8", "replace").strip()
+                if not line:
+                    continue
+                try:
+                    evt = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                etype = evt.get("type")
+                if evt.get("session_id"):
+                    session_id = evt["session_id"]
+                if etype == "assistant":
+                    text = _assistant_text(evt)
+                    if text and on_text is not None:
+                        on_text(text)
+                elif etype == "result":
+                    if evt.get("total_cost_usd") is not None:
+                        usage["cost_usd"] = float(evt["total_cost_usd"])
+                    u = evt.get("usage") or {}
+                    usage["input_tokens"] = int(u.get("input_tokens", 0))
+                    usage["output_tokens"] = int(u.get("output_tokens", 0))
+                    status = "completed" if evt.get("subtype") == "success" else "failed"
+                    if evt.get("is_error"):
+                        error = str(evt.get("result", "cli error"))[:500]
+            await proc.wait()
+        except asyncio.CancelledError:
+            proc.kill()
+            raise
+        finally:
+            self._proc = None
+
+        if self.killed:
+            status = "interrupted"
+            error = error or "task aborted on the runner"
+        elif proc.returncode not in (0, None) and status != "completed":
+            status = "failed"
+            if error is None:
+                err = (await proc.stderr.read()).decode("utf-8", "replace") \
+                    if proc.stderr else ""
+                error = err[:500] or f"claude exited {proc.returncode}"
+
+        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.3.0/src/genesis_cli/runner/client.py

@@ -0,0 +1,111 @@
+"""HTTP client for the Genesis runner gateway.
+
+One rule above all: the token is a credential — it goes into the
+Authorization header and NOWHERE else (never a log line, never an error
+message, never a URL).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import httpx
+
+# The server long-polls a claim for ~25s; read must comfortably outlast that.
+_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)."""
+
+
+class RunnerClient:
+    def __init__(self, server: str, token: str):
+        self._client = httpx.AsyncClient(
+            base_url=server.rstrip("/"),
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=_IO_TIMEOUT,
+        )
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    @staticmethod
+    def _check_auth(resp: httpx.Response) -> None:
+        if resp.status_code == 401:
+            raise RunnerAuthError(
+                "The server rejected this runner's token — it may have been "
+                "rotated or revoked. Run `genesis runner connect` again."
+            )
+
+    async def probe(self) -> bool:
+        """Side-effect-free auth check: a nonexistent work item reads 404 with
+        a valid token, 401 with a bad one (and never claims real work)."""
+        resp = await self._client.get("/api/runner/work/probe/workspace")
+        if resp.status_code == 401:
+            return False
+        return resp.status_code == 404
+
+    async def claim(self) -> dict | None:
+        """One long-poll. None = no work this window (poll again)."""
+        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
+        resp.raise_for_status()
+        data = resp.json()
+        return data if isinstance(data, dict) and data.get("item_id") else None
+
+    async def download_workspace(self, item_id: str, dest: Path) -> Path:
+        """Stream the task workspace archive to dest (tar.gz)."""
+        async with self._client.stream(
+            "GET", f"/api/runner/work/{item_id}/workspace", timeout=_IO_TIMEOUT
+        ) as resp:
+            self._check_auth(resp)
+            resp.raise_for_status()
+            with dest.open("wb") as f:
+                async for chunk in resp.aiter_bytes():
+                    f.write(chunk)
+        return dest
+
+    async def post_events(self, item_id: str, events: list[dict]) -> bool:
+        """Forward an event batch; the reply carries the cancel signal."""
+        resp = await self._client.post(
+            f"/api/runner/work/{item_id}/events", json={"events": events}
+        )
+        self._check_auth(resp)
+        resp.raise_for_status()
+        try:
+            return bool(resp.json().get("cancelled"))
+        except ValueError:
+            return False
+
+    async def post_result(self, item_id: str, result: dict,
+                          tar_path: Path | None = None) -> None:
+        """Upload the task outcome (+ the changed-files archive when any)."""
+        import json
+
+        data = {"result": json.dumps(result)}
+        if tar_path is not None:
+            with tar_path.open("rb") as f:
+                resp = await self._client.post(
+                    f"/api/runner/work/{item_id}/result", data=data,
+                    files={"files": ("files.tar.gz", f, "application/gzip")},
+                    timeout=_IO_TIMEOUT,
+                )
+        else:
+            resp = await self._client.post(
+                f"/api/runner/work/{item_id}/result", data=data, timeout=_IO_TIMEOUT
+            )
+        self._check_auth(resp)
+        resp.raise_for_status()

genesis_cli-0.3.0/src/genesis_cli/runner/config.py

@@ -0,0 +1,62 @@
+"""Runner configuration: ~/.genesis/runner.toml, mode 0600.
+
+The file holds the server URL, the runner token (a credential — hence the
+restrictive mode and the minimal writer that never round-trips through a
+general serializer), and this machine's runner name.
+"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+
+_FIELDS = ("server", "token", "name")
+
+
+def config_dir() -> Path:
+    return Path(os.environ.get("GENESIS_RUNNER_HOME", str(Path.home() / ".genesis")))
+
+
+def config_path() -> Path:
+    return config_dir() / "runner.toml"
+
+
+def work_root() -> Path:
+    """Where claimed task workspaces are materialized (and cleaned up)."""
+    root = config_dir() / "runner-work"
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def load_config() -> dict:
+    path = config_path()
+    if not path.exists():
+        return {}
+    try:
+        data = tomllib.loads(path.read_text())
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+    return {k: v for k, v in data.items() if k in _FIELDS and isinstance(v, str)}
+
+
+def _toml_str(value: str) -> str:
+    # Minimal TOML basic-string escaping: backslash and double quote.
+    return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def save_config(server: str, token: str, name: str) -> Path:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    body = (
+        "# genesis runner credentials — created by `genesis runner connect`\n"
+        f"server = {_toml_str(server)}\n"
+        f"token = {_toml_str(token)}\n"
+        f"name = {_toml_str(name)}\n"
+    )
+    # Create 0600 BEFORE writing the secret (never a world-readable window).
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as f:
+        f.write(body)
+    os.chmod(path, 0o600)
+    return path