auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/v2/agent/tool_caller/integration_test.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Tool Caller Integration Test
+
+验证 ToolCaller 与 AgenticEdit 的集成是否正常工作。
+"""
+
+import sys
+import os
+
+# 添加项目根目录到 Python 路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../../../../..'))
+
+from unittest.mock import Mock
+from autocoder.common import AutoCoderArgs
+from autocoder.common.v2.agent.agentic_edit_types import ExecuteCommandTool, ToolResult
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.tool_caller import ToolCaller
+from autocoder.common.v2.agent.tool_caller.plugins.examples import LoggingPlugin, SecurityFilterPlugin
+
+
+class TestToolResolver(BaseToolResolver):
+    """测试用的工具解析器"""
+    
+    def resolve(self) -> ToolResult:
+        if isinstance(self.tool, ExecuteCommandTool):
+            return ToolResult(
+                success=True,
+                message=f"Test: Command '{self.tool.command}' executed",
+                content={"output": f"Mock output for: {self.tool.command}"}
+            )
+        else:
+            return ToolResult(
+                success=False,
+                message=f"Test: Unsupported tool type {type(self.tool).__name__}"
+            )
+
+
+def test_tool_caller_basic():
+    """测试 ToolCaller 基本功能"""
+    print("Testing ToolCaller basic functionality...")
+    
+    # 创建工具解析器映射
+    tool_resolver_map = {
+        ExecuteCommandTool: TestToolResolver
+    }
+    
+    # 创建 ToolCaller
+    args = AutoCoderArgs(source_dir=".")
+    tool_caller = ToolCaller(
+        tool_resolver_map=tool_resolver_map,
+        args=args,
+        enable_plugins=True
+    )
+    
+    # 测试工具调用
+    tool = ExecuteCommandTool(command="echo 'test'", requires_approval=False)
+    result = tool_caller.call_tool(tool)
+    
+    assert result.success, f"Tool call failed: {result.message}"
+    print("✓ Basic tool calling works")
+    
+    return tool_caller
+
+
+def test_plugin_system(tool_caller):
+    """测试插件系统"""
+    print("Testing plugin system...")
+    
+    # 注册插件
+    logging_plugin = LoggingPlugin(enabled=True)
+    security_plugin = SecurityFilterPlugin(enabled=True)
+    
+    assert tool_caller.register_plugin(logging_plugin), "Failed to register logging plugin"
+    assert tool_caller.register_plugin(security_plugin), "Failed to register security plugin"
+    print("✓ Plugin registration works")
+    
+    # 检查插件状态
+    status = tool_caller.get_plugin_status()
+    assert status["total_plugins"] == 2, f"Expected 2 plugins, got {status['total_plugins']}"
+    assert status["enabled_plugins"] == 2, f"Expected 2 enabled plugins, got {status['enabled_plugins']}"
+    print("✓ Plugin status reporting works")
+    
+    # 测试插件功能
+    safe_tool = ExecuteCommandTool(command="echo 'safe'", requires_approval=False)
+    result = tool_caller.call_tool(safe_tool)
+    assert result.success, "Safe tool call failed"
+    print("✓ Safe tool call with plugins works")
+    
+    # 测试安全过滤
+    dangerous_tool = ExecuteCommandTool(command="rm -rf /", requires_approval=False)
+    result = tool_caller.call_tool(dangerous_tool)
+    assert result.success, "Dangerous tool should be blocked but return success"
+    print("✓ Security filtering works")
+    
+    # 检查统计
+    log_stats = logging_plugin.get_statistics()
+    assert log_stats["total_logged_calls"] > 0, "No calls logged"
+    print("✓ Logging plugin statistics work")
+    
+    filter_stats = security_plugin.get_filter_statistics()
+    assert filter_stats["blocked_count"] > 0, "No dangerous commands blocked"
+    print("✓ Security filter statistics work")
+
+
+def test_integration_with_mock_agent():
+    """测试与模拟代理的集成"""
+    print("Testing integration with mock agent...")
+    
+    # 创建模拟代理
+    mock_agent = Mock()
+    
+    # 创建工具解析器映射
+    tool_resolver_map = {
+        ExecuteCommandTool: TestToolResolver
+    }
+    
+    # 创建 ToolCaller
+    args = AutoCoderArgs(source_dir=".")
+    tool_caller = ToolCaller(
+        tool_resolver_map=tool_resolver_map,
+        agent=mock_agent,
+        args=args,
+        enable_plugins=True
+    )
+    
+    # 测试工具调用
+    tool = ExecuteCommandTool(command="echo 'integration test'", requires_approval=False)
+    result = tool_caller.call_tool(tool)
+    
+    assert result.success, f"Integration test failed: {result.message}"
+    print("✓ Integration with mock agent works")
+    
+    # 测试统计信息
+    stats = tool_caller.get_stats()
+    assert stats["total_calls"] > 0, "No calls recorded"
+    assert stats["success_rate"] == 1.0, f"Expected 100% success rate, got {stats['success_rate']}"
+    print("✓ Statistics collection works")
+
+
+def main():
+    """主测试函数"""
+    print("=" * 60)
+    print("Tool Caller Integration Test")
+    print("=" * 60)
+    
+    try:
+        # 基本功能测试
+        tool_caller = test_tool_caller_basic()
+        
+        # 插件系统测试
+        test_plugin_system(tool_caller)
+        
+        # 集成测试
+        test_integration_with_mock_agent()
+        
+        print("\n" + "=" * 60)
+        print("✓ All integration tests passed!")
+        print("=" * 60)
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n✗ Integration test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1) 

autocoder/common/v2/agent/tool_caller/plugins/__init__.py

@@ -0,0 +1,14 @@
+"""
+Tool Call Plugins
+
+工具调用插件系统，提供插件接口和基础实现。
+"""
+
+from .plugin_interface import ToolCallPlugin, PluginPriority
+from .base_plugin import BaseToolCallPlugin
+
+__all__ = [
+    "ToolCallPlugin",
+    "BaseToolCallPlugin", 
+    "PluginPriority"
+] 

autocoder/common/v2/agent/tool_caller/plugins/base_plugin.py

@@ -0,0 +1,126 @@
+"""
+Base Tool Call Plugin
+
+提供工具调用插件的基础实现。
+"""
+
+from typing import Any, Dict, Optional, TYPE_CHECKING
+from autocoder.common.v2.agent.agentic_edit_types import BaseTool, ToolResult
+from .plugin_interface import ToolCallPlugin, PluginPriority
+from loguru import logger
+
+if TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class BaseToolCallPlugin(ToolCallPlugin):
+    """
+    工具调用插件基础实现类
+    
+    提供常见功能的默认实现，插件开发者可以继承此类。
+    """
+    
+    def __init__(self, enabled: bool = True):
+        """
+        初始化插件
+        
+        Args:
+            enabled: 插件是否启用
+        """
+        self._enabled = enabled
+        self._config = {}
+    
+    @property
+    def enabled(self) -> bool:
+        """插件是否启用"""
+        return self._enabled
+    
+    def set_enabled(self, enabled: bool) -> None:
+        """设置插件启用状态"""
+        self._enabled = enabled
+    
+    def set_config(self, config: Dict[str, Any]) -> None:
+        """设置插件配置"""
+        self._config = config
+    
+    def get_config(self, key: str, default: Any = None) -> Any:
+        """获取配置项"""
+        return self._config.get(key, default)
+    
+    def log_info(self, message: str) -> None:
+        """记录信息日志"""
+        logger.info(f"[{self.name}] {message}")
+    
+    def log_warning(self, message: str) -> None:
+        """记录警告日志"""
+        logger.warning(f"[{self.name}] {message}")
+    
+    def log_error(self, message: str) -> None:
+        """记录错误日志"""
+        logger.error(f"[{self.name}] {message}")
+    
+    def create_context(self, **kwargs) -> Dict[str, Any]:
+        """创建上下文信息"""
+        context = {
+            "plugin_name": self.name,
+            "plugin_priority": self.priority.value,
+            "timestamp": __import__("time").time()
+        }
+        context.update(kwargs)
+        return context
+    
+    def should_process_tool(self, tool: BaseTool, agent: Optional['AgenticEdit']) -> bool:
+        """
+        判断是否应该处理这个工具
+        
+        默认实现：只有当插件启用时才处理
+        """
+        return self.enabled
+    
+    def before_tool_execution(
+        self, 
+        tool: BaseTool, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> BaseTool:
+        """
+        工具执行前的处理
+        
+        默认实现：记录日志并返回原始工具
+        """
+        if self.enabled:
+            self.log_info(f"Before execution of {type(tool).__name__}")
+        return tool
+    
+    def after_tool_execution(
+        self, 
+        tool: BaseTool, 
+        tool_result: ToolResult, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> ToolResult:
+        """
+        工具执行后的处理
+        
+        默认实现：记录日志并返回原始结果
+        """
+        if self.enabled:
+            success_str = "successfully" if tool_result.success else "with error"
+            self.log_info(f"After execution of {type(tool).__name__} {success_str}")
+        return tool_result
+    
+    def on_tool_error(
+        self, 
+        tool: BaseTool, 
+        error: Exception, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> Optional[ToolResult]:
+        """
+        工具执行出错时的处理
+        
+        默认实现：记录错误日志，不提供替代结果
+        """
+        if self.enabled:
+            self.log_error(f"Error in {type(tool).__name__}: {str(error)}")
+        return None 

autocoder/common/v2/agent/tool_caller/plugins/examples/__init__.py

@@ -0,0 +1,13 @@
+"""
+Tool Call Plugin Examples
+
+示例插件集合，展示如何开发和使用工具调用插件。
+"""
+
+from .logging_plugin import LoggingPlugin
+from .security_filter_plugin import SecurityFilterPlugin
+
+__all__ = [
+    "LoggingPlugin",
+    "SecurityFilterPlugin"
+] 

autocoder/common/v2/agent/tool_caller/plugins/examples/logging_plugin.py

@@ -0,0 +1,164 @@
+"""
+Logging Plugin Example
+
+记录工具调用日志的示例插件。
+"""
+
+import json
+from typing import Optional, Dict, Any, TYPE_CHECKING
+from autocoder.common.v2.agent.agentic_edit_types import BaseTool, ToolResult
+from ..base_plugin import BaseToolCallPlugin
+from ..plugin_interface import PluginPriority
+
+if TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class LoggingPlugin(BaseToolCallPlugin):
+    """
+    日志记录插件
+    
+    记录所有工具调用的详细信息，包括参数、执行时间和结果。
+    """
+    
+    def __init__(self, enabled: bool = True, detailed_logging: bool = False):
+        """
+        初始化日志插件
+        
+        Args:
+            enabled: 插件是否启用
+            detailed_logging: 是否记录详细日志（包括工具参数和结果内容）
+        """
+        super().__init__(enabled)
+        self.detailed_logging = detailed_logging
+        self.call_history = []
+    
+    @property
+    def name(self) -> str:
+        return "logging"
+    
+    @property
+    def priority(self) -> PluginPriority:
+        return PluginPriority.LOW  # 记录日志通常优先级较低
+    
+    @property 
+    def description(self) -> str:
+        return "Records detailed logs of all tool calls and executions"
+    
+    def before_tool_execution(
+        self, 
+        tool: BaseTool, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> BaseTool:
+        """记录工具执行前的信息"""
+        if not self.enabled:
+            return tool
+        
+        call_info = {
+            "tool_name": type(tool).__name__,
+            "timestamp": context.get("timestamp") if context else None,
+            "call_id": context.get("call_id") if context else None,
+            "phase": "before_execution"
+        }
+        
+        if self.detailed_logging:
+            call_info["tool_params"] = tool.model_dump() if hasattr(tool, 'model_dump') else str(tool)
+        
+        self.call_history.append(call_info)
+        self.log_info(f"Starting execution of {type(tool).__name__}")
+        
+        if self.detailed_logging:
+            self.log_info(f"Tool parameters: {json.dumps(call_info.get('tool_params', {}), indent=2)}")
+        
+        return tool
+    
+    def after_tool_execution(
+        self, 
+        tool: BaseTool, 
+        tool_result: ToolResult, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> ToolResult:
+        """记录工具执行后的信息"""
+        if not self.enabled:
+            return tool_result
+        
+        call_info = {
+            "tool_name": type(tool).__name__,
+            "timestamp": context.get("timestamp") if context else None,
+            "call_id": context.get("call_id") if context else None,
+            "phase": "after_execution",
+            "success": tool_result.success,
+            "message": tool_result.message
+        }
+        
+        if self.detailed_logging and tool_result.content:
+            # 只记录前500个字符，避免日志过长
+            content_str = str(tool_result.content)
+            if len(content_str) > 500:
+                content_str = content_str[:500] + "..."
+            call_info["result_content"] = content_str
+        
+        self.call_history.append(call_info)
+        
+        status = "successfully" if tool_result.success else "with error"
+        self.log_info(f"Completed execution of {type(tool).__name__} {status}")
+        
+        if not tool_result.success:
+            self.log_warning(f"Tool execution failed: {tool_result.message}")
+        
+        if self.detailed_logging:
+            self.log_info(f"Result: {json.dumps(call_info, indent=2, default=str)}")
+        
+        return tool_result
+    
+    def on_tool_error(
+        self, 
+        tool: BaseTool, 
+        error: Exception, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> Optional[ToolResult]:
+        """记录工具执行错误"""
+        if not self.enabled:
+            return None
+        
+        call_info = {
+            "tool_name": type(tool).__name__,
+            "timestamp": context.get("timestamp") if context else None,
+            "call_id": context.get("call_id") if context else None,
+            "phase": "error",
+            "error_type": type(error).__name__,
+            "error_message": str(error)
+        }
+        
+        self.call_history.append(call_info)
+        self.log_error(f"Tool {type(tool).__name__} failed with {type(error).__name__}: {str(error)}")
+        
+        # 不提供恢复结果，只记录错误
+        return None
+    
+    def get_call_history(self) -> list:
+        """获取调用历史"""
+        return self.call_history.copy()
+    
+    def clear_history(self) -> None:
+        """清空调用历史"""
+        self.call_history.clear()
+        self.log_info("Call history cleared")
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """获取统计信息"""
+        total_calls = len([call for call in self.call_history if call["phase"] == "after_execution"])
+        successful_calls = len([call for call in self.call_history 
+                              if call["phase"] == "after_execution" and call.get("success", False)])
+        error_calls = len([call for call in self.call_history if call["phase"] == "error"])
+        
+        return {
+            "total_logged_calls": total_calls,
+            "successful_calls": successful_calls,
+            "error_calls": error_calls,
+            "success_rate": successful_calls / total_calls if total_calls > 0 else 0.0,
+            "detailed_logging": self.detailed_logging
+        } 

autocoder/common/v2/agent/tool_caller/plugins/examples/security_filter_plugin.py

@@ -0,0 +1,198 @@
+"""
+Security Filter Plugin Example
+
+安全过滤插件，用于拦截和过滤敏感信息。
+"""
+
+import re
+from copy import deepcopy
+from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from autocoder.common.v2.agent.agentic_edit_types import BaseTool, ToolResult, ExecuteCommandTool
+from ..base_plugin import BaseToolCallPlugin
+from ..plugin_interface import PluginPriority
+
+if TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class SecurityFilterPlugin(BaseToolCallPlugin):
+    """
+    安全过滤插件
+    
+    过滤敏感信息，如密码、API密钥等，防止在工具执行过程中泄露。
+    """
+    
+    def __init__(self, enabled: bool = True):
+        """
+        初始化安全过滤插件
+        
+        Args:
+            enabled: 插件是否启用
+        """
+        super().__init__(enabled)
+        
+        # 敏感信息正则模式
+        self.sensitive_patterns = [
+            (r'password\s*[=:]\s*["\']?([^"\'\s]+)["\']?', 'password=***'),
+            (r'passwd\s*[=:]\s*["\']?([^"\'\s]+)["\']?', 'passwd=***'),
+            (r'api_key\s*[=:]\s*["\']?([^"\'\s]+)["\']?', 'api_key=***'),
+            (r'secret\s*[=:]\s*["\']?([^"\'\s]+)["\']?', 'secret=***'),
+            (r'token\s*[=:]\s*["\']?([^"\'\s]+)["\']?', 'token=***'),
+            (r'--password\s+([^\s]+)', '--password ***'),
+            (r'-p\s+([^\s]+)', '-p ***'),
+        ]
+        
+        # 危险命令模式
+        self.dangerous_commands = [
+            r'rm\s+-rf\s+/',
+            r'sudo\s+rm\s+-rf',
+            r'format\s+c:',
+            r'del\s+/q\s+/s\s+c:\\',
+            r'shutdown\s+(-s|-r|-h)',
+            r'halt',
+            r'reboot',
+        ]
+        
+        self.filtered_count = 0
+        self.blocked_count = 0
+    
+    @property
+    def name(self) -> str:
+        return "security_filter"
+    
+    @property
+    def priority(self) -> PluginPriority:
+        return PluginPriority.HIGHEST  # 安全过滤应该最先执行
+    
+    @property
+    def description(self) -> str:
+        return "Filters sensitive information and blocks dangerous commands"
+    
+    def should_process_tool(self, tool: BaseTool, agent: Optional['AgenticEdit']) -> bool:
+        """只处理执行命令工具和其他可能包含敏感信息的工具"""
+        return self.enabled and isinstance(tool, (ExecuteCommandTool,))
+    
+    def before_tool_execution(
+        self, 
+        tool: BaseTool, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> BaseTool:
+        """在工具执行前过滤敏感信息"""
+        if not self.should_process_tool(tool, agent):
+            return tool
+        
+        # 创建工具的副本以避免修改原始工具
+        filtered_tool = deepcopy(tool)
+        
+        if isinstance(filtered_tool, ExecuteCommandTool):
+            original_command = filtered_tool.command
+            
+            # 检查危险命令
+            if self._is_dangerous_command(original_command):
+                self.blocked_count += 1
+                self.log_warning(f"Blocked dangerous command: {original_command}")
+                # 创建一个安全的替代命令
+                filtered_tool.command = "echo 'BLOCKED: Potentially dangerous command detected'"
+                return filtered_tool
+            
+            # 过滤敏感信息
+            filtered_command = self._filter_sensitive_info(original_command)
+            if filtered_command != original_command:
+                self.filtered_count += 1
+                self.log_info(f"Filtered sensitive information from command")
+                filtered_tool.command = filtered_command
+        
+        return filtered_tool
+    
+    def after_tool_execution(
+        self, 
+        tool: BaseTool, 
+        tool_result: ToolResult, 
+        agent: Optional['AgenticEdit'],
+        context: Optional[Dict[str, Any]] = None
+    ) -> ToolResult:
+        """在工具执行后过滤结果中的敏感信息"""
+        if not self.should_process_tool(tool, agent):
+            return tool_result
+        
+        # 创建结果的副本
+        filtered_result = ToolResult(
+            success=tool_result.success,
+            message=self._filter_sensitive_info(tool_result.message),
+            content=self._filter_result_content(tool_result.content)
+        )
+        
+        return filtered_result
+    
+    def _is_dangerous_command(self, command: str) -> bool:
+        """检查是否为危险命令"""
+        command_lower = command.lower().strip()
+        
+        for pattern in self.dangerous_commands:
+            if re.search(pattern, command_lower, re.IGNORECASE):
+                return True
+        
+        return False
+    
+    def _filter_sensitive_info(self, text: str) -> str:
+        """过滤文本中的敏感信息"""
+        if not text:
+            return text
+        
+        filtered_text = text
+        
+        for pattern, replacement in self.sensitive_patterns:
+            filtered_text = re.sub(pattern, replacement, filtered_text, flags=re.IGNORECASE)
+        
+        return filtered_text
+    
+    def _filter_result_content(self, content: Any) -> Any:
+        """过滤结果内容中的敏感信息"""
+        if content is None:
+            return content
+        
+        if isinstance(content, str):
+            return self._filter_sensitive_info(content)
+        
+        elif isinstance(content, dict):
+            filtered_content = {}
+            for key, value in content.items():
+                if isinstance(value, str):
+                    filtered_content[key] = self._filter_sensitive_info(value)
+                else:
+                    filtered_content[key] = value
+            return filtered_content
+        
+        elif isinstance(content, list):
+            return [
+                self._filter_sensitive_info(item) if isinstance(item, str) else item
+                for item in content
+            ]
+        
+        return content
+    
+    def add_sensitive_pattern(self, pattern: str, replacement: str) -> None:
+        """添加新的敏感信息模式"""
+        self.sensitive_patterns.append((pattern, replacement))
+        self.log_info(f"Added new sensitive pattern: {pattern}")
+    
+    def add_dangerous_command(self, pattern: str) -> None:
+        """添加新的危险命令模式"""
+        self.dangerous_commands.append(pattern)
+        self.log_info(f"Added new dangerous command pattern: {pattern}")
+    
+    def get_filter_statistics(self) -> Dict[str, Any]:
+        """获取过滤统计信息"""
+        return {
+            "filtered_count": self.filtered_count,
+            "blocked_count": self.blocked_count,
+            "sensitive_patterns_count": len(self.sensitive_patterns),
+            "dangerous_patterns_count": len(self.dangerous_commands)
+        }
+    
+    def reset_statistics(self) -> None:
+        """重置统计信息"""
+        self.filtered_count = 0
+        self.blocked_count = 0
+        self.log_info("Filter statistics reset")