jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_utils/utils.py

@@ -6,6 +6,9 @@ import signal
 import subprocess
 import sys
 import time
+import atexit
+import errno
+import threading
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple
 from datetime import datetime, date
@@ -23,7 +26,6 @@ from jarvis.jarvis_utils.config import (
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import get_in_chat, get_interrupt, set_interrupt
 from jarvis.jarvis_utils.input import user_confirm
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 # 向后兼容：导出 get_yes_no 供外部模块引用
 get_yes_no = user_confirm
@@ -59,6 +61,10 @@ COMMAND_MAPPING = {
     "jst": "jarvis-stats",
     # 记忆整理
     "jmo": "jarvis-memory-organizer",
+    # 安全分析
+    "jsec": "jarvis-sec",
+    # C2Rust迁移
+    "jc2r": "jarvis-c2rust",
 }
 
 # RAG 依赖检测工具函数（更精确）
@@ -205,6 +211,117 @@ def _setup_signal_handler() -> None:
     signal.signal(signal.SIGINT, sigint_handler)
 
 
+# ----------------------------
+# 单实例文件锁（放置于初始化早期使用）
+# ----------------------------
+_INSTANCE_LOCK_PATH: Optional[Path] = None
+
+
+def _get_instance_lock_path(lock_name: str = "instance.lock") -> Path:
+    try:
+        data_dir = Path(str(get_data_dir()))
+    except Exception:
+        data_dir = Path(os.path.expanduser("~/.jarvis"))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir / lock_name
+
+
+def _read_lock_owner_pid(lock_path: Path) -> Optional[int]:
+    try:
+        txt = lock_path.read_text(encoding="utf-8", errors="ignore").strip()
+        if not txt:
+            return None
+        try:
+            info = json.loads(txt)
+            pid = info.get("pid")
+            return int(pid) if pid is not None else None
+        except Exception:
+            # 兼容纯数字PID
+            return int(txt)
+    except Exception:
+        return None
+
+
+def _is_process_alive(pid: int) -> bool:
+    if pid is None or pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        # 无权限但进程存在
+        return True
+    except OSError as e:
+        # 某些平台上，EPERM 表示进程存在但无权限
+        if getattr(e, "errno", None) == errno.EPERM:
+            return True
+        return False
+    else:
+        return True
+
+
+def _release_instance_lock() -> None:
+    global _INSTANCE_LOCK_PATH
+    try:
+        if _INSTANCE_LOCK_PATH and _INSTANCE_LOCK_PATH.exists():
+            _INSTANCE_LOCK_PATH.unlink()
+    except Exception:
+        # 清理失败不影响退出
+        pass
+    _INSTANCE_LOCK_PATH = None
+
+
+def _acquire_single_instance_lock(lock_name: str = "instance.lock") -> None:
+    """
+    在数据目录(~/.jarvis 或配置的数据目录)下创建实例锁，防止重复启动。
+    如果检测到已有存活实例，提示后退出。
+    """
+    global _INSTANCE_LOCK_PATH
+    lock_path = _get_instance_lock_path(lock_name)
+
+    # 已存在锁：检查是否为有效存活实例
+    if lock_path.exists():
+        pid = _read_lock_owner_pid(lock_path)
+        if pid and _is_process_alive(pid):
+            print(f"⚠️ 检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。\n如果确认不存在正在运行的实例，请删除锁文件后重试：{lock_path}")
+            sys.exit(0)
+        # 尝试移除陈旧锁
+        try:
+            lock_path.unlink()
+        except Exception:
+            print(f"❌ 无法删除旧锁文件：{lock_path}，请手动清理后重试。")
+            sys.exit(1)
+
+    # 原子创建锁文件，避免并发竞争
+    flags = os.O_CREAT | os.O_EXCL | os.O_WRONLY
+    try:
+        fd = os.open(str(lock_path), flags)
+        with os.fdopen(fd, "w", encoding="utf-8") as fp:
+            payload = {
+                "pid": os.getpid(),
+                "time": int(time.time()),
+                "argv": sys.argv[:10],
+            }
+            try:
+                fp.write(json.dumps(payload, ensure_ascii=False))
+            except Exception:
+                fp.write(str(os.getpid()))
+        _INSTANCE_LOCK_PATH = lock_path
+        atexit.register(_release_instance_lock)
+    except FileExistsError:
+        # 极端并发下再次校验
+        pid = _read_lock_owner_pid(lock_path)
+        if pid and _is_process_alive(pid):
+            print(f"⚠️ 检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。")
+            sys.exit(0)
+        print(f"❌ 锁文件已存在但可能为陈旧状态：{lock_path}，请手动删除后重试。")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ 创建实例锁失败: {e}")
+        sys.exit(1)
+
+
 def _check_pip_updates() -> bool:
     """检查pip安装的Jarvis是否有更新
 
@@ -234,7 +351,7 @@ def _check_pip_updates() -> bool:
             with urllib.request.urlopen(url, timeout=5) as response:
                 data = json.loads(response.read().decode())
                 latest_version = data["info"]["version"]
-        except (urllib.error.URLError, KeyError, json.JSONDecodeError):
+        except (urllib.error.URLError, KeyError, ValueError):
             return False
 
         # 比较版本
@@ -242,13 +359,10 @@ def _check_pip_updates() -> bool:
         latest_ver = version.parse(latest_version)
 
         if latest_ver > current_ver:
-            PrettyOutput.print(
-                f"检测到新版本 v{latest_version} (当前版本: v{__version__})",
-                OutputType.INFO,
-            )
+            print(f"ℹ️ 检测到新版本 v{latest_version} (当前版本: v{__version__})")
 
             # 检测是否在虚拟环境中
-            in_venv = hasattr(sys, "real_prefix") or (
+            hasattr(sys, "real_prefix") or (
                 hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
             )
 
@@ -292,7 +406,7 @@ def _check_pip_updates() -> bool:
 
             # 自动尝试升级（失败时提供手动命令）
             try:
-                PrettyOutput.print("正在自动更新 Jarvis，请稍候...", OutputType.INFO)
+                print("ℹ️ 正在自动更新 Jarvis，请稍候...")
                 result = subprocess.run(
                     cmd_list,
                     capture_output=True,
@@ -302,25 +416,18 @@ def _check_pip_updates() -> bool:
                     timeout=600,
                 )
                 if result.returncode == 0:
-                    PrettyOutput.print("更新成功，正在重启以应用新版本...", OutputType.SUCCESS)
+                    print("✅ 更新成功，正在重启以应用新版本...")
                     # 更新检查日期，避免重复触发
                     last_check_file.write_text(today_str)
                     return True
                 else:
                     err = (result.stderr or result.stdout or "").strip()
                     if err:
-                        PrettyOutput.print(
-                            f"自动更新失败，错误信息（已截断）: {err[:500]}",
-                            OutputType.WARNING,
-                        )
-                    PrettyOutput.print(
-                        f"请手动执行以下命令更新: {update_cmd}", OutputType.INFO
-                    )
+                        print(f"⚠️ 自动更新失败，错误信息（已截断）: {err[:500]}")
+                    print(f"ℹ️ 请手动执行以下命令更新: {update_cmd}")
             except Exception:
-                PrettyOutput.print("自动更新出现异常，已切换为手动更新方式。", OutputType.WARNING)
-                PrettyOutput.print(
-                    f"请手动执行以下命令更新: {update_cmd}", OutputType.INFO
-                )
+                print("⚠️ 自动更新出现异常，已切换为手动更新方式。")
+                print(f"ℹ️ 请手动执行以下命令更新: {update_cmd}")
 
         # 更新检查日期
         last_check_file.write_text(today_str)
@@ -338,14 +445,22 @@ def _check_jarvis_updates() -> bool:
     返回:
         bool: 是否需要重启进程
     """
-    script_dir = Path(os.path.dirname(os.path.dirname(__file__)))
+    # 从当前文件目录向上查找包含 .git 的仓库根目录，修复原先只检查 src/jarvis 的问题
+    try:
+        script_path = Path(__file__).resolve()
+        repo_root: Optional[Path] = None
+        for d in [script_path.parent] + list(script_path.parents):
+            if (d / ".git").exists():
+                repo_root = d
+                break
+    except Exception:
+        repo_root = None
 
-    # 先检查是否是git源码安装
-    git_dir = script_dir / ".git"
-    if git_dir.exists():
+    # 先检查是否是git源码安装（找到仓库根目录即认为是源码安装）
+    if repo_root and (repo_root / ".git").exists():
         from jarvis.jarvis_utils.git_utils import check_and_update_git_repo
 
-        return check_and_update_git_repo(str(script_dir))
+        return check_and_update_git_repo(str(repo_root))
 
     # 检查是否是pip/uv pip安装的版本
     return _check_pip_updates()
@@ -353,8 +468,6 @@ def _check_jarvis_updates() -> bool:
 
 def _show_usage_stats(welcome_str: str) -> None:
     """显示Jarvis使用统计信息"""
-    from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
     try:
 
         from rich.console import Console, Group
@@ -365,6 +478,7 @@ def _show_usage_stats(welcome_str: str) -> None:
         console = Console()
 
         from jarvis.jarvis_stats.stats import StatsManager
+        from jarvis.jarvis_stats.storage import StatsStorage
 
         # 获取所有可用的指标
         all_metrics = StatsManager.list_metrics()
@@ -380,19 +494,47 @@ def _show_usage_stats(welcome_str: str) -> None:
             "other": {"title": "📦 其他指标", "metrics": {}, "suffix": ""},
         }
 
