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

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

@@ -0,0 +1,324 @@
+from typing import Dict, Any, Optional, List
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import TodoWriteTool, ToolResult
+from loguru import logger
+import typing
+from autocoder.common import AutoCoderArgs
+import os
+import json
+import uuid
+from datetime import datetime
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class TodoWriteToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: TodoWriteTool, args: AutoCoderArgs):
+        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()
+    
+    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"]
+        
+        if action_performed.startswith("Created"):
+            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}")
+        
+        return "\n".join(output)
+
+    def resolve(self) -> ToolResult:
+        """
+        Create and manage a structured task list based on the action specified.
+        """
+        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(
+                        success=False,
+                        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")
+                    return ToolResult(
+                        success=True,
+                        message="Todo list created successfully.",
+                        content=response
+                    )
+                else:
+                    return ToolResult(
+                        success=False,
+                        message="Failed to save todo list.",
+                        content=None
+                    )
+            
+            elif action == "add_task":
+                if not self.tool.content:
+                    return ToolResult(
+                        success=False,
+                        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']}")
+                    return ToolResult(
+                        success=True,
+                        message="Task added successfully.",
+                        content=response
+                    )
+                else:
+                    return ToolResult(
+                        success=False,
+                        message="Failed to save new task.",
+                        content=None
+                    )
+            
+            elif action in ["update", "mark_progress", "mark_completed"]:
+                if not self.tool.task_id:
+                    return ToolResult(
+                        success=False,
+                        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:
+                    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:
+                    return ToolResult(
+                        success=False,
+                        message="Failed to save task update.",
+                        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_types.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from typing import List, Dict, Any, Callable, Optional, Type
+from typing import List, Dict, Any, Callable, Optional, Type, Union
 from pydantic import SkipValidation
 
 # Result class used by Tool Resolvers
@@ -60,9 +60,34 @@ class UseRAGTool(BaseTool):
     server_name: str
     query: str
 
-class ListPackageInfoTool(BaseTool):
+class ACModReadTool(BaseTool):
     path: str  # 源码包目录，相对路径或绝对路径
 
+class ACModWriteTool(BaseTool):
+    """
+    Tool for creating or updating an AC Module's .ac.mod.md file.
+    """
+    path: str  # AC Module directory path, relative or absolute path
+    diff: str  # diff content to edit the .ac.mod.md file
+
+class TodoReadTool(BaseTool):
+    """
+    Tool for reading the current todo list.
+    Takes no parameters.
+    """
+    pass  # No parameters needed
+
+class TodoWriteTool(BaseTool):
+    """
+    Tool for creating and managing a structured task list.
+    """
+    action: str  # 'create', 'update', 'mark_progress', 'mark_completed', 'add_task'
+    task_id: Optional[str] = None  # Task ID for update/mark operations
+    content: Optional[str] = None  # Task content for create/add operations
+    priority: Optional[str] = None  # 'high', 'medium', 'low'
+    status: Optional[str] = None  # 'pending', 'in_progress', 'completed'
+    notes: Optional[str] = None  # Additional notes for the task
+
 # Event Types for Rich Output Streaming
 class LLMOutputEvent(BaseModel):
     """Represents plain text output from the LLM."""
@@ -109,6 +134,20 @@ class WindowLengthChangeEvent(BaseModel):
     """Represents the token usage in the conversation window."""
     tokens_used: int
 
+# Base event class for all agent events
+class AgentEvent(BaseModel):
+    """Base class for all agent events."""
+    pass
+
+# Metadata for token usage tracking
+class SingleOutputMeta(BaseModel):
+    """Metadata for tracking token usage for a single LLM output."""
+    model_name: str
+    input_tokens: int
+    output_tokens: int
+    input_cost: float
+    output_cost: float
+
 # Deprecated: Will be replaced by specific Event types
 # class PlainTextOutput(BaseModel):
 #     text: str
@@ -127,8 +166,11 @@ TOOL_MODEL_MAP: Dict[str, Type[BaseTool]] = {
     "attempt_completion": AttemptCompletionTool,
     "plan_mode_respond": PlanModeRespondTool,
     "use_mcp_tool": UseMcpTool,
-    "use_rag_tool": UseRAGTool,
-    "list_package_info": ListPackageInfoTool,    
+    "use_rag_tool": UseRAGTool,    
+    "todo_read": TodoReadTool,
+    "todo_write": TodoWriteTool,
+    "ac_mod_read": ACModReadTool,
+    "ac_mod_write": ACModWriteTool,
 }
 
 class FileChangeEntry(BaseModel):
@@ -187,3 +229,4 @@ class AgenticEditConversationConfig(BaseModel):
     conversation_id: Optional[str] = None 
     action: Optional[str] = None
     query: Optional[str] = None
+    pull_request: bool = False

autocoder/common/v2/agent/runner/__init__.py

@@ -0,0 +1,31 @@
+"""
+Runner 模块提供了多种运行模式，用于在不同环境下执行 AgenticEdit 代理。
+
+这个模块包含三种主要的运行器:
+1. TerminalRunner: 在终端环境中运行代理，提供格式化输出
+2. EventRunner: 将代理事件转换为标准事件系统格式
+3. SdkRunner: 提供生成器接口，适用于SDK环境
+
+使用示例:
+```python
+from autocoder.common.v2.agent.runner import TerminalRunner
+from autocoder.common.v2.agent.agentic_edit_types import AgenticEditRequest
+
+runner = TerminalRunner(llm=llm, args=args, ...)
+runner.run(AgenticEditRequest(user_input="请帮我实现一个HTTP服务器"))
+```
+"""
+
+from .base_runner import BaseRunner
+from .terminal_runner import TerminalRunner
+from .event_runner import EventRunner
+from .sdk_runner import SdkRunner
+from .tool_display import get_tool_display_message
+
+__all__ = [
+    "BaseRunner",
+    "TerminalRunner",
+    "EventRunner",
+    "SdkRunner",
+    "get_tool_display_message"
+]

autocoder/common/v2/agent/runner/base_runner.py

@@ -0,0 +1,106 @@
+"""
+BaseRunner 提供了所有运行器的基础实现和接口定义。
+
+这个模块定义了代理运行的核心流程，包括请求处理、事件流生成和变更应用等。
+各种具体运行器通过继承 BaseRunner 并实现特定的运行逻辑来提供不同的运行模式。
+"""
+
+import logging
+from typing import Generator, Any, Dict, Optional, Callable, List
+
+from autocoder.common.v2.agent.agentic_edit_types import (
+    AgenticEditRequest, AgentEvent, CompletionEvent, 
+    AgenticEditConversationConfig, CommandConfig, MemoryConfig
+)
+from autocoder.common import AutoCoderArgs, SourceCodeList
+from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+from autocoder.common.printer import Printer
+
+logger = logging.getLogger(__name__)
+
+class BaseRunner:
+    """
+    代理运行器的基类，定义了运行代理的核心流程和接口。
+    
+    所有具体的运行器实现（终端、事件系统、SDK）都应该继承这个类，
+    并根据特定需求实现 run 方法。
+    """
+    
+    def __init__(
+        self,
+        llm: Any,
+        conversation_history: List[Dict[str, Any]],
+        files: SourceCodeList,
+        args: AutoCoderArgs,
+        memory_config: MemoryConfig,
+        command_config: Optional[CommandConfig] = None,
+        conversation_name: str = "current",
+        conversation_config: Optional[AgenticEditConversationConfig] = None
+    ):
+        """
+        初始化代理运行器。
+        
+        Args:
+            llm: 大语言模型实例
+            conversation_history: 对话历史
+            files: 源代码文件列表
+            args: 自动编码器参数
+            memory_config: 内存配置
+            command_config: 命令配置（可选）
+            conversation_name: 会话名称（默认为"current"）
+            conversation_config: 会话配置（可选）
+        """
+        self.llm = llm
+        self.conversation_history = conversation_history
+        self.files = files
+        self.args = args
+        self.memory_config = memory_config
+        self.command_config = command_config
+        self.conversation_name = conversation_name
+        self.conversation_config = conversation_config  
+        self.printer = Printer()              
+        
+        self.agent = AgenticEdit(
+            llm=llm,
+            conversation_history=conversation_history,
+            files=files,
+            args=args,
+            memory_config=memory_config,
+            command_config=command_config,
+            conversation_name=conversation_name,
+            conversation_config=conversation_config
+        )
+    
+    def run(self, request: AgenticEditRequest) -> Any:
+        """
+        运行代理处理请求。
+        
+        这是一个抽象方法，需要由子类实现。
+        
+        Args:
+            request: 代理编辑请求
+            
+        Returns:
+            根据具体实现返回不同类型的结果
+        """
+        raise NotImplementedError("子类必须实现run方法")
+    
+    def apply_pre_changes(self) -> None:
+        """应用预处理变更"""
+        self.agent.apply_pre_changes()
+    
+    def apply_changes(self) -> None:
+        """应用代理执行后的变更"""
+        self.agent.apply_changes()
+    
+    def analyze(self, request: AgenticEditRequest) -> Generator[AgentEvent, None, None]:
+        """
+        分析请求并生成事件流。
+        
+        Args:
+            request: 代理编辑请求
+            
+        Returns:
+            事件生成器
+        """
+        return self.agent.analyze(request)