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

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.5" 
+__version__ = "0.1.6" 

jarvis/agent.py

@@ -2,7 +2,7 @@ import json
 import subprocess
 from typing import Dict, Any, List, Optional
 from .tools import ToolRegistry
-from .utils import Spinner, PrettyOutput, OutputType, get_multiline_input
+from .utils import PrettyOutput, OutputType, get_multiline_input
 from .models import BaseModel
 import re
 import os
@@ -14,28 +14,77 @@ class Agent:
         self.model = model
         self.tool_registry = tool_registry or ToolRegistry(model)
         self.name = name
-        # 编译正则表达式
-        self.tool_call_pattern = re.compile(r'<tool_call>\s*({[^}]+})\s*</tool_call>')
+
+        # 构建工具说明
+        tools_prompt = "Available Tools:\n"
+        for tool in self.tool_registry.get_all_tools():
+            tools_prompt += f"- Tool: {tool['function']['name']}\n"
+            tools_prompt += f"  Description: {tool['function']['description']}\n"
+            tools_prompt += f"  Arguments: {tool['function']['parameters']}\n"
+
         self.messages = [
             {
                 "role": "system",
-                "content": f"""You are {name}, a rigorous AI assistant that executes tasks step by step.
+                "content": f"""You are {name}, an AI assistant that follows the ReAct (Reasoning + Acting) framework to solve tasks step by step.
+
+FRAMEWORK:
+1. Thought: Analyze the current situation and plan the next step
+2. Action: Execute ONE specific tool call
+3. Observation: Review the result
+4. Next: Plan the next step or conclude
+
+FORMAT:
+Thought: I need to [reasoning about the current situation]...
+Action: I will use [tool] to [purpose]...
+<START_TOOL_CALL>
+name: tool_name
+arguments:
+    param1: value1
+<END_TOOL_CALL>
+
+After receiving result:
+Observation: The tool returned [analyze result]...
+Next: Based on this, I will [next step]...
+
+CORE RULES:
+1. ONE Action Per Response
+   - Only ONE tool call per response
+   - Additional tool calls will be ignored
+   - Complete current step before next
+
+2. Clear Reasoning
+   - Explain your thought process
+   - Justify tool selection
+   - Analyze results thoroughly
+
+Examples:
+✓ Good Response:
+Thought: I need to check the content of utils.py first to understand its structure.
+Action: I will read the file content.
+<START_TOOL_CALL>
+name: file_operation
+arguments:
+    operation: read
+    filepath: src/utils.py
+<END_TOOL_CALL>
 
-Key Principles:
-1. Execute ONE step at a time
-2. Wait for each step's result before planning the next
-3. Use tools to obtain all data, no fabrication
-4. Create sub-agents for independent subtasks
-5. Think carefully before each action
+✗ Bad Response:
+Thought: Let's analyze the code.
+Action: I'll read and check everything.
+[Multiple or vague tool calls...]
 
-""" + self.tool_registry.tool_help_text()
+Remember:
+- Always start with "Thought:"
+- Use exactly ONE tool per response
+- Wait for results before next step
+- Clearly explain your reasoning
+
+{tools_prompt}"""
             }
         ]
-        self.spinner = Spinner()
 
     def _call_model(self, messages: List[Dict], use_tools: bool = True) -> Dict:
         """调用模型获取响应"""
-        self.spinner.start()
         try:
             return self.model.chat(
                 messages=messages,
@@ -43,12 +92,14 @@ Key Principles:
             )
         except Exception as e:
             raise Exception(f"{self.name}: 模型调用失败: {str(e)}")
-        finally:
-            self.spinner.stop()
 
     def run(self, user_input: str) -> str:
         """处理用户输入并返回响应，返回任务总结报告"""
         self.clear_history()