-        # 遍历所有指标，使用快速总量读取以避免全量扫描
-        for metric in all_metrics:
+        # 复用存储实例，避免重复创建
+        storage = StatsStorage()
+        
+        # 一次性读取元数据，避免重复读取
+        try:
+            meta = storage._load_json(storage.meta_file)
+            metrics_info = meta.get("metrics", {})
+        except Exception:
+            metrics_info = {}
+
+        # 批量读取所有总量文件，避免逐个文件操作
+        metric_totals: Dict[str, float] = {}
+        totals_dir = storage.totals_dir
+        if totals_dir.exists():
             try:
-                total = StatsManager.get_metric_total(metric)
+                for total_file in totals_dir.glob("*"):
+                    if total_file.is_file():
+                        try:
+                            with open(total_file, "r", encoding="utf-8") as f:
+                                total = float((f.read() or "0").strip() or "0")
+                                if total > 0:
+                                    metric_totals[total_file.name] = total
+                        except Exception:
+                            pass
             except Exception:
-                total = 0.0
+                pass
 
+        # 遍历所有指标，使用批量读取的数据
+        for metric in all_metrics:
+            # 从批量读取的数据中获取总量
+            total = metric_totals.get(metric, 0.0)
+            
             if not total or total <= 0:
                 continue
 
-            # 优先使用元信息中的分组（在写入指标时已记录）
-            info = StatsManager.get_metric_info(metric) or {}
-            group = info.get("group", "other")
+            # 从已加载的元数据中获取分组信息，避免重复读取
+            try:
+                info = metrics_info.get(metric, {})
+                group = info.get("group", "other")
+            except Exception:
+                group = "other"
 
             if group == "tool":
                 categorized_stats["tool"]["metrics"][metric] = int(total)
@@ -679,7 +821,7 @@ def _show_usage_stats(welcome_str: str) -> None:
 
             # 愿景 Panel
             vision_text = Text(
-                "重新定义开发者体验，打破人与工具的界限，构建开发者与AI之间真正的共生伙伴关系。",
+                "让开发者与AI成为共生伙伴",
                 justify="center",
                 style="italic",
             )
@@ -694,7 +836,7 @@ def _show_usage_stats(welcome_str: str) -> None:
 
             # 使命 Panel
             mission_text = Text(
-                "通过深度人机协作，将开发者的灵感（Vibe）高效落地为代码与行动，释放创造之力。",
+                "让灵感高效落地为代码与行动",
                 justify="center",
                 style="italic",
             )
@@ -755,11 +897,11 @@ def _show_usage_stats(welcome_str: str) -> None:
         # 输出错误信息以便调试
         import traceback
 
