jarvis-ai-assistant 0.1.5__tar.gz → 0.1.6__tar.gz

{jarvis_ai_assistant-0.1.5/src/jarvis_ai_assistant.egg-info → jarvis_ai_assistant-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.5
+Version: 0.1.6
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire

{jarvis_ai_assistant-0.1.5 → jarvis_ai_assistant-0.1.6}/pyproject.toml

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

{jarvis_ai_assistant-0.1.5 → jarvis_ai_assistant-0.1.6}/setup.py

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

{jarvis_ai_assistant-0.1.5 → jarvis_ai_assistant-0.1.6}/src/jarvis/__init__.py

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

jarvis_ai_assistant-0.1.6/src/jarvis/agent.py

@@ -0,0 +1,195 @@
+import json
+import subprocess
+from typing import Dict, Any, List, Optional
+from .tools import ToolRegistry
+from .utils import PrettyOutput, OutputType, get_multiline_input
+from .models import BaseModel
+import re
+import os
+from datetime import datetime
+
+class Agent:
+    def __init__(self, model: BaseModel, tool_registry: ToolRegistry, name: str = "Jarvis"):
+        """Initialize Agent with a model, optional tool registry and name"""
+        self.model = model
+        self.tool_registry = tool_registry or ToolRegistry(model)
+        self.name = name
+
+        # 构建工具说明
+        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}, 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>
+
+✗ Bad Response:
+Thought: Let's analyze the code.
+Action: I'll read and check everything.
+[Multiple or vague tool calls...]
+
+Remember:
+- Always start with "Thought:"
+- Use exactly ONE tool per response
+- Wait for results before next step
+- Clearly explain your reasoning
+
+{tools_prompt}"""
+            }
+        ]
+
+    def _call_model(self, messages: List[Dict], use_tools: bool = True) -> Dict:
+        """调用模型获取响应"""
+        try:
+            return self.model.chat(
+                messages=messages,
+                tools=self.tool_registry.get_all_tools() if use_tools else []
+            )
+        except Exception as e:
+            raise Exception(f"{self.name}: 模型调用失败: {str(e)}")
+
+    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
+        })
+        
+        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", ""),
+                    "tool_calls": current_response["message"]["tool_calls"]
+                })
+                
+                if len(current_response["message"]["tool_calls"]) > 0:
+                    if current_response["message"].get("content"):
+                        PrettyOutput.print(current_response["message"]["content"], OutputType.SYSTEM)
+                        
+                    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",
+                        "content": tool_result
+                    })
+                    continue
+                
+                # 获取用户输入
+                user_input = get_multiline_input(f"{self.name}: 您可以继续输入，或输入空行结束当前任务")
+                if not user_input:
+                    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:
+
+1. Key Information:
+   - Essential findings from analysis
+   - Important results from tool executions
+   - Critical data discovered
+
+2. Task Results:
+   - Final outcome
+   - Actual achievements
+   - Concrete results
+
+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.section("任务总结", OutputType.SUCCESS)
+                            PrettyOutput.print(summary, OutputType.SYSTEM)
+                            PrettyOutput.section("任务完成", OutputType.SUCCESS)
+                            
+                            return summary
+                            
+                        except Exception as e:
+                            PrettyOutput.print(str(e), OutputType.ERROR)
+                
+                if user_input == "__interrupt__":
+                    PrettyOutput.print("任务已取消", OutputType.WARNING)
+                    return "Task cancelled by user"
+                
+                self.messages.append({
+                    "role": "user",
+                    "content": user_input
+                })
+                
+            except Exception as e:
+                PrettyOutput.print(str(e), OutputType.ERROR)
+
+    def clear_history(self):
+        """清除对话历史，只保留系统提示"""
+        self.messages = [self.messages[0]] 

{jarvis_ai_assistant-0.1.5 → jarvis_ai_assistant-0.1.6}/src/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_ai_assistant-0.1.6/src/jarvis/models.py

@@ -0,0 +1,130 @@
+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
+
+class BaseModel(ABC):
+    """大语言模型基类"""
+    
+    @abstractmethod
+    def chat(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> Dict:
+        """执行对话"""
+        pass
+
+    @staticmethod
+    def extract_tool_calls(content: str) -> List[Dict]:
+        """从内容中提取工具调用，只返回第一个有效的工具调用"""
+        # 分割内容为行
+        lines = content.split('\n')
+        tool_call_lines = []
+        in_tool_call = False
+        
+        # 逐行处理
+        for line in lines:
+            if not line:
+                continue
+                
+            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):
+    def __init__(self, model_name: str = "gpt-4o-mini"):
+        """
+        [1]: gpt-4o-mini
+        [2]: claude-3-haiku
+        [3]: llama-3.1-70b
+        [4]: mixtral-8x7b
+        """
+        self.model_name = model_name
+
+    def __make_prompt(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> str:
+        prompt = ""
+        for message in messages:
+            prompt += f"[{message['role']}]: {message['content']}\n"
+        return prompt
+
+    def chat(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> Dict:
+        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": {
+                "content": content,
+                "tool_calls": tool_calls
+            }
+        }
+
+
+class OllamaModel(BaseModel):
+    """Ollama模型实现"""
+    
+    def __init__(self, model_name: str = "qwen2.5:14b", api_base: str = "http://localhost:11434"):
+        self.model_name = model_name
+        self.api_base = api_base
+        self.client = ollama.Client(host=api_base)
+
+    def chat(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> Dict:
+        """调用Ollama API获取响应"""
+        try:
+            # 使用流式调用
+            stream = self.client.chat(
+                model=self.model_name,
+                messages=messages,
+                stream=True
+            )
+
+            # 收集完整响应
+            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,
+                    "tool_calls": tool_calls
+                }
+            }
+        except Exception as e:
+            raise Exception(f"Ollama API调用失败: {str(e)}") 

{jarvis_ai_assistant-0.1.5 → jarvis_ai_assistant-0.1.6}/src/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_ai_assistant-0.1.6/src/jarvis/tools/base.py

@@ -0,0 +1,130 @@
+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):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.func = func
+
+    def to_dict(self) -> Dict:
+        """转换为Ollama工具格式"""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters
+            }
+        }
+
+    def execute(self, arguments: Dict) -> Dict[str, Any]:
+        """执行工具函数"""
+        return self.func(arguments)
+
+class ToolRegistry:
+    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 .file_ops import FileOperationTool
+        from .webpage import WebpageTool
+        from .sub_agent import SubAgentTool
+        from .user_input import UserInputTool
+
+        tools = [
+            SearchTool(),
+            ShellTool(),
+            FileOperationTool(),
+            WebpageTool(),
+            UserInputTool(),
+        ]
+
+        for tool in tools:
+            self.register_tool(
+                name=tool.name,
+                description=tool.description,
+                parameters=tool.parameters,
+                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)
+
+    def get_tool(self, name: str) -> Optional[Tool]:
+        """获取工具"""
+        return self.tools.get(name)
+
+    def get_all_tools(self) -> List[Dict]:
+        """获取所有工具的Ollama格式定义"""
+        return [tool.to_dict() for tool in self.tools.values()]
+
+    def execute_tool(self, name: str, arguments: Dict) -> Dict[str, Any]:
+        """执行指定工具"""
+        tool = self.get_tool(name)
+        if tool is None:
+            return {"success": False, "error": f"Tool {name} does not exist"}
+        return tool.execute(arguments)
+
+    def handle_tool_calls(self, tool_calls: List[Dict]) -> str:
+        """处理工具调用，只处理第一个工具"""
+        if not tool_calls:
+            return ""
+            
+        # 只处理第一个工具调用
+        tool_call = tool_calls[0]
+        name = tool_call["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