jarvis-ai-assistant 0.1.98__py3-none-any.whl → 0.1.100__py3-none-any.whl

jarvis/tools/{generator.py → generate_tool.py}

@@ -32,16 +32,15 @@ class ToolGeneratorTool:
     }
 
     def __init__(self):
-        """初始化工具生成器
-        """
-        # 设置工具目录
-        self.tools_dir = Path.home() / '.jarvis_tools'
+        """Initialize tool generator"""
+        # Set tool directory
+        self.tools_dir = Path.home() / '.jarvis/tools'
         
-        # 确保工具目录存在
+        # Ensure tool directory exists
         self.tools_dir.mkdir(parents=True, exist_ok=True)
 
     def _generate_tool_code(self, tool_name: str, class_name: str, description: str, parameters: Dict) -> str:
-        """使用大模型生成工具代码"""
+        """Use large model to generate tool code"""
         model = PlatformRegistry.get_global_platform_registry().get_codegen_platform()
 
         prompt = f"""Please generate the code for a Python tool class, with the following requirements, and do not output any content except the code:
@@ -96,36 +95,37 @@ class ExampleTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {{
                 "success": False,
-                "error": str(e)
+                "stdout": "",
+                "stderr": str(e)
             }}
 ```"""
 
-        # 调用模型生成代码
+        # Call model to generate code
         response = model.chat_until_success(prompt)
 
-        # 提取代码块
+        # Extract code block
         code_start = response.find("```python")
         code_end = response.find("```", code_start + 9)
         
         if code_start == -1 or code_end == -1:
-            # 如果没有找到代码块标记，假设整个响应都是代码
+            # If code block marker not found, assume the entire response is code
             return response
         
-        # 提取代码块内容（去掉```python和```标记）
+        # Extract code block content (remove ```python and ``` markers)
         code = response[code_start + 9:code_end].strip()
         return code
 
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """生成工具代码"""
+        """Generate tool code"""
         try:
             tool_name = args["tool_name"]
             class_name = args["class_name"]
             description = args["description"]
             parameters = args["parameters"]
 
-            PrettyOutput.print(f"开始生成工具: {tool_name}", OutputType.INFO)
+            PrettyOutput.print(f"Start generating tool: {tool_name}", OutputType.INFO)
 
-            # 生成工具代码
+            # Generate tool code
             tool_code = self._generate_tool_code(
                 tool_name,
                 class_name,
@@ -133,34 +133,35 @@ class ExampleTool:
                 parameters
             )
 
-            # 获取工具文件路径
+            # Get tool file path
             tool_file = self.tools_dir / f"{tool_name}.py"
 
-            # 写入工具文件
+            # Write tool file
             with open(tool_file, "w", encoding="utf-8") as f:
                 f.write(tool_code)
 
-            # 创建或更新 __init__.py
+            # Create or update __init__.py
             init_file = self.tools_dir / "__init__.py"
             if not init_file.exists():
                 with open(init_file, "w", encoding="utf-8") as f:
                     f.write("# Jarvis Tools\n")
 
-            # 注册工具
+            # Register tool
             success = ToolRegistry.get_global_tool_registry().register_tool_by_file(str(tool_file))
             if not success:
                 return {
                     "success": False,
-                    "error": "工具生成成功但注册失败"
+                    "stdout": "",
+                    "stderr": "Tool generated successfully but registration failed"
                 }
 
             return {
                 "success": True,
-                "stdout": f"工具已生成并注册到Jarvis\n"
-                         f"工具目录: {self.tools_dir}\n"
-                         f"工具名称: {tool_name}\n"
-                         f"工具描述: {description}\n"
-                         f"工具参数: {parameters}",
+                "stdout": f"Tool generated and registered to Jarvis\n"
+                         f"Tool directory: {self.tools_dir}\n"
+                         f"Tool name: {tool_name}\n"
+                         f"Tool description: {description}\n"
+                         f"Tool parameters: {parameters}",
                 "stderr": ""
             }
 
@@ -168,5 +169,6 @@ class ExampleTool:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"生成工具失败: {str(e)}"
+                "stdout": "",
+                "stderr": f"Failed to generate tool: {str(e)}"
             }

jarvis/tools/methodology.py

@@ -5,7 +5,7 @@ from jarvis.utils import OutputType, PrettyOutput
 
 
 class MethodologyTool:
-    """经验管理工具"""
+    """Experience management tool"""
     
     name = "methodology"
     description = "Manage problem-solving methodologies, supporting add, update, and delete operations"
@@ -31,47 +31,47 @@ class MethodologyTool:
     }
     
     def __init__(self):
-        """初始化经验管理工具"""
-        self.methodology_file = os.path.expanduser("~/.jarvis_methodology")
+        """Initialize the experience management tool"""
+        self.methodology_file = os.path.expanduser("~/.jarvis/methodology")
         self._ensure_file_exists()
             
     def _ensure_file_exists(self):
