jarvis-ai-assistant 0.3.18__py3-none-any.whl → 0.3.19__py3-none-any.whl

jarvis/jarvis_tools/registry.py

@@ -287,10 +287,7 @@ class ToolRegistry(OutputHandlerProtocol):
             for tool_name in dont_use_list:
                 if tool_name in self.tools:
                     del self.tools[tool_name]
-                    PrettyOutput.print(
-                        f"已排除工具: {tool_name}",
-                        OutputType.INFO,
-                    )
+
 
     def _load_mcp_tools(self) -> None:
         """加载MCP工具，优先从配置获取，其次从目录扫描"""
@@ -354,9 +351,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 try:
                     import subprocess
 
-                    PrettyOutput.print(
-                        f"正在克隆中心工具仓库: {central_repo}", OutputType.INFO
-                    )
+
                     subprocess.run(
                         ["git", "clone", central_repo, central_repo_path], check=True
                     )
@@ -399,10 +394,7 @@ class ToolRegistry(OutputHandlerProtocol):
 
             # 检查enable标志
             if not config.get("enable", True):
-                PrettyOutput.print(
-                    f"MCP配置{config.get('name', '')}已禁用(enable=false)，跳过注册",
-                    OutputType.INFO,
-                )
+
                 return False
 
             name = config.get("name", "mcp")
@@ -414,10 +406,7 @@ class ToolRegistry(OutputHandlerProtocol):
                     args.pop("agent", None)
                     args.pop("want", None)
                     ret = client.get_resource_list()
-                    PrettyOutput.print(
-                        f"MCP {name} 资源列表:\n{yaml.safe_dump(ret, allow_unicode=True)}",
-                        OutputType.TOOL,
-                    )
+
                     return {
                         "success": True,
                         "stdout": yaml.safe_dump(ret, allow_unicode=True),
@@ -438,10 +427,7 @@ class ToolRegistry(OutputHandlerProtocol):
                             "stderr": "缺少必需的uri参数",
                         }
                     ret = client.get_resource(args["uri"])
-                    PrettyOutput.print(
-                        f"MCP {name} 获取资源:\n{yaml.safe_dump(ret, allow_unicode=True)}",
-                        OutputType.TOOL,
-                    )
+
                     return ret
 
                 return execute
@@ -452,10 +438,7 @@ class ToolRegistry(OutputHandlerProtocol):
                     args.pop("agent", None)
                     args.pop("want", None)
                     ret = client.execute(tool_name, args)
-                    PrettyOutput.print(
-                        f"MCP {name} {tool_name} 执行结果:\n{yaml.safe_dump(ret, allow_unicode=True)}",
-                        OutputType.TOOL,
-                    )
+
                     return ret
 
                 return execute
@@ -665,11 +648,8 @@ class ToolRegistry(OutputHandlerProtocol):
                         yaml.safe_load(temp_data[0])  # Check if valid YAML
 
                         # Ask user for confirmation
-                        PrettyOutput.print(
-                            f"检测到缺失的 {ct('TOOL_CALL')} 标签，已自动修复。修复后的内容如下:",
-                            OutputType.INFO,
-                        )
-                        PrettyOutput.print(fixed_content, OutputType.TOOL)
+
+
                         data = temp_data
                     except (yaml.YAMLError, EOFError, KeyboardInterrupt):
                         # Even after fixing, it's not valid YAML, or user cancelled.

jarvis/jarvis_tools/retrieve_memory.py

@@ -147,17 +147,12 @@ class RetrieveMemoryTool:
 
                 # 检查是否超过token限制
                 if total_tokens + memory_tokens > memory_token_limit:
-                    PrettyOutput.print(
-                        f"达到token限制 ({total_tokens}/{memory_token_limit})，停止加载更多记忆",
-                        OutputType.INFO,
-                    )
+
                     break
 
                 # 检查是否超过50条限制
                 if len(filtered_memories) >= 50:
-                    PrettyOutput.print(
-                        f"达到记忆条数限制 (50条)，停止加载更多记忆", OutputType.INFO
-                    )
+
                     break
 
                 filtered_memories.append(memory)
