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

jarvis/jarvis_utils/methodology.py

@@ -208,7 +208,9 @@ def load_methodology(
         if not methodologies:
             PrettyOutput.print("没有找到方法论文件", OutputType.WARNING)
             return ""
-        PrettyOutput.print(f"加载方法论文件完成 (共 {len(methodologies)} 个)", OutputType.SUCCESS)
+        PrettyOutput.print(
+            f"加载方法论文件完成 (共 {len(methodologies)} 个)", OutputType.SUCCESS
+        )
 
         if platform_name:
             platform = PlatformRegistry().create_platform(platform_name)

jarvis/jarvis_utils/output.py

@@ -10,7 +10,7 @@
 """
 from datetime import datetime
 from enum import Enum
-from typing import Dict, Optional, Tuple, Any
+from typing import Dict, Optional, Tuple, Any, List
 
 from pygments.lexers import guess_lexer
 from pygments.util import ClassNotFound
@@ -20,8 +20,10 @@ from rich.style import Style as RichStyle
 from rich.syntax import Syntax
 from rich.text import Text
 
-from jarvis.jarvis_utils.config import get_pretty_output
+from jarvis.jarvis_utils.config import get_pretty_output, is_print_error_traceback
 from jarvis.jarvis_utils.globals import console, get_agent_list
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
 
 
 class OutputType(Enum):
@@ -57,124 +59,60 @@ class OutputType(Enum):
     TOOL = "TOOL"
 
 
-class PrettyOutput:
+@dataclass
+class OutputEvent:
     """
-    使用rich库格式化和显示富文本输出的类。
-
-    提供以下方法：
-    - 使用适当的样式格式化不同类型的输出
-    - 代码块的语法高亮
-    - 结构化内容的面板显示
-    - 渐进显示的流式输出
+    输出事件的通用结构，供不同输出后端（Sink）消费。
+    - text: 文本内容
+    - output_type: 输出类型
+    - timestamp: 是否显示时间戳
+    - lang: 语法高亮语言（可选，不提供则自动检测）
+    - traceback: 是否显示异常堆栈
+    - section: 若为章节标题输出，填入标题文本；否则为None
+    - context: 额外上下文（预留给TUI/日志等）
     """
 
-    # 不同输出类型的图标
-    _ICONS = {
-        OutputType.SYSTEM: "🤖",
-        OutputType.CODE: "📝",
-        OutputType.RESULT: "✨",
-        OutputType.ERROR: "❌",
-        OutputType.INFO: "ℹ️",
-        OutputType.PLANNING: "📋",
-        OutputType.PROGRESS: "⏳",
-        OutputType.SUCCESS: "✅",
-        OutputType.WARNING: "⚠️",
-        OutputType.DEBUG: "🔍",
-        OutputType.USER: "👤",
-        OutputType.TOOL: "🔧",
-    }
-    # 语法高亮的语言映射
-    _lang_map = {
-        "Python": "python",
-        "JavaScript": "javascript",
-        "TypeScript": "typescript",
-        "Java": "java",
-        "C++": "cpp",
-        "C#": "csharp",
-        "Ruby": "ruby",
-        "PHP": "php",
-        "Go": "go",
-        "Rust": "rust",
-        "Bash": "bash",
-        "HTML": "html",
-        "CSS": "css",
-        "SQL": "sql",
-        "R": "r",
-        "Kotlin": "kotlin",
-        "Swift": "swift",
-        "Scala": "scala",
-        "Perl": "perl",
-        "Lua": "lua",
-        "YAML": "yaml",
-        "JSON": "json",
-        "XML": "xml",
-        "Markdown": "markdown",
-        "Text": "text",
-        "Shell": "bash",
-        "Dockerfile": "dockerfile",
-        "Makefile": "makefile",
-        "INI": "ini",
-        "TOML": "toml",
-    }
+    text: str
+    output_type: OutputType
+    timestamp: bool = True
+    lang: Optional[str] = None
+    traceback: bool = False
+    section: Optional[str] = None
+    context: Optional[Dict[str, Any]] = None
 
-    @staticmethod
-    def _detect_language(text: str, default_lang: str = "markdown") -> str:
-        """
-        检测给定文本的编程语言。
 
-        参数：
-            text: 要分析的文本
-            default_lang: 如果检测失败，默认返回的语言
+class OutputSink(ABC):
+    """输出后端抽象接口，不同前端（控制台/TUI/SSE/日志）实现该接口以消费输出事件。"""
 
-        返回：
-            str: 检测到的语言名称
-        """
-        try:
-            lexer = guess_lexer(text)
-            detected_lang = lexer.name  # type: ignore[attr-defined]
-            return PrettyOutput._lang_map.get(detected_lang, default_lang)
-        except (ClassNotFound, Exception):
-            return default_lang
+    @abstractmethod
+    def emit(self, event: OutputEvent) -> None:  # pragma: no cover - 抽象方法
+        raise NotImplementedError
 
-    @staticmethod
-    def _format(output_type: OutputType, timestamp: bool = True) -> str:
-        """
-        使用时间戳和图标格式化输出头。
 
-        参数：
-            output_type: 输出类型
-            timestamp: 是否包含时间戳
+class ConsoleOutputSink(OutputSink):
+    """
+    默认控制台输出实现，保持与原 PrettyOutput 行为一致。
+    """
 
-        返回：
-            Text: 格式化后的rich Text对象
-        """
-        icon = PrettyOutput._ICONS.get(output_type, "")
-        formatted = f"{icon}  "
-        if timestamp:
-            formatted += f"[{datetime.now().strftime('%H:%M:%S')}][{output_type.value}]"
-        agent_info = get_agent_list()
-        if agent_info:
-            formatted += f"[{agent_info}]"
-        return formatted
+    def emit(self, event: OutputEvent) -> None:
+        # 章节输出
+        if event.section is not None:
+            text = Text(event.section, style=event.output_type.value, justify="center")
+            panel = Panel(text, border_style=event.output_type.value)
+            if get_pretty_output():
+                console.print(panel)
+            else:
+                console.print(text)
+            return
 
-    @staticmethod
-    def print(
-        text: str,
-        output_type: OutputType,
-        timestamp: bool = True,
-        lang: Optional[str] = None,
-        traceback: bool = False,
-    ):
-        """
-        使用样式和语法高亮打印格式化输出。
+        # 普通内容输出
+        lang = (
+            event.lang
+            if event.lang is not None
+            else PrettyOutput._detect_language(event.text, default_lang="markdown")
+        )
 
-        参数：
-            text: 要打印的文本内容
-            output_type: 输出类型（影响样式）
-            timestamp: 是否显示时间戳
-            lang: 语法高亮的语言
-            traceback: 是否显示错误的回溯信息
-        """
+        # 与原实现保持一致的样式定义
         styles: Dict[OutputType, Dict[str, Any]] = {
             OutputType.SYSTEM: dict(bgcolor="#1e2b3c"),
             OutputType.CODE: dict(bgcolor="#1c2b1c"),
@@ -255,25 +193,20 @@ class PrettyOutput:
             ),
         }
 
-        lang = (
-            lang
-            if lang is not None
-            else PrettyOutput._detect_language(text, default_lang="markdown")
-        )
         header = Text(
-            PrettyOutput._format(output_type, timestamp),
-            style=header_styles[output_type],
+            PrettyOutput._format(event.output_type, event.timestamp),
+            style=header_styles[event.output_type],
         )
         content = Syntax(
-            text,
+            event.text,
             lang,
             theme="monokai",
             word_wrap=True,
-            background_color=styles[output_type]["bgcolor"],
+            background_color=styles[event.output_type]["bgcolor"],
         )
         panel = Panel(
             content,
-            border_style=header_styles[output_type],
+            border_style=header_styles[event.output_type],
             padding=(0, 0),
             highlight=True,
         )
@@ -281,27 +214,183 @@ class PrettyOutput:
             console.print(panel)
         else:
             console.print(content)
-        if traceback or output_type == OutputType.ERROR:
+        if event.traceback or (
+            event.output_type == OutputType.ERROR and is_print_error_traceback()
+        ):
             try:
                 console.print_exception()
             except Exception as e:
                 console.print(f"Error: {e}")
 
+
+# 模块级输出分发器（默认注册控制台后端）
+_output_sinks: List[OutputSink] = [ConsoleOutputSink()]
+
+
+def emit_output(event: OutputEvent) -> None:
+    """向所有已注册的输出后端广播事件。"""
+    for sink in list(_output_sinks):
+        try:
+            sink.emit(event)
+        except Exception as e:
+            # 后端故障不影响其他后端
+            console.print(f"[输出后端错误] {sink.__class__.__name__}: {e}")
+
+
+class PrettyOutput:
+    """
+    使用rich库格式化和显示富文本输出的类。
+
+    提供以下方法：
+    - 使用适当的样式格式化不同类型的输出
+    - 代码块的语法高亮
+    - 结构化内容的面板显示
+    - 渐进显示的流式输出
+    """
+
+    # 不同输出类型的图标
+    _ICONS = {
+        OutputType.SYSTEM: "🤖",
+        OutputType.CODE: "📝",
+        OutputType.RESULT: "✨",
+        OutputType.ERROR: "❌",
+        OutputType.INFO: "ℹ️",
+        OutputType.PLANNING: "📋",
+        OutputType.PROGRESS: "⏳",
+        OutputType.SUCCESS: "✅",
+        OutputType.WARNING: "⚠️",
+        OutputType.DEBUG: "🔍",
+        OutputType.USER: "👤",
+        OutputType.TOOL: "🔧",
+    }
+    # 语法高亮的语言映射
+    _lang_map = {
+        "Python": "python",
+        "JavaScript": "javascript",
+        "TypeScript": "typescript",
+        "Java": "java",
+        "C++": "cpp",
+        "C#": "csharp",
+        "Ruby": "ruby",
+        "PHP": "php",
+        "Go": "go",
+        "Rust": "rust",
+        "Bash": "bash",
+        "HTML": "html",
+        "CSS": "css",
+        "SQL": "sql",
+        "R": "r",
+        "Kotlin": "kotlin",
+        "Swift": "swift",
+        "Scala": "scala",
+        "Perl": "perl",
+        "Lua": "lua",
+        "YAML": "yaml",
+        "JSON": "json",
+        "XML": "xml",
+        "Markdown": "markdown",
+        "Text": "text",
+        "Shell": "bash",
+        "Dockerfile": "dockerfile",
+        "Makefile": "makefile",
+        "INI": "ini",
+        "TOML": "toml",
+    }
+
     @staticmethod
-    def section(title: str, output_type: OutputType = OutputType.INFO):
+    def _detect_language(text: str, default_lang: str = "markdown") -> str:
         """
-        在样式化面板中打印章节标题。
+        检测给定文本的编程语言。
 
         参数：
-            title: 章节标题文本
-            output_type: 输出类型（影响样式）
+            text: 要分析的文本
+            default_lang: 如果检测失败，默认返回的语言
+
+        返回：
+            str: 检测到的语言名称
         """
-        text = Text(title, style=output_type.value, justify="center")
-        panel = Panel(text, border_style=output_type.value)
-        if get_pretty_output():
-            console.print(panel)
+        try:
+            lexer = guess_lexer(text)
+            detected_lang = lexer.name  # type: ignore[attr-defined]
+            return PrettyOutput._lang_map.get(detected_lang, default_lang)
+        except (ClassNotFound, Exception):
+            return default_lang
+
+    @staticmethod
+    def _format(output_type: OutputType, timestamp: bool = True) -> str:
+        """
+        使用时间戳和图标格式化输出头。
+
+        参数：
+            output_type: 输出类型
+            timestamp: 是否包含时间戳
+
+        返回：
+            Text: 格式化后的rich Text对象
+        """
+        icon = PrettyOutput._ICONS.get(output_type, "")
+        formatted = f"{icon}  "
+        if timestamp:
+            formatted += f"[{datetime.now().strftime('%H:%M:%S')}][{output_type.value}]"
+        agent_info = get_agent_list()
+        if agent_info:
+            formatted += f"[{agent_info}]"
+        return formatted
+
+    @staticmethod
+    def print(
+        text: str,
+        output_type: OutputType,
+        timestamp: bool = True,
+        lang: Optional[str] = None,
+        traceback: bool = False,
+    ):
+        """
+        使用样式和语法高亮打印格式化输出（已抽象为事件 + Sink 机制）。
+        保持对现有调用方的向后兼容，同时为TUI/日志等前端预留扩展点。
+        """
+        event = OutputEvent(
+            text=text,
+            output_type=output_type,
+            timestamp=timestamp,
+            lang=lang,
+            traceback=traceback,
+        )
+        emit_output(event)
+
+    @staticmethod
+    def section(title: str, output_type: OutputType = OutputType.INFO):
+        """
+        在样式化面板中打印章节标题（通过事件 + Sink 机制分发）。
+        """
+        event = OutputEvent(
+            text="",
+            output_type=output_type,
+            section=title,
+        )
+        emit_output(event)
+
+    @staticmethod
+    # Sink管理（为外部注册自定义后端预留）
+    @staticmethod
+    def add_sink(sink: OutputSink) -> None:
+        """注册一个新的输出后端。"""
+        _output_sinks.append(sink)
+
+    @staticmethod
+    def clear_sinks(keep_default: bool = True) -> None:
+        """清空已注册的输出后端；可选择保留默认控制台后端。"""
+        if keep_default:
+            globals()["_output_sinks"] = [
+                s for s in _output_sinks if isinstance(s, ConsoleOutputSink)
+            ]
         else:
-            console.print(text)
+            _output_sinks.clear()
+
+    @staticmethod
+    def get_sinks() -> List[OutputSink]:
+        """获取当前已注册的输出后端列表（副本）。"""
+        return list(_output_sinks)
 
     @staticmethod
     def print_gradient_text(