jarvis-ai-assistant 0.7.8__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_utils/utils.py

@@ -1,3 +1,6 @@
+import atexit
+import errno
+
 # -*- coding: utf-8 -*-
 import hashlib
 import json
@@ -5,27 +8,32 @@ import os
 import signal
 import subprocess
 import sys
-import time
-import atexit
-import errno
 import threading
+import time
+from datetime import date
+from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple
-from datetime import datetime, date
-
-import yaml  # type: ignore
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+import yaml
 from rich.align import Align
 from rich.console import RenderableType
 
 from jarvis import __version__
-from jarvis.jarvis_utils.config import (
-    get_data_dir,
-    get_max_big_content_size,
-    set_global_env_data,
-)
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import get_max_big_content_size
+from jarvis.jarvis_utils.config import set_global_env_data
 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.globals import get_in_chat
+from jarvis.jarvis_utils.globals import get_interrupt
+from jarvis.jarvis_utils.globals import set_interrupt
 from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_utils.output import PrettyOutput
 
 # 向后兼容：导出 get_yes_no 供外部模块引用
 get_yes_no = user_confirm
@@ -107,20 +115,19 @@ def is_editable_install() -> bool:
     """
     检测当前 Jarvis 是否以可编辑模式安装（pip/uv install -e .）。
 
-    判断顺序：
+    判断顺序（多策略并行，任意命中即认为是可编辑安装）：
     1. 读取 PEP 610 的 direct_url.json（dir_info.editable）
-    2. 兼容旧式 .egg-link 安装
+    2. 兼容旧式 .egg-link / .pth 可编辑安装
     3. 启发式回退：源码路径上游存在 .git 且不在 site-packages/dist-packages
     """
     # 优先使用 importlib.metadata 读取 distribution 的 direct_url.json
     try:
         import importlib.metadata as metadata  # Python 3.8+
     except Exception:
-        metadata = None  # type: ignore
+        # 如果importlib.metadata不可用，直接返回None，表示无法检查
+        return False
 
     def _check_direct_url() -> Optional[bool]:
-        if metadata is None:
-            return None
         candidates = ["jarvis-ai-assistant", "jarvis_ai_assistant"]
         for name in candidates:
             try:
@@ -134,10 +141,14 @@ def is_editable_install() -> bool:
                         if f.name == "direct_url.json":
                             p = Path(str(dist.locate_file(f)))
                             if p.exists():
-                                with open(p, "r", encoding="utf-8", errors="ignore") as fp:
+                                with open(
+                                    p, "r", encoding="utf-8", errors="ignore"
+                                ) as fp:
                                     info = json.load(fp)
                                 dir_info = info.get("dir_info") or {}
-                                if isinstance(dir_info, dict) and bool(dir_info.get("editable")):
+                                if isinstance(dir_info, dict) and bool(
+                                    dir_info.get("editable")
+                                ):
                                     return True
                                 # 兼容部分工具可能写入顶层 editable 字段
                                 if bool(info.get("editable")):
@@ -151,15 +162,28 @@ def is_editable_install() -> bool:
 
     res = _check_direct_url()
     if res is True:
+        # 明确标记为 editable，直接返回 True
         return True
-    if res is False:
-        # 明确不是可编辑安装
-        return False
+    # 对于 res 为 False/None 的情况，不直接下结论，继续使用后续多种兼容策略进行判断
 
-    # 兼容旧式 .egg-link 可编辑安装
+    # 兼容旧式 .egg-link / .pth 可编辑安装
     try:
         module_path = Path(__file__).resolve()
         pkg_root = module_path.parent.parent  # jarvis 包根目录
+
+        # 1) 基于 sys.path 的 .egg-link / .pth 检测（更贴近测试场景，依赖 os.path.exists）
+        import os as _os
+
+        for entry in sys.path:
+            try:
+                egg_link = Path(entry) / f"{pkg_root.name}.egg-link"
+                pth_file = Path(entry) / f"{pkg_root.name}.pth"
+                if _os.path.exists(str(egg_link)) or _os.path.exists(str(pth_file)):
+                    return True
+            except Exception:
+                continue
+
+        # 2) 兼容更通用的 .egg-link 形式（读取指向源码路径）
         for entry in sys.path:
             try:
                 p = Path(entry)
@@ -186,7 +210,9 @@ def is_editable_install() -> bool:
     try:
         parents = list(Path(__file__).resolve().parents)
         has_git = any((d / ".git").exists() for d in parents)
-        in_site = any(("site-packages" in str(d)) or ("dist-packages" in str(d)) for d in parents)
+        in_site = any(
+            ("site-packages" in str(d)) or ("dist-packages" in str(d)) for d in parents
+        )
         if has_git and not in_site:
             return True
     except Exception:
@@ -284,13 +310,17 @@ def _acquire_single_instance_lock(lock_name: str = "instance.lock") -> None:
     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}")
+            PrettyOutput.auto_print(
+                f"⚠️ 检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。\n如果确认不存在正在运行的实例，请删除锁文件后重试：{lock_path}"
+            )
             sys.exit(0)
         # 尝试移除陈旧锁
         try:
             lock_path.unlink()
         except Exception:
-            print(f"❌ 无法删除旧锁文件：{lock_path}，请手动清理后重试。")
+            PrettyOutput.auto_print(
+                f"❌ 无法删除旧锁文件：{lock_path}，请手动清理后重试。"
+            )
             sys.exit(1)
 
     # 原子创建锁文件，避免并发竞争
@@ -313,12 +343,16 @@ def _acquire_single_instance_lock(lock_name: str = "instance.lock") -> None:
         # 极端并发下再次校验
         pid = _read_lock_owner_pid(lock_path)
         if pid and _is_process_alive(pid):
-            print(f"⚠️ 检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。")
+            PrettyOutput.auto_print(
+                f"⚠️ 检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。"
+            )
             sys.exit(0)
-        print(f"❌ 锁文件已存在但可能为陈旧状态：{lock_path}，请手动删除后重试。")
+        PrettyOutput.auto_print(
+            f"❌ 锁文件已存在但可能为陈旧状态：{lock_path}，请手动删除后重试。"
+        )
         sys.exit(1)
     except Exception as e:
-        print(f"❌ 创建实例锁失败: {e}")
+        PrettyOutput.auto_print(f"❌ 创建实例锁失败: {e}")
         sys.exit(1)
 
 
