jarvis-ai-assistant 0.1.32__py3-none-any.whl

jarvis/tools/generator.py

@@ -0,0 +1,172 @@
+from typing import Dict, Any
+from pathlib import Path
+from jarvis.models.registry import ModelRegistry
+from jarvis.tools.registry import ToolRegistry
+from jarvis.utils import OutputType, PrettyOutput
+
+class ToolGeneratorTool:
+    name = "generate_tool"
+    description = "生成新的工具代码并自动注册到Jarvis，自动扩充Jarvis的能力"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "tool_name": {
+                "type": "string",
+                "description": "工具的名称（snake_case格式）"
+            },
+            "class_name": {
+                "type": "string",
+                "description": "工具类的名称（PascalCase格式）"
+            },
+            "description": {
+                "type": "string",
+                "description": "工具的功能描述"
+            },
+            "parameters": {
+                "type": "object",
+                "description": "工具参数的JSON Schema定义"
+            }
+        },
+        "required": ["tool_name", "class_name", "description", "parameters"]
+    }
+
+    def __init__(self):
+        """初始化工具生成器
+        """
+        # 设置工具目录
+        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:
+        """使用大模型生成工具代码"""
+        model = ModelRegistry.get_global_model()
+
+        prompt = f"""请生成一个Python工具类的代码，要求如下，除了代码，不要输出任何内容：
+
+1. 类名: {class_name}
+2. 工具名称: {tool_name}
+3. 功能描述: {description}
+4. 参数定义: {parameters}
+
+严格按照以下格式生成代码(各函数的参数和返回值一定要与示例一致)：
+
+```python
+from typing import Dict, Any, Protocol, Optional
+from jarvis.utils import OutputType, PrettyOutput
+from jarvis.models.registry import ModelRegistry
+
+class ExampleTool:
+    name = "example_tool"
+    description = "示例工具"
+    parameters = {{
+        "type": "object",
+        "properties": {{
+            "param1": {{"type": "string"}}
+        }},
+        "required": ["param1"]
+    }}
+
+    def __init__(self):
+        self.model = ModelRegistry.get_global_model()
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        try:
+            # 验证参数示例
+            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,
+                "stderr": ""
+            }}
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {{
+                "success": False,
+                "error": str(e)
+            }}
+```"""
+
+        # 调用模型生成代码
+        response = model.chat(prompt)
+        model.delete_chat()
+
+        # 提取代码块
+        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
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """生成工具代码"""
+        try:
+            tool_name = args["tool_name"]
+            class_name = args["class_name"]
+            description = args["description"]
+            parameters = args["parameters"]
+
+            PrettyOutput.print(f"开始生成工具: {tool_name}", OutputType.INFO)
+
+            # 生成工具代码
+            tool_code = self._generate_tool_code(
+                tool_name,
+                class_name,
+                description,
+                parameters
+            )
+
+            # 获取工具文件路径
+            tool_file = self.tools_dir / f"{tool_name}.py"
+
+            # 写入工具文件
+            with open(tool_file, "w", encoding="utf-8") as f:
+                f.write(tool_code)
+
+            # 创建或更新 __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")
+
+            # 注册工具
+            success = ToolRegistry.get_global_tool_registry().register_tool_by_file(tool_file)
+            if not success:
+                return {
+                    "success": False,
+                    "error": "工具生成成功但注册失败"
+                }
+
+            return {
+                "success": True,
+                "stdout": f"工具已生成并注册到Jarvis\n"
+                         f"工具目录: {self.tools_dir}\n"
+                         f"工具名称: {tool_name}\n"
+                         f"工具描述: {description}\n"
+                         f"工具参数: {parameters}",
+                "stderr": ""
+            }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": f"生成工具失败: {str(e)}"
+            }

jarvis/tools/methodology.py

