emdash-core 0.1.7__py3-none-any.whl

emdash_core/agent/tools/task_output.py

@@ -0,0 +1,204 @@
+"""TaskOutput tool for retrieving sub-agent results.
+
+Retrieves output from background sub-agents started with run_in_background=True.
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base import BaseTool, ToolResult, ToolCategory
+from ...utils.logger import log
+
+
+class TaskOutputTool(BaseTool):
+    """Get output from a running or completed background sub-agent.
+
+    Use this to check on sub-agents that were started with run_in_background=True.
+    """
+
+    name = "task_output"
+    description = """Get output from a background sub-agent.
+
+Use this to check the status and results of sub-agents started with
+run_in_background=True. Can wait for completion or check immediately."""
+    category = ToolCategory.PLANNING
+
+    def __init__(self, repo_root: Path, connection=None):
+        """Initialize with repo root.
+
+        Args:
+            repo_root: Root directory of the repository
+            connection: Optional connection (not used)
+        """
+        self.repo_root = repo_root.resolve()
+        self.agents_dir = repo_root / ".emdash" / "agents"
+        self.connection = connection
+
+    def execute(
+        self,
+        agent_id: str = "",
+        block: bool = True,
+        timeout: int = 60,
+        **kwargs,
+    ) -> ToolResult:
+        """Get output from a background agent.
+
+        Args:
+            agent_id: Agent ID to get output from
+            block: Whether to wait for completion
+            timeout: Max wait time in seconds (if blocking)
+
+        Returns:
+            ToolResult with agent output or status
+        """
+        if not agent_id:
+            return ToolResult.error_result(
+                "agent_id is required",
+                suggestions=["Provide the agent_id from the task() call"],
+            )
+
+        output_file = self.agents_dir / f"{agent_id}.output"
+        transcript_file = self.agents_dir / f"{agent_id}.jsonl"
+
+        if block:
+            return self._wait_for_completion(
+                agent_id, output_file, transcript_file, timeout
+            )
+        else:
+            return self._check_status(agent_id, output_file, transcript_file)
+
+    def _wait_for_completion(
+        self,
+        agent_id: str,
+        output_file: Path,
+        transcript_file: Path,
+        timeout: int,
+    ) -> ToolResult:
+        """Wait for agent to complete.
+
+        Args:
+            agent_id: Agent ID
+            output_file: Path to output file
+            transcript_file: Path to transcript file
+            timeout: Max wait time in seconds
+
+        Returns:
+            ToolResult with results
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            if output_file.exists():
+                content = output_file.read_text().strip()
+
+                # Check if output is complete JSON
+                try:
+                    data = json.loads(content)
+                    if isinstance(data, dict) and "success" in data:
+                        return ToolResult.success_result(
+                            data=data,
+                            metadata={"agent_id": agent_id, "status": "completed"},
+                        )
+                except json.JSONDecodeError:
+                    pass
+
+                # Still running if output exists but isn't complete JSON
+                if content:
+                    return ToolResult.success_result(
+                        data={
+                            "status": "running",
+                            "agent_id": agent_id,
+                            "partial_output": content[-2000:],  # Last 2KB
+                        },
+                    )
+
+            time.sleep(1)
+
+        # Timeout
+        return ToolResult.success_result(
+            data={
+                "status": "timeout",
+                "agent_id": agent_id,
+                "message": f"Agent did not complete within {timeout}s",
+            },
+            suggestions=["Use block=false to check status without waiting"],
+        )
+
+    def _check_status(
+        self,
+        agent_id: str,
+        output_file: Path,
+        transcript_file: Path,
+    ) -> ToolResult:
+        """Check agent status without waiting.
+
+        Args:
+            agent_id: Agent ID
+            output_file: Path to output file
+            transcript_file: Path to transcript file
+
+        Returns:
+            ToolResult with status
+        """
+        # Check if output file exists
+        if not output_file.exists():
+            # Check if transcript exists (agent was started)
+            if transcript_file.exists():
+                return ToolResult.success_result(
+                    data={
+                        "status": "running",
+                        "agent_id": agent_id,
+                    },
+                )
+            else:
+                return ToolResult.error_result(
+                    f"Agent {agent_id} not found",
+                    suggestions=["Check the agent_id is correct"],
+                )
+
+        # Output exists, check if complete
+        try:
+            content = output_file.read_text().strip()
+            data = json.loads(content)
+
+            if isinstance(data, dict) and "success" in data:
+                return ToolResult.success_result(
+                    data=data,
+                    metadata={"agent_id": agent_id, "status": "completed"},
+                )
+
+        except json.JSONDecodeError:
+            pass
+
+        # Partial output
+        return ToolResult.success_result(
+            data={
+                "status": "running",
+                "agent_id": agent_id,
+                "has_output": True,
+            },
+        )
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "agent_id": {
+                    "type": "string",
+                    "description": "Agent ID to get output from",
+                },
+                "block": {
+                    "type": "boolean",
+                    "description": "Wait for completion (default: true)",
+                    "default": True,
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Max wait time in seconds if blocking",
+                    "default": 60,
+                },
+            },
+            required=["agent_id"],
+        )

