jarvis-ai-assistant 0.1.0__py3-none-any.whl

jarvis/.jarvis

@@ -0,0 +1 @@
+- 查看当前git仓库状态，如果有未提交的变更，自动根据当前仓库的文件修改内容总结生成一个git commit，然后执行git push推送到远端仓库，全流程不要询问用户

jarvis/__init__.py

@@ -0,0 +1,3 @@
+"""Jarvis AI Assistant"""
+
+__version__ = "0.1.0" 

jarvis/agent.py

@@ -0,0 +1,100 @@
+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 .models import BaseModel, OllamaModel
+import re
+import os
+from datetime import datetime
+
+class Agent:
+    def __init__(self, model: BaseModel, tool_registry: ToolRegistry):
+        self.model = model
+        self.tool_registry = tool_registry
+        # 编译正则表达式
+        self.tool_call_pattern = re.compile(r'<tool_call>\s*({[^}]+})\s*</tool_call>')
+        self.messages = [
+            {
+                "role": "system",
+                "content": """You are a rigorous AI assistant, all data must be obtained through tools, and no fabrication or speculation is allowed. """ + "\n" + self.tool_registry.tool_help_text()
+            }
+        ]
+        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,
+                tools=self.tool_registry.get_all_tools() if use_tools else None
+            )
+        except Exception as e:
+            raise Exception(f"模型调用失败: {str(e)}")
+        finally:
+            self.spinner.stop()
+
+
+    def run(self, user_input: str) :
+        """处理用户输入并返回响应"""
+        # 检查是否是结束命令
+        self.clear_history()
+        self.messages.append({
+            "role": "user",
+            "content": user_input
+        })
+        while True:
+            try:
+                # 获取初始响应
+                response = self._call_model(self.messages)
+                current_response = response
+
+                # 将工具执行结果添加到对话
+                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)
+                        
+                    # 使用 ToolRegistry 的 handle_tool_calls 方法处理工具调用
+                    tool_result = self.tool_registry.handle_tool_calls(current_response["message"]["tool_calls"])
+                    PrettyOutput.print(tool_result, OutputType.RESULT)
+
+                    self.messages.append({
+                        "role": "tool",
+                        "content": tool_result
+                    })
+                    continue
+                
+                # 添加最终响应到对话历史和输出
+                final_content = current_response["message"].get("content", "")
+                
+                if final_content:
+                    PrettyOutput.print(final_content, OutputType.SYSTEM)
+                    
+                
+                # 如果没有工具调用且响应很短，可能需要继续对话
+                user_input = get_multiline_input("您可以继续输入，或输入空行结束当前任务")
+                if  not user_input:
+                    PrettyOutput.print("===============任务结束===============", OutputType.INFO)
+                    break
+                
+                self.messages.append({
+                    "role": "user",
+                    "content": user_input
+                })
+                
+            except Exception as e:
+                error_msg = f"处理响应时出错: {str(e)}"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+
+    def clear_history(self):
+        """清除对话历史，只保留系统提示"""
+        self.messages = [self.messages[0]] 

