jarvis-ai-assistant 0.1.179__py3-none-any.whl → 0.1.180__py3-none-any.whl

jarvis/jarvis_utils/config.py

@@ -2,10 +2,30 @@
 import os
 from functools import lru_cache
 
+from typing import Any, Dict, List
+
+
 import yaml
 
+
 from jarvis.jarvis_utils.builtin_replace_map import BUILTIN_REPLACE_MAP
 
+
+# 全局环境变量存储
+
+GLOBAL_CONFIG_DATA: Dict[str, Any] = {}
+
+
+def set_global_env_data(env_data: Dict[str, Any]) -> None:
+    """设置全局环境变量数据"""
+    global GLOBAL_CONFIG_DATA
+    GLOBAL_CONFIG_DATA = env_data
+
+def set_config(key: str, value: Any) -> None:
+    """设置配置"""
+    GLOBAL_CONFIG_DATA[key] = value
+
+
 """配置管理模块。
 
 该模块提供了获取Jarvis系统各种配置设置的函数。
@@ -19,7 +39,7 @@ def get_git_commit_prompt() -> str:
     返回:
         str: Git提交信息生成提示模板，如果未配置则返回空字符串
     """
-    return os.getenv("JARVIS_GIT_COMMIT_PROMPT", "")
+    return GLOBAL_CONFIG_DATA.get("JARVIS_GIT_COMMIT_PROMPT", "")
 
 # 输出窗口预留大小
 INPUT_WINDOW_REVERSE_SIZE = 2048
@@ -29,16 +49,27 @@ def get_replace_map() -> dict:
     """
     获取替换映射表。
     
-    从数据目录下的replace_map.yaml文件中读取替换映射表，
+    优先使用GLOBAL_CONFIG_DATA['JARVIS_REPLACE_MAP']的配置，
+    如果没有则从数据目录下的replace_map.yaml文件中读取替换映射表，
     如果文件不存在则返回内置替换映射表。
     
     返回:
         dict: 合并后的替换映射表字典(内置+文件中的映射表)
     """
+    if 'JARVIS_REPLACE_MAP' in GLOBAL_CONFIG_DATA:
+        return {**BUILTIN_REPLACE_MAP, **GLOBAL_CONFIG_DATA['JARVIS_REPLACE_MAP']}
+        
     replace_map_path = os.path.join(get_data_dir(), 'replace_map.yaml')
     if not os.path.exists(replace_map_path):
         return BUILTIN_REPLACE_MAP.copy()
     
+    from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+    PrettyOutput.print(
+        "警告：使用replace_map.yaml进行配置的方式已被弃用，将在未来版本中移除。"
+        "请迁移到使用GLOBAL_CONFIG_DATA中的JARVIS_REPLACE_MAP配置。",
+        output_type=OutputType.WARNING
+    )
+    
     with open(replace_map_path, 'r', encoding='utf-8', errors='ignore') as file:
         file_map = yaml.safe_load(file) or {}
         return {**BUILTIN_REPLACE_MAP, **file_map}
@@ -50,7 +81,7 @@ def get_max_token_count() -> int:
     返回:
         int: 模型能处理的最大token数量。
     """
-    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '960000'))
+    return int(GLOBAL_CONFIG_DATA.get('JARVIS_MAX_TOKEN_COUNT', '960000'))
 
 def get_max_input_token_count() -> int:
     """
@@ -59,7 +90,7 @@ def get_max_input_token_count() -> int:
     返回:
         int: 模型能处理的最大输入token数量。
     """
-    return int(os.getenv('JARVIS_MAX_INPUT_TOKEN_COUNT', '32000'))
+    return int(GLOBAL_CONFIG_DATA.get('JARVIS_MAX_INPUT_TOKEN_COUNT', '32000'))
 
 
 def is_auto_complete() -> bool:
@@ -69,7 +100,7 @@ def is_auto_complete() -> bool:
     返回：
         bool: 如果启用了自动补全则返回True，默认为False
     """
