autopilot-code 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.4.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))