@@ -170,10 +165,10 @@ class RetrieveMemoryTool:
                 all_memories = all_memories[:limit]
 
             # 打印结果摘要
-            PrettyOutput.print(f"检索到 {len(all_memories)} 条记忆", OutputType.INFO)
+
 
             if tags:
-                PrettyOutput.print(f"使用标签过滤: {', '.join(tags)}", OutputType.INFO)
+                pass
 
             # 格式化为Markdown输出
             markdown_output = f"# 记忆检索结果\n\n"
@@ -216,17 +211,11 @@ class RetrieveMemoryTool:
 
             # 如果记忆较多，在终端显示摘要
             if len(all_memories) > 5:
-                PrettyOutput.print(f"记忆较多，仅显示前5条摘要：", OutputType.INFO)
+                # 静默模式下不再打印摘要，完整结果已包含在返回的markdown_output中
                 for i, memory in enumerate(all_memories[:5]):
                     content_preview = memory.get("content", "")[:100]
                     if len(memory.get("content", "")) > 100:
                         content_preview += "..."
-                    PrettyOutput.print(
-                        f"{i+1}. [{memory.get('type')}] {memory.get('id')}\n"
-                        f"   标签: {', '.join(memory.get('tags', []))}\n"
-                        f"   内容: {content_preview}",
-                        OutputType.INFO,
-                    )
 
             return {
                 "success": True,

jarvis/jarvis_tools/rewrite_file.py

@@ -114,7 +114,6 @@ class FileRewriteTool:
                 action = "创建并写入" if not file_exists else "成功重写"
                 stdout_message = f"文件 {abs_path} {action}"
                 stdout_messages.append(stdout_message)
-                PrettyOutput.print(stdout_message, OutputType.SUCCESS)
 
             except Exception as e:
                 stderr_message = f"处理文件 {file_path} 时出错: {str(e)}"
@@ -126,7 +125,6 @@ class FileRewriteTool:
             if not success and processed:
                 rollback_message = "操作失败，正在回滚修改..."
                 stderr_messages.append(rollback_message)
-                PrettyOutput.print(rollback_message, OutputType.WARNING)
 
                 try:
                     if original_content is None:
@@ -141,7 +139,6 @@ class FileRewriteTool:
                         rollback_file_message = f"已回滚文件: {abs_path}"
 
                     stderr_messages.append(rollback_file_message)
-                    PrettyOutput.print(rollback_file_message, OutputType.INFO)
                 except Exception as e:
                     rollback_error = f"回滚文件 {file_path} 失败: {str(e)}"
                     stderr_messages.append(rollback_error)
@@ -172,7 +169,6 @@ class FileRewriteTool:
             if processed:
                 rollback_message = "操作失败，正在回滚修改..."
                 stderr_messages.append(rollback_message)
-                PrettyOutput.print(rollback_message, OutputType.WARNING)
 
                 try:
                     if original_content is None:

jarvis/jarvis_tools/save_memory.py

@@ -159,12 +159,7 @@ class SaveMemoryTool:
                     # 打印单条记忆保存信息
                     memory_type = memory_data["memory_type"]
                     tags = memory_data.get("tags", [])
-                    PrettyOutput.print(
-                        f"[{i+1}/{len(memories)}] {memory_type} 记忆已保存\n"
-                        f"ID: {result['memory_id']}\n"
-                        f"标签: {', '.join(tags)}",
-                        OutputType.SUCCESS,
-                    )
+
                 except Exception as e:
                     failed_count += 1
                     error_msg = f"保存第 {i+1} 条记忆失败: {str(e)}"
@@ -178,10 +173,7 @@ class SaveMemoryTool:
                     )
 
             # 生成总结报告