-        PrettyOutput.print(f"统计显示出错: {str(e)}", OutputType.ERROR)
-        PrettyOutput.print(traceback.format_exc(), OutputType.ERROR)
+        print(f"❌ 统计显示出错: {str(e)}")
+        print(f"❌ {traceback.format_exc()}")
 
 
-def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
+def init_env(welcome_str: str = "", config_file: Optional[str] = None) -> None:
     """初始化Jarvis环境
 
     参数:
@@ -769,35 +911,60 @@ def init_env(welcome_str: str, config_file: Optional[str] = None) -> None:
     # 0. 检查是否处于Jarvis打开的终端环境，避免嵌套
     try:
         if os.environ.get("JARVIS_TERMINAL") == "1":
-            PrettyOutput.print(
-                "检测到当前终端由 Jarvis 打开。再次启动可能导致嵌套。",
-                OutputType.WARNING,
-            )
+            print("⚠️ 检测到当前终端由 Jarvis 打开。再次启动可能导致嵌套。")
             if not user_confirm("是否仍要继续启动 Jarvis？", default=False):
-                PrettyOutput.print("已取消启动以避免终端嵌套。", OutputType.INFO)
+                print("ℹ️ 已取消启动以避免终端嵌套。")
                 sys.exit(0)
     except Exception:
         pass
 
     # 1. 设置信号处理
-    _setup_signal_handler()
+    try:
+        _setup_signal_handler()
+    except Exception:
+        pass
 
-    # 2. 统计命令使用
-    count_cmd_usage()
+    # 2. 统计命令使用（异步执行，避免阻塞初始化）
+    try:
+        count_cmd_usage()
+    except Exception:
+        # 静默失败，不影响正常使用
+        pass
 
     # 3. 设置配置文件
     global g_config_file
     g_config_file = config_file
-    load_config()
+    try:
+        load_config()
+    except Exception:
+        # 静默失败，不影响正常使用
+        pass
 
     # 4. 显示历史统计数据（仅在显示欢迎信息时显示）
+    # 使用延迟加载，避免阻塞初始化
     if welcome_str:
-        _show_usage_stats(welcome_str)
+        try:
+            # 在后台线程中显示统计，避免阻塞主流程
+            import threading
+            def show_stats_async():
+                try:
+                    _show_usage_stats(welcome_str)
+                except Exception:
+                    pass
+            stats_thread = threading.Thread(target=show_stats_async, daemon=True)
+            stats_thread.start()
+        except Exception:
+            # 静默失败，不影响正常使用
+            pass
 
-    # 5. 检查Jarvis更新
-    if _check_jarvis_updates():
-        os.execv(sys.executable, [sys.executable] + sys.argv)
-        sys.exit(0)
+    # 5. 检查Jarvis更新（异步执行，避免阻塞）
+    try:
+        if _check_jarvis_updates():
+            os.execv(sys.executable, [sys.executable] + sys.argv)
+            sys.exit(0)
+    except Exception:
+        # 静默失败，不影响正常使用
+        pass
 
 
 def _interactive_config_setup(config_file_path: Path):
@@ -809,9 +976,7 @@ def _interactive_config_setup(config_file_path: Path):
         user_confirm as get_yes_no,
     )
 
-    PrettyOutput.print(
-        "欢迎使用 Jarvis！未找到配置文件，现在开始引导配置。", OutputType.INFO
-    )
+    print("ℹ️ 欢迎使用 Jarvis！未找到配置文件，现在开始引导配置。")
 
     # 1. 选择平台
     registry = PlatformRegistry.get_global_platform_registry()
@@ -821,7 +986,7 @@ def _interactive_config_setup(config_file_path: Path):
     # 2. 配置环境变量
     platform_class = registry.platforms.get(platform_name)
     if not platform_class:
-        PrettyOutput.print(f"平台 '{platform_name}' 加载失败。", OutputType.ERROR)
+        print(f"❌ 平台 '{platform_name}' 加载失败。")
         sys.exit(1)
 
     env_vars = {}
@@ -829,9 +994,7 @@ def _interactive_config_setup(config_file_path: Path):
     defaults = platform_class.get_env_defaults()
     config_guide = platform_class.get_env_config_guide()
     if required_keys:
-        PrettyOutput.print(
-            f"请输入 {platform_name} 平台所需的配置信息:", OutputType.INFO
-        )
+        print(f"ℹ️ 请输入 {platform_name} 平台所需的配置信息:")
 
         # 如果有配置指导，先显示总体说明
         if config_guide:
@@ -842,7 +1005,7 @@ def _interactive_config_setup(config_file_path: Path):
                     guide_lines.append("")
                     guide_lines.append(f"{key} 获取方法:")
                     guide_lines.append(str(config_guide[key]))
-            PrettyOutput.print("\n".join(guide_lines), OutputType.INFO)
+            print("ℹ️ " + "\n".join(guide_lines))
         else:
             # 若无指导，仍需遍历以保持后续逻辑一致
             pass
@@ -864,7 +1027,7 @@ def _interactive_config_setup(config_file_path: Path):
     try:
         platform_instance = registry.create_platform(platform_name)
         if not platform_instance:
-            PrettyOutput.print(f"无法创建平台 '{platform_name}'。", OutputType.ERROR)
+            print(f"❌ 无法创建平台 '{platform_name}'。")
             sys.exit(1)
 
         model_list_tuples = platform_instance.get_model_list()
@@ -876,13 +1039,13 @@ def _interactive_config_setup(config_file_path: Path):
         model_name, _ = model_list_tuples[selected_index]
 
     except Exception:
-        PrettyOutput.print("获取模型列表失败", OutputType.ERROR)
+        print("❌ 获取模型列表失败")
         if not get_yes_no("无法获取模型列表，是否继续配置？"):
             sys.exit(1)
         model_name = get_input("请输入模型名称:")
 
     # 4. 测试配置
-    PrettyOutput.print("正在测试配置...", OutputType.INFO)
+    print("ℹ️ 正在测试配置...")
     test_passed = False
     try:
         platform_instance = registry.create_platform(platform_name)
@@ -891,16 +1054,14 @@ def _interactive_config_setup(config_file_path: Path):
             response_generator = platform_instance.chat("hello")
             response = "".join(response_generator)
             if response:
-                PrettyOutput.print(
-                    f"测试成功，模型响应: {response}", OutputType.SUCCESS
-                )
+                print(f"✅ 测试成功，模型响应: {response}")
                 test_passed = True
             else:
-                PrettyOutput.print("测试失败，模型没有响应。", OutputType.ERROR)
+                print("❌ 测试失败，模型没有响应。")
         else:
-            PrettyOutput.print("测试失败，无法创建平台实例。", OutputType.ERROR)
+            print("❌ 测试失败，无法创建平台实例。")
     except Exception:
-        PrettyOutput.print("测试失败", OutputType.ERROR)
+        print("❌ 测试失败")
 
     # 5. 交互式确认并应用配置（不直接生成配置文件）
     config_data = {
@@ -911,7 +1072,7 @@ def _interactive_config_setup(config_file_path: Path):
 
     if not test_passed:
         if not get_yes_no("配置测试失败，是否仍要应用该配置并继续？", default=False):
-            PrettyOutput.print("已取消配置。", OutputType.INFO)
+            print("ℹ️ 已取消配置。")
             sys.exit(0)
 
     # 6. 选择其他功能开关与可选项（复用统一逻辑）
@@ -934,11 +1095,11 @@ def _interactive_config_setup(config_file_path: Path):
             if header:
                 f.write(header)
             f.write(yaml_str)
-        PrettyOutput.print(f"配置文件已生成: {config_file_path}", OutputType.SUCCESS)
-        PrettyOutput.print("配置完成，请重新启动Jarvis。", OutputType.INFO)
+        print(f"✅ 配置文件已生成: {config_file_path}")
+        print("ℹ️ 配置完成，请重新启动Jarvis。")
         sys.exit(0)
     except Exception:
-        PrettyOutput.print("写入配置文件失败", OutputType.ERROR)
+        print("❌ 写入配置文件失败")
         sys.exit(1)
 
 
@@ -1016,359 +1177,420 @@ def _process_env_variables(config_data: dict) -> None:
         )
 
 
-def _collect_optional_config_interactively(
-    config_data: dict, ask_all: bool = False
-) -> bool:
-    """
-    复用的交互式配置收集逻辑：
-    - ask_all=False（默认）：仅对缺省的新功能开关/可选项逐项询问，已存在项跳过
-    - ask_all=True：对所有项进行询问，默认值取自当前配置文件，可覆盖现有设置
-    - 修改传入的 config_data
-    - 包含更多来自 config.py 的可选项
-    返回:
-        bool: 是否有变更
-    """
-    from jarvis.jarvis_utils.input import user_confirm as get_yes_no
-    from jarvis.jarvis_utils.input import get_single_line_input
+def _ask_config_bool(config_data: dict, ask_all: bool, _key: str, _tip: str, _default: bool) -> bool:
+    """询问并设置布尔类型配置项"""
+    try:
+        if not ask_all and _key in config_data:
+            return False
+        from jarvis.jarvis_utils.input import user_confirm as get_yes_no
+        cur = bool(config_data.get(_key, _default))
+        val = get_yes_no(_tip, default=cur)
+        if bool(val) == cur:
+            return False
+        config_data[_key] = bool(val)
+        return True
+    except Exception:
+        return False
 
-    def _ask_and_set(_key, _tip, _default, _type="bool"):
-        try:
-            if not ask_all and _key in config_data:
-                return False
-            if _type == "bool":
-                cur = bool(config_data.get(_key, _default))
-                val = get_yes_no(_tip, default=cur)
-                # 与当前值相同则不写入，避免冗余
-                if bool(val) == cur:
-                    return False
-                config_data[_key] = bool(val)
-            else:
-                cur = str(config_data.get(_key, _default or ""))
-                val = get_single_line_input(f"{_tip}", default=cur)
-                v = ("" if val is None else str(val)).strip()
-                # 输入与当前值相同则不写入
-                if v == cur:
-                    return False
-                config_data[_key] = v
-            return True
-        except Exception:
-            # 异常时不写入，保持精简
+
+def _ask_config_str(config_data: dict, ask_all: bool, _key: str, _tip: str, _default: str = "") -> bool:
+    """询问并设置字符串类型配置项"""
+    try:
+        if not ask_all and _key in config_data:
             return False
+        from jarvis.jarvis_utils.input import get_single_line_input
+        cur = str(config_data.get(_key, _default or ""))
+        val = get_single_line_input(f"{_tip}", default=cur)
+        v = ("" if val is None else str(val)).strip()
+        if v == cur:
+            return False
+        config_data[_key] = v
+        return True
+    except Exception:
+        return False
 
-    def _ask_and_set_optional_str(_key, _tip, _default: str = "") -> bool:
-        try:
-            if not ask_all and _key in config_data:
-                return False
-            cur = str(config_data.get(_key, _default or ""))
-            val = get_single_line_input(f"{_tip}", default=cur)
-            if val is None:
-                return False
-            s = str(val).strip()
-            # 空输入表示不改变
-            if s == "":
-                return False
-            if s == cur:
-                return False
-            config_data[_key] = s
-            return True
-        except Exception:
+
+def _ask_config_optional_str(config_data: dict, ask_all: bool, _key: str, _tip: str, _default: str = "") -> bool:
+    """询问并设置可选字符串类型配置项（空输入表示不改变）"""
+    try:
+        if not ask_all and _key in config_data:
+            return False
+        from jarvis.jarvis_utils.input import get_single_line_input
+        cur = str(config_data.get(_key, _default or ""))
+        val = get_single_line_input(f"{_tip}", default=cur)
+        if val is None:
+            return False
+        s = str(val).strip()
+        if s == "" or s == cur:
             return False
+        config_data[_key] = s
+        return True
+    except Exception:
+        return False
+
 
-    def _ask_and_set_int(_key, _tip, _default: int) -> bool:
+def _ask_config_int(config_data: dict, ask_all: bool, _key: str, _tip: str, _default: int) -> bool:
+    """询问并设置整数类型配置项"""
+    try:
+        if not ask_all and _key in config_data:
+            return False
+        from jarvis.jarvis_utils.input import get_single_line_input
+        cur = str(config_data.get(_key, _default))
+        val_str = get_single_line_input(f"{_tip}", default=cur)
+        s = "" if val_str is None else str(val_str).strip()
+        if s == "" or s == cur:
+            return False
         try:
-            if not ask_all and _key in config_data:
-                return False
-            cur = str(config_data.get(_key, _default))
-            val_str = get_single_line_input(f"{_tip}", default=cur)
-            s = "" if val_str is None else str(val_str).strip()
-            if s == "" or s == cur:
-                return False
-            try:
-                v = int(s)
-            except Exception:
-                return False
-            if str(v) == cur:
-                return False
-            config_data[_key] = v
-            return True
+            v = int(s)
         except Exception:
             return False
+        if str(v) == cur:
+            return False
+        config_data[_key] = v
+        return True
+    except Exception:
+        return False
 
-    def _ask_and_set_list(_key, _tip) -> bool:
-        try:
-            if not ask_all and _key in config_data:
-                return False
-            cur_val = config_data.get(_key, [])
-            if isinstance(cur_val, list):
-                cur_display = ", ".join([str(x) for x in cur_val])
-            else:
-                cur_display = str(cur_val or "")
-            val = get_single_line_input(f"{_tip}", default=cur_display)
-            if val is None:
-                return False
-            s = str(val).strip()
-            if s == cur_display.strip():
-                return False
-            if not s:
-                # 输入为空表示不改变
-                return False
-            items = [x.strip() for x in s.split(",") if x.strip()]
-            if isinstance(cur_val, list) and items == cur_val:
-                return False
-            config_data[_key] = items
-            return True
-        except Exception:
+
+def _ask_config_list(config_data: dict, ask_all: bool, _key: str, _tip: str) -> bool:
+    """询问并设置列表类型配置项（逗号分隔）"""
+    try:
+        if not ask_all and _key in config_data:
+            return False
+        from jarvis.jarvis_utils.input import get_single_line_input
+        cur_val = config_data.get(_key, [])
+        if isinstance(cur_val, list):
+            cur_display = ", ".join([str(x) for x in cur_val])
+        else:
+            cur_display = str(cur_val or "")
+        val = get_single_line_input(f"{_tip}", default=cur_display)
+        if val is None:
+            return False
+        s = str(val).strip()
+        if s == cur_display.strip():
             return False
+        if not s:
+            return False
+        items = [x.strip() for x in s.split(",") if x.strip()]
+        if isinstance(cur_val, list) and items == cur_val:
+            return False
+        config_data[_key] = items
+        return True
+    except Exception:
+        return False
+
 
+def _collect_basic_switches(config_data: dict, ask_all: bool) -> bool:
+    """收集基础开关配置"""
     changed = False
-    # 现有两个开关
-    changed = (
-        _ask_and_set(
-            "JARVIS_ENABLE_GIT_JCA_SWITCH",
-            "是否在检测到Git仓库时，提示并可自动切换到代码开发模式（jca）？",
-            False,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_ENABLE_STARTUP_CONFIG_SELECTOR",
-            "在进入默认通用代理前，是否先列出可用配置（agent/multi_agent/roles）供选择？",
-            False,
-            "bool",
-        )
-        or changed
-    )
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_ENABLE_GIT_JCA_SWITCH",
+        "是否在检测到Git仓库时，提示并可自动切换到代码开发模式（jca）？",
+        False,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_ENABLE_STARTUP_CONFIG_SELECTOR",
+        "在进入默认通用代理前，是否先列出可用配置（agent/multi_agent/roles）供选择？",
+        False,
+    ) or changed
+    return changed
 
-    # 新增的配置项交互（通用体验相关）
-    changed = (
-        _ask_and_set(
-            "JARVIS_PRETTY_OUTPUT",
-            "是否启用更美观的终端输出（Pretty Output）？",
-            False,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_PRINT_PROMPT",
-            "是否打印发送给模型的提示词（Prompt）？",
-            False,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_IMMEDIATE_ABORT",
-            "是否启用立即中断？\n- 选择 是/true：在对话输出流的每次迭代中检测到用户中断（例如 Ctrl+C）时，立即返回当前已生成的内容并停止继续输出。\n- 选择 否/false：不会在输出过程中立刻返回，而是按既有流程处理（不中途打断输出）。",
-            False,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_ENABLE_STATIC_ANALYSIS",
-            "是否启用静态代码分析（Static Analysis）？",
-            True,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_USE_METHODOLOGY",
-            "是否启用方法论系统（Methodology）？",
-            True,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_USE_ANALYSIS",
-            "是否启用分析流程（Analysis）？",
-            True,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_FORCE_SAVE_MEMORY",
-            "是否强制保存会话记忆？",
-            True,
-            "bool",
-        )
-        or changed
-    )
 
-    # 代码与工具操作安全提示
-    changed = (
-        _ask_and_set(
-            "JARVIS_EXECUTE_TOOL_CONFIRM",
-            "执行工具前是否需要确认？",
-            False,
-            "bool",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_CONFIRM_BEFORE_APPLY_PATCH",
-            "应用补丁前是否需要确认？",
-            False,
-            "bool",
-        )
-        or changed
-    )
+def _collect_ui_experience_config(config_data: dict, ask_all: bool) -> bool:
+    """收集UI体验相关配置"""
+    changed = False
+    try:
+        import platform as _platform_mod
+        _default_pretty = False if _platform_mod.system() == "Windows" else True
+    except Exception:
+        _default_pretty = True
+    
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_PRETTY_OUTPUT",
+        "是否启用更美观的终端输出（Pretty Output）？",
+        _default_pretty,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_PRINT_PROMPT",
+        "是否打印发送给模型的提示词（Prompt）？",
+        False,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_IMMEDIATE_ABORT",
+        "是否启用立即中断？\n- 选择 是/true：在对话输出流的每次迭代中检测到用户中断（例如 Ctrl+C）时，立即返回当前已生成的内容并停止继续输出。\n- 选择 否/false：不会在输出过程中立刻返回，而是按既有流程处理（不中途打断输出）。",
+        False,
+    ) or changed
+    return changed
 
-    # 数据目录与最大输入Token
-    from jarvis.jarvis_utils.config import get_data_dir as _get_data_dir  # lazy import
 
-    changed = (
-        _ask_and_set_optional_str(
-            "JARVIS_DATA_PATH",
-            f"是否自定义数据目录路径(JARVIS_DATA_PATH)？留空使用默认: {_get_data_dir()}",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set_int(
-            "JARVIS_MAX_INPUT_TOKEN_COUNT",
-            "自定义最大输入Token数量（留空使用默认: 32000）",
-            32000,
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set_int(
-            "JARVIS_TOOL_FILTER_THRESHOLD",
-            "设置AI工具筛选阈值 (当可用工具数超过此值时触发AI筛选, 默认30)",
-            30,
-        )
-        or changed
-    )
+def _collect_analysis_config(config_data: dict, ask_all: bool) -> bool:
+    """收集代码分析相关配置"""
+    changed = False
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_ENABLE_STATIC_ANALYSIS",
+        "是否启用静态代码分析（Static Analysis）？",
+        True,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_ENABLE_BUILD_VALIDATION",
+        "是否启用构建验证（Build Validation）？在代码编辑后自动验证代码能否成功编译/构建。",
+        True,
+    ) or changed
+    changed = _ask_config_int(
+        config_data, ask_all,
+        "JARVIS_BUILD_VALIDATION_TIMEOUT",
+        "构建验证的超时时间（秒，默认30秒）",
+        30,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_ENABLE_IMPACT_ANALYSIS",
+        "是否启用编辑影响范围分析（Impact Analysis）？分析代码编辑的影响范围，识别可能受影响的文件、函数、测试等。",
+        True,
+    ) or changed
+    return changed
 
-    # 目录类配置（逗号分隔）
-    changed = (
-        _ask_and_set_list(
-            "JARVIS_TOOL_LOAD_DIRS",
-            "指定工具加载目录（逗号分隔，留空跳过）：",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set_list(
-            "JARVIS_METHODOLOGY_DIRS",
-            "指定方法论加载目录（逗号分隔，留空跳过）：",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set_list(
-            "JARVIS_AGENT_DEFINITION_DIRS",
-            "指定 agent 定义加载目录（逗号分隔，留空跳过）：",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set_list(
-            "JARVIS_MULTI_AGENT_DIRS",
-            "指定 multi_agent 加载目录（逗号分隔，留空跳过）：",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set_list(
-            "JARVIS_ROLES_DIRS",
-            "指定 roles 加载目录（逗号分隔，留空跳过）：",
-        )
-        or changed
-    )
 
-    # Web 搜索配置（可选）
-    changed = (
-        _ask_and_set_optional_str(
-            "JARVIS_WEB_SEARCH_PLATFORM",
-            "配置 Web 搜索平台名称（留空跳过）：",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set_optional_str(
-            "JARVIS_WEB_SEARCH_MODEL",
-            "配置 Web 搜索模型名称（留空跳过）：",
-        )
-        or changed
-    )
+def _collect_agent_features_config(config_data: dict, ask_all: bool) -> bool:
+    """收集Agent功能相关配置"""
+    changed = False
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_USE_METHODOLOGY",
+        "是否启用方法论系统（Methodology）？",
+        True,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_USE_ANALYSIS",
+        "是否启用分析流程（Analysis）？",
+        True,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_FORCE_SAVE_MEMORY",
+        "是否强制保存会话记忆？",
+        False,
+    ) or changed
+    return changed
 
-    # Git 校验模式
-    def _ask_git_check_mode() -> bool:
-        try:
-            _key = "JARVIS_GIT_CHECK_MODE"
-            if not ask_all and _key in config_data:
-                return False
 
-            from jarvis.jarvis_utils.input import get_choice
-            from jarvis.jarvis_utils.config import get_git_check_mode
-
-            current_mode = config_data.get(_key, get_git_check_mode())
-            choices = ["strict", "warn"]
-            tip = (
-                "请选择 Git 仓库检查模式 (JARVIS_GIT_CHECK_MODE):\n"
-                "此设置决定了当在 Git 仓库中检测到未提交的更改时，Jarvis应如何处理。\n"
-                "这对于确保代码修改和提交操作在干净的工作区上进行至关重要。\n"
-                "  - strict: (推荐) 如果存在未提交的更改，则中断相关操作（如代码修改、自动提交）。\n"
-                "            这可以防止意外覆盖或丢失本地工作。\n"
-                "  - warn:   如果存在未提交的更改，仅显示警告信息，然后继续执行操作。\n"
-                "            适用于您希望绕过检查并自行管理仓库状态的场景。"
-            )
+def _collect_session_config(config_data: dict, ask_all: bool) -> bool:
+    """收集会话与调试相关配置"""
+    changed = False
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_SAVE_SESSION_HISTORY",
+        "是否保存会话记录？",
+        False,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_PRINT_ERROR_TRACEBACK",
+        "是否在错误输出时打印回溯调用链？",
+        False,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_SKIP_PREDEFINED_TASKS",
+        "是否跳过预定义任务加载（不读取 pre-command 列表）？",
+        False,
+    ) or changed
+    changed = _ask_config_int(
+        config_data, ask_all,
+        "JARVIS_CONVERSATION_TURN_THRESHOLD",
+        "对话轮次阈值（达到此轮次时触发总结，建议50-100）：",
+        50,
+    ) or changed
+    return changed
 
 
+def _collect_safety_config(config_data: dict, ask_all: bool) -> bool:
+    """收集代码与工具操作安全提示配置"""
+    changed = False
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_EXECUTE_TOOL_CONFIRM",
+        "执行工具前是否需要确认？",
+        False,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_CONFIRM_BEFORE_APPLY_PATCH",
+        "应用补丁前是否需要确认？",
+        False,
+    ) or changed
+    return changed
 
-            new_mode = get_choice(
-                tip,
-                choices,
-            )
 
-            if new_mode == current_mode:
-                return False
+def _collect_data_and_token_config(config_data: dict, ask_all: bool) -> bool:
+    """收集数据目录与最大输入Token配置"""
+    changed = False
+    from jarvis.jarvis_utils.config import get_data_dir as _get_data_dir
+    changed = _ask_config_optional_str(
+        config_data, ask_all,
+        "JARVIS_DATA_PATH",
+        f"是否自定义数据目录路径(JARVIS_DATA_PATH)？留空使用默认: {_get_data_dir()}",
+    ) or changed
+    changed = _ask_config_int(
+        config_data, ask_all,
+        "JARVIS_MAX_INPUT_TOKEN_COUNT",
+        "自定义最大输入Token数量（留空使用默认: 32000）",
+        32000,
+    ) or changed
+    changed = _ask_config_int(
+        config_data, ask_all,
+        "JARVIS_TOOL_FILTER_THRESHOLD",
+        "设置AI工具筛选阈值 (当可用工具数超过此值时触发AI筛选, 默认30)",
+        30,
+    ) or changed
+    return changed
 
-            config_data[_key] = new_mode
-            return True
-        except Exception:
-            return False
 
-    changed = _ask_git_check_mode() or changed
+def _collect_advanced_config(config_data: dict, ask_all: bool) -> bool:
+    """收集高级配置（自动总结、脚本超时等）"""
+    changed = False
+    changed = _ask_config_int(
+        config_data, ask_all,
+        "JARVIS_SCRIPT_EXECUTION_TIMEOUT",
+        "脚本执行超时时间（秒，默认300，仅非交互模式生效）",
+        300,
+    ) or changed
+    changed = _ask_config_int(
+        config_data, ask_all,
+        "JARVIS_ADDON_PROMPT_THRESHOLD",
+        "附加提示的触发阈值（字符数，默认1024）。当消息长度超过此值时，会自动添加默认的附加提示",
+        1024,
+    ) or changed
+    changed = _ask_config_bool(
+        config_data, ask_all,
+        "JARVIS_ENABLE_INTENT_RECOGNITION",
+        "是否启用意图识别功能？用于智能上下文推荐中的LLM意图提取和语义分析",
+        True,
+    ) or changed
+    return changed
+
 
-    # Git 提交提示词（可选）
-    changed = (
-        _ask_and_set_optional_str(
-            "JARVIS_GIT_COMMIT_PROMPT",
-            "自定义 Git 提交提示模板（留空跳过）：",
+def _collect_directory_config(config_data: dict, ask_all: bool) -> bool:
+    """收集目录类配置（逗号分隔）"""
+    changed = False
+    changed = _ask_config_list(
+        config_data, ask_all,
+        "JARVIS_TOOL_LOAD_DIRS",
+        "指定工具加载目录（逗号分隔，留空跳过）：",
+    ) or changed
+    changed = _ask_config_list(
+        config_data, ask_all,
+        "JARVIS_METHODOLOGY_DIRS",
+        "指定方法论加载目录（逗号分隔，留空跳过）：",
+    ) or changed
+    changed = _ask_config_list(
+        config_data, ask_all,
+        "JARVIS_AGENT_DEFINITION_DIRS",
+        "指定 agent 定义加载目录（逗号分隔，留空跳过）：",
+    ) or changed
+    changed = _ask_config_list(
+        config_data, ask_all,
+        "JARVIS_MULTI_AGENT_DIRS",
+        "指定 multi_agent 加载目录（逗号分隔，留空跳过）：",
+    ) or changed
+    changed = _ask_config_list(
+        config_data, ask_all,
+        "JARVIS_ROLES_DIRS",
+        "指定 roles 加载目录（逗号分隔，留空跳过）：",
+    ) or changed
+    changed = _ask_config_list(
+        config_data, ask_all,
+        "JARVIS_AFTER_TOOL_CALL_CB_DIRS",
+        "指定工具调用后回调实现目录（逗号分隔，留空跳过）：",
+    ) or changed
+    return changed
+
+
+def _collect_web_search_config(config_data: dict, ask_all: bool) -> bool:
+    """收集Web搜索配置"""
+    changed = False
+    changed = _ask_config_optional_str(
+        config_data, ask_all,
+        "JARVIS_WEB_SEARCH_PLATFORM",
+        "配置 Web 搜索平台名称（留空跳过）：",
+    ) or changed
+    changed = _ask_config_optional_str(
+        config_data, ask_all,
+        "JARVIS_WEB_SEARCH_MODEL",
+        "配置 Web 搜索模型名称（留空跳过）：",
+    ) or changed
+    return changed
+
+
+def _ask_git_check_mode(config_data: dict, ask_all: bool) -> bool:
+    """询问Git校验模式"""
+    try:
+        _key = "JARVIS_GIT_CHECK_MODE"
+        if not ask_all and _key in config_data:
+            return False
+        from jarvis.jarvis_utils.input import get_choice
+        from jarvis.jarvis_utils.config import get_git_check_mode
+        current_mode = config_data.get(_key, get_git_check_mode())
+        choices = ["strict", "warn"]
+        tip = (
+            "请选择 Git 仓库检查模式 (JARVIS_GIT_CHECK_MODE):\n"
+            "此设置决定了当在 Git 仓库中检测到未提交的更改时，Jarvis应如何处理。\n"
+            "这对于确保代码修改和提交操作在干净的工作区上进行至关重要。\n"
+            "  - strict: (推荐) 如果存在未提交的更改，则中断相关操作（如代码修改、自动提交）。\n"
+            "            这可以防止意外覆盖或丢失本地工作。\n"
+            "  - warn:   如果存在未提交的更改，仅显示警告信息，然后继续执行操作。\n"
+            "            适用于您希望绕过检查并自行管理仓库状态的场景。"
         )
-        or changed
-    )
+        new_mode = get_choice(tip, choices)
+        if new_mode == current_mode:
+            return False
+        config_data[_key] = new_mode
+        return True
+    except Exception:
+        return False
+
+
+def _collect_git_config(config_data: dict, ask_all: bool) -> bool:
+    """收集Git相关配置"""
+    changed = False
+    changed = _ask_git_check_mode(config_data, ask_all) or changed
+    changed = _ask_config_optional_str(
+        config_data, ask_all,
+        "JARVIS_GIT_COMMIT_PROMPT",
+        "自定义 Git 提交提示模板（留空跳过）：",
+    ) or changed
+    return changed
 
-    # RAG 配置（可选）
+
+def _collect_rag_config(config_data: dict, ask_all: bool) -> bool:
+    """收集RAG配置"""
+    changed = False
     try:
         from jarvis.jarvis_utils.config import (
             get_rag_embedding_model as _get_rag_embedding_model,
             get_rag_rerank_model as _get_rag_rerank_model,
         )
-
+        from jarvis.jarvis_utils.input import user_confirm as get_yes_no
+        from jarvis.jarvis_utils.input import get_single_line_input
+        
         rag_default_embed = _get_rag_embedding_model()
         rag_default_rerank = _get_rag_rerank_model()
     except Exception:
         rag_default_embed = "BAAI/bge-m3"
         rag_default_rerank = "BAAI/bge-reranker-v2-m3"
-
+        get_yes_no = None
+        get_single_line_input = None
+    
     try:
-        if "JARVIS_RAG" not in config_data:
+        if "JARVIS_RAG" not in config_data and get_yes_no:
             if get_yes_no("是否配置 RAG 检索增强参数？", default=False):
                 rag_conf: Dict[str, Any] = {}
                 emb = get_single_line_input(
@@ -1395,49 +1617,74 @@ def _collect_optional_config_interactively(
                 changed = True
     except Exception:
         pass
+    return changed
 
-    # 中心仓库配置
-    changed = (
-        _ask_and_set(
-            "JARVIS_CENTRAL_METHODOLOGY_REPO",
-            "请输入中心方法论仓库地址（可留空跳过）：",
-            "",
-            "str",
-        )
-        or changed
-    )
-    changed = (
-        _ask_and_set(
-            "JARVIS_CENTRAL_TOOL_REPO",
-            "请输入中心工具仓库地址（可留空跳过）：",
-            "",
-            "str",
-        )
-        or changed
-    )
-
-    # 已移除 LLM 组配置交互
 
-    # 已移除 RAG 组配置交互
+def _collect_central_repo_config(config_data: dict, ask_all: bool) -> bool:
+    """收集中心仓库配置"""
+    changed = False
+    changed = _ask_config_str(
+        config_data, ask_all,
+        "JARVIS_CENTRAL_METHODOLOGY_REPO",
+        "请输入中心方法论仓库路径或Git地址（可留空跳过）：",
+        "",
+    ) or changed
+    changed = _ask_config_str(
+        config_data, ask_all,
+        "JARVIS_CENTRAL_TOOL_REPO",
+        "请输入中心工具仓库路径或Git地址（可留空跳过）：",
+        "",
+    ) or changed
+    return changed
 
-    # 已移除 工具组配置交互
 
-    # 已移除：替换映射（JARVIS_REPLACE_MAP）的交互式配置，保持最简交互
-    # SHELL 覆盖（可选）
+def _collect_shell_config(config_data: dict, ask_all: bool) -> bool:
+    """收集SHELL覆盖配置"""
+    changed = False
     try:
+        import os
         default_shell = os.getenv("SHELL", "/bin/bash")
-        changed = (
-            _ask_and_set_optional_str(
-                "SHELL",
-                f"覆盖 SHELL 路径（留空使用系统默认: {default_shell}）：",
-                default_shell,
-            )
-            or changed
-        )
+        changed = _ask_config_optional_str(
+            config_data, ask_all,
+            "SHELL",
+            f"覆盖 SHELL 路径（留空使用系统默认: {default_shell}）：",
+            default_shell,
+        ) or changed
     except Exception:
         pass
+    return changed
+
 
-    # 已移除：MCP（JARVIS_MCP）的交互式配置，保持最简交互
+def _collect_optional_config_interactively(
+    config_data: dict, ask_all: bool = False
+) -> bool:
+    """
+    复用的交互式配置收集逻辑：
+    - ask_all=False（默认）：仅对缺省的新功能开关/可选项逐项询问，已存在项跳过
+    - ask_all=True：对所有项进行询问，默认值取自当前配置文件，可覆盖现有设置
+    - 修改传入的 config_data
+    - 包含更多来自 config.py 的可选项
+    返回:
+        bool: 是否有变更
+    """
+    changed = False
+    
+    # 收集各类配置
+    changed = _collect_basic_switches(config_data, ask_all) or changed
+    changed = _collect_ui_experience_config(config_data, ask_all) or changed
+    changed = _collect_analysis_config(config_data, ask_all) or changed
+    changed = _collect_agent_features_config(config_data, ask_all) or changed
+    changed = _collect_session_config(config_data, ask_all) or changed
+    changed = _collect_safety_config(config_data, ask_all) or changed
+    changed = _collect_data_and_token_config(config_data, ask_all) or changed
+    changed = _collect_advanced_config(config_data, ask_all) or changed
+    changed = _collect_directory_config(config_data, ask_all) or changed
+    changed = _collect_web_search_config(config_data, ask_all) or changed
+    changed = _collect_git_config(config_data, ask_all) or changed
+    changed = _collect_rag_config(config_data, ask_all) or changed
+    changed = _collect_central_repo_config(config_data, ask_all) or changed
+    changed = _collect_shell_config(config_data, ask_all) or changed
+    
     return changed
 
 
@@ -1492,15 +1739,13 @@ def _load_and_process_config(jarvis_dir: str, config_file: str) -> None:
             # 更新全局配置
             set_global_env_data(config_data)
     except Exception:
-        PrettyOutput.print("加载配置文件失败", OutputType.ERROR)
+        print("❌ 加载配置文件失败")
         if get_yes_no("配置文件格式错误，是否删除并重新配置？"):
             try:
                 os.remove(config_file)
-                PrettyOutput.print(
-                    "已删除损坏的配置文件，请重启Jarvis以重新配置。", OutputType.SUCCESS
-                )
+                print("✅ 已删除损坏的配置文件，请重启Jarvis以重新配置。")
             except Exception:
-                PrettyOutput.print("删除配置文件失败", OutputType.ERROR)
+                print("❌ 删除配置文件失败")
         sys.exit(1)
 
 
@@ -1657,69 +1902,113 @@ def _read_old_config_file(config_file):
             {str(k): str(v) for k, v in config_data.items() if v is not None}
         )
         set_global_env_data(config_data)
-    PrettyOutput.print(
-        "检测到旧格式配置文件，旧格式以后将不再支持，请尽快迁移到新格式",
-        OutputType.WARNING,
-    )
+    print("⚠️ 检测到旧格式配置文件，旧格式以后将不再支持，请尽快迁移到新格式")
+
+
+# 线程本地存储，用于共享重试计数器
+_retry_context = threading.local()
+
+
+def _get_retry_count() -> int:
+    """获取当前线程的重试计数"""
+    if not hasattr(_retry_context, 'count'):
+        _retry_context.count = 0
+    return _retry_context.count
+
+
+def _increment_retry_count() -> int:
+    """增加重试计数并返回新的计数值"""
+    if not hasattr(_retry_context, 'count'):
+        _retry_context.count = 0
+    _retry_context.count += 1
+    return _retry_context.count
+
+
+def _reset_retry_count():
+    """重置重试计数"""
+    _retry_context.count = 0
 
 
-def while_success(func: Callable[[], Any], sleep_time: float = 0.1, max_retries: int = 5) -> Any:
+def while_success(func: Callable[[], Any]) -> Any:
     """循环执行函数直到成功（累计日志后统一打印，避免逐次加框）
 
     参数：
     func -- 要执行的函数
-    sleep_time -- 每次失败后的等待时间（秒）
-    max_retries -- 最大重试次数，默认5次
 
     返回：
     函数执行结果
+
+    注意：
+    与while_true共享重试计数器，累计重试6次，使用指数退避（第一次等待1s）
     """
+    MAX_RETRIES = 6
     result: Any = None
-    retry_count = 0
-    while retry_count < max_retries:
+    
+    while True:
         try:
             result = func()
+            _reset_retry_count()  # 成功后重置计数器
             break
-        except Exception:
-            retry_count += 1
-            if retry_count < max_retries:
-                PrettyOutput.print(
-                    f"发生异常，重试中 ({retry_count}/{max_retries})，等待 {sleep_time}s...",
-                    OutputType.WARNING,
-                )
-                time.sleep(sleep_time)
-            continue
+        except Exception as e:
+            retry_count = _increment_retry_count()
+            if retry_count <= MAX_RETRIES:
+                # 指数退避：第1次等待1s (2^0)，第2次等待2s (2^1)，第3次等待4s (2^2)，第4次等待8s (2^3)，第6次等待32s (2^5)
+                sleep_time = 2 ** (retry_count - 1)
+                if retry_count < MAX_RETRIES:
+                    print(f"⚠️ 发生异常:\n{e}\n重试中 ({retry_count}/{MAX_RETRIES})，等待 {sleep_time}s...")
+                    time.sleep(sleep_time)
+                else:
+                    print(f"⚠️ 发生异常:\n{e}\n已达到最大重试次数 ({retry_count}/{MAX_RETRIES})")
+                    _reset_retry_count()
+                    raise
+            else:
+                _reset_retry_count()
+                raise
     return result
 
 
-def while_true(func: Callable[[], bool], sleep_time: float = 0.1, max_retries: int = 5) -> Any:
+def while_true(func: Callable[[], bool]) -> Any:
     """循环执行函数直到返回True（累计日志后统一打印，避免逐次加框）
 
     参数:
         func: 要执行的函数，必须返回布尔值