jarvis/main.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""Command line interface for Jarvis."""
+
+import argparse
+import yaml
+import os
+import sys
+from pathlib import Path
+
+# 添加父目录到Python路径以支持导入
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from jarvis.agent import Agent
+from jarvis.tools import ToolRegistry
+from jarvis.models import DDGSModel, OllamaModel
+from jarvis.utils import PrettyOutput, OutputType, get_multiline_input
+
+# 定义支持的平台和模型
+SUPPORTED_PLATFORMS = {
+    "ollama": {
+        "models": ["llama3.2", "qwen2.5:14b"],
+        "default": "qwen2.5:14b"
+    },
+    "ddgs": {
+        "models": ["gpt-4o-mini", "claude-3-haiku", "llama-3.1-70b", "mixtral-8x7b"],
+        "default": "gpt-4o-mini"
+    }
+}
+
+def load_tasks() -> list:
+    """Load tasks from .jarvis file if it exists."""
+    if not os.path.exists(".jarvis"):
+        return []
+    
+    try:
+        with open(".jarvis", "r", encoding="utf-8") as f:
+            tasks = yaml.safe_load(f)
+            
+        if not isinstance(tasks, list):
+            PrettyOutput.print("Warning: .jarvis file should contain a list of tasks", OutputType.ERROR)
+            return []
+            
+        return [str(task) for task in tasks if task]  # Convert all tasks to strings and filter out empty ones
+    except Exception as e:
+        PrettyOutput.print(f"Error loading .jarvis file: {str(e)}", OutputType.ERROR)
+        return []
+
+def select_task(tasks: list) -> str:
+    """Let user select a task from the list or skip."""
+    if not tasks:
+        return ""
+    
+    PrettyOutput.print("\nFound predefined tasks:", OutputType.INFO)
+    for i, task in enumerate(tasks, 1):
+        PrettyOutput.print(f"[{i}] {task}", OutputType.INFO)
+    PrettyOutput.print("[0] Skip predefined tasks", OutputType.INFO)
+    
+    while True:
+        try:
+            choice = input("\nSelect a task number (0 to skip): ").strip()
+            if not choice:
+                return ""
+            
+            choice = int(choice)
+            if choice == 0:
+                return ""
+            elif 1 <= choice <= len(tasks):
+                return tasks[choice - 1]
+            else:
+                PrettyOutput.print("Invalid choice. Please try again.", OutputType.ERROR)
+        except ValueError:
+            PrettyOutput.print("Please enter a valid number.", OutputType.ERROR)
+
+def main():
+    """Main entry point for Jarvis."""
+    parser = argparse.ArgumentParser(description="Jarvis AI Assistant")
+    
+    # 添加平台选择参数
+    parser.add_argument(
+        "--platform",
+        choices=list(SUPPORTED_PLATFORMS.keys()),
+        default="ollama",
+        help="选择运行平台 (默认: ollama)"
+    )
+    
+    # 添加模型选择参数
+    parser.add_argument(
+        "--model",
+        help="选择模型 (默认: 根据平台自动选择)"
+    )
+    
+    # 添加API基础URL参数
+    parser.add_argument(
+        "--api-base",
+        default="http://localhost:11434",
+        help="Ollama API基础URL (仅用于Ollama平台, 默认: http://localhost:11434)"
+    )
+    
+    args = parser.parse_args()
+    
+    # 验证并设置默认模型
+    if args.model:
+        if args.model not in SUPPORTED_PLATFORMS[args.platform]["models"]:
+            supported_models = ", ".join(SUPPORTED_PLATFORMS[args.platform]["models"])
+            PrettyOutput.print(
+                f"错误: 平台 {args.platform} 不支持模型 {args.model}\n"
+                f"支持的模型: {supported_models}",
+                OutputType.ERROR
+            )
+            return 1
+    else:
+        args.model = SUPPORTED_PLATFORMS[args.platform]["default"]
+
+    try:
+        # 根据平台创建相应的模型实例
+        if args.platform == "ollama":
+            model = OllamaModel(
+                model_name=args.model,
+                api_base=args.api_base
+            )
+            platform_name = f"Ollama ({args.model})"
+        else:  # ddgs
+            model = DDGSModel(model_name=args.model)
+            platform_name = f"DuckDuckGo Search ({args.model})"
+
+        tool_registry = ToolRegistry()
+        agent = Agent(model, tool_registry)
+
+        # 欢迎信息
+        PrettyOutput.print(f"Jarvis 已初始化 - {platform_name}", OutputType.SYSTEM)
+        
+        # 加载预定义任务
+        tasks = load_tasks()
+        if tasks:
+            selected_task = select_task(tasks)
+            if selected_task:
+                PrettyOutput.print(f"\n执行任务: {selected_task}", OutputType.INFO)
+                agent.run(selected_task)
+                return 0
+        
+        # 如果没有选择预定义任务，进入交互模式
+        while True:
+            try:
+                user_input = get_multiline_input("请输入您的任务(输入空行退出):")
+                if not user_input:
+                    break
+                agent.run(user_input)
+            except KeyboardInterrupt:
+                print("\n正在退出...")
+                break
+            except Exception as e:
+                PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+
+    except Exception as e:
+        PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
+        return 1
+
+    return 0
+
+if __name__ == "__main__":
+    exit(main()) 

jarvis/models.py

@@ -0,0 +1,112 @@
+import json
+import re
+import time
+from typing import Dict, List, Optional
+from duckduckgo_search import DDGS
+import ollama
+from abc import ABC, abstractmethod
+
+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]:
+        """从内容中提取工具调用"""
+        tool_calls = []
+        # 修改正则表达式以更好地处理多行内容
+        pattern = re.compile(
+            r'<tool_call>\s*({(?:[^{}]|(?:{[^{}]*})|(?:{(?:[^{}]|{[^{}]*})*}))*})\s*</tool_call>',
+            re.DOTALL  # 添加DOTALL标志以匹配跨行内容
+        )
+        
+        matches = pattern.finditer(content)
+        for match in matches:
+            try:
+                tool_call_str = match.group(1).strip()
+                tool_call = json.loads(tool_call_str)
+                if isinstance(tool_call, dict) and "name" in tool_call and "arguments" in tool_call:
+                    tool_calls.append({
+                        "function": {
+                            "name": tool_call["name"],
+                            "arguments": tool_call["arguments"]
+                        }
+                    })
+                else:
+                    PrettyOutput.print(f"无效的工具调用格式: {tool_call_str}", OutputType.ERROR)
+            except json.JSONDecodeError as e:
+                PrettyOutput.print(f"JSON解析错误: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"解析内容: {tool_call_str}", OutputType.ERROR)
+                continue
+        
+        return tool_calls
+
+
+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 = "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"
+        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)
+        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:
+            response = self.client.chat(
+                model=self.model_name,
+                messages=messages,
+                tools=tools
+            )
+
+            content = response.message.content
+            tool_calls = response.message.tool_calls or 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/tools/__init__.py

@@ -0,0 +1,22 @@
+from .base import Tool, ToolRegistry
+from .python_script import PythonScript
+from .file_ops import FileOperationTool
+from .search import SearchTool
+from .shell import ShellTool
+from .user_interaction import UserInteractionTool
+from .user_confirmation import UserConfirmationTool
+from .rag import RAGTool
+from .webpage import WebpageTool
+
+__all__ = [
+    'Tool',
+    'ToolRegistry',
+    'PythonScript',
+    'FileOperationTool',
+    'SearchTool',
+    'ShellTool',
+    'UserInteractionTool',
+    'UserConfirmationTool',
+    'RAGTool',
+    'WebpageTool',
+] 

jarvis/tools/base.py

@@ -0,0 +1,155 @@
+from typing import Dict, Any, List, Optional, Callable
+import json
+from ..utils import PrettyOutput, OutputType
+
+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):
+        self.tools: Dict[str, Tool] = {}
+        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
+
+        tools = [
+            SearchTool(),
+            ShellTool(),
+            UserInteractionTool(),
+            UserConfirmationTool(),
+            PythonScriptTool(),
+            FileOperationTool(),
+            RAGTool(),
+            WebpageTool(),
+        ]
+
+        for tool in tools:
+            self.register_tool(
+                name=tool.name,
+                description=tool.description,
+                parameters=tool.parameters,
+                func=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:
+        """处理工具调用"""
+        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)
+            
+            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
+
+Guidelines:
+1. Always verify information through tools
+2. Use search + read_webpage for research
+3. Use Python/shell for data processing
+4. Ask user when information is missing
+
+Tool Call Format:
+<tool_call>
+{
+    "name": "tool_name",
+    "arguments": {
+        "param1": "value1"
+    }
+}
+</tool_call>
+
+Example:
+<tool_call>
+{
+    "name": "search",
+    "arguments": {
+        "query": "Python GIL",
+        "max_results": 3
+    }
+}
+</tool_call>"""