autopilot-code 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",

package/scripts/issue_runner/__init__.py

@@ -0,0 +1 @@
+from .git_ops import GitOperations, GitResult, MergeStatus

package/scripts/issue_runner/git_ops.py

@@ -0,0 +1,204 @@
+import subprocess
+import shutil
+import json
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Optional
+from enum import Enum, auto
+
+
+class MergeStatus(Enum):
+    MERGEABLE = auto()
+    CONFLICTING = auto()
+    UNKNOWN = auto()
+    BLOCKED = auto()
+
+
+@dataclass
+class GitResult:
+    success: bool
+    output: str
+    error: Optional[str] = None
+
+
+class GitOperations:
+    def __init__(self, repo_root: Path):
+        self.repo_root = repo_root
+
+    def create_worktree(
+        self, worktree_path: Path, branch: str, base_branch: str = "main"
+    ) -> GitResult:
+        self.prune_worktrees()
+
+        if worktree_path.exists():
+            return GitResult(
+                success=True, output=f"Reusing existing worktree: {worktree_path}"
+            )
+
+        if self.branch_exists(branch):
+            return self._run_git(["worktree", "add", str(worktree_path), branch])
+        else:
+            return self._run_git(
+                ["worktree", "add", str(worktree_path), "-b", branch, base_branch]
+            )
+
+    def remove_worktree(self, worktree_path: Path) -> GitResult:
+        return self._run_git(["worktree", "remove", str(worktree_path)])
+
+    def prune_worktrees(self) -> GitResult:
+        return self._run_git(["worktree", "prune"])
+
+    def worktree_exists(self, worktree_path: Path) -> bool:
+        result = self._run_git(["worktree", "list"])
+        if not result.success:
+            return False
+        return str(worktree_path) in result.output
+
+    def branch_exists(self, branch: str, remote: bool = False) -> bool:
+        if remote:
+            result = self._run_git(["ls-remote", "--heads", "origin", branch])
+        else:
+            result = self._run_git(
+                ["show-ref", "--verify", f"refs/heads/{branch}"], cwd=self.repo_root
+            )
+        return result.success
+
+    def fetch(self, remote: str = "origin", branch: Optional[str] = None) -> GitResult:
+        args = ["fetch", remote]
+        if branch:
+            args.append(branch)
+        return self._run_git(args)
+
+    def push(
+        self,
+        branch: str,
+        remote: str = "origin",
+        force: bool = False,
+        set_upstream: bool = True,
+    ) -> GitResult:
+        args = ["push", remote, branch]
+        if force:
+            args.append("-f")
+        if set_upstream:
+            args.append("-u")
+        return self._run_git(args)
+
+    def has_changes(self, worktree: Path) -> bool:
+        result = self._run_git(["status", "--porcelain"], cwd=worktree)
+        return bool(result.output.strip())
+
+    def stage_all(self, worktree: Path) -> GitResult:
+        return self._run_git(["add", "-A"], cwd=worktree)
+
+    def commit(self, worktree: Path, message: str) -> GitResult:
+        return self._run_git(["commit", "-m", message], cwd=worktree)
+
+    def get_commit_sha(self, worktree: Path, short: bool = True) -> Optional[str]:
+        args = ["rev-parse"]
+        if short:
+            args.append("--short")
+        args.append("HEAD")
+        result = self._run_git(args, cwd=worktree)
+        if result.success:
+            return result.output.strip()
+        return None
+
+    def get_changed_files_count(self, worktree: Path) -> int:
+        result = self._run_git(
+            ["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"], cwd=worktree
+        )
+        if result.success:
+            return len([line for line in result.output.splitlines() if line.strip()])
+        return 0
+
+    def rebase(self, worktree: Path, onto: str = "origin/main") -> GitResult:
+        return self._run_git(["rebase", onto], cwd=worktree)
+
+    def abort_rebase(self, worktree: Path) -> GitResult:
+        return self._run_git(["rebase", "--abort"], cwd=worktree)
+
+    def merge(self, worktree: Path, branch: str = "origin/main") -> GitResult:
+        return self._run_git(["merge", branch], cwd=worktree)
+
+    def abort_merge(self, worktree: Path) -> GitResult:
+        return self._run_git(["merge", "--abort"], cwd=worktree)
+
+    def has_conflicts(self, worktree: Path) -> bool:
+        result = self._run_git(["diff", "--name-only", "--diff-filter=U"], cwd=worktree)
+        if result.success:
+            return bool(result.output.strip())
+        return False
+
+    def get_conflicted_files(self, worktree: Path) -> list[str]:
+        result = self._run_git(["diff", "--name-only", "--diff-filter=U"], cwd=worktree)
+        if result.success:
+            return [line.strip() for line in result.output.splitlines() if line.strip()]
+        return []
+
+    def is_merge_in_progress(self, worktree: Path) -> bool:
+        merge_head = worktree / ".git" / "MERGE_HEAD"
+        if merge_head.exists():
+            return True
+        rebase_merge = worktree / ".git" / "rebase-merge"
+        rebase_apply = worktree / ".git" / "rebase-apply"
+        return rebase_merge.exists() or rebase_apply.exists()
+
+    def get_pr_merge_status(self, repo: str, branch: str) -> MergeStatus:
+        result = self._run_gh(
+            [
+                "pr",
+                "view",
+                "--repo",
+                repo,
+                "--head",
+                branch,
+                "--json",
+                "mergeable,mergeStateStatus",
+            ]
+        )
+
+        if not result.success:
+            return MergeStatus.UNKNOWN
+
+        try:
+            data = json.loads(result.output)
+            mergeable = data.get("mergeable")
+            merge_state = data.get("mergeStateStatus")
+
+            if mergeable == "CONFLICTING" or merge_state == "DIRTY":
+                return MergeStatus.CONFLICTING
+            elif merge_state == "CLEAN" or merge_state == "HAS_HOOKS":
+                return MergeStatus.MERGEABLE
+            elif merge_state == "BLOCKED":
+                return MergeStatus.BLOCKED
+            else:
+                return MergeStatus.UNKNOWN
+        except (json.JSONDecodeError, TypeError):
+            return MergeStatus.UNKNOWN
+
+    def _run_git(self, args: list[str], cwd: Optional[Path] = None) -> GitResult:
+        cwd = cwd or self.repo_root
+        try:
+            result = subprocess.run(
+                ["git"] + args, cwd=cwd, capture_output=True, text=True
+            )
+            return GitResult(
+                success=result.returncode == 0,
+                output=result.stdout,
+                error=result.stderr if result.returncode != 0 else None,
+            )
+        except Exception as e:
+            return GitResult(success=False, output="", error=str(e))
+
+    def _run_gh(self, args: list[str]) -> GitResult:
+        try:
+            result = subprocess.run(
+                ["gh"] + args, cwd=self.repo_root, capture_output=True, text=True
+            )
+            return GitResult(
+                success=result.returncode == 0,
+                output=result.stdout,
+                error=result.stderr if result.returncode != 0 else None,
+            )
+        except Exception as e:
+            return GitResult(success=False, output="", error=str(e))

