auto-coder 0.1.361__py3-none-any.whl → 0.1.363__py3-none-any.whl

autocoder/agent/base_agentic/tools/talk_to_group_tool_resolver.py

@@ -0,0 +1,96 @@
+from typing import Optional, Dict, Any
+import os
+from loguru import logger
+from datetime import datetime
+
+from ..types import TalkToGroupTool, ToolResult
+from ..tools.base_tool_resolver import BaseToolResolver
+from ..agent_hub import AgentHub, Group
+
+
+class TalkToGroupToolResolver(BaseToolResolver):
+    """
+    处理talk_to_group工具的解析器
+    """
+    
+    def resolve(self) -> ToolResult:
+        """
+        解析和执行talk_to_group工具
+        
+        Returns:
+            ToolResult: 工具执行结果
+        """
+        try:
+            # 获取参数
+            group_name = self.tool.group_name
+            content = self.tool.content
+            mentions_names = self.tool.mentions or []
+            print_conversation = self.tool.print_conversation
+            
+            # 获取目标群组
+            groups = AgentHub.get_all_groups()
+            target_group = None
+            for group in groups:
+                if group.name == group_name:
+                    target_group = group
+                    break
+                    
+            if not target_group:
+                return ToolResult(
+                    success=False,
+                    message=f"找不到名为 '{group_name}' 的群组",
+                    content=None
+                )
+            
+            # 解析提及的代理
+            mentions = []
+            for name in mentions_names:
+                agent = AgentHub.get_agent(name)
+                if agent:
+                    mentions.append(agent)
+                else:
+                    logger.warning(f"找不到提及的代理: {name}")
+            
+            # 执行talk_to_group操作
+            self.agent.talk_to_group(
+                group=target_group, 
+                content=content, 
+                mentions=mentions, 
+                print_conversation=print_conversation
+            )
+            
+            # 获取群组消息历史
+            with target_group._history_lock:
+                group_history = target_group.history.copy()
+            
+            # 获取群组成员
+            with target_group._members_lock:
+                members = [member.name for member in target_group.members]
+            
+            # 格式化群组历史
+            formatted_history = f"群组：{group_name}\n"
+            formatted_history += f"成员：{', '.join(members)}\n\n"
+            formatted_history += "对话历史：\n\n"
+            
+            for msg in group_history:
+                sender_display = "你" if msg.sender == self.agent.name else msg.sender
+                mention_text = ""
+                if msg.mentions:
+                    mention_display = ["你" if m == self.agent.name else m for m in msg.mentions]
+                    mention_text = f" @{' @'.join(mention_display)}"
+                formatted_history += f"[{sender_display}]{mention_text}: {msg.content}\n\n"
+            
+            # 返回结果
+            return ToolResult(
+                success=True,
+                message=f"已向群组 '{group_name}' 探讨",
+                content=formatted_history
+            )
+            
+        except Exception as e:
+            logger.exception(f"执行talk_to_group工具时出错: {e}")
+            return ToolResult(
+                success=False,
+                message=f"执行talk_to_group工具时出错: {str(e)}",
+                content=None
+            ) 

autocoder/agent/base_agentic/tools/talk_to_tool_resolver.py

