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

jarvis/jarvis_tools/retrieve_memory.py

@@ -4,7 +4,6 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from jarvis.jarvis_utils.config import get_data_dir, get_max_input_token_count
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.globals import get_short_term_memories
 from jarvis.jarvis_utils.embedding import get_context_token_count
 
@@ -13,17 +12,7 @@ class RetrieveMemoryTool:
     """检索记忆工具，用于从长短期记忆系统中检索信息"""
 
     name = "retrieve_memory"
-    description = """从长短期记忆系统中检索信息。
-    
-    支持的记忆类型：
-    - project_long_term: 项目长期记忆（与当前项目相关的信息）
-    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
-    - short_term: 短期记忆（当前任务相关的信息）
-    - all: 从所有类型中检索
-    
-    可以通过标签过滤检索结果，支持多个标签（满足任一标签即可）
-    注意：标签数量建议不要超过10个，以保证检索效率
-    """
+    description = "从长短期记忆系统中检索信息。支持按类型（project_long_term/global_long_term/short_term/all）和标签过滤，标签建议不超过10个。"
 
     parameters = {
         "type": "object",
@@ -99,9 +88,7 @@ class RetrieveMemoryTool:
 
                     memories.append(memory_data)
                 except Exception as e:
-                    PrettyOutput.print(
-                        f"读取记忆文件 {memory_file} 失败: {str(e)}", OutputType.WARNING
-                    )
+                    print(f"⚠️ 读取记忆文件 {memory_file} 失败: {str(e)}")
 
         return memories
 
@@ -131,9 +118,23 @@ class RetrieveMemoryTool:
             # 按创建时间排序（最新的在前）
             all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
 
-            # 获取最大输入token数的2/3作为记忆的token限制
-            max_input_tokens = get_max_input_token_count()
-            memory_token_limit = int(max_input_tokens * 2 / 3)
+            # 优先使用剩余token数量，回退到输入窗口限制
+            memory_token_limit = None
+            agent = args.get("agent")
+            if agent and hasattr(agent, "model"):
+                try:
+                    remaining_tokens = agent.model.get_remaining_token_count()
+                    # 使用剩余token的2/3作为限制，保留1/3作为安全余量
+                    memory_token_limit = int(remaining_tokens * 2 / 3)
+                    if memory_token_limit <= 0:
+                        memory_token_limit = None
+                except Exception:
+                    pass
+            
+            # 回退方案：使用输入窗口的2/3
+            if memory_token_limit is None:
+                max_input_tokens = get_max_input_token_count()
+                memory_token_limit = int(max_input_tokens * 2 / 3)
 
             # 基于token限制和条数限制筛选记忆
             filtered_memories: List[Dict[str, Any]] = []
@@ -223,5 +224,5 @@ class RetrieveMemoryTool:
 
         except Exception as e:
             error_msg = f"检索记忆失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.ERROR)
+            print(f"❌ {error_msg}")
             return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/rewrite_file.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Any, Dict
+
+
+
+class RewriteFileTool:
+    """文件重写工具，用于完全重写文件内容"""
+
+    name = "rewrite_file"
+    description = "完全重写文件内容，适用于新增文件或大范围改写。具备失败回滚能力。局部修改请使用 edit_file。\n\n    ⚠️ 重要提示：\n    - 不要一次重写太多内容，建议分多次进行，避免超过LLM的上下文窗口大小\n    - 如果文件内容较长（超过2048字符），建议采用以下策略：\n      1. 第一次调用 rewrite_file 写入部分内容（如文件的前半部分或关键部分）\n      2. 然后多次调用 edit_file 工具，使用 insert_after 操作补充后续内容\n    - 这样可以避免单次操作内容过长导致上下文溢出"
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "要重写的文件路径（支持绝对路径和相对路径）",
+            },
+            "content": {
+                "type": "string",
+                "description": "新的文件完整内容",
+            },
+        },
+        "required": ["file_path", "content"],
+    }
+
+    def __init__(self):
+        """初始化文件重写工具"""
+        pass
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行文件重写操作"""
+        try:
+            file_path = args.get("file_path")
+            content = args.get("content")
+
+            if not file_path:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "缺少必需参数：file_path",
+                }
+
+            if content is None:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "缺少必需参数：content",
+                }
+
+            abs_path = os.path.abspath(file_path)
+            original_content = None
+            processed = False
+
+            try:
+                file_exists = os.path.exists(abs_path)
+                if file_exists:
+                    with open(abs_path, "r", encoding="utf-8") as rf:
+                        original_content = rf.read()
+
+                os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                with open(abs_path, "w", encoding="utf-8") as wf:
+                    wf.write(content)
+                processed = True
+
+                # 记录 REWRITE 操作调用统计
+                try:
+                    from jarvis.jarvis_stats.stats import StatsManager
+
+                    StatsManager.increment("rewrite_file", group="tool")
+                except Exception:
+                    pass
+
+                return {
+                    "success": True,
+                    "stdout": f"文件 {abs_path} 重写成功",
+                    "stderr": "",
+                }
+
+            except Exception as e:
+                # 回滚已修改内容
+                try:
+                    if processed:
+                        if original_content is None:
+                            if os.path.exists(abs_path):
+                                os.remove(abs_path)
+                        else:
+                            with open(abs_path, "w", encoding="utf-8") as wf:
+                                wf.write(original_content)
+                except Exception:
+                    pass
+                error_msg = f"文件重写失败: {str(e)}"
+                print(f"❌ {error_msg}")
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": error_msg,
+                }
+
+        except Exception as e:
+            error_msg = f"文件重写失败: {str(e)}"
+            print(f"❌ {error_msg}")
+            return {"success": False, "stdout": "", "stderr": error_msg}
+

jarvis/jarvis_tools/save_memory.py

@@ -6,7 +6,6 @@ from pathlib import Path
 from typing import Any, Dict
 
 from jarvis.jarvis_utils.config import get_data_dir
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.globals import add_short_term_memory
 
 
@@ -14,18 +13,7 @@ class SaveMemoryTool:
     """保存记忆工具，用于将信息保存到长短期记忆系统"""
 
     name = "save_memory"
-    description = """保存信息到长短期记忆系统。
-    
-    支持批量保存多条记忆，可以同时保存不同类型的记忆。
-    
-    支持的记忆类型：
-    - project_long_term: 项目长期记忆（与当前项目相关的信息）
-    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
-    - short_term: 短期记忆（当前任务相关的信息）
-    
-    项目长期记忆存储在当前目录的 .jarvis/memory 下
-    全局长期记忆和短期记忆存储在数据目录的 memory 子目录下
-    """
+    description = "保存信息到长短期记忆系统。支持批量保存，记忆类型：project_long_term（项目长期）、global_long_term（全局长期）、short_term（短期）。"
 
     parameters = {
         "type": "object",
@@ -163,7 +151,7 @@ class SaveMemoryTool:
                 except Exception as e:
                     failed_count += 1
                     error_msg = f"保存第 {i+1} 条记忆失败: {str(e)}"
-                    PrettyOutput.print(error_msg, OutputType.ERROR)
+                    print(f"❌ {error_msg}")
                     results.append(
                         {
                             "error": error_msg,
@@ -190,5 +178,5 @@ class SaveMemoryTool:
 
         except Exception as e:
             error_msg = f"保存记忆失败: {str(e)}"
-            PrettyOutput.print(error_msg, OutputType.ERROR)
+            print(f"❌ {error_msg}")
             return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/search_web.py

@@ -17,7 +17,6 @@ from jarvis.jarvis_utils.config import (
     get_web_search_model_name,
 )
 from jarvis.jarvis_utils.http import get as http_get
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class SearchWebTool:
@@ -65,12 +64,9 @@ class SearchWebTool:
                         visited_urls.append(url)
                         visited_count += 1
                 except requests.exceptions.HTTPError as e:
-                    PrettyOutput.print(
-                        f"⚠️ HTTP错误 {e.response.status_code} 访问 {url}",
-                        OutputType.WARNING,
-                    )
+                    print(f"⚠️ HTTP错误 {e.response.status_code} 访问 {url}")
                 except requests.exceptions.RequestException as e:
-                    PrettyOutput.print(f"⚠️ 请求错误: {e}", OutputType.WARNING)
+                    print(f"⚠️ 请求错误: {e}")
 
             if not full_content.strip():
                 return {
@@ -108,7 +104,7 @@ class SearchWebTool:
             return {"stdout": summary, "stderr": "", "success": True}
 
         except Exception as e:
-            PrettyOutput.print(f"❌ 网页搜索过程中发生错误: {e}", OutputType.ERROR)
+            print(f"❌ 网页搜索过程中发生错误: {e}")
             return {
                 "stdout": "",
                 "stderr": f"网页搜索过程中发生错误: {e}",

jarvis/jarvis_tools/sub_agent.py

@@ -15,7 +15,6 @@ import json
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_utils.globals import delete_agent
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class SubAgentTool:
@@ -28,7 +27,7 @@ class SubAgentTool:
 
     # 必须与文件名一致，供 ToolRegistry 自动注册
     name = "sub_agent"
-    description = "将子任务交给通用 Agent 执行，并返回执行结果（继承父Agent部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer、non_interactive、use_methodology、use_analysis；其他参数需显式提供，自动完成并生成总结）。"
+    description = "将子任务交给通用 Agent 执行并返回结果（继承父Agent部分配置，自动完成并生成总结）。"
     parameters = {
         "type": "object",
         "properties": {
@@ -158,6 +157,21 @@ class SubAgentTool:
                 non_interactive=parent_non_interactive,
             )
 
+            # 禁用 sub_agent 和 sub_code_agent，避免无限递归
+            try:
+                # 获取当前启用的工具列表
+                tool_registry = agent.get_tool_registry()
+                if tool_registry:
+                    current_tools = [t.get("name") for t in tool_registry.get_all_tools() if isinstance(t, dict) and t.get("name")]
+                    # 过滤掉禁止的工具
+                    forbidden_tools = {"sub_agent", "sub_code_agent"}
+                    filtered_tools = [t for t in current_tools if t not in forbidden_tools]
+                    if filtered_tools:
+                        agent.set_use_tools(filtered_tools)
+            except Exception:
+                # 如果禁用工具失败，不影响主流程
+                pass
+
             # 校验子Agent所用模型是否有效，必要时回退到平台可用模型
             try:
                 platform = getattr(agent, "model", None)
@@ -167,10 +181,7 @@ class SubAgentTool:
                         available_names = [m for m, _ in available_models]
                         current_model_name = platform.name()
                         if current_model_name not in available_names:
-                            PrettyOutput.print(
-                                f"检测到子Agent模型 {current_model_name} 不存在于平台 {platform.platform_name()} 的可用模型列表，将回退到 {available_names[0]}",
-                                OutputType.WARNING,
-                            )
+                            print(f"⚠️ 检测到子Agent模型 {current_model_name} 不存在于平台 {platform.platform_name()} 的可用模型列表，将回退到 {available_names[0]}")
                             platform.set_model_name(available_names[0])
             except Exception:
                 # 获取模型列表或设置模型失败时，保持原设置并继续，交由底层报错处理

jarvis/jarvis_tools/sub_code_agent.py

@@ -14,7 +14,6 @@ from typing import Any, Dict, List
 from jarvis.jarvis_code_agent.code_agent import CodeAgent
 from jarvis.jarvis_utils.globals import delete_agent
 from jarvis.jarvis_utils.config import set_config, get_git_check_mode
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class SubCodeAgentTool:
@@ -27,7 +26,7 @@ class SubCodeAgentTool:
 
     # 必须与文件名一致，供 ToolRegistry 自动注册
     name = "sub_code_agent"
-    description = "将子任务交给 CodeAgent 执行，并返回执行结果（使用系统默认配置，自动完成并生成总结）。"
+    description = "将子任务交给 CodeAgent 执行并返回结果（自动完成并生成总结）。"
     parameters = {
         "type": "object",
         "properties": {
@@ -109,21 +108,20 @@ class SubCodeAgentTool:
                 pass
 
             # 依据父Agent已启用工具集，推导 append_tools（作为在 CodeAgent 基础工具上的增量）
+            # 禁用 sub_agent 和 sub_code_agent，避免无限递归
+            forbidden_tools = {"sub_agent", "sub_code_agent"}
             append_tools = None
             try:
                 base_tools = [
                     "execute_script",
-                    "search_web",
-                    "ask_user",
                     "read_code",
-
-                    "save_memory",
-                    "retrieve_memory",
-                    "clear_memory",
-                    "sub_code_agent",
+                    "edit_file",
+                    "rewrite_file",
+                    "lsp_client",
                 ]
                 if use_tools:
-                    extras = [t for t in use_tools if t not in base_tools]
+                    # 过滤掉基础工具和禁止的工具
+                    extras = [t for t in use_tools if t not in base_tools and t not in forbidden_tools]
                     append_tools = ",".join(extras) if extras else None
             except Exception:
                 append_tools = None
@@ -158,9 +156,12 @@ class SubCodeAgentTool:
             # 子Agent需要自动完成
             try:
                 code_agent.auto_complete = True
-                # 同步父Agent工具使用集（如可用）
+                # 同步父Agent工具使用集（如可用），但禁用 sub_agent 和 sub_code_agent 避免无限递归
                 if use_tools:
-                    code_agent.set_use_tools(use_tools)
+                    forbidden_tools = {"sub_agent", "sub_code_agent"}
+                    filtered_tools = [t for t in use_tools if t not in forbidden_tools]
+                    if filtered_tools:
+                        code_agent.set_use_tools(filtered_tools)
                 # 同步父Agent的模型名称（如可用），以尽量保持平台与模型一致
                 if (
                     parent_agent is not None
@@ -181,10 +182,7 @@ class SubCodeAgentTool:
                                         available_names = [m for m, _ in available_models]
                                         current_model_name = model_obj.name()
                                         if current_model_name not in available_names:
-                                            PrettyOutput.print(
-                                                f"检测到子CodeAgent模型 {current_model_name} 不存在于平台 {model_obj.platform_name()} 的可用模型列表，将回退到 {available_names[0]}",
-                                                OutputType.WARNING,
-                                            )
+                                            print(f"⚠️ 检测到子CodeAgent模型 {current_model_name} 不存在于平台 {model_obj.platform_name()} 的可用模型列表，将回退到 {available_names[0]}")
                                             model_obj.set_model_name(available_names[0])
                                 except Exception:
                                     # 获取模型列表或设置模型失败时，保持原设置并继续，交由底层报错处理

jarvis/jarvis_tools/virtual_tty.py

@@ -3,7 +3,6 @@ import os
 import sys
 import time
 from typing import Any, Dict, TYPE_CHECKING
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 # 为了类型检查，总是导入这些模块
 if TYPE_CHECKING:
@@ -19,12 +18,7 @@ else:
 
 class VirtualTTYTool:
     name = "virtual_tty"
-    description = (
-        "控制虚拟终端执行各种操作，如启动终端、输入命令、获取输出等。"
-        + "与execute_script不同，此工具会创建一个持久的虚拟终端会话，可以连续执行多个命令，并保持终端状态。"
-        + "适用于需要交互式操作的场景，如运行需要用户输入的交互式程序（如：ssh连接、sftp传输、gdb/dlv调试等）。"
-        + "注意：Windows平台功能有限，某些Unix特有功能可能不可用。"
-    )
+    description = "控制虚拟终端执行交互式操作（如ssh、sftp、gdb等）。与execute_script不同，此工具创建持久会话，保持终端状态。Windows平台功能有限。"
     parameters = {
         "type": "object",
         "properties": {
@@ -42,19 +36,19 @@ class VirtualTTYTool:
             },
             "keys": {
                 "type": "string",
-                "description": "要发送的按键序列（仅支持单行输入，当action为send_keys时有效）",
+                "description": "要发送的按键序列（仅当action为send_keys时有效）",
             },
             "add_enter": {
                 "type": "boolean",
-                "description": "是否在单行命令末尾自动添加回车符（仅当action为send_keys时有效，默认为true）",
+                "description": "是否在命令末尾自动添加回车符（仅当action为send_keys时有效，默认true）",
             },
             "timeout": {
                 "type": "number",
-                "description": "等待输出的超时时间（秒，仅当action为send_keys或output时有效，默认为5.0）",
+                "description": "等待输出的超时时间（秒，仅当action为send_keys或output时有效，默认5.0）",
             },
             "tty_id": {
                 "type": "string",
-                "description": "虚拟终端的唯一标识符（默认为'default'）",
+                "description": "虚拟终端的唯一标识符（默认'default'）",
             },
         },
         "required": ["action"],
@@ -83,6 +77,8 @@ class VirtualTTYTool:
         # 确保agent有tty_sessions字典
         if not hasattr(agent, "tty_sessions"):
             agent.tty_sessions = {}
+        elif agent.tty_sessions is None:
+            agent.tty_sessions = {}
 
         # 如果指定的tty_id不存在，为其创建一个新的tty_data
         if tty_id not in agent.tty_sessions:
@@ -116,9 +112,7 @@ class VirtualTTYTool:
         try:
             if action == "launch":
                 if args.get("keys", "") != "":
-                    PrettyOutput.print(
-                        "启动虚拟终端时，不能同时指定 keys 参数", OutputType.ERROR
-                    )
+                    print("❌ 启动虚拟终端时，不能同时指定 keys 参数")
                     return {
                         "success": False,
                         "stdout": "",
@@ -127,9 +121,7 @@ class VirtualTTYTool:
 
                 result = self._launch_tty(agent, tty_id)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"启动虚拟终端 [{tty_id}] 失败", OutputType.ERROR
-                    )
+                    print(f"❌ 启动虚拟终端 [{tty_id}] 失败")
                 return result
             elif action == "send_keys":
                 keys = args.get("keys", "").strip()
@@ -138,40 +130,32 @@ class VirtualTTYTool:
 
                 result = self._input_command(agent, tty_id, keys, timeout, add_enter)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"发送按键序列到终端 [{tty_id}] 失败", OutputType.ERROR
-                    )
+                    print(f"❌ 发送按键序列到终端 [{tty_id}] 失败")
                 return result
             elif action == "output":
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
 
                 result = self._get_output(agent, tty_id, timeout)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"获取终端 [{tty_id}] 输出失败", OutputType.ERROR
-                    )
+                    print(f"❌ 获取终端 [{tty_id}] 输出失败")
                 return result
             elif action == "close":
 
                 result = self._close_tty(agent, tty_id)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"关闭虚拟终端 [{tty_id}] 失败", OutputType.ERROR
-                    )
+                    print(f"❌ 关闭虚拟终端 [{tty_id}] 失败")
                 return result
             elif action == "get_screen":
 
                 result = self._get_screen(agent, tty_id)
                 if not result["success"]:
-                    PrettyOutput.print(
-                        f"获取终端 [{tty_id}] 屏幕内容失败", OutputType.ERROR
-                    )
+                    print(f"❌ 获取终端 [{tty_id}] 屏幕内容失败")
                 return result
             elif action == "list":
 
                 result = self._list_ttys(agent)
                 if not result["success"]:
-                    PrettyOutput.print("获取虚拟终端列表失败", OutputType.ERROR)
+                    print("❌ 获取虚拟终端列表失败")
                 return result
             return {"success": False, "stdout": "", "stderr": "不支持的操作"}
 
@@ -231,6 +215,8 @@ class VirtualTTYTool:
                     except BlockingIOError:
                         continue
 
+                if output:
+                    print(f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}")
                 return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -296,6 +282,8 @@ class VirtualTTYTool:
                 except _queue.Empty:
                     continue
 
+            if output:
+                print(f"📥 启动终端时的初始输出 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -372,6 +360,8 @@ class VirtualTTYTool:
                             output += data.decode()
                 except BlockingIOError:
                     continue
+            if output:
+                print(f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -420,6 +410,8 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
+            if output:
+                print(f"📥 命令执行后的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -472,6 +464,8 @@ class VirtualTTYTool:
                                 break
                         except BlockingIOError:
                             break
+            if output:
+                print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -503,6 +497,8 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
+            if output:
+                print(f"📥 获取到的输出内容 [{tty_id}]:\n{output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -568,9 +564,35 @@ class VirtualTTYTool:
             }
 
         try:
+            process = agent.tty_sessions[tty_id]["process"]
             # 终止进程
-            agent.tty_sessions[tty_id]["process"].terminate()
-            agent.tty_sessions[tty_id]["process"].wait()
+            try:
+                import subprocess as _subprocess  # pylint: disable=import-outside-toplevel
+                process.terminate()
+                process.wait(timeout=2)
+            except _subprocess.TimeoutExpired:
+                try:
+                    process.kill()
+                    process.wait()
+                except Exception:
+                    pass
+            except Exception:
+                try:
+                    process.kill()
+                    process.wait()
+                except Exception:
+                    pass
+            finally:
+                # 确保所有文件描述符被关闭
+                try:
+                    if process.stdin:
+                        process.stdin.close()
+                    if process.stdout:
+                        process.stdout.close()
+                    if process.stderr:
+                        process.stderr.close()
+                except Exception:
+                    pass
 
             # 重置终端数据
             import queue as _queue  # pylint: disable=import-outside-toplevel

jarvis/jarvis_utils/clipboard.py

@@ -2,7 +2,6 @@
 import platform
 import subprocess
 
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 def copy_to_clipboard(text: str) -> None:
@@ -11,9 +10,9 @@ def copy_to_clipboard(text: str) -> None:
     参数:
         text: 要复制的文本
     """
