jarvis-ai-assistant 0.3.23__py3-none-any.whl → 0.3.25__py3-none-any.whl

jarvis/jarvis_mcp/streamable_mcp_client.py

@@ -158,6 +158,8 @@ class StreamableMcpClient(McpClient):
 
             # 处理流式响应
             result = None
+            warning_lines = []
+            error_lines = []
             for line in response.iter_lines(decode_unicode=True):
                 if line:
                     try:
@@ -175,20 +177,19 @@ class StreamableMcpClient(McpClient):
                             notify_method = data.get("method", "")
                             params = data.get("params", {})
                             if notify_method in self.notification_handlers:
-                                for handler in self.notification_handlers[
-                                    notify_method
-                                ]:
+                                for handler in self.notification_handlers[notify_method]:
                                     try:
                                         handler(params)
                                     except Exception as e:
-                                        PrettyOutput.print(
-                                            f"处理通知时出错 ({method}): {e}",
-                                            OutputType.ERROR,
-                                        )
+                                        error_lines.append(f"处理通知时出错 ({notify_method}): {e}")
                     except json.JSONDecodeError:
-                        PrettyOutput.print(f"无法解析响应: {line}", OutputType.WARNING)
+                        warning_lines.append(f"无法解析响应: {line}")
                         continue
 
+            if warning_lines:
+                PrettyOutput.print("\n".join(warning_lines), OutputType.WARNING)
+            if error_lines:
+                PrettyOutput.print("\n".join(error_lines), OutputType.ERROR)
             # Ensure response is closed after streaming
             response.close()
             if result is None:

jarvis/jarvis_memory_organizer/memory_organizer.py

@@ -20,8 +20,6 @@ from jarvis.jarvis_utils.config import (
     get_data_dir,
     get_normal_platform_name,
     get_normal_model_name,
-    get_thinking_platform_name,
-    get_thinking_model_name,
 )
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -31,18 +29,14 @@ from jarvis.jarvis_utils.utils import init_env
 class MemoryOrganizer:
     """记忆整理器，用于合并具有相似标签的记忆"""
 
-    def __init__(self, llm_group: Optional[str] = None, llm_type: Optional[str] = None):
+    def __init__(self, llm_group: Optional[str] = None):
         """初始化记忆整理器"""
         self.project_memory_dir = Path(".jarvis/memory")
         self.global_memory_dir = Path(get_data_dir()) / "memory"
 
-        # 根据 llm_type 选择对应的平台和模型获取函数
-        if llm_type == "thinking":
-            platform_name_func = get_thinking_platform_name
-            model_name_func = get_thinking_model_name
-        else:
-            platform_name_func = get_normal_platform_name
-            model_name_func = get_normal_model_name
+        # 统一使用 normal 平台与模型
+        platform_name_func = get_normal_platform_name
+        model_name_func = get_normal_model_name
 
         # 确定平台和模型
         platform_name = platform_name_func(model_group_override=llm_group)
@@ -72,6 +66,7 @@ class MemoryOrganizer:
         """加载指定类型的所有记忆"""
         memories = []
         memory_files = self._get_memory_files(memory_type)
+        error_lines: list[str] = []
 
         for memory_file in memory_files:
             try:
@@ -80,9 +75,10 @@ class MemoryOrganizer:
                     memory_data["file_path"] = str(memory_file)
                     memories.append(memory_data)
             except Exception as e:
-                PrettyOutput.print(
-                    f"读取记忆文件 {memory_file} 失败: {str(e)}", OutputType.WARNING
-                )
+                error_lines.append(f"读取记忆文件 {memory_file} 失败: {str(e)}")
+
+        if error_lines:
+            PrettyOutput.print("\n".join(error_lines), OutputType.WARNING)
 
         return memories
 
@@ -314,16 +310,14 @@ tags:
 
                     group_memories = [memories[i] for i in original_indices]
 
-                    # 显示将要合并的记忆
-                    PrettyOutput.print(
-                        f"\n准备合并 {len(group_memories)} 个记忆:", OutputType.INFO
-                    )
+                    # 显示将要合并的记忆（先拼接后统一打印，避免循环逐条输出）
+                    lines = [f"", f"准备合并 {len(group_memories)} 个记忆:"]
                     for mem in group_memories:
