jarvis-ai-assistant 0.1.125__py3-none-any.whl → 0.1.126__py3-none-any.whl

jarvis/jarvis_tools/registry.py

@@ -16,41 +16,41 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 tool_call_help = """
-# 🛠️ Tool Usage System
-You are using a tool execution system that requires precise formatting and strict rules.
+# 🛠️ 工具使用系统
+您正在使用一个需要精确格式和严格规则的工具执行系统。
 
-# 📋 Tool Call Format
+# 📋 工具调用格式
 <TOOL_CALL>
-name: tool_name
+name: 工具名称
 arguments:
-    param1: value1
-    param2: value2
+    param1: 值1
+    param2: 值2
 </TOOL_CALL>
 
-# ❗ Critical Rules
-1. ONE Tool Per Turn
-   - Execute only ONE tool at a time
-   - Wait for results before next action
+# ❗ 关键规则
+1. 每次只使用一个工具
+   - 一次只执行一个工具
+   - 等待结果后再进行下一步
 
-2. Strict Format Adherence
-   - Follow exact format shown above
-   - Use proper YAML indentation
-   - Include all required parameters
+2. 严格遵守格式
+   - 完全按照上述格式
+   - 使用正确的YAML缩进
+   - 包含所有必需参数
 
-3. Result Handling
-   - Wait for execution results
-   - Never assume outcomes
-   - Don't create fake responses
-   - Don't imagine dialogues
+3. 结果处理
+   - 等待执行结果
+   - 不要假设结果
+   - 不要创建虚假响应
+   - 不要想象对话
 
-4. Information Management
-   - Ask user if info is insufficient
-   - Skip unnecessary steps
-   - Request guidance if stuck
-   - Don't proceed with incomplete info
+4. 信息管理
+   - 如果信息不足，询问用户
+   - 跳过不必要的步骤
+   - 如果卡住，请求指导
+   - 不要在没有完整信息的情况下继续
 
-# 📝 String Parameter Format
-ALWAYS use | syntax for string parameters:
+# 📝 字符串参数格式
+始终使用 | 语法表示字符串参数：
 
 <TOOL_CALL>
 name: execute_shell
@@ -59,19 +59,19 @@ arguments:
         git status --porcelain
 </TOOL_CALL>
 
-# 💡 Best Practices
-- Start execution immediately when ready
-- No need to ask for permission to begin
-- Use proper string formatting
-- Monitor progress and adjust
-- Request help when stuck
-
-# ⚠️ Common Mistakes to Avoid
-- Multiple tool calls at once
-- Missing | for string parameters
-- Assuming tool results
-- Creating fictional dialogues
-- Proceeding without required info
+# 💡 最佳实践
+- 准备好后立即开始执行
+- 无需请求许可即可开始
+- 使用正确的字符串格式
+- 监控进度并调整
+- 遇到困难时请求帮助
+
+# ⚠️ 常见错误
+- 同时调用多个工具
+- 字符串参数缺少 |
+- 假设工具结果
+- 创建虚构对话
+- 在没有所需信息的情况下继续
 """
 
 class ToolRegistry(OutputHandler):
@@ -85,14 +85,14 @@ class ToolRegistry(OutputHandler):
         return False
     
     def prompt(self) -> str:
-        """Load tools"""
+        """加载工具"""
         tools = self.get_all_tools()
         if tools:
-            tools_prompt = "## Available tools:\n"
+            tools_prompt = "## 可用工具:\n"
             for tool in tools:
-                tools_prompt += f"- Name: {tool['name']}\n"
-                tools_prompt += f"  Description: {tool['description']}\n"
-                tools_prompt += f"  Parameters: {tool['parameters']}\n"
+                tools_prompt += f"- 名称: {tool['name']}\n"
+                tools_prompt += f"  描述: {tool['description']}\n"
+                tools_prompt += f"  参数: {tool['parameters']}\n"
             tools_prompt += tool_call_help
             return tools_prompt
         return ""
@@ -101,87 +101,87 @@ class ToolRegistry(OutputHandler):
         tool_calls = self._extract_tool_calls(response)
         if len(tool_calls) > 1:
             PrettyOutput.print(f"操作失败：检测到多个操作。一次只能执行一个操作。尝试执行的操作：{', '.join([tool_call['name'] for tool_call in tool_calls])}", OutputType.WARNING)
-            return False, f"Call failed: Handle multiple tool calls, please ONLY handle one tool call at a time."
+            return False, f"调用失败：请一次只处理一个工具调用。"
         if len(tool_calls) == 0:
             return False, ""
         tool_call = tool_calls[0]
         return False, self.handle_tool_calls(tool_call)
 
     def __init__(self):