-            PrettyOutput.print(
-                f"\n批量保存完成：成功 {success_count} 条，失败 {failed_count} 条",
-                OutputType.INFO,
-            )
+
 
             # 构建返回结果
             output = {

jarvis/jarvis_tools/search_web.py

@@ -34,7 +34,7 @@ class SearchWebTool:
         # pylint: disable=too-many-locals, broad-except
         """执行网络搜索、抓取内容并总结结果。"""
         try:
-            PrettyOutput.print("▶️ 使用 DuckDuckGo 开始网页搜索...", OutputType.INFO)
+
             results = list(DDGS().text(query, max_results=50, page=3))
 
             if not results:
@@ -50,17 +50,14 @@ class SearchWebTool:
 
             for r in results:
                 if visited_count >= 10:
-                    PrettyOutput.print("ℹ️ 已成功获取10个网页，停止抓取。", OutputType.INFO)
+
                     break
 
                 url = r["href"]
                 title = r.get("title", url)
 
                 try:
-                    PrettyOutput.print(
-                        f"📄 ({visited_count + 1}/10) 正在抓取: {title} ({url})",
-                        OutputType.INFO,
-                    )
+
                     response = http_get(url, timeout=10.0, allow_redirects=True)
                     content = md(response.text, strip=["script", "style"])
                     if content:
@@ -83,9 +80,9 @@ class SearchWebTool:
                 }
 
             url_list_str = "\n".join(f"  - {u}" for u in visited_urls)
-            PrettyOutput.print(f"🔍 已成功访问并处理以下URL:\n{url_list_str}", OutputType.INFO)
 
-            PrettyOutput.print("🧠 正在总结内容...", OutputType.INFO)
+
+
             summary_prompt = f"请为查询“{query}”总结以下内容：\n\n{full_content}"
 
             if not agent.model:

jarvis/jarvis_tools/virtual_tty.py

@@ -3,6 +3,7 @@ import os
 import sys
 import time
 from typing import Any, Dict, TYPE_CHECKING
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 # 为了类型检查，总是导入这些模块
 if TYPE_CHECKING:
@@ -126,62 +127,50 @@ class VirtualTTYTool:
         try:
             if action == "launch":
                 if args.get("keys", "") != "":
-                    print(f"🚫 启动虚拟终端时，不能同时指定keys参数")
+                    PrettyOutput.print("启动虚拟终端时，不能同时指定 keys 参数", OutputType.ERROR)
                     return {
                         "success": False,
                         "stdout": "",
                         "stderr": "启动虚拟终端时，不能同时指定keys参数",
                     }
-                print(f"🚀 正在启动虚拟终端 [{tty_id}]...")
+
                 result = self._launch_tty(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 启动虚拟终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 启动虚拟终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"启动虚拟终端 [{tty_id}] 失败", OutputType.ERROR)
                 return result
             elif action == "send_keys":
                 keys = args.get("keys", "").strip()
                 add_enter = args.get("add_enter", True)
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
-                print(f"⌨️ 正在向终端 [{tty_id}] 发送按键序列: {keys}...")
+
                 result = self._input_command(agent, tty_id, keys, timeout, add_enter)
-                if result["success"]:
-                    print(f"✅ 发送按键序列到终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 发送按键序列到终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"发送按键序列到终端 [{tty_id}] 失败", OutputType.ERROR)
                 return result
             elif action == "output":
                 timeout = args.get("timeout", 5.0)  # 默认5秒超时
-                print(f"📥 正在获取终端 [{tty_id}] 输出...")
+
                 result = self._get_output(agent, tty_id, timeout)
-                if result["success"]:
-                    print(f"✅ 获取终端 [{tty_id}] 输出成功")
-                else:
-                    print(f"❌ 获取终端 [{tty_id}] 输出失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"获取终端 [{tty_id}] 输出失败", OutputType.ERROR)
                 return result
             elif action == "close":
-                print(f"🔒 正在关闭虚拟终端 [{tty_id}]...")
+
                 result = self._close_tty(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 关闭虚拟终端 [{tty_id}] 成功")
-                else:
-                    print(f"❌ 关闭虚拟终端 [{tty_id}] 失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"关闭虚拟终端 [{tty_id}] 失败", OutputType.ERROR)
                 return result
             elif action == "get_screen":
-                print(f"🖥️ 正在获取终端 [{tty_id}] 屏幕内容...")
+
                 result = self._get_screen(agent, tty_id)
-                if result["success"]:
-                    print(f"✅ 获取终端 [{tty_id}] 屏幕内容成功")
-                else:
-                    print(f"❌ 获取终端 [{tty_id}] 屏幕内容失败")
+                if not result["success"]:
+                    PrettyOutput.print(f"获取终端 [{tty_id}] 屏幕内容失败", OutputType.ERROR)
                 return result
             elif action == "list":
-                print("📋 正在获取所有虚拟终端列表...")
+
                 result = self._list_ttys(agent)
-                if result["success"]:
-                    print("✅ 获取虚拟终端列表成功")
-                else:
-                    print("❌ 获取虚拟终端列表失败")
+                if not result["success"]:
+                    PrettyOutput.print("获取虚拟终端列表失败", OutputType.ERROR)
                 return result
             return {"success": False, "stdout": "", "stderr": "不支持的操作"}
 
@@ -241,8 +230,7 @@ class VirtualTTYTool:
                     except BlockingIOError:
                         continue
 
-                if output:
-                    print(f"📤 终端 [{tty_id}]: {output}")
+
 
                 return {"success": True, "stdout": output, "stderr": ""}
 
@@ -309,8 +297,7 @@ class VirtualTTYTool:
                 except _queue.Empty:
                     continue
 
-            if output:
-                print(f"📤 终端 [{tty_id}]: {output}")
+
 
             return {"success": True, "stdout": output, "stderr": ""}
 
@@ -388,7 +375,6 @@ class VirtualTTYTool:
                             output += data.decode()
                 except BlockingIOError:
                     continue
-            print(f"📤 终端 [{tty_id}]: {output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -437,7 +423,6 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
-            print(f"📤 终端 [{tty_id}]: {output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -490,8 +475,6 @@ class VirtualTTYTool:
                                 break
                         except BlockingIOError:
                             break
-            print(f"📤 终端 [{tty_id}]: {output}")
-
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:
@@ -523,7 +506,6 @@ class VirtualTTYTool:
                 except Exception:  # queue.Empty
                     continue
 
-            print(f"📤 终端 [{tty_id}]: {output}")
             return {"success": True, "stdout": output, "stderr": ""}
 
         except Exception as e:

jarvis/jarvis_utils/clipboard.py

@@ -11,9 +11,9 @@ def copy_to_clipboard(text: str) -> None:
     参数:
         text: 要复制的文本
     """
-    print("--- 剪贴板内容开始 ---")
-    print(text)
-    print("--- 剪贴板内容结束 ---")
+    PrettyOutput.print("--- 剪贴板内容开始 ---", OutputType.INFO)
+    PrettyOutput.print(text, OutputType.CODE, lang="text")
+    PrettyOutput.print("--- 剪贴板内容结束 ---", OutputType.INFO)
 
     system = platform.system()
 

jarvis/jarvis_utils/input.py

@@ -26,6 +26,8 @@ from prompt_toolkit.document import Document
 from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.enums import DEFAULT_BUFFER
+from prompt_toolkit.filters import has_focus
 from prompt_toolkit.layout.containers import Window
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.layout import Layout
@@ -68,8 +70,9 @@ def get_single_line_input(tip: str, default: str = "") -> str:
     获取支持历史记录的单行输入。
     """
     session: PromptSession = PromptSession(history=None)
-    style = PromptStyle.from_dict({"prompt": "ansicyan"})
-    return session.prompt(f"{tip}", default=default, style=style)
+    style = PromptStyle.from_dict({"prompt": "ansicyan", "bottom-toolbar": "fg:#888888"})
+    prompt = FormattedText([("class:prompt", f"👤 ❯ {tip}")])
+    return session.prompt(prompt, default=default, style=style)
 
 
 def get_choice(tip: str, choices: List[str]) -> str:
@@ -289,14 +292,14 @@ def _show_history_and_copy():
         PrettyOutput.print("没有可复制的消息", OutputType.INFO)
         return
 
-    print("\n" + "=" * 20 + " 消息历史记录 " + "=" * 20)
+    PrettyOutput.print("\n" + "=" * 20 + " 消息历史记录 " + "=" * 20, OutputType.INFO)
     for i, msg in enumerate(history):
         cleaned_msg = msg.replace("\n", r"\n")
         display_msg = (
             (cleaned_msg[:70] + "...") if len(cleaned_msg) > 70 else cleaned_msg
         )
-        print(f"  {i + 1}: {display_msg.strip()}")
-    print("=" * 58 + "\n")
+        PrettyOutput.print(f"  {i + 1}: {display_msg.strip()}", OutputType.INFO)
+    PrettyOutput.print("=" * 58 + "\n", OutputType.INFO)
 
     while True:
         try:
@@ -305,11 +308,11 @@ def _show_history_and_copy():
 
             if not choice_str:  # User pressed Enter
                 if not history:
-                    print("没有历史记录可供选择。")
+                    PrettyOutput.print("没有历史记录可供选择。", OutputType.INFO)
                     break
                 choice = len(history) - 1
             elif choice_str.lower() == "c":
-                print("已取消")
+                PrettyOutput.print("已取消", OutputType.INFO)
                 break
             else:
                 choice = int(choice_str) - 1
@@ -322,11 +325,11 @@ def _show_history_and_copy():
                 )
                 break
             else:
-                print("无效的序号，请重试。")
+                PrettyOutput.print("无效的序号，请重试。", OutputType.WARNING)
         except ValueError:
-            print("无效的输入，请输入数字。")
+            PrettyOutput.print("无效的输入，请输入数字。", OutputType.WARNING)
         except (KeyboardInterrupt, EOFError):
-            print("\n操作取消")
+            PrettyOutput.print("\n操作取消", OutputType.INFO)
             break
 
 
@@ -337,8 +340,8 @@ def _get_multiline_input_internal(tip: str) -> str:
     """
     bindings = KeyBindings()
 
-    # Show a one-time hint on the first Enter press in this invocation
-    first_enter_hint_shown = False
+    # Show a one-time hint on the first Enter press in this invocation (disabled; using inlay toolbar instead)
+    first_enter_hint_shown = True
 
     @bindings.add("enter")
     def _(event):
@@ -347,8 +350,9 @@ def _get_multiline_input_internal(tip: str) -> str:
             first_enter_hint_shown = True
 
             def _show_notice():
-                print(
-                    f"{Fore.YELLOW}提示：当前支持多行输入。输入完成请使用 Ctrl+J 确认；Enter 仅用于换行。{ColoramaStyle.RESET_ALL}"
+                PrettyOutput.print(
+                    "提示：当前支持多行输入。输入完成请使用 Ctrl+J 确认；Enter 仅用于换行。",
+                    OutputType.INFO,
                 )
                 try:
                     input("按回车继续...")
@@ -372,17 +376,49 @@ def _get_multiline_input_internal(tip: str) -> str:
         else:
             event.current_buffer.insert_text("\n")
 
-    @bindings.add("c-j")
+    @bindings.add("c-j", filter=has_focus(DEFAULT_BUFFER))
     def _(event):
         event.current_buffer.validate_and_handle()
 
-    @bindings.add("c-o")
+    @bindings.add("c-o", filter=has_focus(DEFAULT_BUFFER))
     def _(event):
         """Handle Ctrl+O by exiting the prompt and returning the sentinel value."""
         event.app.exit(result=CTRL_O_SENTINEL)
 
-    style = PromptStyle.from_dict({"prompt": "ansicyan"})
+    style = PromptStyle.from_dict(
+        {
+            "prompt": "ansibrightmagenta bold",
+            "bottom-toolbar": "bg:#4b145b #ffd6ff bold",
+            "bt.tip": "bold fg:#ff5f87",
+            "bt.sep": "fg:#ffb3de",
+            "bt.key": "bg:#d7005f #ffffff bold",
+            "bt.label": "fg:#ffd6ff",
+        }
+    )
 
+    def _bottom_toolbar():
+        return FormattedText(
+            [
+                ("class:bt.tip", f" {tip} "),
+                ("class:bt.sep", " • "),
+                ("class:bt.label", "快捷键: "),
+                ("class:bt.key", "@"),
+                ("class:bt.label", " 文件补全 "),
+                ("class:bt.sep", " • "),
+                ("class:bt.key", "Tab"),
+                ("class:bt.label", " 选择 "),
+                ("class:bt.sep", " • "),
+                ("class:bt.key", "Ctrl+J"),
+                ("class:bt.label", " 确认 "),
+                ("class:bt.sep", " • "),
+                ("class:bt.key", "Ctrl+O"),
+                ("class:bt.label", " 历史复制 "),
+                ("class:bt.sep", " • "),
+                ("class:bt.key", "Ctrl+C/D"),
+                ("class:bt.label", " 取消 "),
+            ]
+        )
+    
     history_dir = get_data_dir()
     session: PromptSession = PromptSession(
         history=FileHistory(os.path.join(history_dir, "multiline_input_history")),
@@ -394,25 +430,29 @@ def _get_multiline_input_internal(tip: str) -> str:
         mouse_support=False,
     )
 
-    print(f"{Fore.GREEN}{tip}{ColoramaStyle.RESET_ALL}")
-    prompt = FormattedText([("class:prompt", ">>> ")])
+    # Tip is shown in bottom toolbar; avoid extra print
+    prompt = FormattedText([("class:prompt", "👤 ❯ ")])
 
     try:
-        return session.prompt(prompt, style=style, pre_run=lambda: None).strip()
+        return session.prompt(
+            prompt,
+            style=style,
+            pre_run=lambda: None,
+            bottom_toolbar=_bottom_toolbar,
+        ).strip()
     except (KeyboardInterrupt, EOFError):
         return ""
 
 
-def get_multiline_input(tip: str) -> str:
+def get_multiline_input(tip: str, print_on_empty: bool = True) -> str:
     """
     获取带有增强补全和确认功能的多行输入。
     此函数处理控制流，允许在不破坏终端状态的情况下处理历史记录复制。
-    """
-    PrettyOutput.section(
-        "用户输入 - 使用 @ 触发文件补全，Tab 选择补全项，Ctrl+J 确认，Ctrl+O 从历史记录中选择消息复制，按 Ctrl+C/D 取消输入",
-        OutputType.USER,
-    )
 
+    参数:
+        tip: 提示文本，将显示在底部工具栏中
+        print_on_empty: 当输入为空字符串时，是否打印“输入已取消”提示。默认打印。
+    """
     while True:
         user_input = _get_multiline_input_internal(tip)
 
@@ -421,6 +461,6 @@ def get_multiline_input(tip: str) -> str:
             tip = "请继续输入（或按Ctrl+J确认）:"
             continue
         else:
-            if not user_input:
+            if not user_input and print_on_empty:
                 PrettyOutput.print("\n输入已取消", OutputType.INFO)
             return user_input

jarvis/jarvis_utils/methodology.py

@@ -203,12 +203,12 @@ def load_methodology(
 
     try:
         # 加载所有方法论
-        print(f"📁 加载方法论文件...")
+        PrettyOutput.print("📁 加载方法论文件...", OutputType.INFO)
         methodologies = _load_all_methodologies()
         if not methodologies:
-            print(f"❌ 没有找到方法论文件")
+            PrettyOutput.print("没有找到方法论文件", OutputType.WARNING)
             return ""
-        print(f"✅ 加载方法论文件完成 (共 {len(methodologies)} 个)")
+        PrettyOutput.print(f"加载方法论文件完成 (共 {len(methodologies)} 个)", OutputType.SUCCESS)
 
         if platform_name:
             platform = PlatformRegistry().create_platform(platform_name)

jarvis/jarvis_utils/output.py

@@ -274,19 +274,13 @@ class PrettyOutput:
         panel = Panel(
             content,
             border_style=header_styles[output_type],
-            title=header,
-            title_align="left",
             padding=(0, 0),
             highlight=True,
         )
         if get_pretty_output():
             console.print(panel)
         else:
-            if len(text.strip().splitlines()) > 1:
-                console.print(header)
-                console.print(content)
-            else:
-                console.print(header, content)
+            console.print(content)
         if traceback or output_type == OutputType.ERROR:
             try:
                 console.print_exception()