minion-code 0.1.0__py3-none-any.whl

minion_code/tools/todo_write_tool.py

@@ -0,0 +1,234 @@
+"""Todo Write Tool for managing todo items."""
+
+import uuid
+import json
+from typing import List, Dict, Any, Optional
+from minion.tools import BaseTool
+from minion.types import AgentState
+
+from ..utils.todo_storage import (
+    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):
+        self.result = result
+        self.error_code = error_code
+        self.message = message
+        self.meta = meta or {}
+
+
+def validate_todos(todos: List[TodoItem]) -> ValidationResult:
+    """Validate a list of todos."""
+    # Check for duplicate IDs
+    ids = [todo.id for todo in todos]
+    unique_ids = set(ids)
+    if len(ids) != len(unique_ids):
+        duplicate_ids = [id for id in ids if ids.count(id) > 1]
+        return ValidationResult(
+            result=False,
+            error_code=1,
+            message="Duplicate todo IDs found",
+            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]
+    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]}
+        )
+    
+    # Validate each todo
+    for todo in todos:
+        if not todo.content.strip():
+            return ValidationResult(
+                result=False,
+                error_code=3,
+                message=f'Todo with ID "{todo.id}" has empty content',
+                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])
+    }
+    
+    summary = f"Updated {stats['total']} todo(s)"
+    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
+
+
+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
+    )
+    
+    lines = []
+    for i, todo in enumerate(sorted_todos):
+        # Determine checkbox and formatting
+        if todo.status == TodoStatus.COMPLETED:
+            checkbox = "☒"
+            prefix = "  ⎿ "
+            content = f"~~{todo.content}~~"  # Strikethrough for completed
+        elif todo.status == TodoStatus.IN_PROGRESS:
+            checkbox = "☐"
+            prefix = "  ⎿ "
+            content = f"**{todo.content}**"  # Bold for in progress
+        else:  # pending
+            checkbox = "☐"
+            prefix = "  ⎿ "
+            if i == next_pending_index:
+                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"
+        },
+    }
+    output_type = "string"
+    
+    def _get_agent_id(self, state: AgentState) -> str:
+        """Get agent ID from agent state."""
+        # Try to get from metadata
+        # if 'agent_id' in state.metadata:
+        #     return state.metadata['agent_id']
+        #
+        # # Try to get from input if available
+        # if state.input and hasattr(state.input, 'mind_id'):
+        #     return state.input.mind_id
+        #
+        # # Generate a unique ID based on task or use default
+        # if state.task:
+        #     # 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']
+                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']:
+                    return f"Error: Invalid status '{todo_data['status']}' in todo item {i}"
+                
+                # Validate priority
+                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():
+                    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'])
+                )
+                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])
+            })
+            
+            # 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)}"

