jarvis-ai-assistant 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

jarvis/__init__.py

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

jarvis/agent.py

@@ -103,55 +103,32 @@ class Agent:
                 tools_prompt += f"  描述: {tool['description']}\n"
                 tools_prompt += f"  参数: {tool['parameters']}\n"
 
-            self.prompt = f"""你是 {self.name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
+            self.prompt = f"""你是 {self.name}，一个严格遵循 ReAct 框架的 AI 助手。
 
 {tools_prompt}
 
-关键规则：
-‼️ 禁止创建虚假对话
-‼️ 禁止假设用户回应
-‼️ 禁止在没有实际用户输入时继续
-‼️ 只回应用户实际说的内容
-‼️ 每个动作后停止并等待
+核心能力：
+1. 使用现有工具完成任务
+2. 通过 generate_tool 创建新工具扩展功能
+3. 遵循 ReAct (思考-行动-观察) 框架
 
-ReAct 框架：
+工作流程：
 1. 思考
-   - 分析当前情况
-   - 考虑可用工具
-   - 规划下一步行动
-   - 仅基于事实
-   - 不做用户回应的假设
-   - 不想象对话内容
-
-2. 行动（可选）
-   - 不是每次回应都需要调用工具
-   - 如果需要更多信息，直接询问用户
-   - 使用工具时：
-     - 只使用下面列出的工具
-     - 每次只执行一个工具
-     - 工具由用户手动执行
-     - 必须使用有效合法的YAML格式：
-     <START_TOOL_CALL>
-     name: tool_name
-     arguments:
-         param1: value1       # 所有参数必须正确缩进
-         param2: |           # 使用YAML块样式表示多行字符串
-             line1
-             line2
-     <END_TOOL_CALL>
-
+   - 分析需求和可用工具
+   - 评估是否需要新工具
+   - 规划解决方案
+
+2. 行动 (如果需要)
+   - 使用现有工具
+   - 创建新工具
+   - 询问更多信息
+   
 3. 观察
-   - 等待工具执行结果或用户回应
-   - 工具执行结果由用户提供
-   - 不要假设或想象回应
-   - 不要创建虚假对话
-   - 停止并等待实际输入
+   - 等待执行结果
+   - 分析反馈
+   - 规划下一步
 
-回应格式：
-思考：我分析当前情况[具体情况]... 基于[事实]，我需要[目标]...
-
-[如果需要使用工具：]
-行动：我将使用[工具]来[具体目的]...
+工具使用格式：
 <START_TOOL_CALL>
 name: tool_name
 arguments:
@@ -161,37 +138,28 @@ arguments:
         value
 <END_TOOL_CALL>
 
-[如果需要更多信息：]
-我需要了解更多关于[具体细节]的信息。请提供[需要的信息]。
+创建新工具示例：
+<START_TOOL_CALL>
+name: generate_tool
+arguments:
+    tool_name: custom_tool_name
+    class_name: CustomToolName
+    description: 详细的工具描述
+    parameters:
+        type: object
+        properties:
+            param1: 
+                type: string
+                description: 参数1的描述
+        required: [param1]
+<END_TOOL_CALL>
 
 严格规则：
-‼️ 只使用下面列出的工具
-‼️ 工具调用是可选的 - 需要时询问用户
-‼️ 每次只能调用一个工具
-‼️ 工具调用必须是有效的YAML格式
-‼️ 参数必须正确缩进
-‼️ 使用YAML块样式(|)表示多行值
-‼️ 工具由用户手动执行
-‼️ 等待用户提供工具执行结果
-‼️ 不要假设或想象用户回应
-‼️ 没有用户输入时不要继续对话
-‼️ 不要创建虚假对话
-‼️ 每个动作后停止
-‼️ 不要假设结果
-‼️ 不要假设行动
-
-注意事项：
-- 先思考再行动
-- 需要时询问用户
-- 只使用列出的工具
-- 一次一个工具
-- 严格遵循YAML格式
-- 等待用户回应
-- 工具结果来自用户
-- 不要假设回应
-- 不要虚构对话
-- 每个动作后停止
-- 只在有实际用户输入时继续
+1. 每次只能执行一个工具
+2. 等待用户提供执行结果
+3. 不要假设或想象结果
+4. 不要创建虚假对话
+5. 每个动作后停止等待
 
 任务:
 {user_input}