-        sleep_time: 每次失败后的等待时间(秒)
-        max_retries: 最大重试次数，默认5次
 
     返回:
         函数最终返回的True值
 
     注意:
         与while_success不同，此函数只检查返回是否为True，
-        不捕获异常，异常会直接抛出
+        不捕获异常，异常会直接抛出。
+        与while_success共享重试计数器，累计重试6次，使用指数退避（第一次等待1s）
     """
+    MAX_RETRIES = 6
     ret: bool = False
-    retry_count = 0
-    while retry_count < max_retries:
-        ret = func()
-        if ret:
+    
+    while True:
+        try:
+            ret = func()
+            if ret:
+                _reset_retry_count()  # 成功后重置计数器
+                break
+        except Exception:
+            # 异常直接抛出，不捕获
+            _reset_retry_count()
+            raise
+        
+        retry_count = _increment_retry_count()
+        if retry_count <= MAX_RETRIES:
+            # 指数退避：第1次等待1s (2^0)，第2次等待2s (2^1)，第3次等待4s (2^2)，第4次等待8s (2^3)，第6次等待32s (2^5)
+            sleep_time = 2 ** (retry_count - 1)
+            if retry_count < MAX_RETRIES:
+                print(f"⚠️ 返回空值，重试中 ({retry_count}/{MAX_RETRIES})，等待 {sleep_time}s...")
+                time.sleep(sleep_time)
+            else:
+                print(f"⚠️ 返回空值，已达到最大重试次数 ({retry_count}/{MAX_RETRIES})")
+                _reset_retry_count()
+                break
+        else:
+            _reset_retry_count()
             break
-        retry_count += 1
-        if retry_count < max_retries:
-            PrettyOutput.print(
-                f"返回空值，重试中 ({retry_count}/{max_retries})，等待 {sleep_time}s...",
-                OutputType.WARNING,
-            )
-            time.sleep(sleep_time)
     return ret
 
 
@@ -1730,9 +2019,22 @@ def get_file_md5(filepath: str) -> str:
         filepath: 要计算哈希的文件路径
 
     返回:
-        str: 文件内容的MD5哈希值
+        str: 文件内容的MD5哈希值（为降低内存占用，仅读取前100MB进行计算）
     """
