devorch 0.1.2__py3-none-any.whl

core/modes.py

@@ -0,0 +1,141 @@
+"""
+Agent execution modes - controls how DevOrch handles tool execution.
+
+Modes:
+- PLAN: Create a plan first, show it, ask for approval, then execute
+- AUTO: Execute tools automatically without asking (trusted mode)
+- ASK: Ask for confirmation before each tool execution (default)
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class AgentMode(str, Enum):
+    PLAN = "plan"  # Plan first, then execute after approval
+    AUTO = "auto"  # Execute automatically (no confirmations)
+    ASK = "ask"  # Ask before each tool execution (default)
+
+
+@dataclass
+class PlanStep:
+    """A single step in an execution plan."""
+
+    description: str
+    tool_name: str | None = None
+    tool_args: dict | None = None
+    status: str = "pending"  # pending, approved, rejected, completed, failed
+
+
+@dataclass
+class ExecutionPlan:
+    """A plan of steps to execute."""
+
+    goal: str
+    steps: list[PlanStep] = field(default_factory=list)
+    approved: bool = False
+
+    def add_step(self, description: str, tool_name: str = None, tool_args: dict = None):
+        self.steps.append(
+            PlanStep(description=description, tool_name=tool_name, tool_args=tool_args)
+        )
+
+    def to_display(self) -> str:
+        """Format plan for display."""
+        lines = [f"📋 **Plan: {self.goal}**\n"]
+        for i, step in enumerate(self.steps, 1):
+            status_icon = {
+                "pending": "⬜",
+                "approved": "✅",
+                "rejected": "❌",
+                "completed": "✔️",
+                "failed": "💥",
+            }.get(step.status, "⬜")
+
+            tool_info = f" [{step.tool_name}]" if step.tool_name else ""
+            lines.append(f"{status_icon} {i}. {step.description}{tool_info}")
+
+        return "\n".join(lines)
+
+
+class ModeManager:
+    """Manages the current execution mode and plan state."""
+
+    def __init__(self, default_mode: AgentMode = AgentMode.ASK):
+        self._mode = default_mode
+        self._current_plan: ExecutionPlan | None = None
+        self._on_mode_change: Callable[[AgentMode], None] | None = None
+
+    @property
+    def mode(self) -> AgentMode:
+        return self._mode
+
+    @mode.setter
+    def mode(self, value: AgentMode):
+        old_mode = self._mode
+        self._mode = value
+        if self._on_mode_change and old_mode != value:
+            self._on_mode_change(value)
+
+    @property
+    def current_plan(self) -> ExecutionPlan | None:
+        return self._current_plan
+
+    def set_on_mode_change(self, callback: Callable[[AgentMode], None]):
+        """Set callback for mode changes."""
+        self._on_mode_change = callback
+
+    def start_plan(self, goal: str) -> ExecutionPlan:
+        """Start a new execution plan."""
+        self._current_plan = ExecutionPlan(goal=goal)
+        return self._current_plan
+
+    def clear_plan(self):
+        """Clear the current plan."""
+        self._current_plan = None
+
+    def approve_plan(self) -> bool:
+        """Approve the current plan for execution."""
+        if self._current_plan:
+            self._current_plan.approved = True
+            return True
+        return False
+
+    def should_ask_permission(self) -> bool:
+        """Check if we should ask for tool permission based on mode."""
+        if self._mode == AgentMode.AUTO:
+            return False
+        elif self._mode == AgentMode.PLAN:
+            # In plan mode, don't ask during planning, only during execution
+            if self._current_plan and self._current_plan.approved:
+                return False  # Plan approved, execute without asking
+            return True
+        else:  # ASK mode
+            return True
+
+    def is_planning(self) -> bool:
+        """Check if we're currently in planning phase."""
+        return (
+            self._mode == AgentMode.PLAN
+            and self._current_plan is not None
+            and not self._current_plan.approved
+        )
+
+    def get_mode_display(self) -> str:
+        """Get a short display string for the current mode."""
+        mode_displays = {
+            AgentMode.PLAN: "[yellow]PLAN[/yellow]",
+            AgentMode.AUTO: "[green]AUTO[/green]",
+            AgentMode.ASK: "[blue]ASK[/blue]",
+        }
+        return mode_displays.get(self._mode, str(self._mode))
+
+    def get_mode_description(self) -> str:
+        """Get description of current mode."""
+        descriptions = {
+            AgentMode.PLAN: "Plan mode - I'll show you the plan before executing",
+            AgentMode.AUTO: "Auto mode - I'll execute tools automatically",
+            AgentMode.ASK: "Ask mode - I'll ask before each tool execution",
+        }
+        return descriptions.get(self._mode, "")