minion_code/tools/user_input_tool.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+User input tool
+"""
+
+from typing import Optional
+from minion.tools import BaseTool
+
+
+class UserInputTool(BaseTool):
+    """User input tool"""
+
+    name = "user_input"
+    description = "Ask user a specific question and get input"
+    readonly = True  # Read-only tool, does not modify system state
+    inputs = {
+        "question": {"type": "string", "description": "Question to ask the user"},
+        "default_value": {
+            "type": "string",
+            "description": "Default value (optional)",
+            "nullable": True,
+        },
+    }
+    output_type = "string"
+
+    def forward(self, question: str, default_value: Optional[str] = None) -> str:
+        """Ask user a question"""
+        try:
+            # Build prompt message
+            prompt = f"Question: {question}"
+            if default_value:
+                prompt += f" (default: {default_value})"
+            prompt += "\nPlease enter your answer: "
+
+            # Get user input
+            user_response = input(prompt).strip()
+
+            # Use default value if user didn't input anything and default exists
+            if not user_response and default_value:
+                user_response = default_value
+
+            result = f"User question: {question}\n"
+            if default_value:
+                result += f"Default value: {default_value}\n"
+            result += f"User answer: {user_response}"
+
+            return result
+
+        except KeyboardInterrupt:
+            return "User cancelled input"
+        except Exception as e:
+            return f"Error getting user input: {str(e)}"

minion_code/types.py

@@ -0,0 +1,88 @@
+"""
+Type definitions for minion_code
+Shared types to avoid circular imports
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Dict, Any, Optional, Union
+import uuid
+import time
+
+
+class MessageType(Enum):
+    USER = "user"
+    ASSISTANT = "assistant"
+    PROGRESS = "progress"
+    TOOL_USE = "tool_use"
+    TOOL_RESULT = "tool_result"
+
+
+class InputMode(Enum):
+    BASH = "bash"
+    PROMPT = "prompt"
+    KODING = "koding"
+
+
+@dataclass
+class MessageContent:
+    """Represents message content - can be text or structured content"""
+    content: Union[str, List[Dict[str, Any]]]
+    type: str = "text"
+
+
+@dataclass
+class Message:
+    """Core message structure equivalent to TypeScript MessageType"""
+    uuid: str = field(default_factory=lambda: str(uuid.uuid4()))
+    type: MessageType = MessageType.USER
+    message: MessageContent = field(default_factory=lambda: MessageContent(""))
+    timestamp: float = field(default_factory=time.time)
+    options: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class ToolUseConfirm:
+    """Tool use confirmation context"""
+    tool_name: str
+    parameters: Dict[str, Any]
+    on_confirm: Any  # Callable[[], None]
+    on_abort: Any  # Callable[[], None]
+
+
+@dataclass
+class BinaryFeedbackContext:
+    """Binary feedback context for comparing two assistant messages"""
+    m1: Message
+    m2: Message
+    resolve: Any  # Callable[[str], None]
+
+
+@dataclass
+class ToolJSXContext:
+    """Tool JSX rendering context"""
+    jsx: Optional[Any] = None
+    should_hide_prompt_input: bool = False
+
+
+@dataclass
+class ModelInfo:
+    """Model information display"""
+    name: str
+    provider: str
+    context_length: int
+    current_tokens: int
+    id: Optional[str] = None
+
+
+class REPLConfig:
+    """Configuration equivalent to getGlobalConfig()"""
+    def __init__(self):
+        self.verbose: bool = False
+        self.debug: bool = False
+        self.safe_mode: bool = False
+        self.has_acknowledged_cost_threshold: bool = False
+        self.model_name: str = "claude-3-5-sonnet-20241022"
+    
+    def get_model_name(self, context: str = "main") -> str:
+        return self.model_name

minion_code/utils/__init__.py

@@ -0,0 +1,44 @@
+# Utils package
+
+from .todo_file_utils import (
+    get_todo_file_path,
+    get_default_storage_dir,
+    ensure_storage_dir_exists,
+    list_todo_files,
+    extract_agent_id_from_todo_file,
+    is_todo_file,
+)
+
+from .todo_storage import (
+    TodoItem,
+    TodoStatus,
+    TodoPriority,
+    TodoStorage,
+    get_todos,
+    set_todos,
+    add_todo,
+    update_todo,
+    remove_todo,
+    clear_todos,
+)
+
+__all__ = [
+    # Todo file utilities
+    'get_todo_file_path',
+    'get_default_storage_dir',
+    'ensure_storage_dir_exists',
+    'list_todo_files',
+    'extract_agent_id_from_todo_file',
+    'is_todo_file',
+    # Todo storage
+    'TodoItem',
+    'TodoStatus',
+    'TodoPriority',
+    'TodoStorage',
+    'get_todos',
+    'set_todos',
+    'add_todo',
+    'update_todo',
+    'remove_todo',
+    'clear_todos',
+]

