jarvis-ai-assistant 0.1.149__py3-none-any.whl → 0.1.150__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.149"
+__version__ = "0.1.150"

jarvis/jarvis_agent/jarvis.py

@@ -4,6 +4,7 @@ import sys
 
 from typing import Dict  # 仅保留实际使用的类型导入
 
+from jarvis.jarvis_utils.config import get_data_dir
 from prompt_toolkit import prompt
 import yaml
 from yaspin import yaspin
@@ -25,13 +26,14 @@ def _load_tasks() -> Dict[str, str]:
     """Load tasks from .jarvis files in user home and current directory."""
     tasks: Dict[str, str] = {}
 
-    # Check .jarvis/pre-command in user directory
-    user_jarvis = os.path.expanduser("~/.jarvis/pre-command")
-    if os.path.exists(user_jarvis):
-        spinner_text = f"从{user_jarvis}加载预定义任务..."
+    # Check pre-command in data directory
+    data_dir = get_data_dir()
+    pre_command_path = os.path.join(data_dir, "pre-command")
+    if os.path.exists(pre_command_path):
+        spinner_text = f"从{pre_command_path}加载预定义任务..."
         with yaspin(text=spinner_text, color="cyan") as spinner:
             try:
-                with open(user_jarvis, "r", encoding="utf-8", errors="ignore") as f:
+                with open(pre_command_path, "r", encoding="utf-8", errors="ignore") as f:
                     user_tasks = yaml.safe_load(f)
                 if isinstance(user_tasks, dict):
                     for name, desc in user_tasks.items():

jarvis/jarvis_lsp/registry.py