@@ -0,0 +1,79 @@
+from typing import Optional, Dict, Any
+import os
+from loguru import logger
+from datetime import datetime
+
+from ..types import TalkToTool, ToolResult
+from ..tools.base_tool_resolver import BaseToolResolver
+from ..agent_hub import AgentHub
+
+
+class TalkToToolResolver(BaseToolResolver):
+    """
+    处理talk_to工具的解析器
+    """
+    
+    def resolve(self) -> ToolResult:
+        """
+        解析和执行talk_to工具
+        
+        Returns:
+            ToolResult: 工具执行结果
+        """
+        try:
+            # 获取参数
+            agent_name = self.tool.agent_name
+            content = self.tool.content
+            mentions_names = self.tool.mentions or []
+            print_conversation = self.tool.print_conversation
+            
+            # 获取目标代理
+            target_agent = AgentHub.get_agent(agent_name)
+            if not target_agent:
+                return ToolResult(
+                    success=False,
+                    message=f"找不到名为 '{agent_name}' 的代理",
+                    content=None
+                )
+            
+            # 解析提及的代理
+            mentions = []
+            for name in mentions_names:
+                agent = AgentHub.get_agent(name)
+                if agent:
+                    mentions.append(agent)
+                else:
+                    logger.warning(f"找不到提及的代理: {name}")
+            
+            # 执行talk_to操作
+            self.agent.talk_to(
+                other=target_agent, 
+                content=content, 
+                mentions=mentions, 
+                print_conversation=print_conversation
+            )
+            
+            # 获取对话历史记录，格式化为易读的形式
+            with self.agent._chat_lock:
+                chat_history = self.agent.private_chats.get(agent_name, [])
+            
+            # 格式化聊天历史
+            formatted_history = "对话历史：\n\n"
+            for msg in chat_history:
+                sender_display = "你" if msg.sender == self.agent.name else msg.sender
+                formatted_history += f"[{sender_display}]: {msg.content}\n\n"
+            
+            # 返回结果
+            return ToolResult(
+                success=True,
+                message=f"已向Agent '{agent_name}' 讨论",
+                content=formatted_history
+            )
+            
+        except Exception as e:
+            logger.exception(f"执行talk_to工具时出错: {e}")
+            return ToolResult(
+                success=False,
+                message=f"执行talk_to工具时出错: {str(e)}",
+                content=None
+            ) 

autocoder/agent/base_agentic/tools/use_mcp_tool_resolver.py

@@ -0,0 +1,44 @@
+from typing import Dict, Any, Optional
+import typing
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.types import UseMcpTool, ToolResult # Import ToolResult from types
+from autocoder.common import AutoCoderArgs
+from loguru import logger
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+
+class UseMcpToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], tool: UseMcpTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: UseMcpTool = tool # For type hinting
+
+    def resolve(self) -> ToolResult:
+        """
+        Executes a tool via the Model Context Protocol (MCP) server.
+        """
+        final_query = ""
+        server_name = self.tool.server_name
+        tool_name = self.tool.tool_name
+
+        if server_name:
+            final_query += f"{server_name}\n"
+        
+        if tool_name:
+            final_query += f"{tool_name} is recommended for the following query:\n"
+        
+        final_query += f"{self.tool.query}"
+
+        logger.info(f"Resolving UseMcpTool: Server='{server_name}', Tool='{tool_name}', Query='{final_query}'")
+
+        mcp_server = get_mcp_server()
+        response = mcp_server.send_request(
+            McpRequest(
+                query=final_query,
+                model=self.args.inference_model or self.args.model,
+                product_mode=self.args.product_mode
+            )
+        )
+        return ToolResult(success=True, message=response.result)
+

autocoder/agent/base_agentic/tools/write_to_file_tool_resolver.py

