draft-board 0.1.0-beta.0

package/app/backend/app/dependencies/auth.py

@@ -0,0 +1,80 @@
+"""Auth dependency: extract current user from JWT Bearer token.
+
+When AUTH_ENABLED=false (the default for existing single-user setups),
+all auth dependencies return None so existing routes keep working unchanged.
+"""
+
+import os
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models.user import User
+from app.services.auth_service import decode_access_token, get_user_by_id
+
+AUTH_ENABLED = os.getenv("AUTH_ENABLED", "false").lower() in ("true", "1", "yes")
+
+# auto_error=False so the dependency doesn't 403 when no header is present
+_bearer_scheme = HTTPBearer(auto_error=False)
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials | None = Depends(_bearer_scheme),
+    db: AsyncSession = Depends(get_db),
+) -> User | None:
+    """Return the authenticated User, or None when auth is disabled.
+
+    When AUTH_ENABLED=true:
+      - Missing/invalid token -> 401
+      - Valid token -> User object
+
+    When AUTH_ENABLED=false:
+      - Always returns None (backward compatible, no login needed)
+    """
+    if not AUTH_ENABLED:
+        return None
+
+    if credentials is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authentication required",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    payload = decode_access_token(credentials.credentials)
+    if payload is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    user = await get_user_by_id(db, payload["sub"])
+    if user is None or not user.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="User not found or inactive",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    return user
+
+
+async def get_optional_user(
+    credentials: HTTPAuthorizationCredentials | None = Depends(_bearer_scheme),
+    db: AsyncSession = Depends(get_db),
+) -> User | None:
+    """Like get_current_user but never raises 401 — always returns User or None."""
+    if credentials is None:
+        return None
+
+    payload = decode_access_token(credentials.credentials)
+    if payload is None:
+        return None
+
+    user = await get_user_by_id(db, payload["sub"])
+    if user is None or not user.is_active:
+        return None
+    return user

package/app/backend/app/dependencies.py

@@ -0,0 +1,43 @@
+"""Reusable FastAPI dependencies for validation and DI."""
+
+from typing import Annotated
+
+from fastapi import Path
+
+from app.utils.validators import validate_uuid
+
+
+def ValidatedUUID(field_name: str):
+    """Create an annotated type for UUID path parameter validation.
+
+    Creates a type annotation that validates UUID format and returns the normalized UUID string.
+
+    Usage:
+        @router.get("/{ticket_id}")
+        async def get_ticket(
+            ticket_id: Annotated[str, ValidatedUUID("ticket_id")],
+            db: AsyncSession = Depends(get_db),
+        ):
+            # ticket_id is guaranteed to be a valid UUID
+
+    Args:
+        field_name: Name of the field for error messages (e.g., "ticket_id")
+
+    Returns:
+        A Path dependency that validates and returns the UUID
+    """
+
+    def validator(value: str) -> str:
+        return validate_uuid(value, field_name)
+
+    return Path(..., description=f"Valid UUID for {field_name}")
+
+
+# Type aliases for common ID types - use with Annotated
+# Example: ticket_id: TicketID
+TicketID = Annotated[str, Path(..., description="Valid UUID for ticket_id")]
+JobID = Annotated[str, Path(..., description="Valid UUID for job_id")]
+GoalID = Annotated[str, Path(..., description="Valid UUID for goal_id")]
+BoardID = Annotated[str, Path(..., description="Valid UUID for board_id")]
+RevisionID = Annotated[str, Path(..., description="Valid UUID for revision_id")]
+EvidenceID = Annotated[str, Path(..., description="Valid UUID for evidence_id")]

package/app/backend/app/exceptions.py

