draft-board 0.1.0-beta.0

package/app/backend/app/executors/adapters/claude.py

@@ -0,0 +1,177 @@
+"""Claude Code CLI executor adapter."""
+
+import asyncio
+import os
+import shutil
+from collections.abc import AsyncIterator
+
+from app.executors.registry import ExecutorRegistry
+from app.executors.spec import (
+    ExecutionRequest,
+    ExecutionResult,
+    ExecutorAdapter,
+    ExecutorCapability,
+    ExecutorInvocationError,
+    ExecutorMetadata,
+    ExecutorNotFoundError,
+    ExecutorTimeoutError,
+)
+
+
+@ExecutorRegistry.register("claude")
+class ClaudeAdapter(ExecutorAdapter):
+    """Built-in Claude Code CLI adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="claude",
+            display_name="Claude Code",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.YOLO_MODE,
+                ExecutorCapability.MCP_SERVERS,
+                ExecutorCapability.COST_TRACKING,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "claude-sonnet-4-5",
+                        "description": "Claude model to use",
+                    },
+                    "mcp_config": {
+                        "type": "string",
+                        "description": "Path to MCP config file",
+                    },
+                },
+            },
+            documentation_url="https://docs.anthropic.com/claude-code",
+            author="Anthropic",
+            license="Proprietary",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if claude CLI is installed."""
+        return shutil.which("claude") is not None
+
+    async def check_availability(self) -> dict:
+        """Return detailed availability diagnostics."""
+        cli_path = shutil.which("claude")
+        issues = []
+        version = None
+
+        if not cli_path:
+            issues.append("Claude Code CLI not found in PATH")
+        else:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    "claude",
+                    "--version",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+                version = stdout.decode().strip()
+            except Exception:
+                issues.append("Could not detect Claude Code version")
+
+        return {
+            "available": cli_path is not None,
+            "cli_found": cli_path is not None,
+            "cli_path": cli_path,
+            "version": version,
+            "issues": issues,
+            "setup_instructions": self.get_setup_instructions(),
+        }
+
+    def get_setup_instructions(self) -> str:
+        return (
+            "## Install Claude Code\n\n"
+            "```bash\n"
+            "npm install -g @anthropic-ai/claude-code\n"
+            "```\n\n"
+            "Then authenticate:\n"
+            "```bash\n"
+            "claude auth login\n"
+            "```\n\n"
+            "Docs: https://docs.anthropic.com/claude-code"
+        )
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Claude Code CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Claude Code CLI not found. Install: npm install -g @anthropic-ai/claude-code"
+            )
+
+        # Build command
+        cmd = ["claude", "--print"]
+
+        if request.yolo_mode:
+            cmd.append("--dangerously-skip-permissions")
+
+        # Add MCP servers if configured
+        if request.mcp_servers:
+            for server in request.mcp_servers:
+                cmd.extend(["--mcp-server", server["name"]])
+
+        # Add the prompt
+        cmd.append(request.prompt)
+
+        # Execute
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                cwd=request.working_directory,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, **request.environment},
+            )
+
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), timeout=request.timeout_seconds
+            )
+
+            return ExecutionResult(
+                exit_code=process.returncode,
+                stdout=stdout.decode("utf-8", errors="replace"),
+                stderr=stderr.decode("utf-8", errors="replace"),
+                files_changed=[],  # TODO: Parse from output
+                duration_seconds=0.0,  # TODO: Track duration
+            )
+
+        except TimeoutError:
+            process.kill()
+            raise ExecutorTimeoutError(
+                f"Claude execution timed out after {request.timeout_seconds}s"
+            )
+        except Exception as e:
+            raise ExecutorInvocationError(f"Claude execution failed: {str(e)}")
+
+    async def stream_output(self, request: ExecutionRequest) -> AsyncIterator[str]:
+        """Stream output in real-time."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError("Claude Code CLI not found")
+
+        cmd = ["claude", "--print"]
+        if request.yolo_mode:
+            cmd.append("--dangerously-skip-permissions")
+        cmd.append(request.prompt)
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=request.working_directory,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            env={**os.environ, **request.environment},
+        )
+
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace")
+
+        await process.wait()

package/app/backend/app/executors/adapters/cline.py

@@ -0,0 +1,127 @@
+"""Cline AI assistant adapter."""
+
+import asyncio
+import os
+import shutil
+from collections.abc import AsyncIterator
+
+from app.executors.registry import ExecutorRegistry
+from app.executors.spec import (
+    ExecutionRequest,
+    ExecutionResult,
+    ExecutorAdapter,
+    ExecutorCapability,
+    ExecutorInvocationError,
+    ExecutorMetadata,
+    ExecutorNotFoundError,
+    ExecutorTimeoutError,
+)
+
+
+@ExecutorRegistry.register("cline")
+class ClineAdapter(ExecutorAdapter):
+    """Cline AI assistant adapter (VS Code extension CLI)."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="cline",
+            display_name="Cline",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "claude-3-5-sonnet-20241022",
+                        "description": "LLM model to use",
+                    },
+                    "api_provider": {
+                        "type": "string",
+                        "enum": ["anthropic", "openai", "bedrock"],
+                        "default": "anthropic",
+                        "description": "API provider",
+                    },
+                },
+            },
+            documentation_url="https://github.com/cline/cline",
+            author="Cline",
+            license="Apache-2.0",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if cline CLI is installed."""
+        return shutil.which("cline") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Cline."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Cline not found. Install the Cline VS Code extension with CLI support."
+            )
+
+        # Build command
+        cmd = ["cline", "execute"]
+
+        # Add model and provider
+        model = request.config.get("model", "claude-3-5-sonnet-20241022")
+        provider = request.config.get("api_provider", "anthropic")
+
+        cmd.extend(["--model", model])
+        cmd.extend(["--provider", provider])
+
+        # Add the prompt
+        cmd.extend(["--prompt", request.prompt])
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                cwd=request.working_directory,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, **request.environment},
+            )
+
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), timeout=request.timeout_seconds
+            )
+
+            return ExecutionResult(
+                exit_code=process.returncode,
+                stdout=stdout.decode("utf-8", errors="replace"),
+                stderr=stderr.decode("utf-8", errors="replace"),
+                duration_seconds=0.0,
+            )
+
+        except TimeoutError:
+            process.kill()
+            raise ExecutorTimeoutError(
+                f"Cline execution timed out after {request.timeout_seconds}s"
+            )
+        except Exception as e:
+            raise ExecutorInvocationError(f"Cline execution failed: {str(e)}")
+
+    async def stream_output(self, request: ExecutionRequest) -> AsyncIterator[str]:
+        """Stream output in real-time."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError("Cline not found")
+
+        cmd = ["cline", "execute", "--prompt", request.prompt]
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=request.working_directory,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            env={**os.environ, **request.environment},
+        )
+
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace")
+
+        await process.wait()

