jarvis-ai-assistant 0.1.207__py3-none-any.whl → 0.1.209__py3-none-any.whl

jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.207"
+__version__ = "0.1.209"

jarvis/jarvis_agent/__init__.py

@@ -7,27 +7,30 @@ import platform
 from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Union
 
 # 第三方库导入
-from yaspin import yaspin  # type: ignore
 
 # 本地库导入
 # jarvis_agent 相关
 # jarvis_platform 相关
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
+
 # jarvis_utils 相关
-from jarvis.jarvis_utils.config import (get_data_dir, get_max_token_count,
-                                        get_max_tool_call_count,
-                                        is_auto_complete,
-                                        is_execute_tool_confirm,
-                                        is_use_analysis, get_history_count, is_use_methodology)
+from jarvis.jarvis_utils.config import (
+    get_max_token_count,
+    is_execute_tool_confirm,
+    is_use_analysis,
+    is_use_methodology,
+)
 from jarvis.jarvis_utils.embedding import get_context_token_count
-from jarvis.jarvis_utils.globals import (delete_agent, get_interrupt,
-                                         make_agent_name, set_agent,
-                                         set_interrupt)
+from jarvis.jarvis_utils.globals import (
+    delete_agent,
+    get_interrupt,
+    make_agent_name,
+    set_agent,
+    set_interrupt,
+)
 from jarvis.jarvis_utils.input import get_multiline_input
-from jarvis.jarvis_utils.jarvis_history import JarvisHistory
-from jarvis.jarvis_utils.methodology import (load_methodology,
-                                             upload_methodology)
+from jarvis.jarvis_utils.methodology import load_methodology, upload_methodology
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import user_confirm
@@ -139,7 +142,7 @@ class Agent:
         self.prompt = ""
 
     def __del__(self):
-        self.history.stop_record()
+        # 只有在记录启动时才停止记录
         delete_agent(self.name)
 
     def __init__(
@@ -150,7 +153,7 @@ class Agent:
         platform: Union[Optional[BasePlatform], Optional[str]] = None,
         model_name: Optional[str] = None,
         summary_prompt: Optional[str] = None,
-        auto_complete: Optional[bool] = None,
+        auto_complete: bool = False,
         output_handler: List[OutputHandlerProtocol] = [],
         use_tools: List[str] = [],
         input_handler: Optional[List[Callable[[str, Any], Tuple[str, bool]]]] = None,
@@ -160,7 +163,6 @@ class Agent:
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
         files: List[str] = [],
-        history_count: Optional[int] = None,
     ):
         self.files = files
         """初始化Jarvis Agent实例
@@ -235,17 +237,8 @@ class Agent:
         # Load configuration from environment variables
         self.addon_prompt = ""
 
-        self.tool_call_count = 0
-        self.max_tool_call_count = get_max_tool_call_count()
         self.after_tool_call_cb: Optional[Callable[[Agent], None]] = None
 
-        self.history = JarvisHistory()
-        self.history_dir = str(Path(get_data_dir())/"history")
-        self.history.start_record(self.history_dir)
-
-        self.history_count = history_count if history_count is not None else get_history_count()
-
-
         self.execute_tool_confirm = (
             execute_tool_confirm
             if execute_tool_confirm is not None
@@ -274,9 +267,7 @@ class Agent:
         )
 
         self.max_token_count = get_max_token_count()
-        self.auto_complete = (
-            auto_complete if auto_complete is not None else is_auto_complete()
-        )
+        self.auto_complete = auto_complete
         welcome_message = f"{name} 初始化完成 - 使用 {self.model.name()} 模型"
 
         PrettyOutput.print(welcome_message, OutputType.SYSTEM)
@@ -407,10 +398,10 @@ class Agent:
         if self.conversation_length > self.max_token_count:
             message = self._summarize_and_clear_history() + "\n\n" + message
             self.conversation_length += get_context_token_count(message)
-        self.history.append_msg("user", message)
+
         response = self.model.chat_until_success(message)  # type: ignore
         self.conversation_length += get_context_token_count(response)
-        self.history.append_msg("assistant", response)
+
         return response
 
     def generate_summary(self) -> str:
@@ -422,8 +413,8 @@ class Agent:
         注意:
             仅生成摘要，不修改对话状态
         """
