draft-board 0.1.0-beta.0

package/app/backend/app/services/agent_memory_service.py

@@ -0,0 +1,223 @@
+"""Agent memory service for UDAR conversation history.
+
+This service manages compressed conversation checkpoints for the UDAR agent.
+Instead of storing full LLM conversation history (expensive), it stores
+only summaries and metadata (lean storage optimization).
+"""
+
+import json
+from datetime import datetime, timedelta
+from typing import Any
+
+from sqlalchemy import delete, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.agent_conversation_history import AgentConversationHistory
+
+
+class AgentMemoryService:
+    """Manages conversation history and checkpoints for UDAR agent.
+
+    COST OPTIMIZATION: Stores summaries, not full messages.
+    """
+
+    def __init__(self, db: AsyncSession):
+        """Initialize memory service.
+
+        Args:
+            db: Async database session
+        """
+        self.db = db
+
+    async def save_checkpoint(
+        self,
+        goal_id: str,
+        checkpoint_id: str,
+        state: dict[str, Any],
+    ) -> None:
+        """Save agent state to database (COMPRESSED).
+
+        Only stores summary + metadata, not full LLM responses.
+        This keeps storage lean while preserving essential context.
+
+        Args:
+            goal_id: Goal this checkpoint belongs to
+            checkpoint_id: Unique checkpoint identifier
+            state: UDAR state dict to checkpoint
+        """
+        # Extract only essential data (not full messages)
+        summary = {
+            "tickets_proposed": len(state.get("proposed_tickets", [])),
+            "tickets_validated": len(state.get("validated_tickets", [])),
+            "reasoning_summary": state.get("reasoning", "")[:500],  # Cap at 500 chars
+            "phase": state.get("phase", "unknown"),
+            "iteration": state.get("iteration", 0),
+            "llm_calls_made": state.get("llm_calls_made", 0),
+            "trigger": state.get("trigger", "unknown"),
+        }
+
+        # Check if checkpoint already exists
+        existing = await self.db.execute(
+            select(AgentConversationHistory).where(
+                AgentConversationHistory.goal_id == goal_id,
+                AgentConversationHistory.checkpoint_id == checkpoint_id,
+            )
+        )
+        existing_checkpoint = existing.scalar_one_or_none()
+
+        if existing_checkpoint:
+            # Update existing checkpoint
+            existing_checkpoint.metadata_json = json.dumps(summary)
+            existing_checkpoint.updated_at = datetime.utcnow()
+        else:
+            # Create new checkpoint
+            history = AgentConversationHistory(
+                goal_id=goal_id,
+                checkpoint_id=checkpoint_id,
+                messages_json=json.dumps([]),  # Empty, don't store full messages
+                metadata_json=json.dumps(summary),
+            )
+            self.db.add(history)
+
+        await self.db.commit()
+
+    async def load_checkpoint(self, goal_id: str) -> dict[str, Any] | None:
+        """Load most recent checkpoint summary (not full history).
+
+        Args:
+            goal_id: Goal to load checkpoint for
+
+        Returns:
+            Checkpoint summary dict, or None if no checkpoint exists
+        """
+        result = await self.db.execute(
+            select(AgentConversationHistory)
+            .where(AgentConversationHistory.goal_id == goal_id)
+            .order_by(AgentConversationHistory.created_at.desc())
+            .limit(1)
+        )
+        history = result.scalar_one_or_none()
+
+        if history:
+            # Return summary only, agent doesn't need full history
+            return json.loads(history.metadata_json)
+
+        return None
+
+    async def list_checkpoints(
+        self,
+        goal_id: str,
+        limit: int = 10,
+    ) -> list[dict[str, Any]]:
+        """List recent checkpoints for a goal.
+
+        Args:
+            goal_id: Goal to list checkpoints for
+            limit: Maximum number of checkpoints to return
+
+        Returns:
+            List of checkpoint dicts with metadata
+        """
+        result = await self.db.execute(
+            select(AgentConversationHistory)
+            .where(AgentConversationHistory.goal_id == goal_id)
+            .order_by(AgentConversationHistory.created_at.desc())
+            .limit(limit)
+        )
+        checkpoints = result.scalars().all()
+
+        return [
+            {
+                "id": checkpoint.id,
+                "checkpoint_id": checkpoint.checkpoint_id,
+                "created_at": checkpoint.created_at.isoformat(),
+                "metadata": json.loads(checkpoint.metadata_json),
+            }
+            for checkpoint in checkpoints
+        ]
+
+    async def cleanup_old_checkpoints(self, days: int = 30) -> int:
+        """Delete checkpoints older than N days to save storage.
+
+        Args:
+            days: Age threshold in days
+
+        Returns:
+            Number of checkpoints deleted
+        """
+        cutoff = datetime.utcnow() - timedelta(days=days)
+
+        result = await self.db.execute(
+            delete(AgentConversationHistory).where(
+                AgentConversationHistory.created_at < cutoff
+            )
+        )
+        deleted_count = result.rowcount
+
+        await self.db.commit()
+
+        return deleted_count
+
+    async def delete_checkpoints_for_goal(self, goal_id: str) -> int:
+        """Delete all checkpoints for a goal.
+
+        Args:
+            goal_id: Goal to delete checkpoints for
+
+        Returns:
+            Number of checkpoints deleted
+        """
+        result = await self.db.execute(
+            delete(AgentConversationHistory).where(
+                AgentConversationHistory.goal_id == goal_id
+            )
+        )
+        deleted_count = result.rowcount
+
+        await self.db.commit()
+
+        return deleted_count
+
+    async def get_goal_summary(self, goal_id: str) -> dict[str, Any]:
+        """Get summary of agent activity for a goal.
+
+        Args:
+            goal_id: Goal to summarize
+
+        Returns:
+            Summary dict with aggregated statistics
+        """
+        result = await self.db.execute(
+            select(AgentConversationHistory).where(
+                AgentConversationHistory.goal_id == goal_id
+            )
+        )
+        checkpoints = result.scalars().all()
+
+        if not checkpoints:
+            return {
+                "goal_id": goal_id,
+                "checkpoint_count": 0,
+                "total_llm_calls": 0,
+                "total_tickets_proposed": 0,
+                "first_checkpoint": None,
+                "last_checkpoint": None,
+            }
+
+        # Aggregate statistics
+        total_llm_calls = 0
+        total_tickets_proposed = 0
+
+        for checkpoint in checkpoints:
+            metadata = json.loads(checkpoint.metadata_json)
+            total_llm_calls += metadata.get("llm_calls_made", 0)
+            total_tickets_proposed += metadata.get("tickets_proposed", 0)
+
+        return {
+            "goal_id": goal_id,
+            "checkpoint_count": len(checkpoints),
+            "total_llm_calls": total_llm_calls,
+            "total_tickets_proposed": total_tickets_proposed,
+            "first_checkpoint": checkpoints[-1].created_at.isoformat(),
+            "last_checkpoint": checkpoints[0].created_at.isoformat(),
+        }

