kaizen-loop 0.1.0__py3-none-any.whl

kaizen/run.py

@@ -0,0 +1,93 @@
+import os
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class RunInfo:
+    run_id: str
+    run_dir: str
+    prompt: str
+    branch: str
+    base_commit: str
+    head_commit: str
+    worktree_path: str | None = None
+    repo_cwd: str | None = None
+    pr_url: str | None = None
+
+
+def runs_home() -> str:
+    return os.path.expanduser("~/.kaizen/runs")
+
+
+def setup_run(
+    prompt: str,
+    branch: str,
+    base_commit: str,
+    head_commit: str,
+    worktree_path: str | None = None,
+    repo_cwd: str | None = None,
+) -> RunInfo:
+    run_id = uuid.uuid4().hex[:8]
+    run_dir = os.path.join(runs_home(), run_id)
+    os.makedirs(run_dir, exist_ok=True)
+
+    Path(os.path.join(run_dir, "prompt.md")).write_text(prompt + "\n")
+    Path(os.path.join(run_dir, "branch")).write_text(branch + "\n")
+    Path(os.path.join(run_dir, "base-commit")).write_text(base_commit + "\n")
+    Path(os.path.join(run_dir, "head-commit")).write_text(head_commit + "\n")
+    Path(os.path.join(run_dir, "status")).write_text("pending\n")
+
+    if worktree_path:
+        Path(os.path.join(run_dir, "worktree")).write_text(worktree_path + "\n")
+    if repo_cwd:
+        Path(os.path.join(run_dir, "repo-cwd")).write_text(repo_cwd + "\n")
+
+    notes_path = os.path.join(run_dir, "notes.md")
+    if not os.path.exists(notes_path):
+        Path(notes_path).write_text(
+            f"# kaizen run: {run_id}\n\n"
+            f"Objective: {prompt}\n\n"
+            "## Iteration Log\n"
+        )
+
+    return RunInfo(
+        run_id=run_id,
+        run_dir=run_dir,
+        prompt=prompt,
+        branch=branch,
+        base_commit=base_commit,
+        head_commit=head_commit,
+        worktree_path=worktree_path,
+        repo_cwd=repo_cwd,
+    )
+
+
+def update_run_status(run_dir: str, status: str) -> None:
+    Path(os.path.join(run_dir, "status")).write_text(status + "\n")
+
+
+def update_run_head(run_dir: str, head: str) -> None:
+    Path(os.path.join(run_dir, "head-commit")).write_text(head + "\n")
+
+
+def update_run_pr_url(run_dir: str, pr_url: str) -> None:
+    Path(os.path.join(run_dir, "pr-url")).write_text(pr_url + "\n")
+
+
+def append_notes(
+    notes_path: str, iteration: int, summary: str,
+    changes: list[str], learnings: list[str],
+) -> None:
+    lines = [f"\n### Iteration {iteration}\n", f"**Summary:** {summary}\n"]
+    if changes:
+        lines.append("**Changes:**")
+        lines.extend(f"- {c}" for c in changes)
+        lines.append("")
+    if learnings:
+        lines.append("**Learnings:**")
+        lines.extend(f"- {item}" for item in learnings)
+        lines.append("")
+    with open(notes_path, "a") as f:
+        f.write("\n".join(lines))

kaizen/steps/__init__.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from kaizen.findings import FindingsResult
+
+
+@dataclass
+class StepOutcome:
+    findings: FindingsResult | None = None
+    skipped: bool = False
+    skip_remaining: bool = False
+    pr_url: str = ""