-    return hashlib.md5(open(filepath, "rb").read(100 * 1024 * 1024)).hexdigest()
+    # 采用流式读取，避免一次性加载100MB到内存
+    h = hashlib.md5()
+    max_bytes = 100 * 1024 * 1024  # 与原实现保持一致：仅读取前100MB
+    buf_size = 8 * 1024 * 1024     # 8MB缓冲
+    read_bytes = 0
+    with open(filepath, "rb") as f:
+        while read_bytes < max_bytes:
+            to_read = min(buf_size, max_bytes - read_bytes)
+            chunk = f.read(to_read)
+            if not chunk:
+                break
+            h.update(chunk)
+            read_bytes += len(chunk)
+    return h.hexdigest()
 
 
 def get_file_line_count(filename: str) -> int:
@@ -1745,7 +2047,9 @@ def get_file_line_count(filename: str) -> int:
         int: 文件中的行数，如果文件无法读取则返回0
     """
     try:
-        return len(open(filename, "r", encoding="utf-8", errors="ignore").readlines())
+        # 使用流式逐行计数，避免将整个文件读入内存
+        with open(filename, "r", encoding="utf-8", errors="ignore") as f:
+            return sum(1 for _ in f)
     except Exception:
         return 0
 
@@ -1771,14 +2075,52 @@ def count_cmd_usage() -> None:
 
 
 def is_context_overflow(
-    content: str, model_group_override: Optional[str] = None
+    content: str, 
+    model_group_override: Optional[str] = None,
+    platform: Optional[Any] = None
 ) -> bool:
-    """判断文件内容是否超出上下文限制"""
-    return get_context_token_count(content) > get_max_big_content_size(
-        model_group_override
-    )
-
-
+    """判断文件内容是否超出上下文限制
+    
+    参数:
+        content: 要检查的内容
+        model_group_override: 模型组覆盖（可选）
+        platform: 平台实例（可选），如果提供则使用剩余token数量判断
+        
+    返回:
+        bool: 如果内容超出上下文限制返回True
+    """
+    # 快速长度预估：如果内容长度明显超过限制，直接返回True，无需精确计算token
+    if content:
+        # 粗略估算：假设平均每个token约4个字符，保守估计使用3.5个字符/token
+        estimated_tokens = len(content) // 3.5
+        
+        # 获取最大token限制
+        max_tokens = get_max_big_content_size(model_group_override)
+        
+        # 如果预估token数超过限制的150%，直接认为超出（避免精确计算）
+        if estimated_tokens > max_tokens * 1.5:
+            return True
+            
+        # 如果预估token数小于限制的50%，直接认为安全
+        if estimated_tokens < max_tokens * 0.5:
+            return False
+    
+    # 只有在预估结果不明确时，才进行精确的token计算
+    content_tokens = get_context_token_count(content)
+    
+    # 优先使用剩余token数量
+    if platform is not None:
+        try:
+            remaining_tokens = platform.get_remaining_token_count()
+            # 如果内容token数超过剩余token的80%，认为超出限制
+            threshold = int(remaining_tokens * 0.8)
+            if threshold > 0:
+                return content_tokens > threshold
+        except Exception:
+            pass
+    
+    # 回退方案：使用输入窗口限制
+    return content_tokens > get_max_big_content_size(model_group_override)
 def get_loc_stats() -> str:
     """使用loc命令获取当前目录的代码统计信息
 
