kaizen-loop 0.1.0__py3-none-any.whl

kaizen/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

kaizen/__main__.py

@@ -0,0 +1,4 @@
+from kaizen.cli import main
+
+if __name__ == "__main__":
+    main()

kaizen/agent.py

@@ -0,0 +1,349 @@
+import http.client
+import json
+import os
+import signal
+import socket
+import subprocess
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from urllib.parse import quote, urlparse
+
+_RETRYABLE_STATUS = frozenset({502, 503, 504})
+_MAX_RETRIES = 2
+_RETRY_BASE_DELAY = 0.5
+
+
+def _validate_server_url(url: str | None) -> None:
+    if url is None:
+        return
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https"):
+        raise ValueError(
+            f"Invalid server URL: {url!r}. Must start with http:// or https://"
+        )
+    if not parsed.hostname:
+        raise ValueError(f"Invalid server URL: {url!r}. No hostname found.")
+
+
+@dataclass
+class AgentResult:
+    output: dict
+    text: str = ""
+    input_tokens: int = 0
+    output_tokens: int = 0
+
+
+class _Session:
+    def __init__(self, agent: "OpenCodeAgent", session_id: str):
+        self._agent = agent
+        self._id = session_id
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    def send(self, prompt: str, schema: dict | None = None) -> AgentResult:
+        try:
+            return self._agent._send_message(self._id, prompt, schema)
+        except Exception:
+            self._agent._abort_session(self._id)
+            raise
+
+
+class OpenCodeAgent:
+    def __init__(self, bin_path: str = "opencode", server_url: str | None = None):
+        _validate_server_url(server_url)
+        self.bin_path = bin_path
+        self._external_server = server_url
+        self._process: subprocess.Popen | None = None
+        self._base_url: str | None = server_url
+        self._port: int | None = None
+        self._conn: http.client.HTTPConnection | None = None
+
+    def _get_conn(self) -> http.client.HTTPConnection:
+        if self._conn is not None:
+            return self._conn
+        url = self._base_url
+        if not url:
+            raise RuntimeError("No server URL configured")
+        parsed = urlparse(url)
+        self._conn = http.client.HTTPConnection(
+            parsed.hostname or "127.0.0.1",
+            parsed.port or 80,
+            timeout=300,
+        )
+        return self._conn
+
+    def _reconnect(self) -> http.client.HTTPConnection:
+        self._close_conn()
+        return self._get_conn()
+
+    def _close_conn(self) -> None:
+        if self._conn:
+            try:
+                self._conn.close()
+            except Exception:
+                pass
+            self._conn = None
+
+    def _http_request(
+        self,
+        method: str,
+        path: str,
+        body: dict | None = None,
+        timeout: float | None = None,
+        max_retries: int = _MAX_RETRIES,
+    ) -> dict:
+        conn = self._get_conn()
+        if timeout is not None:
+            conn.timeout = timeout
+        headers = {"Accept": "application/json"}
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode()
+            headers["Content-Type"] = "application/json"
+
+        last_err: Exception | None = None
+        for attempt in range(max_retries + 1):
+            try:
+                conn.request(method, path, body=data, headers=headers)
+                resp = conn.getresponse()
+                resp_data = resp.read()
+                if 200 <= resp.status < 300:
+                    return json.loads(resp_data)
+                if resp.status in _RETRYABLE_STATUS and attempt < max_retries:
+                    last_err = RuntimeError(f"HTTP {resp.status}")
+                    time.sleep(_RETRY_BASE_DELAY * (2**attempt))
+                    conn = self._reconnect()
+                    continue
+                raise RuntimeError(
+                    f"HTTP {resp.status}: {resp_data.decode(errors='replace')}"
+                )
+            except (
+                ConnectionError,
+                OSError,
+                http.client.HTTPException,
+            ) as e:
+                if attempt < max_retries:
+                    last_err = e
+                    time.sleep(_RETRY_BASE_DELAY * (2**attempt))
+                    conn = self._reconnect()
+                    continue
+                raise RuntimeError(
+                    f"Request failed after {max_retries} retries: {e}"
+                ) from e
+        raise last_err  # type: ignore[misc]
+
+    def _request(
+        self,
+        path: str,
+        method: str = "GET",
+        body: dict | None = None,
+        timeout: float = 300,
+    ) -> dict:
+        return self._http_request(method, path, body=body, timeout=timeout)
+
+    def _ensure_server(self, server_cwd: str) -> None:
+        if self._base_url:
+            self._check_external_server()
+            return
+
+        self._port = _get_free_port()
+        env = {**os.environ}
+        env.pop("OPENCODE_SERVER_USERNAME", None)
+        env.pop("OPENCODE_SERVER_PASSWORD", None)
+
+        self._process = subprocess.Popen(
+            [
+                self.bin_path,
+                "serve",
+                "--hostname",
+                "127.0.0.1",
+                "--port",
+                str(self._port),
+                "--print-logs",
+            ],
+            cwd=server_cwd,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env,
+            start_new_session=True,
+        )
+        self._base_url = f"http://127.0.0.1:{self._port}"
+        self._wait_healthy(timeout=30)
+
+    def _check_external_server(self) -> None:
+        url = self._base_url
+        if not url:
+            raise RuntimeError("No server URL configured")
+        try:
+            self._http_request(
+                "GET", "/global/health", timeout=5, max_retries=1
+            )
+        except (
+            RuntimeError,
+            ConnectionError,
+            OSError,
+            http.client.HTTPException,
+        ) as e:
+            port = url.split(":")[-1].rstrip("/")
+            raise RuntimeError(
+                f"Shared server at {url} is not reachable. "
+                f"Start it with: opencode serve --hostname 127.0.0.1 --port {port}  |  Error: {e}"
+            )
+
+    def _wait_healthy(self, timeout: float = 30) -> None:
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if self._process and self._process.poll() is not None:
+                raise RuntimeError("opencode server exited during startup")
+            try:
+                conn = self._reconnect()
+                conn.timeout = 2
+                conn.request("GET", "/global/health")
+                resp = conn.getresponse()
+                resp.read()
+                if resp.status == 200:
+                    return
+            except (ConnectionError, OSError, http.client.HTTPException):
+                pass
+            time.sleep(0.25)
+        raise RuntimeError(
+            f"opencode server did not become healthy on port {self._port}"
+        )
+
+    def _create_session(self, session_dir: str) -> str:
+        resp = self._request(
+            f"/session?directory={quote(session_dir, safe='')}",
+            method="POST",
+            body={},
+            timeout=10,
+        )
+        return resp.get("id", "")
+
+    @contextmanager
+    def session(self, work_dir: str, repo_dir: str | None = None):
+        server_cwd = repo_dir or work_dir
+        self._ensure_server(server_cwd)
+        session_id = self._create_session(work_dir)
+        try:
+            yield _Session(self, session_id)
+        finally:
+            self._delete_session(session_id)
+
+    def run(
+        self,
+        prompt: str,
+        work_dir: str,
+        schema: dict | None = None,
+        repo_dir: str | None = None,
+    ) -> AgentResult:
+        server_cwd = repo_dir or work_dir
+        self._ensure_server(server_cwd)
+        session_id = self._create_session(work_dir)
+        try:
+            return self._send_message(session_id, prompt, schema)
+        except Exception:
+            self._abort_session(session_id)
+            raise
+        finally:
+            self._delete_session(session_id)
+
+    def _send_message(
+        self, session_id: str, prompt: str, schema: dict | None = None
+    ) -> AgentResult:
+        body: dict = {
+            "role": "user",
+            "parts": [{"type": "text", "text": prompt}],
+        }
+        if schema:
+            body["format"] = {
+                "type": "json_schema",
+                "schema": schema,
+                "retryCount": 1,
+            }
+        result = self._request(
+            f"/session/{session_id}/message",
+            method="POST",
+            body=body,
+            timeout=600,
+        )
+
+        info = result.get("info", {})
+        structured = info.get("structured")
+        tokens = info.get("tokens", {})
+
+        if structured:
+            return AgentResult(
+                output=structured,
+                input_tokens=tokens.get("input", 0),
+                output_tokens=tokens.get("output", 0),
+            )
+
+        text = ""
+        for part in result.get("parts", []):
+            if part.get("type") == "text" and part.get("text"):
+                text = part["text"]
+
+        if not text:
+            raise RuntimeError("No structured output or text in agent response")
+
+        raise RuntimeError(f"Agent returned unstructured text: {text[:200]}")
+
+    def _abort_session(self, session_id: str) -> None:
+        try:
+            self._request(
+                f"/session/{session_id}/abort", method="POST", timeout=3
+            )
+        except Exception:
+            pass
+
+    def _delete_session(self, session_id: str) -> None:
+        try:
+            self._request(
+                f"/session/{session_id}", method="DELETE", timeout=3
+            )
+        except Exception:
+            pass
+
+    def close(self) -> None:
+        if self._external_server:
+            self._close_conn()
+            return
+        if self._base_url:
+            try:
+                self._http_request(
+                    "POST", "/instance/dispose", timeout=5, max_retries=0
+                )
+            except Exception:
+                pass
+        self._close_conn()
+        if self._process and self._process.poll() is None:
+            try:
+                self._process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                try:
+                    os.killpg(os.getpgid(self._process.pid), signal.SIGTERM)
+                except OSError:
+                    self._process.terminate()
+                try:
+                    self._process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    try:
+                        os.killpg(
+                            os.getpgid(self._process.pid), signal.SIGKILL
+                        )
+                    except OSError:
+                        self._process.kill()
+                    self._process.wait(timeout=2)
+        self._process = None
+        self._base_url = None
+        self._port = None
+
+
+def _get_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]

