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

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

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Tool Caller Usage Example
+
+展示如何使用 tool_caller 模块进行工具调用和插件管理。
+"""
+
+import sys
+import os
+
+# 添加项目根目录到 Python 路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../../../../..'))
+
+from autocoder.common import AutoCoderArgs
+from autocoder.common.v2.agent.agentic_edit_types import ExecuteCommandTool, ReadFileTool, 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 DemoToolResolver(BaseToolResolver):
+    """演示用的简单工具解析器"""
+    
+    def resolve(self) -> ToolResult:
+        """简化的工具解析实现"""
+        if isinstance(self.tool, ExecuteCommandTool):
+            return ToolResult(
+                success=True,
+                message=f"Demo: Command '{self.tool.command}' executed",
+                content={"output": f"Mock output for: {self.tool.command}"}
+            )
+        elif isinstance(self.tool, ReadFileTool):
+            return ToolResult(
+                success=True,
+                message=f"Demo: File '{self.tool.path}' read",
+                content={"content": f"Mock content of {self.tool.path}"}
+            )
+        else:
+            return ToolResult(
+                success=False,
+                message=f"Demo: Unsupported tool type {type(self.tool).__name__}"
+            )
+
+
+def main():
+    """主演示函数"""
+    print("=" * 60)
+    print("Tool Caller Module Usage Example")
+    print("=" * 60)
+    
+    # 1. 创建工具解析器映射
+    print("\n1. Setting up tool resolver mapping...")
+    tool_resolver_map = {
+        ExecuteCommandTool: DemoToolResolver,
+        ReadFileTool: DemoToolResolver
+    }
+    
+    # 2. 创建工具调用器
+    print("2. Creating ToolCaller instance...")
+    args = AutoCoderArgs(source_dir=".")
+    tool_caller = ToolCaller(
+        tool_resolver_map=tool_resolver_map,
+        args=args,
+        enable_plugins=True
+    )
+    
+    # 3. 注册插件
+    print("3. Registering plugins...")
+    logging_plugin = LoggingPlugin(enabled=True, detailed_logging=True)
+    security_plugin = SecurityFilterPlugin(enabled=True)
+    
+    tool_caller.register_plugin(logging_plugin)
+    tool_caller.register_plugin(security_plugin)
+    
+    print(f"   - Registered logging plugin (priority: {logging_plugin.priority.value})")
+    print(f"   - Registered security filter plugin (priority: {security_plugin.priority.value})")
+    
+    # 4. 获取插件状态
+    print("\n4. Plugin system status:")
+    status = tool_caller.get_plugin_status()
+    print(f"   - Total plugins: {status['total_plugins']}")
+    print(f"   - Enabled plugins: {status['enabled_plugins']}")
+    for plugin_info in status['plugins']:
+        print(f"   - {plugin_info['name']}: priority={plugin_info['priority']}, enabled={plugin_info['enabled']}")
+    
+    # 5. 执行一些工具调用
+    print("\n5. Executing tool calls...")
+    
+    # 安全命令
+    safe_tool = ExecuteCommandTool(command="echo 'Hello World'", requires_approval=False)
+    print(f"\n   Executing safe command: {safe_tool.command}")
+    result = tool_caller.call_tool(safe_tool)
+    print(f"   Result: {result.success} - {result.message}")
+    
+    # 包含敏感信息的命令（会被过滤）
+    sensitive_tool = ExecuteCommandTool(command="mysql -u root -p secret123", requires_approval=False)
+    print(f"\n   Executing sensitive command: {sensitive_tool.command}")
+    result = tool_caller.call_tool(sensitive_tool)
+    print(f"   Result: {result.success} - {result.message}")
+    
+    # 危险命令（会被阻止）
+    dangerous_tool = ExecuteCommandTool(command="rm -rf /", requires_approval=False)
+    print(f"\n   Executing dangerous command: {dangerous_tool.command}")
+    result = tool_caller.call_tool(dangerous_tool)
+    print(f"   Result: {result.success} - {result.message}")
+    
+    # 文件读取
+    read_tool = ReadFileTool(path="example.txt")
+    print(f"\n   Reading file: {read_tool.path}")
+    result = tool_caller.call_tool(read_tool)
+    print(f"   Result: {result.success} - {result.message}")
+    
+    # 6. 查看统计信息
+    print("\n6. Tool execution statistics:")
+    stats = tool_caller.get_stats()
+    print(f"   - Total calls: {stats['total_calls']}")
+    print(f"   - Successful calls: {stats['successful_calls']}")
+    print(f"   - Failed calls: {stats['failed_calls']}")
+    print(f"   - Success rate: {stats['success_rate']:.2%}")
+    print(f"   - Plugin intercepted calls: {stats['plugin_intercepted_calls']}")
+    print(f"   - Average execution time: {stats['average_execution_time']:.3f}s")
+    
+    # 7. 查看插件统计
+    print("\n7. Plugin statistics:")
+    
+    # 日志插件统计
+    log_stats = logging_plugin.get_statistics()
+    print(f"   Logging plugin:")
+    print(f"     - Total logged calls: {log_stats['total_logged_calls']}")
+    print(f"     - Success rate: {log_stats['success_rate']:.2%}")
+    print(f"     - Call history entries: {len(logging_plugin.get_call_history())}")
+    
+    # 安全过滤插件统计
+    filter_stats = security_plugin.get_filter_statistics()
+    print(f"   Security filter plugin:")
+    print(f"     - Filtered count: {filter_stats['filtered_count']}")
+    print(f"     - Blocked count: {filter_stats['blocked_count']}")
+    print(f"     - Sensitive patterns: {filter_stats['sensitive_patterns_count']}")
+    print(f"     - Dangerous patterns: {filter_stats['dangerous_patterns_count']}")
+    
+    # 8. 插件管理演示
+    print("\n8. Plugin management demo:")
+    
+    # 禁用日志插件
+    print("   Disabling logging plugin...")
+    tool_caller.disable_plugin("logging")
+    
+    # 执行一个命令（不会被日志插件记录）
+    test_tool = ExecuteCommandTool(command="echo 'test without logging'", requires_approval=False)
+    old_history_length = len(logging_plugin.get_call_history())
+    result = tool_caller.call_tool(test_tool)
+    new_history_length = len(logging_plugin.get_call_history())
+    
+    print(f"   Command executed, logging plugin did not record it")
+    print(f"   History length before: {old_history_length}, after: {new_history_length}")
+    
+    # 重新启用日志插件
+    print("   Re-enabling logging plugin...")
+    tool_caller.enable_plugin("logging")
+    
+    # 9. 全局插件控制
+    print("\n9. Global plugin control demo:")
+    print("   Disabling all plugins globally...")
+    tool_caller.set_plugins_enabled(False)
+    
+    # 执行命令（所有插件都被禁用）
+    test_tool2 = ExecuteCommandTool(command="rm -rf /tmp", requires_approval=False)  # 通常会被安全插件阻止
+    result = tool_caller.call_tool(test_tool2)
+    print(f"   Dangerous command executed without plugin protection: {result.success}")
+    
+    # 重新启用插件系统
+    print("   Re-enabling plugin system...")
+    tool_caller.set_plugins_enabled(True)
+    
+    # 10. 最终统计
+    print("\n10. Final statistics:")
+    final_stats = tool_caller.get_stats()
+    print(f"   - Total calls in demo: {final_stats['total_calls']}")
+    print(f"   - Overall success rate: {final_stats['success_rate']:.2%}")
+    
+    print("\n" + "=" * 60)
+    print("Demo completed successfully!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"Demo failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1) 

autocoder/common/v2/code_agentic_editblock_manager.py

@@ -15,7 +15,7 @@ from autocoder.utils.auto_coder_utils.chat_stream_out import stream_out
 from autocoder.common.stream_out_type import LintStreamOutType, CompileStreamOutType, UnmergedBlocksStreamOutType, ContextMissingCheckStreamOutType
 from autocoder.common.auto_coder_lang import get_message_with_format
 from autocoder.common.printer import Printer
-from autocoder.rag.token_counter import count_tokens
+from autocoder.common.tokens import count_string_tokens as count_tokens
 from autocoder.utils import llms as llm_utils
 from autocoder.memory.active_context_manager import ActiveContextManager
 from autocoder.common.v2.code_auto_generate_editblock import CodeAutoGenerateEditBlock
@@ -433,7 +433,7 @@ class CodeEditBlockManager:
             return (unmerged_formatted_text, merged_formatted_text)
 
         for attempt in range(self.args.auto_fix_merge_max_attempts):
-            global_cancel.check_and_raise(token=self.args.event_file)
+            global_cancel.check_and_raise(token=self.args.cancel_token)
             unmerged_formatted_text, merged_formatted_text = _format_blocks(
                 merge)
             fix_prompt = self.fix_unmerged_blocks.prompt(
@@ -657,7 +657,7 @@ class CodeEditBlockManager:
         token_cost_calculator = TokenCostCalculator(args=self.args)
 
         for attempt in range(self.auto_fix_compile_max_attempts):
-            global_cancel.check_and_raise(token=self.args.event_file)
+            global_cancel.check_and_raise(token=self.args.cancel_token)
             # 先更新增量影子系统的文件
             self.shadow_manager.clean_shadows()
             shadow_files = self._create_shadow_files_from_edits(
@@ -804,7 +804,7 @@ class CodeEditBlockManager:
         # 生成代码并自动修复lint错误
 
         generation_result = self.generate_and_fix(query, source_code_list)
-        global_cancel.check_and_raise(token=self.args.event_file)
+        global_cancel.check_and_raise(token=self.args.cancel_token)
 
         # 合并代码
         self.code_merger.merge_code(generation_result)

autocoder/common/v2/code_auto_generate.py

@@ -6,18 +6,26 @@ from autocoder.common import sys_prompt
 from autocoder.privacy.model_filter import ModelPathFilter
 import json
 from concurrent.futures import ThreadPoolExecutor
-from autocoder.common.utils_code_auto_generate import chat_with_continue,stream_chat_with_continue,ChatWithContinueResult
+from autocoder.common.utils_code_auto_generate import (
+    chat_with_continue,
+    stream_chat_with_continue,
+    ChatWithContinueResult,
+)
 from autocoder.utils.auto_coder_utils.chat_stream_out import stream_out
 from autocoder.common.stream_out_type import CodeGenerateStreamOutType
 from autocoder.common.auto_coder_lang import get_message_with_format
 from autocoder.common.printer import Printer
-from autocoder.rag.token_counter import count_tokens
+from autocoder.common.tokens import count_string_tokens as count_tokens
 from autocoder.utils import llms as llm_utils
 from autocoder.common import SourceCodeList
 from autocoder.memory.active_context_manager import ActiveContextManager
 from loguru import logger
-from autocoder.common.rulefiles.autocoderrules_utils import get_rules
-from autocoder.run_context import get_run_context,RunMode
+from autocoder.common.rulefiles import get_rules
+from autocoder.run_context import get_run_context, RunMode
+import os
+from datetime import datetime
+import platform
+
 
 class CodeAutoGenerate:
     def __init__(
@@ -40,9 +48,19 @@ class CodeAutoGenerate:
 
     @byzerllm.prompt(llm=lambda self: self.llm)
     def single_round_instruction(
-        self, instruction: str, content: str, context: str = "", package_context: str = ""
+        self,
+        instruction: str,
+        content: str,
+        context: str = "",
+        package_context: str = "",
     ) -> str:
         """
+        <env>
+        当前工作目录: {{ current_dir }}
+        操作系统: {{ os_info }}
+        当前时间: {{ current_time }}
+        </env>
+
         {%- if structure %}
         ====
         {{ structure }}
@@ -64,7 +82,7 @@ class CodeAutoGenerate:
         {%- endif %}
 
         {%- if context %}
-        ====        
+        ====
         {{ context }}
         {%- endif %}
 
@@ -80,7 +98,7 @@ class CodeAutoGenerate:
         ##File: {{ key }}
         {{ value }}
         </user_rule>
-        {% endfor %}        
+        {% endfor %}
         {% endif %}
 
         下面是用户的需求：
@@ -103,14 +121,21 @@ class CodeAutoGenerate:
 
         请确保每份代码的完整性，而不要只生成修改部分。
         """
-        
+        # 收集环境信息
+        current_dir = os.getcwd()
+        os_info = f"{platform.system()} {platform.release()}"
+        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
         if not self.args.include_project_structure:
             return {
-                "structure": "",                
+                "structure": "",
+                "current_dir": current_dir,
+                "os_info": os_info,
+                "current_time": current_time,
             }
-        
-        extra_docs = get_rules()    
-        
+
+        extra_docs = get_rules()
+
         return {
             "structure": (
                 self.action.pp.get_tree_like_directory_structure()
@@ -118,38 +143,46 @@ class CodeAutoGenerate:
                 else ""
             ),
             "extra_docs": extra_docs,
-        }        
+            "current_dir": current_dir,
+            "os_info": os_info,
+            "current_time": current_time,
+        }
 
     def single_round_run(
-        self, query: str, source_code_list: SourceCodeList        
+        self, query: str, source_code_list: SourceCodeList
     ) -> CodeGenerateResult:
-        
+
         # Apply model filter for code_llm
         printer = Printer()
         for llm in self.llms:
             model_filter = ModelPathFilter.from_model_object(llm, self.args)
             filtered_sources = []
             for source in source_code_list.sources:
-                if model_filter.is_accessible(source.module_name): 
+                if model_filter.is_accessible(source.module_name):
                     filtered_sources.append(source)
                 else:
-                    printer.print_in_terminal("index_file_filtered", 
-                                               style="yellow",
-                                               file_path=source.module_name, 
-                                               model_name=",".join(llm_utils.get_llm_names(llm)))
+                    printer.print_in_terminal(
+                        "index_file_filtered",
+                        style="yellow",
+                        file_path=source.module_name,
+                        model_name=",".join(llm_utils.get_llm_names(llm)),
+                    )
 
         source_code_list = SourceCodeList(filtered_sources)
-        
+
         llm_config = {"human_as_model": self.args.human_as_model}
 
         source_content = source_code_list.to_str()
 
         active_context_manager = ActiveContextManager(self.llm, self.args.source_dir)
-       
+
         # 获取包上下文信息
         package_context = ""
-        
-        if self.args.enable_active_context and self.args.enable_active_context_in_generate:
+
+        if (
+            self.args.enable_active_context
+            and self.args.enable_active_context_in_generate
+        ):
             # 获取活动上下文信息
             result = active_context_manager.load_active_contexts_for_files(
                 [source.module_name for source in source_code_list.sources]
@@ -158,28 +191,32 @@ class CodeAutoGenerate:
             if result.contexts:
                 package_context_parts = []
                 for dir_path, context in result.contexts.items():
-                    package_context_parts.append(f"<package_info>{context.content}</package_info>")
-                
+                    package_context_parts.append(
+                        f"<package_info>{context.content}</package_info>"
+                    )
+
                 package_context = "\n".join(package_context_parts)
 
         init_prompt = self.single_round_instruction.prompt(
-            instruction=query, content=source_content, context=self.args.context, 
-            package_context=package_context
-        )        
+            instruction=query,
+            content=source_content,
+            context=self.args.context,
+            package_context=package_context,
+        )
 
-        with open(self.args.target_file, "w",encoding="utf-8") as file:
+        with open(self.args.target_file, "w", encoding="utf-8") as file:
             file.write(init_prompt)
 
         conversations = []
 
         if self.args.system_prompt and self.args.system_prompt.strip() == "claude":
             conversations.append(
-                {"role": "system", "content": sys_prompt.claude_sys_prompt.prompt()})
+                {"role": "system", "content": sys_prompt.claude_sys_prompt.prompt()}
+            )
         elif self.args.system_prompt:
-            conversations.append(
-                {"role": "system", "content": self.args.system_prompt})
+            conversations.append({"role": "system", "content": self.args.system_prompt})
 
-        conversations.append({"role": "user", "content": init_prompt})        
+        conversations.append({"role": "user", "content": init_prompt})
 
         conversations_list = []
         results = []
@@ -193,93 +230,114 @@ class CodeAutoGenerate:
 
         printer = Printer()
         estimated_input_tokens = count_tokens(
-            json.dumps(conversations, ensure_ascii=False))
-        printer.print_in_terminal("estimated_input_tokens_in_generate",
-                                  style="yellow",
-                                  estimated_input_tokens_in_generate=estimated_input_tokens,
-                                  generate_mode="diff"
-                                  )
+            json.dumps(conversations, ensure_ascii=False)
+        )
+        printer.print_in_terminal(
+            "estimated_input_tokens_in_generate",
+            style="yellow",
+            estimated_input_tokens_in_generate=estimated_input_tokens,
+            generate_mode="diff",
+        )
 
         if not self.args.human_as_model or get_run_context().mode == RunMode.WEB:
-            with ThreadPoolExecutor(max_workers=len(self.llms) * self.generate_times_same_model) as executor:
+            with ThreadPoolExecutor(
+                max_workers=len(self.llms) * self.generate_times_same_model
+            ) as executor:
                 futures = []
                 count = 0
                 for llm in self.llms:
-                    
-                    model_names_list = llm_utils.get_llm_names(llm) 
+
+                    model_names_list = llm_utils.get_llm_names(llm)
                     model_name = None
                     if model_names_list:
-                        model_name = model_names_list[0]                    
+                        model_name = model_names_list[0]
 
                     for _ in range(self.generate_times_same_model):
-                        model_names.append(model_name)                        
+                        model_names.append(model_name)
                         if count == 0:
+
                             def job():
                                 stream_generator = stream_chat_with_continue(
-                                    llm=llm, 
-                                    conversations=conversations, 
+                                    llm=llm,
+                                    conversations=conversations,
                                     llm_config=llm_config,
-                                    args=self.args
+                                    args=self.args,
                                 )
                                 full_response, last_meta = stream_out(
-                                stream_generator,
-                                model_name=model_name,
-                                title=get_message_with_format(
-                                    "code_generate_title", model_name=model_name),
-                                args=self.args,
-                                extra_meta={
-                                    "stream_out_type": CodeGenerateStreamOutType.CODE_GENERATE.value
-                                })
+                                    stream_generator,
+                                    model_name=model_name,
+                                    title=get_message_with_format(
+                                        "code_generate_title", model_name=model_name
+                                    ),
+                                    args=self.args,
+                                    extra_meta={
+                                        "stream_out_type": CodeGenerateStreamOutType.CODE_GENERATE.value
+                                    },
+                                )
                                 return ChatWithContinueResult(
                                     content=full_response,
                                     input_tokens_count=last_meta.input_tokens_count,
-                                    generated_tokens_count=last_meta.generated_tokens_count
+                                    generated_tokens_count=last_meta.generated_tokens_count,
                                 )
+
                             futures.append(executor.submit(job))
-                        else:                                
-                            futures.append(executor.submit(
-                                chat_with_continue, 
-                                llm=llm, 
-                                conversations=conversations, 
-                                llm_config=llm_config,
-                                args=self.args
-                            ))
+                        else:
+                            futures.append(
+                                executor.submit(
+                                    chat_with_continue,
+                                    llm=llm,
+                                    conversations=conversations,
+                                    llm_config=llm_config,
+                                    args=self.args,
+                                )
+                            )
                         count += 1
-                
+
                 temp_results = [future.result() for future in futures]
-                
-                for result,model_name in zip(temp_results,model_names):
+
+                for result, model_name in zip(temp_results, model_names):
                     results.append(result.content)
                     input_tokens_count += result.input_tokens_count
                     generated_tokens_count += result.generated_tokens_count
-                    model_info = llm_utils.get_model_info(model_name,self.args.product_mode)                    
+                    model_info = llm_utils.get_model_info(
+                        model_name, self.args.product_mode
+                    )
                     input_cost = model_info.get("input_price", 0) if model_info else 0
                     output_cost = model_info.get("output_price", 0) if model_info else 0
-                    input_tokens_cost += input_cost * result.input_tokens_count / 1000000
-                    generated_tokens_cost += output_cost * result.generated_tokens_count / 1000000
+                    input_tokens_cost += (
+                        input_cost * result.input_tokens_count / 1000000
+                    )
+                    generated_tokens_cost += (
+                        output_cost * result.generated_tokens_count / 1000000
+                    )
 
             for result in results:
                 conversations_list.append(
-                    conversations + [{"role": "assistant", "content": result}])
+                    conversations + [{"role": "assistant", "content": result}]
+                )
         else:
             for _ in range(self.args.human_model_num):
                 single_result = chat_with_continue(
-                    llm=self.llms[0], 
-                    conversations=conversations, 
+                    llm=self.llms[0],
+                    conversations=conversations,
                     llm_config=llm_config,
-                    args=self.args
+                    args=self.args,
                 )
                 results.append(single_result.content)
                 input_tokens_count += single_result.input_tokens_count
                 generated_tokens_count += single_result.generated_tokens_count
                 conversations_list.append(
-                    conversations + [{"role": "assistant", "content": single_result.content}])
+                    conversations
+                    + [{"role": "assistant", "content": single_result.content}]
+                )
 
         statistics = {
             "input_tokens_count": input_tokens_count,
             "generated_tokens_count": generated_tokens_count,
             "input_tokens_cost": input_tokens_cost,
-            "generated_tokens_cost": generated_tokens_cost
+            "generated_tokens_cost": generated_tokens_cost,
         }
 
-        return CodeGenerateResult(contents=results, conversations=conversations_list, metadata=statistics) 
+        return CodeGenerateResult(
+            contents=results, conversations=conversations_list, metadata=statistics
+        )