-        with yaspin(text="正在总结对话历史...", color="cyan") as spinner:
-            summary_prompt = """
+        print("📄 正在总结对话历史...")
+        summary_prompt = """
 <summary_request>
 <objective>
 请对当前对话历史进行简明扼要的总结，提取关键信息和重要决策点。这个总结将作为上下文继续任务，因此需要保留对后续对话至关重要的内容。
@@ -447,14 +438,11 @@ class Agent:
 """
 
         try:
-            with spinner.hidden():
-                summary = self.model.chat_until_success(self.prompt + "\n" + summary_prompt)  # type: ignore
-            spinner.text = "总结对话历史完成"
-            spinner.ok("✅")
+            summary = self.model.chat_until_success(self.prompt + "\n" + summary_prompt)  # type: ignore
+            print("✅ 总结对话历史完成")
             return summary
         except Exception as e:
-            spinner.text = "总结对话历史失败"
-            spinner.fail("❌")
+            print("❌ 总结对话历史失败")
             return ""
 
     def _summarize_and_clear_history(self) -> str:
@@ -482,9 +470,9 @@ class Agent:
                 summary = self.generate_summary()
             else:
                 import tempfile
+
                 tmp_file = tempfile.NamedTemporaryFile(delete=False)
                 tmp_file_name = tmp_file.name
-                self.history.save_history(tmp_file_name)
             self.clear_history()  # type: ignore
 
             if need_summary:
@@ -540,32 +528,16 @@ class Agent:
             )
         if len(tool_list) == 0:
             return False, ""
-        if (
-            self.max_tool_call_count > 0
-            and self.tool_call_count >= self.max_tool_call_count
-        ):
-            if user_confirm(f"工具调用次数超过限制，是否继续执行？", True):
-                self.reset_tool_call_count()
-            else:
-                return False, ""
-        if self.execute_tool_confirm:
-            self.reset_tool_call_count()
+
         if not self.execute_tool_confirm or user_confirm(
             f"需要执行{tool_list[0].name()}确认执行？", True
         ):
-            with yaspin(
-                text=f"正在执行{tool_list[0].name()}...", color="cyan"
-            ) as spinner:
-                with spinner.hidden():
-                    result = tool_list[0].handle(response, self)
-                spinner.text = f"{tool_list[0].name()}执行完成"
-                spinner.ok("✅")
-                self.tool_call_count += 1
-                return result
-        return False, ""
+            print(f"🔧 正在执行{tool_list[0].name()}...")
+            result = tool_list[0].handle(response, self)
+            print(f"✅ {tool_list[0].name()}执行完成")
 
-    def reset_tool_call_count(self):
-        self.tool_call_count = 0
+            return result
+        return False, ""
 
     def _complete_task(self) -> str:
         """完成任务并生成总结(如果需要)
@@ -581,21 +553,19 @@ class Agent:
         if self.use_analysis:
             self._analysis_task()
         if self.need_summary:
-            with yaspin(text="正在生成总结...", color="cyan") as spinner:
-                self.prompt = self.summary_prompt
-                with spinner.hidden():
-                    ret = self.model.chat_until_success(self.prompt)  # type: ignore
-                    spinner.text = "总结生成完成"
-                    spinner.ok("✅")
-                    return ret
+            print("📄 正在生成总结...")
+            self.prompt = self.summary_prompt
+            ret = self.model.chat_until_success(self.prompt)  # type: ignore
+            print("✅ 总结生成完成")
+            return ret
 
         return "任务完成"
 
     def _analysis_task(self):
-        with yaspin(text="正在分析任务...", color="cyan") as spinner:
-            try:
-                # 让模型判断是否需要生成方法论
-                analysis_prompt = f"""<task_analysis>
+        print("🔍 正在分析任务...")
+        try:
+            # 让模型判断是否需要生成方法论
+            analysis_prompt = f"""<task_analysis>
 <request>
 当前任务已结束，请分析该任务的解决方案：
 1. 首先检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
