comate-cli 0.1.0__py3-none-any.whl

comate_cli/terminal_agent/fragment_utils.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+
+def clip_fragments(
+    fragments: list[tuple[str, str]],
+    max_len: int,
+) -> list[tuple[str, str]]:
+    if max_len <= 0:
+        return []
+
+    remaining = max_len
+    clipped: list[tuple[str, str]] = []
+    for style, text in fragments:
+        if remaining <= 0:
+            break
+        if len(text) <= remaining:
+            clipped.append((style, text))
+            remaining -= len(text)
+            continue
+        clipped.append((style, text[:remaining]))
+        break
+
+    return clipped

comate_cli/terminal_agent/history_printer.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from rich.console import Console, Group
+from rich.text import Text
+
+from comate_cli.terminal_agent.models import HistoryEntry
+
+
+def _entry_prefix(entry: HistoryEntry) -> str:
+    if entry.entry_type == "user":
+        return ">"
+    if entry.entry_type == "assistant":
+        return "⏺"
+    if entry.entry_type == "tool_call":
+        return "→"
+    if entry.entry_type == "tool_result":
+        return "●"
+    if entry.entry_type == "thinking":
+        return "💭"
+    return "•"
+
+
+def _entry_content(
+    entry: HistoryEntry,
+    *,
+    terminal_width: int,
+    render_markdown_to_plain: Callable[..., str],
+) -> str:
+    if entry.entry_type != "assistant":
+        return str(entry.text)
+    width = max(terminal_width - 6, 40)
+    return render_markdown_to_plain(str(entry.text), width=width)
+
+
+def render_history_group(
+    console: Console,
+    entries: list[HistoryEntry],
+    *,
+    terminal_width: int,
+    render_markdown_to_plain: Callable[..., str],
+) -> Group | None:
+    if not entries:
+        return None
+
+    renderables: list[Any] = []
+    for entry in entries:
+        # Thinking entries: 灰色显示，无前缀
+        if entry.entry_type == "thinking":
+            content = str(entry.text)
+            content_lines = content.splitlines() or [""]
+            line_text = Text()
+            line_text.append("  ", style="dim")
+            line_text.append(content_lines[0], style="dim")
+            for line in content_lines[1:]:
+                line_text.append("\n")
+                line_text.append("  ", style="dim")
+                line_text.append(line, style="dim")
+            renderables.append(line_text)
+            renderables.append(Text(""))
+            continue
+
+        # Elapsed entries: 灰色显示，无前缀
+        if entry.entry_type == "elapsed":
+            line_text = Text()
+            line_text.append(str(entry.text), style="dim")
+            renderables.append(line_text)
+            renderables.append(Text(""))
+            continue
+
+        # System entries: 按 severity 区分视觉样式
+        if entry.entry_type == "system":
+            if entry.severity == "error":
+                prefix_char = "✖"
+                prefix_style = "#FF9FC6"
+            elif entry.severity == "warning":
+                prefix_char = "⚠"
+                prefix_style = "#B8B630"
+            else:
+                prefix_char = "•"
+                prefix_style = "dim"
+            line_text = Text()
+            line_text.append(f"{prefix_char} ", style=prefix_style)
+            line_text.append(str(entry.text), style=prefix_style)
+            renderables.append(line_text)
+            renderables.append(Text(""))
+            continue
+
+        if entry.entry_type == "tool_result":
+            prefix_char = "✖" if entry.severity == "error" else "●"
+            prefix_style = "bold red" if entry.severity == "error" else "bold green"
+
+            if isinstance(entry.text, Text):
+                # Rich Text object — preserve styled content (e.g. colored diff)
+                line_text = Text()
+                line_text.append(f"{prefix_char} ", style=prefix_style)
+                line_text.append_text(entry.text)
+                renderables.append(line_text)
+                renderables.append(Text(""))
+                continue
+
+            content = str(entry.text)
+            content_lines = content.splitlines() or [""]
+
+            line_text = Text()
+            line_text.append(f"{prefix_char} ", style=prefix_style)
+            line_text.append(content_lines[0])
+            for line in content_lines[1:]:
+                line_text.append("\n")
+                line_text.append("  ")
+                line_text.append(line)
+
+            renderables.append(line_text)
+            renderables.append(Text(""))
+            continue
+
+        if hasattr(entry.text, "__rich_console__"):
+            prefix = _entry_prefix(entry)
+            prefixed = Text(f"{prefix} ", style="bold")
+            prefixed.append_text(entry.text)  # type: ignore[arg-type]
+            renderables.append(prefixed)
+        else:
+            prefix = _entry_prefix(entry)
+            content = _entry_content(
+                entry,
+                terminal_width=terminal_width,
+                render_markdown_to_plain=render_markdown_to_plain,
+            )
+            content_lines = content.splitlines() or [""]
+            lines = [f"{prefix} {content_lines[0]}"]
+            for line in content_lines[1:]:
+                lines.append(f"  {line}")
+            renderables.append("\n".join(lines))
+
+        renderables.append(Text(""))
+
+    if not renderables:
+        return None
+
+    return Group(*renderables)
+
+
+async def print_history_group_async(console: Console, group: Group) -> None:
+    console.print(group)
+
+
+def print_history_group_sync(console: Console, group: Group) -> None:
+    console.print(group)

