jarvis-ai-assistant 0.1.46__py3-none-any.whl → 0.1.48__py3-none-any.whl

jarvis/tools/__init__.py

@@ -2,4 +2,4 @@ from .registry import ToolRegistry
 
 __all__ = [
     'ToolRegistry',
-]
+] 

jarvis/tools/base.py

@@ -2,9 +2,9 @@ from typing import Dict, Any, Callable
 import json
 
 
+
 class Tool:
-    def __init__(self, name: str, description: str,
-                 parameters: Dict, func: Callable):
+    def __init__(self, name: str, description: str, parameters: Dict, func: Callable):
         self.name = name
         self.description = description
         self.parameters = parameters

jarvis/tools/file_ops.py

@@ -34,19 +34,18 @@ class FileOperationTool:
         "required": ["operation", "filepath"]
     }
 
+
     def execute(self, args: Dict) -> Dict[str, Any]:
         """执行文件操作"""
         try:
             operation = args["operation"]
             filepath = args["filepath"]
             encoding = args.get("encoding", "utf-8")
-
+            
             # 记录操作和完整路径
             abs_path = os.path.abspath(filepath)
-            PrettyOutput.print(
-                f"文件操作: {operation} - {abs_path}",
-                OutputType.INFO)
-
+            PrettyOutput.print(f"文件操作: {operation} - {abs_path}", OutputType.INFO)
+            
             if operation == "exists":
                 exists = os.path.exists(filepath)
                 return {
@@ -54,21 +53,21 @@ class FileOperationTool:
                     "stdout": str(exists),
                     "stderr": ""
                 }
-
+                
             elif operation == "read":
                 if not os.path.exists(filepath):
                     return {
                         "success": False,
                         "error": f"文件不存在: {filepath}"
                     }
-
+                    
                 # 检查文件大小
                 if os.path.getsize(filepath) > 10 * 1024 * 1024:  # 10MB
                     return {
                         "success": False,
                         "error": "文件过大 (>10MB)"
                     }
-
+                    
                 with open(filepath, 'r', encoding=encoding) as f:
                     content = f.read()
                 return {
@@ -76,39 +75,36 @@ class FileOperationTool:
                     "stdout": content,
                     "stderr": ""
                 }
-
+                
             elif operation in ["write", "append"]:
                 if not args.get("content"):
                     return {
                         "success": False,
                         "error": "写入/追加操作需要提供content参数"
                     }
-
+                
                 # 创建目录（如果不存在）
-                os.makedirs(
-                    os.path.dirname(
-                        os.path.abspath(filepath)),
-                    exist_ok=True)
-
+                os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
+                    
                 mode = 'a' if operation == "append" else 'w'
                 with open(filepath, mode, encoding=encoding) as f:
                     f.write(args["content"])
-
+                    
                 return {
                     "success": True,
                     "stdout": f"成功{operation}内容到 {filepath}",
                     "stderr": ""
                 }
-
+                
             else:
                 return {
                     "success": False,
                     "error": f"未知操作: {operation}"
                 }
-
+                
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
                 "success": False,
                 "error": f"文件操作失败: {str(e)}"
-            }
+            } 

jarvis/tools/generator.py

@@ -5,7 +5,6 @@ from jarvis.models.registry import PlatformRegistry
 from jarvis.tools.registry import ToolRegistry
 from jarvis.utils import OutputType, PrettyOutput
 
-
 class ToolGeneratorTool:
     name = "generate_tool"
     description = "生成新的工具代码并自动注册到Jarvis，自动扩充Jarvis的能力"