@@ -0,0 +1,58 @@
+import os
+from typing import Dict, Any, Optional
+from autocoder.agent.base_agentic.types import WriteToFileTool, ToolResult  # Import ToolResult from types
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from loguru import logger
+from autocoder.common import AutoCoderArgs
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+class WriteToFileToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], tool: WriteToFileTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: WriteToFileTool = tool  # For type hinting
+        self.shadow_manager = self.agent.shadow_manager if self.agent else None
+
+    def resolve(self) -> ToolResult:
+        file_path = self.tool.path
+        content = self.tool.content
+        source_dir = self.args.source_dir or "."
+        abs_project_dir = os.path.abspath(source_dir)
+        abs_file_path = os.path.abspath(os.path.join(source_dir, file_path))
+
+        # Security check: ensure the path is within the source directory
+        if not abs_file_path.startswith(abs_project_dir):
+            return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
+
+        try:
+            if self.shadow_manager:
+                shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+                # Ensure shadow directory exists
+                os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
+                with open(shadow_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
+
+                # 回调AgenticEdit，记录变更
+                if self.agent:
+                    rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                    self.agent.record_file_change(rel_path, "added", diff=None, content=content)
+
+                return ToolResult(success=True, message=f"Successfully wrote to file (shadow): {file_path}", content=content)
+            else:
+                # No shadow manager fallback to original file
+                os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)
+                with open(abs_file_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                logger.info(f"Successfully wrote to file: {file_path}")
+
+                if self.agent:
+                    rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                    self.agent.record_file_change(rel_path, "added", diff=None, content=content)
+
+                return ToolResult(success=True, message=f"Successfully wrote to file: {file_path}", content=content)
+        except Exception as e:
+            logger.error(f"Error writing to file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")

autocoder/agent/base_agentic/types.py

@@ -0,0 +1,189 @@
+from pydantic import BaseModel, SkipValidation
+from typing import List, Dict, Any, Optional, Type, Union, Tuple, Generator, Literal
+
+
+# 工具结果类，由工具解析器使用
+class ToolResult(BaseModel):
+    """
+    工具执行结果
+    """
+    success: bool = False  # 执行是否成功
+    message: str = ""  # 结果消息
+    content: Any = None  # 返回内容，可以是任何类型
+
+
+# 工具的基本Pydantic模型
+class BaseTool(BaseModel):
+    """
+    代理工具的基类，所有工具类都应继承此类
+    """
+    pass
+
+
+class ExecuteCommandTool(BaseTool):
+    command: str
+    requires_approval: bool
+
+class ReadFileTool(BaseTool):
+    path: str
+
+class WriteToFileTool(BaseTool):
+    path: str
+    content: str
+
+class ReplaceInFileTool(BaseTool):
+    path: str
+    diff: str
+
+class SearchFilesTool(BaseTool):
+    path: str
+    regex: str
+    file_pattern: Optional[str] = None
+
+class ListFilesTool(BaseTool):
+    path: str
+    recursive: Optional[bool] = False
+
+class AskFollowupQuestionTool(BaseTool):
+    question: str
+    options: Optional[List[str]] = None
+
+class AttemptCompletionTool(BaseTool):
+    result: str
+    command: Optional[str] = None
+
+class PlanModeRespondTool(BaseTool):
+    response: str
+    options: Optional[List[str]] = None
+
+class UseMcpTool(BaseTool):
+    server_name: str
+    tool_name: str
+    query:str  
+
+class TalkToTool(BaseTool):
+    agent_name: str
+    content: str
+    mentions: List[str] = []
+    print_conversation: bool = False
+
+class TalkToGroupTool(BaseTool):
+    group_name: str
+    content: str
+    mentions: List[str] = []
+    print_conversation: bool = False
+
+
+# 工具指南相关类型
+class ToolDescription(BaseModel):
+    """
+    工具描述
+    """
+    description: str  # 工具描述内容    
+
+
+class ToolExample(BaseModel):
+    """
+    工具使用示例
+    """
+    title: str  # 示例标题
+    body: str   # 示例内容
+
+
+class RoleDescription(BaseModel):
+    """
+    代理角色描述
+    """
+    agent_type: str  # 代理类型
+    description: str  # 角色描述
+
+
+# 事件类型，用于流式输出
+class LLMOutputEvent(BaseModel):
+    """表示来自LLM的纯文本输出"""
+    text: str
+
+
+class LLMThinkingEvent(BaseModel):
+    """表示来自LLM的<thinking>标签内的文本"""
+    text: str
+
+
+class ToolCallEvent(BaseModel):
+    """表示LLM决定调用工具"""
+    tool: SkipValidation[BaseTool]  # 使用SkipValidation因为BaseTool本身很复杂
+    tool_xml: str
+
+
+class ToolResultEvent(BaseModel):
+    """表示执行工具的结果"""
+    tool_name: str
+    result: ToolResult
+
+
+class TokenUsageEvent(BaseModel):
+    """表示Token使用情况"""
+    usage: Any
+
+
+class CompletionEvent(BaseModel):
+    """表示LLM尝试完成任务"""
+    completion: Any  # 完成的工具，使用Any以避免循环导入
+    completion_xml: str
+
+
+class ErrorEvent(BaseModel):
+    """表示过程中的错误"""
+    message: str
+
+class PlanModeRespondEvent(BaseModel):
+    """Represents the LLM attempting to complete the task."""
+    completion: SkipValidation[PlanModeRespondTool] # Skip validation
+    completion_xml: str    
+
+
+# 工具执行中的事件类型联合
+AgentEvent = Union[
+    LLMOutputEvent,
+    LLMThinkingEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+    TokenUsageEvent,
+    CompletionEvent,
+    ErrorEvent,
+    PlanModeRespondEvent
+]
+
+
+# 文件变更记录
+class FileChangeEntry(BaseModel):
+    """
+    文件变更条目，用于记录文件的变更信息
+    """
+    type: str  # 'added' 或 'modified'
+    diffs: List[str] = []  # 使用 replace_in_file 时，记录 diff 内容
+    content: Optional[str] = None  # 使用 write_to_file 时，记录文件内容
+
+
+# 代理编辑请求
+class AgentRequest(BaseModel):
+    """
+    代理请求
+    """
+    user_input: str 
+
+
+class Message(BaseModel):
+    sender: str
+    content: str
+    mentions: List[str] = []
+    is_group: bool = False
+    group_name: Optional[str] = None
+    reply_config: Dict[str, Any] = {}
+
+class ReplyDecision(BaseModel):
+    content: str
+    strategy: Literal["broadcast", "private", "ignore"] 
+    mentions: List[str] = []
+    priority: int = 0
+    reason: str = ""

autocoder/agent/base_agentic/utils.py

@@ -0,0 +1,100 @@
+from datetime import datetime
+import typing
+
+if typing.TYPE_CHECKING:
+    from .agent_hub import Group
+import byzerllm
+from typing import Union,List
+from concurrent.futures import ThreadPoolExecutor
+from pydantic import BaseModel
+import threading
+from loguru import logger
+class GroupMember(BaseModel):
+    member: str
+    reason: str
+
+class GroupMemberResponse(BaseModel):
+    group_name: str
+    members: List[GroupMember]
+
+class GroupUtils:
+    _executor = ThreadPoolExecutor(max_workers=8)
+    _executor_lock = threading.Lock()
+
+    def __init__(self, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]):
+        self.llm = llm
+
+    def auto_select_group(self, content: str, groups: List['Group']) -> List[GroupMemberResponse]:
+        futures = []
+        with self._executor_lock:
+            for group in groups:
+                future = self._executor.submit(
+                    self._safe_select_group,
+                    content,
+                    group
+                )
+                futures.append((group.name, future))
+
+        results = []
+        for group_name, future in futures:
+            try:
+                members = future.result()
+                if members and len(members) > 0:
+                    results.append(GroupMemberResponse(
+                        group_name=group_name,
+                        members=members
+                    ))
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                logger.error(f"Failed to select group {group_name}: {str(e)}")
+        
+        return results
+
+    def _safe_select_group(self, content: str, group: 'Group') -> List[GroupMember]:
+        try:
+            return self.select_group.with_llm(self.llm).with_return_type(List[GroupMember]).run(content=content, group=group)
+        except Exception as e:
+            logger.error(f"Error in select_group: {str(e)}")
+            return []
+    
+    @byzerllm.prompt()
+    def select_group(self, content: str, group: 'Group') -> List[GroupMember]:
+        '''
+        当前时间: {{ time }}
+        用户发来了如下问题:
+        <user_question>
+        {{ content }}
+        </user_question>
+
+        下面是群组 {{ group_name }} 所有成员及其对应的角色：
+        {% for member_info in members_info %}
+        ===== {{ member_info[0] }} =====
+        <who_are_you>
+        {{ member_info[1] }}
+        </who_are_you>
+        {% endfor %}
+
+        请分析该群组中的成员是否有人可以回答用户的问题。
+
+        请生成 JSON 格式回复：
+
+        ```json
+        [
+            {
+                "member": "可以回答用户问题的用户名",
+                "reason": "选择这些用户的原因"
+            }
+        ]
+        ```
+        如果群组中没有合适的成员可以回答问题，请返回空列表。
+        请严格按照 JSON 格式输出，不要有任何多余的内容。
+        '''
+        members_info = [(member.name, member.system_prompt) for member in group.members]
+        
+        context = {
+            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),            
+            "group_name": group.name,
+            "members_info": members_info
+        }
+        return context