core/planner.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+from schemas.message import Message
+
+
+class Planner(ABC):
+    """
+    Decides the next step for the agent.
+    """
+
+    @abstractmethod
+    def plan(self, history: list[Message]) -> list[Message]:
+        """
+        Returns updated messages to send to the LLM.
+        """
+        pass

core/sessions.py

@@ -0,0 +1,271 @@
+import json
+import sqlite3
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from schemas.message import Message
+
+DATA_DIR = Path.home() / ".devorch"
+DB_PATH = DATA_DIR / "sessions.db"
+
+# Default limits
+DEFAULT_MESSAGE_LIMIT = 50  # Max messages before summarization
+DEFAULT_TOKEN_ESTIMATE_LIMIT = 100000  # Rough token estimate
+
+
+class SessionManager:
+    """Manages chat session persistence using SQLite."""
+
+    def __init__(self, message_limit: int = DEFAULT_MESSAGE_LIMIT):
+        self._ensure_db()
+        self.current_session_id: str | None = None
+        self.message_limit = message_limit
+        self._message_count = 0
+
+    def _ensure_db(self):
+        """Create database and tables if they don't exist."""
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                name TEXT,
+                provider TEXT NOT NULL,
+                model TEXT NOT NULL,
+                parent_session_id TEXT,
+                summary TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (parent_session_id) REFERENCES sessions(id)
+            )
+        """)
+
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id TEXT NOT NULL,
+                role TEXT NOT NULL,
+                content TEXT NOT NULL,
+                name TEXT,
+                tool_call_id TEXT,
+                metadata TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+            )
+        """)
+
+        # Add parent_session_id and summary columns if they don't exist (migration)
+        try:
+            cursor.execute("ALTER TABLE sessions ADD COLUMN parent_session_id TEXT")
+        except sqlite3.OperationalError:
+            pass  # Column already exists
+
+        try:
+            cursor.execute("ALTER TABLE sessions ADD COLUMN summary TEXT")
+        except sqlite3.OperationalError:
+            pass  # Column already exists
+
+        conn.commit()
+        conn.close()
+
+    def create_session(
+        self,
+        provider: str,
+        model: str,
+        name: str | None = None,
+        parent_session_id: str | None = None,
+        summary: str | None = None,
+    ) -> str:
+        """Create a new session and return its ID."""
+        session_id = str(uuid.uuid4())[:8]
+        if not name:
+            name = f"Session {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+
+        cursor.execute(
+            """INSERT INTO sessions (id, name, provider, model, parent_session_id, summary)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (session_id, name, provider, model, parent_session_id, summary),
+        )
+
+        conn.commit()
+        conn.close()
+
+        self.current_session_id = session_id
+        self._message_count = 0
+        return session_id
+
+    def save_message(self, message: Message, session_id: str | None = None):
+        """Save a message to the current or specified session."""
+        sid = session_id or self.current_session_id
+        if not sid:
+            return
+
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+
+        metadata_json = json.dumps(message.metadata) if message.metadata else None
+
+        cursor.execute(
+            """INSERT INTO messages (session_id, role, content, name, tool_call_id, metadata)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (sid, message.role, message.content, message.name, message.tool_call_id, metadata_json),
+        )
+
+        # Update session timestamp
+        cursor.execute("UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE id = ?", (sid,))
+
+        conn.commit()
+        conn.close()
+
+        if sid == self.current_session_id:
+            self._message_count += 1
+
+    def get_message_count(self, session_id: str | None = None) -> int:
+        """Get the number of messages in a session."""
+        sid = session_id or self.current_session_id
+        if not sid:
+            return 0
+
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT COUNT(*) FROM messages WHERE session_id = ?", (sid,))
+        count = cursor.fetchone()[0]
+
+        conn.close()
+        return count
+
+    def should_summarize(self) -> bool:
+        """Check if the current session should be summarized."""
+        return self._message_count >= self.message_limit
+
+    def load_session(self, session_id: str) -> tuple[dict, list[Message]]:
+        """Load a session and its messages. Returns (session_info, messages)."""
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        # Get session info
+        cursor.execute("SELECT * FROM sessions WHERE id = ?", (session_id,))
+        session_row = cursor.fetchone()
+
+        if not session_row:
+            conn.close()
+            raise ValueError(f"Session '{session_id}' not found")
+
+        session_info = dict(session_row)
+
+        # Get messages
+        cursor.execute(
+            "SELECT * FROM messages WHERE session_id = ? ORDER BY created_at", (session_id,)
+        )
+        message_rows = cursor.fetchall()
+
+        messages = []
+        for row in message_rows:
+            metadata = json.loads(row["metadata"]) if row["metadata"] else None
+            msg = Message(
+                role=row["role"],
+                content=row["content"],
+                name=row["name"],
+                tool_call_id=row["tool_call_id"],
+                metadata=metadata,
+            )
+            messages.append(msg)
+
+        conn.close()
+
+        self.current_session_id = session_id
+        self._message_count = len(messages)
+        return session_info, messages
+
+    def create_continuation_session(self, provider: str, model: str, summary: str) -> str:
+        """Create a new session that continues from the current one with a summary."""
+        parent_id = self.current_session_id
+
+        # Get parent session name for naming continuation
+        name = f"Continuation {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+
+        new_session_id = self.create_session(
+            provider=provider, model=model, name=name, parent_session_id=parent_id, summary=summary
+        )
+
+        return new_session_id
+
+    def get_session_chain(self, session_id: str) -> list[dict]:
+        """Get the chain of sessions (parent -> child) for context."""
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        chain = []
+        current_id = session_id
+
+        # Walk up the parent chain
+        while current_id:
+            cursor.execute("SELECT * FROM sessions WHERE id = ?", (current_id,))
+            row = cursor.fetchone()
+            if row:
+                chain.insert(0, dict(row))
+                current_id = row["parent_session_id"]
+            else:
+                break
+
+        conn.close()
+        return chain
+
+    def list_sessions(self, limit: int = 20) -> list[dict]:
+        """List recent sessions."""
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        cursor.execute(
+            """SELECT s.*, COUNT(m.id) as message_count
+               FROM sessions s
+               LEFT JOIN messages m ON s.id = m.session_id
+               GROUP BY s.id
+               ORDER BY s.updated_at DESC
+               LIMIT ?""",
+            (limit,),
+        )
+
+        sessions = [dict(row) for row in cursor.fetchall()]
+        conn.close()
+
+        return sessions
+
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session and its messages."""
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+
+        # Enable foreign keys for cascade delete
+        cursor.execute("PRAGMA foreign_keys = ON")
+
+        cursor.execute("DELETE FROM messages WHERE session_id = ?", (session_id,))
+        cursor.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+
+        deleted = cursor.rowcount > 0
+        conn.commit()
+        conn.close()
+
+        return deleted
+
+    def session_exists(self, session_id: str) -> bool:
+        """Check if a session exists."""
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT 1 FROM sessions WHERE id = ?", (session_id,))
+        exists = cursor.fetchone() is not None
+
+        conn.close()
+        return exists

core/tasks.py

@@ -0,0 +1,142 @@
+"""Task manager for tracking work progress with visual display."""
+
+from collections.abc import Callable
+
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+
+from schemas.task import Task, TaskList, TaskStatus
+
+console = Console()
+
+
+class TaskManager:
+    """Manages tasks and displays progress."""
+
+    def __init__(self, on_update: Callable | None = None):
+        self.task_list = TaskList()
+        self.on_update = on_update  # Callback when tasks change
+        self._live: Live | None = None
+
+    def set_tasks(self, tasks: list[dict]) -> None:
+        """Set tasks from a list of dictionaries (from AI tool call)."""
+        self.task_list.clear()
+        for task_data in tasks:
+            task = Task(
+                content=task_data["content"],
+                status=TaskStatus(task_data.get("status", "pending")),
+                active_form=task_data.get("activeForm") or task_data.get("active_form"),
+            )
+            self.task_list.add(task)
+        self._display()
+
+    def add_task(self, content: str, active_form: str | None = None) -> Task:
+        """Add a new task."""
+        task = Task(content=content, active_form=active_form or content)
+        self.task_list.add(task)
+        self._display()
+        return task
+
+    def start_task(self, task_id: str) -> Task | None:
+        """Mark a task as in progress."""
+        task = self.task_list.update_status(task_id, TaskStatus.IN_PROGRESS)
+        self._display()
+        return task
+
+    def complete_task(self, task_id: str) -> Task | None:
+        """Mark a task as completed."""
+        task = self.task_list.update_status(task_id, TaskStatus.COMPLETED)
+        self._display()
+        return task
+
+    def get_current_task(self) -> Task | None:
+        """Get the currently active task."""
+        return self.task_list.get_current()
+
+    def clear_tasks(self) -> None:
+        """Clear all tasks."""
+        self.task_list.clear()
+
+    def _display(self) -> None:
+        """Display the current task list."""
+        if self.task_list.total_count == 0:
+            return
+
+        panel = self._create_panel()
+        console.print(panel)
+
+        if self.on_update:
+            self.on_update(self.task_list)
+
+    def _create_panel(self) -> Panel:
+        """Create a Rich panel showing task progress."""
+        # Build task display
+        lines = []
+
+        for task in self.task_list.tasks:
+            if task.status == TaskStatus.COMPLETED:
+                icon = "[green]✓[/green]"
+                style = "dim"
+                text = task.content
+            elif task.status == TaskStatus.IN_PROGRESS:
+                icon = "[cyan]●[/cyan]"
+                style = "bold cyan"
+                text = task.active_form or task.content
+            else:  # PENDING
+                icon = "[dim]○[/dim]"
+                style = "dim"
+                text = task.content
+
+            lines.append(f"  {icon} [{style}]{text}[/{style}]")
+
+        content = "\n".join(lines)
+
+        # Progress info
+        completed = self.task_list.completed_count
+        total = self.task_list.total_count
+        progress = f"{completed}/{total}"
+
+        # Create panel with progress in title
+        return Panel(
+            content,
+            title=f"[bold]Tasks[/bold] [dim]({progress})[/dim]",
+            border_style="blue",
+            padding=(0, 1),
+        )
+
+    def get_status_line(self) -> str:
+        """Get a short status line for the current task."""
+        current = self.get_current_task()
+        if current:
+            completed = self.task_list.completed_count
+            total = self.task_list.total_count
+            return f"[{completed}/{total}] {current.active_form or current.content}"
+        return ""
+
+    def to_dict(self) -> dict:
+        """Export task list as dictionary."""
+        return {
+            "tasks": self.task_list.to_list(),
+            "completed": self.task_list.completed_count,
+            "total": self.task_list.total_count,
+        }
+
+
+# Global task manager instance
+_task_manager: TaskManager | None = None
+
+
+def get_task_manager() -> TaskManager:
+    """Get or create the global task manager."""
+    global _task_manager
+    if _task_manager is None:
+        _task_manager = TaskManager()
+    return _task_manager
+
+
+def reset_task_manager() -> TaskManager:
+    """Reset and return a new task manager."""
+    global _task_manager
+    _task_manager = TaskManager()
+    return _task_manager