-    return os.getenv('JARVIS_AUTO_COMPLETE', 'false') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_AUTO_COMPLETE', 'false') == 'true'
 
 
 def get_shell_name() -> str:
@@ -79,7 +110,7 @@ def get_shell_name() -> str:
     返回：
         str: Shell名称（例如bash, zsh），默认为bash
     """
-    shell_path = os.getenv('SHELL', '/bin/bash')
+    shell_path = GLOBAL_CONFIG_DATA.get('SHELL', '/bin/bash')
     return os.path.basename(shell_path)
 def get_normal_platform_name() -> str:
     """
@@ -88,7 +119,7 @@ def get_normal_platform_name() -> str:
     返回：
         str: 平台名称，默认为'yuanbao'
     """
-    return os.getenv('JARVIS_PLATFORM', 'yuanbao')
+    return GLOBAL_CONFIG_DATA.get('JARVIS_PLATFORM', 'yuanbao')
 def get_normal_model_name() -> str:
     """
     获取正常操作的模型名称。
@@ -96,7 +127,7 @@ def get_normal_model_name() -> str:
     返回：
         str: 模型名称，默认为'deep_seek'
     """
-    return os.getenv('JARVIS_MODEL', 'deep_seek_v3')
+    return GLOBAL_CONFIG_DATA.get('JARVIS_MODEL', 'deep_seek_v3')
 
 
 def get_thinking_platform_name() -> str:
@@ -106,7 +137,7 @@ def get_thinking_platform_name() -> str:
     返回：
         str: 平台名称，默认为'yuanbao'
     """
-    return os.getenv('JARVIS_THINKING_PLATFORM', os.getenv('JARVIS_PLATFORM', 'yuanbao'))
+    return GLOBAL_CONFIG_DATA.get('JARVIS_THINKING_PLATFORM', GLOBAL_CONFIG_DATA.get('JARVIS_PLATFORM', 'yuanbao'))
 def get_thinking_model_name() -> str:
     """
     获取思考操作的模型名称。
@@ -114,7 +145,7 @@ def get_thinking_model_name() -> str:
     返回：
         str: 模型名称，默认为'deep_seek'
     """
-    return os.getenv('JARVIS_THINKING_MODEL', os.getenv('JARVIS_MODEL', 'deep_seek'))
+    return GLOBAL_CONFIG_DATA.get('JARVIS_THINKING_MODEL', GLOBAL_CONFIG_DATA.get('JARVIS_MODEL', 'deep_seek'))
 
 def is_execute_tool_confirm() -> bool:
     """
@@ -123,7 +154,7 @@ def is_execute_tool_confirm() -> bool:
     返回：
         bool: 如果需要确认则返回True，默认为False
     """
-    return os.getenv('JARVIS_EXECUTE_TOOL_CONFIRM', 'false') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_EXECUTE_TOOL_CONFIRM', 'false') == 'true'
 def is_confirm_before_apply_patch() -> bool:
     """
     检查应用补丁前是否需要确认。
@@ -131,7 +162,7 @@ def is_confirm_before_apply_patch() -> bool:
     返回：
         bool: 如果需要确认则返回True，默认为False
     """
-    return os.getenv('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'true') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'true') == 'true'
 
 def get_max_tool_call_count() -> int:
     """
@@ -140,7 +171,7 @@ def get_max_tool_call_count() -> int:
     返回：
         int: 最大连续工具调用次数，默认为20
     """
-    return int(os.getenv('JARVIS_MAX_TOOL_CALL_COUNT', '20'))
+    return int(GLOBAL_CONFIG_DATA.get('JARVIS_MAX_TOOL_CALL_COUNT', '20'))
 
 
 def get_data_dir() -> str:
@@ -151,7 +182,7 @@ def get_data_dir() -> str:
         str: 数据目录路径，优先从JARVIS_DATA_PATH环境变量获取，
              如果未设置或为空，则使用~/.jarvis作为默认值
     """
-    data_path = os.getenv('JARVIS_DATA_PATH', '').strip()
+    data_path = GLOBAL_CONFIG_DATA.get('JARVIS_DATA_PATH', '').strip()
     if not data_path:
         return os.path.expanduser('~/.jarvis')
     return data_path
@@ -163,7 +194,7 @@ def get_auto_update() -> bool:
     返回：
         bool: 如果需要自动更新则返回True，默认为True
     """
-    return os.getenv('JARVIS_AUTO_UPDATE', 'true') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_AUTO_UPDATE', 'true') == 'true'
 
 def get_max_big_content_size() -> int:
     """
@@ -172,7 +203,7 @@ def get_max_big_content_size() -> int:
     返回：
         int: 最大大内容大小
     """
-    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '1024000'))
+    return int(GLOBAL_CONFIG_DATA.get('JARVIS_MAX_BIG_CONTENT_SIZE', '1024000'))
 
 def get_pretty_output() -> bool:
     """
@@ -181,7 +212,7 @@ def get_pretty_output() -> bool:
     返回：
         bool: 如果启用PrettyOutput则返回True，默认为True
     """
-    return os.getenv('JARVIS_PRETTY_OUTPUT', 'false') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_PRETTY_OUTPUT', 'false') == 'true'
 
 def is_use_methodology() -> bool:
     """
@@ -190,7 +221,7 @@ def is_use_methodology() -> bool:
     返回：
         bool: 如果启用方法论则返回True，默认为True
     """
-    return os.getenv('JARVIS_USE_METHODOLOGY', 'false') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_USE_METHODOLOGY', 'false') == 'true'
 
 def is_use_analysis() -> bool:
     """
@@ -199,7 +230,7 @@ def is_use_analysis() -> bool:
     返回：
         bool: 如果启用任务分析则返回True，默认为True
     """
-    return os.getenv('JARVIS_USE_ANALYSIS', 'false') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_USE_ANALYSIS', 'false') == 'true'
 
 def is_print_prompt() -> bool:
     """
@@ -208,4 +239,14 @@ def is_print_prompt() -> bool:
     返回：
         bool: 如果打印提示则返回True，默认为True
     """
-    return os.getenv('JARVIS_PRINT_PROMPT', 'false') == 'true'
+    return GLOBAL_CONFIG_DATA.get('JARVIS_PRINT_PROMPT', 'false') == 'true'
+
+
+def get_mcp_config() -> List[Dict[str, Any]]:
+    """
+    获取MCP配置列表。
+
+    返回:
+        List[Dict[str, Any]]: MCP配置项列表，如果未配置则返回空列表
+    """
+    return GLOBAL_CONFIG_DATA.get("JARVIS_MCP", [])

jarvis/jarvis_utils/git_utils.py

@@ -139,7 +139,7 @@ def get_diff() -> str:
 
 
 
-def revert_file(filepath: str):
+def revert_file(filepath: str) -> None:
     """增强版git恢复，处理新文件"""
     import subprocess
     try:
@@ -162,7 +162,7 @@ def revert_file(filepath: str):
 # 修改后的恢复函数
 
 
-def revert_change():
+def revert_change() -> None:
     """恢复所有未提交的修改到HEAD状态"""
     import subprocess
     try:
@@ -176,7 +176,7 @@ def revert_change():
             subprocess.run(['git', 'reset', '--hard', 'HEAD'], check=True)
         subprocess.run(['git', 'clean', '-fd'], check=True)
     except subprocess.CalledProcessError as e:
-        return f"恢复更改失败: {str(e)}"
+        PrettyOutput.print(f"恢复更改失败: {str(e)}", OutputType.ERROR)
 
 
 def handle_commit_workflow() -> bool:
@@ -192,15 +192,15 @@ def handle_commit_workflow() -> bool:
     import subprocess
     try:
         # 获取当前分支的提交总数