kaizen/cli.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import argparse
+import signal
+import sys
+
+from kaizen import __version__
+from kaizen.agent import OpenCodeAgent
+from kaizen.config import load_config
+from kaizen.git import is_git_repo
+
+
+def cmd_loop(args: argparse.Namespace) -> None:
+    cwd = args.directory or args.cwd
+    if not is_git_repo(cwd):
+        print("Error: not a git repo", file=sys.stderr)
+        sys.exit(1)
+
+    if not args.prompt:
+        print("Error: prompt required", file=sys.stderr)
+        sys.exit(1)
+
+    config = load_config()
+    opencode_bin = args.opencode_bin or config.get("opencode_bin", "opencode")
+    use_worktree = not args.no_worktree
+    server_url = args.server_url or config.get("server_url")
+
+    agent = OpenCodeAgent(bin_path=opencode_bin, server_url=server_url)
+
+    force_exit = False
+
+    def handle_sigint(sig, frame):
+        nonlocal force_exit
+        if force_exit:
+            print("\n  force stop")
+            agent.close()
+            sys.exit(130)
+        force_exit = True
+        print("\n  stopping... (Ctrl+C again to force)")
+
+    signal.signal(signal.SIGINT, handle_sigint)
+    signal.signal(signal.SIGTERM, lambda s, f: sys.exit(0))
+
+    try:
+        from kaizen.loop import run_loop
+
+        result = run_loop(
+            prompt=args.prompt,
+            cwd=cwd,
+            agent=agent,
+            max_work_iterations=args.max_iterations,
+            max_review_rounds=args.max_review_rounds or config.get("max_review_rounds", 3),
+            use_worktree=use_worktree,
+        )
+
+        if result == "passed":
+            print("\n  kaizen loop passed")
+        elif result == "cancelled":
+            print("\n  kaizen loop cancelled")
+            sys.exit(1)
+        else:
+            print("\n  kaizen loop failed")
+            sys.exit(1)
+    except Exception as e:
+        print(f"\n  fatal: {e}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        agent.close()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="kaizen",
+        description="Continuous code improvement: work → review → fix → ship",
+    )
+    parser.add_argument("--version", action="version", version=f"kaizen {__version__}")
+    parser.add_argument("--directory", "-C", help="Path to git repo (default: current dir)")
+
+    parser.add_argument("prompt", nargs="?", help="What the agent should do")
+    parser.add_argument("--max-iterations", type=int, help="Max work iterations")
+    parser.add_argument("--max-review-rounds", type=int, help="Max review rounds")
+    parser.add_argument("--no-worktree", action="store_true", help="Work in current tree instead of worktree")
+    parser.add_argument("--opencode-bin", help="Path to opencode binary")
+    parser.add_argument("--server-url", help="URL of an existing opencode serve instance (e.g. http://127.0.0.1:4096)")
+
+    args = parser.parse_args()
+    args.cwd = args.directory or ""
+
+    if args.prompt:
+        cmd_loop(args)
+    else:
+        parser.print_help()