@@ -6,6 +6,7 @@ import sys
 from typing import Dict, Type, Optional, List
 from jarvis.jarvis_lsp.base import BaseLSP
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.config import get_data_dir
 
 REQUIRED_METHODS = [
     ('initialize', ['workspace_path']),
@@ -21,7 +22,7 @@ class LSPRegistry:
     @staticmethod
     def get_lsp_dir() -> str:
         """Get LSP implementation directory."""
-        user_lsp_dir = os.path.expanduser("~/.jarvis/lsp")
+        user_lsp_dir = os.path.join(get_data_dir(), "lsp")
         if not os.path.exists(user_lsp_dir):
             try:
                 os.makedirs(user_lsp_dir)

jarvis/jarvis_mcp/__init__.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+
+class McpClient(ABC):
+    """MCP客户端抽象基类"""
+    
+    @abstractmethod
+    def get_tool_list(self) -> List[Dict[str, Any]]:
+        """获取工具列表
+        
+        返回:
+            List[Dict[str, Any]]: 工具列表，每个工具包含以下字段：
+                - name: str - 工具名称
+                - description: str - 工具描述
+                - parameters: Dict - 工具参数
+        """
+        pass
+    
+    @abstractmethod
+    def execute(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """执行工具
+        
+        参数:
+            tool_name: 工具名称
+            arguments: 参数字典，包含工具执行所需的参数
+            
+        返回:
+            Dict[str, Any]: 执行结果，包含以下字段：
+                - success: bool - 是否执行成功
+                - stdout: str - 标准输出
+                - stderr: str - 标准错误
+        """
+        pass
+
+

jarvis/jarvis_mcp/local_mcp_client.py

@@ -0,0 +1,241 @@
+from typing import Any, Dict, List
+import subprocess
+import os
+import json
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from . import McpClient
+
+
+class LocalMcpClient(McpClient):
+    """本地MCP客户端实现
+    
+    参数:
+        config: 配置字典（command、args、env）
+    """
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.process = None
+        self.protocol_version = "2025-03-26"  # MCP协议版本
+        self._start_process()
+        self._initialize()
+
+    def _start_process(self) -> None:
+        """启动MCP进程"""
+        try:
+            # 构建命令和参数
+            command = self.config.get('command', '')
+            if not command:
+                raise ValueError('No command specified in config')
+
+            # 获取参数列表
+            args = self.config.get('args', [])
+            if not isinstance(args, list):
+                args = [str(args)]
+
+            # 获取环境变量
+            env = os.environ.copy()
+            env.update(self.config.get('env', {}))
+
+            # 启动进程
+            self.process = subprocess.Popen(
+                [command] + args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                text=True
+            )
+
+        except Exception as e:
+            PrettyOutput.print(f"启动MCP进程失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def _initialize(self) -> None:
+        """初始化MCP连接"""
+        try:
+            # 发送初始化请求
+            response = self._send_request('initialize', {
+                'processId': os.getpid(),
+                'clientInfo': {
+                    'name': 'jarvis',
+                    'version': '1.0.0'
+                },
+                'capabilities': {},
+                'protocolVersion': self.protocol_version
+            })
+
+            # 验证服务器响应
+            if 'result' not in response:
+                raise RuntimeError(f"初始化失败: {response.get('error', 'Unknown error')}")
+
+            result = response['result']
+            
+            # 发送initialized通知 - 使用正确的方法名格式
+            self._send_notification('notifications/initialized', {})
+
+        except Exception as e:
+            PrettyOutput.print(f"MCP初始化失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def _send_request(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """发送请求到MCP进程
+        
+        参数:
+            method: 请求方法
+            params: 请求参数
+            
+        返回:
+            Dict[str, Any]: 响应结果
+        """
+        if not self.process:
+            raise RuntimeError('MCP process not started')
+
+        try:
+            # 构建请求
+            request = {
+                'jsonrpc': '2.0',
+                'method': method,
+                'params': params,
+                'id': 1
+            }
+
+            # 发送请求
+            self.process.stdin.write(json.dumps(request) + '\n')  # type: ignore
+            self.process.stdin.flush()  # type: ignore
+
+            # 读取响应
+            response = self.process.stdout.readline()  # type: ignore
+            return json.loads(response)
+
+        except Exception as e:
+            PrettyOutput.print(f"发送请求失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def _send_notification(self, method: str, params: Dict[str, Any]) -> None:
+        """发送通知到MCP进程（不需要响应）
+        
+        参数:
+            method: 通知方法
+            params: 通知参数
+        """
+        if not self.process:
+            raise RuntimeError('MCP process not started')
+
+        try:
+            # 构建通知
+            notification = {
+                'jsonrpc': '2.0',
+                'method': method,
+                'params': params
+            }
+            # 发送通知
+            self.process.stdin.write(json.dumps(notification) + '\n')  # type: ignore
+            self.process.stdin.flush()  # type: ignore
+
+        except Exception as e:
+            PrettyOutput.print(f"发送通知失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def get_tool_list(self) -> List[Dict[str, Any]]:
+        """获取工具列表
+        
+        返回:
+            List[Dict[str, Any]]: 工具列表，每个工具包含以下字段：
+                - name: str - 工具名称
+                - description: str - 工具描述
+                - parameters: Dict - 工具参数
+        """
+        try:
+            response = self._send_request('tools/list', {})
+            if 'result' in response and 'tools' in response['result']:
+                # 注意这里: 响应结构是 response['result']['tools']
+                tools = response['result']['tools']
+                # 将MCP协议字段转换为内部格式
+                formatted_tools = []
+                for tool in tools:
+                    # 从inputSchema中提取参数定义
+                    input_schema = tool.get('inputSchema', {})
+                    parameters = {}
+                    if 'properties' in input_schema:
+                        parameters = input_schema['properties']
+                    
+                    formatted_tools.append({
+                        'name': tool.get('name', ''),
+                        'description': tool.get('description', ''),
+                        'parameters': parameters
+                    })
+                return formatted_tools
+            else:
+                error_msg = "获取工具列表失败"
+                if 'error' in response:
+                    error_msg += f": {response['error']}"
+                elif 'result' in response:
+                    error_msg += f": 响应格式不正确 - {response['result']}"
+                else:
+                    error_msg += ": 未知错误"
+                    
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                return []
+        except Exception as e:
+            PrettyOutput.print(f"获取工具列表失败: {str(e)}", OutputType.ERROR)
+            return []
+
+    def execute(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """执行工具
+        
+        参数:
+            tool_name: 工具名称
+            arguments: 参数字典，包含工具执行所需的参数
+            
+        返回:
+            Dict[str, Any]: 执行结果，包含以下字段：
+                - success: bool - 是否执行成功
+                - stdout: str - 标准输出
+                - stderr: str - 标准错误
+        """
+        try:
+            response = self._send_request('tools/call', {
+                'name': tool_name,
+                'arguments': arguments
+            })
+            if 'result' in response:
+                result = response['result']
+                # 从content中提取输出信息
+                stdout = ''
+                stderr = ''
+                for content in result.get('content', []):
+                    if content.get('type') == 'text':
+                        stdout += content.get('text', '')
+                    elif content.get('type') == 'error':
+                        stderr += content.get('text', '')
+                
+                return {
+                    'success': True,
+                    'stdout': stdout,
+                    'stderr': stderr
+                }
+            else:
+                return {
+                    'success': False,
+                    'stdout': '',
+                    'stderr': response.get('error', 'Unknown error')
+                }
+        except Exception as e:
+            PrettyOutput.print(f"执行工具失败: {str(e)}", OutputType.ERROR)
+            return {
+                'success': False,
+                'stdout': '',
+                'stderr': str(e)
+            }
+
+    def __del__(self):
+        """清理资源"""
+        if self.process:
+            try:
+                # 发送退出通知 - 使用通知而非请求
+                self._send_notification('notifications/exit', {})
+                # 等待进程结束
+                self.process.wait(timeout=1)
+            except:
+                # 如果进程没有正常退出，强制终止
+                self.process.kill()

jarvis/jarvis_mcp/remote_mcp_client.py

@@ -0,0 +1,230 @@
+from typing import Any, Dict, List
+import requests
+import sseclient
+from urllib.parse import urljoin
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from . import McpClient
+
+
+class RemoteMcpClient(McpClient):
+    """远程MCP客户端实现
+    
+    参数:
+        config: 配置字典，包含以下字段：
+            - base_url: str - MCP服务器的基础URL
+            - auth_token: str - 认证令牌（可选）
+            - headers: Dict[str, str] - 额外的HTTP头（可选）
+    """
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.base_url = config.get('base_url', '')
+        if not self.base_url:
+            raise ValueError('No base_url specified in config')
+        
+        # 设置HTTP客户端
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+        })
+        
+        # 添加认证令牌（如果提供）
+        auth_token = config.get('auth_token')
+        if auth_token:
+            self.session.headers['Authorization'] = f'Bearer {auth_token}'
+        
+        # 添加额外的HTTP头
+        extra_headers = config.get('headers', {})
+        self.session.headers.update(extra_headers)
+        
+        # 初始化SSE连接
+        self.sse_client = None
+        self._initialize()
+
+    def _initialize(self) -> None:
+        """初始化MCP连接"""
+        try:
+            # 发送初始化请求
+            response = self._send_request('initialize', {
+                'processId': None,  # 远程客户端不需要进程ID
+                'clientInfo': {
+                    'name': 'jarvis',
+                    'version': '1.0.0'
+                },
+                'capabilities': {},
+                'protocolVersion': "2025-03-26"
+            })
+
+            # 验证服务器响应
+            if 'result' not in response:
+                raise RuntimeError(f"初始化失败: {response.get('error', 'Unknown error')}")
+
+            result = response['result']
+            
+            # 发送initialized通知 - 使用正确的方法名格式
+            self._send_notification('notifications/initialized', {})
+
+            # 建立SSE连接
+            sse_url = urljoin(self.base_url, 'events')
+            response = self.session.get(sse_url, stream=True)
+            self.sse_client = sseclient.SSEClient(response)
+
+        except Exception as e:
+            PrettyOutput.print(f"MCP初始化失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def _send_request(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """发送请求到MCP服务器
+        
+        参数:
+            method: 请求方法
+            params: 请求参数
+            
+        返回:
+            Dict[str, Any]: 响应结果
+        """
+        try:
+            # 构建请求
+            request = {
+                'jsonrpc': '2.0',
+                'method': method,
+                'params': params,
+                'id': 1
+            }
+
+            # 发送请求
+            response = self.session.post(
+                urljoin(self.base_url, 'rpc'),
+                json=request
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except Exception as e:
+            PrettyOutput.print(f"发送请求失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def _send_notification(self, method: str, params: Dict[str, Any]) -> None:
+        """发送通知到MCP服务器（不需要响应）
+        
+        参数:
+            method: 通知方法
+            params: 通知参数
+        """
+        try:
+            # 构建通知
+            notification = {
+                'jsonrpc': '2.0',
+                'method': method,
+                'params': params
+            }
+
+            # 发送通知
+            response = self.session.post(
+                urljoin(self.base_url, 'rpc'),
+                json=notification
+            )
+            response.raise_for_status()
+
+        except Exception as e:
+            PrettyOutput.print(f"发送通知失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def get_tool_list(self) -> List[Dict[str, Any]]:
+        """获取工具列表
+        
+        返回:
+            List[Dict[str, Any]]: 工具列表，每个工具包含以下字段：
+                - name: str - 工具名称
+                - description: str - 工具描述
+                - parameters: Dict - 工具参数
+        """
+        try:
+            response = self._send_request('tools/list', {})
+            if 'result' in response and 'tools' in response['result']:
+                # 注意这里: 响应结构是 response['result']['tools']
+                tools = response['result']['tools']
+                # 将MCP协议字段转换为内部格式
+                formatted_tools = []
+                for tool in tools:
+                    # 从inputSchema中提取参数定义
+                    input_schema = tool.get('inputSchema', {})
+                    parameters = {}
+                    if 'properties' in input_schema:
+                        parameters = input_schema['properties']
+                    
+                    formatted_tools.append({
+                        'name': tool.get('name', ''),
+                        'description': tool.get('description', ''),
+                        'parameters': parameters
+                    })
+                return formatted_tools
+            else:
+                error_msg = "获取工具列表失败"
+                if 'error' in response:
+                    error_msg += f": {response['error']}"
+                elif 'result' in response:
+                    error_msg += f": 响应格式不正确 - {response['result']}"
+                else:
+                    error_msg += ": 未知错误"
+                    
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                return []
+        except Exception as e:
+            PrettyOutput.print(f"获取工具列表失败: {str(e)}", OutputType.ERROR)
+            return []
+
+    def execute(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """执行工具
+        
+        参数:
+            tool_name: 工具名称
+            arguments: 参数字典，包含工具执行所需的参数
+            
+        返回:
+            Dict[str, Any]: 执行结果，包含以下字段：
+                - success: bool - 是否执行成功
+                - stdout: str - 标准输出
+                - stderr: str - 标准错误
+        """
+        try:
+            response = self._send_request('tools/call', {
+                'name': tool_name,
+                'arguments': arguments
+            })
+            if 'result' in response:
+                result = response['result']
+                # 从content中提取输出信息
+                stdout = ''
+                stderr = ''
+                for content in result.get('content', []):
+                    if content.get('type') == 'text':
+                        stdout += content.get('text', '')
+                    elif content.get('type') == 'error':
+                        stderr += content.get('text', '')
+                
+                return {
+                    'success': True,
+                    'stdout': stdout,
+                    'stderr': stderr
+                }
+            else:
+                return {
+                    'success': False,
+                    'stdout': '',
+                    'stderr': response.get('error', 'Unknown error')
+                }
+        except Exception as e:
+            PrettyOutput.print(f"执行工具失败: {str(e)}", OutputType.ERROR)
+            return {
+                'success': False,
+                'stdout': '',
+                'stderr': str(e)
+            }
+
+    def __del__(self):
+        """清理资源"""
+        if self.sse_client and hasattr(self.sse_client, 'resp'):
+            self.sse_client.resp.close()
+        if self.session:
+            self.session.close()

jarvis/jarvis_platform/kimi.py

@@ -7,6 +7,7 @@ import time
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import while_success
+from jarvis.jarvis_utils.config import get_data_dir
 
 class KimiModel(BasePlatform):
     """Kimi model implementation"""
@@ -39,8 +40,8 @@ class KimiModel(BasePlatform):
                 "   • 在请求中找到 Authorization 头\n"
                 "   • 复制 token 值（去掉 'Bearer ' 前缀）\n"
                 "2. 设置环境变量:\n"
-                "   • 方法 1: 创建或编辑 ~/.jarvis/env 文件:\n"
-                "   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis/env\n"
+                "   • 方法 1: 创建或编辑配置文件:\n"
+                f"   echo 'KIMI_API_KEY=your_key_here' > {get_data_dir()}/env\n"
                 "   • 方法 2: 直接设置环境变量:\n"
                 "   export KIMI_API_KEY=your_key_here\n"
                 "设置后，重新运行 Jarvis。"

jarvis/jarvis_platform/registry.py

@@ -4,7 +4,7 @@ import os
 import sys
 from typing import Dict, Type, Optional, List
 from jarvis.jarvis_platform.base import BasePlatform
-from jarvis.jarvis_utils.config import get_normal_model_name, get_normal_platform_name, get_thinking_model_name, get_thinking_platform_name
+from jarvis.jarvis_utils.config import get_normal_model_name, get_normal_platform_name, get_thinking_model_name, get_thinking_platform_name, get_data_dir
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 REQUIRED_METHODS = [
@@ -26,15 +26,13 @@ class PlatformRegistry:
 
     @staticmethod
     def get_platform_dir() -> str:
-        user_platform_dir = os.path.expanduser("~/.jarvis/models")
+        user_platform_dir = os.path.join(get_data_dir(), "models")
         if not os.path.exists(user_platform_dir):
             try:
                 os.makedirs(user_platform_dir)
                 # 创建 __init__.py 使其成为 Python 包
                 with open(os.path.join(user_platform_dir, "__init__.py"), "w", errors="ignore") as f:
                     pass
-
-                pass
             except Exception as e:
                 PrettyOutput.print(f"创建平台目录失败: {str(e)}", OutputType.ERROR)
                 return ""

jarvis/jarvis_platform/yuanbao.py

@@ -6,7 +6,6 @@ import hmac
 import hashlib
 import time
 import urllib.parse
-from pathlib import Path
 from PIL import Image
 from yaspin import yaspin
 from yaspin.spinners import Spinners
@@ -14,6 +13,7 @@ from yaspin.api import Yaspin
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import while_success
+from jarvis.jarvis_utils.config import get_data_dir
 
 class YuanbaoPlatform(BasePlatform):
     """Hunyuan模型实现"""
@@ -46,9 +46,9 @@ class YuanbaoPlatform(BasePlatform):
                 "   • 发送任意消息\n"
                 "   • 在请求中找到 X-Uskey 和 T-UserID 头部值\n"
                 "2. 设置环境变量:\n"
-                "   • 方法 1: 创建或编辑 ~/.jarvis/env 文件:\n"
-                "   echo 'YUANBAO_COOKIES=your_cookies_here' >> ~/.jarvis/env\n"
-                "   echo 'YUANBAO_AGENT_ID=your_agent_id_here' >> ~/.jarvis/env\n"
+                "   • 方法 1: 创建或编辑配置文件:\n"
+                f"   echo 'YUANBAO_COOKIES=your_cookies_here' >> {get_data_dir()}/env\n"
+                f"   echo 'YUANBAO_AGENT_ID=your_agent_id_here' >> {get_data_dir()}/env\n"
                 "   • 方法 2: 直接设置环境变量:\n"
                 "   export YUANBAO_COOKIES=your_cookies_here\n"
                 "   export YUANBAO_AGENT_ID=your_agent_id_here\n"