minion-code 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

minion_code/tools/task_tool.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""
+Task Tool for launching specialized agents to handle complex, multi-step tasks.
+Uses SubagentRegistry to dynamically manage available agent types.
+"""
+
+import time
+import uuid
+from pathlib import Path
+from typing import Dict, Any, Optional, List, Union
+from minion.tools import AsyncBaseTool
+from minion.types import AgentState
+
+
+def generate_task_tool_prompt() -> str:
+    """
+    Generate the complete Task tool prompt including available subagents.
+    This is used to generate the Task tool description dynamically.
+
+    Returns:
+        Complete task tool prompt with all available subagents
+    """
+    from ..subagents import load_subagents
+
+    registry = load_subagents()
+    subagents = registry.list_all()
+
+    if not subagents:
+        return """Launch a new agent to handle complex, multi-step tasks autonomously.
+
+No subagents are currently available."""
+
+    # Generate subagent descriptions
+    subagent_lines = registry.generate_tool_description_lines()
+
+    return f"""Launch a new agent to handle complex, multi-step tasks autonomously.
+
+Available agent types and the tools they have access to:
+{subagent_lines}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use. Default is "general-purpose".
+
+When to use the Task tool:
+- For complex, multi-step tasks that require specialized expertise
+- When you need to delegate a complete subtask to a focused agent
+- For exploration tasks (use "Explore" subagent)
+- For planning and architecture design (use "Plan" subagent)
+- For documentation lookup (use "claude-code-guide" subagent)
+
+When NOT to use the Task tool:
+- If you want to read a specific file path, use the file_read tool instead
+- For simple grep searches, use the grep tool directly
+- For single bash commands, use the bash tool directly
+- For simple questions you can answer directly without tools
+
+Usage notes:
+1. Each agent invocation is stateless and autonomous
+2. Provide detailed task descriptions for best results
+3. Choose the appropriate subagent_type for your specific task
+4. Read-only subagents (Explore, Plan) cannot modify files
+
+Example usage:
+- Task(description="Explore auth", prompt="Find all authentication-related files", subagent_type="Explore")
+- Task(description="Plan feature", prompt="Design implementation plan for user settings", subagent_type="Plan")
+- Task(description="Complex refactor", prompt="Refactor the database layer...", subagent_type="general-purpose")
+"""
+
+
+class TaskTool(AsyncBaseTool):
+    """
+    A tool for launching specialized agents to handle complex, multi-step tasks autonomously.
+    Uses SubagentRegistry to dynamically manage available agent types.
+    """
+
+    name = "Task"
+    # Description will be set dynamically in __init__
+    description = "Launch a new agent to handle complex, multi-step tasks autonomously"
+    readonly = (
+        True  # Task execution is read-only from the perspective of the calling agent
+    )
+    needs_state = True
+
+    inputs = {
+        "description": {
+            "type": "string",
+            "description": "A short (3-5 word) description of the task",
+        },
+        "prompt": {
+            "type": "string",
+            "description": "The task for the agent to perform",
+        },
+        "model_name": {
+            "type": "string",
+            "description": "Optional: Specific model name to use for this task",
+            "nullable": True,
+        },
+        "subagent_type": {
+            "type": "string",
+            "description": "The type of specialized agent to use (default: general-purpose)",
+            "nullable": True,
+        },
+    }
+    output_type = "string"
+
+    def __init__(self, workdir: Optional[str] = None):
+        super().__init__()
+        self._registry = None
+        self._workdir = Path(workdir) if workdir else None
+        # Set dynamic description
+        self.description = generate_task_tool_prompt()
+
+    @property
+    def registry(self):
+        """Get the subagent registry, loading subagents if needed."""
+        if self._registry is None:
+            from ..subagents import load_subagents
+
+            self._registry = load_subagents()
+        return self._registry
+
+    async def forward(
+        self,
+        description: str,
+        prompt: str,
+        model_name: Optional[str] = None,
+        subagent_type: Optional[str] = None,
+        *,
+        state: AgentState,
+    ) -> str:
+        """Execute the task using a specialized agent (async)."""
+        start_time = time.time()
+
+        # Default to general-purpose
+        agent_type = subagent_type or "general-purpose"
+
+        # Get subagent config from registry
+        subagent_config = self.registry.get(agent_type)
+
+        if subagent_config is None:
+            available_types = self.registry.list_names()
+            return (
+                f"Agent type '{agent_type}' not found.\n\nAvailable agents:\n"
+                + "\n".join(f"  - {t}" for t in available_types)
+                + "\n\nUse one of the available agent types."
+            )
+
+        # Build effective prompt
+        effective_prompt = prompt
+        if subagent_config.system_prompt:
+            effective_prompt = f"{subagent_config.system_prompt}\n\n{prompt}"
+
+        # Determine model
+        effective_model = model_name or "gpt-4o-mini"
+        if not model_name and subagent_config.model_name != "inherit":
+            effective_model = subagent_config.model_name
+
+        # Progress messages
+        progress_messages = [
+            f"Starting agent: {agent_type}",
+            f"Using model: {effective_model}",
+            f"Task: {description}",
+        ]
+
+        try:
+            from ..agents.code_agent import MinionCodeAgent
+
+            # Determine working directory
+            workdir = self._workdir or Path.cwd()
+
+            # Create agent with filtered tools
+            agent = await MinionCodeAgent.create(
+                name=f"Task Agent ({agent_type})",
+                llm=effective_model,
+                system_prompt=(
+                    effective_prompt if subagent_config.system_prompt else None
+                ),
+                workdir=workdir,
+                additional_tools=self._get_filtered_tools(subagent_config.tools),
+                # History decay: save large outputs to file after N steps
+                decay_enabled=True,
+                decay_ttl_steps=3,
+                decay_min_size=100_000,  # 100KB
+            )
+
+            # Execute
+            response = await agent.run_async(prompt)
+
+            # Extract response
+            if hasattr(response, "answer"):
+                result_text = response.answer
+            elif hasattr(response, "content"):
+                result_text = response.content
+            else:
+                result_text = str(response)
+
+            duration = time.time() - start_time
+            completion_message = f"Task completed ({self._format_duration(duration)})"
+
+            return (
+                "\n".join(progress_messages)
+                + f"\n\n{result_text}\n\n{completion_message}"
+            )
+
+        except Exception as e:
+            return (
+                "\n".join(progress_messages)
+                + f"\n\nError during task execution: {str(e)}"
+            )
+
+    def _get_filtered_tools(self, tool_filter: Union[str, List[str]]) -> Optional[List]:
+        """Get filtered tools based on subagent configuration."""
+        if tool_filter == "*" or (isinstance(tool_filter, list) and "*" in tool_filter):
+            return None  # Use all default tools
+
+        # TODO: Implement actual tool filtering based on tool names
+        # For now, return None to use all tools
+        return None
+
+    def _format_duration(self, seconds: float) -> str:
+        """Format duration in a human-readable way."""
+        if seconds < 1:
+            return f"{int(seconds * 1000)}ms"
+        elif seconds < 60:
+            return f"{seconds:.1f}s"
+        else:
+            minutes = int(seconds // 60)
+            remaining_seconds = seconds % 60
+            return f"{minutes}m {remaining_seconds:.1f}s"
+
+    def _validate_input(
+        self,
+        description: str,
+        prompt: str,
+        model_name: Optional[str] = None,
+        subagent_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Validate input parameters."""
+
+        if not description or not isinstance(description, str):
+            return {
+                "valid": False,
+                "message": "Description is required and must be a string",
+            }
+
+        if not prompt or not isinstance(prompt, str):
+            return {
+                "valid": False,
+                "message": "Prompt is required and must be a string",
+            }
+
+        # Validate subagent_type if provided
+        if subagent_type and not self.registry.exists(subagent_type):
+            available_types = self.registry.list_names()
+            return {
+                "valid": False,
+                "message": f"Agent type '{subagent_type}' does not exist. Available types: {', '.join(available_types)}",
+            }
+
+        return {"valid": True}
+
+    @classmethod
+    def get_available_agent_types(cls) -> List[str]:
+        """Get list of available agent types."""
+        from ..subagents import get_available_subagents
+
+        return [s.name for s in get_available_subagents()]
+
+    @classmethod
+    def get_agent_description(cls, agent_type: str) -> Optional[Dict[str, Any]]:
+        """Get description for a specific agent type."""
+        from ..subagents import get_subagent_registry
+
+        registry = get_subagent_registry()
+        subagent = registry.get(agent_type)
+        if subagent:
+            return {
+                "description": subagent.description,
+                "when_to_use": subagent.when_to_use,
+                "tools": subagent.tools,
+                "readonly": subagent.readonly,
+            }
+        return None
+
+    @classmethod
+    def get_prompt_text(cls) -> str:
+        """Get the tool prompt text for agent instructions."""
+        return generate_task_tool_prompt()