@@ -0,0 +1,145 @@
+import os
+import yaml
+from typing import Dict, Optional, Any
+from jarvis.utils import OutputType, PrettyOutput
+
+
+class MethodologyTool:
+    """经验管理工具"""
+    
+    name = "methodology"
+    description = "管理问题处理方法论，支持添加、更新、删除操作"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "operation": {
+                "type": "string",
+                "description": "操作类型 (delete/update/add)",
+                "enum": ["delete", "update", "add"]
+            },
+            "problem_type": {
+                "type": "string",
+                "description": "问题类型，例如：code_review, bug_fix 等"
+            },
+            "content": {
+                "type": "string",
+                "description": "方法论内容 (update/add 时必需)",
+                "optional": True
+            }
+        },
+        "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):
+            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)
+                
+    def _load_methodologies(self) -> Dict:
+        """加载所有方法论"""
+        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)
+            return {}
+            
+    def _save_methodologies(self, methodologies: Dict):
+        """保存所有方法论"""
+        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)
+            
+    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:
+                    del methodologies[problem_type]
+                    self._save_methodologies(methodologies)
+                    return {
+                        "success": True,
+                        "stdout": f"已删除问题类型 '{problem_type}' 的方法论"
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": f"未找到问题类型 '{problem_type}' 的方法论"
+                    }
+                    
+            elif operation in ["update", "add"]:
+                if not content:
+                    return {
+                        "success": False,
+                        "error": f"{operation} 操作需要提供方法论内容"
+                    }
+                    
+                if operation == "update" and problem_type not in methodologies:
+                    return {
+                        "success": False,
+                        "error": f"未找到问题类型 '{problem_type}' 的方法论，无法更新"
+                    }
+                    
+                methodologies[problem_type] = content
+                self._save_methodologies(methodologies)
+                return {
+                    "success": True,
+                    "stdout": f"已{'更新' if operation == 'update' else '添加'}问题类型 '{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) 

jarvis/tools/registry.py

@@ -0,0 +1,183 @@
+
+import importlib
+import json
+from pathlib import Path
+import sys
+from typing import Any, Callable, Dict, List, Optional
+
+from jarvis.models.registry import ModelRegistry
+from jarvis.tools.base import Tool
+from jarvis.utils import OutputType, PrettyOutput
+
+
+class ToolRegistry:
+    global_tool_registry = None # type: ignore
+    def __init__(self):
+        """初始化工具注册器
+        """
+        self.tools: Dict[str, Tool] = {}
+        # 加载内置工具和外部工具
+        self._load_builtin_tools()
+        self._load_external_tools()
+
+    @staticmethod
+    def get_global_tool_registry():
+        """获取全局工具注册器"""
+        if ToolRegistry.global_tool_registry is None:
+            ToolRegistry.global_tool_registry = ToolRegistry()
+        return ToolRegistry.global_tool_registry
+
+    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):
+        """从~/.jarvis_tools加载外部工具"""
+        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: 是否成功加载工具
+        """
+        try:
+            file_path = Path(file_path).resolve()  # 获取绝对路径
+            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)
+            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')):
+                    
+                    # 实例化工具类，传入模型和输出处理器
+                    tool_instance = item()
+                    
+                    # 注册工具
+                    self.register_tool(
+                        name=tool_instance.name,
+                        description=tool_instance.description,
+                        parameters=tool_instance.parameters,
+                        func=tool_instance.execute
+                    )
+                    PrettyOutput.print(f"已加载工具: {tool_instance.name}: {tool_instance.description}", OutputType.INFO)
+                    tool_found = True
+                    
+            if not tool_found:
+                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)
+            return False
+
+    def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
+        """注册新工具"""
+        self.tools[name] = Tool(name, description, parameters, func)
+
+    def get_tool(self, name: str) -> Optional[Tool]:
+        """获取工具"""
+        return self.tools.get(name)
+
+    def get_all_tools(self) -> List[Dict]:
+        """获取所有工具的Ollama格式定义"""
+        return [tool.to_dict() for tool in self.tools.values()]
+
+    def execute_tool(self, name: str, arguments: Dict) -> Dict[str, Any]:
+        """执行指定工具"""
+        tool = self.get_tool(name)
+        if tool is None:
+            return {"success": False, "error": f"Tool {name} does not exist"}
+        return tool.execute(arguments)
+
+    def handle_tool_calls(self, tool_calls: List[Dict]) -> str:
+        """处理工具调用，只处理第一个工具"""
+        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)
+                except json.JSONDecodeError:
+                    PrettyOutput.print(f"工具参数格式无效: {name}", OutputType.ERROR)
+                    return ""
+
+            # 显示工具调用信息
+            PrettyOutput.section(f"执行工具: {name}", OutputType.TOOL)
+            if isinstance(args, dict):
+                for key, value in args.items():
+                    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"]
+                stderr = result.get("stderr", "")
+                output_parts = []
+                if stdout:
+                    output_parts.append(f"输出:\n{stdout}")
+                if stderr:
+                    output_parts.append(f"错误:\n{stderr}")
+                output = "\n\n".join(output_parts)
+                output = "没有输出和错误" if not output else output
+                PrettyOutput.section("执行成功", OutputType.SUCCESS)
+            else:
+                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)
+            return f"Tool call failed: {str(e)}"

jarvis/tools/shell.py

@@ -0,0 +1,78 @@
+from typing import Dict, Any
+import os
+import tempfile
+from pathlib import Path
+
+from jarvis.utils import OutputType, PrettyOutput
+
+
+class ShellTool:
+    name = "execute_shell"
+    description = """执行shell命令并返回结果"""
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "Shell command to execute"
+            }
+        },
+        "required": ["command"]
+    }
+
+
+    def _escape_command(self, cmd: str) -> str:
+        """转义命令中的特殊字符"""
+        return cmd.replace("'", "'\"'\"'")
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """执行shell命令"""
+        try:
+            command = args["command"]
+            
+            # 生成临时文件名
+            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:
+                    output = f.read()
+                    # 移除script命令添加的头尾
+                    if output:
+                        lines = output.splitlines()
+                        if len(lines) > 2:
+                            output = "\n".join(lines[1:-1])
+            except Exception as e:
+                output = f"读取输出文件失败: {str(e)}"
+            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():
+                Path(output_file).unlink(missing_ok=True)
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": str(e)
+            } 

jarvis/tools/sub_agent.py

@@ -0,0 +1,82 @@
+from typing import Dict, Any
+
+
+from jarvis.agent import Agent
+from jarvis.utils import OutputType, PrettyOutput
+
+
+class SubAgentTool:
+    name = "create_sub_agent"
+    description = "创建一个子代理来处理特定任务，子代理会生成任务总结报告"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "agent_name": {
+                "type": "string",
+                "description": "子代理的名称"
+            },
+            "task": {
+                "type": "string",
+                "description": "需要完成的具体任务"
+            },
+            "context": {
+                "type": "string",
+                "description": "任务相关的上下文信息",
+                "default": ""
+            },
+            "goal": {
+                "type": "string",
+                "description": "任务的完成目标",
+                "default": ""
+            },
+            "files": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "相关文件路径列表，用于文件问答和处理",
+                "default": []
+            }
+        },
+        "required": ["agent_name", "task", "context", "goal"]
+    }
+
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """创建并运行子代理"""
+        try:
+            agent_name = args["agent_name"]
+            task = args["task"]
+            context = args.get("context", "")
+            goal = args.get("goal", "")
+            files = args.get("files", [])
+
+            PrettyOutput.print(f"创建子代理: {agent_name}", OutputType.INFO)
+
+            # 构建任务描述
+            task_description = task
+            if context:
+                task_description = f"上下文信息:\n{context}\n\n任务:\n{task}"
+            if goal:
+                task_description += f"\n\n完成目标:\n{goal}"
+
+            # 创建子代理
+            sub_agent = Agent(
+                name=agent_name,
+                is_sub_agent=True
+            )
+
+            # 运行子代理，传入文件列表
+            PrettyOutput.print("子代理开始执行任务...", OutputType.INFO)
+            result = sub_agent.run(task_description, file_list=files)
+
+            return {
+                "success": True,
+                "stdout": f"子代理任务完成\n\n{result}",
+                "stderr": ""
+            }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": f"子代理执行失败: {str(e)}"
+            }