package/scripts/issue_runner/states.py

@@ -0,0 +1,102 @@
+from enum import Enum
+from dataclasses import dataclass, asdict, field
+from typing import Optional
+from datetime import datetime
+import json
+
+
+class IssueStep(Enum):
+    """Discrete steps in the issue resolution workflow."""
+
+    INIT = "init"
+    WORKTREE_READY = "worktree_ready"
+    DEPS_INSTALLED = "deps_installed"
+    ISSUE_FETCHED = "issue_fetched"
+    PLAN_POSTED = "plan_posted"
+    IMPLEMENTED = "implemented"
+    COMMITTED = "committed"
+    PUSHED = "pushed"
+    PR_CREATED = "pr_created"
+    CONFLICTS_RESOLVING = "conflicts_resolving"
+    CONFLICTS_RESOLVED = "conflicts_resolved"
+    CHECKS_WAITING = "checks_waiting"
+    CHECKS_FIXING = "checks_fixing"
+    CHECKS_PASSED = "checks_passed"
+    MERGED = "merged"
+    DONE = "done"
+    FAILED = "failed"
+
+
+@dataclass
+class StateData:
+    """
+    Issue state persisted to GitHub as a hidden comment.
+    This is the single source of truth for issue progress.
+    """
+
+    issue_number: int
+    step: IssueStep
+    branch: str
+    worktree: str
+    pr_number: Optional[int] = None
+    session_id: Optional[str] = None  # Agent session for context continuity
+    conflict_attempts: int = 0
+    ci_fix_attempts: int = 0
+    error_message: Optional[str] = None
+    updated_at: str = field(default_factory=lambda: datetime.utcnow().isoformat() + "Z")
+
+    def to_dict(self) -> dict:
+        """Convert to JSON-serializable dict."""
+        d = asdict(self)
+        d["step"] = self.step.value
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "StateData":
+        """Create from dict (parsed from JSON)."""
+        data["step"] = IssueStep(data["step"])
+        return cls(**data)
+
+    def to_comment_body(self, status_message: str) -> str:
+        """Generate GitHub comment with hidden state JSON."""
+        state_json = json.dumps(self.to_dict(), indent=2)
+        return f"""
+<!-- autopilot-state
+{state_json}
+-->
+
+🤖 **Autopilot Status**: {status_message}
+"""
+
+
+# Human-readable status messages for each step
+STEP_STATUS_MESSAGES = {
+    IssueStep.INIT: "Starting work on this issue...",
+    IssueStep.WORKTREE_READY: "Git worktree created.",
+    IssueStep.DEPS_INSTALLED: "Dependencies installed.",
+    IssueStep.ISSUE_FETCHED: "Issue details retrieved.",
+    IssueStep.PLAN_POSTED: "Implementation plan ready.",
+    IssueStep.IMPLEMENTED: "Code changes complete.",
+    IssueStep.COMMITTED: "Changes committed.",
+    IssueStep.PUSHED: "Branch pushed to remote.",
+    IssueStep.PR_CREATED: "Pull request created.",
+    IssueStep.CONFLICTS_RESOLVING: "Resolving merge conflicts...",
+    IssueStep.CONFLICTS_RESOLVED: "Merge conflicts resolved.",
+    IssueStep.CHECKS_WAITING: "Waiting for CI checks to pass...",
+    IssueStep.CHECKS_FIXING: "Attempting to fix failing CI checks...",
+    IssueStep.CHECKS_PASSED: "All CI checks passed!",
+    IssueStep.MERGED: "PR merged successfully!",
+    IssueStep.DONE: "Issue complete! 🎉",
+    IssueStep.FAILED: "❌ Autopilot encountered an error.",
+}
+
+# Labels to apply for each step (for human visibility in issue list)
+STEP_LABELS = {
+    IssueStep.INIT: "autopilot:starting",
+    IssueStep.PLAN_POSTED: "autopilot:planning",
+    IssueStep.IMPLEMENTED: "autopilot:implementing",
+    IssueStep.PR_CREATED: "autopilot:pr-created",
+    IssueStep.CHECKS_WAITING: "autopilot:waiting-checks",
+    IssueStep.CHECKS_FIXING: "autopilot:fixing-checks",
+    IssueStep.MERGED: "autopilot:merging",
+}