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

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/base.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 import re
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 from jarvis.jarvis_utils.globals import clear_read_file_record
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import ct, ot, get_context_token_count, while_success, while_true

jarvis/jarvis_platform/kimi.py

@@ -7,7 +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 yaspin import yaspin
+from jarvis.jarvis_utils.config import get_data_dir
 
 class KimiModel(BasePlatform):
     """Kimi model implementation"""
@@ -40,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"

jarvis/jarvis_tools/code_plan.py

@@ -15,7 +15,6 @@ from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.git_utils import find_git_root
-from jarvis.jarvis_utils.utils import init_env
 
 class CodePlanTool:
     """用于代码修改规划和需求分析的工具

jarvis/jarvis_tools/file_analyzer.py

@@ -1,4 +1,4 @@
-from typing import Dict, Any, List
+from typing import Dict, Any
 import os
 
 from jarvis.jarvis_platform.registry import PlatformRegistry

jarvis/jarvis_tools/file_operation.py

@@ -8,15 +8,14 @@ from jarvis.jarvis_utils.globals import add_read_file_record
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 # 导入文件处理器
 from jarvis.jarvis_utils.file_processors import (
-    TextFileProcessor, PDFProcessor, DocxProcessor, 
-    PPTProcessor, ExcelProcessor
+    TextFileProcessor
 )
 
 
 
 class FileOperationTool:
     name = "file_operation"
-    description = "文件批量操作工具，可批量读写多个文件，支持文本、PDF、Word、Excel、PPT等格式，适用于需要同时处理多个文件的场景（读取配置文件、保存生成内容等）"
+    description = "文件批量操作工具，可批量读写多个文件，仅支持文本文件，适用于需要同时处理多个文件的场景（读取配置文件、保存生成内容等）"
     parameters = {
         "type": "object",
         "properties": {
@@ -44,10 +43,6 @@ class FileOperationTool:
     def _get_file_processor(self, file_path: str):
         """获取适合处理指定文件的处理器"""
         processors = [
-            PDFProcessor,    # PDF文件处理器
-            DocxProcessor,   # Word文档处理器
-            PPTProcessor,    # PowerPoint演示文稿处理器
-            ExcelProcessor,  # Excel表格处理器
             TextFileProcessor  # 文本文件处理器(放在最后作为兜底)
         ]
         
@@ -126,25 +121,11 @@ class FileOperationTool:
                                 "stderr": f"读取文本文件失败: {str(e)}"
                             }
                     else:
-                        # 使用专用处理器来提取非文本文件的内容
-                        try:
-                            spinner.text = f"使用 {processor.__name__} 提取 {abs_path} 的内容..."
-                            content = processor.extract_text(abs_path)
-                            # 获取文件类型友好名称
-                            file_type_names = {
-                                PDFProcessor: "PDF文档",
-                                DocxProcessor: "Word文档",
-                                PPTProcessor: "PowerPoint演示文稿",
-                                ExcelProcessor: "Excel表格"
-                            }
-                            file_type = file_type_names.get(processor, file_extension)
-                            file_info = f"\n文件: {abs_path} ({file_type})"
-                        except Exception as e:
-                            return {
-                                "success": False,
-                                "stdout": "",
-                                "stderr": f"提取 {file_extension} 文件内容失败: {str(e)}"
-                            }
+                        return {
+                            "success": False,
+                            "stdout": "",
+                            "stderr": f"不支持的文件类型: {file_extension}"
+                        }
                     
                     # 构建输出信息
                     output = f"{file_info}\n{content}" + "\n\n"

jarvis/jarvis_tools/methodology.py

@@ -3,6 +3,7 @@ import json
 import hashlib
 from typing import Dict, Any
 
+from jarvis.jarvis_utils.config import get_data_dir
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
@@ -35,7 +36,7 @@ class MethodologyTool:
 
     def __init__(self):
         """初始化经验管理工具"""
-        self.methodology_dir = os.path.expanduser("~/.jarvis/methodologies")
+        self.methodology_dir = os.path.join(get_data_dir(), "methodologies")
         self._ensure_dir_exists()
 
     def _ensure_dir_exists(self):

jarvis/jarvis_tools/read_code.py

@@ -1,7 +1,6 @@
 from typing import Dict, Any
 import os
 
-from pkg_resources import add_activation_listener
 from yaspin import yaspin
 
 from jarvis.jarvis_utils.globals import add_read_file_record

jarvis/jarvis_tools/registry.py

@@ -10,10 +10,12 @@ import yaml
 from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.base import Tool
-from jarvis.jarvis_utils.config import INPUT_WINDOW_REVERSE_SIZE, get_max_input_token_count
+from jarvis.jarvis_utils.config import INPUT_WINDOW_REVERSE_SIZE, get_max_input_token_count, get_data_dir
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import ct, ot, init_env
+from jarvis.jarvis_mcp.local_mcp_client import LocalMcpClient
+from jarvis.jarvis_mcp.remote_mcp_client import RemoteMcpClient
 
 
 
@@ -131,6 +133,7 @@ class ToolRegistry(OutputHandler):
         # 加载内置工具和外部工具
         self._load_builtin_tools()
         self._load_external_tools()
+        self._load_mcp_tools()
         self.max_input_token_count = get_max_input_token_count() - INPUT_WINDOW_REVERSE_SIZE
 
     def use_tools(self, name: List[str]) -> None:
@@ -152,6 +155,16 @@ class ToolRegistry(OutputHandler):
         """
         self.tools = {name: tool for name, tool in self.tools.items() if name not in names}
 