comate_cli/terminal_agent/input_geometry.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from prompt_toolkit.utils import get_cwidth
+
+
+def compute_visual_line_ranges(text: str, max_cols: int) -> list[tuple[int, int]]:
+    """
+    Compute visual line ranges [start, end) by wrapping `text` at `max_cols`
+    display cells, respecting explicit newlines.
+    """
+    if max_cols <= 0:
+        max_cols = 1
+
+    ranges: list[tuple[int, int]] = []
+    start = 0
+    col = 0
+    for idx, ch in enumerate(text):
+        if ch == "\n":
+            ranges.append((start, idx))
+            start = idx + 1
+            col = 0
+            continue
+
+        ch_width = get_cwidth(ch)
+        if ch_width <= 0:
+            ch_width = 1
+        if ch_width > max_cols:
+            ch_width = max_cols
+
+        if col + ch_width > max_cols:
+            ranges.append((start, idx))
+            start = idx
+            col = 0
+
+        col += ch_width
+
+    ranges.append((start, len(text)))
+    return ranges
+
+
+def visual_col_for_index(
+    text: str,
+    start: int,
+    end: int,
+    max_cols: int,
+    index: int,
+) -> int:
+    if max_cols <= 0:
+        max_cols = 1
+    if index < start:
+        return 0
+    if index > end:
+        index = end
+    col = 0
+    for ch in text[start:index]:
+        ch_width = get_cwidth(ch)
+        if ch_width <= 0:
+            ch_width = 1
+        if ch_width > max_cols:
+            ch_width = max_cols
+        if col + ch_width > max_cols:
+            break
+        col += ch_width
+    return col
+
+
+def index_for_visual_col(
+    text: str,
+    start: int,
+    end: int,
+    max_cols: int,
+    target_col: int,
+) -> int:
+    if max_cols <= 0:
+        max_cols = 1
+    if target_col <= 0:
+        return start
+    if target_col > max_cols:
+        target_col = max_cols
+    col = 0
+    for idx in range(start, end):
+        ch = text[idx]
+        ch_width = get_cwidth(ch)
+        if ch_width <= 0:
+            ch_width = 1
+        if ch_width > max_cols:
+            ch_width = max_cols
+        if col + ch_width > target_col:
+            return idx
+        col += ch_width
+    return end
+