@@ -1846,16 +2188,10 @@ def _pull_git_repo(repo_path: Path, repo_type: str):
                     subprocess.TimeoutExpired,
                     FileNotFoundError,
                 ) as e:
-                    PrettyOutput.print(
-                        f"放弃 '{repo_path.name}' 的更改失败: {str(e)}",
-                        OutputType.ERROR,
-                    )
+                    print(f"❌ 放弃 '{repo_path.name}' 的更改失败: {str(e)}")
                     return
             else:
-                PrettyOutput.print(
-                    f"跳过更新 '{repo_path.name}' 以保留未提交的更改。",
-                    OutputType.INFO,
-                )
+                print(f"ℹ️ 跳过更新 '{repo_path.name}' 以保留未提交的更改。")
                 return
 
         # 获取更新前的commit hash
@@ -1908,25 +2244,17 @@ def _pull_git_repo(repo_path: Path, repo_type: str):
         after_hash = after_hash_result.stdout.strip()
 
         if before_hash != after_hash:
-            PrettyOutput.print(
-                f"{repo_type}库 '{repo_path.name}' 已更新。", OutputType.SUCCESS
-            )
+            print(f"✅ {repo_type}库 '{repo_path.name}' 已更新。")
 
     except FileNotFoundError:
-        PrettyOutput.print(
-            f"git 命令未找到，跳过更新 '{repo_path.name}'。", OutputType.WARNING
-        )
+        print(f"⚠️ git 命令未找到，跳过更新 '{repo_path.name}'。")
     except subprocess.TimeoutExpired:
-        PrettyOutput.print(f"更新 '{repo_path.name}' 超时。", OutputType.ERROR)
+        print(f"❌ 更新 '{repo_path.name}' 超时。")
     except subprocess.CalledProcessError as e:
         error_message = e.stderr.strip() if e.stderr else str(e)
-        PrettyOutput.print(
-            f"更新 '{repo_path.name}' 失败: {error_message}", OutputType.ERROR
-        )
+        print(f"❌ 更新 '{repo_path.name}' 失败: {error_message}")
     except Exception as e:
-        PrettyOutput.print(
-            f"更新 '{repo_path.name}' 时发生未知错误: {str(e)}", OutputType.ERROR
-        )
+        print(f"❌ 更新 '{repo_path.name}' 时发生未知错误: {str(e)}")
 
 
 def daily_check_git_updates(repo_dirs: List[str], repo_type: str):
@@ -1959,4 +2287,4 @@ def daily_check_git_updates(repo_dirs: List[str], repo_type: str):
         try:
             last_check_file.write_text(str(time.time()))
         except IOError as e:
-            PrettyOutput.print(f"无法写入git更新检查时间戳: {e}", OutputType.WARNING)
+            print(f"⚠️ 无法写入git更新检查时间戳: {e}")