minion_code/tools/todo_read_tool.py

@@ -11,17 +11,17 @@ def format_todos_display(todos):
     """Format todos for display."""
     if not todos:
         return "No todos currently"
-    
+
     # Sort: [completed, in_progress, pending]
     order = [TodoStatus.COMPLETED, TodoStatus.IN_PROGRESS, TodoStatus.PENDING]
     sorted_todos = sorted(todos, key=lambda t: (order.index(t.status), t.content))
-    
+
     # Find the next pending task
     next_pending_index = next(
         (i for i, todo in enumerate(sorted_todos) if todo.status == TodoStatus.PENDING),
-        -1
+        -1,
     )
-    
+
     lines = []
     for i, todo in enumerate(sorted_todos):
         # Determine checkbox and formatting
@@ -40,61 +40,65 @@ def format_todos_display(todos):
                 content = f"**{todo.content}**"  # Bold for next pending
             else:
                 content = todo.content
-        
+
         lines.append(f"{prefix}{checkbox} {content}")
-    
+
     return "\n".join(lines)
 
 
 class TodoReadTool(BaseTool):
     """Tool for reading and displaying current todo items."""
-    
+
     name = "todo_read"
     description = "View current todo items and their status."
     readonly = True  # Read-only tool, does not modify system state
     needs_state = True  # Tool needs agent state
     inputs = {}
     output_type = "string"
-    
+
     def _get_agent_id(self, state: AgentState) -> str:
         """Get agent ID from agent state."""
         # Try to get from metadata
         return state.agent.agent_id
-    
+
     def forward(self, state: AgentState) -> str:
         """Execute the todo read operation."""
         try:
             # Get agent ID from agent state
             agent_id = self._get_agent_id(state)
-            
+
             # Get current todos
             todos = get_todos(agent_id)
-            
+
             if not todos:
                 return "No todos currently"
-            
+
             # Generate statistics
             stats = {
-                'total': len(todos),
-                'pending': len([t for t in todos if t.status == TodoStatus.PENDING]),
-                'in_progress': len([t for t in todos if t.status == TodoStatus.IN_PROGRESS]),
-                'completed': len([t for t in todos if t.status == TodoStatus.COMPLETED])
+                "total": len(todos),
+                "pending": len([t for t in todos if t.status == TodoStatus.PENDING]),
+                "in_progress": len(
+                    [t for t in todos if t.status == TodoStatus.IN_PROGRESS]
+                ),
+                "completed": len(
+                    [t for t in todos if t.status == TodoStatus.COMPLETED]
+                ),
             }
-            
+
             # Update agent metadata with current todo stats
-            state.metadata['current_todo_stats'] = stats
-            
+            state.metadata["current_todo_stats"] = stats
+
             # Reset iteration counter since todo tool was used
             state.metadata["iteration_without_todos"] = 0
-            
+
             # Format display
             display = format_todos_display(todos)
-            
+
             # Generate summary
             summary = f"Found {stats['total']} todo(s): {stats['pending']} pending, {stats['in_progress']} in progress, {stats['completed']} completed"
-            
+
             result = f"{summary}\n\n{display}"
             return result
-            
+
         except Exception as e:
-            return f"Error reading todos: {str(e)}"
+            return f"Error reading todos: {str(e)}"

minion_code/tools/todo_write_tool.py

@@ -7,17 +7,24 @@ from minion.tools import BaseTool
 from minion.types import AgentState
 
 from ..utils.todo_storage import (
-    TodoItem, TodoStatus, TodoPriority, 
-    get_todos, set_todos
+    TodoItem,
+    TodoStatus,
+    TodoPriority,
+    get_todos,
+    set_todos,
 )
 
 
-
-
-
 class ValidationResult:
     """Result of todo validation."""
-    def __init__(self, result: bool, error_code: int = 0, message: str = "", meta: Dict[str, Any] = None):
+
+    def __init__(
+        self,
+        result: bool,
+        error_code: int = 0,
+        message: str = "",
+        meta: Dict[str, Any] = None,
+    ):
         self.result = result
         self.error_code = error_code
         self.message = message
@@ -35,19 +42,21 @@ def validate_todos(todos: List[TodoItem]) -> ValidationResult:
             result=False,
             error_code=1,
             message="Duplicate todo IDs found",
-            meta={"duplicate_ids": list(set(duplicate_ids))}
+            meta={"duplicate_ids": list(set(duplicate_ids))},
         )
-    
+
     # Check for multiple in_progress tasks
-    in_progress_tasks = [todo for todo in todos if todo.status == TodoStatus.IN_PROGRESS]
+    in_progress_tasks = [
+        todo for todo in todos if todo.status == TodoStatus.IN_PROGRESS
+    ]
     if len(in_progress_tasks) > 1:
         return ValidationResult(
             result=False,
             error_code=2,
             message="Only one task can be in_progress at a time",
-            meta={"in_progress_task_ids": [t.id for t in in_progress_tasks]}
+            meta={"in_progress_task_ids": [t.id for t in in_progress_tasks]},
         )
-    
+
     # Validate each todo
     for todo in todos:
         if not todo.content.strip():
@@ -55,26 +64,26 @@ def validate_todos(todos: List[TodoItem]) -> ValidationResult:
                 result=False,
                 error_code=3,
                 message=f'Todo with ID "{todo.id}" has empty content',
-                meta={"todo_id": todo.id}
+                meta={"todo_id": todo.id},
             )
-    
+
     return ValidationResult(result=True)
 
 
 def generate_todo_summary(todos: List[TodoItem]) -> str:
     """Generate a summary of todos."""
     stats = {
-        'total': len(todos),
-        'pending': len([t for t in todos if t.status == TodoStatus.PENDING]),
-        'in_progress': len([t for t in todos if t.status == TodoStatus.IN_PROGRESS]),
-        'completed': len([t for t in todos if t.status == TodoStatus.COMPLETED])
+        "total": len(todos),
+        "pending": len([t for t in todos if t.status == TodoStatus.PENDING]),
+        "in_progress": len([t for t in todos if t.status == TodoStatus.IN_PROGRESS]),
+        "completed": len([t for t in todos if t.status == TodoStatus.COMPLETED]),
     }
-    
+
     summary = f"Updated {stats['total']} todo(s)"
-    if stats['total'] > 0:
+    if stats["total"] > 0:
         summary += f" ({stats['pending']} pending, {stats['in_progress']} in progress, {stats['completed']} completed)"
     summary += ". Continue tracking your progress with the todo list."
-    
+
     return summary
 
 
@@ -82,17 +91,17 @@ def format_todos_display(todos: List[TodoItem]) -> str:
     """Format todos for display."""
     if not todos:
         return "No todos currently"
-    
+
     # Sort: [completed, in_progress, pending]
     order = [TodoStatus.COMPLETED, TodoStatus.IN_PROGRESS, TodoStatus.PENDING]
     sorted_todos = sorted(todos, key=lambda t: (order.index(t.status), t.content))
-    
+
     # Find the next pending task
     next_pending_index = next(
         (i for i, todo in enumerate(sorted_todos) if todo.status == TodoStatus.PENDING),
-        -1
+        -1,
     )
-    
+
     lines = []
     for i, todo in enumerate(sorted_todos):
         # Determine checkbox and formatting
@@ -111,27 +120,27 @@ def format_todos_display(todos: List[TodoItem]) -> str:
                 content = f"**{todo.content}**"  # Bold for next pending
             else:
                 content = todo.content
-        
+
         lines.append(f"{prefix}{checkbox} {content}")
-    
+
     return "\n".join(lines)
 
 
 class TodoWriteTool(BaseTool):
     """Tool for writing and managing todo items."""
-    
+
     name = "todo_write"
     description = "Creates and manages todo items for task tracking and progress management in the current session."
     readonly = False  # Writing tool, modifies system state
     needs_state = True  # Tool needs agent state
     inputs = {
         "todos_json": {
-            "type": "string", 
-            "description": "JSON string containing array of todo items with id, content, status, and priority fields"
+            "type": "string",
+            "description": "JSON string containing array of todo items with id, content, status, and priority fields",
         },
     }
     output_type = "string"
-    
+
     def _get_agent_id(self, state: AgentState) -> str:
         """Get agent ID from agent state."""
         # Try to get from metadata
@@ -147,88 +156,96 @@ class TodoWriteTool(BaseTool):
         #     # Use a hash of the task as agent ID
         #      import hashlib
         #      return hashlib.md5(state.task.encode()).hexdigest()[:8]
-        
+
         # Default fallback
         return state.agent.agent_id
-    
+
     def forward(self, todos_json: str, *, state: AgentState) -> str:
         """Execute the todo write operation."""
         try:
             # Get agent ID from agent state
             agent_id = self._get_agent_id(state)
-            
+
             # Parse JSON input
             try:
                 todos_data = json.loads(todos_json)
             except json.JSONDecodeError as e:
                 return f"Error: Invalid JSON format - {str(e)}"
-            
+
             if not isinstance(todos_data, list):
                 return "Error: todos_json must be an array of todo items"
-            
+
             # Convert to TodoItem objects and validate
             todo_items = []
             for i, todo_data in enumerate(todos_data):
                 if not isinstance(todo_data, dict):
                     return f"Error: Todo item {i} must be an object"
-                
+
                 # Validate required fields
-                required_fields = ['id', 'content', 'status', 'priority']
+                required_fields = ["id", "content", "status", "priority"]
                 for field in required_fields:
                     if field not in todo_data:
                         return f"Error: Todo item {i} missing required field '{field}'"
-                
+
                 # Validate status
-                if todo_data['status'] not in ['pending', 'in_progress', 'completed']:
+                if todo_data["status"] not in ["pending", "in_progress", "completed"]:
                     return f"Error: Invalid status '{todo_data['status']}' in todo item {i}"
-                
+
                 # Validate priority
-                if todo_data['priority'] not in ['high', 'medium', 'low']:
+                if todo_data["priority"] not in ["high", "medium", "low"]:
                     return f"Error: Invalid priority '{todo_data['priority']}' in todo item {i}"
-                
+
                 # Validate content
-                if not todo_data['content'].strip():
+                if not todo_data["content"].strip():
                     return f"Error: Todo item {i} has empty content"
-                
+
                 todo_item = TodoItem(
-                    id=todo_data['id'],
-                    content=todo_data['content'],
-                    status=TodoStatus(todo_data['status']),
-                    priority=TodoPriority(todo_data['priority'])
+                    id=todo_data["id"],
+                    content=todo_data["content"],
+                    status=TodoStatus(todo_data["status"]),
+                    priority=TodoPriority(todo_data["priority"]),
                 )
                 todo_items.append(todo_item)
-            
+
             # Validate todos
             validation = validate_todos(todo_items)
             if not validation.result:
                 return f"Validation Error: {validation.message}"
-            
+
             # Get previous todos for comparison
             previous_todos = get_todos(agent_id)
-            
+
             # Update todos in storage
             set_todos(todo_items, agent_id)
-            
+
             # Update agent metadata with todo info
-            state.metadata['todo_count'] = len(todo_items)
-            state.metadata['last_todo_update'] = json.dumps({
-                'total': len(todo_items),
-                'pending': len([t for t in todo_items if t.status == TodoStatus.PENDING]),
-                'in_progress': len([t for t in todo_items if t.status == TodoStatus.IN_PROGRESS]),
-                'completed': len([t for t in todo_items if t.status == TodoStatus.COMPLETED])
-            })
-            
+            state.metadata["todo_count"] = len(todo_items)
+            state.metadata["last_todo_update"] = json.dumps(
+                {
+                    "total": len(todo_items),
+                    "pending": len(
+                        [t for t in todo_items if t.status == TodoStatus.PENDING]
+                    ),
+                    "in_progress": len(
+                        [t for t in todo_items if t.status == TodoStatus.IN_PROGRESS]
+                    ),
+                    "completed": len(
+                        [t for t in todo_items if t.status == TodoStatus.COMPLETED]
+                    ),
+                }
+            )
+
             # Reset iteration counter since todo tool was used
             state.metadata["iteration_without_todos"] = 0
-            
+
             # Generate summary
             summary = generate_todo_summary(todo_items)
-            
+
             # Format display
             display = format_todos_display(todo_items)
-            
+
             result = f"{summary}\n\n{display}"
             return result
-            
+
         except Exception as e:
-            return f"Error updating todos: {str(e)}"
+            return f"Error updating todos: {str(e)}"