+        
+        # 显示任务开始
+        PrettyOutput.section(f"开始新任务: {self.name}", OutputType.PLANNING)
+        
         self.messages.append({
             "role": "user",
             "content": user_input
@@ -56,9 +107,14 @@ Key Principles:
         
         while True:
             try:
+                # 显示思考状态
+                PrettyOutput.print("分析任务...", OutputType.PROGRESS)
                 response = self._call_model(self.messages)
                 current_response = response
 
+                # 流式输出已经在model中处理，这里添加换行
+                PrettyOutput.print_stream_end()
+
                 self.messages.append({
                     "role": "assistant",
                     "content": response["message"].get("content", ""),
@@ -67,10 +123,16 @@ Key Principles:
                 
                 if len(current_response["message"]["tool_calls"]) > 0:
                     if current_response["message"].get("content"):
-                        PrettyOutput.print(f"{self.name}: {current_response['message']['content']}", OutputType.SYSTEM)
+                        PrettyOutput.print(current_response["message"]["content"], OutputType.SYSTEM)
                         
-                    tool_result = self.tool_registry.handle_tool_calls(current_response["message"]["tool_calls"])
-                    PrettyOutput.print(f"{self.name} Tool Result: {tool_result}", OutputType.RESULT)
+                    try:
+                        # 显示工具调用
+                        PrettyOutput.print("执行工具调用...", OutputType.PROGRESS)
+                        tool_result = self.tool_registry.handle_tool_calls(current_response["message"]["tool_calls"])
+                        PrettyOutput.print(tool_result, OutputType.RESULT)
+                    except Exception as e:
+                        PrettyOutput.print(str(e), OutputType.ERROR)
+                        tool_result = f"Tool call failed: {str(e)}"
 
                     self.messages.append({
                         "role": "tool",
@@ -78,15 +140,12 @@ Key Principles:
                     })
                     continue
                 
-                final_content = current_response["message"].get("content", "")
-                if final_content:
-                    PrettyOutput.print(f"{self.name}: {final_content}", OutputType.SYSTEM)
-                
+                # 获取用户输入
                 user_input = get_multiline_input(f"{self.name}: 您可以继续输入，或输入空行结束当前任务")
                 if not user_input:
-                    PrettyOutput.print(f"{self.name}: 正在生成任务总结...", OutputType.INFO)
+                    PrettyOutput.print("生成任务总结...", OutputType.PROGRESS)
                     
-                    # 优化后的任务总结提示语
+                    # 生成任务总结
                     summary_prompt = {
                         "role": "user",
                         "content": """The task has been completed. Based on the previous analysis and execution results, provide a task summary including:
@@ -103,21 +162,25 @@ Key Principles:
 
 Focus only on facts and actual results. Be direct and concise."""
                     }
+                    
                     while True:
                         try:
                             summary_response = self._call_model(self.messages + [summary_prompt], use_tools=False)
                             summary = summary_response["message"].get("content", "")
                             
-                            PrettyOutput.print(f"==============={self.name} 任务总结===============", OutputType.INFO)
+                            # 显示任务总结
+                            PrettyOutput.section("任务总结", OutputType.SUCCESS)
                             PrettyOutput.print(summary, OutputType.SYSTEM)
-                            PrettyOutput.print("=" * (len(self.name) + 16), OutputType.INFO)
+                            PrettyOutput.section("任务完成", OutputType.SUCCESS)
                             
                             return summary
                             
                         except Exception as e:
-                            error_msg = f"{self.name}: 生成任务总结时出错: {str(e)}"
-                            PrettyOutput.print(error_msg, OutputType.ERROR)
-                        
+                            PrettyOutput.print(str(e), OutputType.ERROR)
+                
+                if user_input == "__interrupt__":
+                    PrettyOutput.print("任务已取消", OutputType.WARNING)
+                    return "Task cancelled by user"
                 
                 self.messages.append({
                     "role": "user",
@@ -125,8 +188,7 @@ Focus only on facts and actual results. Be direct and concise."""
                 })
                 
             except Exception as e:
-                error_msg = f"{self.name}: 处理响应时出错: {str(e)}"
-                PrettyOutput.print(error_msg, OutputType.ERROR)
+                PrettyOutput.print(str(e), OutputType.ERROR)
 
     def clear_history(self):
         """清除对话历史，只保留系统提示"""

jarvis/main.py

@@ -19,7 +19,7 @@ from jarvis.zte_llm import create_zte_llm
 # 定义支持的平台和模型
 SUPPORTED_PLATFORMS = {
     "ollama": {
-        "models": ["llama3.2", "qwen2.5:14b"],
+        "models": ["qwen2.5:14b", "qwq"],
         "default": "qwen2.5:14b"
     },
     "ddgs": {
@@ -88,13 +88,16 @@ def select_task(tasks: dict) -> str:
 
 def main():
     """Main entry point for Jarvis."""
+
+    load_env_from_file()
+
     parser = argparse.ArgumentParser(description="Jarvis AI Assistant")
     
     # 添加平台选择参数
     parser.add_argument(
         "--platform",
         choices=list(SUPPORTED_PLATFORMS.keys()),
-        default="ddgs",
+        default=os.getenv("JARVIS_PLATFORM") or "ddgs",
         help="选择运行平台 (默认: ollama)"
     )
     
@@ -107,13 +110,13 @@ def main():
     # 添加API基础URL参数
     parser.add_argument(
         "--api-base",
-        default="http://localhost:11434",
+        default=os.getenv("JARVIS_OLLAMA_API_BASE") or "http://localhost:11434",
         help="Ollama API基础URL (仅用于Ollama平台, 默认: http://localhost:11434)"
     )
     
     args = parser.parse_args()
 
-    load_env_from_file()
+    args.model = args.model or os.getenv("JARVIS_MODEL")
     
     # 验证并设置默认模型
     if args.model:
@@ -162,12 +165,9 @@ def main():
         while True:
             try:
                 user_input = get_multiline_input("请输入您的任务(输入空行退出):")
-                if not user_input:
+                if not user_input or user_input == "__interrupt__":
                     break
                 agent.run(user_input)
-            except KeyboardInterrupt:
-                print("\n正在退出...")
-                break
             except Exception as e:
                 PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
 

jarvis/models.py

@@ -1,10 +1,10 @@
-import json
 import re
 import time
 from typing import Dict, List, Optional
 from duckduckgo_search import DDGS
 import ollama
 from abc import ABC, abstractmethod
+import yaml
 
 from .utils import OutputType, PrettyOutput
 
@@ -18,32 +18,46 @@ class BaseModel(ABC):
 
     @staticmethod
     def extract_tool_calls(content: str) -> List[Dict]:
-        """从内容中提取工具调用"""
-        tool_calls = []
-        # 使用非贪婪匹配来获取标签之间的所有内容
-        pattern = re.compile(r'<tool_call>(.*?)</tool_call>', re.DOTALL)
+        """从内容中提取工具调用，只返回第一个有效的工具调用"""
+        # 分割内容为行
+        lines = content.split('\n')
+        tool_call_lines = []
+        in_tool_call = False
         
-        matches = pattern.finditer(content)
-        for match in matches:
-            try:
-                # 提取并解析 JSON
-                tool_call_text = match.group(1).strip()
-                tool_call_data = json.loads(tool_call_text)
+        # 逐行处理
+        for line in lines:
+            if not line:
+                continue
                 
-                # 验证必要的字段
-                if "name" in tool_call_data and "arguments" in tool_call_data:
-                    tool_calls.append({
-                        "function": {
-                            "name": tool_call_data["name"],
-                            "arguments": tool_call_data["arguments"]
-                        }
-                    })
-            except json.JSONDecodeError:
-                continue  # 跳过无效的 JSON
-            except Exception:
-                continue  # 跳过其他错误
-                
-        return tool_calls
+            if line == '<START_TOOL_CALL>':
+                tool_call_lines = []
+                in_tool_call = True
+                continue
+            elif line == '<END_TOOL_CALL>':
+                if in_tool_call and tool_call_lines:
+                    try:
+                        # 解析工具调用内容
+                        tool_call_text = '\n'.join(tool_call_lines)
+                        tool_call_data = yaml.safe_load(tool_call_text)
+                        
+                        # 验证必要的字段
+                        if "name" in tool_call_data and "arguments" in tool_call_data:
+                            # 只返回第一个有效的工具调用
+                            return [{
+                                "function": {
+                                    "name": tool_call_data["name"],
+                                    "arguments": tool_call_data["arguments"]
+                                }
+                            }]
+                    except yaml.YAMLError:
+                        pass  # 跳过无效的YAML
+                    except Exception:
+                        pass  # 跳过其他错误
+                in_tool_call = False
+            elif in_tool_call:
+                tool_call_lines.append(line)
+        
+        return []  # 如果没有找到有效的工具调用，返回空列表
 
 
 class DDGSModel(BaseModel):
@@ -57,11 +71,7 @@ class DDGSModel(BaseModel):
         self.model_name = model_name
 
     def __make_prompt(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> str:
-        prompt = "You are an AI Agent skilled in utilizing tools and planning tasks. Based on the task input by the user and the list of available tools, you output the tool invocation methods in a specified format. The user will provide feedback on the results of the tool execution, allowing you to continue analyzing and ultimately complete the user's designated task. Below is the list of tools and their usage methods. Let's use them step by step to accomplish the user's task.\n"
-        for tool in tools:
-            prompt += f"- Tool: {tool['function']['name']}\n"
-            prompt += f"  Description: {tool['function']['description']}\n"
-            prompt += f"  Arguments: {tool['function']['parameters']}\n"
+        prompt = ""
         for message in messages:
             prompt += f"[{message['role']}]: {message['content']}\n"
         return prompt
@@ -70,6 +80,7 @@ class DDGSModel(BaseModel):
         ddgs = DDGS()
         prompt = self.__make_prompt(messages, tools)
         content = ddgs.chat(prompt)
+        PrettyOutput.print_stream(content, OutputType.SYSTEM)
         tool_calls = BaseModel.extract_tool_calls(content)
         return {
             "message": {
@@ -90,16 +101,25 @@ class OllamaModel(BaseModel):
     def chat(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> Dict:
         """调用Ollama API获取响应"""
         try:
-            response = self.client.chat(
+            # 使用流式调用
+            stream = self.client.chat(
                 model=self.model_name,
                 messages=messages,
-                tools=tools
+                stream=True
             )
 
-            content = response.message.content
-            tool_calls = response.message.tool_calls or BaseModel.extract_tool_calls(content)
+            # 收集完整响应
+            content_parts = []
+            for chunk in stream:
+                if chunk.message.content:
+                    content_parts.append(chunk.message.content)
+                    # 实时打印内容
+                    PrettyOutput.print_stream(chunk.message.content, OutputType.SYSTEM)
+
+            # 合并完整内容
+            content = "".join(content_parts)
+            tool_calls = BaseModel.extract_tool_calls(content)
             
-            # 转换响应格式
             return {
                 "message": {
                     "content": content,

jarvis/tools/__init__.py

@@ -1,16 +1,16 @@
 from .base import Tool, ToolRegistry
-from .python_script import PythonScript
 from .file_ops import FileOperationTool
 from .search import SearchTool
 from .shell import ShellTool
 from .webpage import WebpageTool
+from .user_input import UserInputTool
 
 __all__ = [
     'Tool',
     'ToolRegistry',
-    'PythonScript',
     'FileOperationTool',
     'SearchTool',
     'ShellTool',
     'WebpageTool',
-] 
+    'UserInputTool',
+] 

jarvis/tools/base.py

@@ -35,17 +35,17 @@ 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
+        from .user_input import UserInputTool
 
         tools = [
             SearchTool(),
             ShellTool(),
-            PythonScriptTool(),
             FileOperationTool(),
             WebpageTool(),
+            UserInputTool(),
         ]
 
         for tool in tools:
@@ -84,115 +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. 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["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