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

jarvis/jarvis_utils/utils.py

@@ -8,6 +8,7 @@ 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
@@ -25,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
@@ -284,20 +284,13 @@ 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):
-            PrettyOutput.print(
-                f"检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。\n"
-                f"如果确认不存在正在运行的实例，请删除锁文件后重试：{lock_path}",
-                OutputType.WARNING,
-            )
+            print(f"⚠️ 检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。\n如果确认不存在正在运行的实例，请删除锁文件后重试：{lock_path}")
             sys.exit(0)
         # 尝试移除陈旧锁
         try:
             lock_path.unlink()
         except Exception:
-            PrettyOutput.print(
-                f"无法删除旧锁文件：{lock_path}，请手动清理后重试。",
-                OutputType.ERROR,
-            )
+            print(f"❌ 无法删除旧锁文件：{lock_path}，请手动清理后重试。")
             sys.exit(1)
 
     # 原子创建锁文件，避免并发竞争
@@ -320,18 +313,12 @@ 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):
-            PrettyOutput.print(
-                f"检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。",
-                OutputType.WARNING,
-            )
+            print(f"⚠️ 检测到已有一个 Jarvis 实例正在运行 (PID: {pid})。")
             sys.exit(0)
-        PrettyOutput.print(
-            f"锁文件已存在但可能为陈旧状态：{lock_path}，请手动删除后重试。",
-            OutputType.ERROR,
-        )
+        print(f"❌ 锁文件已存在但可能为陈旧状态：{lock_path}，请手动删除后重试。")
         sys.exit(1)
     except Exception as e:
-        PrettyOutput.print(f"创建实例锁失败: {e}", OutputType.ERROR)
+        print(f"❌ 创建实例锁失败: {e}")
         sys.exit(1)
 
 
@@ -364,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
 
         # 比较版本
@@ -372,10 +359,7 @@ 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__})")
 
             # 检测是否在虚拟环境中
             hasattr(sys, "real_prefix") or (
@@ -422,7 +406,7 @@ def _check_pip_updates() -> bool:
 
             # 自动尝试升级（失败时提供手动命令）
             try:
-                PrettyOutput.print("正在自动更新 Jarvis，请稍候...", OutputType.INFO)
+                print("ℹ️ 正在自动更新 Jarvis，请稍候...")
                 result = subprocess.run(
                     cmd_list,
                     capture_output=True,
@@ -432,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)
@@ -491,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
@@ -503,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()
@@ -518,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)
@@ -893,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环境
 
     参数:
@@ -907,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):
@@ -947,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()
@@ -959,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 = {}
@@ -967,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:
@@ -980,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
@@ -1002,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()
@@ -1014,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)
@@ -1029,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 = {
@@ -1049,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. 选择其他功能开关与可选项（复用统一逻辑）
@@ -1072,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)
 
 
@@ -1380,6 +1403,12 @@ def _collect_session_config(config_data: dict, ask_all: bool) -> bool:
         "是否跳过预定义任务加载（不读取 pre-command 列表）？",
         False,
     ) or changed
+    changed = _ask_config_int(
+        config_data, ask_all,
+        "JARVIS_CONVERSATION_TURN_THRESHOLD",
+        "对话轮次阈值（达到此轮次时触发总结，建议50-100）：",
+        50,
+    ) or changed
     return changed
 
 
@@ -1425,33 +1454,9 @@ def _collect_data_and_token_config(config_data: dict, ask_all: bool) -> bool:
     return changed
 
 
-def _collect_planning_config(config_data: dict, ask_all: bool) -> bool:
-    """收集规划相关配置"""
-    changed = False
-    changed = _ask_config_bool(
-        config_data, ask_all,
-        "JARVIS_PLAN_ENABLED",
-        "是否默认启用任务规划？当 Agent 初始化时 plan 参数未指定，将从此配置加载",
-        True,
-    ) or changed
-    changed = _ask_config_int(
-        config_data, ask_all,
-        "JARVIS_PLAN_MAX_DEPTH",
-        "任务规划的最大层数（限制递归拆分深度，默认2；仅在启用规划时生效）",
-        2,
-    ) 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_AUTO_SUMMARY_ROUNDS",
-        "基于对话轮次的自动总结阈值（达到该轮次后自动总结并清理历史，默认50）",
-        50,
-    ) or changed
     changed = _ask_config_int(
         config_data, ask_all,
         "JARVIS_SCRIPT_EXECUTION_TIMEOUT",
@@ -1553,37 +1558,10 @@ def _ask_git_check_mode(config_data: dict, ask_all: bool) -> bool:
         return False
 
 
-def _ask_patch_format_mode(config_data: dict, ask_all: bool) -> bool:
-    """询问补丁格式模式"""
-    try:
-        _key = "JARVIS_PATCH_FORMAT"
-        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_patch_format
-        current_mode = config_data.get(_key, get_patch_format())
-        choices = ["all", "search", "search_range"]
-        tip = (
-            "请选择补丁格式处理模式 (JARVIS_PATCH_FORMAT):\n"
-            "该设置影响 edit_file_handler 在处理补丁时允许的匹配方式。\n"
-            "  - all: 同时支持 SEARCH 与 SEARCH_START/SEARCH_END 两种模式（默认）。\n"
-            "  - search: 仅允许精确片段匹配（SEARCH）。更稳定，适合较弱模型或严格控制改动。\n"
-            "  - search_range: 仅允许范围匹配（SEARCH_START/SEARCH_END）。更灵活，适合较强模型和块内细粒度修改。"
-        )
-        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_patch_format_mode(config_data, ask_all) or changed
     changed = _ask_config_optional_str(
         config_data, ask_all,
         "JARVIS_GIT_COMMIT_PROMPT",
@@ -1699,7 +1677,6 @@ def _collect_optional_config_interactively(
     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_planning_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
@@ -1762,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)
 
 
@@ -1927,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 while_success(func: Callable[[], Any], sleep_time: float = 0.1, max_retries: int = 5) -> Any:
+
+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]) -> 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 as e:
-            retry_count += 1
-            if retry_count < max_retries:
-                PrettyOutput.print(
-                    f"发生异常:\n{e}\n重试中 ({retry_count}/{max_retries})，等待 {sleep_time}s...",
-                    OutputType.WARNING,
-                )
-                time.sleep(sleep_time)
-            continue
+            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
 
 
@@ -2056,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命令获取当前目录的代码统计信息
 
@@ -2131,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
@@ -2193,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):
@@ -2244,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}")