autocoder/auto_coder.py

@@ -1069,7 +1069,7 @@ def main(input_args: Optional[List[str]] = None):
                         border_style="green",
                     )
                 )
-                if not args.query:
+                if not args.query or (args.query_prefix and args.query == args.query_prefix) or (args.query_suffix and args.query == args.query_suffix):
                     return
 
             if os.path.exists(memory_file):

autocoder/auto_coder_runner.py

@@ -65,6 +65,7 @@ from loguru import logger as global_logger
 from autocoder.utils.project_structure import EnhancedFileAnalyzer
 from autocoder.common import SourceCodeList,SourceCode
 from autocoder.common.file_monitor import FileMonitor
+from filelock import FileLock
 
 
 ## 对外API，用于第三方集成 auto-coder 使用。
@@ -230,7 +231,7 @@ def get_all_extensions(directory: str = ".") -> str:
     return ",".join(sorted(all_extensions))
 
 def configure_logger():
-    # 设置日志目录和文件
+    # 设置日志目录和文件    
     log_dir = os.path.join(project_root, ".auto-coder", "logs")
     os.makedirs(log_dir, exist_ok=True)
     log_file = os.path.join(log_dir, "auto-coder.log")
@@ -257,13 +258,26 @@ def configure_logger():
         ]
     )
 