jarvis/main.py

@@ -6,6 +6,9 @@ import yaml
 import os
 import sys
 from pathlib import Path
+from prompt_toolkit import prompt
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.validation import Validator, ValidationError
 
 # 添加父目录到Python路径以支持导入
 sys.path.insert(0, str(Path(__file__).parent.parent))
@@ -55,6 +58,19 @@ def load_tasks() -> dict:
     
     return tasks
 
+class NumberValidator(Validator):
+    def validate(self, document):
+        text = document.text.strip()
+        if not text:  # Allow empty input
+            return
+            
+        try:
+            number = int(text)
+            if number < 0:
+                raise ValidationError(message='Please enter a non-negative number')
+        except ValueError:
+            raise ValidationError(message='Please enter a valid number')
+
 def select_task(tasks: dict) -> str:
     """Let user select a task from the list or skip. Returns task description if selected."""
     if not tasks:
@@ -68,9 +84,20 @@ def select_task(tasks: dict) -> str:
         PrettyOutput.print(f"[{i}] {name}", OutputType.INFO)
     PrettyOutput.print("[0] Skip predefined tasks", OutputType.INFO)
     
+    # Create completer with valid numbers
+    valid_numbers = [str(i) for i in range(len(task_names) + 1)]
+    number_completer = WordCompleter(valid_numbers)
+    
     while True:
         try:
-            choice = input("\nSelect a task number (0 to skip): ").strip()
+            choice = prompt(
+                "\nSelect a task number (0 to skip): ",
+                completer=number_completer,
+                validator=NumberValidator(),
+                validate_while_typing=False,
+                enable_history_search=True,
+            ).strip()
+            
             if not choice:
                 return ""
             
@@ -81,9 +108,12 @@ def select_task(tasks: dict) -> str:
                 selected_name = task_names[choice - 1]
                 return tasks[selected_name]  # Return the task description
             else:
-                PrettyOutput.print("Invalid choice. Please try again.", OutputType.ERROR)
-        except ValueError:
-            PrettyOutput.print("Please enter a valid number.", OutputType.ERROR)
+                PrettyOutput.print("Invalid choice. Please select a number from the list.", OutputType.ERROR)
+                
+        except KeyboardInterrupt:
+            return ""  # Return empty on Ctrl+C
+        except EOFError:
+            return ""  # Return empty on Ctrl+D
 
 def main():
     """Main entry point for Jarvis."""
@@ -121,7 +151,7 @@ def main():
         
         model = KimiModel(kimi_api_key)
 
-        tool_registry = ToolRegistry(model)
+        tool_registry = ToolRegistry()
         agent = Agent(model, tool_registry)
 
         # 欢迎信息

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/tools/base.py

@@ -1,5 +1,12 @@
-from typing import Dict, Any, List, Optional, Callable
+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
 
@@ -11,7 +18,7 @@ class Tool:
         self.func = func
 
     def to_dict(self) -> Dict:
-        """转换为Ollama工具格式"""
+        """转换为工具格式"""
         return {
             "name": self.name,
             "description": self.description,
@@ -23,28 +30,103 @@ class Tool:
         return self.func(arguments)
 
 class ToolRegistry:
-    def __init__(self, model: BaseModel):
+    def __init__(self, output_handler=None):
+        """初始化工具注册器
+        
+        Args:
+            output_handler: 输出处理器 (可选)
+        """
         self.tools: Dict[str, Tool] = {}
-        self.model = model
-        self._register_default_tools()
+        self.output_handler = output_handler or PrettyOutput
+        
+        # 加载内置工具和外部工具
+        self._load_builtin_tools()
+        self._load_external_tools()
 
-    def _register_default_tools(self):
-        """注册所有默认工具"""
-        from .shell import ShellTool
-        from .file_ops import FileOperationTool
+    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)
 
-        tools = [
-            ShellTool(),
-            FileOperationTool(),
-        ]
+    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)
 
-        for tool in tools:
-            self.register_tool(
-                name=tool.name,
-                description=tool.description,
-                parameters=tool.parameters,
-                func=tool.execute
-            )
+    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):
         """注册新工具"""

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)}"

jarvis/tools/generator.py

@@ -0,0 +1,227 @@
+from typing import Dict, Any, Protocol, Optional
+import os
+from pathlib import Path
+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 ToolGeneratorTool:
+    name = "generate_tool"
+    description = "生成新的工具代码并自动注册到ToolRegistry"
+    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, **kwargs):
+        """初始化工具生成器
+        
+        Args:
+            model: 模型处理器 (必需)
+            output_handler: 输出处理器 (可选)
+            register: 注册器 (必需)
+            tools_dir: 工具目录 (可选，默认为 ~/.jarvis_tools)
+        """
+        self.register = kwargs.get('register')
+        if not self.register:
+            raise Exception("Register is required for ToolGeneratorTool")
+        self.model = kwargs.get('model')
+        if not self.model:
+            raise Exception("Model is required for ToolGeneratorTool")
+        self.output = kwargs.get('output_handler')
+        
+        # 设置工具目录
+        tools_dir = kwargs.get('tools_dir')
+        if tools_dir:
+            self.tools_dir = Path(tools_dir)
+        else:
+            self.tools_dir = Path.home() / '.jarvis_tools'
+        
+        # 确保工具目录存在
+        self.tools_dir.mkdir(parents=True, exist_ok=True)
+
+    def _print(self, text: str, output_type: OutputType = OutputType.INFO):
+        """输出信息"""
+        if self.output:
+            self.output.print(text, output_type)
+
+    def _generate_tool_code(self, tool_name: str, class_name: str, description: str, parameters: Dict) -> str:
+        """使用大模型生成工具代码"""
+        if not self.model:
+            raise Exception("Model not initialized")
+
+        prompt = f"""请生成一个Python工具类的代码，要求如下：
+
+1. 类名: {class_name}
+2. 工具名称: {tool_name}
+3. 功能描述: {description}
+4. 参数定义: {parameters}
+
+严格按照以下格式生成代码(各函数的参数和返回值一定要与示例一致)：
+
+```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 ExampleTool:
+    name = "example_tool"
+    description = "示例工具"
+    parameters = {{
+        "type": "object",
+        "properties": {{
+            "param1": {{"type": "string"}}
+        }},
+        "required": ["param1"]
+    }}
+
+    def __init__(self, **kwargs):
+        '''初始化工具
+        Args:
+            model: 模型处理器  
+                与大模型交互: model.chat(prompt) 
+                使用完成后删除会话: model.delete_chat()
+            output_handler: 输出处理器 
+                输出信息: output_handler.print(text, output_type)
+            register: 注册器
+                注册工具: register.register_tool_by_file(tool_file)
+        '''
+        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):
+        if self.output:
+            self.output.print(text, output_type)
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        try:
+            # 验证参数
+            if "param1" not in args:
+                return {{"success": False, "error": "缺少必需参数: param1"}}
+            
+            # 记录操作
+            self._print(f"处理参数: {{args['param1']}}")
+            
+            # 实现具体功能
+            result = "处理结果"
+            
+            return {{
+                "success": True,
+                "stdout": result,
+                "stderr": ""
+            }}
+        except Exception as e:
+            self._print(str(e), OutputType.ERROR)
+            return {{
+                "success": False,
+                "error": str(e)
+            }}
+```"""
+
+        # 调用模型生成代码
+        response = self.model.chat(prompt)
+        self.model.delete_chat()
+
+        # 提取代码块
+        code_start = response.find("```python")
+        code_end = response.rfind("```")
+        
+        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"]
+
+            self._print(f"开始生成工具: {tool_name}")
+
+            # 生成工具代码
+            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 = self.register.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:
+            self._print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": f"生成工具失败: {str(e)}"
+            }

jarvis/tools/shell.py

@@ -1,9 +1,18 @@
-from typing import Dict, Any
+from typing import Dict, Any, Protocol, Optional
 import os
 import tempfile
-import shlex
 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 ShellTool:
     name = "execute_shell"
@@ -14,15 +23,22 @@ class ShellTool:
         "properties": {
             "command": {
                 "type": "string",
-                "description": "Shell command to execute (filter output when possible)"
+                "description": "Shell command to execute"
             }
         },
         "required": ["command"]
     }
 
+    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 _escape_command(self, cmd: str) -> str:
         """转义命令中的特殊字符"""
-        # 将命令中的单引号替换为'"'"'
         return cmd.replace("'", "'\"'\"'")
 
     def execute(self, args: Dict) -> Dict[str, Any]:
@@ -39,7 +55,7 @@ class ShellTool:
             # 修改命令以使用script
             tee_command = f"script -q -c '{escaped_command}' {output_file}"
             
-            PrettyOutput.print(f"执行命令: {command}", OutputType.INFO)
+            self._print(f"执行命令: {command}")
             
             # 执行命令
             return_code = os.system(tee_command)
@@ -70,6 +86,7 @@ class ShellTool:
             # 确保清理临时文件
             if 'output_file' in locals():
                 Path(output_file).unlink(missing_ok=True)
