draft-board 0.1.0-beta.0

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

@@ -0,0 +1,123 @@
+"""Qwen 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("qwen")
+class QwenAdapter(ExecutorAdapter):
+    """Qwen Code CLI adapter for automated code changes."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="qwen",
+            display_name="Qwen Code CLI",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.YOLO_MODE,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "qwen-coder",
+                        "description": "Qwen model to use",
+                    }
+                },
+            },
+            documentation_url="https://github.com/QwenLM/qwen-agent",
+            author="Alibaba Cloud",
+            license="Apache-2.0",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if qwen CLI is installed."""
+        return shutil.which("qwen") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Qwen CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Qwen CLI not found. Install from https://github.com/QwenLM/qwen-agent"
+            )
+
+        cmd = ["qwen", "--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"Qwen execution timed out after {request.timeout_seconds}s"
+            ) from None
+        except Exception as e:
+            raise ExecutorInvocationError(f"Qwen 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("Qwen CLI not found")
+
+        cmd = ["qwen", "--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()

package/app/backend/app/executors/plugins/__init__.py

@@ -0,0 +1 @@
+"""Community/third-party executor plugins."""

package/app/backend/app/executors/registry.py

@@ -0,0 +1,202 @@
+"""Executor plugin registry with dynamic loading."""
+
+import importlib
+import logging
+import pkgutil
+from pathlib import Path
+
+from app.executors.spec import ExecutorAdapter, ExecutorMetadata, ExecutorNotFoundError
+
+logger = logging.getLogger(__name__)
+
+
+class ExecutorRegistry:
+    """Registry for executor plugins with dynamic loading."""
+
+    _adapters: dict[str, type[ExecutorAdapter]] = {}
+    _instances: dict[str, ExecutorAdapter] = {}
+    _loaded: bool = False
+
+    @classmethod
+    def register(cls, name: str):
+        """Decorator to register an executor adapter.
+
+        Usage:
+            @ExecutorRegistry.register("claude")
+            class ClaudeAdapter(ExecutorAdapter):
+                ...
+        """
+
+        def decorator(adapter_class: type[ExecutorAdapter]):
+            if name in cls._adapters:
+                logger.warning(f"Overwriting existing executor adapter: {name}")
+            cls._adapters[name] = adapter_class
+            logger.info(f"Registered executor adapter: {name}")
+            return adapter_class
+
+        return decorator
+
+    @classmethod
+    def get(cls, name: str) -> ExecutorAdapter:
+        """Get an executor adapter instance by name.
+
+        Args:
+            name: Executor name (e.g., "claude", "cursor")
+
+        Returns:
+            ExecutorAdapter instance
+
+        Raises:
+            ExecutorNotFoundError: If executor not registered
+        """
+        # Ensure plugins are loaded
+        if not cls._loaded:
+            cls.load_all_plugins()
+
+        if name not in cls._adapters:
+            raise ExecutorNotFoundError(
+                f"Unknown executor: {name}. Available: {list(cls._adapters.keys())}"
+            )
+
+        # Return cached instance or create new
+        if name not in cls._instances:
+            cls._instances[name] = cls._adapters[name]()
+
+        return cls._instances[name]
+
+    @classmethod
+    async def get_available(cls) -> list[ExecutorMetadata]:
+        """List all available executors (installed and accessible).
+
+        Returns:
+            List of ExecutorMetadata for available executors
+        """
+        if not cls._loaded:
+            cls.load_all_plugins()
+
+        available = []
+        for name, _adapter_class in cls._adapters.items():
+            try:
+                adapter = cls.get(name)
+                if await adapter.is_available():
+                    available.append(adapter.get_metadata())
+            except Exception as e:
+                logger.warning(f"Failed to check availability of {name}: {e}")
+
+        return available
+
+    @classmethod
+    def list_all(cls) -> list[ExecutorMetadata]:
+        """List all registered executors (may not be installed).
+
+        Returns:
+            List of ExecutorMetadata for all registered executors
+        """
+        if not cls._loaded:
+            cls.load_all_plugins()
+
+        all_executors = []
+        for name, _adapter_class in cls._adapters.items():
+            try:
+                adapter = cls.get(name)
+                all_executors.append(adapter.get_metadata())
+            except Exception as e:
+                logger.warning(f"Failed to get metadata for {name}: {e}")
+
+        return all_executors
+
+    @classmethod
+    def load_all_plugins(cls):
+        """Load all executor plugins from adapters and plugins directories."""
+        if cls._loaded:
+            return
+
+        logger.info("Loading executor plugins...")
+
+        # Load built-in adapters
+        cls._load_plugins_from_package("app.executors.adapters")
+
+        # Load community plugins
+        cls._load_plugins_from_package("app.executors.plugins")
+
+        cls._loaded = True
+        logger.info(f"Loaded {len(cls._adapters)} executor plugins")
+
+    @classmethod
+    def _load_plugins_from_package(cls, package_name: str):
+        """Load all Python modules from a package.
+
+        Args:
+            package_name: Package name (e.g., "app.executors.adapters")
+        """
+        try:
+            package = importlib.import_module(package_name)
+            package_path = Path(package.__file__).parent
+
+            for _finder, name, _ispkg in pkgutil.iter_modules([str(package_path)]):
+                if name.startswith("_"):
+                    continue
+
+                module_name = f"{package_name}.{name}"
+                try:
+                    importlib.import_module(module_name)
+                    logger.debug(f"Loaded plugin module: {module_name}")
+                except Exception as e:
+                    logger.error(f"Failed to load plugin {module_name}: {e}")
+
+        except ImportError as e:
+            logger.warning(f"Package {package_name} not found: {e}")
+
+    @classmethod
+    def reload_plugins(cls):
+        """Reload all plugins (useful for development)."""
+        cls._adapters.clear()
+        cls._instances.clear()
+        cls._loaded = False
+        cls.load_all_plugins()
+
+    @classmethod
+    def unregister(cls, name: str):
+        """Unregister an executor adapter.
+
+        Args:
+            name: Executor name to unregister
+        """
+        if name in cls._adapters:
+            del cls._adapters[name]
+        if name in cls._instances:
+            del cls._instances[name]
+        logger.info(f"Unregistered executor adapter: {name}")
+
+
+# Convenience functions
+
+
+def get_executor(name: str) -> ExecutorAdapter:
+    """Get an executor adapter by name.
+
+    Args:
+        name: Executor name
+
+    Returns:
+        ExecutorAdapter instance
+    """
+    return ExecutorRegistry.get(name)
+
+
+async def list_available_executors() -> list[ExecutorMetadata]:
+    """List all available executors.
+
+    Returns:
+        List of ExecutorMetadata
+    """
+    return await ExecutorRegistry.get_available()
+
+
+def list_all_executors() -> list[ExecutorMetadata]:
+    """List all registered executors.
+
+    Returns:
+        List of ExecutorMetadata
+    """
+    return ExecutorRegistry.list_all()

package/app/backend/app/executors/spec.py

@@ -0,0 +1,226 @@
+"""
+Draft Executor Adapter Specification v1.0
+
+This defines the interface for adding new AI coding agents to Draft.
+Implement this interface to create a new executor plugin.
+"""
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+
+class ExecutorCapability(StrEnum):
+    """Capabilities an executor may support."""
+
+    STREAMING_OUTPUT = "streaming_output"  # Real-time stdout
+    SESSION_RESUME = "session_resume"  # Continue previous sessions
+    YOLO_MODE = "yolo_mode"  # Auto-approve all actions
+    MCP_SERVERS = "mcp_servers"  # Model Context Protocol
+    COST_TRACKING = "cost_tracking"  # Token/cost reporting
+    INTERACTIVE = "interactive"  # Requires human interaction
+
+
+@dataclass
+class ExecutorMetadata:
+    """Metadata about an executor."""
+
+    name: str  # e.g., "claude", "codex"
+    display_name: str  # e.g., "Claude Code", "OpenAI Codex"
+    version: str  # Executor adapter version
+    agent_version: str | None = None  # Underlying agent version if detectable
+    capabilities: list[ExecutorCapability] = field(default_factory=list)
+    config_schema: dict = field(default_factory=dict)  # JSON Schema for configuration
+    documentation_url: str | None = None
+    author: str | None = None  # Plugin author
+    license: str | None = None  # Plugin license
+
+
+@dataclass
+class ExecutionRequest:
+    """Request to execute a task."""
+
+    prompt: str
+    working_directory: str
+    timeout_seconds: int = 600
+    yolo_mode: bool = False
+    session_id: str | None = None  # For session resume
+    environment: dict[str, str] = field(default_factory=dict)  # Additional env vars
+    mcp_servers: list[dict] = field(default_factory=list)  # MCP server configs
+    config: dict[str, any] = field(default_factory=dict)  # Executor-specific config
+
+
+@dataclass
+class ExecutionResult:
+    """Result of an execution."""
+
+    exit_code: int
+    stdout: str
+    stderr: str
+    session_id: str | None = None  # For future resume
+    files_changed: list[str] = field(default_factory=list)
+    cost_usd: float | None = None
+    tokens_used: dict[str, int] | None = None  # {"input": X, "output": Y}
+    duration_seconds: float = 0.0
+    metadata: dict[str, any] = field(default_factory=dict)  # Executor-specific data
+
+
+class ExecutorAdapter(ABC):
+    """
+    Abstract base class for executor adapters.
+
+    Implement this to add a new AI coding agent to Draft.
+    """
+
+    @abstractmethod
+    def get_metadata(self) -> ExecutorMetadata:
+        """Return metadata about this executor.
+
+        Returns:
+            ExecutorMetadata with name, capabilities, etc.
+        """
+        pass
+
+    @abstractmethod
+    async def is_available(self) -> bool:
+        """Check if the underlying agent is installed and accessible.
+
+        Returns:
+            True if executor can be used, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute a task and return the result.
+
+        Args:
+            request: ExecutionRequest with prompt, working directory, etc.
+
+        Returns:
+            ExecutionResult with exit code, stdout, stderr, etc.
+
+        Raises:
+            ExecutorError: If execution fails
+        """
+        pass
+
+    async def stream_output(self, request: ExecutionRequest) -> AsyncIterator[str]:
+        """
+        Stream output in real-time. Optional - implement if your agent supports it.
+
+        Default implementation runs execute() and yields all output at once.
+
+        Args:
+            request: ExecutionRequest
+
+        Yields:
+            str: Output lines as they're produced
+        """
+        result = await self.execute(request)
+        yield result.stdout
+        if result.stderr:
+            yield result.stderr
+
+    def get_mcp_config_path(self) -> str | None:
+        """Return the path to this agent's MCP config file, if applicable.
+
+        Returns:
+            Path to MCP config or None
+        """
+        return None
+
+    def supports_capability(self, capability: ExecutorCapability) -> bool:
+        """Check if this executor supports a capability.
+
+        Args:
+            capability: ExecutorCapability to check
+
+        Returns:
+            True if supported
+        """
+        metadata = self.get_metadata()
+        return capability in metadata.capabilities
+
+    async def check_availability(self) -> dict[str, any]:
+        """Return detailed availability diagnostics.
+
+        Returns:
+            Dict with keys:
+              - available (bool): Whether executor is ready
+              - cli_found (bool): Whether CLI binary was found
+              - version (str|None): Detected CLI version
+              - issues (list[str]): Problems preventing use
+              - setup_instructions (str): How to install/configure
+
+        Default implementation delegates to is_available().
+        Override for richer diagnostics.
+        """
+        available = await self.is_available()
+        metadata = self.get_metadata()
+        return {
+            "available": available,
+            "cli_found": available,
+            "version": metadata.agent_version,
+            "issues": [] if available else ["CLI not found in PATH"],
+            "setup_instructions": self.get_setup_instructions(),
+        }
+
+    def get_setup_instructions(self) -> str:
+        """Return human-readable setup instructions for this executor.
+
+        Returns:
+            Markdown-formatted setup guide.
+        """
+        metadata = self.get_metadata()
+        url = metadata.documentation_url or ""
+        return (
+            f"Install {metadata.display_name}. See {url}"
+            if url
+            else f"Install {metadata.display_name}."
+        )
+
+    async def validate_config(self, config: dict) -> bool:
+        """Validate executor-specific configuration.
+
+        Args:
+            config: Configuration dict to validate
+
+        Returns:
+            True if valid
+
+        Raises:
+            ValueError: If config is invalid
+        """
+        # Default: no validation
+        return True
+
+
+class ExecutorError(Exception):
+    """Base exception for executor errors."""
+
+    pass
+
+
+class ExecutorNotFoundError(ExecutorError):
+    """Raised when executor CLI is not found."""
+
+    pass
+
+
+class ExecutorInvocationError(ExecutorError):
+    """Raised when executor CLI invocation fails."""
+
+    def __init__(
+        self, message: str, exit_code: int | None = None, stderr: str | None = None
+    ):
+        super().__init__(message)
+        self.exit_code = exit_code
+        self.stderr = stderr
+
+
+class ExecutorTimeoutError(ExecutorError):
+    """Raised when executor execution times out."""
+
+    pass