minion_code/utils/mcp_loader.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+MCP (Model Context Protocol) Tools Loader
+
+This module provides functionality to load MCP tools from configuration files
+and integrate them with MinionCodeAgent.
+"""
+
+import json
+import logging
+import subprocess
+import asyncio
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+
+try:
+    from minion.tools.mcp.mcp_toolset import MCPToolset, StdioServerParameters
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+    MCPToolset = None
+    StdioServerParameters = None
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MCPServerConfig:
+    """Configuration for an MCP server."""
+    name: str
+    command: str
+    args: List[str]
+    env: Optional[Dict[str, str]] = None
+    disabled: bool = False
+    auto_approve: List[str] = None
+    
+    def __post_init__(self):
+        if self.auto_approve is None:
+            self.auto_approve = []
+
+
+class MCPToolsLoader:
+    """Loader for MCP tools from configuration files."""
+    
+    def __init__(self, config_path: Optional[Path] = None):
+        """
+        Initialize MCP tools loader.
+        
+        Args:
+            config_path: Path to MCP configuration file
+        """
+        self.config_path = config_path
+        self.servers: Dict[str, MCPServerConfig] = {}
+        self.loaded_tools = []
+        self.toolsets: List[Any] = []  # Store MCPToolset instances for cleanup
+    
+    def load_config(self, config_path: Optional[Path] = None) -> Dict[str, MCPServerConfig]:
+        """
+        Load MCP configuration from JSON file.
+        
+        Args:
+            config_path: Path to configuration file
+            
+        Returns:
+            Dictionary of server configurations
+        """
+        if config_path:
+            self.config_path = config_path
+        
+        if not self.config_path or not self.config_path.exists():
+            logger.warning(f"MCP config file not found: {self.config_path}")
+            return {}
+        
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config_data = json.load(f)
+            
+            servers_config = config_data.get('mcpServers', {})
+            
+            for server_name, server_data in servers_config.items():
+                self.servers[server_name] = MCPServerConfig(
+                    name=server_name,
+                    command=server_data.get('command', ''),
+                    args=server_data.get('args', []),
+                    env=server_data.get('env', {}),
+                    disabled=server_data.get('disabled', False),
+                    auto_approve=server_data.get('autoApprove', [])
+                )
+            
+            logger.info(f"Loaded {len(self.servers)} MCP server configurations")
+            return self.servers
+            
+        except Exception as e:
+            logger.error(f"Failed to load MCP config from {self.config_path}: {e}")
+            return {}
+    
+    async def load_tools_from_server(self, server_config: MCPServerConfig) -> List[Any]:
+        """
+        Load tools from an MCP server.
+        
+        Args:
+            server_config: Server configuration
+            
+        Returns:
+            List of loaded tools
+        """
+        if server_config.disabled:
+            logger.info(f"Skipping disabled MCP server: {server_config.name}")
+            return []
+        
+        if not MCP_AVAILABLE:
+            logger.warning("MCP framework not available, skipping MCP server loading")
+            return []
+        
+        try:
+            logger.info(f"Loading tools from MCP server: {server_config.name}")
+            logger.info(f"Command: {server_config.command} {' '.join(server_config.args)}")
+            
+            # Create MCPToolset with StdioServerParameters
+            toolset = await MCPToolset.create(
+                connection_params=StdioServerParameters(
+                    command=server_config.command,
+                    args=server_config.args,
+                    env=server_config.env or {}
+                ),
+                name=server_config.name,
+                structured_output=False  # Set to False as requested
+            )
+            
+            # Store toolset for cleanup
+            self.toolsets.append(toolset)
+            
+            # Get tools from the toolset
+            tools = toolset.tools if hasattr(toolset, 'tools') else []
+            
+            logger.info(f"Successfully loaded {len(tools)} tools from {server_config.name}")
+            return tools
+            
+        except Exception as e:
+            logger.error(f"Failed to load tools from MCP server {server_config.name}: {e}")
+            return []
+    
+    async def load_all_tools(self) -> List[Any]:
+        """
+        Load tools from all configured MCP servers.
+        
+        Returns:
+            List of all loaded MCP tools
+        """
+        all_tools = []
+        
+        for server_name, server_config in self.servers.items():
+            if not server_config.disabled:
+                tools = await self.load_tools_from_server(server_config)
+                all_tools.extend(tools)
+                logger.info(f"Loaded {len(tools)} tools from {server_name}")
+        
+        self.loaded_tools = all_tools
+        logger.info(f"Total MCP tools loaded: {len(all_tools)}")
+        return all_tools
+    
+    def get_server_info(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get information about configured servers.
+        
+        Returns:
+            Dictionary with server information
+        """
+        info = {}
+        for name, config in self.servers.items():
+            info[name] = {
+                'command': config.command,
+                'args': config.args,
+                'disabled': config.disabled,
+                'auto_approve_count': len(config.auto_approve)
+            }
+        return info
+    
+    async def close(self):
+        """
+        Close all MCP toolsets and clean up resources.
+        """
+        logger.info(f"Closing {len(self.toolsets)} MCP toolsets...")
+        
+        for toolset in self.toolsets:
+            try:
+                await toolset.close()
+                logger.debug(f"Closed toolset: {getattr(toolset, 'name', 'unknown')}")
+            except Exception as e:
+                logger.error(f"Error closing toolset: {e}")
+        
+        self.toolsets.clear()
+        logger.info("All MCP toolsets closed")
+
+
+# Convenience function
+async def load_mcp_tools(config_path: Path) -> List[Any]:
+    """
+    Convenience function to load MCP tools from a configuration file.
+    
+    Args:
+        config_path: Path to MCP configuration file
+        
+    Returns:
+        List of loaded MCP tools
+    """
+    loader = MCPToolsLoader(config_path)
+    loader.load_config()
+    return await loader.load_all_tools()