-        commit_count = subprocess.run(
+        commit_result = subprocess.run(
             ['git', 'rev-list', '--count', 'HEAD'],
             capture_output=True,
             text=True
         )
-        if commit_count.returncode != 0:
+        if commit_result.returncode != 0:
             return False
             
-        commit_count = int(commit_count.stdout.strip())
+        commit_count = int(commit_result.stdout.strip())
         
         # 暂存所有修改
         subprocess.run(['git', 'add', '.'], check=True)
@@ -313,15 +313,28 @@ def check_and_update_git_repo(repo_path: str) -> bool:
         if has_uncommitted_changes():
             return False
 
-        # 获取远程更新
-        subprocess.run(["git", "fetch"], cwd=git_root, check=True)
-        # 检查本地是否落后
-        result = subprocess.run(["git", "rev-list", "--count", "HEAD..origin/main"], 
-                              cwd=git_root, capture_output=True, text=True)
-        if result.returncode == 0 and int(result.stdout.strip()) > 0:
-            PrettyOutput.print("检测到新版本，正在更新Jarvis...", OutputType.INFO)
-            subprocess.run(["git", "pull"], cwd=git_root, check=True)
-            PrettyOutput.print("Jarvis已更新到最新版本", OutputType.SUCCESS)
+        # 获取远程tag更新
+        subprocess.run(["git", "fetch", "--tags"], cwd=git_root, check=True)
+        # 获取最新本地tag
+        local_tag_result = subprocess.run(["git", "describe", "--tags", "--abbrev=0"],
+                                cwd=git_root, capture_output=True, text=True)
+        # 获取最新远程tag
+        remote_tag_result = subprocess.run(
+            ["git", "ls-remote", "--tags", "--refs", "origin"],
+            cwd=git_root, capture_output=True, text=True
+        )
+        if remote_tag_result.returncode == 0:
+            # 提取最新的tag名称
+            tags = [ref.split("/")[-1] for ref in remote_tag_result.stdout.splitlines()]
+            tags = sorted(tags, key=lambda x: [int(i) if i.isdigit() else i for i in re.split(r'([0-9]+)', x)])
+            remote_tag = tags[-1] if tags else ""
+            remote_tag_result.stdout = remote_tag
+
+        if (local_tag_result.returncode == 0 and remote_tag_result.returncode == 0 and
+            local_tag_result.stdout.strip() != remote_tag_result.stdout.strip()):
+            PrettyOutput.print(f"检测到新版本tag {remote_tag_result.stdout.strip()}，正在更新Jarvis...", OutputType.INFO)
+            subprocess.run(["git", "checkout", remote_tag_result.stdout.strip()], cwd=git_root, check=True)
+            PrettyOutput.print(f"Jarvis已更新到tag {remote_tag_result.stdout.strip()}", OutputType.SUCCESS)
             return True
         return False
     except Exception as e:

jarvis/jarvis_utils/utils.py

@@ -3,19 +3,19 @@ import hashlib
 import os
 import tarfile
 import time
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict
 
 import yaml
 
 from jarvis import __version__
-from jarvis.jarvis_utils.config import get_data_dir, get_max_big_content_size
+from jarvis.jarvis_utils.config import get_data_dir, get_max_big_content_size, set_global_env_data
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.input import get_single_line_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
+
 def init_env(welcome_str: str) -> None:
     """初始化环境变量从jarvis_data/env文件
     功能：
@@ -43,15 +43,16 @@ def init_env(welcome_str: str) -> None:
         PrettyOutput.print_gradient_text(jarvis_ascii_art, (0, 120, 255), (0, 255, 200))
 
     jarvis_dir = Path(get_data_dir())
-    env_file = jarvis_dir / "env"
-
-    script_dir = Path(os.path.dirname(os.path.dirname(__file__)))
-    hf_archive = script_dir / "jarvis_data" / "huggingface.tar.gz"
+    config_file = jarvis_dir / "config.yaml"
 
     # 检查jarvis_data目录是否存在
     if not jarvis_dir.exists():
         jarvis_dir.mkdir(parents=True)
 
+    script_dir = Path(os.path.dirname(os.path.dirname(__file__)))
+    hf_archive = script_dir / "jarvis_data" / "huggingface.tar.gz"
+
+
     # 检查并解压huggingface模型
     hf_dir = jarvis_dir / "huggingface" / "hub"
     if not hf_dir.exists() and hf_archive.exists():
@@ -63,62 +64,91 @@ def init_env(welcome_str: str) -> None:
         except Exception as e:
             PrettyOutput.print(f"解压HuggingFace模型失败: {e}", OutputType.ERROR)
 
-    if env_file.exists():
-        try:
-            # 首先尝试作为YAML文件读取
-            try:
-                with open(env_file, "r", encoding="utf-8") as f:
-                    env_data = yaml.safe_load(f) or {}
-                    if isinstance(env_data, dict):
-                        os.environ.update({str(k): str(v) for k, v in env_data.items() if v is not None})
-                        return
-            except yaml.YAMLError:
-                pass
-            
-            # 如果不是YAML格式，按旧格式处理
-            current_key = None
-            current_value = []
-            env_data = {}
-            with open(env_file, "r", encoding="utf-8", errors="ignore") as f:
-                for line in f:
-                    line = line.rstrip()
-                    if not line or line.startswith(("#", ";")):
-                        continue
-                    if "=" in line and not line.startswith((" ", "\t")):
-                        # 处理之前收集的多行值
-                        if current_key is not None:
-                            env_data[current_key] = "\n".join(current_value).strip().strip("'").strip('"')
-                            current_value = []
-                        # 解析新的键值对
-                        key, value = line.split("=", 1)
-                        current_key = key.strip()
-                        current_value.append(value.strip())
-                    elif current_key is not None:
-                        # 多行值的后续行
-                        current_value.append(line.strip())
-            # 处理最后一个键值对
-            if current_key is not None:
-                env_data[current_key] = "\n".join(current_value).strip().strip("'").strip('"')
-            
-            # 更新环境变量
-            os.environ.update(env_data)
-            
-            # 如果是旧格式，转换为YAML并备份
-            backup_file = env_file.with_name(f"env.bak.{datetime.now().strftime('%Y%m%d%H%M%S')}")
-            env_file.rename(backup_file)
-            with open(env_file, "w", encoding="utf-8") as f:
-                yaml.dump(env_data, f, default_flow_style=False, allow_unicode=True)
-            
-            PrettyOutput.print(f"检测到旧格式配置文件，已自动转换为YAML格式并备份到 {backup_file}", OutputType.INFO)
-            
-        except Exception as e:
-            PrettyOutput.print(f"警告: 读取 {env_file} 失败: {e}", OutputType.WARNING)
+
+    if not config_file.exists():
+        old_config_file = jarvis_dir / "env"
+        if old_config_file.exists():# 旧的配置文件存在
+            _read_old_config_file(old_config_file)
+    else:
+        _read_config_file(jarvis_dir, config_file)        
 
         # 检查是否是git仓库并更新
     from jarvis.jarvis_utils.git_utils import check_and_update_git_repo
 
     check_and_update_git_repo(str(script_dir))
 
+def _read_config_file(jarvis_dir, config_file):
+    """读取并解析YAML格式的配置文件
+    
+    功能：
+    1. 读取配置文件内容
+    2. 检查并添加schema声明(如果缺失)
+    3. 将配置数据保存到全局变量
+    4. 设置环境变量(如果配置中有ENV字段)
+    
+    参数:
+        jarvis_dir: Jarvis数据目录路径
+        config_file: 配置文件路径
+    """
+    with open(config_file, "r", encoding="utf-8") as f:
+        content = f.read()
+        config_data = yaml.safe_load(content) or {}
+        if isinstance(config_data, dict):
+                # 检查是否已有schema声明，没有则添加
+            if "# yaml-language-server: $schema=" not in content:
+                schema_path = Path(os.path.relpath(
+                        Path(__file__).parent.parent / "jarvis_data" / "config_schema.json",
+                        start=jarvis_dir
+                    ))
+                with open(config_file, "w", encoding="utf-8") as f:
+                    f.write(f"# yaml-language-server: $schema={schema_path}\n")
+                    f.write(content)
+            # 保存到全局变量
+        set_global_env_data(config_data)
+            # 如果配置中有ENV键值对，则设置环境变量
+        if "ENV" in config_data and isinstance(config_data["ENV"], dict):
+            os.environ.update({str(k): str(v) for k, v in config_data["ENV"].items() if v is not None})
+
+def _read_old_config_file(config_file):
+    """读取并解析旧格式的env配置文件
+    
+    功能：
+    1. 解析键值对格式的旧配置文件
+    2. 支持多行值的处理
+    3. 自动去除值的引号和空格
+    4. 将配置数据保存到全局变量
+    5. 设置环境变量并显示迁移警告
+    
+    参数:
+        config_file: 旧格式配置文件路径
+    """
+    config_data = {}
+    current_key = None
+    current_value = []
+    with open(config_file, "r", encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            line = line.rstrip()
+            if not line or line.startswith(("#", ";")):
+                continue
+            if "=" in line and not line.startswith((" ", "\t")):
+                        # 处理之前收集的多行值
+                if current_key is not None:
+                    config_data[current_key] = "\n".join(current_value).strip().strip("'").strip('"')
+                    current_value = []
+                        # 解析新的键值对
+                key, value = line.split("=", 1)
+                current_key = key.strip()
+                current_value.append(value.strip())
+            elif current_key is not None:
+                        # 多行值的后续行
+                current_value.append(line.strip())
+                # 处理最后一个键值对
+        if current_key is not None:
+            config_data[current_key] = "\n".join(current_value).strip().strip("'").strip('"')
+        os.environ.update({str(k): str(v) for k, v in config_data.items() if v is not None})
+        set_global_env_data(config_data)
+    PrettyOutput.print(f"检测到旧格式配置文件，旧格式以后将不再支持，请尽快迁移到新格式", OutputType.WARNING)
+
     
 def while_success(func: Callable[[], Any], sleep_time: float = 0.1) -> Any:
     """循环执行函数直到成功
@@ -138,7 +168,19 @@ def while_success(func: Callable[[], Any], sleep_time: float = 0.1) -> Any:
             time.sleep(sleep_time)
             continue
 def while_true(func: Callable[[], bool], sleep_time: float = 0.1) -> Any:
-    """循环执行函数直到返回True"""
+    """循环执行函数直到返回True
+    
+    参数:
+        func: 要执行的函数，必须返回布尔值
+        sleep_time: 每次失败后的等待时间(秒)
+        
+    返回:
+        函数最终返回的True值
+        
+    注意:
+        与while_success不同，此函数只检查返回是否为True，
+        不捕获异常，异常会直接抛出
+    """
     while True:
         ret = func()
         if ret:
@@ -206,7 +248,7 @@ def _update_cmd_stats(cmd_name: str) -> None:
     stats_file = Path(get_data_dir()) / "cmd_stat.yaml"
     try:
         with open(stats_file, "w", encoding="utf-8") as f:
-            yaml.safe_dump(stats, f)
+            yaml.safe_dump(stats, f, allow_unicode=True)
     except Exception as e:
         PrettyOutput.print(
             f"保存命令调用统计失败: {str(e)}", OutputType.WARNING
@@ -215,9 +257,7 @@ def _update_cmd_stats(cmd_name: str) -> None:
 def count_cmd_usage() -> None:
     """统计当前命令的使用次数"""
     import sys
-    if len(sys.argv) > 1:
-        cmd_name = sys.argv[1]
-        _update_cmd_stats(cmd_name)
+    _update_cmd_stats(sys.argv[0])
 
 def is_context_overflow(content: str) -> bool:
     """判断文件内容是否超出上下文限制"""