@@ -741,17 +711,12 @@ arguments:
 </output_requirements>
 </task_analysis>"""
 
-                self.prompt = analysis_prompt
-                with spinner.hidden():
-                    response = self.model.chat_until_success(self.prompt)  # type: ignore
-
-                with spinner.hidden():
-                    self._call_tools(response)
-                spinner.text = "分析完成"
-                spinner.ok("✅")
-            except Exception as e:
-                spinner.text = "分析失败"
-                spinner.fail("❌")
+            self.prompt = analysis_prompt
+            response = self.model.chat_until_success(self.prompt)  # type: ignore
+            self._call_tools(response)
+            print("✅ 分析完成")
+        except Exception as e:
+            print("❌ 分析失败")
 
     def make_default_addon_prompt(self, need_complete: bool) -> str:
         """生成附加提示。
@@ -808,9 +773,8 @@ arguments:
             set_agent(self.name, self)
 
             while True:
-                history_md = ""
                 if self.first:
-                    history_md = self._first_run()
+                    self._first_run()
                 try:
                     current_response = self._call_model(self.prompt, True)
                     self.prompt = ""
@@ -822,8 +786,13 @@ arguments:
                         )
                         if user_input:
                             # 如果有工具调用且用户确认继续，则将干预信息和工具执行结果拼接为prompt
-                            if any(handler.can_handle(current_response) for handler in self.output_handler):
-                                if user_confirm("检测到有工具调用，是否继续处理工具调用？", True):
+                            if any(
+                                handler.can_handle(current_response)
+                                for handler in self.output_handler
+                            ):
+                                if user_confirm(
+                                    "检测到有工具调用，是否继续处理工具调用？", True
+                                ):
                                     self.prompt = f"{user_input}\n\n{current_response}"
                                     continue
                             self.prompt += f"{user_input}"
@@ -843,8 +812,6 @@ arguments:
                     if self.auto_complete and ot("!!!COMPLETE!!!") in current_response:
                         return self._complete_task()
 
