autopilot-code 0.4.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.4.0",
+  "version": "0.6.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/agents/__init__.py

@@ -1,3 +1,4 @@
 from .base import BaseAgent, AgentResult
+from .opencode import OpenCodeAgent
 
-__all__ = ["BaseAgent", "AgentResult"]
+__all__ = ["BaseAgent", "AgentResult", "OpenCodeAgent"]

package/scripts/issue_runner/agents/opencode.py

@@ -0,0 +1,137 @@
+import subprocess
+import shutil
+import os
+from pathlib import Path
+from typing import Optional
+
+from .base import BaseAgent, AgentResult
+
+
+class OpenCodeAgent(BaseAgent):
+    """
+    Agent implementation for OpenCode CLI.
+
+    OpenCode is invoked via: opencode run "<prompt>"
+
+    Session support: OpenCode supports --continue flag to resume sessions.
+    The session ID is the conversation ID from the previous run.
+    """
+
+    @property
+    def name(self) -> str:
+        return "OpenCode"
+
+    @property
+    def supports_sessions(self) -> bool:
+        return True  # OpenCode supports --continue
+
+    def find_binary(self) -> str:
+        """
+        Locate the opencode binary.
+
+        Search order:
+        1. agentPath from config
+        2. PATH
+        3. Common nvm locations
+        4. Other common locations
+        """
+        # 1. Config-specified path
+        agent_path = self.config.get("agentPath", "")
+        if agent_path and os.path.isfile(agent_path) and os.access(agent_path, os.X_OK):
+            return agent_path
+
+        # 2. Already in PATH
+        which_result = shutil.which("opencode")
+        if which_result:
+            return which_result
+
+        # 3. Common nvm locations
+        home = Path.home()
+        nvm_dir = home / ".nvm" / "versions" / "node"
+        if nvm_dir.exists():
+            for node_dir in nvm_dir.iterdir():
+                opencode_path = node_dir / "bin" / "opencode"
+                if opencode_path.exists() and os.access(opencode_path, os.X_OK):
+                    return str(opencode_path)
+
+        # 4. Other common locations
+        common_paths = [
+            home / ".local" / "bin" / "opencode",
+            Path("/usr/local/bin/opencode"),
+            home / ".npm-global" / "bin" / "opencode",
+        ]
+        for path in common_paths:
+            if path.exists() and os.access(path, os.X_OK):
+                return str(path)
+
+        raise FileNotFoundError(
+            "opencode not found. Set 'agentPath' in autopilot.json or ensure opencode is installed."
+        )
+
+    def run(
+        self, worktree: Path, prompt: str, session_id: Optional[str] = None
+    ) -> AgentResult:
+        """
+        Run OpenCode with the given prompt.
+
+        Args:
+            worktree: Working directory for the agent
+            prompt: The task/prompt
+            session_id: Previous session ID to continue (if any)
+
+        Returns:
+            AgentResult with session_id for future continuation
+        """
+        cmd = [self.binary_path, "run"]
+
+        # Add session continuation if we have a previous session
+        if session_id and self.supports_sessions:
+            cmd.extend(["--continue", session_id])
+
+        cmd.append(prompt)
+
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=worktree,
+                capture_output=True,
+                text=True,
+                timeout=1800,  # 30 minute timeout
+            )
+
+            # Extract session ID from output if available
+            # OpenCode outputs session info that we can parse
+            new_session_id = self._extract_session_id(result.stdout) or session_id
+
+            return AgentResult(
+                success=result.returncode == 0,
+                session_id=new_session_id,
+                output=result.stdout,
+                error=result.stderr if result.returncode != 0 else None,
+            )
+        except subprocess.TimeoutExpired:
+            return AgentResult(
+                success=False,
+                session_id=session_id,
+                output="",
+                error="Agent timed out after 30 minutes",
+            )
+        except Exception as e:
+            return AgentResult(
+                success=False, session_id=session_id, output="", error=str(e)
+            )
+
+    def _extract_session_id(self, output: str) -> Optional[str]:
+        """
+        Extract session/conversation ID from OpenCode output.
+
+        This allows subsequent calls to continue the same session.
+        """
+        # TODO: Implement based on OpenCode's actual output format
+        # Look for patterns like "Session: abc123" or similar
+        import re
+
+        match = re.search(
+            r"(?:session|conversation)[:\s]+([a-zA-Z0-9_-]+)", output, re.IGNORECASE
+        )
+        return match.group(1) if match else None

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/github_state.py

