autopilot-code 0.5.0 → 0.7.0

package/package.json

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

package/scripts/issue_runner/agents/__init__.py

@@ -1,3 +1,32 @@
 from .base import BaseAgent, AgentResult
+from .opencode import OpenCodeAgent
+from .claude import ClaudeCodeAgent
 
-__all__ = ["BaseAgent", "AgentResult"]
+__all__ = ["BaseAgent", "AgentResult", "OpenCodeAgent", "ClaudeCodeAgent"]
+
+
+def get_agent(agent_type: str, config: dict) -> BaseAgent:
+    """
+    Factory function to create the appropriate agent.
+
+    Args:
+        agent_type: "opencode" or "claude"
+        config: Agent configuration from autopilot.json
+
+    Returns:
+        Configured agent instance
+
+    Raises:
+        ValueError: If agent_type is unknown
+    """
+    agents = {
+        "opencode": OpenCodeAgent,
+        "claude": ClaudeCodeAgent,
+    }
+
+    if agent_type not in agents:
+        raise ValueError(
+            f"Unknown agent type: {agent_type}. Available: {list(agents.keys())}"
+        )
+
+    return agents[agent_type](config)

package/scripts/issue_runner/agents/claude.py

@@ -0,0 +1,157 @@
+import subprocess
+import shutil
+import os
+from pathlib import Path
+from typing import Optional
+
+from .base import BaseAgent, AgentResult
+
+
+class ClaudeCodeAgent(BaseAgent):
+    """
+    Agent implementation for Claude Code CLI (Anthropic's official CLI).
+
+    Claude Code is invoked via: claude [options] "<prompt>"
+
+    Session support: Claude Code supports --resume <session_id> to continue sessions.
+    Sessions maintain full conversation history and context.
+    """
+
+    @property
+    def name(self) -> str:
+        return "Claude Code"
+
+    @property
+    def supports_sessions(self) -> bool:
+        return True  # Claude Code supports --resume
+
+    def find_binary(self) -> str:
+        """
+        Locate the claude binary.
+
+        Search order:
+        1. agentPath from config
+        2. PATH
+        3. Common npm global locations
+        4. Homebrew location (macOS)
+        """
+        # 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("claude")
+        if which_result:
+            return which_result
+
+        # 3. Common locations
+        home = Path.home()
+        common_paths = [
+            home / ".local" / "bin" / "claude",
+            Path("/usr/local/bin/claude"),
+            home / ".npm-global" / "bin" / "claude",
+            Path("/opt/homebrew/bin/claude"),  # macOS Homebrew
+        ]
+
+        # Also check nvm locations
+        nvm_dir = home / ".nvm" / "versions" / "node"
+        if nvm_dir.exists():
+            for node_dir in nvm_dir.iterdir():
+                claude_path = node_dir / "bin" / "claude"
+                if claude_path.exists() and os.access(claude_path, os.X_OK):
+                    return str(claude_path)
+
+        for path in common_paths:
+            if path.exists() and os.access(path, os.X_OK):
+                return str(path)
+
+        raise FileNotFoundError(
+            "claude not found. Install via 'npm install -g @anthropic-ai/claude-code' "
+            "or set 'agentPath' in autopilot.json."
+        )
+
+    def run(
+        self, worktree: Path, prompt: str, session_id: Optional[str] = None
+    ) -> AgentResult:
+        """
+        Run Claude Code with the given prompt.
+
+        Args:
+            worktree: Working directory for the agent
+            prompt: The task/prompt
+            session_id: Previous session ID to resume (if any)
+
+        Returns:
+            AgentResult with session_id for future continuation
+        """
+        cmd = [self.binary_path]
+
+        # Add session resume if we have a previous session
+        if session_id and self.supports_sessions:
+            cmd.extend(["--resume", session_id])
+
+        # Add print mode for non-interactive execution
+        cmd.extend(["--print", "--dangerously-skip-permissions"])
+
+        # Add the prompt
+        cmd.extend(["-p", prompt])
+
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=worktree,
+                capture_output=True,
+                text=True,
+                timeout=1800,  # 30 minute timeout
+                env={**os.environ, "CLAUDE_CODE_HEADLESS": "1"},
+            )
+
+            # Extract session ID from output
+            # Claude Code outputs the session ID which we can capture
+            new_session_id = (
+                self._extract_session_id(result.stdout, result.stderr) 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, stdout: str, stderr: str) -> Optional[str]:
+        """
+        Extract session ID from Claude Code output.
+
+        Claude Code outputs session information that we can parse to get
+        the session ID for future --resume calls.
+        """
+        import re
+
+        # Check both stdout and stderr for session info
+        for output in [stdout, stderr]:
+            # Look for session ID patterns
+            # Claude Code may output something like "Session ID: abc123" or similar
+            patterns = [
+                r"session[_\s]?id[:\s]+([a-zA-Z0-9_-]+)",
+                r"resume[:\s]+([a-zA-Z0-9_-]+)",
+                r"--resume\s+([a-zA-Z0-9_-]+)",
+            ]
+            for pattern in patterns:
+                match = re.search(pattern, output, re.IGNORECASE)
+                if match:
+                    return match.group(1)
+
+        return None

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/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