-        """确保方法论文件存在"""
+        """Ensure the methodology file exists"""
         if not os.path.exists(self.methodology_file):
             try:
                 with open(self.methodology_file, 'w', encoding='utf-8') as f:
                     yaml.safe_dump({}, f, allow_unicode=True)
             except Exception as e:
-                PrettyOutput.print(f"创建方法论文件失败: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to create methodology file: {str(e)}", OutputType.ERROR)
                 
     def _load_methodologies(self) -> Dict:
-        """加载所有方法论"""
+        """Load all methodologies"""
         try:
             with open(self.methodology_file, 'r', encoding='utf-8') as f:
                 return yaml.safe_load(f) or {}
         except Exception as e:
-            PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to load methodologies: {str(e)}", OutputType.ERROR)
             return {}
             
     def _save_methodologies(self, methodologies: Dict):
-        """保存所有方法论"""
+        """Save all methodologies"""
         try:
             with open(self.methodology_file, 'w', encoding='utf-8') as f:
                 yaml.safe_dump(methodologies, f, allow_unicode=True)
         except Exception as e:
-            PrettyOutput.print(f"保存方法论失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to save methodologies: {str(e)}", OutputType.ERROR)
             
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行方法论管理操作
+        """Execute the operation of managing methodologies
         
         Args:
-            args: 包含操作参数的字典
-                - operation: 操作类型 (delete/update/add)
-                - problem_type: 问题类型
-                - content: 方法论内容 (update/add 时必需)
+            args: A dictionary containing the operation parameters
+                - operation: The operation type (delete/update/add)
+                - problem_type: The problem type
+                - content: The methodology content (required for update/add)
             
         Returns:
-            Dict[str, Any]: 包含执行结果的字典
+            Dict[str, Any]: A dictionary containing the execution result
         """
         operation = args.get("operation")
         problem_type = args.get("problem_type")
@@ -80,7 +80,8 @@ class MethodologyTool:
         if not operation or not problem_type:
             return {
                 "success": False,
-                "error": "缺少必要参数: operation 和 problem_type"
+                "stdout": "",
+                "stderr": "Missing required parameters: operation and problem_type"
             }
             
         methodologies = self._load_methodologies()
@@ -92,50 +93,55 @@ class MethodologyTool:
                     self._save_methodologies(methodologies)
                     return {
                         "success": True,
-                        "stdout": f"已删除问题类型 '{problem_type}' 的方法论"
+                        "stdout": f"Deleted methodology for problem type '{problem_type}'"
                     }
                 else:
                     return {
                         "success": False,
-                        "error": f"未找到问题类型 '{problem_type}' 的方法论"
+                        "stdout": "",
+                        "stderr": f"Methodology for problem type '{problem_type}' not found"
                     }
                     
             elif operation in ["update", "add"]:
                 if not content:
                     return {
                         "success": False,
-                        "error": "需要提供方法论内容"
+                        "stdout": "",
+                        "stderr": "Need to provide methodology content"
                     }
                     
                 methodologies[problem_type] = content
                 self._save_methodologies(methodologies)
                 
-                action = "更新" if problem_type in methodologies else "添加"
+                action = "Update" if problem_type in methodologies else "Add"
                 return {
                     "success": True,
-                    "stdout": f"已{action}问题类型 '{problem_type}' 的方法论"
+                    "stdout": f"{action} methodology for problem type '{problem_type}'",
+                    "stderr": ""
                 }
                 
             else:
                 return {
                     "success": False,
-                    "error": f"不支持的操作类型: {operation}"
+                    "stdout": "",
+                    "stderr": f"Unsupported operation type: {operation}"
                 }
                 
         except Exception as e:
             return {
                 "success": False,
-                "error": f"执行失败: {str(e)}"
+                "stdout": "",
+                "stderr": f"Execution failed: {str(e)}"
             }
             
     def get_methodology(self, problem_type: str) -> Optional[str]:
-        """获取指定问题类型的方法论
+        """Get the methodology for a specific problem type
         
         Args:
-            problem_type: 问题类型
+            problem_type: The problem type
             
         Returns:
-            Optional[str]: 方法论内容，如果不存在则返回 None
+            Optional[str]: The methodology content, or None if it does not exist
         """
         methodologies = self._load_methodologies()
         return methodologies.get(problem_type) 

jarvis/tools/rag.py

@@ -27,71 +27,74 @@ class RAGTool:
     }
 
     def __init__(self):
-        """初始化 RAG 工具"""
-        self.rag_instances = {}  # 缓存不同目录的 RAG 实例
+        """Initialize RAG tool"""
+        self.rag_instances = {}  # Cache RAG instances for different directories
 
     def _get_rag_instance(self, dir_path: str) -> RAGCore:
-        """获取或创建 RAG 实例
+        """Get or create RAG instance
         
         Args:
-            dir_path: 文档目录的绝对路径
+            dir_path: The absolute path of the document directory
             
         Returns:
-            RAGCore: RAG 实例
+            RAGCore: RAG instance
         """
         if dir_path not in self.rag_instances:
             self.rag_instances[dir_path] = RAGCore(dir_path)
         return self.rag_instances[dir_path]
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行文档问答
+        """Execute document question and answer
         
         Args:
-            args: 包含参数的字典
-                - dir: 文档目录路径
-                - question: 要询问的问题
-                - rebuild_index: 是否重建索引
+            args: A dictionary containing parameters
+                - dir: The document directory path
+                - question: The question to ask
+                - rebuild_index: Whether to rebuild the index
                 
         Returns:
-            Dict[str, Any]: 执行结果
+            Dict[str, Any]: The execution result
         """
         try:
-            # 获取参数
-            dir_path = os.path.expanduser(args["dir"])  # 展开 ~ 等路径
-            dir_path = os.path.abspath(dir_path)  # 转换为绝对路径
+            # Get parameters
+            dir_path = os.path.expanduser(args["dir"])  # Expand ~ paths
+            dir_path = os.path.abspath(dir_path)  # Convert to absolute path
             question = args["question"]
             rebuild_index = args.get("rebuild_index", False)
             
-            # 检查目录是否存在
+            # Check if the directory exists
             if not os.path.exists(dir_path):
                 return {
                     "success": False,
-                    "error": f"目录不存在: {dir_path}"
+                    "stdout": "",
+                    "stderr": f"Directory does not exist: {dir_path}"
                 }
                 
-            # 检查是否是目录
+            # Check if it is a directory
             if not os.path.isdir(dir_path):
                 return {
                     "success": False,
-                    "error": f"路径不是目录: {dir_path}"
+                    "stdout": "",
+                    "stderr": f"The path is not a directory: {dir_path}"
                 }
                 
-            # 获取 RAG 实例
+            # Get RAG instance
             rag = self._get_rag_instance(dir_path)
             
-            # 如果需要重建索引或索引不存在
+            # If you need to rebuild the index or the index does not exist
             if rebuild_index or not rag.is_index_built():
-                PrettyOutput.print("正在构建文档索引...", OutputType.INFO)
+                PrettyOutput.print("Building document index...", OutputType.INFO)
                 rag.build_index(dir_path)
             
-            # 执行问答
-            PrettyOutput.print(f"问题: {question}", OutputType.INFO)
+            # Execute question and answer
+            PrettyOutput.print(f"Question: {question}", OutputType.INFO)
             response = rag.ask(question)
             
             if response is None:
                 return {
                     "success": False,
-                    "error": "未能获取答案，可能是没有找到相关文档"
+                    "stdout": "",
+                    "stderr": "Failed to get answer, possibly no relevant documents found"
                 }
                 
             return {
@@ -101,20 +104,21 @@ class RAGTool:
             }
             
         except Exception as e:
-            PrettyOutput.print(f"文档问答失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Document question and answer failed: {str(e)}", OutputType.ERROR)
             return {
                 "success": False,
-                "error": f"执行失败: {str(e)}"
+                "stdout": "",
+                "stderr": f"Execution failed: {str(e)}"
             }
 
 def main():
-    """命令行直接运行工具"""
+    """Run the tool directly from the command line"""
     import argparse
     
-    parser = argparse.ArgumentParser(description='文档问答工具')
-    parser.add_argument('--dir', required=True, help='文档目录路径')
-    parser.add_argument('--question', required=True, help='要询问的问题')
-    parser.add_argument('--rebuild', action='store_true', help='重建索引')
+    parser = argparse.ArgumentParser(description='Document question and answer tool')
+    parser.add_argument('--dir', required=True, help='Document directory path')
+    parser.add_argument('--question', required=True, help='The question to ask')
+    parser.add_argument('--rebuild', action='store_true', help='Rebuild index')
     args = parser.parse_args()
     
     tool = RAGTool()
@@ -125,10 +129,10 @@ def main():
     })
     
     if result["success"]:
-        PrettyOutput.print("\n回答:", OutputType.INFO)
+        PrettyOutput.print("\nAnswer:", OutputType.INFO)
         PrettyOutput.print(result["stdout"], OutputType.INFO)
     else:
-        PrettyOutput.print(result["error"], OutputType.ERROR)
+        PrettyOutput.print(result["stderr"], OutputType.ERROR)
 
 if __name__ == "__main__":
     main() 

jarvis/tools/{webpage.py → read_webpage.py}

@@ -67,10 +67,12 @@ class WebpageTool:
         except requests.RequestException as e:
             return {
                 "success": False,
-                "error": f"Webpage request failed: {str(e)}"
+                "stdout": "",
+                "stderr": f"Webpage request failed: {str(e)}"
             }
         except Exception as e:
             return {
                 "success": False,
-                "error": f"Failed to parse webpage: {str(e)}"
+                "stdout": "",
+                "stderr": f"Failed to parse webpage: {str(e)}"
             }