kaizen/steps/pr.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+import subprocess
+
+from kaizen.findings import FindingsResult
+from kaizen.steps import StepOutcome
+
+
+class PRStep:
+    def name(self) -> str:
+        return "pr"
+
+    def execute(
+        self, work_dir: str, branch: str, base_branch: str,
+        findings: FindingsResult | None = None,
+    ) -> StepOutcome:
+        title = f"{branch}: changes"
+        body = self._build_body(branch, findings)
+
+        existing = self._find_existing_pr(branch)
+        if existing:
+            print(f"  updating PR: {existing}")
+            self._update_pr(existing, title, body)
+            return StepOutcome(pr_url=existing)
+
+        url = self._create_pr(branch, base_branch, title, body, work_dir)
+        if url:
+            print(f"  PR created: {url}")
+            return StepOutcome(pr_url=url)
+
+        return StepOutcome(skipped=True)
+
+    def _build_body(self, branch: str, findings: FindingsResult | None) -> str:
+        lines = ["## What Changed", ""]
+        if findings and findings.summary:
+            lines.append(findings.summary)
+        else:
+            lines.append(f"Changes on branch `{branch}`.")
+        lines.append("")
+        if findings:
+            lines.append("## Risk Assessment")
+            lines.append("")
+            lines.append(f"**Risk:** {findings.risk_level}")
+            if findings.risk_rationale:
+                lines.append(findings.risk_rationale)
+            lines.append("")
+        lines.append("---")
+        lines.append("*Validated through kaizen pipeline*")
+        return "\n".join(lines)
+
+    def _find_existing_pr(self, branch: str) -> str:
+        try:
+            result = subprocess.run(
+                ["gh", "pr", "list", "--head", branch, "--json", "url", "--limit", "1"],
+                capture_output=True, text=True, timeout=30,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                prs = json.loads(result.stdout)
+                if prs:
+                    return prs[0].get("url", "")
+        except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+            pass
+        return ""
+
+    def _create_pr(
+        self, branch: str, base_branch: str, title: str, body: str, work_dir: str,
+    ) -> str:
+        try:
+            result = subprocess.run(
+                [
+                    "gh", "pr", "create",
+                    "--head", branch, "--base", base_branch,
+                    "--title", title, "--body", body,
+                ],
+                cwd=work_dir,
+                capture_output=True, text=True, timeout=30,
+            )
+            if result.returncode == 0:
+                for line in result.stdout.splitlines():
+                    if "pull" in line.lower():
+                        return line.strip()
+                return result.stdout.strip()
+            print(f"  gh pr create failed: {result.stderr.strip()}")
+        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+            print(f"  gh not available: {e}")
+        return ""
+
+    def _update_pr(self, pr_url: str, title: str, body: str) -> None:
+        try:
+            subprocess.run(
+                ["gh", "pr", "edit", pr_url, "--title", title, "--body", body],
+                capture_output=True, text=True, timeout=30,
+            )
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass

kaizen/steps/push.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import sys
+
+from kaizen.steps import StepOutcome
+
+
+class PushStep:
+    def name(self) -> str:
+        return "push"
+
+    def execute(self, work_dir: str, branch: str) -> StepOutcome:
+        from kaizen.git import force_push_with_lease
+
+        print(f"  pushing {branch} to origin...")
+        try:
+            force_push_with_lease(work_dir, "origin", branch)
+            print("  pushed successfully")
+        except RuntimeError as e:
+            print(f"  push failed: {e}", file=sys.stderr)
+            return StepOutcome(skipped=True)
+
+        return StepOutcome()

kaizen/steps/review.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import sys
+
+from kaizen.agent import OpenCodeAgent
+from kaizen.findings import parse_findings
+from kaizen.review_prompt import REVIEW_SCHEMA, build_review_prompt
+from kaizen.steps import StepOutcome
+
+
+class ReviewStep:
+    def name(self) -> str:
+        return "review"
+
+    def execute(
+        self, work_dir: str, base_commit: str, head_commit: str,
+        agent: OpenCodeAgent, intent: str = "", repo_dir: str | None = None,
+    ) -> StepOutcome:
+        from kaizen.git import get_diff
+
+        try:
+            diff = get_diff(base_commit, head_commit, work_dir)
+        except RuntimeError as e:
+            print(f"  Could not get diff: {e}", file=sys.stderr)
+            return StepOutcome(skipped=True)
+
+        if not diff.strip():
+            print("  No diff found, skipping review")
+            return StepOutcome(skipped=True)
+
+        max_diff_size = 50000
+        if len(diff) > max_diff_size:
+            diff = diff[:max_diff_size] + "\n... (truncated)"
+
+        prompt = build_review_prompt(diff, intent=intent)
+        result = agent.run(prompt, work_dir, schema=REVIEW_SCHEMA, repo_dir=repo_dir)
+
+        findings = parse_findings(result.output)
+
+        if not findings.items:
+            print(f"  Clean: {findings.summary}")
+            return StepOutcome(findings=findings)
+
+        print(f"  Risk: {findings.risk_level} — {findings.risk_rationale}")
+        print(f"  {findings.summary}\n")
+        print(f"  {'ID':<6} {'SEV':<9} {'ACTION':<12} DESCRIPTION")
+        print(f"  {'-' * 6} {'-' * 9} {'-' * 12} {'-' * 40}")
+        for f in findings.items:
+            desc = f.description[:60]
+            print(f"  {f.id:<6} {f.severity:<9} {f.action:<12} {desc}")
+        print()
+
+        return StepOutcome(
+            findings=findings,
+        )

kaizen/work_prompt.py

@@ -0,0 +1,43 @@
+def build_iteration_prompt(
+    n: int,
+    run_id: str,
+    prompt: str,
+    stop_when: str | None = None,
+) -> str:
+    output_fields = [
+        "- success: true if you made a meaningful contribution. false means changes should be discarded",
+        "- summary: concise one-sentence summary of the accomplishment",
+        "- key_changes_made: array of descriptions of key changes",
+        "- key_learnings: array of new learnings informative for future iterations",
+    ]
+
+    if stop_when is not None:
+        output_fields.append(
+            "- should_fully_stop: set true ONLY when the stop condition is fully met"
+        )
+
+    stop_section = ""
+    if stop_when is not None:
+        stop_section = (
+            "\n\n## Stop Condition\n\n"
+            f"The user configured: {stop_when}\n"
+            "If this condition is fully met, set should_fully_stop=true."
+        )
+
+    fields_text = "\n".join(output_fields)
+
+    return (
+        "You are working autonomously towards an objective.\n"
+        f"This is iteration {n}. Each iteration makes one incremental step.\n\n"
+        "## Instructions\n\n"
+        f"1. Read .kaizen/runs/{run_id}/notes.md to understand prior work. Do NOT modify notes.md\n"
+        "2. Identify the next smallest verifiable unit of work\n"
+        "3. If a solution didn't move the needle, document learnings and set success=false\n"
+        "4. If you made code changes, run build/tests/linters if available. Do NOT make git commits\n"
+        "5. Stop any background processes before finishing\n\n"
+        "## Output\n\n"
+        "When finished, the structured output tool will prompt you for these fields:\n"
+        f"{fields_text}\n"
+        f"{stop_section}\n\n"
+        f"## Objective\n\n{prompt}"
+    )

kaizen_loop-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: kaizen-loop
+Version: 0.1.0
+Summary: Continuous code improvement: autonomous work → review → fix → ship
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'

kaizen_loop-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+kaizen/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+kaizen/__main__.py,sha256=nIfRxBDvGRUzGKsjJ3_g-IbMsLZGGNJbviPAcKmXtOs,67
+kaizen/agent.py,sha256=YYgpvujk3nhCa8LxbM5fX3r0lPC-M01YtWUByWRBwc8,11080
+kaizen/cli.py,sha256=NVw--X4tQh90Wd2ZMue0nArdMKXPrQkrr7uNYhnXnSY,2989
+kaizen/config.py,sha256=Hb5SmctueA6PqLsJMjBgdSURQ_qBfBC5eOHNYe5ZW4w,761
+kaizen/findings.py,sha256=GLsNdxx8z8KpCpsUOUGSwqYv7uwV7HKkI91lf5IW-3k,1369
+kaizen/git.py,sha256=nwu7MigAVe_lAdK6xx1jQq1Cx5OC0I4uejpnUM7kBCM,6100
+kaizen/loop.py,sha256=YzHFwcN4dlsQ_USpWKou-yJbu8o01vtH-sxygfusO8U,7456
+kaizen/orchestrator.py,sha256=DgR-CYJZnqvKDq6RyQ_cf0_xr-qaAd5Lt2yEtouvBA8,6191
+kaizen/review_prompt.py,sha256=4eiZbtDeks94q7aRbCu7LW__sKBjDUtKJlWV7EmbW-k,2572
+kaizen/run.py,sha256=rZMB3PXhVW6YgVLcq5OK9tAWcACvM6lKD5oB3tYarF8,2675
+kaizen/work_prompt.py,sha256=Umai3rYxWG566dQFuq4s8VmAMaavaeNjSGs1GJZSeGc,1758
+kaizen/steps/__init__.py,sha256=H8bo43GmWfiLZMBJxSf62hRoBNaEFWXeGVD_FTS6NDI,233
+kaizen/steps/pr.py,sha256=mWOdt_BCx_AP83eawJEI0M4ZZtRpv_HL0RnBR_CFLQ4,3391
+kaizen/steps/push.py,sha256=BZYjK-7FtXXyVkD4x7OTGabH02LmkQEimMuc78jr0Fc,608
+kaizen/steps/review.py,sha256=TY0cOxIH4CKOjqrDpwL2--pA90oZjNMdrI_-ajz5kV4,1816
+kaizen_loop-0.1.0.dist-info/METADATA,sha256=TFLrj68Ty4b4Z97bd7dvT5lEDE1EuVNbWxYsefnYtHY,301
+kaizen_loop-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+kaizen_loop-0.1.0.dist-info/entry_points.txt,sha256=JsUdOanDcNnxHkJbRYekf5rYHopnDOzeXsh1r9tcAIc,43
+kaizen_loop-0.1.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+kaizen_loop-0.1.0.dist-info/RECORD,,

kaizen_loop-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

kaizen_loop-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kaizen = kaizen.cli:main

kaizen_loop-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.