@@ -0,0 +1,178 @@
+"""Custom exceptions for Draft."""
+
+
+class DraftError(Exception):
+    """Base exception for Draft."""
+
+    pass
+
+
+class InvalidStateTransitionError(DraftError):
+    """Raised when an invalid state transition is attempted."""
+
+    def __init__(self, from_state: str, to_state: str, message: str | None = None):
+        self.from_state = from_state
+        self.to_state = to_state
+        self.message = (
+            message or f"Invalid transition from '{from_state}' to '{to_state}'"
+        )
+        super().__init__(self.message)
+
+
+class ResourceNotFoundError(DraftError):
+    """Raised when a requested resource is not found."""
+
+    def __init__(self, resource_type: str, resource_id: str):
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+        self.message = f"{resource_type} with id '{resource_id}' not found"
+        super().__init__(self.message)
+
+
+class ValidationError(DraftError):
+    """Raised when validation fails."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class ConflictError(DraftError):
+    """Raised when an operation conflicts with current resource state.
+
+    Typically maps to HTTP 409 Conflict.
+    Example: Attempting to comment on a superseded revision.
+    """
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class WorkspaceError(DraftError):
+    """Base exception for workspace-related errors."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class NotAGitRepositoryError(WorkspaceError):
+    """Raised when the configured path is not a git repository."""
+
+    def __init__(self, path: str):
+        self.path = path
+        super().__init__(f"Repository at '{path}' is not a git repository")
+
+
+class WorktreeCreationError(WorkspaceError):
+    """Raised when worktree creation fails."""
+
+    def __init__(self, message: str, git_error: str | None = None):
+        self.git_error = git_error
+        full_message = message
+        if git_error:
+            full_message = f"{message}: {git_error}"
+        super().__init__(full_message)
+
+
+class BranchNotFoundError(WorkspaceError):
+    """Raised when the base branch is not found."""
+
+    def __init__(self, branch: str):
+        self.branch = branch
+        super().__init__(f"Base branch '{branch}' not found in repository")
+
+
+class ExecutorError(DraftError):
+    """Base exception for executor-related errors."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class ExecutorNotFoundError(ExecutorError):
+    """Raised when no supported code executor CLI is found."""
+
+    def __init__(self, message: str | None = None):
+        default_message = (
+            "No supported code executor CLI found. "
+            "Please install Cursor CLI or Claude Code CLI."
+        )
+        super().__init__(message or default_message)
+
+
+class ExecutorInvocationError(ExecutorError):
+    """Raised when the executor CLI invocation fails."""
+
+    def __init__(
+        self,
+        message: str,
+        exit_code: int | None = None,
+        stderr: str | None = None,
+    ):
+        self.exit_code = exit_code
+        self.stderr = stderr
+        full_message = message
+        if exit_code is not None:
+            full_message = f"{message} (exit code: {exit_code})"
+        if stderr:
+            full_message = f"{full_message}\nError output: {stderr}"
+        super().__init__(full_message)
+
+
+class ConfigurationError(DraftError):
+    """Raised when required configuration is missing or invalid."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class PlannerError(DraftError):
+    """Base exception for planner-related errors."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class LLMAPIError(PlannerError):
+    """Raised when an LLM API call fails."""
+
+    def __init__(self, message: str, provider: str, status_code: int | None = None):
+        self.provider = provider
+        self.status_code = status_code
+        full_message = f"[{provider}] {message}"
+        if status_code:
+            full_message = f"{full_message} (status: {status_code})"
+        super().__init__(full_message)
+
+
+class LLMTimeoutError(LLMAPIError):
+    """Raised when an LLM API call times out."""
+
+    def __init__(self, provider: str, timeout_seconds: int):
+        self.timeout_seconds = timeout_seconds
+        message = f"LLM API call timed out after {timeout_seconds} seconds"
+        super().__init__(message, provider)
+
+
+class UDARAgentError(PlannerError):
+    """Base exception for UDAR agent errors."""
+
+    def __init__(self, message: str, phase: str | None = None):
+        self.phase = phase
+        full_message = message
+        if phase:
+            full_message = f"[{phase} phase] {message}"
+        super().__init__(full_message)
+
+
+class ToolExecutionError(UDARAgentError):
+    """Raised when a UDAR tool execution fails."""
+
+    def __init__(self, tool_name: str, message: str, phase: str | None = None):
+        self.tool_name = tool_name
+        super().__init__(f"Tool '{tool_name}' failed: {message}", phase)

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

@@ -0,0 +1 @@
+"""Executor plugin system for Draft."""

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

@@ -0,0 +1 @@
+"""Built-in executor adapters."""

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

@@ -0,0 +1,152 @@
+"""Aider AI coding 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("aider")
+class AiderAdapter(ExecutorAdapter):
+    """Aider AI coding assistant adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="aider",
+            display_name="Aider",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+                ExecutorCapability.SESSION_RESUME,
+                ExecutorCapability.COST_TRACKING,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "model": {
+                        "type": "string",
+                        "default": "gpt-4",
+                        "description": "LLM model to use",
+                    },
+                    "edit_format": {
+                        "type": "string",
+                        "enum": ["diff", "whole"],
+                        "default": "diff",
+                        "description": "Edit format (diff or whole file)",
+                    },
+                    "auto_commits": {
+                        "type": "boolean",
+                        "default": True,
+                        "description": "Auto-commit changes",
+                    },
+                },
+            },
+            documentation_url="https://aider.chat/docs/",
+            author="Aider Project",
+            license="Apache-2.0",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if aider is installed."""
+        return shutil.which("aider") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Aider."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Aider not found. Install: pip install aider-chat"
+            )
+
+        # Build command
+        cmd = [
+            "aider",
+            "--yes",  # Auto-confirm
+            "--no-git",  # We handle git ourselves
+            "--message",
+            request.prompt,
+        ]
+
+        # Add session resume if provided
+        if request.session_id:
+            cmd.extend(["--restore-chat-history", request.session_id])
+
+        # Add model config
+        model = request.config.get("model", "gpt-4")
+        cmd.extend(["--model", model])
+
+        # 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=self._parse_changed_files(stdout.decode()),
+                duration_seconds=0.0,
+            )
+
+        except TimeoutError:
+            process.kill()
+            raise ExecutorTimeoutError(
+                f"Aider execution timed out after {request.timeout_seconds}s"
+            )
+        except Exception as e:
+            raise ExecutorInvocationError(f"Aider 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("Aider not found")
+
+        cmd = ["aider", "--yes", "--no-git", "--message", 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()
+
+    def _parse_changed_files(self, output: str) -> list[str]:
+        """Parse changed files from Aider output.
+
+        Aider logs lines like: "Modified path/to/file.py"
+        """
+        files = []
+        for line in output.split("\n"):
+            if line.strip().startswith("Modified "):
+                file_path = line.strip()[9:].strip()  # Remove "Modified "
+                files.append(file_path)
+        return files

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

@@ -0,0 +1,103 @@
+"""Amazon Q Developer 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,
+    ExecutorTimeoutError,
+)
+
+
+@ExecutorRegistry.register("amazon-q")
+class AmazonQAdapter(ExecutorAdapter):
+    """Amazon Q Developer adapter."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="amazon-q",
+            display_name="Amazon Q Developer",
+            version="1.0.0",
+            capabilities=[
+                ExecutorCapability.STREAMING_OUTPUT,
+            ],
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "profile": {"type": "string", "description": "AWS profile to use"},
+                    "model": {
+                        "type": "string",
+                        "default": "q-developer",
+                        "description": "Model variant to use",
+                    },
+                },
+            },
+            documentation_url="https://aws.amazon.com/q/developer/",
+            author="AWS",
+            license="Proprietary",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if Q CLI is installed."""
+        # Amazon Q can be accessed via `q` or `amazon-q` command
+        return shutil.which("q") is not None or shutil.which("amazon-q") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Amazon Q Developer."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Amazon Q not found. Install AWS CLI and Q extension."
+            )
+
+        # Determine which command is available
+        cmd_name = "q" if shutil.which("q") else "amazon-q"
+
+        # Build command
+        cmd = [cmd_name, "chat"]
+
+        if request.yolo_mode:
+            cmd.append("--trust-all-tools")
+
+        # Add AWS profile if specified
+        profile = request.config.get("profile")
+        if profile:
+            cmd.extend(["--profile", profile])
+
+        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},
+            )
+
+            # Amazon Q uses stdin for the prompt
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(input=request.prompt.encode()),
+                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"Amazon Q execution timed out after {request.timeout_seconds}s"
+            )
+        except Exception as e:
+            raise ExecutorInvocationError(f"Amazon Q execution failed: {str(e)}")

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

@@ -0,0 +1,123 @@
+"""Amp (Sourcegraph) 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("amp")
+class AmpAdapter(ExecutorAdapter):
+    """Amp (Sourcegraph) CLI adapter for automated code changes."""
+
+    def get_metadata(self) -> ExecutorMetadata:
+        return ExecutorMetadata(
+            name="amp",
+            display_name="Amp CLI (Sourcegraph)",
+            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 Amp",
+                    }
+                },
+            },
+            documentation_url="https://github.com/sourcegraph/amp",
+            author="Sourcegraph",
+            license="Apache-2.0",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if amp CLI is installed."""
+        return shutil.which("amp") is not None
+
+    async def execute(self, request: ExecutionRequest) -> ExecutionResult:
+        """Execute using Amp CLI."""
+        if not await self.is_available():
+            raise ExecutorNotFoundError(
+                "Amp CLI not found. Install from https://github.com/sourcegraph/amp"
+            )
+
+        cmd = ["amp", "--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"Amp execution timed out after {request.timeout_seconds}s"
+            ) from None
+        except Exception as e:
+            raise ExecutorInvocationError(f"Amp 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("Amp CLI not found")
+
+        cmd = ["amp", "--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()