+            self._print(str(e), OutputType.ERROR)
             return {
                 "success": False,
                 "error": str(e)

{jarvis_ai_assistant-0.1.17.dist-info → jarvis_ai_assistant-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.17
+Version: 0.1.19
 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.dist-info → jarvis_ai_assistant-0.1.19.dist-info}/RECORD

@@ -1,10 +1,10 @@
-jarvis/__init__.py,sha256=xxLxgf6AkpQC_oecmvL8lRlgdfb5m-km2HjhnO8aW1U,50
-jarvis/agent.py,sha256=f8RIOFIiwRAuql4O32P_nDXByzBKbrNM-ergf_F8FfU,9409
-jarvis/main.py,sha256=Llbg-3oV5GkGxergaYbAByAunNol9cvBRitYURvjy4s,7051
+jarvis/__init__.py,sha256=ZS0T4CRb_B0dOsiPYPRNrunjMPVvZzmD9IIaUB29ig8,50
+jarvis/agent.py,sha256=r00CssF8HzSj4r2GXR9KNJ3XJk46HIjw4BEfzx-fKMQ,8114
+jarvis/main.py,sha256=tptQp6rjhHOSsPphmrtoxf7l78btnP_hJmr3hVMO4zg,8103
 jarvis/utils.py,sha256=YipQpEuIRwFE3y3YrgGlSVLEPDrlbBNY1gRiOJix9DU,6602
-jarvis/__pycache__/__init__.cpython-313.pyc,sha256=TpUmCVKoqlVLwQ1cPv_nR5XhD2vW505asH_ltcKmAko,209
-jarvis/__pycache__/agent.cpython-313.pyc,sha256=anFGVa4pfpsOCDbstPAPSsUmglCZUrRkuDN-jnvhSyI,12152
-jarvis/__pycache__/main.cpython-313.pyc,sha256=1Dc3AKvb_cgJnl-aZOkV1_dXxhrcZnxtczzo0uthRtY,9674
+jarvis/__pycache__/__init__.cpython-313.pyc,sha256=TnbFSQwCFYqlSRaAgJgfajYnPQVIUrqM9Pyj4QRQjDQ,209
+jarvis/__pycache__/agent.cpython-313.pyc,sha256=ItAH6Mb964vpqvziIsw-62avHUVu54mNgTa02VWK3lM,10855
+jarvis/__pycache__/main.cpython-313.pyc,sha256=uQ1QHMHR6EukOb7z-YOz8CicXRPEfiHyS7KRq15xxVw,10943
 jarvis/__pycache__/models.cpython-313.pyc,sha256=uWuRIjGrY4YDB3dGW5PGDLWaS03et8g11O725TjY_eU,5960
 jarvis/__pycache__/tools.cpython-313.pyc,sha256=lAD4LrnnWzNZQmHXGfZ_2l7oskOpr2_2OC-gdFhxQY8,33933
 jarvis/__pycache__/utils.cpython-313.pyc,sha256=Jpkf2GOA1d_fgrRftqZch1yiO0mB75LWHzQk8IfhHRU,8977
@@ -15,26 +15,30 @@ jarvis/models/kimi.py,sha256=CR3rU4wPSUQjmYOP516NXLU6h3YtcF6taB-4da3-rA4,10690
 jarvis/models/__pycache__/__init__.cpython-313.pyc,sha256=jAwySX4diR7EWM_alK75tiIb_J8bVfs4Bh_U3bdjDLo,534
 jarvis/models/__pycache__/base.cpython-313.pyc,sha256=4I9KZlXHvTB7vENA9YWK4Fx0sns_KvIOtWqzE9y_-Co,1094
 jarvis/models/__pycache__/kimi.cpython-313.pyc,sha256=-hOwhZrfvqfd5K_c34Tm-uR3gaZ9r6EV1NtwV0-FDmg,13647
-jarvis/tools/__init__.py,sha256=000SvX1Z0yzKtuVR9NS45r41DHUVpE6EiSEzzE99uR0,196
-jarvis/tools/base.py,sha256=qm73kMOkqAWHjUisUWFye-x69LJuZdwm0U3Tct-mmMc,3890
-jarvis/tools/file_ops.py,sha256=zTksx45NZm3iz9itN5iQGZ8DoxnSeTHdrnF08_ix7PU,3770
-jarvis/tools/shell.py,sha256=7q52lA3slf0TdjBjP1bkwugoO5pB0eqh6cYjAzAXNtI,2547
-jarvis/tools/__pycache__/__init__.cpython-313.pyc,sha256=6BQJ333a0Oh9uEDLlgh0HHeXS34I7NaPs9KFQI-sil8,347
-jarvis/tools/__pycache__/base.cpython-313.pyc,sha256=ZfkdDuQDiCuA7V3qx69coGwrkchLPqNDF6tCGPXKflU,6197
+jarvis/tools/__init__.py,sha256=AjmFYLXt-_ulZXdYiXya2fD7QCJ-RaK91PEZCNj-UbA,262
+jarvis/tools/base.py,sha256=ZHmRczYks7CuaYHU9uB5QnsD40G_jeqE6ubuhlaSFR8,7318
+jarvis/tools/file_ops.py,sha256=KbQLVCCXw-MtJg-12iyMeVGu8BTtLq7Mk7fpVKau40U,4296
+jarvis/tools/generator.py,sha256=VJXfZg0Xt3OZr1LtX8m-RJh9807VxZRah5xV7UtX6is,7406
+jarvis/tools/shell.py,sha256=MWe9-BAGApbGJfR60XG4nElGYHNBnbdF9vsOQTnEZ4g,2989
+jarvis/tools/__pycache__/__init__.cpython-313.pyc,sha256=KC48FS57427navbkxZ0eDKLePMCH2BKc5vAIu0b8lFc,404
+jarvis/tools/__pycache__/base.cpython-313.pyc,sha256=r-jPPg5L_Rok2c_VsMEAXkhuiiUjHv6bLCwVjnONDRo,9861
 jarvis/tools/__pycache__/bing_search.cpython-313.pyc,sha256=1G_wPbk5wcQYh7H0drLIS2Aw0XOG2ZM8ztgfQaqu3P8,2031
-jarvis/tools/__pycache__/file_ops.cpython-313.pyc,sha256=LbOp31JUzoRp5XVazy1VBqCQhpFg0qQYmVftFVY90V4,3628
+jarvis/tools/__pycache__/calculator.cpython-313.pyc,sha256=C_qwTDGm6gc7QNxtPzPZXyStdKEintJVQIt5NMHQ8oY,4205
+jarvis/tools/__pycache__/calculator_tool.cpython-313.pyc,sha256=PI4LZNDTPdSe3ffWDRovLZ-r-vF8Kl-n6xdGdFWiBpY,4296
+jarvis/tools/__pycache__/file_ops.cpython-313.pyc,sha256=OBR2EDQ2Ana7CTtLOoM5AYJzyVwP683LS7QrOR8_I3g,5208
+jarvis/tools/__pycache__/generator.cpython-313.pyc,sha256=3XTMBphRw7gqRqJXPuQrA4_6FirinFZ3khd7LiCy7uU,8746
 jarvis/tools/__pycache__/python_script.cpython-313.pyc,sha256=8JpryqTovEiTvBlWAK1KjZmPvHUuPc9GT9rTXBEQoJc,6693
 jarvis/tools/__pycache__/rag.cpython-313.pyc,sha256=JH6-PSZRMKAvTZqCwlRXJGClxYXNMs-vetU0q7hBLz0,6064
 jarvis/tools/__pycache__/search.cpython-313.pyc,sha256=wLMIkFwT-h4NGHgssytT4xme7sGO6ZhEnex7kjcy0-k,5990
-jarvis/tools/__pycache__/shell.cpython-313.pyc,sha256=QMaLUc1MtZXWod3msv_x7iMq2IybwMwz1OoaKsbm6U4,3271
+jarvis/tools/__pycache__/shell.cpython-313.pyc,sha256=6HWtxO-OWIxSraGkLs4K8hJrJ-UBVdi5KVuQUhyEUMA,4784
 jarvis/tools/__pycache__/sub_agent.cpython-313.pyc,sha256=9spmVX8KSQ4qIH7FbXo5tmmZfNx8KfIGtjy2lxTSp4Y,3144
 jarvis/tools/__pycache__/user_confirmation.cpython-313.pyc,sha256=wK3Ev10lHSUSRvoYmi7A0GzxYkzU-C4Wfhs5qW_HBqs,2271
 jarvis/tools/__pycache__/user_input.cpython-313.pyc,sha256=JjTFOhObKsKF4Pn8KBRuKfV1_Ssj083fjU7Mfc_5z7c,2531
 jarvis/tools/__pycache__/user_interaction.cpython-313.pyc,sha256=RuVZ-pmiPBDywY3efgXSfohMAciC1avMGPmBK5qlnew,3305
 jarvis/tools/__pycache__/webpage.cpython-313.pyc,sha256=BjzSfnNzsKCrLETCcWjt32lNDLzwnjqcVGg4JfWd9OM,3008
-jarvis_ai_assistant-0.1.17.dist-info/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.1.17.dist-info/METADATA,sha256=qrsMqKWDAyI_fvhoS18eKxn5TQ_28vIuzgIkb1-90yU,6525
-jarvis_ai_assistant-0.1.17.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jarvis_ai_assistant-0.1.17.dist-info/entry_points.txt,sha256=iKu7OMfew9dtfGhW71gIMTg4wvafuPqKb4wyQOnMAGU,44
-jarvis_ai_assistant-0.1.17.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.17.dist-info/RECORD,,
+jarvis_ai_assistant-0.1.19.dist-info/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.1.19.dist-info/METADATA,sha256=SPaJ0q7U024HA6W3sagtO6SlmDizohRfXhCBEuFMdrM,10193
+jarvis_ai_assistant-0.1.19.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jarvis_ai_assistant-0.1.19.dist-info/entry_points.txt,sha256=iKu7OMfew9dtfGhW71gIMTg4wvafuPqKb4wyQOnMAGU,44
+jarvis_ai_assistant-0.1.19.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.19.dist-info/RECORD,,