jarvis-ai-assistant 0.1.17__tar.gz → 0.1.18__tar.gz

{jarvis_ai_assistant-0.1.17/src/jarvis_ai_assistant.egg-info → jarvis_ai_assistant-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.17
+Version: 0.1.18
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -87,6 +87,9 @@ Dynamic: requires-python
 - File operations (read/write/append)
 - Task automation
 - Predefined task support
+- Dynamic tool system with auto-loading
+- AI-powered tool generation
+- Custom tool development
 
 🔄 **Interactive Experience**
 - Natural language understanding
@@ -95,6 +98,139 @@ Dynamic: requires-python
 - Multi-line input support
 - Colored output with progress indicators
 
+## 🛠️ Custom Tools
+
+### Tool Locations
+- Built-in tools: `src/jarvis/tools/`
+- User tools: `~/.jarvis_tools/` (automatically created)
+
+### Creating Tools
+
+#### 1. Using AI Generator (Recommended)
+```yaml
+<START_TOOL_CALL>
+name: generate_tool
+arguments:
+    tool_name: calculator
+    class_name: CalculatorTool
+    description: Basic math calculations
+    parameters:
+        type: object
+        properties:
+            operation:
+                type: string
+                enum: ["add", "subtract", "multiply", "divide"]
+            numbers:
+                type: array
+                items:
+                    type: number
+        required: ["operation", "numbers"]
+<END_TOOL_CALL>
+```
+
+#### 2. Manual Creation
+Create a new Python file in `~/.jarvis_tools/`:
+
+```python
+from typing import Dict, Any, Protocol, Optional
+from enum import Enum
+
+class OutputType(Enum):
+    INFO = "info"
+    ERROR = "error"
+
+class OutputHandler(Protocol):
+    def print(self, text: str, output_type: OutputType) -> None: ...
+
+class ModelHandler(Protocol):
+    def chat(self, message: str) -> str: ...
+
+class CustomTool:
+    name = "tool_name"              # Tool name for invocation
+    description = "Tool description" # Tool purpose
+    parameters = {                  # JSON Schema for parameters
+        "type": "object",
+        "properties": {
+            "param1": {"type": "string"}
+        },
+        "required": ["param1"]
+    }
+
+    def __init__(self, **kwargs):
+        """Initialize tool with optional dependencies
+        
+        Args:
+            model: AI model for advanced features
+            output_handler: For consistent output formatting
+            register: Access to tool registry
+        """
+        self.model = kwargs.get('model')
+        self.output = kwargs.get('output_handler')
+        self.register = kwargs.get('register')
+        
+    def _print(self, text: str, output_type: OutputType = OutputType.INFO):
+        """Print formatted output"""
+        if self.output:
+            self.output.print(text, output_type)
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute tool functionality
+        
+        Args:
+            args: Parameters passed to the tool
+            
+        Returns:
+            Dict with execution results:
+            {
+                "success": bool,
+                "stdout": str,  # On success
+                "stderr": str,  # Optional error details
+                "error": str    # On failure
+            }
+        """
+        try:
+            # Implement tool logic here
+            result = "Tool execution result"
+            
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+        except Exception as e:
+            self._print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": str(e)
+            }
+```
+
+### Development Guidelines
+
+1. **Tool Structure**
+   - Clear name and description
+   - Well-defined parameters schema
+   - Proper error handling
+   - Consistent output format
+
+2. **Best Practices**
+   - Use `_print` for output
+   - Handle all required parameters
+   - Document functionality
+   - Return standardized results
+   - Keep tools focused and simple
+
+3. **Testing**
+   - Verify parameter validation
+   - Test error handling
+   - Check output format
+   - Ensure proper cleanup
+
+4. **Integration**
+   - Tools are auto-loaded on startup
+   - No manual registration needed
+   - Hot-reload supported
+   - Dependencies injected automatically
 
 ## ⚙️ Environment Setup
 

{jarvis_ai_assistant-0.1.17 → jarvis_ai_assistant-0.1.18}/README.md

@@ -34,6 +34,9 @@
 - File operations (read/write/append)
 - Task automation
 - Predefined task support
+- Dynamic tool system with auto-loading
+- AI-powered tool generation
+- Custom tool development
 
 🔄 **Interactive Experience**
 - Natural language understanding
@@ -42,6 +45,139 @@
 - Multi-line input support
 - Colored output with progress indicators
 
+## 🛠️ Custom Tools
+
+### Tool Locations
+- Built-in tools: `src/jarvis/tools/`
+- User tools: `~/.jarvis_tools/` (automatically created)
+
+### Creating Tools
+
+#### 1. Using AI Generator (Recommended)
+```yaml
+<START_TOOL_CALL>
+name: generate_tool
+arguments:
+    tool_name: calculator
+    class_name: CalculatorTool
+    description: Basic math calculations
+    parameters:
+        type: object
+        properties:
+            operation:
+                type: string
+                enum: ["add", "subtract", "multiply", "divide"]
+            numbers:
+                type: array
+                items:
+                    type: number
+        required: ["operation", "numbers"]
+<END_TOOL_CALL>
+```
+
+#### 2. Manual Creation
+Create a new Python file in `~/.jarvis_tools/`:
+
+```python
+from typing import Dict, Any, Protocol, Optional
+from enum import Enum
+
+class OutputType(Enum):
+    INFO = "info"
+    ERROR = "error"
+
+class OutputHandler(Protocol):
+    def print(self, text: str, output_type: OutputType) -> None: ...
+
+class ModelHandler(Protocol):
+    def chat(self, message: str) -> str: ...
+
+class CustomTool:
+    name = "tool_name"              # Tool name for invocation
+    description = "Tool description" # Tool purpose
+    parameters = {                  # JSON Schema for parameters
+        "type": "object",
+        "properties": {
+            "param1": {"type": "string"}
+        },
+        "required": ["param1"]
+    }
+
+    def __init__(self, **kwargs):
+        """Initialize tool with optional dependencies
+        
+        Args:
+            model: AI model for advanced features
+            output_handler: For consistent output formatting
+            register: Access to tool registry
+        """
+        self.model = kwargs.get('model')
+        self.output = kwargs.get('output_handler')
+        self.register = kwargs.get('register')
+        
+    def _print(self, text: str, output_type: OutputType = OutputType.INFO):
+        """Print formatted output"""
+        if self.output:
+            self.output.print(text, output_type)
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Execute tool functionality
+        
+        Args:
+            args: Parameters passed to the tool
+            
+        Returns:
+            Dict with execution results:
+            {
+                "success": bool,
+                "stdout": str,  # On success
+                "stderr": str,  # Optional error details
+                "error": str    # On failure
+            }
+        """
+        try:
+            # Implement tool logic here
+            result = "Tool execution result"
+            
+            return {
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }
+        except Exception as e:
+            self._print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": str(e)
+            }
+```
+
+### Development Guidelines
+
+1. **Tool Structure**
+   - Clear name and description
+   - Well-defined parameters schema
+   - Proper error handling
+   - Consistent output format
+
+2. **Best Practices**
+   - Use `_print` for output
+   - Handle all required parameters
+   - Document functionality
+   - Return standardized results
+   - Keep tools focused and simple
+
+3. **Testing**
+   - Verify parameter validation
+   - Test error handling
+   - Check output format
+   - Ensure proper cleanup
+
+4. **Integration**
+   - Tools are auto-loaded on startup
+   - No manual registration needed
+   - Hot-reload supported
+   - Dependencies injected automatically
 
 ## ⚙️ Environment Setup
 

{jarvis_ai_assistant-0.1.17 → jarvis_ai_assistant-0.1.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.1.17"
+version = "0.1.18"
 description = "Jarvis: An AI assistant that uses tools to interact with the system"
 readme = "README.md"
 authors = [{ name = "Your Name", email = "your.email@example.com" }]

{jarvis_ai_assistant-0.1.17 → jarvis_ai_assistant-0.1.18}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.1.17",
+    version="0.1.18",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",

{jarvis_ai_assistant-0.1.17 → jarvis_ai_assistant-0.1.18}/src/jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.17" 
+__version__ = "0.1.18" 

{jarvis_ai_assistant-0.1.17 → jarvis_ai_assistant-0.1.18}/src/jarvis/main.py

@@ -121,7 +121,7 @@ def main():
         
         model = KimiModel(kimi_api_key)
 
-        tool_registry = ToolRegistry(model)
+        tool_registry = ToolRegistry()
         agent = Agent(model, tool_registry)
 
         # 欢迎信息

{jarvis_ai_assistant-0.1.17 → jarvis_ai_assistant-0.1.18}/src/jarvis/tools/__init__.py

@@ -1,10 +1,12 @@
 from .base import Tool, ToolRegistry
 from .file_ops import FileOperationTool
 from .shell import ShellTool
+from .generator import ToolGeneratorTool
 
 __all__ = [
     'Tool',
     'ToolRegistry',
     'FileOperationTool',
     'ShellTool',
+    'ToolGeneratorTool',
 ] 

jarvis_ai_assistant-0.1.18/src/jarvis/tools/base.py

@@ -0,0 +1,195 @@
+from typing import Dict, Any, List, Optional, Callable, Type
+import json
+import os
+import importlib.util
+from pathlib import Path
+import sys
+
+from jarvis.models.kimi import KimiModel
+
+from ..utils import PrettyOutput, OutputType
+from ..models import BaseModel
+
+class Tool:
+    def __init__(self, name: str, description: str, parameters: Dict, func: Callable):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.func = func
+
+    def to_dict(self) -> Dict:
+        """转换为工具格式"""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": json.dumps(self.parameters)
+        }
+
+    def execute(self, arguments: Dict) -> Dict[str, Any]:
+        """执行工具函数"""
+        return self.func(arguments)
+
+class ToolRegistry:
+    def __init__(self, output_handler=None):
+        """初始化工具注册器
+        
+        Args:
+            output_handler: 输出处理器 (可选)
+        """
+        self.tools: Dict[str, Tool] = {}
+        self.output_handler = output_handler or PrettyOutput
+        
+        # 加载内置工具和外部工具
+        self._load_builtin_tools()
+        self._load_external_tools()
+
+    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"]:
+                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():
+                self.output_handler.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:
+                self.output_handler.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(model=KimiModel(), register=self, output_handler=self.output_handler)
+                    
+                    # 注册工具
+                    self.register_tool(
+                        name=tool_instance.name,
+                        description=tool_instance.description,
+                        parameters=tool_instance.parameters,
+                        func=tool_instance.execute
+                    )
+                    self.output_handler.print(f"已加载工具: {tool_instance.name}", OutputType.INFO)
+                    tool_found = True
+                    
+            if not tool_found:
+                self.output_handler.print(f"文件中未找到有效的工具类: {file_path}", OutputType.WARNING)
+                return False
+                
+            return True
+            
+        except Exception as e:
+            self.output_handler.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:
+        """处理工具调用，只处理第一个工具"""
+        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

{jarvis_ai_assistant-0.1.17 → jarvis_ai_assistant-0.1.18}/src/jarvis/tools/file_ops.py

@@ -1,7 +1,17 @@
-from typing import Dict, Any
+from typing import Dict, Any, Protocol, Optional
 import os
 from pathlib import Path
-from ..utils import PrettyOutput, OutputType
+from enum import Enum
+
+class OutputType(Enum):
+    INFO = "info"
+    ERROR = "error"
+
+class OutputHandler(Protocol):
+    def print(self, text: str, output_type: OutputType) -> None: ...
+
+class ModelHandler(Protocol):
+    def chat(self, message: str) -> str: ...
 
 class FileOperationTool:
     name = "file_operation"
@@ -32,6 +42,14 @@ class FileOperationTool:
         "required": ["operation", "filepath"]
     }
 
+    def __init__(self, **kwargs):
+        self.output = kwargs.get('output_handler')
+
+    def _print(self, text: str, output_type: OutputType = OutputType.INFO):
+        """输出信息"""
+        if self.output:
+            self.output.print(text, output_type)
+
     def execute(self, args: Dict) -> Dict[str, Any]:
         """执行文件操作"""
         try:
@@ -41,7 +59,7 @@ class FileOperationTool:
             
             # 记录操作和完整路径
             abs_path = os.path.abspath(filepath)
-            PrettyOutput.print(f"文件操作: {operation} - {abs_path}", OutputType.INFO)
+            self._print(f"文件操作: {operation} - {abs_path}")
             
             if operation == "exists":
                 exists = os.path.exists(filepath)
@@ -100,6 +118,7 @@ class FileOperationTool:
                 }
                 
         except Exception as e:
+            self._print(str(e), OutputType.ERROR)
             return {
                 "success": False,
                 "error": f"文件操作失败: {str(e)}"