auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/common/v2/agent/agentic_edit_tools/todo_write_tool_resolver.py

@@ -4,10 +4,10 @@ from autocoder.common.v2.agent.agentic_edit_types import TodoWriteTool, ToolResu
 from loguru import logger
 import typing
 from autocoder.common import AutoCoderArgs
-import os
-import json
-import uuid
-from datetime import datetime
+
+# Import the new todos module
+from autocoder.common.todos.get_todo_manager import get_todo_manager
+from autocoder.common.todos.exceptions import TodoManagerError, TodoNotFoundError
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit
@@ -18,191 +18,134 @@ class TodoWriteToolResolver(BaseToolResolver):
         super().__init__(agent, tool, args)
         self.tool: TodoWriteTool = tool  # For type hinting
         
-    def _get_todo_file_path(self) -> str:
-        """Get the path to the todo file for this session."""
-        source_dir = self.args.source_dir or "."
-        todo_dir = os.path.join(source_dir, ".auto-coder", "todos")
-        os.makedirs(todo_dir, exist_ok=True)
-        return os.path.join(todo_dir, "current_session.json")
-    
-    def _load_todos(self) -> Dict[str, Any]:
-        """Load todos from the session file."""
-        todo_file = self._get_todo_file_path()
-        if not os.path.exists(todo_file):
-            return {
-                "created_at": datetime.now().isoformat(),
-                "updated_at": datetime.now().isoformat(),
-                "todos": []
-            }
-        
-        try:
-            with open(todo_file, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except Exception as e:
-            logger.warning(f"Failed to load todos: {e}")
-            return {
-                "created_at": datetime.now().isoformat(),
-                "updated_at": datetime.now().isoformat(),
-                "todos": []
-            }
-    
-    def _save_todos(self, data: Dict[str, Any]) -> bool:
-        """Save todos to the session file."""
-        try:
-            todo_file = self._get_todo_file_path()
-            data["updated_at"] = datetime.now().isoformat()
-            
-            with open(todo_file, 'w', encoding='utf-8') as f:
-                json.dump(data, f, ensure_ascii=False, indent=2)
-            return True
-        except Exception as e:
-            logger.error(f"Failed to save todos: {e}")
-            return False
-    
-    def _generate_todo_id(self) -> str:
-        """Generate a unique ID for a todo item."""
-        return str(uuid.uuid4())[:8]
-    
-    def _find_todo_by_id(self, todos: List[Dict[str, Any]], task_id: str) -> Optional[Dict[str, Any]]:
-        """Find a todo item by ID."""
-        for todo in todos:
-            if todo.get('id') == task_id:
-                return todo
-        return None
-    
-    def _create_todo_list(self, content: str) -> List[Dict[str, Any]]:
-        """Create a new todo list from content."""
-        import re
-        
-        todos = []
-        
-        # First, try to parse <task> tags
-        task_pattern = r'<task>(.*?)</task>'
-        task_matches = re.findall(task_pattern, content, re.DOTALL)
-        
-        if task_matches:
-            # Found <task> tags, use them
-            for task_content in task_matches:
-                task_content = task_content.strip()
-                if task_content:
-                    todo = {
-                        "id": self._generate_todo_id(),
-                        "content": task_content,
-                        "status": "pending",
-                        "priority": self.tool.priority or "medium",
-                        "created_at": datetime.now().isoformat(),
-                        "updated_at": datetime.now().isoformat()
-                    }
-                    
-                    if self.tool.notes:
-                        todo["notes"] = self.tool.notes
-                    
-                    todos.append(todo)
-        else:
-            # Fallback to original line-by-line parsing
-            lines = content.strip().split('\n')
-            
-            for line in lines:
-                line = line.strip()
-                if not line:
-                    continue
-                
-                # Remove common prefixes like "1.", "- ", "* ", etc.
-                line = line.lstrip('0123456789.- *\t')
-                
-                if line:
-                    todo = {
-                        "id": self._generate_todo_id(),
-                        "content": line,
-                        "status": "pending",
-                        "priority": self.tool.priority or "medium",
-                        "created_at": datetime.now().isoformat(),
-                        "updated_at": datetime.now().isoformat()
-                    }
-                    
-                    if self.tool.notes:
-                        todo["notes"] = self.tool.notes
-                    
-                    todos.append(todo)
-        
-        return todos
-    
-    def _add_single_task(self, todos: List[Dict[str, Any]], content: str) -> Dict[str, Any]:
-        """Add a single task to the existing todo list."""
-        import re
-        
-        # Check if content contains <task> tags
-        task_pattern = r'<task>(.*?)</task>'
-        task_matches = re.findall(task_pattern, content, re.DOTALL)
-        
-        if task_matches:
-            # If <task> tags found, use the first one
-            task_content = task_matches[0].strip()
-        else:
-            # Use the content as-is
-            task_content = content.strip()
-        
-        todo = {
-            "id": self._generate_todo_id(),
-            "content": task_content,
-            "status": self.tool.status or "pending",
-            "priority": self.tool.priority or "medium",
-            "created_at": datetime.now().isoformat(),
-            "updated_at": datetime.now().isoformat()
-        }
-        
-        if self.tool.notes:
-            todo["notes"] = self.tool.notes
-        
-        todos.append(todo)
-        return todo
-    
-    def _update_task(self, todo: Dict[str, Any]) -> None:
-        """Update an existing task."""
-        if self.tool.content:
-            todo["content"] = self.tool.content
-        if self.tool.status:
-            todo["status"] = self.tool.status
-        if self.tool.priority:
-            todo["priority"] = self.tool.priority
-        if self.tool.notes:
-            todo["notes"] = self.tool.notes
-        
-        todo["updated_at"] = datetime.now().isoformat()
-    
+        # Initialize todo manager
+        self.todo_manager = get_todo_manager()
+
     def _format_todo_response(self, todos: List[Dict[str, Any]], action_performed: str) -> str:
         """Format the response message after todo operations."""
         if not todos:
             return f"Operation completed: {action_performed}"
-        
-        # Show the latest todos
-        recent_todos = todos[-3:] if len(todos) > 3 else todos
-        
-        output = [f"✅ Operation completed: {action_performed}\n"]
-        
+
+        output = [f"Operation completed: {action_performed}\n"]
+
         if action_performed.startswith("Created"):
+            # For creation operations, show newly created tasks
             output.append("📝 Newly created todos:")
-            for todo in recent_todos:
-                priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(todo.get('priority', 'medium'), "⚪")
-                status_icon = {"pending": "⏳", "in_progress": "🔄", "completed": "✅"}.get(todo.get('status', 'pending'), "⏳")
-                output.append(f"  {priority_icon} {status_icon} [{todo['id']}] {todo['content']}")
-        
-        elif action_performed.startswith("Updated") or action_performed.startswith("Marked"):
-            output.append("📝 Updated todos:")
-            for todo in recent_todos:
-                priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(todo.get('priority', 'medium'), "⚪")
-                status_icon = {"pending": "⏳", "in_progress": "🔄", "completed": "✅"}.get(todo.get('status', 'pending'), "⏳")
-                output.append(f"  {priority_icon} {status_icon} [{todo['id']}] {todo['content']}")
-        
-        total_todos = len(todos)
-        pending_count = len([t for t in todos if t.get('status') == 'pending'])
-        in_progress_count = len([t for t in todos if t.get('status') == 'in_progress'])
-        completed_count = len([t for t in todos if t.get('status') == 'completed'])
-        
-        output.append(f"\n📊 Current summary: Total {total_todos} items | Pending {pending_count} | In Progress {in_progress_count} | Completed {completed_count}")
-        
+            for todo in todos:
+                priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(
+                    todo.get('priority', 'medium'), "⚪")
+                status_icon = {"pending": "⏳", "in_progress": "🔄", "completed": "✅"}.get(
+                    todo.get('status', 'pending'), "⏳")
+                todo_id = todo.get('todo_id', 'MISSING_ID')
+                todo_content = todo.get('content', 'Missing content')
+
+                # Log any todos with missing IDs
+                if todo_id == 'MISSING_ID':
+                    logger.error(f"Found todo with missing ID: {todo}")
+
+                output.append(
+                    f"  {priority_icon} {status_icon} [{todo_id}] {todo_content}")
+
+            total_todos = len(todos)
+            pending_count = len(
+                [t for t in todos if t.get('status') == 'pending'])
+            in_progress_count = len(
+                [t for t in todos if t.get('status') == 'in_progress'])
+            completed_count = len(
+                [t for t in todos if t.get('status') == 'completed'])
+
+            output.append(
+                f"\n📊 Current summary: Total {total_todos} items | Pending {pending_count} | In Progress {in_progress_count} | Completed {completed_count}")
+        else:
+            # For update operations, show complete TODO list
+            output.append(self._format_full_todo_list())
+
         return "\n".join(output)
 
+    def _format_full_todo_list(self) -> str:
+        """Format the complete todo list using the same format as todo_read_tool_resolver."""
+        try:
+            # Get all todos from the current conversation
+            conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+            all_todos = self.todo_manager.get_todos(conversation_id=conversation_id)
+
+            if not all_todos:
+                return "No todos found for current conversation."
+
+            output = []
+            output.append("=== Current Conversation Todo List ===\n")
+
+            # Status emoji mapping
+            status_emoji = {
+                'pending': '⏳',
+                'in_progress': '🔄',
+                'completed': '✅',
+                'cancelled': '❌'
+            }
+
+            # Priority icon mapping
+            priority_icon = {
+                'high': '🔴',
+                'medium': '🟡',
+                'low': '🟢'
+            }
+
+            # Display todos in a single list with status markers
+            for idx, todo in enumerate(all_todos, 1):
+                status = todo.get('status', 'pending')
+                priority = todo.get('priority', 'medium')
+                todo_id = todo.get('todo_id', 'MISSING_ID')
+                todo_content = todo.get('content', 'Missing content')
+
+                # Log any todos with missing IDs
+                if todo_id == 'MISSING_ID':
+                    logger.error(
+                        f"Found todo with missing ID in full list: {todo}")
+
+                # Get status emoji and priority icon
+                status_mark = status_emoji.get(status, '❓')
+                priority_mark = priority_icon.get(priority, '⚪')
+
+                # Format each todo item
+                output.append(
+                    f"{idx}. {status_mark} {priority_mark} [{todo_id}] {todo_content}")
+
+                # Add notes if present
+                if todo.get('notes'):
+                    output.append(f"   └─ 📝 {todo['notes']}")
+
+                # Add dependencies if present
+                if todo.get('dependencies'):
+                    deps = ', '.join(todo['dependencies'])
+                    output.append(f"   └─ 🔗 Depends on: {deps}")
+
+            output.append("")
+
+            # Add summary statistics
+            conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+            stats = self.todo_manager.get_statistics(conversation_id=conversation_id)
+            total = stats.get('total', 0)
+            status_counts = {
+                'pending': stats.get('pending', 0),
+                'in_progress': stats.get('in_progress', 0),
+                'completed': stats.get('completed', 0),
+                'cancelled': stats.get('cancelled', 0)
+            }
+
+            summary_parts = [f"Total: {total}"]
+            for status, emoji in status_emoji.items():
+                if status in status_counts and status_counts[status] > 0:
+                    summary_parts.append(
+                        f"{emoji} {status.replace('_', ' ').title()}: {status_counts[status]}")
+
+            output.append("📊 Summary: " + " | ".join(summary_parts))
+
+            return "\n".join(output)
+            
+        except Exception as e:
+            logger.error(f"Failed to format full todo list: {e}")
+            return "Error retrieving todo list."
+
     def resolve(self) -> ToolResult:
         """
         Create and manage a structured task list based on the action specified.
@@ -210,11 +153,7 @@ class TodoWriteToolResolver(BaseToolResolver):
         try:
             action = self.tool.action.lower()
             logger.info(f"Performing todo action: {action}")
-            
-            # Load existing todos
-            data = self._load_todos()
-            todos = data["todos"]
-            
+
             if action == "create":
                 if not self.tool.content:
                     return ToolResult(
@@ -222,25 +161,40 @@ class TodoWriteToolResolver(BaseToolResolver):
                         message="Error: Content is required for creating todos.",
                         content=None
                     )
-                
-                # Clear existing todos and create new ones
-                new_todos = self._create_todo_list(self.tool.content)
-                data["todos"] = new_todos
-                
-                if self._save_todos(data):
-                    response = self._format_todo_response(new_todos, f"Created {len(new_todos)} new todo items")
+
+                # Create new todos using the todo manager
+                try:
+                    conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+                    todo_ids = self.todo_manager.create_todos(
+                        content=self.tool.content,
+                        conversation_id=conversation_id,
+                        priority=self.tool.priority or "medium",
+                        notes=self.tool.notes
+                    )
+                    
+                    # Get the created todos for display
+                    created_todos = []
+                    conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+                    all_todos = self.todo_manager.get_todos(conversation_id=conversation_id)
+                    for todo in all_todos:
+                        if todo.get('todo_id') in todo_ids:
+                            created_todos.append(todo)
+                    
+                    response = self._format_todo_response(
+                        created_todos, f"Created {len(todo_ids)} new todo items")
                     return ToolResult(
                         success=True,
                         message="Todo list created successfully.",
                         content=response
                     )
-                else:
+                    
+                except TodoManagerError as e:
                     return ToolResult(
                         success=False,
-                        message="Failed to save todo list.",
+                        message=f"Failed to create todos: {str(e)}",
                         content=None
                     )
-            
+
             elif action == "add_task":
                 if not self.tool.content:
                     return ToolResult(
@@ -248,23 +202,41 @@ class TodoWriteToolResolver(BaseToolResolver):
                         message="Error: Content is required for adding a task.",
                         content=None
                     )
-                
-                new_todo = self._add_single_task(todos, self.tool.content)
-                
-                if self._save_todos(data):
-                    response = self._format_todo_response([new_todo], f"Added new task: {new_todo['content']}")
+
+                try:
+                    conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+                    todo_id = self.todo_manager.add_todo(
+                        content=self.tool.content,
+                        conversation_id=conversation_id,
+                        status=self.tool.status or "pending",
+                        priority=self.tool.priority or "medium",
+                        notes=self.tool.notes
+                    )
+                    
+                    # Get the created todo for display
+                    conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+                    all_todos = self.todo_manager.get_todos(conversation_id=conversation_id)
+                    new_todo = next((t for t in all_todos if t.get('todo_id') == todo_id), None)
+                    
+                    if new_todo:
+                        response = self._format_todo_response(
+                            [new_todo], f"Added new task: {new_todo['content']}")
+                    else:
+                        response = f"Added new task with ID: {todo_id}"
+                    
                     return ToolResult(
                         success=True,
                         message="Task added successfully.",
                         content=response
                     )
-                else:
+                    
+                except TodoManagerError as e:
                     return ToolResult(
                         success=False,
-                        message="Failed to save new task.",
+                        message=f"Failed to add task: {str(e)}",
                         content=None
                     )
-            
+
             elif action in ["update", "mark_progress", "mark_completed"]:
                 if not self.tool.task_id:
                     return ToolResult(
@@ -272,53 +244,85 @@ class TodoWriteToolResolver(BaseToolResolver):
                         message="Error: Task ID is required for update operations.",
                         content=None
                     )
-                
-                todo = self._find_todo_by_id(todos, self.tool.task_id)
-                if not todo:
+
+                try:
+                    # Prepare update parameters
+                    update_kwargs = {}
+                    action_msg = ""
+                    
+                    if action == "mark_progress":
+                        update_kwargs['status'] = "in_progress"
+                        action_msg = "Marked task as in progress"
+                    elif action == "mark_completed":
+                        update_kwargs['status'] = "completed"
+                        action_msg = "Marked task as completed"
+                    else:  # update
+                        if self.tool.content:
+                            update_kwargs['content'] = self.tool.content
+                        if self.tool.status:
+                            update_kwargs['status'] = self.tool.status
+                        if self.tool.priority:
+                            update_kwargs['priority'] = self.tool.priority
+                        if self.tool.notes:
+                            update_kwargs['notes'] = self.tool.notes
+                        action_msg = "Updated task"
+                    
+                    # Update the todo
+                    conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+                    success = self.todo_manager.update_todo(
+                        todo_id=self.tool.task_id,
+                        conversation_id=conversation_id,
+                        **update_kwargs
+                    )
+                    
+                    if success:
+                        # Get the updated todo for display
+                        conversation_id = self.agent.conversation_config.conversation_id if self.agent else None
+                        all_todos = self.todo_manager.get_todos(conversation_id=conversation_id)
+                        updated_todo = next((t for t in all_todos if t.get('todo_id') == self.tool.task_id), None)
+                        
+                        if updated_todo:
+                            full_action_msg = f"{action_msg}: {updated_todo['content']}"
+                            response = self._format_todo_response([updated_todo], full_action_msg)
+                        else:
+                            response = f"{action_msg} with ID: {self.tool.task_id}"
+                        
+                        return ToolResult(
+                            success=True,
+                            message="Task updated successfully.",
+                            content=response
+                        )
+                    else:
+                        return ToolResult(
+                            success=False,
+                            message=f"Task with ID '{self.tool.task_id}' not found.",
+                            content=None
+                        )
+                        
+                except TodoNotFoundError:
                     return ToolResult(
                         success=False,
                         message=f"Error: Task with ID '{self.tool.task_id}' not found.",
                         content=None
                     )
-                
-                # Apply specific action
-                if action == "mark_progress":
-                    todo["status"] = "in_progress"
-                    todo["updated_at"] = datetime.now().isoformat()
-                    action_msg = f"Marked task as in progress: {todo['content']}"
-                elif action == "mark_completed":
-                    todo["status"] = "completed"
-                    todo["updated_at"] = datetime.now().isoformat()
-                    action_msg = f"Marked task as completed: {todo['content']}"
-                else:  # update
-                    self._update_task(todo)
-                    action_msg = f"Updated task: {todo['content']}"
-                
-                if self._save_todos(data):
-                    response = self._format_todo_response([todo], action_msg)
-                    return ToolResult(
-                        success=True,
-                        message="Task updated successfully.",
-                        content=response
-                    )
-                else:
+                except TodoManagerError as e:
                     return ToolResult(
                         success=False,
-                        message="Failed to save task update.",
+                        message=f"Failed to update task: {str(e)}",
                         content=None
                     )
-            
+
             else:
                 return ToolResult(
                     success=False,
                     message=f"Error: Unknown action '{action}'. Supported actions: create, add_task, update, mark_progress, mark_completed.",
                     content=None
                 )
-            
+
         except Exception as e:
             logger.error(f"Error in todo write operation: {e}")
             return ToolResult(
                 success=False,
                 message=f"Failed to perform todo operation: {str(e)}",
                 content=None
-            ) 
+            )

autocoder/common/v2/agent/agentic_edit_tools/use_mcp_tool_resolver.py

@@ -1,10 +1,10 @@
 from typing import Dict, Any, Optional
 import typing
 from autocoder.common import AutoCoderArgs
-from autocoder.common.mcp_server_types import McpRequest
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
 from autocoder.common.v2.agent.agentic_edit_types import UseMcpTool, ToolResult # Import ToolResult from types
-from autocoder.common.mcp_server import get_mcp_server
+from autocoder.common.mcp_tools.types import McpRequest
+from autocoder.common.mcp_tools.server import get_mcp_server
 from loguru import logger
 
 if typing.TYPE_CHECKING: