kaizen-loop 0.1.0__py3-none-any.whl

kaizen/git.py

@@ -0,0 +1,208 @@
+import os
+import re
+import subprocess
+
+
+def _git(args: list[str], cwd: str) -> str:
+    result = subprocess.run(
+        ["git"] + args,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        env={**os.environ, "GIT_TERMINAL_PROMPT": "0"},
+    )
+    if result.returncode != 0:
+        parts = [result.stderr.strip(), result.stdout.strip()]
+        raise RuntimeError(" | ".join(p for p in parts if p))
+    return result.stdout.strip()
+
+
+def is_git_repo(cwd: str) -> bool:
+    try:
+        _git(["rev-parse", "--git-dir"], cwd)
+        return True
+    except RuntimeError:
+        return False
+
+
+def git_root(cwd: str) -> str:
+    return _git(["rev-parse", "--show-toplevel"], cwd)
+
+
+def current_branch(cwd: str) -> str:
+    try:
+        return _git(["symbolic-ref", "--short", "HEAD"], cwd)
+    except RuntimeError:
+        return _git(["rev-parse", "--abbrev-ref", "HEAD"], cwd)
+
+
+def head_commit(cwd: str) -> str:
+    return _git(["rev-parse", "HEAD"], cwd)
+
+
+def ensure_clean_tree(cwd: str) -> None:
+    status = _git(["status", "--porcelain"], cwd)
+    if status:
+        raise RuntimeError("Working tree is not clean. Commit or stash changes first.")
+
+
+def get_default_branch(cwd: str) -> str:
+    try:
+        ref = _git(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd)
+        return ref.split("/")[-1]
+    except RuntimeError:
+        try:
+            refs = _git(["branch", "-r"], cwd)
+            for line in refs.splitlines():
+                line = line.strip()
+                if line == "origin/main":
+                    return "main"
+                if line == "origin/master":
+                    return "master"
+        except RuntimeError:
+            pass
+    return "main"
+
+
+def resolve_ref(cwd: str, ref: str) -> str:
+    return _git(["rev-parse", ref], cwd)
+
+
+def get_diff(base: str, head: str, cwd: str) -> str:
+    return _git(["diff", f"{base}..{head}"], cwd)
+
+
+def fetch(cwd: str, remote: str = "origin") -> None:
+    _git(["fetch", remote], cwd)
+
+
+def create_branch(name: str, cwd: str) -> None:
+    _git(["checkout", "-b", name], cwd)
+
+
+def checkout(branch: str, cwd: str) -> None:
+    _git(["checkout", branch], cwd)
+
+
+def branch_exists(cwd: str, branch: str) -> bool:
+    try:
+        _git(["rev-parse", "--verify", branch], cwd)
+        return True
+    except RuntimeError:
+        return False
+
+
+def delete_branch(branch: str, cwd: str) -> None:
+    try:
+        _git(["branch", "-D", branch], cwd)
+    except RuntimeError:
+        pass
+
+
+def commit_all(message: str, cwd: str) -> None:
+    _git(["add", "-A"], cwd)
+    diff = subprocess.run(
+        ["git", "diff", "--cached", "--quiet"],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    if diff.returncode == 0:
+        return
+    _git(
+        ["-c", "commit.gpgsign=false", "-c", "tag.gpgsign=false", "commit", "-m", message],
+        cwd,
+    )
+
+
+def reset_hard(cwd: str) -> None:
+    _git(["reset", "--hard", "HEAD"], cwd)
+    _git(["clean", "-fdx", "-e", ".kaizen"], cwd)
+
+
+def branch_commit_count(base: str, cwd: str) -> int:
+    if not base:
+        return 0
+    return int(_git(["rev-list", "--count", "--first-parent", f"{base}..HEAD"], cwd))
+
+
+def branch_diff_stats(base: str, cwd: str) -> dict:
+    if not base:
+        return {"files_changed": 0, "lines_added": 0, "lines_deleted": 0}
+    rng = f"{base}..HEAD"
+    name_status = _git(["diff", "--name-status", rng], cwd)
+    numstat = _git(["diff", "--numstat", rng], cwd)
+    files_changed = len([line for line in name_status.splitlines() if line.strip()])
+    lines_added = 0
+    lines_deleted = 0
+    for line in numstat.splitlines():
+        parts = line.split("\t")
+        if len(parts) >= 2 and parts[0] != "-":
+            lines_added += int(parts[0] or 0)
+            lines_deleted += int(parts[1] or 0)
+    return {"files_changed": files_changed, "lines_added": lines_added, "lines_deleted": lines_deleted}
+
+
+def slugify_prompt(text: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    slug = re.sub(r"-+", "-", slug)[:50].strip("-")
+    return f"kaizen/{slug}" if slug else "kaizen/run"
+
+
+def create_worktree(repo_cwd: str, branch_name: str, target_path: str) -> str:
+    os.makedirs(os.path.dirname(target_path), exist_ok=True)
+    if os.path.isdir(target_path):
+        remove_worktree(repo_cwd, target_path)
+    try:
+        _git(["worktree", "add", target_path, "-b", branch_name, "HEAD"], repo_cwd)
+    except RuntimeError as e:
+        if "already exists" not in str(e).lower():
+            raise
+        remove_worktree(repo_cwd, target_path)
+        try:
+            _git(["branch", "-D", branch_name], repo_cwd)
+        except RuntimeError:
+            pass
+        _git(["worktree", "prune"], repo_cwd)
+        _git(["worktree", "add", target_path, "-b", branch_name, "HEAD"], repo_cwd)
+    return target_path
+
+
+def create_worktree_from_ref(repo_cwd: str, target_path: str, branch_name: str, ref: str) -> str:
+    os.makedirs(os.path.dirname(target_path), exist_ok=True)
+    if os.path.isdir(target_path):
+        remove_worktree(repo_cwd, target_path)
+    _git(["worktree", "add", "-b", branch_name, target_path, ref], repo_cwd)
+    return target_path
+
+
+def remove_worktree(repo_cwd: str, target_path: str) -> None:
+    try:
+        _git(["worktree", "remove", "--force", target_path], repo_cwd)
+    except RuntimeError:
+        pass
+    try:
+        _git(["worktree", "prune"], repo_cwd)
+    except RuntimeError:
+        pass
+
+
+def push_branch(cwd: str, remote: str = "origin", branch: str | None = None) -> None:
+    args = ["push", remote]
+    if branch:
+        args.extend(["-u", branch])
+    _git(args, cwd)
+
+
+def force_push_with_lease(cwd: str, remote: str, branch: str) -> None:
+    _git(["push", "--force-with-lease", remote, f"HEAD:refs/heads/{branch}"], cwd)
+
+
+def copy_user_identity(src_cwd: str, dst_cwd: str) -> None:
+    for key in ["user.name", "user.email"]:
+        try:
+            val = _git(["config", key], src_cwd)
+            if val:
+                _git(["config", key, val], dst_cwd)
+        except RuntimeError:
+            pass

kaizen/loop.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from kaizen.agent import OpenCodeAgent
+from kaizen.config import load_config
+from kaizen.findings import FindingsResult, Finding
+from kaizen.git import (
+    checkout,
+    commit_all,
+    copy_user_identity,
+    create_branch,
+    create_worktree_from_ref,
+    delete_branch,
+    fetch,
+    get_default_branch,
+    head_commit,
+    remove_worktree,
+    resolve_ref,
+    slugify_prompt,
+)
+from kaizen.orchestrator import Orchestrator
+from kaizen.review_prompt import build_fix_prompt
+from kaizen.run import RunInfo, setup_run, update_run_head, update_run_pr_url, update_run_status
+from kaizen.steps.pr import PRStep
+from kaizen.steps.push import PushStep
+from kaizen.steps.review import ReviewStep
+
+
+@dataclass
+class _WorkContext:
+    branch: str
+    work_dir: str
+    worktree_path: str | None
+    base_commit: str
+    run_info: RunInfo
+    default_branch: str
+
+
+def _setup_work_context(
+    prompt: str,
+    cwd: str,
+    use_worktree: bool = True,
+) -> _WorkContext:
+    kaizen_dir = os.path.join(cwd, ".kaizen")
+    os.makedirs(kaizen_dir, exist_ok=True)
+    gitignore = os.path.join(kaizen_dir, ".gitignore")
+    if not os.path.exists(gitignore):
+        Path(gitignore).write_text("worktrees/\nruns/\n")
+
+    root_gitignore = os.path.join(cwd, ".gitignore")
+    if os.path.exists(root_gitignore):
+        content = Path(root_gitignore).read_text()
+        if ".kaizen" not in content.splitlines():
+            Path(root_gitignore).write_text(content.rstrip() + "\n.kaizen/\n")
+    else:
+        Path(root_gitignore).write_text(".kaizen/\n")
+
+    fetch(cwd)
+    default_branch = get_default_branch(cwd)
+    try:
+        base_commit = resolve_ref(cwd, f"origin/{default_branch}")
+    except RuntimeError:
+        base_commit = head_commit(cwd)
+
+    branch = slugify_prompt(prompt)
+    work_dir = cwd
+    worktree_path: str | None = None
+
+    if use_worktree:
+        worktree_path = os.path.join(cwd, ".kaizen", "worktrees", branch.replace("/", "-"))
+        print(f"  creating worktree: {worktree_path}")
+        try:
+            create_worktree_from_ref(cwd, worktree_path, branch, f"origin/{default_branch}")
+        except RuntimeError as e:
+            print(f"  worktree creation failed: {e}", file=sys.stderr)
+            sys.exit(1)
+        copy_user_identity(cwd, worktree_path)
+        work_dir = worktree_path
+    else:
+        try:
+            create_branch(branch, cwd)
+        except RuntimeError:
+            pass
+
+    current_head = head_commit(work_dir)
+    run_info = setup_run(
+        prompt=prompt,
+        branch=branch,
+        base_commit=base_commit,
+        head_commit=current_head,
+        worktree_path=worktree_path,
+        repo_cwd=cwd,
+    )
+
+    return _WorkContext(
+        branch=branch,
+        work_dir=work_dir,
+        worktree_path=worktree_path,
+        base_commit=base_commit,
+        run_info=run_info,
+        default_branch=default_branch,
+    )
+
+
+def run_loop(
+    prompt: str,
+    cwd: str,
+    agent: OpenCodeAgent,
+    max_work_iterations: int | None = None,
+    max_review_rounds: int = 3,
+    use_worktree: bool = True,
+) -> str:
+    ctx = _setup_work_context(prompt, cwd, use_worktree)
+
+    print(f"  run {ctx.run_info.run_id} on branch {ctx.branch}")
+    print(f"  base: {ctx.default_branch} ({ctx.base_commit[:8]})")
+
+    try:
+        # ── Phase 1: WORK ──
+        print(f"\n{'=' * 50}")
+        print("  PHASE: WORK")
+        print(f"{'=' * 50}")
+
+        config = load_config()
+        orch = Orchestrator(
+            agent=agent,
+            run_info=ctx.run_info,
+            prompt=prompt,
+            cwd=ctx.work_dir,
+            max_iterations=max_work_iterations or config.get("max_work_iterations"),
+            repo_dir=cwd,
+        )
+        orch.run()
+
+        current_head = head_commit(ctx.work_dir)
+        update_run_head(ctx.run_info.run_dir, current_head)
+
+        # ── Phase 2: REVIEW (with fix loop) ──
+        print(f"\n{'=' * 50}")
+        print("  PHASE: REVIEW")
+        print(f"{'=' * 50}")
+
+        review_step = ReviewStep()
+        final_findings: FindingsResult | None = None
+
+        for round_num in range(max_review_rounds):
+            print(f"\n  review round {round_num + 1}/{max_review_rounds}")
+
+            current_head = head_commit(ctx.work_dir)
+            outcome = review_step.execute(
+                work_dir=ctx.work_dir,
+                base_commit=ctx.base_commit,
+                head_commit=current_head,
+                agent=agent,
+                intent=prompt,
+                repo_dir=cwd,
+            )
+
+            if outcome.skipped:
+                print("  review skipped")
+                break
+
+            if outcome.findings:
+                final_findings = outcome.findings
+
+            if not outcome.findings or not outcome.findings.items:
+                print("  review clean")
+                break
+
+            findings = outcome.findings
+            auto_fix_items = findings.auto_fix_items
+
+            if auto_fix_items:
+                print(f"\n  auto-fixing {len(auto_fix_items)} issues...")
+                fix_prompt = build_fix_prompt([_finding_to_dict(f) for f in auto_fix_items])
+                try:
+                    agent.run(fix_prompt, ctx.work_dir, repo_dir=cwd)
+                    commit_all(f"kaizen: fix {len(auto_fix_items)} review findings", ctx.work_dir)
+                    current_head = head_commit(ctx.work_dir)
+                    update_run_head(ctx.run_info.run_dir, current_head)
+                    print("  fixes committed")
+                    continue
+                except Exception as e:
+                    print(f"  auto-fix failed: {e}")
+            else:
+                print("  no actionable findings")
+            break
+
+        # ── Phase 3: SHIP ──
+        print(f"\n{'=' * 50}")
+        print("  PHASE: SHIP")
+        print(f"{'=' * 50}")
+
+        push_step = PushStep()
+        push_outcome = push_step.execute(work_dir=ctx.work_dir, branch=ctx.branch)
+        if push_outcome.skipped:
+            print("  push skipped, cannot create PR")
+            update_run_status(ctx.run_info.run_dir, "failed")
+            return "failed"
+
+        pr_step = PRStep()
+        pr_outcome = pr_step.execute(
+            work_dir=ctx.work_dir,
+            branch=ctx.branch,
+            base_branch=ctx.default_branch,
+            findings=final_findings,
+        )
+
+        if pr_outcome.pr_url:
+            update_run_pr_url(ctx.run_info.run_dir, pr_outcome.pr_url)
+
+        update_run_status(ctx.run_info.run_dir, "completed")
+        return "passed"
+
+    except Exception as e:
+        print(f"\n  [FATAL] {e}", file=sys.stderr)
+        update_run_status(ctx.run_info.run_dir, "failed")
+        return "failed"
+
+    finally:
+        # ── Phase 4: CLEANUP ──
+        print("\n  cleaning up...")
+        if ctx.worktree_path:
+            remove_worktree(cwd, ctx.worktree_path)
+        else:
+            try:
+                checkout(ctx.default_branch, cwd)
+            except RuntimeError:
+                pass
+        delete_branch(ctx.branch, cwd)
+
+
+def _finding_to_dict(f: Finding) -> dict:
+    d: dict = {
+        "id": f.id,
+        "severity": f.severity,
+        "description": f.description,
+        "action": f.action,
+    }
+    if f.file:
+        d["file"] = f.file
+    if f.line:
+        d["line"] = f.line
+    return d

kaizen/orchestrator.py

@@ -0,0 +1,159 @@
+import time
+
+from kaizen.agent import OpenCodeAgent
+from kaizen.config import load_config
+from kaizen.git import (
+    branch_commit_count,
+    commit_all,
+    push_branch,
+    reset_hard,
+)
+from kaizen.run import RunInfo, append_notes
+from kaizen.work_prompt import build_iteration_prompt
+
+WORK_SCHEMA = {
+    "type": "object",
+    "additionalProperties": False,
+    "properties": {
+        "success": {"type": "boolean"},
+        "summary": {"type": "string"},
+        "key_changes_made": {"type": "array", "items": {"type": "string"}},
+        "key_learnings": {"type": "array", "items": {"type": "string"}},
+        "should_fully_stop": {"type": "boolean"},
+    },
+    "required": ["success", "summary", "key_changes_made", "key_learnings"],
+}
+
+
+class Orchestrator:
+    def __init__(
+        self,
+        agent: OpenCodeAgent,
+        run_info: RunInfo,
+        prompt: str,
+        cwd: str,
+        start_iteration: int = 0,
+        max_iterations: int | None = None,
+        stop_when: str | None = None,
+        push_remote: str | None = None,
+        repo_dir: str | None = None,
+    ):
+        self.agent = agent
+        self.run_info = run_info
+        self.prompt = prompt
+        self.cwd = cwd
+        self.repo_dir = repo_dir
+        self.config = load_config()
+        self.iteration = start_iteration
+        self.max_iterations = max_iterations
+        self.stop_when = stop_when
+        self.push_remote = push_remote
+        self.success_count = 0
+        self.fail_count = 0
+        self.consecutive_failures = 0
+        self.total_input_tokens = 0
+        self.total_output_tokens = 0
+        self.commit_count = branch_commit_count(run_info.base_commit, cwd)
+        self.start_time: float = 0
+        self._stop_requested = False
+
+    def request_stop(self) -> None:
+        self._stop_requested = True
+
+    def run(self) -> str:
+        self.start_time = time.time()
+        status = "stopped"
+
+        try:
+            with self.agent.session(self.cwd, repo_dir=self.repo_dir) as sess:
+                while not self._stop_requested:
+                    if self.max_iterations and self.iteration >= self.max_iterations:
+                        print(f"  max iterations reached ({self.max_iterations})")
+                        status = "aborted"
+                        break
+
+                    self.iteration += 1
+                    print(f"\n  --- work iteration {self.iteration} ---")
+
+                    iter_prompt = build_iteration_prompt(
+                        self.iteration, self.run_info.run_id,
+                        self.prompt, self.stop_when,
+                    )
+
+                    try:
+                        result = sess.send(iter_prompt, schema=WORK_SCHEMA)
+                    except Exception as e:
+                        print(f"  [ERROR] {e}")
+                        self.fail_count += 1
+                        self.consecutive_failures += 1
+                        reset_hard(self.cwd)
+                        if self.consecutive_failures >= self.config.get("max_consecutive_failures", 3):
+                            print(f"  {self.consecutive_failures} consecutive failures, aborting")
+                            status = "aborted"
+                            break
+                        continue
+
+                    success = bool(result.output.get("success"))
+                    summary = str(result.output.get("summary", ""))
+                    changes = result.output.get("key_changes_made") or []
+                    learnings = result.output.get("key_learnings") or []
+                    should_stop = bool(result.output.get("should_fully_stop", False))
+
+                    self.total_input_tokens += result.input_tokens
+                    self.total_output_tokens += result.output_tokens
+
+                    if success:
+                        commit_msg = f"kaizen {self.iteration}: {summary}"
+                        try:
+                            commit_all(commit_msg, self.cwd)
+                        except RuntimeError as e:
+                            print(f"  [COMMIT FAILED] {e}")
+                            self.fail_count += 1
+                            self.consecutive_failures += 1
+                            continue
+
+                        self.commit_count = branch_commit_count(self.run_info.base_commit, self.cwd)
+                        self.success_count += 1
+                        self.consecutive_failures = 0
+                        append_notes(
+                            self.run_info.run_dir + "/notes.md",
+                            self.iteration, summary, changes, learnings,
+                        )
+                        print(f"  committed: {summary}")
+
+                        if self.push_remote:
+                            try:
+                                push_branch(self.cwd, self.push_remote)
+                                print(f"  pushed to {self.push_remote}")
+                            except RuntimeError as e:
+                                print(f"  [PUSH FAILED] {e}")
+                    else:
+                        self.fail_count += 1
+                        self.consecutive_failures += 1
+                        reset_hard(self.cwd)
+                        append_notes(
+                            self.run_info.run_dir + "/notes.md",
+                            self.iteration, f"[FAIL] {summary}", [], learnings,
+                        )
+                        print(f"  failed: {summary}")
+
+                    if self.stop_when and should_stop:
+                        print(f"  stop condition met: {self.stop_when}")
+                        status = "stopped"
+                        break
+
+                    if self.consecutive_failures >= self.config.get("max_consecutive_failures", 3):
+                        print(f"  {self.consecutive_failures} consecutive failures, aborting")
+                        status = "aborted"
+                        break
+
+        except KeyboardInterrupt:
+            print("\n  interrupted")
+            status = "stopped"
+
+        return status
+
+    def elapsed(self) -> float:
+        if not self.start_time:
+            return 0
+        return time.time() - self.start_time

kaizen/review_prompt.py

@@ -0,0 +1,66 @@
+REVIEW_SCHEMA = {
+    "type": "object",
+    "additionalProperties": False,
+    "properties": {
+        "findings": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": False,
+                "properties": {
+                    "id": {"type": "string"},
+                    "severity": {"type": "string", "enum": ["info", "warning", "error"]},
+                    "file": {"type": "string"},
+                    "line": {"type": "integer"},
+                    "description": {"type": "string"},
+                    "action": {"type": "string", "enum": ["no-op", "auto-fix"]},
+                },
+                "required": ["id", "severity", "description", "action"],
+            },
+        },
+        "summary": {"type": "string"},
+        "risk_level": {"type": "string", "enum": ["low", "medium", "high"]},
+        "risk_rationale": {"type": "string"},
+    },
+    "required": ["findings", "summary", "risk_level"],
+}
+
+
+def build_review_prompt(diff: str, intent: str = "") -> str:
+    intent_section = ""
+    if intent:
+        intent_section = f"\n## User Intent\n\n{intent}\n"
+
+    return (
+        "You are reviewing a git diff for bugs, security issues, and code quality.\n\n"
+        "## Instructions\n\n"
+        "1. Analyze the diff for correctness, security, and quality\n"
+        "2. For each issue classify severity (info/warning/error) and action:\n"
+        "   - no-op: informational, no action needed\n"
+        "   - auto-fix: mechanical fix (typos, missing error handling, dead code, obvious bugs, behavioral changes)\n"
+        "3. Provide an overall risk assessment\n\n"
+        "## Output\n\n"
+        "Return structured output with:\n"
+        "- findings: array of issues found (empty array if clean)\n"
+        "- summary: one-sentence overall assessment\n"
+        "- risk_level: low, medium, or high\n"
+        "- risk_rationale: brief explanation of the risk level\n"
+        f"{intent_section}\n"
+        "## Diff\n\n"
+        f"```diff\n{diff}\n```\n"
+    )
+
+
+def build_fix_prompt(findings_items: list[dict]) -> str:
+    lines = [
+        "Fix the following issues found during code review.\n",
+        "Do NOT commit. Just make the code changes.\n",
+    ]
+
+    for f in findings_items:
+        loc = f" ({f['file']}:{f.get('line', '?')})" if f.get("file") else ""
+        lines.append(f"1. [{f['severity']}]{loc} — {f['description']} ({f['action']})")
+
+    lines.append("\nAfter fixing, run any available tests or linters to verify.")
+
+    return "\n".join(lines)