-configure_logger()
+def init_singleton_instances():
+    # 初始化文件监控系统
+    try:
+        FileMonitor(project_root).start()
+    except Exception as e:
+        global_logger.error(f"Failed to start file monitor: {e}")
+        global_logger.exception(e)
+    
+    # 初始化规则文件管理器
+    from autocoder.common.rulefiles.autocoderrules_utils import get_rules
+    get_rules(project_root=project_root)
+
+    # 初始化忽略文件管理器
+    from autocoder.common.ignorefiles.ignore_file_utils import IgnoreFileManager
+    _ = IgnoreFileManager(project_root=project_root)
+
 
-try:
-    FileMonitor(project_root).start()
-except Exception as e:
-    global_logger.error(f"Failed to start file monitor: {e}")
-    global_logger.exception(e)
+if os.environ.get('autocoder_auto_init',"true") in ["true","True","True",True]:
+    configure_logger()
+    init_singleton_instances()
 
 def initialize_system(args:InitializeSystemRequest):
     from autocoder.utils.model_provider_selector import ModelProviderSelector
@@ -633,20 +647,28 @@ def get_symbol_list() -> List[SymbolItem]:
 
 
 def save_memory():
-    with open(os.path.join(base_persist_dir, "memory.json"), "w",encoding="utf-8") as f:
-        json.dump(memory, f, indent=2, ensure_ascii=False)
+    memory_path = os.path.join(base_persist_dir, "memory.json")
+    lock_path = memory_path + ".lock"
+    
+    with FileLock(lock_path, timeout=30):
+        with open(memory_path, "w", encoding="utf-8") as f:
+            json.dump(memory, f, indent=2, ensure_ascii=False)
+    
     load_memory()
 
 
 def load_memory():    
     global memory
     memory_path = os.path.join(base_persist_dir, "memory.json")
+    lock_path = memory_path + ".lock"
+    
     if os.path.exists(memory_path):
-        with open(memory_path, "r", encoding="utf-8") as f:
-            _memory = json.load(f)
-        # clear memory
-        memory.clear()
-        memory.update(_memory)    
+        with FileLock(lock_path, timeout=30):
+            with open(memory_path, "r", encoding="utf-8") as f:
+                _memory = json.load(f)
+            # clear memory
+            memory.clear()
+            memory.update(_memory)    
     return memory
 
 def get_memory():