comate_cli/terminal_agent/layout_coordinator.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from rich.console import Console, Group, RenderableType
+from rich.live import Live
+from rich.segment import Segment, Segments
+from rich.text import Text
+
+_TODO_MIN_LINES = 6
+
+
+def _is_empty_text(renderable: RenderableType | None) -> bool:
+    return isinstance(renderable, Text) and not renderable.plain
+
+
+def _renderable_to_lines(console: Console, renderable: RenderableType | None) -> list[list[Segment]]:
+    if renderable is None:
+        return []
+    if _is_empty_text(renderable):
+        return []
+    return console.render_lines(renderable, console.options, pad=False, new_lines=False)
+
+
+def _lines_to_renderable(lines: list[list[Segment]]) -> RenderableType | None:
+    if not lines:
+        return None
+    segments: list[Segment] = []
+    last_index = len(lines) - 1
+    for idx, line in enumerate(lines):
+        segments.extend(line)
+        if idx != last_index:
+            segments.append(Segment.line())
+    return Segments(segments, new_lines=False)
+
+
+def _total_height(*layers: list[list[Segment]]) -> int:
+    non_empty = [layer for layer in layers if layer]
+    if not non_empty:
+        return 0
+    return sum(len(layer) for layer in non_empty) + max(0, len(non_empty) - 1)
+
+
+class TerminalLayoutCoordinator:
+    """Single Live owner for loading/message/todo layers."""
+
+    def __init__(
+        self,
+        console: Console,
+        *,
+        target_fps: int = 12,
+    ) -> None:
+        normalized_fps = max(4, min(int(target_fps), 24))
+        self._console = console
+        self._target_fps = normalized_fps
+        self._turn_active = False
+        self._live: Live | None = None
+        self._dirty = False
+        self._loading_layer: RenderableType | None = None
+        self._message_layer: RenderableType | None = Text("")
+        self._todo_layer: RenderableType | None = None
+
+    def start_turn(self) -> None:
+        self._turn_active = True
+        self._dirty = True
+        self._ensure_live()
+        self.refresh(force=True)
+
+    def stop_turn(self) -> None:
+        if not self._turn_active:
+            return
+        self.refresh(force=True)
+        self._stop_live()
+        self._turn_active = False
+
+    def close(self) -> None:
+        self._stop_live()
+        self._turn_active = False
+
+    def update_layers(
+        self,
+        *,
+        loading: RenderableType | None,
+        message: RenderableType | None,
+        todo: RenderableType | None,
+    ) -> None:
+        self._loading_layer = loading
+        self._message_layer = message
+        self._todo_layer = todo
+        self._dirty = True
+
+    def refresh(self, *, force: bool = False) -> None:
+        if not self._turn_active:
+            return
+        if not force and not self._dirty:
+            return
+
+        self._ensure_live()
+        if self._live is None:
+            return
+        self._live.update(self._compose(), refresh=True)
+        self._dirty = False
+
+    def _ensure_live(self) -> None:
+        if self._live is not None:
+            return
+        self._live = Live(
+            Text(""),
+            console=self._console,
+            transient=False,
+            refresh_per_second=self._target_fps,
+            vertical_overflow="crop",
+            redirect_stdout=False,
+            redirect_stderr=False,
+        )
+        self._live.start()
+
+    def _stop_live(self) -> None:
+        if self._live is None:
+            return
+        self._live.stop()
+        self._live = None
+
+    def _compose(self) -> RenderableType:
+        message_lines = _renderable_to_lines(self._console, self._message_layer)
+        todo_lines = _renderable_to_lines(self._console, self._todo_layer)
+        loading_lines = _renderable_to_lines(self._console, self._loading_layer)
+
+        max_height = max(int(self._console.size.height), 1)
+        while True:
+            total = _total_height(message_lines, todo_lines, loading_lines)
+            if total <= max_height:
+                break
+
+            overflow = total - max_height
+            progressed = False
+
+            if message_lines and overflow > 0:
+                drop = min(overflow, len(message_lines))
+                message_lines = message_lines[drop:]
+                progressed = progressed or drop > 0
+
+            total = _total_height(message_lines, todo_lines, loading_lines)
+            overflow = max(0, total - max_height)
+            if todo_lines and overflow > 0 and len(todo_lines) > _TODO_MIN_LINES:
+                max_drop = len(todo_lines) - _TODO_MIN_LINES
+                drop = min(overflow, max_drop)
+                todo_lines = todo_lines[: len(todo_lines) - drop]
+                progressed = progressed or drop > 0
+
+            total = _total_height(message_lines, todo_lines, loading_lines)
+            overflow = max(0, total - max_height)
+            if loading_lines and overflow > 0:
+                original_len = len(loading_lines)
+                keep = max(original_len - overflow, 1)
+                dropped = original_len - keep
+                loading_lines = loading_lines[-keep:]
+                progressed = progressed or dropped > 0
+
+            total = _total_height(message_lines, todo_lines, loading_lines)
+            overflow = max(0, total - max_height)
+            if todo_lines and overflow > 0:
+                original_len = len(todo_lines)
+                keep = max(original_len - overflow, 1)
+                dropped = original_len - keep
+                todo_lines = todo_lines[:keep]
+                progressed = progressed or dropped > 0
+
+            if not progressed:
+                break
+
+        message = _lines_to_renderable(message_lines)
+        todo = _lines_to_renderable(todo_lines)
+        loading = _lines_to_renderable(loading_lines)
+
+        parts: list[RenderableType] = []
+        if message is not None:
+            parts.append(message)
+        if todo is not None:
+            if parts:
+                parts.append(Text(""))
+            parts.append(todo)
+        if loading is not None:
+            if parts:
+                parts.append(Text(""))
+            parts.append(loading)
+
+        if not parts:
+            return Text("")
+        return Group(*parts)