@@ -328,8 +362,9 @@ def _check_pip_updates() -> bool:
     返回:
         bool: 是否执行了更新（成功更新返回True以触发重启）
     """
-    import urllib.request
     import urllib.error
+    import urllib.request
+
     from packaging import version
 
     # 检查上次检查日期
@@ -359,7 +394,9 @@ def _check_pip_updates() -> bool:
         latest_ver = version.parse(latest_version)
 
         if latest_ver > current_ver:
-            print(f"ℹ️ 检测到新版本 v{latest_version} (当前版本: v{__version__})")
+            PrettyOutput.auto_print(
+                f"ℹ️ 检测到新版本 v{latest_version} (当前版本: v{__version__})"
+            )
 
             # 检测是否在虚拟环境中
             hasattr(sys, "real_prefix") or (
@@ -368,6 +405,7 @@ def _check_pip_updates() -> bool:
 
             # 检测是否可用 uv（优先使用虚拟环境内的uv，其次PATH中的uv）
             from shutil import which as _which
+
             uv_executable: Optional[str] = None
             if sys.platform == "win32":
                 venv_uv = Path(sys.prefix) / "Scripts" / "uv.exe"
@@ -384,6 +422,7 @@ def _check_pip_updates() -> bool:
             from jarvis.jarvis_utils.utils import (
                 is_rag_installed as _is_rag_installed,
             )  # 延迟导入避免潜在循环依赖
+
             rag_installed = _is_rag_installed()
 
             # 更新命令
@@ -406,7 +445,7 @@ def _check_pip_updates() -> bool:
 
             # 自动尝试升级（失败时提供手动命令）
             try:
-                print("ℹ️ 正在自动更新 Jarvis，请稍候...")
+                PrettyOutput.auto_print("ℹ️ 正在自动更新 Jarvis，请稍候...")
                 result = subprocess.run(
                     cmd_list,
                     capture_output=True,
@@ -416,18 +455,20 @@ def _check_pip_updates() -> bool:
                     timeout=600,
                 )
                 if result.returncode == 0:
-                    print("✅ 更新成功，正在重启以应用新版本...")
+                    PrettyOutput.auto_print("✅ 更新成功，正在重启以应用新版本...")
                     # 更新检查日期，避免重复触发
                     last_check_file.write_text(today_str)
                     return True
                 else:
                     err = (result.stderr or result.stdout or "").strip()
                     if err:
-                        print(f"⚠️ 自动更新失败，错误信息（已截断）: {err[:500]}")
-                    print(f"ℹ️ 请手动执行以下命令更新: {update_cmd}")
+                        PrettyOutput.auto_print(
+                            f"⚠️ 自动更新失败，错误信息（已截断）: {err[:500]}"
+                        )
+                    PrettyOutput.auto_print(f"ℹ️ 请手动执行以下命令更新: {update_cmd}")
             except Exception:
-                print("⚠️ 自动更新出现异常，已切换为手动更新方式。")
-                print(f"ℹ️ 请手动执行以下命令更新: {update_cmd}")
+                PrettyOutput.auto_print("⚠️ 自动更新出现异常，已切换为手动更新方式。")
+                PrettyOutput.auto_print(f"ℹ️ 请手动执行以下命令更新: {update_cmd}")
 
         # 更新检查日期
         last_check_file.write_text(today_str)
@@ -469,8 +510,8 @@ def _check_jarvis_updates() -> bool:
 def _show_usage_stats(welcome_str: str) -> None:
     """显示Jarvis使用统计信息"""
     try:
-
-        from rich.console import Console, Group
+        from rich.console import Console
+        from rich.console import Group
         from rich.panel import Panel
         from rich.table import Table
         from rich.text import Text
@@ -496,7 +537,7 @@ def _show_usage_stats(welcome_str: str) -> None:
 
         # 复用存储实例，避免重复创建
         storage = StatsStorage()
-        
+
         # 一次性读取元数据，避免重复读取
         try:
             meta = storage._load_json(storage.meta_file)
@@ -525,7 +566,7 @@ def _show_usage_stats(welcome_str: str) -> None:
         for metric in all_metrics:
             # 从批量读取的数据中获取总量
             total = metric_totals.get(metric, 0.0)
-            
+
             if not total or total <= 0:
                 continue
 
@@ -569,138 +610,75 @@ def _show_usage_stats(welcome_str: str) -> None:
         # 如果有 generated，则计算采纳率
         if generated_commits > 0:
             adoption_rate = (accepted_commits / generated_commits) * 100
-            categorized_stats["adoption"]["metrics"][
-                "adoption_rate"
-            ] = f"{adoption_rate:.1f}%"
-            categorized_stats["adoption"]["metrics"][
-                "commits_status"
-            ] = f"{accepted_commits}/{generated_commits}"
-
-        # 构建输出
-        has_data = False
-        stats_output = []
-
-        for category, data in categorized_stats.items():
-            if data["metrics"]:
-                has_data = True
-                stats_output.append((data["title"], data["metrics"], data["suffix"]))
-
-        # 显示统计信息
-        if has_data:
-            # 1. 创建统计表格
-            from rich import box
-
-            table = Table(
-                show_header=True,
-                header_style="bold magenta",
-                title_justify="center",
-                box=box.ROUNDED,
-                padding=(0, 1),
+            categorized_stats["adoption"]["metrics"]["adoption_rate"] = (
+                f"{adoption_rate:.1f}%"
+            )
+            categorized_stats["adoption"]["metrics"]["commits_status"] = (
+                f"{accepted_commits}/{generated_commits}"
             )
-            table.add_column("分类", style="cyan", no_wrap=True, width=12)
-            table.add_column("指标", style="white", width=20)
-            table.add_column("数量", style="green", justify="right", width=10)
-            table.add_column("分类", style="cyan", no_wrap=True, width=12)
-            table.add_column("指标", style="white", width=20)
-            table.add_column("数量", style="green", justify="right", width=10)
-
-            # 收集所有要显示的数据
-            all_rows = []
-            for title, stats, suffix in stats_output:
-                if stats:
-                    sorted_stats = sorted(
-                        stats.items(), key=lambda item: item[1], reverse=True
-                    )
-                    for i, (metric, count) in enumerate(sorted_stats):
-                        display_name = metric.replace("_", " ").title()
-                        category_title = title if i == 0 else ""
-                        # 处理不同类型的count值
-                        if isinstance(count, (int, float)):
-                            count_str = f"{count:,} {suffix}"
-                        else:
-                            # 对于字符串类型的count（如百分比或比率），直接使用
-                            count_str = str(count)
-                        all_rows.append((category_title, display_name, count_str))
-
-            # 以3行2列的方式添加数据
-            has_content = len(all_rows) > 0
-            # 计算需要多少行来显示所有数据
-            total_rows = len(all_rows)
-            rows_needed = (total_rows + 1) // 2  # 向上取整，因为是2列布局
-
-            for i in range(rows_needed):
-                left_idx = i
-                right_idx = i + rows_needed
-
-                if left_idx < len(all_rows):
-                    left_row = all_rows[left_idx]
-                else:
-                    left_row = ("", "", "")
-
-                if right_idx < len(all_rows):
-                    right_row = all_rows[right_idx]
-                else:
-                    right_row = ("", "", "")
-
-                table.add_row(
-                    left_row[0],
-                    left_row[1],
-                    left_row[2],
-                    right_row[0],
-                    right_row[1],
-                    right_row[2],
-                )
 
-            # 2. 创建总结面板
-            summary_content = []
+        # 右侧内容：总体表现 + 使命与愿景
+        right_column_items = []
+        summary_content: list[str] = []
+        from rich import box
+
+        # 计算总体表现的摘要数据
+        # 总结统计
+        total_tools = sum(
+            count
+            for _, stats in categorized_stats["tool"]["metrics"].items()
+            for metric, count in {
+                k: v
+                for k, v in categorized_stats["tool"]["metrics"].items()
+                if isinstance(v, (int, float))
+            }.items()
+        )
+        total_tools = sum(
+            count
+            for metric, count in categorized_stats["tool"]["metrics"].items()
+            if isinstance(count, (int, float))
+        )
 
-            # 总结统计
-            total_tools = sum(
-                count
-                for title, stats, _ in stats_output
-                if "工具" in title
-                for metric, count in stats.items()
-            )
-            total_changes = sum(
-                count
-                for title, stats, _ in stats_output
-                if "代码修改" in title
-                for metric, count in stats.items()
-            )
+        total_changes = sum(
+            count
+            for metric, count in categorized_stats["code"]["metrics"].items()
+            if isinstance(count, (int, float))
+        )
 
-            # 统计代码行数
-            lines_stats = categorized_stats["lines"]["metrics"]
-            total_lines_added = lines_stats.get(
-                "code_lines_inserted", lines_stats.get("code_lines_added", 0)
-            )
-            total_lines_deleted = lines_stats.get("code_lines_deleted", 0)
-            total_lines_modified = total_lines_added + total_lines_deleted
-
-            if total_tools > 0 or total_changes > 0 or total_lines_modified > 0:
-                parts = []
-                if total_tools > 0:
-                    parts.append(f"工具调用 {total_tools:,} 次")
-                if total_changes > 0:
-                    parts.append(f"代码修改 {total_changes:,} 次")
-                if total_lines_modified > 0:
-                    parts.append(f"修改代码行数 {total_lines_modified:,} 行")
-
-                if parts:
-                    summary_content.append(f"📈 总计: {', '.join(parts)}")
-
-                # 添加代码采纳率显示
-                adoption_metrics = categorized_stats["adoption"]["metrics"]
-                if "adoption_rate" in adoption_metrics:
-                    summary_content.append(
-                        f"✅ 代码采纳率: {adoption_metrics['adoption_rate']}"
-                    )
+        # 统计代码行数
+        lines_stats = categorized_stats["lines"]["metrics"]
+        total_lines_added = lines_stats.get(
+            "code_lines_inserted", lines_stats.get("code_lines_added", 0)
+        )
+        total_lines_deleted = lines_stats.get("code_lines_deleted", 0)
+        total_lines_modified = total_lines_added + total_lines_deleted
+
+        # 构建总体表现内容
+        if total_tools > 0 or total_changes > 0 or total_lines_modified > 0:
+            parts = []
+            if total_tools > 0:
+                parts.append(f"工具调用 {total_tools:,} 次")
+            if total_changes > 0:
+                parts.append(f"代码修改 {total_changes:,} 次")
+            if total_lines_modified > 0:
+                parts.append(f"修改代码行数 {total_lines_modified:,} 行")
+
+            if parts:
+                summary_content.append(f"📈 总计: {', '.join(parts)}")
+
+            # 添加代码采纳率显示
+            adoption_metrics = categorized_stats["adoption"]["metrics"]
+            if "adoption_rate" in adoption_metrics:
+                summary_content.append(
+                    f"✅ 代码采纳率: {adoption_metrics['adoption_rate']}"
+                )
 
             # 计算节省的时间
-            time_saved_seconds = 0
+            time_saved_seconds: float = 0.0
             tool_stats = categorized_stats["tool"]["metrics"]
             code_agent_changes = categorized_stats["code"]["metrics"]
             lines_stats = categorized_stats["lines"]["metrics"]
-            # commit_stats is already defined above
+            commit_stats = categorized_stats["commit"]["metrics"]
             command_stats = categorized_stats["command"]["metrics"]
 
             # 统一的工具使用时间估算（每次调用节省2分钟）
@@ -708,23 +686,37 @@ def _show_usage_stats(welcome_str: str) -> None:
 
             # 计算所有工具的时间节省
             for tool_name, count in tool_stats.items():
-                time_saved_seconds += count * DEFAULT_TOOL_TIME_SAVINGS
+                if isinstance(count, (int, float)):
+                    time_saved_seconds += count * DEFAULT_TOOL_TIME_SAVINGS
 
             # 其他类型的时间计算
-            total_code_agent_calls = sum(code_agent_changes.values())
+            total_code_agent_calls: float = float(
+                sum(
+                    v
+                    for v in code_agent_changes.values()
+                    if isinstance(v, (int, float))
+                )
+            )
             time_saved_seconds += total_code_agent_calls * 10 * 60
             time_saved_seconds += lines_stats.get("code_lines_added", 0) * 0.8 * 60
             time_saved_seconds += lines_stats.get("code_lines_deleted", 0) * 0.2 * 60
-            time_saved_seconds += sum(commit_stats.values()) * 10 * 60
-            time_saved_seconds += sum(command_stats.values()) * 1 * 60
+            time_saved_seconds += (
+                sum(v for v in commit_stats.values() if isinstance(v, (int, float)))
+                * 10
+                * 60
+            )
+            time_saved_seconds += (
+                sum(v for v in command_stats.values() if isinstance(v, (int, float)))
+                * 1
+                * 60
+            )
 
-            time_str = ""
-            hours = 0
             if time_saved_seconds > 0:
                 total_minutes = int(time_saved_seconds / 60)
                 seconds = int(time_saved_seconds % 60)
                 hours = total_minutes // 60
                 minutes = total_minutes % 60
+
                 # 只显示小时和分钟
                 if hours > 0:
                     time_str = f"{hours} 小时 {minutes} 分钟"
@@ -733,21 +725,17 @@ def _show_usage_stats(welcome_str: str) -> None:
                 else:
                     time_str = f"{seconds} 秒"
 
-                if summary_content:
-                    summary_content.append("")  # Add a separator line
                 summary_content.append(f"⏱️  节省时间: 约 {time_str}")
 
-                encouragement = ""
-                # 计算各级时间单位
-                total_work_days = hours // 8  # 总工作日数
-                work_years = total_work_days // 240  # 每年约240个工作日
+                # 计算时间节省的鼓励信息
+                total_work_days = hours // 8
+                work_years = total_work_days // 240
                 remaining_days_after_years = total_work_days % 240
-                work_months = remaining_days_after_years // 20  # 每月约20个工作日
+                work_months = remaining_days_after_years // 20
                 remaining_days_after_months = remaining_days_after_years % 20
                 work_days = remaining_days_after_months
-                remaining_hours = int(hours % 8)  # 剩余不足一个工作日的小时数
+                remaining_hours = int(hours % 8)
 
-                # 构建时间描述
                 time_parts = []
                 if work_years > 0:
                     time_parts.append(f"{work_years} 年")
@@ -778,18 +766,13 @@ def _show_usage_stats(welcome_str: str) -> None:
                         )
                 elif hours >= 1:
                     encouragement = f"⭐ 相当于节省了 {int(hours)} 小时的工作时间，积少成多，继续保持！"
+
                 if encouragement:
                     summary_content.append(encouragement)
 
-            # 3. 组合并打印
-            from rich import box
-
-            # 右侧内容：总体表现 + 使命与愿景
-            right_column_items = []
-
-            # 欢迎信息 Panel
-            if welcome_str:
-                jarvis_ascii_art_str = """
+        # 欢迎信息 Panel
+        if welcome_str:
+            jarvis_ascii_art_str = """
    ██╗ █████╗ ██████╗ ██╗   ██╗██╗███████╗
    ██║██╔══██╗██╔══██╗██║   ██║██║██╔════╝
    ██║███████║██████╔╝██║   ██║██║███████╗
@@ -797,108 +780,189 @@ def _show_usage_stats(welcome_str: str) -> None:
 ╚████║██║  ██║██║  ██║ ╚████╔╝ ██║███████║
  ╚═══╝╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚══════╝"""
 