+    def _load_mcp_tools(self) -> None:
+        """从jarvis_data/tools/mcp加载工具"""
+        mcp_tools_dir = Path(get_data_dir()) / 'mcp'
+        if not mcp_tools_dir.exists():
+            return
+
+        # 遍历目录中的所有.yaml文件
+        for file_path in mcp_tools_dir.glob("*.yaml"):
+            self.register_mcp_tool_by_file(str(file_path))
+
     def _load_builtin_tools(self) -> None:
         """从内置工具目录加载工具"""
         tools_dir = Path(__file__).parent
@@ -165,8 +178,8 @@ class ToolRegistry(OutputHandler):
             self.register_tool_by_file(str(file_path))
 
     def _load_external_tools(self) -> None:
-        """从~/.jarvis/tools加载外部工具"""
-        external_tools_dir = Path.home() / '.jarvis/tools'
+        """从jarvis_data/tools加载外部工具"""
+        external_tools_dir = Path(get_data_dir()) / 'tools'
         if not external_tools_dir.exists():
             return
 
@@ -178,6 +191,98 @@ class ToolRegistry(OutputHandler):
 
             self.register_tool_by_file(str(file_path))
 
+    def register_mcp_tool_by_file(self, file_path: str) -> bool:
+        """从指定文件加载并注册工具
+        
+        参数:
+            file_path: 工具文件的路径
+
+        返回:
+            bool: 工具是否加载成功
+        """
+        try:
+            config = yaml.safe_load(open(file_path, 'r', encoding='utf-8'))
+            if 'type' not in config:
+                PrettyOutput.print(f"文件 {file_path} 缺少type字段", OutputType.WARNING)
+                return False
+            if config['type'] == 'local':
+                if 'command' not in config:
+                    PrettyOutput.print(f"文件 {file_path} 缺少command字段", OutputType.WARNING)
+                    return False
+                
+                # 创建本地MCP客户端
+                mcp_client = LocalMcpClient(config)
+                
+                # 获取工具信息
+                tools = mcp_client.get_tool_list()
+                if not tools:
+                    PrettyOutput.print(f"从 {file_path} 获取工具列表失败", OutputType.WARNING)
+                    return False
+                
+                # 注册每个工具
+                for tool in tools:
+                    def create_local_execute_func(tool_name: str, client: LocalMcpClient):
+                        def execute(arguments: Dict[str, Any]) -> Dict[str, Any]:
+                            args = arguments.copy()
+                            args.pop('agent', None)
+                            args.pop('want', None)
+                            ret = client.execute(tool_name, args)
+                            PrettyOutput.print(f"MCP {tool_name} 执行结果:\n{yaml.safe_dump(ret)}", OutputType.TOOL)
+                            return ret
+                        return execute
+                    
+                    # 注册工具
+                    self.register_tool(
+                        name=tool['name'],
+                        description=tool['description'],
+                        parameters=tool['parameters'],
+                        func=create_local_execute_func(tool['name'], mcp_client)
+                    )
+                
+                return True
+                
+            elif config['type'] == 'remote':
+                if 'base_url' not in config:
+                    PrettyOutput.print(f"文件 {file_path} 缺少base_url字段", OutputType.WARNING)
+                    return False
+                
+                # 创建远程MCP客户端
+                mcp_client = RemoteMcpClient(config)
+                
+                # 获取工具信息
+                tools = mcp_client.get_tool_list()
+                if not tools:
+                    PrettyOutput.print(f"从 {file_path} 获取工具列表失败", OutputType.WARNING)
+                    return False
+                
+                # 注册每个工具
+                for tool in tools:
+                    def create_remote_execute_func(tool_name: str, client: RemoteMcpClient):
+                        def execute(arguments: Dict[str, Any]) -> Dict[str, Any]:
+                            args = arguments.copy()
+                            args.pop('agent', None)
+                            args.pop('want', None)
+                            ret = client.execute(tool_name, args)
+                            PrettyOutput.print(f"MCP {tool_name} 执行结果:\n{yaml.safe_dump(ret)}", OutputType.TOOL)
+                            return ret
+                        return execute
+                    
+                    # 注册工具
+                    self.register_tool(
+                        name=tool['name'],
+                        description=tool['description'],
+                        parameters=tool['parameters'],
+                        func=create_remote_execute_func(tool['name'], mcp_client)
+                    )
+                
+                return True
+            else:
+                PrettyOutput.print(f"文件 {file_path} 类型错误: {config['type']}", OutputType.WARNING)
+                return False
+        except Exception as e:
+            PrettyOutput.print(f"文件 {file_path} 加载失败: {str(e)}", OutputType.WARNING)
+            return False
+        
     def register_tool_by_file(self, file_path: str) -> bool:
         """从指定文件加载并注册工具
 

jarvis/jarvis_tools/search_web.py

@@ -1,5 +1,4 @@
 import os
-import statistics
 from typing import Any, Dict
 from jarvis.jarvis_platform.registry import PlatformRegistry
 

jarvis/jarvis_utils/config.py

@@ -31,14 +31,6 @@ def get_max_input_token_count() -> int:
     """
     return int(os.getenv('JARVIS_MAX_INPUT_TOKEN_COUNT', '32000'))
 