-        """Initialize tool registry"""
+        """初始化工具注册表"""
         self.tools: Dict[str, Tool] = {}
-        # Load built-in tools and external tools
+        # 加载内置工具和外部工具
         self._load_builtin_tools()
         self._load_external_tools()
-        # Ensure max_token_count is an integer
+        # 确保max_token_count是整数
         self.max_token_count = int(get_max_token_count() * 0.8)
 
     def use_tools(self, name: List[str]):
-        """Use specified tools"""
+        """使用指定工具"""
         missing_tools = [tool_name for tool_name in name if tool_name not in self.tools]
         if missing_tools:
             PrettyOutput.print(f"工具 {missing_tools} 不存在，可用的工具有: {', '.join(self.tools.keys())}", OutputType.WARNING)
         self.tools = {tool_name: self.tools[tool_name] for tool_name in name}
 
     def dont_use_tools(self, names: List[str]):
-        """Remove specified tools from the registry"""
+        """从注册表中移除指定工具"""
         self.tools = {name: tool for name, tool in self.tools.items() if name not in names}
 
     def _load_builtin_tools(self):
-        """Load tools from the built-in tools directory"""
+        """从内置工具目录加载工具"""
         tools_dir = Path(__file__).parent
         
-        # Iterate through all .py files in the directory
+        # 遍历目录中的所有.py文件
         for file_path in tools_dir.glob("*.py"):
-            # Skip base.py and __init__.py
+            # 跳过base.py和__init__.py
             if file_path.name in ["base.py", "__init__.py", "registry.py"]:
                 continue
                 
             self.register_tool_by_file(str(file_path))
 
     def _load_external_tools(self):
-        """Load external tools from ~/.jarvis/tools"""
+        """从~/.jarvis/tools加载外部工具"""
         external_tools_dir = Path.home() / '.jarvis/tools'
         if not external_tools_dir.exists():
             return
             
-        # Iterate through all .py files in the directory
+        # 遍历目录中的所有.py文件
         for file_path in external_tools_dir.glob("*.py"):
-            # Skip __init__.py
+            # 跳过__init__.py
             if file_path.name == "__init__.py":
                 continue
                 
             self.register_tool_by_file(str(file_path))
 
     def register_tool_by_file(self, file_path: str):
-        """Load and register tools from a specified file
+        """从指定文件加载并注册工具
         
-        Args:
-            file_path: The path of the tool file
+        参数:
+            file_path: 工具文件的路径
             
-        Returns:
-            bool: Whether the tool is loaded successfully
+        返回:
+            bool: 工具是否加载成功
         """
         try:
-            p_file_path = Path(file_path).resolve()  # Get the absolute path
+            p_file_path = Path(file_path).resolve()  # 获取绝对路径
             if not p_file_path.exists() or not p_file_path.is_file():
                 PrettyOutput.print(f"文件不存在: {p_file_path}", OutputType.ERROR)
                 return False
                 
-            # Add the parent directory to sys.path temporarily
+            # 临时将父目录添加到sys.path
             parent_dir = str(p_file_path.parent)
             sys.path.insert(0, parent_dir)
             
             try:
-                # Import the module using standard import mechanism
+                # 使用标准导入机制导入模块
                 module_name = p_file_path.stem
                 module = __import__(module_name)
                 
-                # Find the tool class in the module
+                # 在模块中查找工具类
                 tool_found = False
                 for item_name in dir(module):
                     item = getattr(module, item_name)
-                    # Check if it is a class and has the necessary attributes
+                    # 检查是否是类并具有必要属性
                     if (isinstance(item, type) and 
                         hasattr(item, 'name') and 
                         hasattr(item, 'description') and 
@@ -193,10 +193,10 @@ class ToolRegistry(OutputHandler):
                             if not item.check():
                                 continue
                         
-                        # Instantiate the tool class
+                        # 实例化工具类
                         tool_instance = item()
                         
-                        # Register the tool
+                        # 注册工具
                         self.register_tool(
                             name=tool_instance.name,
                             description=tool_instance.description,
@@ -212,7 +212,7 @@ class ToolRegistry(OutputHandler):
                 return True
                 
             finally:
-                # Remove the directory from sys.path
+                # 从sys.path中移除目录
                 sys.path.remove(parent_dir)
                 
         except Exception as e:
@@ -220,18 +220,18 @@ class ToolRegistry(OutputHandler):
             return False
     @staticmethod
     def _extract_tool_calls(content: str) -> List[Dict]:
-        """Extract tool calls from content.
+        """从内容中提取工具调用。
         
-        Args:
-            content: The content containing tool calls
+        参数:
+            content: 包含工具调用的内容
             
-        Returns:
-            List[Dict]: List of extracted tool calls with name and arguments
+        返回:
+            List[Dict]: 包含名称和参数的提取工具调用列表
             
-        Raises:
-            Exception: If tool call is missing necessary fields
+        异常:
+            Exception: 如果工具调用缺少必要字段
         """
