draft-board 0.1.0-beta.0

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

@@ -0,0 +1,87 @@
+"""Cursor AI IDE adapter."""
+
+import asyncio
+import os
+import shutil
+
+from app.executors.registry import ExecutorRegistry
+from app.executors.spec import (
+    ExecutionRequest,
+    ExecutionResult,
+    ExecutorAdapter,
+    ExecutorCapability,
+    ExecutorInvocationError,
+    ExecutorMetadata,
+    ExecutorNotFoundError,
+)
+
+
+@ExecutorRegistry.register("cursor")
+class CursorAdapter(ExecutorAdapter):
+    """Cursor AI IDE adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="cursor",
+            display_name="Cursor",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.INTERACTIVE,  # Opens IDE
+                ExecutorCapability.MCP_SERVERS,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "auto_apply": {
+                        "type": "boolean",
+                        "default": False,
+                        "description": "Auto-apply suggestions without confirmation",
+                    }
+                },
+            },
+            documentation_url="https://cursor.sh/",
+            author="Cursor",
+            license="Proprietary",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if cursor is installed."""
+        return shutil.which("cursor") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Cursor.
+
+        Note: Cursor is primarily interactive, so this opens the IDE
+        and requires human interaction to complete the task.
+        """
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Cursor not found. Install from https://cursor.sh/"
+            )
+
+        # Build command - opens Cursor in the working directory
+        cmd = ["cursor", request.working_directory]
+
+        # Note: Cursor doesn't have a headless mode for autonomous execution
+        # This will open the IDE and the human must complete the work
+
+        try:
+            await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, **request.environment},
+            )
+
+            # For Cursor, we just launch it and return immediately
+            # The actual work happens interactively
+
+            return ExecutionResult(
+                exit_code=0,
+                stdout=f"Opened Cursor in {request.working_directory}\\nPrompt: {request.prompt}",
+                stderr="",
+                metadata={"interactive": True, "requires_human": True},
+            )
+
+        except Exception as e:
+            raise ExecutorInvocationError(f"Cursor execution failed: {str(e)}")

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

@@ -0,0 +1,123 @@
+"""Droid 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("droid")
+class DroidAdapter(ExecutorAdapter):
+    """Droid CLI adapter for automated code changes."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="droid",
+            display_name="Droid CLI",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.YOLO_MODE,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "default",
+                        "description": "Model to use for Droid",
+                    }
+                },
+            },
+            documentation_url="https://github.com/anthropics/droid",
+            author="Anthropic",
+            license="MIT",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if droid CLI is installed."""
+        return shutil.which("droid") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Droid CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Droid CLI not found. Install from https://github.com/anthropics/droid"
+            )
+
+        cmd = ["droid", "--print"]
+
+        if request.yolo_mode:
+            cmd.append("--dangerously-skip-permissions")
+
+        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"Droid execution timed out after {request.timeout_seconds}s"
+            ) from None
+        except Exception as e:
+            raise ExecutorInvocationError(f"Droid 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("Droid CLI not found")
+
+        cmd = ["droid", "--print"]
+        if request.yolo_mode:
+            cmd.append("--dangerously-skip-permissions")
+
+        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},
+        )
+
+        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/gemini.py

@@ -0,0 +1,132 @@
+"""Google Gemini 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("gemini")
+class GeminiAdapter(ExecutorAdapter):
+    """Google Gemini CLI adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="gemini",
+            display_name="Google Gemini CLI",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.YOLO_MODE,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "gemini-2.0-flash",
+                        "enum": ["gemini-2.0-flash", "gemini-pro", "gemini-ultra"],
+                        "description": "Gemini model to use",
+                    },
+                    "sandbox": {
+                        "type": "string",
+                        "enum": ["docker", "local"],
+                        "default": "docker",
+                        "description": "Execution sandbox environment",
+                    },
+                },
+            },
+            documentation_url="https://github.com/google/gemini-cli",
+            author="Google",
+            license="Apache-2.0",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if gemini CLI is installed."""
+        return shutil.which("gemini") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Gemini CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Gemini CLI not found. Install from https://github.com/google/gemini-cli"
+            )
+
+        # Build command
+        cmd = ["gemini", "--print"]
+
+        if request.yolo_mode:
+            cmd.append("--yolo")
+
+        # Add model if specified
+        model = request.config.get("model", "gemini-2.0-flash")
+        cmd.extend(["--model", model])
+
+        # 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"Gemini execution timed out after {request.timeout_seconds}s"
+            )
+        except Exception as e:
+            raise ExecutorInvocationError(f"Gemini 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("Gemini CLI not found")
+
+        cmd = ["gemini", "--print"]
+        if request.yolo_mode:
+            cmd.append("--yolo")
+        cmd.extend(["--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/goose.py

@@ -0,0 +1,131 @@
+"""Goose 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("goose")
+class GooseAdapter(ExecutorAdapter):
+    """Goose AI assistant adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="goose",
+            display_name="Goose",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.SESSION_RESUME,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "gpt-4",
+                        "description": "LLM model to use",
+                    },
+                    "profile": {
+                        "type": "string",
+                        "description": "Goose profile to use",
+                    },
+                },
+            },
+            documentation_url="https://github.com/square/goose",
+            author="Square",
+            license="Apache-2.0",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if goose is installed."""
+        return shutil.which("goose") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Goose."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Goose not found. Install: pip install goose-ai"
+            )
+
+        # Build command
+        cmd = ["goose", "run"]
+
+        # Add session if provided
+        if request.session_id:
+            cmd.extend(["--session", request.session_id])
+
+        # Add profile if specified
+        profile = request.config.get("profile")
+        if profile:
+            cmd.extend(["--profile", profile])
+
+        # 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"),
+                session_id=request.session_id,  # Can be resumed
+                duration_seconds=0.0,
+            )
+
+        except TimeoutError:
+            process.kill()
+            raise ExecutorTimeoutError(
+                f"Goose execution timed out after {request.timeout_seconds}s"
+            )
+        except Exception as e:
+            raise ExecutorInvocationError(f"Goose 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("Goose not found")
+
+        cmd = ["goose", "run", request.prompt]
+        if request.session_id:
+            cmd.extend(["--session", request.session_id])
+
+        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/opencode.py

@@ -0,0 +1,123 @@
+"""OpenCode 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("opencode")
+class OpenCodeAdapter(ExecutorAdapter):
+    """OpenCode CLI adapter for automated code changes."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="opencode",
+            display_name="OpenCode CLI",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.YOLO_MODE,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "provider": {
+                        "type": "string",
+                        "default": "anthropic",
+                        "description": "LLM provider for OpenCode",
+                    }
+                },
+            },
+            documentation_url="https://github.com/opencode-ai/opencode",
+            author="OpenCode",
+            license="MIT",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if opencode CLI is installed."""
+        return shutil.which("opencode") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using OpenCode CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "OpenCode CLI not found. Install from https://github.com/opencode-ai/opencode"
+            )
+
+        cmd = ["opencode", "--print"]
+
+        if request.yolo_mode:
+            cmd.append("--yolo")
+
+        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"OpenCode execution timed out after {request.timeout_seconds}s"
+            ) from None
+        except Exception as e:
+            raise ExecutorInvocationError(f"OpenCode 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("OpenCode CLI not found")
+
+        cmd = ["opencode", "--print"]
+        if request.yolo_mode:
+            cmd.append("--yolo")
+
+        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},
+        )
+
+        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()