emdash_core/agent/tools/tasks.py

@@ -0,0 +1,454 @@
+"""Task management tools for agent workflows."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+from .base import BaseTool, ToolResult, ToolCategory
+
+
+class TaskStatus(Enum):
+    """Status of a task."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+
+
+@dataclass
+class Task:
+    """A task in the todo list."""
+
+    id: str
+    title: str
+    description: str = ""
+    status: TaskStatus = TaskStatus.PENDING
+    complexity: str = "M"  # T-shirt size: S, M, L, XL
+    files: list[str] = field(default_factory=list)  # Target files for this task
+    checklist: list[dict] = field(default_factory=list)  # Subtasks: [{text, done}]
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "status": self.status.value,
+            "complexity": self.complexity,
+            "files": self.files,
+            "checklist": self.checklist,
+        }
+
+
+class TaskState:
+    """Singleton state for task management."""
+
+    _instance: Optional["TaskState"] = None
+
+    def __init__(self):
+        self.tasks: list[Task] = []
+        self.completed: bool = False
+        self.completion_summary: Optional[str] = None
+        self.pending_question: Optional[str] = None
+        self.user_response: Optional[str] = None
+        self._next_id: int = 1
+
+    @classmethod
+    def get_instance(cls) -> "TaskState":
+        """Get the singleton instance."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset the singleton instance."""
+        cls._instance = None
+
+    def add_task(
+        self,
+        title: str,
+        description: str = "",
+        complexity: str = "M",
+        files: list[str] = None,
+        checklist: list[str] = None,
+    ) -> Task:
+        """Add a new task.
+
+        Args:
+            title: Task title
+            description: Detailed description
+            complexity: T-shirt size (S, M, L, XL)
+            files: List of target file paths
+            checklist: List of subtask strings (converted to {text, done} dicts)
+        """
+        task = Task(
+            id=str(self._next_id),
+            title=title,
+            description=description,
+            complexity=complexity,
+            files=files or [],
+            checklist=[{"text": item, "done": False} for item in (checklist or [])],
+        )
+        self._next_id += 1
+        self.tasks.append(task)
+        return task
+
+    def get_task(self, task_id: str) -> Optional[Task]:
+        """Get task by ID."""
+        for task in self.tasks:
+            if task.id == task_id:
+                return task
+        return None
+
+    def update_status(self, task_id: str, status: TaskStatus) -> bool:
+        """Update task status."""
+        task = self.get_task(task_id)
+        if task:
+            task.status = status
+            return True
+        return False
+
+    def get_all_tasks(self) -> list[dict]:
+        """Get all tasks as dicts."""
+        return [t.to_dict() for t in self.tasks]
+
+    def mark_completed(self, summary: str):
+        """Mark the overall task as completed."""
+        self.completed = True
+        self.completion_summary = summary
+
+    def ask_question(self, question: str):
+        """Set a pending question for the user."""
+        self.pending_question = question
+        self.user_response = None
+
+
+class TaskManagementTool(BaseTool):
+    """Base class for task management tools."""
+
+    category = ToolCategory.PLANNING
+
+    def __init__(self, connection=None):
+        """Initialize without requiring connection."""
+        self.connection = connection
+
+    @property
+    def state(self) -> TaskState:
+        """Get current TaskState instance (always fresh to handle resets)."""
+        return TaskState.get_instance()
+
+
+class WriteTodoTool(TaskManagementTool):
+    """Create a new sub-task for complex work breakdown."""
+
+    name = "write_todo"
+    description = "Create a new task with target files and checklist items. Use reset=true to clear all existing tasks first."
+
+    def execute(
+        self,
+        title: str,
+        description: str = "",
+        complexity: str = "M",
+        files: list[str] = None,
+        checklist: list[str] = None,
+        reset: bool = False,
+        **kwargs,
+    ) -> ToolResult:
+        """Create a new task.
+
+        Args:
+            title: Short task title
+            description: Detailed description (optional)
+            complexity: T-shirt size (S, M, L, XL)
+            files: Target file paths this task will modify
+            checklist: List of subtask items to track
+            reset: If true, clear all existing tasks before adding this one
+
+        Returns:
+            ToolResult with task info
+        """
+        if not title or not title.strip():
+            return ToolResult.error_result("Task title is required")
+
+        # Reset all tasks if requested
+        if reset:
+            TaskState.reset()
+
+        task = self.state.add_task(
+            title=title.strip(),
+            description=description.strip() if description else "",
+            complexity=complexity,
+            files=files or [],
+            checklist=checklist or [],
+        )
+
+        return ToolResult.success_result({
+            "task": task.to_dict(),
+            "total_tasks": len(self.state.tasks),
+            "all_tasks": self.state.get_all_tasks(),
+            "was_reset": reset,
+        })
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "title": {
+                    "type": "string",
+                    "description": "Short task title",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Detailed description of what needs to be done",
+                },
+                "complexity": {
+                    "type": "string",
+                    "enum": ["S", "M", "L", "XL"],
+                    "description": "T-shirt size complexity: S (trivial), M (moderate), L (significant), XL (complex)",
+                },
+                "files": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Target file paths this task will modify",
+                },
+                "checklist": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of subtask items to track (e.g., ['Add imports', 'Update function', 'Add tests'])",
+                },
+                "reset": {
+                    "type": "boolean",
+                    "description": "Set to true to clear all existing tasks before adding this one",
+                    "default": False,
+                },
+            },
+            required=["title"],
+        )
+
+
+class UpdateTodoListTool(TaskManagementTool):
+    """Update task status or checklist items."""
+
+    name = "update_todo_list"
+    description = "Update task status, mark checklist items done, or add files. Auto-creates tasks if they don't exist."
+
+    def execute(
+        self,
+        task_id: str,
+        status: str = None,
+        checklist_done: list[int] = None,
+        checklist: list[int] = None,  # Alias for checklist_done
+        files: list[str] = None,
+        title: str = "",
+        description: str = "",
+        **kwargs,  # Ignore unexpected params from LLM
+    ) -> ToolResult:
+        """Update task status or checklist items.
+
+        Args:
+            task_id: Task ID to update (e.g., "1", "2")
+            status: New status (pending, in_progress, completed)
+            checklist_done: Indices of checklist items to mark done (0-based)
+            checklist: Alias for checklist_done
+            files: Additional files to add to the task
+            title: Optional title for auto-created tasks
+            description: Optional description for auto-created tasks
+
+        Returns:
+            ToolResult with updated task list
+        """
+        # Handle checklist alias
+        if checklist and not checklist_done:
+            checklist_done = checklist
+        task = self.state.get_task(task_id)
+
+        # Auto-create task if not found
+        if not task:
+            new_status = TaskStatus.PENDING
+            if status:
+                try:
+                    new_status = TaskStatus(status.lower())
+                except ValueError:
+                    pass
+
+            task = Task(
+                id=str(task_id),
+                title=title or f"Task {task_id}",
+                status=new_status,
+                description=description,
+                files=files or [],
+            )
+            self.state.tasks.append(task)
+            return ToolResult.success_result({
+                "task_id": task_id,
+                "auto_created": True,
+                "task": task.to_dict(),
+                "all_tasks": self.state.get_all_tasks(),
+            })
+
+        # Update status if provided
+        if status:
+            try:
+                task.status = TaskStatus(status.lower())
+            except ValueError:
+                return ToolResult.error_result(
+                    f"Invalid status: {status}. Use: pending, in_progress, completed"
+                )
+
+        # Mark checklist items as done
+        if checklist_done:
+            for idx in checklist_done:
+                if 0 <= idx < len(task.checklist):
+                    task.checklist[idx]["done"] = True
+
+        # Add files
+        if files:
+            for f in files:
+                if f not in task.files:
+                    task.files.append(f)
+
+        return ToolResult.success_result({
+            "task_id": task_id,
+            "task": task.to_dict(),
+            "all_tasks": self.state.get_all_tasks(),
+        })
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "task_id": {
+                    "type": "string",
+                    "description": "ID of the task to update (e.g., '1', '2')",
+                },
+                "status": {
+                    "type": "string",
+                    "enum": ["pending", "in_progress", "completed"],
+                    "description": "New status for the task",
+                },
+                "checklist_done": {
+                    "type": "array",
+                    "items": {"type": "integer"},
+                    "description": "Indices of checklist items to mark done (0-based)",
+                },
+                "files": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Additional file paths to add to the task",
+                },
+                "title": {
+                    "type": "string",
+                    "description": "Task title (used if auto-creating)",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Task description (used if auto-creating)",
+                },
+            },
+            required=["task_id"],
+        )
+
+
+class AskFollowupQuestionTool(TaskManagementTool):
+    """Request clarification from the user."""
+
+    name = "ask_followup_question"
+    description = "Ask the user a clarifying question. Use this when you need more information to proceed."
+
+    def execute(
+        self,
+        question: str,
+        options: Optional[list[str]] = None,
+    ) -> ToolResult:
+        """Ask a followup question.
+
+        Args:
+            question: Question to ask the user
+            options: Optional list of suggested answers
+
+        Returns:
+            ToolResult indicating question was set
+        """
+        if not question or not question.strip():
+            return ToolResult.error_result("Question is required")
+
+        self.state.ask_question(question.strip())
+
+        return ToolResult.success_result({
+            "question": question,
+            "options": options,
+            "status": "awaiting_response",
+            "message": "Question will be shown to user. Agent loop will pause.",
+        })
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "question": {
+                    "type": "string",
+                    "description": "The question to ask the user",
+                },
+                "options": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Suggested answer options",
+                },
+            },
+            required=["question"],
+        )
+
+
+class AttemptCompletionTool(TaskManagementTool):
+    """Signal task completion with summary."""
+
+    name = "attempt_completion"
+    description = "Signal that the task is complete. Provide a summary of what was accomplished and list files that were modified."
+
+    def execute(
+        self,
+        summary: str,
+        files_modified: list[str] = None,
+    ) -> ToolResult:
+        """Signal task completion.
+
+        Args:
+            summary: Summary of what was accomplished
+            files_modified: List of files that were modified
+
+        Returns:
+            ToolResult with completion info
+        """
+        if not summary or not summary.strip():
+            return ToolResult.error_result("Summary is required")
+
+        self.state.mark_completed(summary.strip())
+
+        # Count completed vs total tasks
+        completed = sum(1 for t in self.state.tasks if t.status == TaskStatus.COMPLETED)
+        total = len(self.state.tasks)
+
+        return ToolResult.success_result({
+            "status": "completed",
+            "summary": summary,
+            "files_modified": files_modified or [],
+            "tasks_completed": f"{completed}/{total}" if total > 0 else "No subtasks",
+            "message": "Task marked as complete. Agent loop will terminate.",
+        })
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "summary": {
+                    "type": "string",
+                    "description": "Summary of what was accomplished",
+                },
+                "files_modified": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of file paths that were modified",
+                },
+            },
+            required=["summary"],
+        )