jarvis-ai-assistant 0.1.3__py3-none-any.whl → 0.1.6__py3-none-any.whl

jarvis/tools/base.py

@@ -1,6 +1,7 @@
 from typing import Dict, Any, List, Optional, Callable
 import json
 from ..utils import PrettyOutput, OutputType
+from ..models import BaseModel
 
 class Tool:
     def __init__(self, name: str, description: str, parameters: Dict, func: Callable):
@@ -25,30 +26,26 @@ class Tool:
         return self.func(arguments)
 
 class ToolRegistry:
-    def __init__(self):
+    def __init__(self, model: BaseModel):
         self.tools: Dict[str, Tool] = {}
+        self.model = model
         self._register_default_tools()
 
     def _register_default_tools(self):
         """注册所有默认工具"""
         from .search import SearchTool
         from .shell import ShellTool
-        from .user_interaction import UserInteractionTool
-        from .user_confirmation import UserConfirmationTool
-        from .python_script import PythonScriptTool
         from .file_ops import FileOperationTool
-        from .rag import RAGTool
         from .webpage import WebpageTool
+        from .sub_agent import SubAgentTool
+        from .user_input import UserInputTool
 
         tools = [
             SearchTool(),
             ShellTool(),
-            UserInteractionTool(),
-            UserConfirmationTool(),
-            PythonScriptTool(),
             FileOperationTool(),
-            RAGTool(),
             WebpageTool(),
+            UserInputTool(),
         ]
 
         for tool in tools:
@@ -59,6 +56,14 @@ class ToolRegistry:
                 func=tool.execute
             )
 
+        sub_agent_tool = SubAgentTool(self.model)
+        self.register_tool(
+            name=sub_agent_tool.name,
+            description=sub_agent_tool.description,
+            parameters=sub_agent_tool.parameters,
+            func=sub_agent_tool.execute
+        )
+
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
         """注册新工具"""
         self.tools[name] = Tool(name, description, parameters, func)
@@ -79,133 +84,47 @@ class ToolRegistry:
         return tool.execute(arguments)
 
     def handle_tool_calls(self, tool_calls: List[Dict]) -> str:
-        """处理工具调用"""
-        results = []
-        for tool_call in tool_calls:
-            name = tool_call["function"]["name"]
-            args = tool_call["function"]["arguments"]
-            if isinstance(args, str):
-                try:
-                    args = json.loads(args)
-                except json.JSONDecodeError:
-                    return f"Invalid JSON in arguments for tool {name}"
-
-            PrettyOutput.print(f"Calling tool: {name}", OutputType.INFO)
-            if isinstance(args, dict):
-                for key, value in args.items():
-                    PrettyOutput.print(f"  - {key}: {value}", OutputType.INFO)
-            else:
-                PrettyOutput.print(f"  Arguments: {args}", OutputType.INFO)
-            PrettyOutput.print("", OutputType.INFO)
+        """处理工具调用，只处理第一个工具"""
+        if not tool_calls:
+            return ""
             
-            result = self.execute_tool(name, args)
-            if result["success"]:
-                stdout = result["stdout"]
-                stderr = result.get("stderr", "")
-                output_parts = []
-                output_parts.append(f"Result:\n{stdout}")
-                if stderr:
-                    output_parts.append(f"Errors:\n{stderr}")
-                output = "\n\n".join(output_parts)
-            else:
-                error_msg = result["error"]
-                output = f"Execution failed: {error_msg}"
-                    
-            results.append(output)
-        return "\n".join(results)
-
-    def tool_help_text(self) -> str:
-        """返回所有工具的帮助文本"""
-        return """Available Tools:
-
-1. search: Search for information using DuckDuckGo
-2. read_webpage: Extract content from webpages
-3. execute_python: Run Python code with dependency management
-4. execute_shell: Execute shell commands
-5. ask_user: Get input from user with options support
-6. ask_user_confirmation: Get yes/no confirmation from user
-7. file_operation: Read/write files in workspace directory
-8. rag_query: Query documents using RAG
-
-Output Guidelines:
-1. Focus on Essential Information
-   - Filter out irrelevant or redundant information
-   - Only output the most relevant search results
-   - Summarize long content when possible
-
-2. Context Management
-   - Avoid repeating information that's already known
-   - Don't echo back the entire content of files
-   - Use snippets instead of full documents
-
-3. Error Handling
-   - Only show relevant parts of error messages
-   - Include troubleshooting steps when appropriate
-   - Omit stack traces unless specifically requested
-
-4. Search Results
-   - Focus on the most relevant 2-3 results
-   - Extract key information instead of full articles
-   - Skip duplicate or similar content
-
-5. RAG Queries
-   - Return only the most relevant passages
-   - Combine similar information
-   - Skip redundant context
-
-Tool Call Format Requirements:
-1. MUST use exact format:
-<tool_call>
-{
-    "name": "tool_name",
-    "arguments": {
-        "param1": "value1"
-    }
-}
-</tool_call>
-
-2. Format Rules:
-   - NO comments or explanations inside tool_call blocks
-   - NO additional text or formatting within JSON
-   - NO markdown or other markup inside tool_call
-   - ONLY valid JSON allowed in arguments
-   - ALL arguments must match tool parameters exactly
-
-3. Invalid Examples (DO NOT USE):
-   ❌ <tool_call>
-   {
-       "name": "search",  # Search tool
-       "arguments": {
-           "query": "Python GIL"  // Search query
-       }
-   }
-   </tool_call>
-
-   ❌ <tool_call>
-   ```json
-   {
-       "name": "search",
-       "arguments": {
-           "query": "Python GIL"
-       }
-   }
-   ```
-   </tool_call>
-
-4. Valid Example:
-   ✅ <tool_call>
-   {
-       "name": "search",
-       "arguments": {
-           "query": "Python GIL",
-           "max_results": 2
-       }
-   }
-   </tool_call>
-
-Remember:
-1. Quality over quantity
-2. Relevance over completeness
-3. Conciseness over verbosity
-4. Context efficiency is crucial
-5. STRICT adherence to tool call format"""
+        # 只处理第一个工具调用
+        tool_call = tool_calls[0]
+        name = tool_call["function"]["name"]
+        args = tool_call["function"]["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)
+            PrettyOutput.section("执行成功", OutputType.SUCCESS)
+        else:
+            error_msg = result["error"]
+            output = f"执行失败: {error_msg}"
+            PrettyOutput.section("执行失败", OutputType.ERROR)
+            
+        return output

jarvis/tools/shell.py

@@ -1,80 +1,94 @@
 from typing import Dict, Any
-import subprocess
+import os
+import tempfile
+import shlex
+from pathlib import Path
 from ..utils import PrettyOutput, OutputType
 
 class ShellTool:
     name = "execute_shell"
     description = """Execute shell commands and return the results.
-    Guidelines for output optimization:
-    1. Use grep/awk/sed to filter output when possible
-    2. Avoid listing all files/dirs unless specifically needed
-    3. Prefer -q/--quiet flags when status is all that's needed
-    4. Use head/tail to limit long outputs
-    5. Redirect stderr to /dev/null for noisy commands
-    
-    Examples of optimized commands:
-    - 'ls -l file.txt' instead of 'ls -l'
-    - 'grep -c pattern file' instead of 'grep pattern file'
-    - 'ps aux | grep process | head -n 5' instead of 'ps aux'
-    - 'command 2>/dev/null' to suppress error messages
-    - 'df -h . ' instead of 'df -h'
-    """
+
+Guidelines:
+1. Filter outputs
+   - Use grep/sed for specific data
+   - Use head/tail to limit lines
+   - Use -q for status checks
+
+Examples:
+✓ <START_TOOL_CALL>
+name: execute_shell
+arguments:
+    command: ls -l file.txt  # specific file
+<END_TOOL_CALL>
+
+✗ <START_TOOL_CALL>
+name: execute_shell
+arguments:
+    command: ps aux  # too much output
+<END_TOOL_CALL>"""
+
     parameters = {
         "type": "object",
         "properties": {
             "command": {
                 "type": "string",
-                "description": "Shell command to execute (use filters/limits for large outputs)"
-            },
-            "timeout": {
-                "type": "integer",
-                "description": "Command execution timeout in seconds",
-                "default": 30
+                "description": "Shell command to execute (filter output when possible)"
             }
         },
         "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"]
-            timeout = args.get("timeout", 30)
             
-            # 执行命令
-            result = subprocess.run(
-                command,
-                shell=True,
-                capture_output=True,
-                text=True,
-                timeout=timeout
-            )
+            # 生成临时文件名
+            output_file = os.path.join(tempfile.gettempdir(), f"jarvis_shell_{os.getpid()}.log")
             
-            # 构建输出
-            output = []
+            # 转义命令中的特殊字符
+            escaped_command = self._escape_command(command)
+            
+            # 修改命令以使用script
+            tee_command = f"script -q -c '{escaped_command}' {output_file}"
             
-            # 添加命令信息
             PrettyOutput.print(f"执行命令: {command}", OutputType.INFO)
-            output.append(f"命令: {command}")
-            output.append("")
             
-            # 添加输出
-            if result.stdout:
-                output.append(result.stdout)
+            # 执行命令
+            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": True,
-                "stdout": "\n".join(output),
-                "stderr": result.stderr,
-                "return_code": result.returncode
-            }
-        except subprocess.TimeoutExpired:
-            return {
-                "success": False,
-                "error": f"命令执行超时 (>{timeout}秒)"
+                "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)
             return {
                 "success": False,
                 "error": str(e)

jarvis/tools/sub_agent.py

@@ -0,0 +1,141 @@
+from typing import Dict, Any
+from ..agent import Agent
+from ..models import BaseModel
+from ..utils import PrettyOutput, OutputType
+from .base import ToolRegistry
+
+class SubAgentTool:
+    name = "create_sub_agent"
+    description = """Create a sub-agent to handle independent tasks.
+    
+IMPORTANT: Sub-agents start with NO context!
+Must provide complete steps and context.
+
+Required:
+1. Context
+   - Project background
+   - File locations
+   - Current standards
+   - Requirements
+
+2. Steps
+   - Clear actions
+   - Success criteria
+   - Expected output
+
+Example (Good):
+<START_TOOL_CALL>
+name: create_sub_agent
+arguments:
+    name: CodeAnalyzer
+    task: Analyze error handling
+    context: |
+        Project: Python 3.8+
+        File: src/utils.py
+        
+        Steps:
+        1. Read file content
+        2. Find error patterns
+        3. Check consistency
+        4. Verify logging
+        
+        Expected:
+        - Pattern list
+        - Issues found
+        - Suggestions
+        
+        Standards:
+        - Dict[str, Any] returns
+        - PrettyOutput logging
+<END_TOOL_CALL>
+
+Example (Bad):
+<START_TOOL_CALL>
+name: create_sub_agent
+arguments:
+    name: Analyzer
+    task: Check code
+    context: Look at utils.py
+<END_TOOL_CALL>
+
+Use for:
+✓ Clear, independent tasks
+✓ Well-defined goals
+✗ Vague tasks
+✗ Simple operations"""
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "Sub-agent name (e.g., 'FileAnalyzer')"
+            },
+            "task": {
+                "type": "string",
+                "description": "Task with clear steps and goals"
+            },
+            "context": {
+                "type": "string",
+                "description": "REQUIRED: Background, steps, and expected results",
+                "default": ""
+            }
+        },
+        "required": ["name", "task", "context"]
+    }
+
+    def __init__(self, model: BaseModel):
+        """Initialize with the same model as parent agent"""
+        self.model = model
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """Create and run a sub-agent for the specified task"""
+        try:
+            name = args["name"]
+            task = args["task"]
+            context = args.get("context")
+
+            if not context:
+                return {
+                    "success": False,
+                    "error": "Context is required. Please provide complete background and steps."
+                }
+
+            PrettyOutput.print(f"Creating sub-agent '{name}'...", OutputType.INFO)
+            
+            # Create a new tool registry for the sub-agent
+            tool_registry = ToolRegistry(self.model)
+            
+            # Create the sub-agent with the specified name
+            sub_agent = Agent(self.model, tool_registry, name=name)
+            
+            # Prepare the task with context
+            full_task = f"""Background and Steps:
+{context}
+
+Primary Task:
+{task}
+
+Requirements:
+1. Follow the provided steps exactly
+2. Report progress after each step
+3. Highlight any issues or unclear points
+4. Provide detailed results matching expected output"""
+            
+            PrettyOutput.print(f"Sub-agent '{name}' executing task...", OutputType.INFO)
+            
+         
+            # Execute the task and get the summary
+            summary = sub_agent.run(full_task)
+            return {
+                "success": True,
+                "stdout": f"Sub-agent '{name}' completed.\n\nResults:\n{summary}",
+                "stderr": ""
+            }
+
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Sub-agent failed: {str(e)}"
+            } 

jarvis/tools/user_input.py

@@ -0,0 +1,74 @@
+from typing import Dict, Any
+from ..utils import PrettyOutput, OutputType, get_multiline_input
+
+class UserInputTool:
+    name = "ask_user"
+    description = """Ask user for information or confirmation.
+
+Use this tool when you need:
+1. Additional information
+2. Confirmation before critical actions
+3. User preferences or choices"""
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "question": {
+                "type": "string",
+                "description": "Clear question for the user"
+            },
+            "options": {
+                "type": "string",
+                "description": "Optional: Numbered list of choices",
+                "default": ""
+            },
+            "context": {
+                "type": "string",
+                "description": "Optional: Additional context to help user understand",
+                "default": ""
+            }
+        },
+        "required": ["question"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """向用户询问信息并返回响应"""
+        try:
+            question = args["question"]
+            options = args.get("options", "")
+            context = args.get("context", "")
+
+            # 显示问题
+            PrettyOutput.section("用户确认", OutputType.USER)
+            
+            # 显示上下文（如果有）
+            if context:
+                PrettyOutput.print(f"背景: {context}", OutputType.INFO)
+            
+            # 显示问题
+            PrettyOutput.print(f"问题: {question}", OutputType.USER)
+            
+            # 显示选项（如果有）
+            if options:
+                PrettyOutput.print("\n选项:\n" + options, OutputType.INFO)
+
+            # 获取用户输入
+            response = get_multiline_input("请输入您的回答:")
+            
+            if response == "__interrupt__":
+                return {
+                    "success": False,
+                    "error": "User cancelled the input"
+                }
+
+            return {
+                "success": True,
+                "stdout": response,
+                "stderr": ""
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Failed to get user input: {str(e)}"
+            }