package/app/backend/app/services/agent_registry.py

@@ -0,0 +1,346 @@
+"""Agent registry for supporting multiple AI coding agents.
+
+This module provides a pluggable architecture for supporting multiple
+AI coding agents (Claude, Amp, Codex, Gemini, etc.) with a unified interface.
+"""
+
+import logging
+import shutil
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class AgentType(StrEnum):
+    """Supported AI coding agents."""
+
+    CLAUDE = "claude"
+    CURSOR = "cursor"
+    AMP = "amp"
+    CODEX = "codex"
+    GEMINI = "gemini"
+    AIDER = "aider"
+    CONTINUE = "continue"
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for an AI agent."""
+
+    agent_type: AgentType
+    command: str  # Base command to run
+    args: list[str] = field(default_factory=list)
+    env_vars: dict[str, str] = field(default_factory=dict)
+    timeout: int = 600  # seconds
+    supports_yolo: bool = False
+    supports_session_resume: bool = False
+    supports_mcp: bool = False
+    cost_per_1k_input: float | None = None
+    cost_per_1k_output: float | None = None
+
+
+class AgentExecutor(ABC):
+    """Abstract base class for agent executors."""
+
+    def __init__(self, config: AgentConfig):
+        self.config = config
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this agent is available on the system."""
+        pass
+
+    @abstractmethod
+    def build_command(
+        self,
+        prompt: str,
+        working_dir: Path,
+        yolo_mode: bool = False,
+        session_id: str | None = None,
+        **kwargs,
+    ) -> list[str]:
+        """Build the command to execute the agent."""
+        pass
+
+    @abstractmethod
+    def parse_output(self, stdout: str, stderr: str) -> dict[str, Any]:
+        """Parse agent output into structured format."""
+        pass
+
+
+class ClaudeExecutor(AgentExecutor):
+    """Executor for Claude Code CLI."""
+
+    def is_available(self) -> bool:
+        return shutil.which("claude") is not None
+
+    def build_command(
+        self,
+        prompt: str,
+        working_dir: Path,
+        yolo_mode: bool = False,
+        session_id: str | None = None,
+        **kwargs,
+    ) -> list[str]:
+        cmd = [self.config.command, "--print", "--output-format", "json"]
+
+        if yolo_mode and self.config.supports_yolo:
+            cmd.append("--dangerously-skip-permissions")
+
+        if session_id and self.config.supports_session_resume:
+            cmd.extend(["--resume", session_id])
+
+        cmd.extend(["--prompt", prompt])
+        return cmd
+
+    def parse_output(self, stdout: str, stderr: str) -> dict[str, Any]:
+        # Parse Claude's JSON output format
+        import json
+
+        try:
+            return {"success": True, "data": json.loads(stdout)}
+        except json.JSONDecodeError:
+            return {"success": False, "raw_output": stdout, "error": stderr}
+
+
+class AmpExecutor(AgentExecutor):
+    """Executor for Amp CLI."""
+
+    def is_available(self) -> bool:
+        return shutil.which("amp") is not None
+
+    def build_command(
+        self,
+        prompt: str,
+        working_dir: Path,
+        yolo_mode: bool = False,
+        session_id: str | None = None,
+        **kwargs,
+    ) -> list[str]:
+        cmd = [self.config.command, "run"]
+
+        if session_id:
+            cmd.extend(["--thread", session_id])
+
+        cmd.extend(["--message", prompt])
+        return cmd
+
+    def parse_output(self, stdout: str, stderr: str) -> dict[str, Any]:
+        return {"success": True, "raw_output": stdout}
+
+
+class CursorExecutor(AgentExecutor):
+    """Executor for Cursor Agent CLI."""
+
+    def is_available(self) -> bool:
+        # Check common paths for cursor-agent
+        paths = [
+            shutil.which("cursor-agent"),
+            Path.home() / ".local/bin/cursor-agent",
+            Path("/usr/local/bin/cursor-agent"),
+        ]
+        return any(p and (isinstance(p, str) or p.exists()) for p in paths)
+
+    def build_command(
+        self,
+        prompt: str,
+        working_dir: Path,
+        yolo_mode: bool = False,
+        session_id: str | None = None,
+        **kwargs,
+    ) -> list[str]:
+        cmd = [self.config.command]
+        cmd.extend(["--prompt", prompt])
+        return cmd
+
+    def parse_output(self, stdout: str, stderr: str) -> dict[str, Any]:
+        return {"success": True, "raw_output": stdout, "interactive": True}
+
+
+class AiderExecutor(AgentExecutor):
+    """Executor for Aider CLI (open-source coding assistant)."""
+
+    def is_available(self) -> bool:
+        return shutil.which("aider") is not None
+
+    def build_command(
+        self,
+        prompt: str,
+        working_dir: Path,
+        yolo_mode: bool = False,
+        session_id: str | None = None,
+        **kwargs,
+    ) -> list[str]:
+        cmd = [self.config.command, "--yes", "--no-auto-commits"]
+
+        if yolo_mode:
+            cmd.append("--auto-commits")
+
+        cmd.extend(["--message", prompt])
+        return cmd
+
+    def parse_output(self, stdout: str, stderr: str) -> dict[str, Any]:
+        return {"success": True, "raw_output": stdout}
+
+
+class GeminiExecutor(AgentExecutor):
+    """Executor for Gemini CLI."""
+
+    def is_available(self) -> bool:
+        return shutil.which("gemini") is not None
+
+    def build_command(
+        self,
+        prompt: str,
+        working_dir: Path,
+        yolo_mode: bool = False,
+        session_id: str | None = None,
+        **kwargs,
+    ) -> list[str]:
+        cmd = [self.config.command]
+
+        if yolo_mode:
+            cmd.extend(["--sandbox=false"])
+
+        cmd.extend(["--prompt", prompt])
+        return cmd
+
+    def parse_output(self, stdout: str, stderr: str) -> dict[str, Any]:
+        return {"success": True, "raw_output": stdout}
+
+
+class CodexExecutor(AgentExecutor):
+    """Executor for OpenAI Codex CLI."""
+
+    def is_available(self) -> bool:
+        return shutil.which("codex") is not None
+
+    def build_command(
+        self,
+        prompt: str,
+        working_dir: Path,
+        yolo_mode: bool = False,
+        session_id: str | None = None,
+        **kwargs,
+    ) -> list[str]:
+        cmd = [self.config.command]
+
+        if yolo_mode:
+            cmd.extend(["--approval-mode", "full-auto"])
+
+        cmd.extend([prompt])
+        return cmd
+
+    def parse_output(self, stdout: str, stderr: str) -> dict[str, Any]:
+        return {"success": True, "raw_output": stdout}
+
+
+# Agent registry with default configurations
+AGENT_REGISTRY: dict[AgentType, AgentConfig] = {
+    AgentType.CLAUDE: AgentConfig(
+        agent_type=AgentType.CLAUDE,
+        command="claude",
+        supports_yolo=True,
+        supports_session_resume=True,
+        supports_mcp=True,
+        cost_per_1k_input=0.003,
+        cost_per_1k_output=0.015,
+    ),
+    AgentType.CURSOR: AgentConfig(
+        agent_type=AgentType.CURSOR,
+        command="cursor-agent",
+        supports_yolo=False,
+        supports_session_resume=False,
+    ),
+    AgentType.AMP: AgentConfig(
+        agent_type=AgentType.AMP,
+        command="amp",
+        supports_yolo=False,
+        supports_session_resume=True,
+    ),
+    AgentType.AIDER: AgentConfig(
+        agent_type=AgentType.AIDER,
+        command="aider",
+        supports_yolo=True,
+        supports_session_resume=False,
+        cost_per_1k_input=0.003,  # Depends on model used
+        cost_per_1k_output=0.015,
+    ),
+    AgentType.GEMINI: AgentConfig(
+        agent_type=AgentType.GEMINI,
+        command="gemini",
+        supports_yolo=True,
+        supports_session_resume=False,
+        supports_mcp=False,
+        cost_per_1k_input=0.001,
+        cost_per_1k_output=0.002,
+    ),
+    AgentType.CODEX: AgentConfig(
+        agent_type=AgentType.CODEX,
+        command="codex",
+        supports_yolo=True,
+        supports_session_resume=False,
+        cost_per_1k_input=0.01,
+        cost_per_1k_output=0.03,
+    ),
+}
+
+EXECUTOR_CLASSES: dict[AgentType, type] = {
+    AgentType.CLAUDE: ClaudeExecutor,
+    AgentType.CURSOR: CursorExecutor,
+    AgentType.AMP: AmpExecutor,
+    AgentType.AIDER: AiderExecutor,
+    AgentType.GEMINI: GeminiExecutor,
+    AgentType.CODEX: CodexExecutor,
+}
+
+
+class AgentRegistry:
+    """Registry for managing multiple AI coding agents."""
+
+    def __init__(self):
+        self._executors: dict[AgentType, AgentExecutor] = {}
+
+    def get_executor(self, agent_type: AgentType) -> AgentExecutor | None:
+        """Get an executor for the specified agent type."""
+        if agent_type not in self._executors:
+            config = AGENT_REGISTRY.get(agent_type)
+            executor_class = EXECUTOR_CLASSES.get(agent_type)
+            if config and executor_class:
+                self._executors[agent_type] = executor_class(config)
+
+        return self._executors.get(agent_type)
+
+    def get_available_agents(self) -> list[AgentType]:
+        """Get list of agents available on this system."""
+        available = []
+        for agent_type in AgentType:
+            executor = self.get_executor(agent_type)
+            if executor and executor.is_available():
+                available.append(agent_type)
+        return available
+
+    def get_agent_info(self, agent_type: AgentType) -> dict[str, Any] | None:
+        """Get information about an agent."""
+        config = AGENT_REGISTRY.get(agent_type)
+        if not config:
+            return None
+
+        executor = self.get_executor(agent_type)
+        return {
+            "type": agent_type.value,
+            "available": executor.is_available() if executor else False,
+            "supports_yolo": config.supports_yolo,
+            "supports_session_resume": config.supports_session_resume,
+            "supports_mcp": config.supports_mcp,
+            "cost_per_1k_input": config.cost_per_1k_input,
+            "cost_per_1k_output": config.cost_per_1k_output,
+        }
+
+
+# Global registry instance
+agent_registry = AgentRegistry()