-                        PrettyOutput.print(
+                        lines.append(
                             f"  - ID: {mem.get('id', '未知')}, "
-                            f"标签: {', '.join(mem.get('tags', []))[:50]}...",
-                            OutputType.INFO,
+                            f"标签: {', '.join(mem.get('tags', []))[:50]}..."
                         )
+                    PrettyOutput.print("\n".join(lines), OutputType.INFO)
 
                     if not dry_run:
                         # 合并记忆
@@ -396,27 +390,28 @@ tags:
             OutputType.SUCCESS,
         )
 
-        # 删除原始记忆文件
+        # 删除原始记忆文件（先汇总日志，最后统一打印）
+        info_lines: list[str] = []
+        warn_lines: list[str] = []
         for orig_memory in original_memories:
             if "file_path" in orig_memory:
                 try:
                     file_path = Path(orig_memory["file_path"])
                     if file_path.exists():
                         file_path.unlink()
-                        PrettyOutput.print(
-                            f"删除原始记忆: {orig_memory.get('id', '未知')}",
-                            OutputType.INFO,
-                        )
+                        info_lines.append(f"删除原始记忆: {orig_memory.get('id', '未知')}")
                     else:
-                        PrettyOutput.print(
-                            f"原始记忆文件已不存在，跳过删除: {orig_memory.get('id', '未知')}",
-                            OutputType.INFO,
+                        info_lines.append(
+                            f"原始记忆文件已不存在，跳过删除: {orig_memory.get('id', '未知')}"
                         )
                 except Exception as e:
-                    PrettyOutput.print(
-                        f"删除记忆文件失败 {orig_memory['file_path']}: {str(e)}",
-                        OutputType.WARNING,
+                    warn_lines.append(
+                        f"删除记忆文件失败 {orig_memory.get('file_path', '')}: {str(e)}"
                     )
+        if info_lines:
+            PrettyOutput.print("\n".join(info_lines), OutputType.INFO)
+        if warn_lines:
+            PrettyOutput.print("\n".join(warn_lines), OutputType.WARNING)
 
     def export_memories(
         self,
@@ -436,9 +431,10 @@ tags:
             导出的记忆数量
         """
         all_memories = []
+        progress_lines: list[str] = []
 
         for memory_type in memory_types:
-            PrettyOutput.print(f"正在导出 {memory_type} 类型的记忆...", OutputType.INFO)
+            progress_lines.append(f"正在导出 {memory_type} 类型的记忆...")
             memories = self._load_memories(memory_type)
 
             # 如果指定了标签，进行过滤
@@ -456,9 +452,11 @@ tags:
                 memory.pop("file_path", None)
 
             all_memories.extend(memories)
-            PrettyOutput.print(
-                f"从 {memory_type} 导出了 {len(memories)} 个记忆", OutputType.INFO
-            )
+            progress_lines.append(f"从 {memory_type} 导出了 {len(memories)} 个记忆")
+
+        # 统一展示导出进度日志
+        if progress_lines:
+            PrettyOutput.print("\n".join(progress_lines), OutputType.INFO)
 
         # 保存到文件
         output_file.parent.mkdir(parents=True, exist_ok=True)
@@ -505,10 +503,6 @@ tags:
         for memory in memories:
             memory_type = memory.get("memory_type", memory.get("type"))
             if not memory_type:
-                PrettyOutput.print(
-                    f"跳过没有类型的记忆: {memory.get('id', '未知')}",
-                    OutputType.WARNING,
-                )
                 skipped_count += 1
                 continue
 
@@ -560,8 +554,9 @@ tags:
 
         # 显示导入结果
         PrettyOutput.print("\n导入完成！", OutputType.SUCCESS)
-        for memory_type, count in import_stats.items():
-            PrettyOutput.print(f"{memory_type}: 导入了 {count} 个记忆", OutputType.INFO)
+        if import_stats:
+            lines = [f"{memory_type}: 导入了 {count} 个记忆" for memory_type, count in import_stats.items()]
+            PrettyOutput.print("\n".join(lines), OutputType.INFO)
 
         if skipped_count > 0:
             PrettyOutput.print(f"跳过了 {skipped_count} 个记忆", OutputType.WARNING)
@@ -592,12 +587,7 @@ def organize(
     llm_group: Optional[str] = typer.Option(
         None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
     ),
-    llm_type: Optional[str] = typer.Option(
-        "normal",
-        "-t",
-        "--llm-type",
-        help="使用的LLM类型，可选值：'normal'（普通）或 'thinking'（思考模式）",
-    ),
+
 ):
     """
     整理和合并具有相似标签的记忆。
@@ -627,7 +617,7 @@ def organize(
 
     # 创建整理器并执行
     try:
-        organizer = MemoryOrganizer(llm_group=llm_group, llm_type=llm_type)
+        organizer = MemoryOrganizer(llm_group=llm_group)
         stats = organizer.organize_memories(
             memory_type=memory_type, min_overlap=min_overlap, dry_run=dry_run
         )
@@ -681,12 +671,15 @@ def export(
     try:
         organizer = MemoryOrganizer()
 
-        # 验证记忆类型
+        # 验证记忆类型（先收集无效类型，统一打印一次）
         valid_types = ["project_long_term", "global_long_term"]
-        for mt in memory_types:
-            if mt not in valid_types:
-                PrettyOutput.print(f"错误：不支持的记忆类型 '{mt}'", OutputType.ERROR)
-                raise typer.Exit(1)
+        invalid_types = [mt for mt in memory_types if mt not in valid_types]
+        if invalid_types:
+            PrettyOutput.print(
+                "错误：不支持的记忆类型: " + ", ".join(f"'{mt}'" for mt in invalid_types),
+                OutputType.ERROR,
+            )
+            raise typer.Exit(1)
 
         count = organizer.export_memories(
             memory_types=memory_types,

jarvis/jarvis_methodology/main.py

@@ -94,9 +94,11 @@ def list_methodologies():
             PrettyOutput.print("没有找到方法论", OutputType.INFO)
             return
 
-        PrettyOutput.print("可用方法论:", OutputType.INFO)
+        # 先拼接再统一打印，避免在循环中逐条输出造成信息稀疏
+        lines = ["可用方法论:"]
         for i, (problem_type, _) in enumerate(methodologies.items(), 1):
-            PrettyOutput.print(f"{i}. {problem_type}", OutputType.INFO)
+            lines.append(f"{i}. {problem_type}")
+        PrettyOutput.print("\n".join(lines), OutputType.INFO)
     except (OSError, json.JSONDecodeError) as e:
         PrettyOutput.print(f"列出方法论失败: {str(e)}", OutputType.ERROR)
         raise typer.Exit(code=1)

jarvis/jarvis_platform/base.py

@@ -9,6 +9,7 @@ from typing_extensions import Self
 from rich import box  # type: ignore
 from rich.live import Live  # type: ignore
 from rich.panel import Panel  # type: ignore
+from rich.status import Status  # type: ignore
 from rich.text import Text  # type: ignore
 
 from jarvis.jarvis_utils.config import (
@@ -120,32 +121,100 @@ class BasePlatform(ABC):
         else:
             response = ""
 
-            text_content = Text()
-            panel = Panel(
-                text_content,
-                title=f"[bold cyan]{self.name()}[/bold cyan]",
-                subtitle="[dim]思考中... (按 Ctrl+C 中断)[/dim]",
-                border_style="bright_blue",
-                box=box.ROUNDED,
-            )
-
             if not self.suppress_output:
                 if get_pretty_output():
-                    with Live(panel, refresh_per_second=10, transient=False) as live:
-                        for s in self.chat(message):
-                            response += s
-                            text_content.append(s, style="bright_white")
-                            panel.subtitle = (
-                                "[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]"
-                            )
-                            live.update(panel)
+                    chat_iterator = self.chat(message)
+                    first_chunk = None
+
+                    with Status(
+                        f"🤔 {self.name()} 正在思考中...", spinner="dots", console=console
+                    ):
+                        try:
+                            while True:
+                                first_chunk = next(chat_iterator)
+                                if first_chunk:
+                                    break
+                        except StopIteration:
+                            return ""
+
+                    text_content = Text(overflow="fold")
+                    panel = Panel(
+                        text_content,
+                        title=f"[bold cyan]{self.name()}[/bold cyan]",
+                        subtitle="[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]",
+                        border_style="bright_blue",
+                        box=box.ROUNDED,
+                        expand=True,  # 允许面板自动调整大小
+                    )
+
+                    buffer = []
+                    buffer_count = 0
+                    with Live(panel, refresh_per_second=4, transient=False) as live:
+                        # Process first chunk
+                        response += first_chunk
+                        buffer.append(first_chunk)
+                        buffer_count += 1
+
+                        # Process rest of the chunks
+                        for s in chat_iterator:
+                            if not s:
+                                continue
+                            response += s  # Accumulate the full response string
+                            buffer.append(s)
+                            buffer_count += 1
+
+                            # 积累一定量或达到最后再更新，减少闪烁
+                            if buffer_count >= 5 or s == "":
+                                # Append buffered content to the Text object
+                                text_content.append(
+                                    "".join(buffer), style="bright_white"
+                                )
+                                buffer.clear()
+                                buffer_count = 0
+
+                                # --- Scrolling Logic ---
+                                # Calculate available height in the panel
+                                max_text_height = (
+                                    console.height - 5
+                                )  # Leave space for borders/titles
+                                if max_text_height <= 0:
+                                    max_text_height = 1
+
+                                # Get the actual number of lines the text will wrap to
+                                lines = text_content.wrap(
+                                    console,
+                                    console.width - 4 if console.width > 4 else 1,
+                                )
+
+                                # If content overflows, truncate to show only the last few lines
+                                if len(lines) > max_text_height:
+                                    new_text = "\n".join(
+                                        text_content.plain.splitlines()[
+                                            -max_text_height:
+                                        ]
+                                    )
+                                    text_content.plain = new_text
+
+                                panel.subtitle = (
+                                    "[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]"
+                                )
+                                live.update(panel)
+
                             if is_immediate_abort() and get_interrupt():
-                                return response
+                                return response  # Return the partial response immediately
+
+                        # Ensure any remaining content in the buffer is displayed
+                        if buffer:
+                            text_content.append(
+                                "".join(buffer), style="bright_white"
+                            )
+
+                        # At the end, display the entire response
+                        text_content.plain = response
+
                         end_time = time.time()
                         duration = end_time - start_time
-                        panel.subtitle = (
-                            f"[bold green]✓ 对话完成耗时: {duration:.2f}秒[/bold green]"
-                        )
+                        panel.subtitle = f"[bold green]✓ 对话完成耗时: {duration:.2f}秒[/bold green]"
                         live.update(panel)
                 else:
                     # Print a clear prefix line before streaming model output (non-pretty mode)

jarvis/jarvis_platform/kimi.py

@@ -194,9 +194,7 @@ class KimiModel(BasePlatform):
         uploaded_files = []
         for index, file_path in enumerate(file_list, 1):
             file_name = os.path.basename(file_path)
-            PrettyOutput.print(
-                f"处理文件 [{index}/{len(file_list)}]: {file_name}", OutputType.INFO
-            )
+            log_lines: list[str] = [f"处理文件 [{index}/{len(file_list)}]: {file_name}"]
             try:
                 mime_type, _ = mimetypes.guess_type(file_path)
                 action = (
@@ -204,44 +202,40 @@ class KimiModel(BasePlatform):
                 )
 
                 # 获取预签名URL
-                PrettyOutput.print(f"获取上传URL: {file_name}", OutputType.INFO)
+                log_lines.append(f"获取上传URL: {file_name}")
                 presigned_data = self._get_presigned_url(file_path, action)
 
                 # 上传文件
-                PrettyOutput.print(f"上传文件: {file_name}", OutputType.INFO)
+                log_lines.append(f"上传文件: {file_name}")
                 if self._upload_file(file_path, presigned_data["url"]):
                     # 获取文件信息
-                    PrettyOutput.print(f"获取文件信息: {file_name}", OutputType.INFO)
+                    log_lines.append(f"获取文件信息: {file_name}")
                     file_info = self._get_file_info(presigned_data, file_name, action)
 
                     # 只有文件需要解析
                     if action == "file":
-                        PrettyOutput.print(
-                            f"等待文件解析: {file_name}", OutputType.INFO
-                        )
+                        log_lines.append(f"等待文件解析: {file_name}")
                         if self._wait_for_parse(file_info["id"]):
                             uploaded_files.append(file_info)
-                            PrettyOutput.print(
-                                f"文件处理完成: {file_name}", OutputType.SUCCESS
-                            )
+                            log_lines.append(f"文件处理完成: {file_name}")
                         else:
-                            PrettyOutput.print(
-                                f"文件解析失败: {file_name}", OutputType.ERROR
-                            )
+                            log_lines.append(f"文件解析失败: {file_name}")
+                            PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                             return False
                     else:
                         uploaded_files.append(file_info)
-                        PrettyOutput.print(
-                            f"图片处理完成: {file_name}", OutputType.SUCCESS
-                        )
+                        log_lines.append(f"图片处理完成: {file_name}")
                 else:
-                    PrettyOutput.print(f"文件上传失败: {file_name}", OutputType.ERROR)
+                    log_lines.append(f"文件上传失败: {file_name}")
+                    PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                     return False
 
+                # 成功路径统一输出本文件的处理日志
+                PrettyOutput.print("\n".join(log_lines), OutputType.INFO)
+
             except Exception as e:
-                PrettyOutput.print(
-                    f"处理文件出错 {file_path}: {str(e)}", OutputType.ERROR
-                )
+                log_lines.append(f"处理文件出错 {file_path}: {str(e)}")
+                PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                 return False
 
         self.uploaded_files = uploaded_files

jarvis/jarvis_platform/registry.py

@@ -10,8 +10,6 @@ from jarvis.jarvis_utils.config import (
     get_data_dir,
     get_normal_model_name,
     get_normal_platform_name,
-    get_thinking_model_name,
-    get_thinking_platform_name,
 )
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
@@ -113,6 +111,7 @@ class PlatformRegistry:
         if directory not in sys.path:
             sys.path.append(directory)
 
+        error_lines = []
         # 遍历目录下的所有.py文件
         for filename in os.listdir(directory):
             if filename.endswith(".py") and not filename.startswith("__"):
@@ -142,16 +141,15 @@ class PlatformRegistry:
                                 platform_name = obj.platform_name()
                                 platforms[platform_name] = obj
                             except Exception as e:
-                                PrettyOutput.print(
-                                    f"实例化或注册平台失败 {obj.__name__}: {str(e)}",
-                                    OutputType.ERROR,
+                                error_lines.append(
+                                    f"实例化或注册平台失败 {obj.__name__}: {str(e)}"
                                 )
                             break
                 except Exception as e:
-                    PrettyOutput.print(
-                        f"加载平台 {module_name} 失败: {str(e)}", OutputType.ERROR
-                    )
+                    error_lines.append(f"加载平台 {module_name} 失败: {str(e)}")
 
+        if error_lines:
+            PrettyOutput.print("\n".join(error_lines), OutputType.ERROR)
         return platforms
 
     @staticmethod
@@ -187,12 +185,7 @@ class PlatformRegistry:
         platform.set_model_name(model_name)  # type: ignore
         return platform  # type: ignore
 
-    def get_thinking_platform(self) -> BasePlatform:
-        platform_name = get_thinking_platform_name()
-        model_name = get_thinking_model_name()
-        platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)  # type: ignore
-        return platform  # type: ignore
+
 
     def register_platform(self, name: str, platform_class: Type[BasePlatform]) -> None:
         """Register platform class

jarvis/jarvis_platform/tongyi.py

@@ -276,16 +276,19 @@ class TongyiPlatform(BasePlatform):
 
             for file_path in file_list:
                 file_name = os.path.basename(file_path)
-                PrettyOutput.print(f"上传文件 {file_name}", OutputType.INFO)
+                log_lines: list[str] = []
+                log_lines.append(f"上传文件 {file_name}")
                 try:
                     if not os.path.exists(file_path):
-                        PrettyOutput.print(f"文件不存在: {file_path}", OutputType.ERROR)
+                        # 先输出已收集的日志与错误后返回
+                        log_lines.append(f"文件不存在: {file_path}")
+                        PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                         return False
 
                     # Get file name and content type
                     content_type = self._get_content_type(file_path)
 
-                    PrettyOutput.print(f"准备上传文件: {file_name}", OutputType.INFO)
+                    log_lines.append(f"准备上传文件: {file_name}")
 
                     # Prepare form data
                     form_data = {
@@ -300,7 +303,7 @@ class TongyiPlatform(BasePlatform):
                     # Prepare files
                     files = {"file": (file_name, open(file_path, "rb"), content_type)}
 
-                    PrettyOutput.print(f"正在上传文件: {file_name}", OutputType.INFO)
+                    log_lines.append(f"正在上传文件: {file_name}")
 
                     # Upload file
                     response = http.post(
@@ -308,10 +311,8 @@ class TongyiPlatform(BasePlatform):
                     )
 
                     if response.status_code != 200:
-                        PrettyOutput.print(
-                            f"上传失败 {file_name}: HTTP {response.status_code}",
-                            OutputType.ERROR,
-                        )
+                        log_lines.append(f"上传失败 {file_name}: HTTP {response.status_code}")
+                        PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                         return False
 
                     # Determine file type based on extension
@@ -326,7 +327,7 @@ class TongyiPlatform(BasePlatform):
                         }
                     )
 
-                    PrettyOutput.print(f"获取下载链接: {file_name}", OutputType.INFO)
+                    log_lines.append(f"获取下载链接: {file_name}")
 
                     # Get download links for uploaded files
                     url = "https://api.tongyi.com/dialog/downloadLink/batch"
@@ -343,26 +344,20 @@ class TongyiPlatform(BasePlatform):
 
                     response = http.post(url, headers=headers, json=payload)
                     if response.status_code != 200:
-                        PrettyOutput.print(
-                            f"获取下载链接失败: HTTP {response.status_code}",
-                            OutputType.ERROR,
-                        )
+                        log_lines.append(f"获取下载链接失败: HTTP {response.status_code}")
+                        PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                         return False
 
                     result = response.json()
                     if not result.get("success"):
-                        PrettyOutput.print(
-                            f"获取下载链接失败: {result.get('errorMsg')}",
-                            OutputType.ERROR,
-                        )
+                        log_lines.append(f"获取下载链接失败: {result.get('errorMsg')}")
+                        PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                         return False
 
                     # Add files to chat
                     self.uploaded_file_info = result.get("data", {}).get("results", [])
                     for file_info in self.uploaded_file_info:
-                        PrettyOutput.print(
-                            f"添加文件到对话: {file_name}", OutputType.INFO
-                        )
+                        log_lines.append(f"添加文件到对话: {file_name}")
                         add_url = "https://api.tongyi.com/assistant/api/chat/file/add"
                         add_payload = {
                             "workSource": "chat",
@@ -385,29 +380,23 @@ class TongyiPlatform(BasePlatform):
                             add_url, headers=headers, json=add_payload
                         )
                         if add_response.status_code != 200:
-                            PrettyOutput.print(
-                                f"添加文件到对话失败: HTTP {add_response.status_code}",
-                                OutputType.ERROR,
-                            )
+                            log_lines.append(f"添加文件到对话失败: HTTP {add_response.status_code}")
                             continue
 
                         add_result = add_response.json()
                         if not add_result.get("success"):
-                            PrettyOutput.print(
-                                f"添加文件到对话失败: {add_result.get('errorMsg')}",
-                                OutputType.ERROR,
-                            )
+                            log_lines.append(f"添加文件到对话失败: {add_result.get('errorMsg')}")
                             continue
 
                         file_info.update(add_result.get("data", {}))
 
-                    PrettyOutput.print(f"文件 {file_name} 上传成功", OutputType.SUCCESS)
+                    log_lines.append(f"文件 {file_name} 上传成功")
+                    PrettyOutput.print("\n".join(log_lines), OutputType.INFO)
                     time.sleep(1)  # 短暂暂停以便用户看到成功状态
 
                 except Exception as e:
-                    PrettyOutput.print(
-                        f"上传文件 {file_name} 时出错: {str(e)}", OutputType.ERROR
-                    )
+                    log_lines.append(f"上传文件 {file_name} 时出错: {str(e)}")
+                    PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                     return False
             return True