autopilot-code 0.6.0 → 0.7.0

package/package.json

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

package/scripts/issue_runner/agents/__init__.py

@@ -1,4 +1,32 @@
 from .base import BaseAgent, AgentResult
 from .opencode import OpenCodeAgent
+from .claude import ClaudeCodeAgent
 
-__all__ = ["BaseAgent", "AgentResult", "OpenCodeAgent"]
+__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