-        # Split content into lines
+        # 将内容拆分为行
         data = re.findall(r'<TOOL_CALL>(.*?)</TOOL_CALL>', content, re.DOTALL)
         ret = []
         for item in data:
@@ -244,68 +244,68 @@ class ToolRegistry(OutputHandler):
         return ret
 
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
-        """Register a new tool"""
+        """注册新工具"""
         self.tools[name] = Tool(name, description, parameters, func)
 
     def get_tool(self, name: str) -> Optional[Tool]:
-        """Get a tool"""
+        """获取工具"""
         return self.tools.get(name)
 
     def get_all_tools(self) -> List[Dict]:
-        """Get all tools in Ollama format definition"""
+        """获取所有工具（Ollama格式定义）"""
         return [tool.to_dict() for tool in self.tools.values()]
 
     def execute_tool(self, name: str, arguments: Dict) -> Dict[str, Any]:
-        """Execute a specified tool"""
+        """执行指定工具"""
         tool = self.get_tool(name)
         if tool is None:
-            return {"success": False, "stderr": f"Tool {name} does not exist, available tools: {', '.join(self.tools.keys())}", "stdout": ""}
+            return {"success": False, "stderr": f"工具 {name} 不存在，可用的工具有: {', '.join(self.tools.keys())}", "stdout": ""}
         return tool.execute(arguments)
 
     def handle_tool_calls(self, tool_call: Dict) -> str:
-        """Handle tool calls, only process the first tool"""
+        """处理工具调用，只处理第一个工具"""
         try:
-            # Only process the first tool call
+            # 只处理第一个工具调用
             name = tool_call["name"]
             args = tool_call["arguments"]
 
             tool_call_help = """
-# 🛠️ Tool Usage System
-You are using a tool execution system that requires precise formatting and strict rules.
+# 🛠️ 工具使用系统
+您正在使用一个需要精确格式和严格规则的工具执行系统。
 
-# 📋 Tool Call Format
+# 📋 工具调用格式
 
 <TOOL_CALL>
-name: tool_name
+name: 工具名称
 arguments:
-    param1: value1
-    param2: value2
+    param1: 值1
+    param2: 值2
 </TOOL_CALL>
 
-# ❗ Critical Rules
-1. ONE Tool Per Turn
-   - Execute only ONE tool at a time
-   - Wait for results before next action
+# ❗ 关键规则
+1. 每次只使用一个工具
+   - 一次只执行一个工具
+   - 等待结果后再进行下一步
 
-2. Strict Format Adherence
-   - Follow exact format shown above
-   - Use proper YAML indentation
-   - Include all required parameters
+2. 严格遵守格式
+   - 完全按照上述格式
+   - 使用正确的YAML缩进
+   - 包含所有必需参数
 
-3. Result Handling
-   - Wait for execution results
-   - Never assume outcomes
-   - Don't create fake responses
-   - Don't imagine dialogues
+3. 结果处理
+   - 等待执行结果
+   - 不要假设结果
+   - 不要创建虚假响应
+   - 不要想象对话
 
-4. Information Management
-   - Ask user if info is insufficient
-   - Skip unnecessary steps
-   - Request guidance if stuck
-   - Don't proceed with incomplete info
+4. 信息管理
+   - 如果信息不足，询问用户
+   - 跳过不必要的步骤
+   - 如果卡住，请求指导
+   - 不要在没有完整信息的情况下继续
 
-# 📝 String Parameter Format
-ALWAYS use | syntax for string parameters:
+# 📝 字符串参数格式
+始终使用 | 语法表示字符串参数：
 
 <TOOL_CALL>
 name: execute_shell
@@ -314,19 +314,19 @@ arguments:
         git status --porcelain
 </TOOL_CALL>
 
-# 💡 Best Practices
-- Start execution immediately when ready
-- No need to ask for permission to begin
-- Use proper string formatting
-- Monitor progress and adjust
-- Request help when stuck
-
-# ⚠️ Common Mistakes to Avoid
-- Multiple tool calls at once
-- Missing | for string parameters
-- Assuming tool results
-- Creating fictional dialogues
-- Proceeding without required info
+# 💡 最佳实践
+- 准备好后立即开始执行
+- 无需请求许可即可开始
+- 使用正确的字符串格式
+- 监控进度并调整
+- 遇到困难时请求帮助
+
+# ⚠️ 常见错误
+- 同时调用多个工具
+- 字符串参数缺少 |
+- 假设工具结果
+- 创建虚构对话
+- 在没有所需信息的情况下继续
 """
             
             if isinstance(args, str):