-                welcome_panel_content = Group(
-                    Align.center(Text(jarvis_ascii_art_str, style="bold blue")),
-                    Align.center(Text(welcome_str, style="bold")),
-                    "",  # for a blank line
-                    Align.center(Text(f"v{__version__}")),
-                    Align.center(Text("https://github.com/skyfireitdiy/Jarvis")),
-                )
-
-                welcome_panel = Panel(
-                    welcome_panel_content, border_style="yellow", expand=True
-                )
-                right_column_items.append(welcome_panel)
-            if summary_content:
-                summary_panel = Panel(
-                    Text("\n".join(summary_content), justify="left"),
-                    title="✨ 总体表现 ✨",
-                    title_align="center",
-                    border_style="green",
-                    expand=True,
-                )
-                right_column_items.append(summary_panel)
-
-            # 愿景 Panel
-            vision_text = Text(
-                "让开发者与AI成为共生伙伴",
-                justify="center",
-                style="italic",
+            welcome_panel_content = Group(
+                Align.center(Text(jarvis_ascii_art_str, style="bold blue")),
+                Align.center(Text(welcome_str, style="bold")),
+                "",  # for a blank line
+                Align.center(Text(f"v{__version__}")),
+                Align.center(Text("https://github.com/skyfireitdiy/Jarvis")),
             )
-            vision_panel = Panel(
-                vision_text,
-                title="🔭 愿景 (Vision) 🔭",
-                title_align="center",
-                border_style="cyan",
-                expand=True,
+
+            welcome_panel = Panel(
+                welcome_panel_content, border_style="yellow", expand=True
             )
-            right_column_items.append(vision_panel)
+            right_column_items.append(welcome_panel)
+
+        # 总体表现 Panel
+        summary_panel = Panel(
+            Text(
+                "\n".join(summary_content) if summary_content else "暂无数据",
+                justify="left",
+            ),
+            title="✨ 总体表现 ✨",
+            title_align="center",
+            border_style="green",
+            expand=True,
+        )
+        right_column_items.append(summary_panel)
 
-            # 使命 Panel
-            mission_text = Text(
-                "让灵感高效落地为代码与行动",
-                justify="center",
-                style="italic",
+        # 愿景 Panel
+        vision_text = Text(
+            "让开发者与AI成为共生伙伴",
+            justify="center",
+            style="italic",
+        )
+        vision_panel = Panel(
+            vision_text,
+            title="🔭 愿景 (Vision) 🔭",
+            title_align="center",
+            border_style="cyan",
+            expand=True,
+        )
+        right_column_items.append(vision_panel)
+
+        # 使命 Panel
+        mission_text = Text(
+            "让灵感高效落地为代码与行动",
+            justify="center",
+            style="italic",
+        )
+        mission_panel = Panel(
+            mission_text,
+            title="🎯 使命 (Mission) 🎯",
+            title_align="center",
+            border_style="magenta",
+            expand=True,
+        )
+        right_column_items.append(mission_panel)
+
+        # 创建左右两列的内容组
+        left_column_items = []
+        right_column_items = []
+
+        # 左侧：欢迎Logo和基本信息
+        if welcome_str:
+            jarvis_ascii_art_str = """
+   ██╗ █████╗ ██████╗ ██╗   ██╗██╗███████╗
+   ██║██╔══██╗██╔══██╗██║   ██║██║██╔════╝
+   ██║███████║██████╔╝██║   ██║██║███████╗
+██╗██║██╔══██║██╔══██╗╚██╗ ██╔╝██║╚════██║
+╚████║██║  ██║██║  ██║ ╚████╔╝ ██║███████║
+ ╚═══╝╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚══════╝"""
+
+            welcome_content = Group(
+                Align.center(Text(jarvis_ascii_art_str, style="bold blue")),
+                Align.center(Text(welcome_str, style="bold")),
+                "",  # for a blank line
+                Align.center(Text(f"v{__version__}")),
+                Align.center(Text("https://github.com/skyfireitdiy/Jarvis")),
             )
-            mission_panel = Panel(
-                mission_text,
-                title="🎯 使命 (Mission) 🎯",
-                title_align="center",
-                border_style="magenta",
+
+            welcome_panel = Panel(
+                welcome_content,
+                title="🤖 Jarvis AI Assistant",
+                border_style="yellow",
                 expand=True,
             )
-            right_column_items.append(mission_panel)
+            left_column_items.append(welcome_panel)
+
+        # 右侧：总体表现、愿景和使命
+        # 总体表现 Panel
+        summary_panel = Panel(
+            Text(
+                "\n".join(summary_content) if summary_content else "暂无数据",
+                justify="left",
+            ),
+            title="✨ 总体表现 ✨",
+            title_align="center",
+            border_style="green",
+            expand=True,
+        )
+        right_column_items.append(summary_panel)
 
-            right_column_group = Group(*right_column_items)
+        # 愿景 Panel
+        vision_text = Text(
+            "让开发者与AI成为共生伙伴",
+            justify="center",
+            style="italic",
+        )
+        vision_panel = Panel(
+            vision_text,
+            title="🔭 愿景 (Vision) 🔭",
+            title_align="center",
+            border_style="cyan",
+            expand=True,
+        )
+        right_column_items.append(vision_panel)
 
-            layout_renderable: RenderableType
+        # 使命 Panel
+        mission_text = Text(
+            "让灵感高效落地为代码与行动",
+            justify="center",
+            style="italic",
+        )
+        mission_panel = Panel(
+            mission_text,
+            title="🎯 使命 (Mission) 🎯",
+            title_align="center",
+            border_style="magenta",
+            expand=True,
+        )
+        right_column_items.append(mission_panel)
 
-            if console.width < 200:
-                # 上下布局
-                layout_items: List[RenderableType] = []
-                layout_items.append(right_column_group)
-                if has_content:
-                    layout_items.append(Align.center(table))
-                layout_renderable = Group(*layout_items)
-            else:
-                # 左右布局（当前）
-                layout_table = Table(
-                    show_header=False,
-                    box=None,
-                    padding=0,
-                    expand=True,
-                    pad_edge=False,
-                )
-                # 左右布局，左侧为总结信息，右侧为统计表格
-                layout_table.add_column(ratio=5)  # 左侧
-                layout_table.add_column(ratio=5)  # 右侧
+        left_column_group = Group(*left_column_items) if left_column_items else None
+        right_column_group = Group(*right_column_items)
 
-                if has_content:
-                    # 将总结信息放在左侧，统计表格放在右侧（表格居中显示）
-                    layout_table.add_row(right_column_group, Align.center(table))
-                else:
-                    # 如果没有统计数据，则总结信息占满
-                    layout_table.add_row(right_column_group)
-                layout_renderable = layout_table
-
-            # 打印最终的布局
-            if has_content or summary_content:
-                # 将整体布局封装在一个最终的Panel中，以提供整体边框
-                final_panel = Panel(
-                    layout_renderable,
-                    title="Jarvis AI Assistant",
-                    title_align="center",
-                    border_style="blue",
-                    box=box.HEAVY,
-                    padding=(0, 1),
-                )
-                console.print(final_panel)
+        layout_renderable: RenderableType
+
+        if console.width < 200:
+            # 上下布局（窄屏）
+            layout_items: List[RenderableType] = []
+            if left_column_group:
+                layout_items.append(left_column_group)
+            layout_items.append(right_column_group)
+            layout_renderable = Group(*layout_items)
+        else:
+            # 左右布局（宽屏）
+            layout_table = Table(
+                show_header=False,
+                box=None,
+                padding=(0, 2),  # 上下0，左右2字符的内边距
+                expand=True,
+                pad_edge=False,
+            )
+            # 左右布局，优化比例：左侧更紧凑，右侧更宽敞
+            if left_column_group:
+                layout_table.add_column(
+                    ratio=35, min_width=40
+                )  # 左侧欢迎信息，最小宽度40
+                layout_table.add_column(
+                    ratio=65, min_width=80
+                )  # 右侧统计信息，最小宽度80
+                layout_table.add_row(left_column_group, right_column_group)
+            else:
+                # 如果没有欢迎信息，右侧占满
+                layout_table.add_column(ratio=100)
+                layout_table.add_row(right_column_group)
+            layout_renderable = layout_table
+
+        # 打印最终的布局
+        # 将整体布局封装在一个最终的Panel中，以提供整体边框
+        final_panel = Panel(
+            layout_renderable,
+            title="Jarvis AI Assistant",
+            title_align="center",
+            border_style="blue",
+            box=box.HEAVY,
+            padding=(0, 1),
+        )
+        console.print(final_panel)
     except Exception as e:
         # 输出错误信息以便调试
         import traceback
 
-        print(f"❌ 统计显示出错: {str(e)}")
-        print(f"❌ {traceback.format_exc()}")
+        PrettyOutput.auto_print(f"❌ 统计显示出错: {str(e)}")
+        PrettyOutput.auto_print(f"❌ {traceback.format_exc()}")
 
 
 def init_env(welcome_str: str = "", config_file: Optional[str] = None) -> None:
@@ -910,10 +974,12 @@ def init_env(welcome_str: str = "", config_file: Optional[str] = None) -> None:
     """
     # 0. 检查是否处于Jarvis打开的终端环境，避免嵌套
     try:
-        if os.environ.get("JARVIS_TERMINAL") == "1":
-            print("⚠️ 检测到当前终端由 Jarvis 打开。再次启动可能导致嵌套。")
+        if os.environ.get("terminal") == "1":
+            PrettyOutput.auto_print(
+                "⚠️ 检测到当前终端由 Jarvis 打开。再次启动可能导致嵌套。"
+            )
             if not user_confirm("是否仍要继续启动 Jarvis？", default=False):
-                print("ℹ️ 已取消启动以避免终端嵌套。")
+                PrettyOutput.auto_print("ℹ️ 已取消启动以避免终端嵌套。")
                 sys.exit(0)
     except Exception:
         pass
@@ -946,11 +1012,13 @@ def init_env(welcome_str: str = "", config_file: Optional[str] = None) -> None:
         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:
@@ -970,31 +1038,41 @@ def init_env(welcome_str: str = "", config_file: Optional[str] = None) -> None:
 def _interactive_config_setup(config_file_path: Path):
     """交互式配置引导"""
     from jarvis.jarvis_platform.registry import PlatformRegistry
-    from jarvis.jarvis_utils.input import (
-        get_choice,
-        get_single_line_input as get_input,
-        user_confirm as get_yes_no,
-    )
+    from jarvis.jarvis_utils.input import get_choice
+    from jarvis.jarvis_utils.input import get_single_line_input as get_input
+    from jarvis.jarvis_utils.input import user_confirm as get_yes_no
 
-    print("ℹ️ 欢迎使用 Jarvis！未找到配置文件，现在开始引导配置。")
+    PrettyOutput.auto_print("ℹ️ 欢迎使用 Jarvis！未找到配置文件，现在开始引导配置。")
 
     # 1. 选择平台
     registry = PlatformRegistry.get_global_platform_registry()
     platforms = registry.get_available_platforms()
     platform_name = get_choice("请选择您要使用的AI平台", platforms)
 
-    # 2. 配置环境变量
+    # 2. 配置 API 密钥等信息（用于 llm_config）
     platform_class = registry.platforms.get(platform_name)
     if not platform_class:
-        print(f"❌ 平台 '{platform_name}' 加载失败。")
+        PrettyOutput.auto_print(f"❌ 平台 '{platform_name}' 加载失败。")
         sys.exit(1)
 
     env_vars = {}
+    llm_config = {}
     required_keys = platform_class.get_required_env_keys()
     defaults = platform_class.get_env_defaults()
     config_guide = platform_class.get_env_config_guide()
+
+    # 环境变量到 llm_config 键名的映射
+    env_to_llm_config_map = {
+        "OPENAI_API_KEY": "openai_api_key",
+        "OPENAI_API_BASE": "openai_api_base",
+        "OPENAI_EXTRA_HEADERS": "openai_extra_headers",
+        "KIMI_API_KEY": "kimi_api_key",
+        "TONGYI_COOKIES": "tongyi_cookies",
+        "YUANBAO_COOKIES": "yuanbao_cookies",
+    }
+
     if required_keys:
-        print(f"ℹ️ 请输入 {platform_name} 平台所需的配置信息:")
+        PrettyOutput.auto_print(f"ℹ️ 请输入 {platform_name} 平台所需的配置信息:")
 
         # 如果有配置指导，先显示总体说明
         if config_guide:
@@ -1005,7 +1083,7 @@ def _interactive_config_setup(config_file_path: Path):
                     guide_lines.append("")
                     guide_lines.append(f"{key} 获取方法:")
                     guide_lines.append(str(config_guide[key]))
-            print("ℹ️ " + "\n".join(guide_lines))
+            PrettyOutput.auto_print("ℹ️ " + "\n".join(guide_lines))
         else:
             # 若无指导，仍需遍历以保持后续逻辑一致
             pass
@@ -1023,11 +1101,19 @@ def _interactive_config_setup(config_file_path: Path):
             env_vars[key] = value
             os.environ[key] = value  # 立即设置环境变量以便后续测试
 
+            # 同时添加到 llm_config（如果存在映射）
+            llm_config_key = env_to_llm_config_map.get(key)
+            if llm_config_key:
+                llm_config[llm_config_key] = value
+
     # 3. 选择模型
     try:
-        platform_instance = registry.create_platform(platform_name)
+        # 创建平台实例时传递 llm_config（如果已收集）
+        platform_instance = registry.create_platform(
+            platform_name, llm_config=llm_config if llm_config else None
+        )
         if not platform_instance:
-            print(f"❌ 无法创建平台 '{platform_name}'。")
+            PrettyOutput.auto_print(f"❌ 无法创建平台 '{platform_name}'。")
             sys.exit(1)
 
         model_list_tuples = platform_instance.get_model_list()
@@ -1039,43 +1125,79 @@ def _interactive_config_setup(config_file_path: Path):
         model_name, _ = model_list_tuples[selected_index]
 
     except Exception:
-        print("❌ 获取模型列表失败")
+        PrettyOutput.auto_print("❌ 获取模型列表失败")
         if not get_yes_no("无法获取模型列表，是否继续配置？"):
             sys.exit(1)
         model_name = get_input("请输入模型名称:")
 
     # 4. 测试配置
-    print("ℹ️ 正在测试配置...")
+    PrettyOutput.auto_print("ℹ️ 正在测试配置...")
     test_passed = False
     try:
-        platform_instance = registry.create_platform(platform_name)
+        # 创建平台实例时传递 llm_config（如果已收集）
+        platform_instance = registry.create_platform(
+            platform_name, llm_config=llm_config if llm_config else None
+        )
         if platform_instance:
             platform_instance.set_model_name(model_name)
             response_generator = platform_instance.chat("hello")
             response = "".join(response_generator)
             if response:
-                print(f"✅ 测试成功，模型响应: {response}")
+                PrettyOutput.auto_print(f"✅ 测试成功，模型响应: {response}")
                 test_passed = True
             else:
-                print("❌ 测试失败，模型没有响应。")
+                PrettyOutput.auto_print("❌ 测试失败，模型没有响应。")
         else:
-            print("❌ 测试失败，无法创建平台实例。")
+            PrettyOutput.auto_print("❌ 测试失败，无法创建平台实例。")
+    except Exception:
+        PrettyOutput.auto_print("❌ 测试失败")
+
+    # 5. 询问最大输入 token 数量
+    max_input_token_count = 32000
+    try:
+        max_input_token_str = get_input(
+            "请输入最大输入 token 数量（留空使用默认: 32000）:",
+            default="32000",
+        )
+        if max_input_token_str and max_input_token_str.strip():
+            max_input_token_count = int(max_input_token_str.strip())
     except Exception:
-        print("❌ 测试失败")
+        pass
+
+    # 6. 生成 LLM 配置名称
+    llm_name = f"{platform_name}-{model_name}".replace(" ", "-").lower()
+    # 清理名称，只保留字母、数字和连字符
+    import re
+
+    llm_name = re.sub(r"[^a-z0-9-]", "", llm_name)
+    if not llm_name:
+        llm_name = "default-llm"
 
-    # 5. 交互式确认并应用配置（不直接生成配置文件）
+    # 7. 交互式确认并应用配置（使用新的引用方式）
     config_data = {
         "ENV": env_vars,
-        "JARVIS_PLATFORM": platform_name,
-        "JARVIS_MODEL": model_name,
+        "llms": {
+            llm_name: {
+                "platform": platform_name,
+                "model": model_name,
+                "max_input_token_count": max_input_token_count,
+                "llm_config": llm_config if llm_config else {},
+            }
+        },
+        "llm_groups": {
+            "default": {
+                "normal_llm": llm_name,
+            }
+        },
+        "llm_group": "default",
     }
 
     if not test_passed:
         if not get_yes_no("配置测试失败，是否仍要应用该配置并继续？", default=False):
-            print("ℹ️ 已取消配置。")
+            PrettyOutput.auto_print("ℹ️ 已取消配置。")
             sys.exit(0)
 
-    # 6. 选择其他功能开关与可选项（复用统一逻辑）
+    # 8. 选择其他功能开关与可选项（复用统一逻辑）
     _collect_optional_config_interactively(config_data)
 
     # 7. 应用到当前会话并写入配置文件（基于交互结果，不从默认值生成）
@@ -1095,11 +1217,11 @@ def _interactive_config_setup(config_file_path: Path):
             if header:
                 f.write(header)
             f.write(yaml_str)
-        print(f"✅ 配置文件已生成: {config_file_path}")
-        print("ℹ️ 配置完成，请重新启动Jarvis。")
+        PrettyOutput.auto_print(f"✅ 配置文件已生成: {config_file_path}")
+        PrettyOutput.auto_print("ℹ️ 配置完成，请重新启动Jarvis。")
         sys.exit(0)
     except Exception:
-        print("❌ 写入配置文件失败")
+        PrettyOutput.auto_print("❌ 写入配置文件失败")
         sys.exit(1)
 
 
@@ -1122,8 +1244,6 @@ def load_config():
         _load_and_process_config(str(config_file_path.parent), str(config_file_path))
 
 
-
-
 def _load_config_file(config_file: str) -> Tuple[str, dict]:
     """读取并解析YAML格式的配置文件
 
@@ -1177,12 +1297,15 @@ def _process_env_variables(config_data: dict) -> None:
         )
 
 
-def _ask_config_bool(config_data: dict, ask_all: bool, _key: str, _tip: str, _default: bool) -> bool:
+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:
@@ -1193,12 +1316,15 @@ def _ask_config_bool(config_data: dict, ask_all: bool, _key: str, _tip: str, _de
         return False
 
 
-def _ask_config_str(config_data: dict, ask_all: bool, _key: str, _tip: str, _default: str = "") -> bool:
+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()
@@ -1210,15 +1336,18 @@ def _ask_config_str(config_data: dict, ask_all: bool, _key: str, _tip: str, _def
         return False
 
 
-def _ask_config_optional_str(config_data: dict, ask_all: bool, _key: str, _tip: str, _default: str = "") -> bool:
+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:
+        if not val:
             return False
         s = str(val).strip()
         if s == "" or s == cur:
@@ -1229,12 +1358,15 @@ def _ask_config_optional_str(config_data: dict, ask_all: bool, _key: str, _tip:
         return False
 
 
-def _ask_config_int(config_data: dict, ask_all: bool, _key: str, _tip: str, _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()
@@ -1258,13 +1390,14 @@ def _ask_config_list(config_data: dict, ask_all: bool, _key: str, _tip: str) ->
         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:
+        if not val:
             return False
         s = str(val).strip()
         if s == cur_display.strip():
@@ -1283,18 +1416,26 @@ def _ask_config_list(config_data: dict, ask_all: bool, _key: str, _tip: str) ->
 def _collect_basic_switches(config_data: dict, ask_all: bool) -> bool:
     """收集基础开关配置"""
     changed = False
-    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
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "enable_git_jca_switch",
+            "是否在检测到Git仓库时，提示并可自动切换到代码开发模式（jca）？",
+            True,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "enable_startup_config_selector",
+            "在进入默认通用代理前，是否先列出可用配置（agent/multi_agent/roles）供选择？",
+            True,
+        )
+        or changed
+    )
     return changed
 
 
@@ -1303,130 +1444,213 @@ def _collect_ui_experience_config(config_data: dict, ask_all: bool) -> bool:
     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
+
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "pretty_output",
+            "是否启用更美观的终端输出（Pretty Output）？",
+            _default_pretty,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "print_prompt",
+            "是否打印发送给模型的提示词（Prompt）？",
+            False,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "immediate_abort",
+            "是否启用立即中断？\n- 选择 是/true：在对话输出流的每次迭代中检测到用户中断（例如 Ctrl+C）时，立即返回当前已生成的内容并停止继续输出。\n- 选择 否/false：不会在输出过程中立刻返回，而是按既有流程处理（不中途打断输出）。",
+            False,
+        )
+        or changed
+    )
+
+    # Diff 可视化模式配置
+    if ask_all or "diff_visualization_mode" not in config_data:
+        from jarvis.jarvis_utils.input import get_choice
+
+        current_mode = config_data.get("diff_visualization_mode", "side_by_side")
+        diff_mode_choices = [
+            f"side_by_side - 左右分栏对比显示{'（当前）' if current_mode == 'side_by_side' else ''}",
+            f"unified - 统一diff格式{'（当前）' if current_mode == 'unified' else ''}",
+            f"syntax - 语法高亮模式{'（当前）' if current_mode == 'syntax' else ''}",
+            f"compact - 紧凑模式{'（当前）' if current_mode == 'compact' else ''}",
+        ]
+        selected_display = get_choice("选择 Diff 可视化模式", diff_mode_choices)
+        selected_mode = selected_display.split(" - ")[0]
+        if selected_mode != current_mode:
+            config_data["diff_visualization_mode"] = selected_mode
+            changed = True
+
     return 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
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "enable_static_analysis",
+            "是否启用静态代码分析（Static Analysis）？",
+            True,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "enable_build_validation",
+            "是否启用构建验证（Build Validation）？在代码编辑后自动验证代码能否成功编译/构建。",
+            True,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "build_validation_timeout",
+            "构建验证的超时时间（秒，默认30秒）",
+            30,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "enable_impact_analysis",
+            "是否启用编辑影响范围分析（Impact Analysis）？分析代码编辑的影响范围，识别可能受影响的文件、函数、测试等。",
+            True,
+        )
+        or changed
+    )
     return 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
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "use_methodology",
+            "是否启用方法论系统（Methodology）？",
+            True,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "use_analysis",
+            "是否启用分析流程（Analysis）？",
+            True,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "force_save_memory",
+            "是否强制保存会话记忆？",
+            False,
+        )
+        or changed
+    )
     return changed
 
 
 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
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "save_session_history",
+            "是否保存会话记录？",
+            False,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "print_error_traceback",
+            "是否在错误输出时打印回溯调用链？",
+            False,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "skip_predefined_tasks",
+            "是否跳过预定义任务加载（不读取 pre-command 列表）？",
+            False,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "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
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "execute_tool_confirm",
+            "执行工具前是否需要确认？",
+            False,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "confirm_before_apply_patch",
+            "应用补丁前是否需要确认？",
+            False,
+        )
+        or changed
+    )
     return changed
 
 