@@ -37,15 +36,13 @@ class ToolGeneratorTool:
         """
         # 设置工具目录
         self.tools_dir = Path.home() / '.jarvis_tools'
-
+        
         # 确保工具目录存在
         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:
+    def _generate_tool_code(self, tool_name: str, class_name: str, description: str, parameters: Dict) -> str:
         """使用大模型生成工具代码"""
-        platform_name = os.getenv(
-            "JARVIS_CODEGEN_PLATFORM") or PlatformRegistry.get_global_platform_name()
+        platform_name = os.getenv("JARVIS_CODEGEN_PLATFORM") or PlatformRegistry.get_global_platform_name()
         model = PlatformRegistry.create_platform(platform_name)
         model_name = os.getenv("JARVIS_CODEGEN_MODEL")
         if model_name:
@@ -84,16 +81,16 @@ class ExampleTool:
             # 验证参数示例
             if "param1" not in args:
                 return {{"success": False, "error": "缺少必需参数: param1"}}
-
+            
             # 记录操作示例
             PrettyOutput.print(f"处理参数: {{args['param1']}}", OutputType.INFO)
 
             # 使用大模型示例
             response = self.model.chat("prompt")
-
+            
             # 实现具体功能
             result = "处理结果"
-
+            
             return {{
                 "success": True,
                 "stdout": result,
@@ -114,11 +111,11 @@ class ExampleTool:
         # 提取代码块
         code_start = response.find("```python")
         code_end = response.find("```", code_start + 9)
-
+        
         if code_start == -1 or code_end == -1:
             # 如果没有找到代码块标记，假设整个响应都是代码
             return response
-
+        
         # 提取代码块内容（去掉```python和```标记）
         code = response[code_start + 9:code_end].strip()
         return code
@@ -165,10 +162,10 @@ class ExampleTool:
             return {
                 "success": True,
                 "stdout": f"工具已生成并注册到Jarvis\n"
-                f"工具目录: {self.tools_dir}\n"
-                f"工具名称: {tool_name}\n"
-                f"工具描述: {description}\n"
-                f"工具参数: {parameters}",
+                         f"工具目录: {self.tools_dir}\n"
+                         f"工具名称: {tool_name}\n"
+                         f"工具描述: {description}\n"
+                         f"工具参数: {parameters}",
                 "stderr": ""
             }
 

jarvis/tools/methodology.py

@@ -6,7 +6,7 @@ from jarvis.utils import OutputType, PrettyOutput
 
 class MethodologyTool:
     """经验管理工具"""
-
+    
     name = "methodology"
     description = "管理问题处理经验总结，支持添加、更新、删除操作"
     parameters = {
@@ -29,12 +29,12 @@ class MethodologyTool:
         },
         "required": ["operation", "problem_type"]
     }
-
+    
     def __init__(self):
         """初始化经验管理工具"""
         self.methodology_file = os.path.expanduser("~/.jarvis_methodology")
         self._ensure_file_exists()
-
+            
     def _ensure_file_exists(self):
         """确保经验总结文件存在"""
         if not os.path.exists(self.methodology_file):
@@ -43,7 +43,7 @@ class MethodologyTool:
                     yaml.safe_dump({}, f, allow_unicode=True)
             except Exception as e:
                 PrettyOutput.print(f"创建经验总结文件失败: {str(e)}", OutputType.ERROR)
-
+                
     def _load_methodologies(self) -> Dict:
         """加载所有经验总结"""
         try:
@@ -52,7 +52,7 @@ class MethodologyTool:
         except Exception as e:
             PrettyOutput.print(f"加载经验总结失败: {str(e)}", OutputType.ERROR)
             return {}
-
+            
     def _save_methodologies(self, methodologies: Dict):
         """保存所有经验总结"""
         try:
@@ -60,31 +60,31 @@ class MethodologyTool:
                 yaml.safe_dump(methodologies, f, allow_unicode=True)
         except Exception as e:
             PrettyOutput.print(f"保存经验总结失败: {str(e)}", OutputType.ERROR)
-
+            
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行经验总结管理操作
-
+        
         Args:
             args: 包含操作参数的字典
                 - operation: 操作类型 (delete/update/add)
                 - problem_type: 问题类型
                 - content: 经验总结内容 (update/add 时必需)
-
+            
         Returns:
             Dict[str, Any]: 包含执行结果的字典
         """
         operation = args.get("operation")
         problem_type = args.get("problem_type")
         content = args.get("content")
-
+        
         if not operation or not problem_type:
             return {
                 "success": False,
                 "error": "缺少必要参数: operation 和 problem_type"
             }
-
+            
         methodologies = self._load_methodologies()
-
+        
         try:
             if operation == "delete":
                 if problem_type in methodologies:
@@ -99,43 +99,43 @@ class MethodologyTool:
                         "success": False,
                         "error": f"未找到问题类型 '{problem_type}' 的经验总结"
                     }
-
+                    
             elif operation in ["update", "add"]:
                 if not content:
                     return {
                         "success": False,
                         "error": "需要提供经验总结内容"
                     }
-
+                    
                 methodologies[problem_type] = content
                 self._save_methodologies(methodologies)