comate_cli/terminal_agent/logging_adapter.py

@@ -0,0 +1,147 @@
+"""TUI logging adapter - 将日志输出到 prompt_toolkit TUI 而不破坏界面"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.application import run_in_terminal
+
+if TYPE_CHECKING:
+    from comate_cli.terminal_agent.event_renderer import EventRenderer
+
+
+class TUILoggingHandler(logging.Handler):
+    """自定义 logging handler，将日志友好地显示在 TUI 中
+
+    特性：
+    - WARNING/ERROR 显示给用户，带颜色标识
+    - 首次显示机制：相同消息只显示一次
+    - 使用 run_in_terminal() 不破坏 prompt_toolkit 界面
+    """
+
+    def __init__(self, renderer: EventRenderer) -> None:
+        super().__init__()
+        self._renderer = renderer
+        self._shown_messages: set[str] = set()  # 跟踪已显示的消息（首次显示）
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """处理日志记录"""
+        try:
+            # 只处理 WARNING 和 ERROR
+            if record.levelno < logging.WARNING:
+                return
+
+            # 生成友好消息
+            msg = self._format_message(record)
+            if not msg:
+                return
+
+            # 首次显示检查
+            msg_key = self._get_message_key(record)
+            if msg_key in self._shown_messages:
+                return
+            self._shown_messages.add(msg_key)
+
+            # 按日志级别映射 severity，渲染层负责视觉区分
+            if record.levelno >= logging.ERROR:
+                severity = "error"
+            else:
+                severity = "warning"
+            self._append_to_tui(msg, severity=severity)
+
+        except Exception:
+            self.handleError(record)
+
+    def _format_message(self, record: logging.LogRecord) -> str:
+        """格式化日志消息为用户友好格式（不嵌入 emoji，由渲染层负责视觉样式）"""
+        msg = record.getMessage()
+
+        # 特殊处理：token count fallback
+        if "token count failed" in msg.lower() and "fallback" in msg.lower():
+            return "Token estimation using fallback (working normally)"
+
+        return self._simplify_message(msg)
+
+    def _simplify_message(self, msg: str) -> str:
+        """简化技术细节"""
+        # 去掉常见的技术参数
+        if "exc_type=" in msg:
+            # 截断到第一个技术参数之前
+            parts = msg.split("exc_type=")
+            msg = parts[0].rstrip(": ,")
+
+        if "timeout_ms=" in msg:
+            parts = msg.split("timeout_ms=")
+            msg = parts[0].rstrip(": ,")
+
+        # 限制长度
+        max_len = 100
+        if len(msg) > max_len:
+            msg = msg[:max_len] + "..."
+
+        return msg
+
+    def _get_message_key(self, record: logging.LogRecord) -> str:
+        """生成消息的唯一键（用于首次显示检查）"""
+        # 使用 logger 名称 + 消息内容的前 50 个字符
+        msg = record.getMessage()
+        # 对于 token count，使用固定 key
+        if "token count failed" in msg.lower():
+            return "token_count_fallback"
+        # 其他消息用完整内容作为 key
+        return f"{record.name}:{msg[:50]}"
+
+    def _append_to_tui(self, msg: str, *, severity: str = "warning") -> None:
+        """将消息追加到 TUI（通过 run_in_terminal 避免破坏界面）"""
+        def _append() -> None:
+            self._renderer.append_system_message(msg, severity=severity)  # type: ignore[arg-type]
+
+        # 使用 run_in_terminal 确保不破坏 prompt_toolkit 的输入
+        # 如果没有运行中的真实 Application，直接调用（测试或初始化阶段）
+        try:
+            from prompt_toolkit.application import get_app
+            from prompt_toolkit.application.dummy import DummyApplication
+            app = get_app()
+            if isinstance(app, DummyApplication):
+                # DummyApplication，直接调用
+                _append()
+            else:
+                # 真实 app，使用 run_in_terminal
+                run_in_terminal(_append, in_executor=False)
+        except Exception:
+            # 没有 app 或导入失败，直接调用
+            _append()
+
+
+def setup_tui_logging(renderer: EventRenderer) -> None:
+    """统一日志初始化：文件 + TUI 双通道。
+
+    - 所有日志（含 traceback）写入 ~/.comate/logs/agent.log（RotatingFileHandler）
+    - WARNING/ERROR 以用户友好格式显示在 TUI scrollback
+    - 清除 root logger 默认的 stderr handler，阻止 traceback 泄漏到终端
+    """
+    import os
+    from logging.handlers import RotatingFileHandler
+
+    # 1. 日志文件 handler（完整调试信息，含 traceback）
+    log_dir = os.path.join(os.path.expanduser("~"), ".comate", "logs")
+    os.makedirs(log_dir, exist_ok=True)
+    log_path = os.path.join(log_dir, "agent.log")
+    file_handler = RotatingFileHandler(
+        log_path, maxBytes=10 * 1024 * 1024, backupCount=3, encoding="utf-8",
+    )
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(
+        logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
+    )
+
+    # 2. 清除 root logger 的所有 handler，阻止 stderr 泄漏
+    root = logging.getLogger()
+    root.handlers.clear()
+    root.addHandler(file_handler)
+    root.setLevel(logging.DEBUG)
+
+    # 3. TUI handler 挂到 root（覆盖所有命名空间的 WARNING/ERROR）
+    tui_handler = TUILoggingHandler(renderer)
+    tui_handler.setLevel(logging.WARNING)
+    root.addHandler(tui_handler)

comate_cli/terminal_agent/logo.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from rich.console import Console
+from rich.text import Text
+
+_LOGO_LINES: tuple[str, ...] = (
+    "",
+    "  ██████╗ ██████╗ ███╗   ███╗ █████╗ ████████╗███████╗",
+    " ██╔════╝██╔═══██╗████╗ ████║██╔══██╗╚══██╔══╝██╔════╝",
+    " ██║     ██║   ██║██╔████╔██║███████║   ██║   █████╗  ",
+    " ██║     ██║   ██║██║╚██╔╝██║██╔══██║   ██║   ██╔══╝  ",
+    " ╚██████╗╚██████╔╝██║ ╚═╝ ██║██║  ██║   ██║   ███████╗",
+    "  ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝   ╚═╝   ╚══════╝",
+)
+
+
+def _lerp_rgb(
+    start_rgb: tuple[int, int, int],
+    end_rgb: tuple[int, int, int],
+    ratio: float,
+) -> tuple[int, int, int]:
+    clamped = max(0.0, min(1.0, ratio))
+    r = int(start_rgb[0] + (end_rgb[0] - start_rgb[0]) * clamped)
+    g = int(start_rgb[1] + (end_rgb[1] - start_rgb[1]) * clamped)
+    b = int(start_rgb[2] + (end_rgb[2] - start_rgb[2]) * clamped)
+    return r, g, b
+
+
+def _resolve_version() -> str:
+    try:
+        return f"v{version('comate-cli')}"
+    except PackageNotFoundError:
+        try:
+            return f"v{version('comate-agent-sdk')}"
+        except PackageNotFoundError:
+            return "v0.1.0-dev"
+
+
+def print_logo(console: Console) -> None:
+    start_rgb = (67, 114, 240)
+    end_rgb = (54, 214, 220)
+    line_count = len(_LOGO_LINES)
+
+    logo_text = Text()
+    for idx, line in enumerate(_LOGO_LINES):
+        ratio = idx / max(line_count - 1, 1)
+        r, g, b = _lerp_rgb(start_rgb, end_rgb, ratio)
+        logo_text.append(line, style=f"bold rgb({r},{g},{b})")
+        if idx < line_count - 1:
+            logo_text.append("\n")
+
+    console.print(logo_text)
+    console.print(
+        Text(f"  {_resolve_version()}  Product-grade terminal agent UI", style="dim")
+    )
+    console.print()

comate_cli/terminal_agent/markdown_render.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from io import StringIO
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+def render_markdown_to_plain(content: str, *, width: int) -> str:
+    normalized_width = max(int(width), 40)
+    try:
+        sink = StringIO()
+        console = Console(
+            file=sink,
+            width=normalized_width,
+            force_terminal=False,
+            color_system=None,
+            soft_wrap=True,
+        )
+        console.print(Markdown(content, code_theme="monokai", hyperlinks=False))
+        rendered = sink.getvalue().rstrip("\n")
+        return rendered
+    except Exception:
+        return content