@@ -1434,186 +1658,283 @@ 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
+
+    changed = (
+        _ask_config_optional_str(
+            config_data,
+            ask_all,
+            "data_path",
+            f"是否自定义数据目录路径(data_path)？留空使用默认: {_get_data_dir()}",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "max_input_token_count",
+            "自定义最大输入Token数量（留空使用默认: 128000）",
+            128000,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "cheap_max_input_token_count",
+            "廉价模型的最大输入Token数量（留空或0表示使用max_input_token_count）",
+            0,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "smart_max_input_token_count",
+            "智能模型的最大输入Token数量（留空或0表示使用max_input_token_count）",
+            0,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "tool_filter_threshold",
+            "设置AI工具筛选阈值 (当可用工具数超过此值时触发AI筛选, 默认30)",
+            30,
+        )
+        or changed
+    )
     return 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
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "script_execution_timeout",
+            "脚本执行超时时间（秒，默认300，仅非交互模式生效）",
+            300,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_int(
+            config_data,
+            ask_all,
+            "addon_prompt_threshold",
+            "附加提示的触发阈值（字符数，默认1024）。当消息长度超过此值时，会自动添加默认的附加提示",
+            1024,
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_bool(
+            config_data,
+            ask_all,
+            "enable_intent_recognition",
+            "是否启用意图识别功能？用于智能上下文推荐中的LLM意图提取和语义分析",
+            True,
+        )
+        or changed
+    )
     return changed
 
 
 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