kaizen/config.py

@@ -0,0 +1,31 @@
+import json
+import os
+from pathlib import Path
+
+
+DEFAULT_CONFIG = {
+    "max_work_iterations": None,
+    "max_review_rounds": 3,
+    "max_consecutive_failures": 3,
+    "opencode_bin": "opencode",
+    "use_worktree": True,
+    "server_url": None,
+}
+
+
+def config_path() -> str:
+    return os.path.expanduser("~/.kaizen/config.json")
+
+
+def load_config() -> dict:
+    path = config_path()
+    if os.path.exists(path):
+        try:
+            with open(path) as f:
+                cfg = json.load(f)
+            return {**DEFAULT_CONFIG, **cfg}
+        except (json.JSONDecodeError, OSError):
+            pass
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    Path(path).write_text(json.dumps(DEFAULT_CONFIG, indent=2) + "\n")
+    return {**DEFAULT_CONFIG}

kaizen/findings.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+
+ACTION_NOOP = "no-op"
+ACTION_AUTO_FIX = "auto-fix"
+
+SEVERITY_INFO = "info"
+SEVERITY_WARNING = "warning"
+SEVERITY_ERROR = "error"
+
+
+@dataclass
+class Finding:
+    id: str
+    severity: str
+    file: str = ""
+    line: int = 0
+    description: str = ""
+    action: str = ACTION_NOOP
+
+
+@dataclass
+class FindingsResult:
+    items: list[Finding] = field(default_factory=list)
+    summary: str = ""
+    risk_level: str = "low"
+    risk_rationale: str = ""
+
+    @property
+    def has_auto_fix(self) -> bool:
+        return any(f.action == ACTION_AUTO_FIX for f in self.items)
+
+    @property
+    def auto_fix_items(self) -> list[Finding]:
+        return [f for f in self.items if f.action == ACTION_AUTO_FIX]
+
+
+def parse_findings(data: dict) -> FindingsResult:
+    items = []
+    for i, f in enumerate(data.get("findings", [])):
+        items.append(Finding(
+            id=f.get("id", f"f{i + 1}"),
+            severity=f.get("severity", SEVERITY_INFO),
+            file=f.get("file", ""),
+            line=f.get("line", 0),
+            description=f.get("description", ""),
+            action=f.get("action", ACTION_NOOP),
+        ))
+    return FindingsResult(
+        items=items,
+        summary=data.get("summary", ""),
+        risk_level=data.get("risk_level", "low"),
+        risk_rationale=data.get("risk_rationale", ""),
+    )