-def get_thread_count() -> int:
-    """
-    获取用于并行处理的线程数。
-
-    返回：
-        int: 线程数，默认为1
-    """
-    return int(os.getenv('JARVIS_THREAD_COUNT', '1'))
 
 def is_auto_complete() -> bool:
     """
@@ -118,3 +110,17 @@ def get_max_tool_call_count() -> int:
         int: 最大连续工具调用次数，默认为20
     """
     return int(os.getenv('JARVIS_MAX_TOOL_CALL_COUNT', '20'))
+
+
+def get_data_dir() -> str:
+    """
+    获取Jarvis数据存储目录路径。
+    
+    返回:
+        str: 数据目录路径，优先从JARVIS_DATA_PATH环境变量获取，
+             如果未设置或为空，则使用~/.jarvis作为默认值
+    """
+    data_path = os.getenv('JARVIS_DATA_PATH', '').strip()
+    if not data_path:
+        return os.path.expanduser('~/.jarvis')
+    return data_path

jarvis/jarvis_utils/embedding.py

@@ -1,16 +1,12 @@
 import os
-import numpy as np
-import torch
-from sentence_transformers import SentenceTransformer
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-from typing import List, Any, Optional, Tuple
+from transformers import AutoTokenizer
+from typing import List
 import functools
 
-from yaspin.api import Yaspin
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+from jarvis.jarvis_utils.config import get_data_dir
 
 # 全局缓存，避免重复加载模型
-_global_models = {}
 _global_tokenizers = {}
 
 def get_context_token_count(text: str) -> int:
@@ -159,7 +155,7 @@ def load_tokenizer() -> AutoTokenizer:
         AutoTokenizer: 加载的分词器
     """
     model_name = "gpt2"
-    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
+    cache_dir = os.path.join(get_data_dir(), "huggingface", "hub")
 
     # 检查全局缓存
     if model_name in _global_tokenizers: