jarvis-ai-assistant 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

jarvis/tools/__init__.py

@@ -1,5 +1,4 @@
 from .base import Tool, ToolRegistry
-from .python_script import PythonScript
 from .file_ops import FileOperationTool
 from .search import SearchTool
 from .shell import ShellTool
@@ -8,9 +7,8 @@ from .webpage import WebpageTool
 __all__ = [
     'Tool',
     'ToolRegistry',
-    'PythonScript',
     'FileOperationTool',
     'SearchTool',
     'ShellTool',
     'WebpageTool',
-] 
+] 

jarvis/tools/base.py

@@ -13,12 +13,9 @@ class Tool:
     def to_dict(self) -> Dict:
         """转换为Ollama工具格式"""
         return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": self.parameters
-            }
+            "name": self.name,
+            "description": self.description,
+            "parameters": json.dumps(self.parameters)
         }
 
     def execute(self, arguments: Dict) -> Dict[str, Any]:
@@ -35,17 +32,16 @@ class ToolRegistry:
         """注册所有默认工具"""
         from .search import SearchTool
         from .shell import ShellTool
-        from .python_script import PythonScriptTool
         from .file_ops import FileOperationTool
         from .webpage import WebpageTool
         from .sub_agent import SubAgentTool
 
         tools = [
-            SearchTool(),
+            SearchTool(self.model),
             ShellTool(),
-            PythonScriptTool(),
             FileOperationTool(),
             WebpageTool(),
+            SubAgentTool(self.model)
         ]
 
         for tool in tools:
@@ -56,14 +52,6 @@ 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)
@@ -84,115 +72,48 @@ 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. file_operation: Read/write files in workspace directory
-6. create_sub_agent: Create a sub-agent to handle subtasks (ONLY for independent subtasks)
-
-Core Rules:
-1. ONE Step at a Time
-   - Execute only one action per response
-   - Explain what you're going to do before doing it
-   - Wait for the result before planning next step
-   - No multiple actions or parallel execution
-
-2. Sub-Agent Usage (ONLY for Subtasks)
-   - Create sub-agents ONLY to handle independent subtasks
-   - Main task should be broken down into clear subtasks first
-   - Examples of good subtask delegation:
-     * Analyzing each Python file in a directory
-     * Processing each data file in a batch
-     * Researching different aspects of a topic
-     * Reviewing multiple code components
-   - Do NOT use for:
-     * Main task execution
-     * Single file operations
-     * Simple sequential steps
-     * Tasks requiring continuous context
-
-3. Output Guidelines
-   - Focus on essential information
-   - Clear step-by-step explanations
-   - Summarize results concisely
-
-Tool Call Format:
-<tool_call>
-{
-    "name": "tool_name",
-    "arguments": {
-        "param1": "value1"
-    }
-}
-</tool_call>
-
-Example (Correct - Subtask Delegation):
-Assistant: I'll create a sub-agent to handle the code analysis subtask.
-<tool_call>
-{
-    "name": "create_sub_agent",
-    "arguments": {
-        "name": "CodeAnalyzer",
-        "task": "Analyze the utils.py file structure and generate documentation",
-        "context": "This is part of the larger documentation task"
-    }
-}
-</tool_call>
-
-Example (Incorrect - Main Task):
-❌ Assistant: I'll create a sub-agent to handle the entire project analysis.
-<tool_call>
-{
-    "name": "create_sub_agent",
-    "arguments": {
-        "name": "ProjectAnalyzer",
-        "task": "Analyze and document the entire project"
-    }
-}
-</tool_call>
-
-Remember:
-1. ONE step at a time
-2. Create sub-agents ONLY for subtasks
-3. Explain before acting
-4. Wait for results"""
+        # 只处理第一个工具调用
+        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/tools/file_ops.py

@@ -5,7 +5,7 @@ from ..utils import PrettyOutput, OutputType
 
 class FileOperationTool:
     name = "file_operation"
-    description = "Execute file operations (read/write/append/exists)"
+    description = "文件操作 (read/write/append/exists)"
     parameters = {
         "type": "object",
         "properties": {

jarvis/tools/search.py

@@ -1,43 +1,106 @@
-from typing import Dict, Any
+from typing import Dict, Any, List
 from duckduckgo_search import DDGS
 from ..utils import PrettyOutput, OutputType
+from .webpage import WebpageTool
 
 class SearchTool:
     name = "search"
-    description = "Search for information using DuckDuckGo search engine"
+    description = "使用DuckDuckGo搜索引擎搜索信息，并根据问题提取关键信息"
     parameters = {
         "type": "object",
         "properties": {
             "query": {
                 "type": "string",
-                "description": "Search query string"
+                "description": "搜索关键词"
+            },
+            "question": {
+                "type": "string",
+                "description": "需要回答的具体问题，用于从搜索结果中提取相关信息"
             },
             "max_results": {
                 "type": "integer",
-                "description": "Maximum number of results to return",
-                "default": 5
+                "description": "最大搜索结果数量",
+                "default": 3
             }
         },
-        "required": ["query"]
+        "required": ["query", "question"]
     }
 
+    def __init__(self, model):
+        """初始化搜索工具，需要传入语言模型用于信息提取"""
+        self.model = model
+        self.webpage_tool = WebpageTool()
+
+    def _extract_info(self, contents: List[str], question: str) -> str:
+        """使用语言模型从网页内容中提取关键信息"""
+        prompt = {
+            "role": "user",
+            "content": f"""请根据以下搜索结果内容，回答问题：{question}
+
+搜索结果内容：
+{'-' * 40}
+{''.join(contents)}
+{'-' * 40}
+
+请提供一个简洁、准确的答案，重点关注与问题直接相关的信息。如果搜索结果中没有相关信息，请明确说明。
+回答时注意：
+1. 保持客观性，只基于搜索结果提供信息
+2. 如果不同来源有冲突，请指出差异
+3. 适当引用信息来源
+4. 如果信息不完整或不确定，请说明"""
+        }
+
+        try:
+            response = self.model.chat([prompt])
+            return response
+        except Exception as e:
+            return f"信息提取失败: {str(e)}"
+
     def execute(self, args: Dict) -> Dict[str, Any]:
-        """使用DuckDuckGo进行搜索"""
+        """执行搜索并提取信息"""
         try:
-            # 打印搜索查询
-            PrettyOutput.print(f"搜索查询: {args['query']}", OutputType.INFO)
+            query = args["query"]
+            question = args["question"]
+            max_results = args.get("max_results", 3)
+            
+            # 打印搜索信息
+            PrettyOutput.print(f"搜索查询: {query}", OutputType.INFO)
+            PrettyOutput.print(f"相关问题: {question}", OutputType.INFO)
             
             # 获取搜索结果
+            search_results = []
             with DDGS() as ddgs:
-                results = ddgs.text(
-                    keywords=args["query"],
-                    max_results=args.get("max_results", 5)
-                )
+                results = list(ddgs.text(
+                    keywords=query,
+                    max_results=max_results
+                ))
+            
+            # 收集网页内容
+            contents = []
+            for i, result in enumerate(results, 1):
+                try:
+                    PrettyOutput.print(f"正在读取第 {i}/{len(results)} 个结果... {result['title']} - {result['href']} - {result['body']}", OutputType.PROGRESS)
+                    webpage_result = self.webpage_tool.execute({"url": result["href"]})
+                    if webpage_result["success"]:
+                        contents.append(f"\n来源 {i}：{result['href']}\n")
+                        contents.append(webpage_result["stdout"])
+                except Exception as e:
+                    PrettyOutput.print(f"读取结果 {i} 失败: {str(e)}", OutputType.WARNING)
+                    continue
+            
+            if not contents:
+                return {
+                    "success": False,
+                    "error": "未能获取任何有效的搜索结果"
+                }
             
+            # 提取信息
+            PrettyOutput.print("正在分析搜索结果...", OutputType.PROGRESS)
+            analysis = self._extract_info(contents, question)
             
             return {
                 "success": True,
-                "stdout": results,
+                "stdout": f"搜索分析结果：\n\n{analysis}",
                 "stderr": ""
             }
 

jarvis/tools/shell.py

@@ -1,80 +1,75 @@
 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'
-    """
+    description = """执行shell命令并返回结果"""
+
     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

@@ -6,37 +6,26 @@ from .base import ToolRegistry
 
 class SubAgentTool:
     name = "create_sub_agent"
-    description = """Create a sub-agent to handle independent tasks.
-    
-Use this tool when:
-1. A subtask can be executed independently
-2. The task requires separate context management
-3. To optimize token usage of the main agent
-4. For parallel task processing
+    description = """创建一个子代理来处理独立任务。（重要：子代理启动时没有任何上下文！必须提供完整的步骤和上下文。）"""
 
-The sub-agent will:
-1. Inherit all tools from the parent agent
-2. Maintain its own conversation history
-3. Return a comprehensive task summary
-"""
     parameters = {
         "type": "object",
         "properties": {
             "name": {
                 "type": "string",
-                "description": "Name for the sub-agent (e.g., 'FileAnalyzer', 'CodeReviewer')"
+                "description": "子代理名称（例如：'文件分析器'）"
             },
             "task": {
                 "type": "string",
-                "description": "Task description with complete context"
+                "description": "需要明确步骤和目标的任务"
             },
             "context": {
                 "type": "string",
-                "description": "Additional context or background information",
+                "description": "必填：背景信息、执行步骤和预期结果",
                 "default": ""
             }
         },
-        "required": ["name", "task"]
+        "required": ["name", "task", "context"]
     }
 
     def __init__(self, model: BaseModel):
@@ -48,32 +37,47 @@ The sub-agent will:
         try:
             name = args["name"]
             task = args["task"]
-            context = args.get("context", "")
+            context = args.get("context")
 
-            PrettyOutput.print(f"Creating sub-agent '{name}'...", OutputType.INFO)
+            if not context:
+                return {
+                    "success": False,
+                    "error": "必须提供上下文信息，包括完整的背景和执行步骤。"
+                }
+
+            PrettyOutput.print(f"正在创建子代理 '{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)
+            sub_agent = Agent(self.model, tool_registry, name=name, is_sub_agent=True)
             
-            # Prepare the task with context if provided
-            full_task = f"{context}\n\nTask: {task}" if context else task
+            # Prepare the task with context
+            full_task = f"""背景和步骤：
+{context}
+
+主要任务：
+{task}
+
+要求：
+1. 严格按照提供的步骤执行
+2. 每完成一个步骤都要报告进度
+3. 突出显示任何问题或不明确的点
+4. 提供符合预期输出的详细结果"""
             
-            PrettyOutput.print(f"Sub-agent '{name}' executing task...", OutputType.INFO)
+            PrettyOutput.print(f"子代理 '{name}' 正在执行任务...", OutputType.INFO)
             
             # Execute the task and get the summary
             summary = sub_agent.run(full_task)
-            
             return {
                 "success": True,
-                "stdout": f"Sub-agent '{name}' completed the task.\n\nSummary:\n{summary}",
+                "stdout": f"子代理 '{name}' 已完成。\n\n结果：\n{summary}",
                 "stderr": ""
             }
 
         except Exception as e:
             return {
                 "success": False,
-                "error": f"Sub-agent execution failed: {str(e)}"
+                "error": f"子代理执行失败：{str(e)}"
             }