@@ -0,0 +1,247 @@
+import json
+import subprocess
+import re
+from typing import Optional
+from .states import StateData, IssueStep, STEP_STATUS_MESSAGES, STEP_LABELS
+
+
+class GitHubStateManager:
+    """
+    Manages issue state via GitHub comments and labels.
+
+    State is stored in a special comment with hidden JSON:
+    <!-- autopilot-state
+    {"step": "...", "branch": "...", ...}
+    -->
+    """
+
+    STATE_COMMENT_MARKER = "<!-- autopilot-state"
+
+    def __init__(self, repo: str):
+        """
+        Args:
+            repo: GitHub repo in "owner/repo" format
+        """
+        self.repo = repo
+
+    def load_state(self, issue_number: int) -> Optional[StateData]:
+        """
+        Load state from the autopilot comment on the issue.
+
+        Returns None if no state comment exists (new issue).
+        """
+        comment_id = self._find_state_comment_id(issue_number)
+        if not comment_id:
+            return None
+
+        comments = self._get_comments(issue_number)
+        for comment in comments:
+            if comment["id"] == comment_id:
+                return self._parse_state_from_comment(comment["body"])
+
+        return None
+
+    def save_state(
+        self, issue_number: int, state: StateData, message: Optional[str] = None
+    ) -> None:
+        """
+        Create or update the state comment on the issue.
+
+        Also updates the autopilot step label for visibility.
+
+        Args:
+            issue_number: The GitHub issue number
+            state: The state to persist
+            message: Optional custom status message (uses default if None)
+        """
+        if message is None:
+            message = STEP_STATUS_MESSAGES.get(state.step, "Processing...")
+
+        state_body = state.to_comment_body(message)
+        comment_id = self._find_state_comment_id(issue_number)
+
+        if comment_id:
+            self._update_comment(comment_id, state_body)
+        else:
+            self._create_comment(issue_number, state_body)
+
+        self._set_step_label(issue_number, state.step)
+
+    def transition(
+        self, issue_number: int, state: StateData, new_step: IssueStep, **updates
+    ) -> StateData:
+        """
+        Transition to a new step and persist.
+
+        Convenience method that updates step, applies any additional updates,
+        and saves to GitHub.
+
+        Args:
+            issue_number: The GitHub issue number
+            state: Current state
+            new_step: The step to transition to
+            **updates: Additional StateData fields to update (e.g., pr_number=123)
+
+        Returns:
+            Updated StateData
+        """
+        state.step = new_step
+        for key, value in updates.items():
+            if hasattr(state, key):
+                setattr(state, key, value)
+        self.save_state(issue_number, state)
+        return state
+
+    def add_progress_comment(self, issue_number: int, message: str) -> None:
+        """Add a regular (non-state) comment for progress updates."""
+        self._create_comment(issue_number, message)
+
+    def get_issue_details(self, issue_number: int) -> tuple[str, str]:
+        """
+        Fetch issue title and body.
+
+        Returns:
+            (title, body) tuple
+        """
+        result = self._run_gh(
+            [
+                "issue",
+                "view",
+                str(issue_number),
+                "--repo",
+                self.repo,
+                "--json",
+                "title,body",
+            ]
+        )
+
+        try:
+            data = json.loads(result)
+            return data.get("title", ""), data.get("body", "")
+        except json.JSONDecodeError:
+            return "", ""
+
+    def _find_state_comment_id(self, issue_number: int) -> Optional[int]:
+        """Find the comment ID of the state comment, if it exists."""
+        comments = self._get_comments(issue_number)
+        for comment in comments:
+            if self.STATE_COMMENT_MARKER in comment.get("body", ""):
+                return comment["id"]
+        return None
+
+    def _get_comments(self, issue_number: int) -> list[dict]:
+        """Get all comments on an issue."""
+        result = self._run_gh(
+            [
+                "issue",
+                "view",
+                str(issue_number),
+                "--repo",
+                self.repo,
+                "--json",
+                "comments",
+                "--jq",
+                ".comments[]",
+            ]
+        )
+
+        if not result.strip():
+            return []
+
+        try:
+            return json.loads("[" + result + "]")
+        except json.JSONDecodeError:
+            return []
+
+    def _create_comment(self, issue_number: int, body: str) -> None:
+        """Create a new comment on the issue."""
+        self._run_gh(
+            ["issue", "comment", str(issue_number), "--repo", self.repo, "--body", body]
+        )
+
+    def _update_comment(self, comment_id: int, body: str) -> None:
+        """Update an existing comment."""
+        self._run_gh(
+            [
+                "api",
+                f"repos/{self.repo}/issues/comments/{comment_id}",
+                "--method",
+                "PATCH",
+                "-f",
+                f"body={body}",
+            ]
+        )
+
+    def _parse_state_from_comment(self, body: str) -> Optional[StateData]:
+        """Extract StateData from a comment body containing hidden JSON."""
+        match = re.search(r"<!-- autopilot-state\s*\n({.*?})\s*\n-->", body, re.DOTALL)
+        if not match:
+            return None
+        try:
+            data = json.loads(match.group(1))
+            return StateData.from_dict(data)
+        except (json.JSONDecodeError, KeyError, TypeError):
+            return None
+
+    def _set_step_label(self, issue_number: int, step: IssueStep) -> None:
+        """
+        Update the autopilot step label.
+
+        Removes any existing autopilot:* step labels and adds the new one.
+        """
+        result = self._run_gh(
+            [
+                "issue",
+                "view",
+                str(issue_number),
+                "--repo",
+                self.repo,
+                "--json",
+                "labels",
+                "--jq",
+                ".labels[].name",
+            ]
+        )
+
+        current_labels = result.strip().split("\n") if result.strip() else []
+
+        for label in current_labels:
+            if label.startswith("autopilot:") and label in STEP_LABELS.values():
+                self._run_gh(
+                    [
+                        "issue",
+                        "edit",
+                        str(issue_number),
+                        "--repo",
+                        self.repo,
+                        "--remove-label",
+                        label,
+                    ]
+                )
+
+        if step in STEP_LABELS:
+            self._run_gh(
+                [
+                    "issue",
+                    "edit",
+                    str(issue_number),
+                    "--repo",
+                    self.repo,
+                    "--add-label",
+                    STEP_LABELS[step],
+                ]
+            )
+
+    def _run_gh(self, args: list[str]) -> str:
+        """Run a gh CLI command and return stdout."""
+        try:
+            result = subprocess.run(
+                ["gh"] + args, capture_output=True, text=True, check=True
+            )
+            return result.stdout
+        except subprocess.CalledProcessError as e:
+            if e.stderr:
+                raise RuntimeError(f"gh command failed: {e.stderr}") from e
+            raise RuntimeError(
+                f"gh command failed with exit code {e.returncode}"
+            ) from e