+    changed = (
+        _ask_config_list(
+            config_data,
+            ask_all,
+            "tool_load_dirs",
+            "指定工具加载目录（逗号分隔，留空跳过）：",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_list(
+            config_data,
+            ask_all,
+            "methodology_dirs",
+            "指定方法论加载目录（逗号分隔，留空跳过）：",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_list(
+            config_data,
+            ask_all,
+            "agent_definition_dirs",
+            "指定 agent 定义加载目录（逗号分隔，留空跳过）：",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_list(
+            config_data,
+            ask_all,
+            "multi_agent_dirs",
+            "指定 multi_agent 加载目录（逗号分隔，留空跳过）：",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_list(
+            config_data,
+            ask_all,
+            "roles_dirs",
+            "指定 roles 加载目录（逗号分隔，留空跳过）：",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_list(
+            config_data,
+            ask_all,
+            "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
+    changed = (
+        _ask_config_optional_str(
+            config_data,
+            ask_all,
+            "web_search_platform",
+            "配置 Web 搜索平台名称（留空跳过）：",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_optional_str(
+            config_data,
+            ask_all,
+            "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"
-            "            适用于您希望绕过检查并自行管理仓库状态的场景。"
-        )
-        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
+    changed = (
+        _ask_config_optional_str(
+            config_data,
+            ask_all,
+            "git_commit_prompt",
+            "自定义 Git 提交提示模板（留空跳过）：",
+        )
+        or changed
+    )
     return changed
 
 
 def _collect_rag_config(config_data: dict, ask_all: bool) -> bool:
-    """收集RAG配置"""
+    """收集RAG配置（使用新的引用方式）"""
     changed = False
     try:
         from jarvis.jarvis_utils.config import (
             get_rag_embedding_model as _get_rag_embedding_model,
+        )
+        from jarvis.jarvis_utils.config import (
             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
-        
+        from jarvis.jarvis_utils.input import (
+            get_single_line_input as get_single_line_input_func,
+        )
+        from jarvis.jarvis_utils.input import user_confirm as get_yes_no_func
+
         rag_default_embed = _get_rag_embedding_model()
         rag_default_rerank = _get_rag_rerank_model()
+        get_yes_no_var: Optional[Any] = get_yes_no_func
+        get_single_line_input_var: Optional[Any] = get_single_line_input_func
     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
-    
+        get_yes_no_var = None
+        get_single_line_input_var = None
+
     try:
-        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(
+        if (
+            "rag_groups" not in config_data
+            and get_yes_no_var is not None
+            and get_single_line_input_var is not None
+        ):
+            if get_yes_no_var("是否配置 RAG 检索增强参数？", default=False):
+                # 初始化 embeddings 和 rerankers（如果不存在）
+                if "embeddings" not in config_data:
+                    config_data["embeddings"] = {}
+                if "rerankers" not in config_data:
+                    config_data["rerankers"] = {}
+                if "rag_groups" not in config_data:
+                    config_data["rag_groups"] = {}
+
+                # 收集嵌入模型配置
+                emb = get_single_line_input_var(
                     f"RAG 嵌入模型（留空使用默认: {rag_default_embed}）：",
                     default="",
                 ).strip()
-                rerank = get_single_line_input(
+                if not emb:
+                    emb = rag_default_embed
+
+                # 创建嵌入模型配置
+                embedding_name = "default-rag-embedding"
+                config_data["embeddings"][embedding_name] = {
+                    "embedding_model": emb,
+                    "embedding_type": "LocalEmbeddingModel",
+                    "embedding_max_length": 512,
+                }
+
+                # 收集重排模型配置
+                rerank = get_single_line_input_var(
                     f"RAG rerank 模型（留空使用默认: {rag_default_rerank}）：",
                     default="",
                 ).strip()
-                use_bm25 = get_yes_no("RAG 是否使用 BM25？", default=True)
-                use_rerank = get_yes_no("RAG 是否使用 rerank？", default=True)
-                if emb:
-                    rag_conf["embedding_model"] = emb
+                if get_yes_no_var is not None:
+                    use_bm25 = get_yes_no_var("RAG 是否使用 BM25？", default=True)
+                    use_rerank = get_yes_no_var("RAG 是否使用 rerank？", default=True)
                 else:
-                    rag_conf["embedding_model"] = rag_default_embed
-                if rerank:
-                    rag_conf["rerank_model"] = rerank
-                else:
-                    rag_conf["rerank_model"] = rag_default_rerank
-                rag_conf["use_bm25"] = bool(use_bm25)
-                rag_conf["use_rerank"] = bool(use_rerank)
-                config_data["JARVIS_RAG"] = rag_conf
+                    use_bm25 = True
+                    use_rerank = True
+
+                # 创建重排模型配置（如果使用 rerank）
+                rag_group_config = {
+                    "embedding": embedding_name,
+                    "use_bm25": bool(use_bm25),
+                    "use_rerank": bool(use_rerank),
+                }
+
+                if use_rerank:
+                    if not rerank:
+                        rerank = rag_default_rerank
+                    reranker_name = "default-rag-reranker"
+                    config_data["rerankers"][reranker_name] = {
+                        "rerank_model": rerank,
+                        "reranker_type": "LocalReranker",
+                        "reranker_max_length": 512,
+                    }
+                    rag_group_config["reranker"] = reranker_name
+
+                # 创建 rag_groups 配置（对象格式）
+                config_data["rag_groups"]["default"] = rag_group_config
+                config_data["rag_group"] = "default"
                 changed = True
     except Exception:
         pass
@@ -1623,18 +1944,26 @@ def _collect_rag_config(config_data: dict, ask_all: bool) -> bool:
 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
+    changed = (
+        _ask_config_str(
+            config_data,
+            ask_all,
+            "central_methodology_repo",
+            "请输入中心方法论仓库路径或Git地址（可留空跳过）：",
+            "",
+        )
+        or changed
+    )
+    changed = (
+        _ask_config_str(
+            config_data,
+            ask_all,
+            "central_tool_repo",
+            "请输入中心工具仓库路径或Git地址（可留空跳过）：",
+            "",
+        )
+        or changed
+    )
     return changed
 
 
@@ -1643,13 +1972,18 @@ def _collect_shell_config(config_data: dict, ask_all: bool) -> bool:
     changed = False
     try:
         import os
+
         default_shell = os.getenv("SHELL", "/bin/bash")
-        changed = _ask_config_optional_str(
-            config_data, ask_all,
-            "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
@@ -1668,7 +2002,7 @@ def _collect_optional_config_interactively(
         bool: 是否有变更
     """
     changed = False
-    
+
     # 收集各类配置
     changed = _collect_basic_switches(config_data, ask_all) or changed
     changed = _collect_ui_experience_config(config_data, ask_all) or changed
@@ -1684,7 +2018,7 @@ def _collect_optional_config_interactively(
     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
 
 
@@ -1739,13 +2073,15 @@ def _load_and_process_config(jarvis_dir: str, config_file: str) -> None:
             # 更新全局配置
             set_global_env_data(config_data)
     except Exception:
-        print("❌ 加载配置文件失败")
+        PrettyOutput.auto_print("❌ 加载配置文件失败")
         if get_yes_no("配置文件格式错误，是否删除并重新配置？"):
             try:
                 os.remove(config_file)
-                print("✅ 已删除损坏的配置文件，请重启Jarvis以重新配置。")
+                PrettyOutput.auto_print(
+                    "✅ 已删除损坏的配置文件，请重启Jarvis以重新配置。"
+                )
             except Exception:
-                print("❌ 删除配置文件失败")
+                PrettyOutput.auto_print("❌ 删除配置文件失败")
         sys.exit(1)
 
 
@@ -1874,35 +2210,43 @@ def _read_old_config_file(config_file):
             if "=" in line and not line.startswith((" ", "\t")):
                 # 处理之前收集的多行值
                 if current_key is not None:
-                    value = "\n".join(current_value).strip().strip("'").strip('"')
+                    processed_value = (
+                        "\n".join(current_value).strip().strip("'").strip('"')
+                    )
                     # 将字符串"true"/"false"转换为bool类型
-                    if value.lower() == "true":
-                        value = True
-                    elif value.lower() == "false":
-                        value = False
-                    config_data[current_key] = value
+                    if processed_value.lower() == "true":
+                        final_value = True
+                    elif processed_value.lower() == "false":
+                        final_value = False
+                    else:
+                        final_value = processed_value  # type: ignore[assignment]
+                    config_data[current_key] = final_value
                     current_value = []
                     # 解析新的键值对
-                key, value = line.split("=", 1)
-                current_key = key.strip()
-                current_value.append(value.strip())
+                key_part, value_part = line.split("=", 1)
+                current_key = key_part.strip()
+                current_value.append(value_part.strip())
             elif current_key is not None:
                 # 多行值的后续行
                 current_value.append(line.strip())
                 # 处理最后一个键值对
         if current_key is not None:
-            value = "\n".join(current_value).strip().strip("'").strip('"')
+            processed_value = "\n".join(current_value).strip().strip("'").strip('"')
             # 将字符串"true"/"false"转换为bool类型
-            if value.lower() == "true":
-                value = True
-            elif value.lower() == "false":
-                value = False
-            config_data[current_key] = value
+            if processed_value.lower() == "true":
+                final_value = True
+            elif processed_value.lower() == "false":
+                final_value = False
+            else:
+                final_value = processed_value  # type: ignore[assignment]
+            config_data[current_key] = final_value
         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)
-    print("⚠️ 检测到旧格式配置文件，旧格式以后将不再支持，请尽快迁移到新格式")
+    PrettyOutput.auto_print(
+        "⚠️ 检测到旧格式配置文件，旧格式以后将不再支持，请尽快迁移到新格式"
+    )
 
 
 # 线程本地存储，用于共享重试计数器
@@ -1911,17 +2255,17 @@ _retry_context = threading.local()
 
 def _get_retry_count() -> int:
     """获取当前线程的重试计数"""
-    if not hasattr(_retry_context, 'count'):
+    if not hasattr(_retry_context, "count"):
         _retry_context.count = 0
-    return _retry_context.count
+    return int(_retry_context.count)
 
 
 def _increment_retry_count() -> int:
     """增加重试计数并返回新的计数值"""
-    if not hasattr(_retry_context, 'count'):
+    if not hasattr(_retry_context, "count"):
         _retry_context.count = 0
     _retry_context.count += 1
-    return _retry_context.count
+    return int(_retry_context.count)
 
 
 def _reset_retry_count():
@@ -1943,7 +2287,7 @@ def while_success(func: Callable[[], Any]) -> Any:
     """
     MAX_RETRIES = 6
     result: Any = None
-    
+
     while True:
         try:
             result = func()
@@ -1955,10 +2299,14 @@ def while_success(func: Callable[[], Any]) -> Any:
                 # 指数退避：第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...")
+                    PrettyOutput.auto_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})")
+                    PrettyOutput.auto_print(
+                        f"⚠️ 发生异常:\n{e}\n已达到最大重试次数 ({retry_count}/{MAX_RETRIES})"
+                    )
                     _reset_retry_count()
                     raise
             else:
@@ -1983,7 +2331,7 @@ def while_true(func: Callable[[], bool]) -> Any:
     """
     MAX_RETRIES = 6
     ret: bool = False
-    
+
     while True:
         try:
             ret = func()
@@ -1994,16 +2342,20 @@ def while_true(func: Callable[[], bool]) -> Any:
             # 异常直接抛出，不捕获
             _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...")
+                PrettyOutput.auto_print(
+                    f"⚠️ 返回空值，重试中 ({retry_count}/{MAX_RETRIES})，等待 {sleep_time}s..."
+                )
                 time.sleep(sleep_time)
             else:
-                print(f"⚠️ 返回空值，已达到最大重试次数 ({retry_count}/{MAX_RETRIES})")
+                PrettyOutput.auto_print(
+                    f"⚠️ 返回空值，已达到最大重试次数 ({retry_count}/{MAX_RETRIES})"
+                )
                 _reset_retry_count()
                 break
         else:
@@ -2024,7 +2376,7 @@ def get_file_md5(filepath: str) -> str:
     # 采用流式读取，避免一次性加载100MB到内存
     h = hashlib.md5()
     max_bytes = 100 * 1024 * 1024  # 与原实现保持一致：仅读取前100MB
-    buf_size = 8 * 1024 * 1024     # 8MB缓冲
+    buf_size = 8 * 1024 * 1024  # 8MB缓冲
     read_bytes = 0
     with open(filepath, "rb") as f:
         while read_bytes < max_bytes:
@@ -2056,8 +2408,9 @@ def get_file_line_count(filename: str) -> int:
 
 def count_cmd_usage() -> None:
     """统计当前命令的使用次数"""
-    import sys
     import os
+    import sys
+
     from jarvis.jarvis_stats.stats import StatsManager
 
     # 从完整路径中提取命令名称
@@ -2075,17 +2428,17 @@ def count_cmd_usage() -> None:
 
 
 def is_context_overflow(
-    content: str, 
+    content: str,
     model_group_override: Optional[str] = None,
-    platform: Optional[Any] = None
+    platform: Optional[Any] = None,
 ) -> bool:
     """判断文件内容是否超出上下文限制
-    
+
     参数:
         content: 要检查的内容
         model_group_override: 模型组覆盖（可选）
         platform: 平台实例（可选），如果提供则使用剩余token数量判断
-        
+
     返回:
         bool: 如果内容超出上下文限制返回True
     """
@@ -2093,21 +2446,21 @@ def is_context_overflow(
     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:
@@ -2118,9 +2471,11 @@ def is_context_overflow(
                 return content_tokens > threshold
         except Exception:
             pass
-    
+
     # 回退方案：使用输入窗口限制
     return content_tokens > get_max_big_content_size(model_group_override)
+
+
 def get_loc_stats() -> str:
     """使用loc命令获取当前目录的代码统计信息
 
@@ -2188,10 +2543,14 @@ def _pull_git_repo(repo_path: Path, repo_type: str):
                     subprocess.TimeoutExpired,
                     FileNotFoundError,
                 ) as e:
-                    print(f"❌ 放弃 '{repo_path.name}' 的更改失败: {str(e)}")
+                    PrettyOutput.auto_print(
+                        f"❌ 放弃 '{repo_path.name}' 的更改失败: {str(e)}"
+                    )
                     return
             else:
-                print(f"ℹ️ 跳过更新 '{repo_path.name}' 以保留未提交的更改。")
+                PrettyOutput.auto_print(
+                    f"ℹ️ 跳过更新 '{repo_path.name}' 以保留未提交的更改。"
+                )
                 return
 
         # 获取更新前的commit hash
@@ -2244,17 +2603,17 @@ def _pull_git_repo(repo_path: Path, repo_type: str):
         after_hash = after_hash_result.stdout.strip()
 
         if before_hash != after_hash:
-            print(f"✅ {repo_type}库 '{repo_path.name}' 已更新。")
+            PrettyOutput.auto_print(f"✅ {repo_type}库 '{repo_path.name}' 已更新。")
 
     except FileNotFoundError:
-        print(f"⚠️ git 命令未找到，跳过更新 '{repo_path.name}'。")
+        PrettyOutput.auto_print(f"⚠️ git 命令未找到，跳过更新 '{repo_path.name}'。")
     except subprocess.TimeoutExpired:
-        print(f"❌ 更新 '{repo_path.name}' 超时。")
+        PrettyOutput.auto_print(f"❌ 更新 '{repo_path.name}' 超时。")
     except subprocess.CalledProcessError as e:
         error_message = e.stderr.strip() if e.stderr else str(e)
-        print(f"❌ 更新 '{repo_path.name}' 失败: {error_message}")
+        PrettyOutput.auto_print(f"❌ 更新 '{repo_path.name}' 失败: {error_message}")
     except Exception as e:
-        print(f"❌ 更新 '{repo_path.name}' 时发生未知错误: {str(e)}")
+        PrettyOutput.auto_print(f"❌ 更新 '{repo_path.name}' 时发生未知错误: {str(e)}")
 
 
 def daily_check_git_updates(repo_dirs: List[str], repo_type: str):
@@ -2279,7 +2638,6 @@ def daily_check_git_updates(repo_dirs: List[str], repo_type: str):
             pass
 
     if should_check_for_updates:
-
         for repo_dir in repo_dirs:
             p_repo_dir = Path(repo_dir)
             if p_repo_dir.exists() and p_repo_dir.is_dir():
@@ -2287,4 +2645,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:
-            print(f"⚠️ 无法写入git更新检查时间戳: {e}")
+            PrettyOutput.auto_print(f"⚠️ 无法写入git更新检查时间戳: {e}")