-    PrettyOutput.print("--- 剪贴板内容开始 ---", OutputType.INFO)
+    print("ℹ️ --- 剪贴板内容开始 ---")
     print(text)
-    PrettyOutput.print("--- 剪贴板内容结束 ---", OutputType.INFO)
+    print("ℹ️ --- 剪贴板内容结束 ---")
 
     system = platform.system()
 
@@ -33,7 +32,7 @@ def copy_to_clipboard(text: str) -> None:
                 process.stdin.close()
             return
         except Exception as e:
-            PrettyOutput.print(f"使用Windows clip命令时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用Windows clip命令时出错: {e}")
 
     # macOS系统
     elif system == "Darwin":
@@ -49,7 +48,7 @@ def copy_to_clipboard(text: str) -> None:
                 process.stdin.close()
             return
         except Exception as e:
-            PrettyOutput.print(f"使用macOS pbcopy命令时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用macOS pbcopy命令时出错: {e}")
 
     # Linux系统
     else:
@@ -68,7 +67,7 @@ def copy_to_clipboard(text: str) -> None:
         except FileNotFoundError:
             pass  # xsel 未安装，继续尝试下一个
         except Exception as e:
-            PrettyOutput.print(f"使用xsel时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用xsel时出错: {e}")
 
         # 尝试使用 xclip
         try:
@@ -83,8 +82,6 @@ def copy_to_clipboard(text: str) -> None:
                 process.stdin.close()
             return
         except FileNotFoundError:
-            PrettyOutput.print(
-                "xsel 和 xclip 均未安装, 无法复制到剪贴板", OutputType.WARNING
-            )
+            print("⚠️ xsel 和 xclip 均未安装, 无法复制到剪贴板")
         except Exception as e:
-            PrettyOutput.print(f"使用xclip时出错: {e}", OutputType.WARNING)
+            print(f"⚠️ 使用xclip时出错: {e}")