-                    self.reset_tool_call_count()
-
                     # 获取用户输入
                     user_input = self.multiline_inputer(
                         f"{self.name}: 请输入，或输入空行来结束当前任务："
@@ -858,8 +825,6 @@ arguments:
                         return self._complete_task()
 
                 except Exception as e:
-                    if history_md:
-                        os.remove(history_md)
                     PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
                     return f"Task failed: {str(e)}"
 
@@ -868,21 +833,15 @@ arguments:
             return f"Task failed: {str(e)}"
 
     def _first_run(self):
-        history_md = ""
-        if self.history_count > 0 and self.model and self.model.support_upload_files():
-            import tempfile
-            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-            history_md = str(Path(tempfile.gettempdir())/f"{self.name}_history_{timestamp}.md")
-            self.history.export_history_to_markdown(self.history_dir, history_md, max_files=self.history_count)
-            self.files.append(history_md)
-
-                        # 如果有上传文件，先上传文件
+        # 如果有上传文件，先上传文件
         if self.model and self.model.support_upload_files():
             if self.use_methodology:
                 if not upload_methodology(self.model, other_files=self.files):
                     if self.files:
-                        PrettyOutput.print("文件上传失败，将忽略文件列表", OutputType.WARNING)
-                                    # 上传失败则回退到本地加载
+                        PrettyOutput.print(
+                            "文件上传失败，将忽略文件列表", OutputType.WARNING
+                        )
+                        # 上传失败则回退到本地加载
                     msg = self.prompt
                     for handler in self.input_handler:
                         msg, _ = handler(msg, self)
@@ -894,7 +853,9 @@ arguments:
                         self.prompt = f"{self.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
             elif self.files:
                 if not self.model.upload_files(self.files):
-                    PrettyOutput.print("文件上传失败，将忽略文件列表", OutputType.WARNING)
+                    PrettyOutput.print(
+                        "文件上传失败，将忽略文件列表", OutputType.WARNING
+                    )
                 else:
                     self.prompt = f"{self.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
         else:
@@ -907,7 +868,6 @@ arguments:
                 self.prompt = f"{self.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
 
         self.first = False
-        return history_md
 
     def clear_history(self):
         """清空对话历史但保留系统提示

jarvis/jarvis_agent/edit_file_handler.py

@@ -2,9 +2,6 @@ import os
 import re
 from typing import Any, Dict, List, Tuple
 
-from yaspin import yaspin  # type: ignore
-from yaspin.core import Yaspin  # type: ignore
-
 from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.git_utils import revert_file
@@ -71,19 +68,19 @@ class EditFileHandler(OutputHandler):
                 {"SEARCH": diff["SEARCH"], "REPLACE": diff["REPLACE"]} for diff in diffs
             ]
 
-            with yaspin(text=f"正在处理文件 {file_path}...", color="cyan") as spinner:
-                # 首先尝试fast_edit模式
-                success, result = self._fast_edit(file_path, file_patches, spinner)
-                if not success:
-                    # 如果fast_edit失败，尝试slow_edit模式
-                    success, result = EditFileHandler._slow_edit(
-                        file_path, file_patches, spinner, agent
-                    )
+            print(f"📝 正在处理文件 {file_path}...")
+            # 首先尝试fast_edit模式
+            success, result = self._fast_edit(file_path, file_patches)
+            if not success:
+                # 如果fast_edit失败，尝试slow_edit模式
+                success, result = EditFileHandler._slow_edit(
+                    file_path, file_patches, agent
+                )
 
-                if success:
-                    results.append(f"✅ 文件 {file_path} 修改成功")
-                else:
-                    results.append(f"❌ 文件 {file_path} 修改失败: {result}")
+            if success:
+                results.append(f"✅ 文件 {file_path} 修改成功")
+            else:
+                results.append(f"❌ 文件 {file_path} 修改失败: {result}")
 
         summary = "\n".join(results)
         return False, summary
@@ -153,10 +150,11 @@ class EditFileHandler(OutputHandler):
             file_path = match.group(1) or match.group(2) or match.group(3)
             diffs = []
             for diff_match in self.diff_pattern.finditer(match.group(0)):
+                # 完全保留原始格式（包括所有空白和换行）
                 diffs.append(
                     {
-                        "SEARCH": diff_match.group(1).strip(),
-                        "REPLACE": diff_match.group(2).strip(),
+                        "SEARCH": diff_match.group(1),  # 原始SEARCH内容
+                        "REPLACE": diff_match.group(2),  # 原始REPLACE内容
                     }
                 )
             if diffs:
@@ -167,9 +165,7 @@ class EditFileHandler(OutputHandler):
         return patches
 
     @staticmethod
-    def _fast_edit(
-        file_path: str, patches: List[Dict[str, str]], spinner: Yaspin
-    ) -> Tuple[bool, str]:
+    def _fast_edit(file_path: str, patches: List[Dict[str, str]]) -> Tuple[bool, str]:
         """快速应用补丁到文件
 
         该方法直接尝试将补丁应用到目标文件，适用于简单、明确的修改场景。
@@ -182,7 +178,6 @@ class EditFileHandler(OutputHandler):
         Args:
             file_path: 要修改的文件路径，支持绝对路径和相对路径
             patches: 补丁列表，每个补丁包含search(搜索文本)和replace(替换文本)
-            spinner: 进度显示对象，用于显示处理状态和结果
 
         Returns:
             Tuple[bool, str]:
@@ -207,17 +202,22 @@ class EditFileHandler(OutputHandler):
                 replace_text = patch["REPLACE"]
                 patch_count += 1
 
-                if search_text in modified_content:
-                    if modified_content.count(search_text) > 1:
+                # 精确匹配搜索文本（保留原始换行和空格）
+                exact_search = search_text
+
+                if exact_search in modified_content:
+                    if modified_content.count(exact_search) > 1:
                         PrettyOutput.print(
-                            f"搜索文本在文件中存在多处匹配：\n{search_text}",
+                            f"搜索文本在文件中存在多处匹配：\n{exact_search}",
                             output_type=OutputType.WARNING,
                         )
-                        return False, f"搜索文本在文件中存在多处匹配：\n{search_text}"
+                        return False, f"搜索文本在文件中存在多处匹配：\n{exact_search}"
+
+                    # 直接执行替换（保留所有原始格式）
                     modified_content = modified_content.replace(
-                        search_text, replace_text
+                        exact_search, replace_text
                     )
-                    spinner.write(f"✅ 补丁 #{patch_count} 应用成功")
+                    print(f"✅ 补丁 #{patch_count} 应用成功")
                 else:
                     # 尝试增加缩进重试
                     found = False
@@ -243,7 +243,7 @@ class EditFileHandler(OutputHandler):
                             modified_content = modified_content.replace(
                                 indented_search, indented_replace
                             )
-                            spinner.write(
+                            print(
                                 f"✅ 补丁 #{patch_count} 应用成功 (自动增加 {space_count} 个空格缩进)"
                             )
                             found = True
@@ -260,19 +260,17 @@ class EditFileHandler(OutputHandler):
             with open(file_path, "w", encoding="utf-8") as f:
                 f.write(modified_content)
 
-            spinner.text = f"文件 {file_path} 修改完成，应用了 {patch_count} 个补丁"
-            spinner.ok("✅")
+            print(f"✅ 文件 {file_path} 修改完成，应用了 {patch_count} 个补丁")
             return True, modified_content
 
         except Exception as e:
-            spinner.text = f"文件修改失败: {str(e)}"
-            spinner.fail("❌")
+            print(f"❌ 文件修改失败: {str(e)}")
             revert_file(file_path)
             return False, f"文件修改失败: {str(e)}"
 
     @staticmethod
     def _slow_edit(
-        file_path: str, patches: List[Dict[str, str]], spinner: Yaspin, agent: Any
+        file_path: str, patches: List[Dict[str, str]], agent: Any
     ) -> Tuple[bool, str]:
         """使用AI模型生成补丁并应用到文件
 
@@ -287,7 +285,6 @@ class EditFileHandler(OutputHandler):
         Args:
             file_path: 要修改的文件路径，支持绝对路径和相对路径
             patches: 补丁列表，每个补丁包含search(搜索文本)和replace(替换文本)
-            spinner: 进度显示对象，用于显示处理状态和结果
             agent: 执行处理的agent实例，用于访问AI模型平台
 
         Returns:
@@ -308,15 +305,14 @@ class EditFileHandler(OutputHandler):
             upload_success = False
 
             # 如果是大文件，尝试上传到模型平台
-            with spinner.hidden():
-                if (
-                    is_large_context
-                    and model.support_upload_files()
-                    and model.upload_files([file_path])
-                ):
-                    upload_success = True
+            if (
+                is_large_context
+                and model.support_upload_files()
+                and model.upload_files([file_path])
+            ):
+                upload_success = True
 
-            model.set_suppress_output(True)
+            model.set_suppress_output(False)
 
             # 构建补丁内容
             patch_content = []
@@ -387,8 +383,9 @@ class EditFileHandler(OutputHandler):
                 # 检查是否被中断
                 if get_interrupt():
                     set_interrupt(False)
-                    with spinner.hidden():
-                        user_input = agent.multiline_inputer("补丁应用被中断，请输入补充信息:")
+                    user_input = agent.multiline_inputer(
+                        "补丁应用被中断，请输入补充信息:"
+                    )
                     if not user_input.strip():
                         return False, "用户中断了补丁应用"
                     return False, f"用户中断了补丁应用并提供了补充信息: {user_input}"
@@ -422,7 +419,7 @@ class EditFileHandler(OutputHandler):
                 if generated_patches:
                     # 尝试应用生成的补丁
                     success, result = EditFileHandler._fast_edit(
-                        file_path, generated_patches, spinner
+                        file_path, generated_patches
                     )
                     if success:
                         return True, result
@@ -430,7 +427,6 @@ class EditFileHandler(OutputHandler):
             return False, "AI模型无法生成有效的补丁"
 
         except Exception as e:
-            spinner.text = f"文件修改失败: {str(e)}"
-            spinner.fail("❌")
+            print(f"❌ 文件修改失败: {str(e)}")
             revert_file(file_path)
             return False, f"文件修改失败: {str(e)}"

jarvis/jarvis_agent/jarvis.py

@@ -4,13 +4,17 @@ import os
 import sys
 from typing import Dict
 
-import yaml
-from prompt_toolkit import prompt
-from yaspin import yaspin
-
-from jarvis.jarvis_agent import (Agent, OutputType, PrettyOutput,
-                                 get_multiline_input,
-                                 origin_agent_system_prompt, user_confirm)
+import yaml  # type: ignore
+from prompt_toolkit import prompt  # type: ignore
+
+from jarvis.jarvis_agent import (
+    Agent,
+    OutputType,
+    PrettyOutput,
+    get_multiline_input,
+    origin_agent_system_prompt,
+    user_confirm,
+)
 from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
 from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
 from jarvis.jarvis_tools.registry import ToolRegistry
@@ -26,43 +30,33 @@ def _load_tasks() -> Dict[str, str]:
     data_dir = get_data_dir()
     pre_command_path = os.path.join(data_dir, "pre-command")
     if os.path.exists(pre_command_path):
-        spinner_text = f"从{pre_command_path}加载预定义任务..."
-        with yaspin(text=spinner_text, color="cyan") as spinner:
-            try:
-                with open(
-                    pre_command_path, "r", encoding="utf-8", errors="ignore"
-                ) as f:
-                    user_tasks = yaml.safe_load(f)
-                if isinstance(user_tasks, dict):
-                    for name, desc in user_tasks.items():
-                        if desc:
-                            tasks[str(name)] = str(desc)
-                spinner.text = f"预定义任务加载完成{pre_command_path}"
-                spinner.ok("✅")
-            except (yaml.YAMLError, OSError):
-                spinner.text = f"预定义任务加载失败{pre_command_path}"
-                spinner.fail("❌")
+        print(f"🔍 从{pre_command_path}加载预定义任务...")
+        try:
+            with open(pre_command_path, "r", encoding="utf-8", errors="ignore") as f:
+                user_tasks = yaml.safe_load(f)
+            if isinstance(user_tasks, dict):
+                for name, desc in user_tasks.items():
+                    if desc:
+                        tasks[str(name)] = str(desc)
+            print(f"✅ 预定义任务加载完成 {pre_command_path}")
+        except (yaml.YAMLError, OSError):
+            print(f"❌ 预定义任务加载失败 {pre_command_path}")
 
     # Check .jarvis/pre-command in current directory
     pre_command_path = ".jarvis/pre-command"
     if os.path.exists(pre_command_path):
         abs_path = os.path.abspath(pre_command_path)
-        spinner_text = f"从{abs_path}加载预定义任务..."
-        with yaspin(text=spinner_text, color="cyan") as spinner:
-            try:
-                with open(
-                    pre_command_path, "r", encoding="utf-8", errors="ignore"
-                ) as f:
-                    local_tasks = yaml.safe_load(f)
-                if isinstance(local_tasks, dict):
-                    for name, desc in local_tasks.items():
-                        if desc:
-                            tasks[str(name)] = str(desc)
-                spinner.text = f"预定义任务加载完成{pre_command_path}"
-                spinner.ok("✅")
-            except (yaml.YAMLError, OSError):
-                spinner.text = f"预定义任务加载失败{pre_command_path}"
-                spinner.fail("❌")
+        print(f"🔍 从{abs_path}加载预定义任务...")
+        try:
+            with open(pre_command_path, "r", encoding="utf-8", errors="ignore") as f:
+                local_tasks = yaml.safe_load(f)
+            if isinstance(local_tasks, dict):
+                for name, desc in local_tasks.items():
+                    if desc:
+                        tasks[str(name)] = str(desc)
+            print(f"✅ 预定义任务加载完成 {pre_command_path}")
+        except (yaml.YAMLError, OSError):
+            print(f"❌ 预定义任务加载失败 {pre_command_path}")
 
     return tasks