@@ -354,11 +354,11 @@ arguments:
             stderr = result.get("stderr", "")
             output_parts = []
             if stdout:
-                output_parts.append(f"Output:\n{stdout}")
+                output_parts.append(f"输出:\n{stdout}")
             if stderr:
-                output_parts.append(f"Error:\n{stderr}")
+                output_parts.append(f"错误:\n{stderr}")
             output = "\n\n".join(output_parts)
-            output = "no output and error" if not output else output
+            output = "无输出和错误" if not output else output
             
             # Process the result
             if result["success"]:
@@ -375,33 +375,33 @@ arguments:
                         max_count = self.max_token_count
                         if get_context_token_count(output) > max_count:
                             output_to_summarize = output[-max_count:]
-                            truncation_notice = f"\n(Note: Due to the length of the output, only the last {max_count} characters are summarized)"
+                            truncation_notice = f"\n(注意：由于输出过长，仅总结最后 {max_count} 个字符)"
                         else:
                             output_to_summarize = output
                             truncation_notice = ""
 
-                        prompt = f"""Please summarize the execution result of the following tool, extracting key information and important results. Note:
-1. Keep all important numerical values, paths, error information, etc.
-2. Maintain the accuracy of the results
-3. Describe the main content in concise language
-4. If there is error information, ensure it is included in the summary
+                        prompt = f"""请总结以下工具的执行结果，提取关键信息和重要结果。注意：
+1. 保留所有重要的数值、路径、错误信息等
+2. 保持结果的准确性
+3. 用简洁的语言描述主要内容
+4. 如果有错误信息，确保包含在总结中
 
-Tool name: {name}
-Execution result:
+工具名称: {name}
+执行结果:
 {output_to_summarize}
 
-Please provide a summary:"""
+请提供总结:"""
 
                         summary = model.chat_until_success(prompt)
-                        output = f"""--- Original output is too long, here is the summary ---{truncation_notice}
+                        output = f"""--- 原始输出过长，以下是总结 ---{truncation_notice}
 
 {summary}
 
---- Summary ends ---"""
+--- 总结结束 ---"""
                         
                     except Exception as e:
                         PrettyOutput.print(f"总结失败: {str(e)}", OutputType.ERROR)
-                        output = f"Output is too long ({len(output)} characters), it is recommended to view the original output.\nPreview of the first 300 characters:\n{output[:300]}..."
+                        output = f"输出过长 ({len(output)} 字符)，建议查看原始输出。\n前300字符预览:\n{output[:300]}..."
             
             else:
                 PrettyOutput.section("执行失败", OutputType.WARNING)
@@ -410,4 +410,4 @@ Please provide a summary:"""
             
         except Exception as e:
             PrettyOutput.print(f"工具执行失败：{str(e)}", OutputType.ERROR)
-            return f"Tool call failed: {str(e)}"
+            return f"工具调用失败: {str(e)}"

jarvis/jarvis_tools/search_web.py

@@ -66,21 +66,21 @@ def bing_search(query):
 
 class SearchTool:
     name = "search_web"
-    description = "Use Bing search engine to search for information, and extract key information based on the question"
+    description = "使用Bing搜索引擎搜索信息，并根据问题提取关键信息"
     parameters = {
         "type": "object",
         "properties": {
             "query": {
                 "type": "string",
-                "description": "Search keywords"
+                "description": "搜索关键词"
             },
             "question": {
                 "type": "string",
-                "description": "Specific question to answer, used to extract relevant information from search results"
+                "description": "要回答的具体问题，用于从搜索结果中提取相关信息"
             },
             "max_results": {
                 "type": "integer",
-                "description": "Maximum number of search results",
+                "description": "最大搜索结果数量",
                 "default": 3
             }
         },
@@ -293,4 +293,4 @@ def main():
         sys.exit(1)
 
 if __name__ == "__main__":
-    main() 
+    main()

jarvis/jarvis_tools/select_code_files.py

@@ -6,7 +6,7 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class CodeFileSelecterTool:
     name = "select_code_files"
-    description = "Select and manage code files for modification with interactive file selection"
+    description = "通过交互式文件选择工具选择和修改代码文件"
     parameters = {
         "type": "object",
         "properties": {
@@ -15,12 +15,12 @@ class CodeFileSelecterTool:
                 "items": {
                     "type": "string",
                 },
-                "description": "List of initially related files",
+                "description": "初始相关的文件列表",
                 "default": []
             },
             "root_dir": {
                 "type": "string",
-                "description": "Root directory of the codebase",
+                "description": "代码库的根目录",
                 "default": "."
             }
         },