package/app/backend/app/executors/adapters/codex.py

@@ -0,0 +1,167 @@
+"""OpenAI Codex CLI adapter."""
+
+import asyncio
+import os
+import shutil
+from collections.abc import AsyncIterator
+
+from app.executors.registry import ExecutorRegistry
+from app.executors.spec import (
+    ExecutionRequest,
+    ExecutionResult,
+    ExecutorAdapter,
+    ExecutorCapability,
+    ExecutorInvocationError,
+    ExecutorMetadata,
+    ExecutorNotFoundError,
+    ExecutorTimeoutError,
+)
+
+
+@ExecutorRegistry.register("codex")
+class CodexAdapter(ExecutorAdapter):
+    """OpenAI Codex CLI adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="codex",
+            display_name="OpenAI Codex CLI",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.YOLO_MODE,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "o3",
+                        "description": "OpenAI model used by Codex",
+                    }
+                },
+            },
+            documentation_url="https://github.com/openai/codex",
+            author="OpenAI",
+            license="Apache-2.0",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if codex CLI is installed."""
+        return shutil.which("codex") is not None
+
+    async def check_availability(self) -> dict:
+        """Return detailed availability diagnostics."""
+        cli_path = shutil.which("codex")
+        issues = []
+        version = None
+
+        if not cli_path:
+            issues.append("Codex CLI not found in PATH")
+        else:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    "codex",
+                    "--version",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+                version = stdout.decode().strip()
+            except Exception:
+                issues.append("Could not detect Codex CLI version")
+
+        return {
+            "available": cli_path is not None,
+            "cli_found": cli_path is not None,
+            "cli_path": cli_path,
+            "version": version,
+            "issues": issues,
+            "setup_instructions": self.get_setup_instructions(),
+        }
+
+    def get_setup_instructions(self) -> str:
+        return (
+            "## Install OpenAI Codex CLI\n\n"
+            "```bash\n"
+            "npm install -g @openai/codex\n"
+            "```\n\n"
+            "Then authenticate:\n"
+            "```bash\n"
+            "export OPENAI_API_KEY=your-key\n"
+            "```\n\n"
+            "Docs: https://github.com/openai/codex"
+        )
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Codex CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Codex CLI not found. Install from https://github.com/openai/codex"
+            )
+
+        cmd = ["codex", "--print", "--auto-edit"]
+
+        if request.yolo_mode:
+            cmd.append("--full-auto")
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                cwd=request.working_directory,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, **request.environment},
+            )
+
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(input=request.prompt.encode("utf-8")),
+                timeout=request.timeout_seconds,
+            )
+
+            return ExecutionResult(
+                exit_code=process.returncode,
+                stdout=stdout.decode("utf-8", errors="replace"),
+                stderr=stderr.decode("utf-8", errors="replace"),
+                duration_seconds=0.0,
+            )
+
+        except TimeoutError:
+            process.kill()
+            raise ExecutorTimeoutError(
+                f"Codex execution timed out after {request.timeout_seconds}s"
+            ) from None
+        except Exception as e:
+            raise ExecutorInvocationError(f"Codex execution failed: {e!s}") from e
+
+    async def stream_output(self, request: ExecutionRequest) -> AsyncIterator[str]:
+        """Stream output in real-time."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError("Codex CLI not found")
+
+        cmd = ["codex", "--print", "--auto-edit"]
+        if request.yolo_mode:
+            cmd.append("--full-auto")
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=request.working_directory,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            env={**os.environ, **request.environment},
+        )
+
+        # Send prompt via stdin then close
+        process.stdin.write(request.prompt.encode("utf-8"))
+        await process.stdin.drain()
+        process.stdin.close()
+
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace")
+
+        await process.wait()

package/app/backend/app/executors/adapters/copilot.py

@@ -0,0 +1,202 @@
+"""GitHub Copilot CLI adapter."""
+
+import asyncio
+import os
+import shutil
+from collections.abc import AsyncIterator
+
+from app.executors.registry import ExecutorRegistry
+from app.executors.spec import (
+    ExecutionRequest,
+    ExecutionResult,
+    ExecutorAdapter,
+    ExecutorCapability,
+    ExecutorInvocationError,
+    ExecutorMetadata,
+    ExecutorNotFoundError,
+    ExecutorTimeoutError,
+)
+
+
+@ExecutorRegistry.register("copilot")
+class CopilotAdapter(ExecutorAdapter):
+    """GitHub Copilot CLI adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="copilot",
+            display_name="GitHub Copilot CLI",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "gpt-4",
+                        "description": "OpenAI model used by Copilot",
+                    }
+                },
+            },
+            documentation_url="https://githubnext.com/projects/copilot-cli/",
+            author="GitHub",
+            license="Proprietary",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if copilot CLI is installed."""
+        # GitHub Copilot CLI is accessed via `gh copilot` or dedicated `copilot` command
+        has_gh = shutil.which("gh") is not None
+        has_copilot = shutil.which("copilot") is not None
+
+        if has_gh:
+            # Check if copilot extension is installed
+            try:
+                process = await asyncio.create_subprocess_exec(
+                    "gh",
+                    "extension",
+                    "list",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, _ = await process.communicate()
+                return b"copilot" in stdout.lower()
+            except Exception:
+                return False
+
+        return has_copilot
+
+    async def check_availability(self) -> dict:
+        """Return detailed availability diagnostics."""
+        has_gh = shutil.which("gh")
+        has_copilot_cli = shutil.which("copilot")
+        issues = []
+        version = None
+        copilot_ext_installed = False
+
+        if not has_gh and not has_copilot_cli:
+            issues.append("Neither 'gh' CLI nor 'copilot' CLI found in PATH")
+        elif has_gh:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    "gh",
+                    "extension",
+                    "list",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+                if b"copilot" in stdout.lower():
+                    copilot_ext_installed = True
+                else:
+                    issues.append("GitHub Copilot extension not installed in gh CLI")
+            except Exception:
+                issues.append("Could not check gh extensions")
+
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    "gh",
+                    "--version",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+                version = stdout.decode().strip().split("\n")[0]
+            except Exception:
+                pass
+
+        return {
+            "available": copilot_ext_installed or has_copilot_cli is not None,
+            "cli_found": has_gh is not None or has_copilot_cli is not None,
+            "cli_path": has_gh or has_copilot_cli,
+            "version": version,
+            "copilot_extension_installed": copilot_ext_installed,
+            "issues": issues,
+            "setup_instructions": self.get_setup_instructions(),
+        }
+
+    def get_setup_instructions(self) -> str:
+        return (
+            "## Install GitHub Copilot CLI\n\n"
+            "1. Install the GitHub CLI:\n"
+            "```bash\n"
+            "brew install gh  # macOS\n"
+            "```\n\n"
+            "2. Install the Copilot extension:\n"
+            "```bash\n"
+            "gh extension install github/gh-copilot\n"
+            "```\n\n"
+            "Docs: https://githubnext.com/projects/copilot-cli/"
+        )
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using GitHub Copilot CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "GitHub Copilot CLI not found. Install: gh extension install github/gh-copilot"
+            )
+
+        # Determine command structure
+        if shutil.which("gh"):
+            cmd = ["gh", "copilot", "suggest"]
+        else:
+            cmd = ["copilot", "suggest"]
+
+        # Add the prompt
+        cmd.append(request.prompt)
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                cwd=request.working_directory,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, **request.environment},
+            )
+
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), timeout=request.timeout_seconds
+            )
+
+            return ExecutionResult(
+                exit_code=process.returncode,
+                stdout=stdout.decode("utf-8", errors="replace"),
+                stderr=stderr.decode("utf-8", errors="replace"),
+                duration_seconds=0.0,
+            )
+
+        except TimeoutError:
+            process.kill()
+            raise ExecutorTimeoutError(
+                f"Copilot execution timed out after {request.timeout_seconds}s"
+            ) from None
+        except Exception as e:
+            raise ExecutorInvocationError(f"Copilot execution failed: {str(e)}") from e
+
+    async def stream_output(self, request: ExecutionRequest) -> AsyncIterator[str]:
+        """Stream output in real-time."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError("GitHub Copilot CLI not found")
+
+        if shutil.which("gh"):
+            cmd = ["gh", "copilot", "suggest", request.prompt]
+        else:
+            cmd = ["copilot", "suggest", request.prompt]
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=request.working_directory,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            env={**os.environ, **request.environment},
+        )
+
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace")
+
+        await process.wait()