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

autocoder/common/agent_query_queue/queue_manager.py

@@ -0,0 +1,325 @@
+
+import os
+import json
+import uuid
+import threading
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from enum import Enum
+from loguru import logger as global_logger
+
+
+class QueueTaskStatus(Enum):
+    """队列任务状态枚举"""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class QueueTask:
+    """队列任务数据结构"""
+    task_id: str
+    user_query: str  # 用户需求而非命令
+    model: str  # 使用的模型
+    status: QueueTaskStatus
+    created_at: datetime
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    result: Optional[str] = None
+    error_message: Optional[str] = None
+    priority: int = 0  # 优先级，数字越大优先级越高
+    worktree_name: Optional[str] = None  # worktree 名称
+    # 兼容旧版本
+    command: Optional[str] = None  # 保留以兼容旧数据
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式"""
+        data = asdict(self)
+        # 处理datetime和enum类型
+        data['status'] = self.status.value
+        data['created_at'] = self.created_at.isoformat() if self.created_at else None
+        data['started_at'] = self.started_at.isoformat() if self.started_at else None
+        data['completed_at'] = self.completed_at.isoformat() if self.completed_at else None
+        return data
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'QueueTask':
+        """从字典创建任务对象"""
+        # 处理datetime和enum类型
+        data['status'] = QueueTaskStatus(data['status'])
+        data['created_at'] = datetime.fromisoformat(data['created_at']) if data.get('created_at') else None
+        data['started_at'] = datetime.fromisoformat(data['started_at']) if data.get('started_at') else None
+        data['completed_at'] = datetime.fromisoformat(data['completed_at']) if data.get('completed_at') else None
+        
+        # 兼容旧版本数据
+        if 'command' in data and 'user_query' not in data:
+            data['user_query'] = data['command']
+        if 'model' not in data:
+            data['model'] = 'auto'
+        
+        # 只传递存在的字段
+        valid_fields = {'task_id', 'user_query', 'model', 'status', 'created_at', 
+                       'started_at', 'completed_at', 'result', 'error_message', 
+                       'priority', 'worktree_name', 'command'}
+        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
+        
+        return cls(**filtered_data)
+
+
+class QueueManager:
+    """队列管理器"""
+    
+    def __init__(self, queue_dir: Optional[str] = None):
+        """
+        初始化队列管理器
+        
+        Args:
+            queue_dir: 队列数据存储目录，默认为 ~/.auto-coder/queue
+        """
+        if queue_dir is None:
+            self.queue_dir = Path.home() / ".auto-coder" / "queue"
+        else:
+            self.queue_dir = Path(queue_dir)
+        
+        self.queue_dir.mkdir(parents=True, exist_ok=True)
+        self.queue_file = self.queue_dir / "tasks.json"
+        self._lock = threading.Lock()
+        
+        # 初始化队列文件
+        if not self.queue_file.exists():
+            self._save_tasks([])
+    
+    def _load_tasks(self) -> List[QueueTask]:
+        """加载所有任务"""
+        try:
+            with open(self.queue_file, 'r', encoding='utf-8') as f:
+                tasks_data = json.load(f)
+                return [QueueTask.from_dict(task_data) for task_data in tasks_data]
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            global_logger.warning(f"Failed to load tasks: {e}")
+            return []
+    
+    def _save_tasks(self, tasks: List[QueueTask]) -> None:
+        """保存所有任务"""
+        try:
+            tasks_data = [task.to_dict() for task in tasks]
+            with open(self.queue_file, 'w', encoding='utf-8') as f:
+                json.dump(tasks_data, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            global_logger.error(f"Failed to save tasks: {e}")
+            raise
+    
+    def add_task(self, user_query: str = None, model: str = "auto", priority: int = 0, command: str = None, worktree_name: str = None) -> str:
+        """
+        添加新任务到队列
+        
+        Args:
+            user_query: 用户需求
+            model: 使用的模型
+            priority: 任务优先级，数字越大优先级越高
+            command: 旧版本兼容参数
+            worktree_name: 自定义 worktree 名称
+            
+        Returns:
+            str: 任务ID
+        """
+        with self._lock:
+            task_id = str(uuid.uuid4())[:8]  # 使用8位UUID作为任务ID
+            
+            # 兼容旧版本
+            if command and not user_query:
+                user_query = command
+            
+            task = QueueTask(
+                task_id=task_id,
+                user_query=user_query,
+                model=model,
+                status=QueueTaskStatus.PENDING,
+                created_at=datetime.now(),
+                priority=priority,
+                worktree_name=worktree_name,
+                command=command  # 兼容字段
+            )
+            
+            tasks = self._load_tasks()
+            tasks.append(task)
+            
+            # 按优先级和创建时间排序（优先级高的在前，同优先级按创建时间排序）
+            tasks.sort(key=lambda t: (-t.priority, t.created_at))
+            
+            self._save_tasks(tasks)
+            global_logger.info(f"Added task {task_id}: {user_query[:100]}..." if len(user_query) > 100 else f"Added task {task_id}: {user_query}")
+            return task_id
+    
+    def get_task(self, task_id: str) -> Optional[QueueTask]:
+        """
+        获取指定任务
+        
+        Args:
+            task_id: 任务ID
+            
+        Returns:
+            QueueTask: 任务对象，如果不存在返回None
+        """
+        tasks = self._load_tasks()
+        for task in tasks:
+            if task.task_id == task_id:
+                return task
+        return None
+    
+    def list_tasks(self, status_filter: Optional[QueueTaskStatus] = None) -> List[QueueTask]:
+        """
+        列出所有任务
+        
+        Args:
+            status_filter: 状态过滤器，只返回指定状态的任务
+            
+        Returns:
+            List[QueueTask]: 任务列表
+        """
+        tasks = self._load_tasks()
+        if status_filter:
+            tasks = [task for task in tasks if task.status == status_filter]
+        return tasks
+    
+    def remove_task(self, task_id: str) -> bool:
+        """
+        移除指定任务
+        
+        Args:
+            task_id: 任务ID
+            
+        Returns:
+            bool: 是否成功移除
+        """
+        with self._lock:
+            tasks = self._load_tasks()
+            original_count = len(tasks)
+            
+            # 只允许移除非运行状态的任务
+            tasks = [task for task in tasks if not (
+                task.task_id == task_id and task.status != QueueTaskStatus.RUNNING
+            )]
+            
+            if len(tasks) < original_count:
+                self._save_tasks(tasks)
+                global_logger.info(f"Removed task {task_id}")
+                return True
+            else:
+                global_logger.warning(f"Task {task_id} not found or is running")
+                return False
+    
+    def update_task_status(self, task_id: str, status: QueueTaskStatus, 
+                          result: Optional[str] = None, 
+                          error_message: Optional[str] = None) -> bool:
+        """
+        更新任务状态
+        
+        Args:
+            task_id: 任务ID
+            status: 新状态
+            result: 执行结果
+            error_message: 错误信息
+            
+        Returns:
+            bool: 是否更新成功
+        """
+        with self._lock:
+            tasks = self._load_tasks()
+            for task in tasks:
+                if task.task_id == task_id:
+                    task.status = status
+                    
+                    if status == QueueTaskStatus.RUNNING and task.started_at is None:
+                        task.started_at = datetime.now()
+                    elif status in [QueueTaskStatus.COMPLETED, QueueTaskStatus.FAILED, QueueTaskStatus.CANCELLED]:
+                        task.completed_at = datetime.now()
+                    
+                    if result is not None:
+                        task.result = result
+                    if error_message is not None:
+                        task.error_message = error_message
+                    
+                    self._save_tasks(tasks)
+                    global_logger.info(f"Updated task {task_id} status to {status.value}")
+                    return True
+            
+            global_logger.warning(f"Task {task_id} not found")
+            return False
+    
+    def get_next_pending_task(self) -> Optional[QueueTask]:
+        """
+        获取下一个待执行的任务（优先级最高的pending任务）
+        
+        Returns:
+            QueueTask: 下一个待执行的任务，如果没有返回None
+        """
+        tasks = self._load_tasks()
+        pending_tasks = [task for task in tasks if task.status == QueueTaskStatus.PENDING]
+        
+        if not pending_tasks:
+            return None
+        
+        # 返回优先级最高的任务（已经按优先级排序）
+        return pending_tasks[0]
+    
+    def get_running_tasks(self) -> List[QueueTask]:
+        """
+        获取所有正在运行的任务
+        
+        Returns:
+            List[QueueTask]: 正在运行的任务列表
+        """
+        return self.list_tasks(QueueTaskStatus.RUNNING)
+    
+    def clear_completed_tasks(self) -> int:
+        """
+        清理已完成的任务
+        
+        Returns:
+            int: 清理的任务数量
+        """
+        with self._lock:
+            tasks = self._load_tasks()
+            original_count = len(tasks)
+            
+            # 保留未完成的任务
+            tasks = [task for task in tasks if task.status not in [
+                QueueTaskStatus.COMPLETED, 
+                QueueTaskStatus.FAILED, 
+                QueueTaskStatus.CANCELLED
+            ]]
+            
+            removed_count = original_count - len(tasks)
+            if removed_count > 0:
+                self._save_tasks(tasks)
+                global_logger.info(f"Cleared {removed_count} completed tasks")
+            
+            return removed_count
+    
+    def get_queue_statistics(self) -> Dict[str, int]:
+        """
+        获取队列统计信息
+        
+        Returns:
+            Dict[str, int]: 统计信息
+        """
+        tasks = self._load_tasks()
+        stats = {
+            'total': len(tasks),
+            'pending': 0,
+            'running': 0,
+            'completed': 0,
+            'failed': 0,
+            'cancelled': 0
+        }
+        
+        for task in tasks:
+            stats[task.status.value] += 1
+        
+        return stats

autocoder/common/agents/__init__.py

@@ -0,0 +1,11 @@
+"""
+AutoCoder Agents Module
+
+This module provides functionality to read and parse agent definitions from .md files
+in the .autocoderagents directory.
+"""
+
+from .agent_manager import AgentManager
+from .agent_parser import AgentParser, Agent
+
+__all__ = ['AgentManager', 'AgentParser', 'Agent']

autocoder/common/agents/agent_manager.py

@@ -0,0 +1,323 @@
+import shlex
+import os
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+from loguru import logger
+import byzerllm
+
+from .agent_parser import AgentParser, Agent
+
+# 导入优先级目录查找器
+from autocoder.common.priority_directory_finder import (
+    PriorityDirectoryFinder, FinderConfig, SearchStrategy, 
+    ValidationMode, create_file_filter
+)
+
+
+class AgentManager:
+    """Manager for loading and accessing agent definitions with multi-directory support."""
+    
+    def __init__(self, project_root: str):
+        """
+        Initialize AgentManager.
+        
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = Path(project_root)
+        self.agents: Dict[str, Agent] = {}
+        self.agents_directories: List[str] = []
+        self._load_agents()
+    
+    def _get_agents_search_paths(self) -> List[Path]:
+        """
+        Get the list of directories to search for agents, in priority order.
+        
+        Returns:
+            List of Path objects in priority order:
+            1. Project directory/.autocoderagents
+            2. Project directory/.auto-coder/.autocoderagents  
+            3. ~/.auto-coder/.autocoderagents
+        """
+        search_paths = []
+        
+        # 1. Project directory/.autocoderagents (highest priority)
+        project_agents_dir = self.project_root / ".autocoderagents"
+        search_paths.append(project_agents_dir)
+        
+        # 2. Project directory/.auto-coder/.autocoderagents
+        project_autocoder_dir = self.project_root / ".auto-coder" / ".autocoderagents"
+        search_paths.append(project_autocoder_dir)
+        
+        # 3. ~/.auto-coder/.autocoderagents (lowest priority)
+        home_autocoder_dir = Path.home() / ".auto-coder" / ".autocoderagents"
+        search_paths.append(home_autocoder_dir)
+        
+        return search_paths
+    
+    def _load_agents(self) -> None:
+        """
+        使用优先级目录查找器加载 agent 定义。
+        采用 MERGE_ALL 策略，合并所有目录中的 agent 定义，支持优先级覆盖和repos功能。
+        """
+        try:
+            # 创建文件过滤器，只查找.md文件
+            md_filter = create_file_filter(extensions=[".md"], recursive=False)
+            
+            # 创建查找器配置，使用MERGE_ALL策略合并所有目录
+            config = FinderConfig(strategy=SearchStrategy.MERGE_ALL)
+            
+            # 获取项目名用于repos目录
+            project_name = self.project_root.name
+            
+            # 按优先级添加目录配置
+            config.add_directory(
+                path=str(self.project_root / ".autocoderagents"),
+                priority=1,
+                validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+                file_filter=md_filter,
+                description="项目级agent目录"
+            )
+            config.add_directory(
+                path=str(self.project_root / ".auto-coder" / ".autocoderagents"),
+                priority=2,
+                validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+                file_filter=md_filter,
+                description="项目.auto-coder agent目录"
+            )
+            config.add_directory(
+                path="~/.auto-coder/.autocoderagents",
+                priority=3,
+                validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+                file_filter=md_filter,
+                description="全局agent目录"
+            )
+            # 添加repos目录支持
+            repos_dir = f"~/.auto-coder/.autocoderagents/repos/{project_name}"
+            config.add_directory(
+                path=repos_dir,
+                priority=4,
+                validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+                file_filter=md_filter,
+                description=f"项目特定repos agent目录: {project_name}"
+            )
+            
+            # 执行查找
+            finder = PriorityDirectoryFinder(config)
+            result = finder.find_directories()
+            
+            if result.success and result.selected_directories:
+                logger.info(f"使用优先级查找器找到 {len(result.selected_directories)} 个agent目录")
+                self.agents_directories = result.selected_directories
+                
+                # 按优先级顺序加载agents，高优先级覆盖低优先级
+                for agents_dir in self.agents_directories:
+                    logger.info(f"加载agent目录: {agents_dir}")
+                    self._load_agents_from_directory(Path(agents_dir))
+            else:
+                logger.info("优先级查找器未找到包含agent文件的目录")
+                self.agents_directories = []
+                
+        except Exception as e:
+            logger.error(f"使用优先级查找器加载agents时出错: {e}")
+            # 回退到传统方法
+            self._load_agents_fallback()
+    
+    def _load_agents_from_directory(self, agents_dir: Path) -> None:
+        """Load agents from a specific directory with priority-based override logic."""
+        if not agents_dir.exists():
+            logger.debug(f"Agents directory not found: {agents_dir}")
+            return
+            
+        if not agents_dir.is_dir():
+            logger.warning(f"Expected directory but found file: {agents_dir}")
+            return
+        
+        # Find all .md files in the agents directory
+        md_files = list(agents_dir.glob("*.md"))
+        
+        if md_files:
+            logger.debug(f"Found {len(md_files)} agent files in {agents_dir}")
+        
+        for md_file in md_files:
+            try:
+                agent = AgentParser.parse_agent_file(md_file)
+                
+                # Validate agent
+                errors = AgentParser.validate_agent(agent)
+                if errors:
+                    logger.error(f"Validation errors for {md_file.name}: {'; '.join(errors)}")
+                    continue
+                
+                # 检查是否已有同名agent，实现优先级覆盖逻辑
+                if agent.name in self.agents:
+                    old_agent_path = self.agents[agent.name].file_path
+                    # 由于我们按优先级顺序加载，后加载的优先级更低，所以跳过
+                    logger.debug(f"跳过agent '{agent.name}' from {md_file} (已存在优先级更高的版本: {old_agent_path})")
+                    continue
+                    
+                self.agents[agent.name] = agent
+                logger.debug(f"Loaded agent '{agent.name}' from {md_file}")
+                
+            except Exception as e:
+                logger.error(f"Failed to parse agent file {md_file.name}: {e}")
+    
+    def _load_agents_fallback(self) -> None:
+        """回退到传统的agent加载方法"""
+        logger.info("回退到传统的agent目录查找方法")
+        search_paths = self._get_agents_search_paths()
+        
+        # Load agents from all directories, with higher priority directories loaded last
+        # This way higher priority agents will overwrite lower priority ones
+        for agents_dir in reversed(search_paths):  # Start with lowest priority
+            self._load_agents_from_directory(agents_dir)
+    
+    def get_agent(self, name: str) -> Optional[Agent]:
+        """
+        Get an agent by name.
+        
+        Args:
+            name: Name of the agent
+            
+        Returns:
+            Agent object if found, None otherwise
+        """
+        return self.agents.get(name)
+    
+    def list_agents(self) -> List[Agent]:
+        """
+        Get a list of all loaded agents.
+        
+        Returns:
+            List of Agent objects
+        """
+        return list(self.agents.values())
+    
+    def get_agent_names(self) -> List[str]:
+        """
+        Get a list of all agent names.
+        
+        Returns:
+            List of agent names
+        """
+        return list(self.agents.keys())
+    
+    @byzerllm.prompt()
+    def render_sub_agents_section(self, current_model: Optional[str] = None) -> str:
+        """
+        {% if not agents_available %}
+        {% else %}                        
+        ## Available Named Sub Agents
+
+        The following specialized agents are available for delegation:
+
+        {% for agent in sorted_agents %}
+        ### {{ agent.name }}
+        **Description**: {{ agent.description }}
+        {% if agent.tools %}
+        **Available Tools**: {{ agent.tools | join(', ') }}
+        {% endif %}
+        
+        {% endfor %}        
+        ## How to Use
+
+        Use the `run_named_subagents` tool to run multiple agent commands:
+
+        ### Example: Parallel Execution
+        
+        <run_named_subagents>
+        <subagents>
+        mode: parallel
+        subagents:
+        {% for agent in example_agents %}
+            - name: {{ agent.name }}
+              task: {{ agent.example_task }}
+        {% endfor %}
+        </subagents>
+        </run_named_subagents>
+        
+
+        ### Example: Serial Execution
+        
+        <run_named_subagents>
+        <subagents>
+        mode: serial
+        subagents:
+            - name: agent_name
+              task: your task description here
+        </subagents>
+        </run_named_subagents>
+                                
+        {% endif %}
+        """
+        if not self.agents:
+            return {
+                "agents_available": False
+            }
+        
+        # Sort agents by name for consistent output
+        sorted_agents = sorted(self.agents.values(), key=lambda a: a.name)
+        
+        # Prepare agent data for template
+        agents_data = []
+        for agent in sorted_agents:
+            model_to_use = agent.model or current_model
+            if not model_to_use:
+                raise ValueError(f"Agent {agent.name} has no model specified and no current model provided")
+
+            # Use shlex.quote for safe shell escaping
+            safe_task = shlex.quote("YOUR_TASK_HERE")
+            safe_model = shlex.quote(model_to_use)
+            safe_prompt = shlex.quote(agent.content)
+            command = f'echo {safe_task} | auto-coder.run --model {safe_model} --system-prompt {safe_prompt}'
+            
+            agents_data.append({
+                "name": agent.name,
+                "description": agent.description,
+                "tools": agent.tools if agent.tools else None,
+                "command": command
+            })
+        
+        # Prepare example agents data
+        example_agents_data = []
+        example_agents = sorted_agents[:2] if len(sorted_agents) >= 2 else sorted_agents
+        for agent in example_agents:
+            example_agents_data.append({
+                "name": agent.name,
+                "example_task": f"Task for {agent.name}"
+            })
+        
+        return {
+            "agents_available": True,
+            "sorted_agents": agents_data,
+            "example_agents": example_agents_data
+        } # type: ignore
+    
+    def reload_agents(self) -> None:
+        """Reload all agents from the directory."""
+        self.agents.clear()
+        self._load_agents()
+    
+    def get_all_agents_directories(self) -> List[str]:
+        """
+        获取所有agent目录路径
+        
+        Returns:
+            List[str]: 所有agent目录路径列表，按优先级排序
+        """
+        return self.agents_directories.copy()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the agent manager state to a dictionary.
+        
+        Returns:
+            Dictionary representation of all agents
+        """
+        search_paths = self._get_agents_search_paths()
+        return {
+            'project_root': str(self.project_root),
+            'search_paths': [str(path) for path in search_paths],
+            'agents_directories': self.agents_directories,
+            'agents': {name: agent.to_dict() for name, agent in self.agents.items()}
+        }