-
+                
                 action = "更新" if problem_type in methodologies else "添加"
                 return {
                     "success": True,
                     "stdout": f"已{action}问题类型 '{problem_type}' 的经验总结"
                 }
-
+                
             else:
                 return {
                     "success": False,
                     "error": f"不支持的操作类型: {operation}"
                 }
-
+                
         except Exception as e:
             return {
                 "success": False,
                 "error": f"执行失败: {str(e)}"
             }
-
+            
     def get_methodology(self, problem_type: str) -> Optional[str]:
         """获取指定问题类型的经验总结
-
+        
         Args:
             problem_type: 问题类型
-
+            
         Returns:
             Optional[str]: 经验总结内容，如果不存在则返回 None
         """
         methodologies = self._load_methodologies()
-        return methodologies.get(problem_type)
+        return methodologies.get(problem_type) 

jarvis/tools/registry.py

@@ -11,8 +11,7 @@ from jarvis.utils import OutputType, PrettyOutput
 
 
 class ToolRegistry:
-    global_tool_registry = None  # type: ignore
-
+    global_tool_registry = None # type: ignore
     def __init__(self):
         """初始化工具注册器
         """
@@ -31,13 +30,13 @@ class ToolRegistry:
     def _load_builtin_tools(self):
         """从内置tools目录加载工具"""
         tools_dir = Path(__file__).parent
-
+        
         # 遍历目录下的所有.py文件
         for file_path in tools_dir.glob("*.py"):
             # 跳过基础文件和__init__.py
             if file_path.name in ["base.py", "__init__.py", "registry.py"]:
                 continue
-
+                
             self.register_tool_by_file(file_path)
 
     def _load_external_tools(self):
@@ -45,21 +44,21 @@ class ToolRegistry:
         external_tools_dir = Path.home() / '.jarvis_tools'
         if not external_tools_dir.exists():
             return
-
+            
         # 遍历目录下的所有.py文件
         for file_path in external_tools_dir.glob("*.py"):
             # 跳过__init__.py
             if file_path.name == "__init__.py":
                 continue
-
+                
             self.register_tool_by_file(file_path)
 
     def register_tool_by_file(self, file_path: str):
         """从指定文件加载并注册工具
-
+        
         Args:
             file_path: 工具文件的路径
-
+            
         Returns:
             bool: 是否成功加载工具
         """
@@ -68,32 +67,31 @@ class ToolRegistry:
             if not file_path.exists() or not file_path.is_file():
                 PrettyOutput.print(f"文件不存在: {file_path}", OutputType.ERROR)
                 return False
-
+                
             # 动态导入模块
             module_name = file_path.stem
-            spec = importlib.util.spec_from_file_location(
-                module_name, file_path)
+            spec = importlib.util.spec_from_file_location(module_name, file_path)
             if not spec or not spec.loader:
                 PrettyOutput.print(f"无法加载模块: {file_path}", OutputType.ERROR)
                 return False
-
+                
             module = importlib.util.module_from_spec(spec)
             sys.modules[module_name] = module  # 添加到 sys.modules 以支持相对导入
             spec.loader.exec_module(module)
-
+            
             # 查找模块中的工具类
             tool_found = False
             for item_name in dir(module):
                 item = getattr(module, item_name)
                 # 检查是否是类，并且有必要的属性
-                if (isinstance(item, type) and
-                    hasattr(item, 'name') and
-                    hasattr(item, 'description') and
-                        hasattr(item, 'parameters')):
-
+                if (isinstance(item, type) and 
+                    hasattr(item, 'name') and 
+                    hasattr(item, 'description') and 
+                    hasattr(item, 'parameters')):
+                    
                     # 实例化工具类，传入模型和输出处理器
                     tool_instance = item()
-
+                    
                     # 注册工具
                     self.register_tool(
                         name=tool_instance.name,
@@ -101,31 +99,20 @@ class ToolRegistry:
                         parameters=tool_instance.parameters,
                         func=tool_instance.execute
                     )
-                    PrettyOutput.print(
-                        f"从 {file_path} 加载工具: {
-                            tool_instance.name}: {
-                            tool_instance.description}",
-                        OutputType.INFO)
+                    PrettyOutput.print(f"从 {file_path} 加载工具: {tool_instance.name}: {tool_instance.description}", OutputType.INFO)
                     tool_found = True
-
+                    
             if not tool_found:
-                PrettyOutput.print(
-                    f"文件中未找到有效的工具类: {file_path}",
-                    OutputType.WARNING)
+                PrettyOutput.print(f"文件中未找到有效的工具类: {file_path}", OutputType.WARNING)
                 return False
-
+                
             return True
-
+            
         except Exception as e:
-            PrettyOutput.print(
-                f"加载工具失败 {
-                    file_path.name}: {
-                    str(e)}",
-                OutputType.ERROR)
+            PrettyOutput.print(f"加载工具失败 {file_path.name}: {str(e)}", OutputType.ERROR)
             return False
 
-    def register_tool(self, name: str, description: str,
-                      parameters: Dict, func: Callable):
+    def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
         """注册新工具"""
         self.tools[name] = Tool(name, description, parameters, func)
 
@@ -149,12 +136,12 @@ class ToolRegistry:
         try:
             if not tool_calls:
                 return ""
-
+                
             # 只处理第一个工具调用
             tool_call = tool_calls[0]
             name = tool_call["name"]
             args = tool_call["arguments"]
-
+            
             if isinstance(args, str):
                 try:
                     args = json.loads(args)
@@ -166,14 +153,13 @@ class ToolRegistry:
             PrettyOutput.section(f"执行工具: {name}", OutputType.TOOL)
             if isinstance(args, dict):
                 for key, value in args.items():
-                    PrettyOutput.print(
-                        f"参数: {key} = {value}", OutputType.DEBUG)
+                    PrettyOutput.print(f"参数: {key} = {value}", OutputType.DEBUG)
             else:
                 PrettyOutput.print(f"参数: {args}", OutputType.DEBUG)
-
+            
             # 执行工具调用
             result = self.execute_tool(name, args)
-
+            
             # 处理结果
             if result["success"]:
                 stdout = result["stdout"]
@@ -190,7 +176,7 @@ class ToolRegistry:
                 error_msg = result["error"]
                 output = f"执行失败: {error_msg}"
                 PrettyOutput.section("执行失败", OutputType.ERROR)
-
+                
             return output
         except Exception as e:
             PrettyOutput.print(f"执行工具失败: {str(e)}", OutputType.ERROR)

jarvis/tools/shell.py

@@ -21,6 +21,7 @@ class ShellTool:
         "required": ["command"]
     }
 
+
     def _escape_command(self, cmd: str) -> str:
         """转义命令中的特殊字符"""
         return cmd.replace("'", "'\"'\"'")
@@ -29,23 +30,21 @@ class ShellTool:
         """执行shell命令"""
         try:
             command = args["command"]
-
+            
             # 生成临时文件名
-            output_file = os.path.join(
-                tempfile.gettempdir(), f"jarvis_shell_{
-                    os.getpid()}.log")
-
+            output_file = os.path.join(tempfile.gettempdir(), f"jarvis_shell_{os.getpid()}.log")
+            
             # 转义命令中的特殊字符
             escaped_command = self._escape_command(command)
-
+            
             # 修改命令以使用script
             tee_command = f"script -q -c '{escaped_command}' {output_file}"
-
+            
             PrettyOutput.print(f"执行命令: {command}", OutputType.INFO)
-
+            
             # 执行命令
             return_code = os.system(tee_command)
-
+            
             # 读取输出文件
             try:
                 with open(output_file, 'r', encoding='utf-8', errors='replace') as f:
@@ -60,14 +59,14 @@ class ShellTool:
             finally:
                 # 清理临时文件
                 Path(output_file).unlink(missing_ok=True)
-
+            
             return {
                 "success": return_code == 0,
                 "stdout": output,
                 "stderr": "",
                 "return_code": return_code
             }
-
+                
         except Exception as e:
             # 确保清理临时文件
             if 'output_file' in locals():
@@ -76,4 +75,4 @@ class ShellTool:
             return {
                 "success": False,
                 "error": str(e)
-            }
+            } 

jarvis/tools/sub_agent.py

@@ -39,6 +39,7 @@ class SubAgentTool:
         "required": ["agent_name", "task", "context", "goal"]
     }
 
+
     def execute(self, args: Dict) -> Dict[str, Any]:
         """创建并运行子代理"""
         try:
@@ -78,4 +79,4 @@ class SubAgentTool:
             return {
                 "success": False,
                 "error": f"子代理执行失败: {str(e)}"
-            }
+            }