comate-cli 0.3.2__tar.gz → 0.3.3__tar.gz

{comate_cli-0.3.2 → comate_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.3.2
+Version: 0.3.3
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

comate_cli-0.3.3/comate_cli/terminal_agent/codenames.py

@@ -0,0 +1,14 @@
+"""Version codenames — one entry per memorable release."""
+
+from __future__ import annotations
+
+CODENAMES: dict[str, str] = {
+    "0.3.3": "Update for My Brothers",
+    "0.3.2": "We are with Ukraine",
+}
+
+
+def get_codename(ver: str) -> str | None:
+    """Return codename for a version string like '0.3.2' or 'v0.3.2'."""
+    stripped = ver.lstrip("v")
+    return CODENAMES.get(stripped)

comate_cli-0.3.3/comate_cli/terminal_agent/error_display.py

@@ -0,0 +1,83 @@
+"""Unified error formatter for terminal agent."""
+from __future__ import annotations
+
+import re
+
+
+def format_error(exc: Exception) -> tuple[str, str, str]:
+    """Convert exception to user-friendly (message, transient_summary, severity).
+
+    - message: full error text for scrollback (plain English, no icons)
+    - transient_summary: short text for status bar transient notification
+    - severity: "error" or "warning"
+    """
+    exc_type = type(exc).__name__
+    exc_msg = str(exc)
+
+    # LLM Provider errors
+    if exc_type == "ModelRateLimitError":
+        return "Rate limit exceeded", "Rate limited", "warning"
+
+    if exc_type == "ModelProviderError":
+        code = getattr(exc, "status_code", None)
+
+        # Context size exceeded (400 with specific body pattern)
+        if code == 400:
+            ctx = _parse_context_size_error(exc_msg)
+            if ctx:
+                return (
+                    f"Request ({ctx[0]} tokens) exceeds context limit ({ctx[1]})",
+                    "Context limit exceeded",
+                    "error",
+                )
+            return f"API error: {_truncate(exc_msg, 80)}", "API error", "error"
+
+        if code == 401:
+            return "Invalid or expired API key", "Auth failed", "error"
+        if code == 403:
+            return "Access denied to this model", "Access denied", "error"
+        if code == 404:
+            return "Model not found or invalid API path", "Model not found", "error"
+        if code and code >= 500:
+            return f"Server error ({code})", "Server error", "warning"
+        return f"API error: {_truncate(exc_msg, 80)}", "API error", "error"
+
+    # Session errors
+    if exc_type == "ChatSessionClosedError":
+        return "Session closed", "Session closed", "error"
+
+    # Network errors (heuristic)
+    lower_msg = exc_msg.lower()
+    if "timeout" in lower_msg or "timed out" in lower_msg:
+        return "Request timed out", "Timed out", "warning"
+    if "connection" in lower_msg:
+        return "Connection failed", "Connection failed", "error"
+
+    # Generic fallback
+    return f"Error: {_truncate(exc_msg, 80)}", "Error occurred", "error"
+
+
+def _parse_context_size_error(msg: str) -> tuple[str, str] | None:
+    """Extract (prompt_tokens, ctx_limit) from context size error body.
+
+    Matches patterns like 'n_prompt_tokens': 35099, 'n_ctx': 32768
+    or 'request (35099 tokens) exceeds the available context size (32768 tokens)'.
+    """
+    m = re.search(r"n_prompt_tokens['\"]?:\s*(\d+)", msg)
+    n = re.search(r"n_ctx['\"]?:\s*(\d+)", msg)
+    if m and n:
+        return m.group(1), n.group(1)
+
+    m2 = re.search(r"request\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
+    n2 = re.search(r"context\s*size\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
+    if m2 and n2:
+        return m2.group(1), n2.group(1)
+
+    if "exceed_context_size_error" in msg:
+        return None  # Type matches but can't parse numbers — fall through to generic 400
+
+    return None
+
+
+def _truncate(s: str, max_len: int) -> str:
+    return s[:max_len] + "..." if len(s) > max_len else s

{comate_cli-0.3.2 → comate_cli-0.3.3}/comate_cli/terminal_agent/history_printer.py

@@ -85,17 +85,13 @@ def render_history_group(
         # System entries: 按 severity 区分视觉样式
         if entry.entry_type == "system":
             if entry.severity == "error":
-                prefix_char = "✖"
-                prefix_style = "#FF9FC6"
+                text_style = "bold #FF6B6B"
             elif entry.severity == "warning":
-                prefix_char = "⚠"
-                prefix_style = "#B8B630"
+                text_style = "#E8B830"
             else:
-                prefix_char = "•"
-                prefix_style = "dim"
+                text_style = "dim"
             line_text = Text()
-            line_text.append(f"{prefix_char} ", style=prefix_style)
-            line_text.append(str(entry.text), style=prefix_style)
+            line_text.append(str(entry.text), style=text_style)
             renderables.append(line_text)
             renderables.append(Text(""))
             continue

{comate_cli-0.3.2 → comate_cli-0.3.3}/comate_cli/terminal_agent/logo.py

@@ -8,6 +8,8 @@ from rich.text import Text
 
 from comate_agent_sdk.utils.paths import PathInput, normalize_path_input
 
+from .codenames import get_codename
+
 _LOGO_LINES: tuple[str, ...] = (
     "",
     "  ██████╗ ██████╗ ███╗   ███╗ █████╗ ████████╗███████╗",
@@ -59,6 +61,7 @@ def print_logo(console: Console, *, project_root: PathInput | None = None) -> No
     line_count = len(_LOGO_LINES)
 
     ver = _resolve_version()
+    codename = get_codename(ver)
     logo_text = Text()
     for idx, line in enumerate(_LOGO_LINES):
         ratio = idx / max(line_count - 1, 1)
@@ -66,6 +69,13 @@ def print_logo(console: Console, *, project_root: PathInput | None = None) -> No
         logo_text.append(line, style=f"bold rgb({r},{g},{b})")
         if idx == line_count - 1:
             logo_text.append(f"  {ver}", style="dim")
+            if codename:
+                er, eg, eb = end_rgb
+                logo_text.append(": ", style="dim")
+                logo_text.append(
+                    codename,
+                    style=f"italic rgb({er},{eg},{eb})",
+                )
         if idx < line_count - 1:
             logo_text.append("\n")
 

{comate_cli-0.3.2 → comate_cli-0.3.3}/comate_cli/terminal_agent/status_bar.py

@@ -30,6 +30,7 @@ class StatusBar:
         self._git_diff_stats: GitDiffStats | None = None
         self._git_diff_cache_time: float = 0.0
         self._transient_message: str | None = None
+        self._transient_severity: str = "info"
         self._transient_until: float | None = None
 
     @staticmethod
@@ -258,9 +259,11 @@ class StatusBar:
         fragments.append(("", " "))
         return fragments
 
-    def show_transient(self, message: str, duration_s: float = 5.0) -> None:
+    def show_transient(self, message: str, duration_s: float = 5.0,
+                       severity: str = "info") -> None:
         """Set a transient message that auto-clears after *duration_s* seconds."""
         self._transient_message = message
+        self._transient_severity = severity
         self._transient_until = time.monotonic() + duration_s
 
     def clear_transient_if_expired(self) -> bool:
@@ -271,6 +274,7 @@ class StatusBar:
         """
         if self._transient_until is not None and time.monotonic() >= self._transient_until:
             self._transient_message = None
+            self._transient_severity = "info"
             self._transient_until = None
             return True
         return False
@@ -283,5 +287,9 @@ class StatusBar:
     def has_transient(self) -> bool:
         return self._transient_message is not None
 
+    @property
+    def transient_severity(self) -> str:
+        return self._transient_severity if self._transient_message else "info"
+
     def helper_toolbar(self) -> list[tuple[str, str]]:
         return []

{comate_cli-0.3.2 → comate_cli-0.3.3}/comate_cli/terminal_agent/tui.py

@@ -485,6 +485,8 @@ class TerminalAgentTUI(
                 "status.mode.plan": "bg:default #7AC9CA bold",
                 "status.hint": "bg:default #6B7280",
                 "status.transient": "bg:default italic fg:ansiyellow",
+                "status.transient.error": "bg:default bold fg:ansired",
+                "status.transient.warning": "bg:default italic fg:ansiyellow",
                 "input.placeholder": "bg:default #9CA3AF",
                 "auto-suggestion": "bg:default #94a3b8",
                 "queue": "bg:#1d222a #d8dee9",
@@ -732,6 +734,24 @@ class TerminalAgentTUI(
         self._render_dirty = True
         self._invalidate()
 
+    async def _handle_error(self, exc: Exception) -> None:
+        """Unified error cleanup: format → display → stop animation → reset state."""
+        from comate_cli.terminal_agent.error_display import format_error
+
+        message, transient_summary, severity = format_error(exc)
+
+        self._renderer.append_system_message(message, severity=severity)
+        self._renderer.interrupt_turn()
+        await self._animation_controller.shutdown()
+        self._status_bar.show_transient(transient_summary, severity=severity)
+        self._last_turn_user_preview = None
+        self._append_run_elapsed_to_history(stop_reason="error")
+        self._run_start_time = None
+        self._interrupt_requested_at = None
+        self._set_busy(False)
+        await self._status_bar.refresh()
+        self._refresh_layers()
+
     async def _submit_user_message(
         self,
         text: str,
@@ -775,21 +795,7 @@ class TerminalAgentTUI(
             await self._session.send(text)
         except Exception as exc:
             logger.exception("send failed")
-            from comate_cli.terminal_agent.error_display import format_error
-
-            error_msg, suggestion = format_error(exc)
-            self._renderer.append_system_message(error_msg, severity="error")
-            if suggestion:
-                self._renderer.append_system_message(f"💡 {suggestion}")
-            self._renderer.interrupt_turn()
-            await self._animation_controller.shutdown()
-            self._last_turn_user_preview = None
-            self._append_run_elapsed_to_history(stop_reason="error")
-            self._run_start_time = None
-            self._interrupt_requested_at = None
-            self._set_busy(False)
-            await self._status_bar.refresh()
-            self._refresh_layers()
+            await self._handle_error(exc)
 
     async def _consume_event_stream(self) -> None:
         waiting_for_input = False
@@ -899,12 +905,7 @@ class TerminalAgentTUI(
             raise
         except Exception as exc:
             logger.exception("session event pump failed")
-            self._renderer.append_system_message(
-                f"会话事件流异常终止: {exc}",
-                severity="error",
-            )
-            self._set_busy(False)
-            self._refresh_layers()
+            await self._handle_error(exc)
 
     def _open_plan_approval_menu(self, approval: dict[str, str]) -> None:
         plan_path = str(approval.get("plan_path", "")).strip()

{comate_cli-0.3.2 → comate_cli-0.3.3}/comate_cli/terminal_agent/tui_parts/input_behavior.py

@@ -322,7 +322,7 @@ class InputBehaviorMixin:
         # busy 或 initializing 时：非斜杠命令 → 入队，斜杠命令 → 交由命令分发决定
         is_busy = self._busy or self._initializing
         if is_busy:
-            if display_text.lstrip().startswith("/"):
+            if raw_text.startswith("/"):
                 normalized_slash = display_text.strip()
                 parsed = parse_slash_command_call(normalized_slash)
                 registry = getattr(self, "_slash_registry", None)
@@ -351,7 +351,7 @@ class InputBehaviorMixin:
                 self._schedule_background(self._execute_command(normalized_slash))
                 return
 
-            if not display_text.lstrip().startswith("/"):
+            if not raw_text.startswith("/"):
                 queue_size = len(self._queued_messages)
                 if queue_size >= int(self._message_queue_max_size):
                     self._renderer.append_system_message(
@@ -364,7 +364,7 @@ class InputBehaviorMixin:
                 self._invalidate()
                 return
 
-        if display_text.lstrip().startswith("/"):
+        if raw_text.startswith("/"):
             self._schedule_background(self._execute_command(display_text.strip()))
             return
 

{comate_cli-0.3.2 → comate_cli-0.3.3}/comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -67,7 +67,13 @@ class RenderPanelsMixin:
             padding = max(1, width - left_w - right_w - 2)
 
             frags: list[tuple[str, str]] = [
-                ("class:status.transient", transient),
+                (
+                    {
+                        "error": "class:status.transient.error",
+                        "warning": "class:status.transient.warning",
+                    }.get(self._status_bar.transient_severity, "class:status.transient"),
+                    transient,
+                ),
                 ("class:status", " " * padding),
                 ("class:status", right_text),
             ]

{comate_cli-0.3.2 → comate_cli-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.3.2"
+version = "0.3.3"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11"

comate_cli-0.3.3/tests/test_format_error.py

@@ -0,0 +1,153 @@
+"""Tests for unified error formatter."""
+from __future__ import annotations
+
+import unittest
+
+
+class TestFormatError(unittest.TestCase):
+    """Each test verifies (message, transient_summary, severity) for one error type."""
+
+    def _make_exc(self, cls_name: str, msg: str = "", **attrs):
+        """Create a fake exception with a given class name and attributes."""
+        exc = type(cls_name, (Exception,), {})(msg)
+        for k, v in attrs.items():
+            setattr(exc, k, v)
+        return exc
+
+    def test_rate_limit(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc("ModelRateLimitError")
+        msg, transient, severity = format_error(exc)
+        assert severity == "warning"
+        assert "Rate limit" in msg
+        assert transient == "Rate limited"
+
+    def test_provider_401(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc("ModelProviderError", status_code=401)
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "API key" in msg
+        assert transient == "Auth failed"
+
+    def test_provider_403(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc("ModelProviderError", status_code=403)
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "Access denied" in msg
+        assert transient == "Access denied"
+
+    def test_provider_404(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc("ModelProviderError", status_code=404)
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "not found" in msg.lower()
+        assert transient == "Model not found"
+
+    def test_provider_5xx(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc("ModelProviderError", status_code=502)
+        msg, transient, severity = format_error(exc)
+        assert severity == "warning"
+        assert "502" in msg
+        assert transient == "Server error"
+
+    def test_context_size_exceeded(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        body = (
+            "Error code: 400 - {'error': {'code': 400, "
+            "'message': 'request (35099 tokens) exceeds the available context size (32768 tokens)', "
+            "'type': 'exceed_context_size_error', 'n_prompt_tokens': 35099, 'n_ctx': 32768}}"
+        )
+        exc = self._make_exc("ModelProviderError", body, status_code=400)
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "35099" in msg
+        assert "32768" in msg
+        assert transient == "Context limit exceeded"
+
+    def test_context_size_type_without_parseable_numbers(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc(
+            "ModelProviderError",
+            "exceed_context_size_error without parseable numbers",
+            status_code=400,
+        )
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert transient == "API error"  # Falls through to generic 400
+
+    def test_provider_400_generic(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc("ModelProviderError", "bad request", status_code=400)
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "API error" in msg
+        assert transient == "API error"
+
+    def test_session_closed(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = self._make_exc("ChatSessionClosedError")
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "Session closed" in msg
+        assert transient == "Session closed"
+
+    def test_timeout(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = Exception("request timed out after 30s")
+        msg, transient, severity = format_error(exc)
+        assert severity == "warning"
+        assert "timed out" in msg.lower()
+        assert transient == "Timed out"
+
+    def test_connection_error(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = Exception("Connection refused")
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "Connection failed" in msg
+        assert transient == "Connection failed"
+
+    def test_generic_fallback(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        exc = Exception("something unexpected")
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert "something unexpected" in msg
+        assert transient == "Error occurred"
+
+    def test_no_icons_in_messages(self):
+        """All messages must be plain text, no emoji icons."""
+        from comate_cli.terminal_agent.error_display import format_error
+
+        test_cases = [
+            self._make_exc("ModelRateLimitError"),
+            self._make_exc("ModelProviderError", status_code=401),
+            self._make_exc("ChatSessionClosedError"),
+            Exception("timeout"),
+            Exception("generic error"),
+        ]
+        for exc in test_cases:
+            msg, transient, severity = format_error(exc)
+            assert "⚠" not in msg, f"Icon found in: {msg}"
+            assert "✖" not in msg, f"Icon found in: {msg}"
+            assert "💡" not in msg, f"Icon found in: {msg}"
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

comate_cli-0.3.3/tests/test_handle_error.py

@@ -0,0 +1,115 @@
+"""Tests for unified _handle_error() in TUI."""
+from __future__ import annotations
+
+import asyncio
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+
+
+def _make_tui_stub():
+    """Create a minimal TUI stub with mocked dependencies."""
+    tui = MagicMock()
+    tui._renderer = MagicMock()
+    tui._animation_controller = AsyncMock()
+    tui._status_bar = MagicMock()
+    tui._status_bar.refresh = AsyncMock()
+    tui._last_turn_user_preview = "some preview"
+    tui._run_start_time = 12345.0
+    tui._interrupt_requested_at = 67890.0
+    return tui
+
+
+class TestHandleError(unittest.TestCase):
+    def test_handle_error_stops_animation(self):
+        """Regression: animation must be stopped on any error."""
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = Exception("test error")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        tui._animation_controller.shutdown.assert_awaited_once()
+
+    def test_handle_error_sets_busy_false(self):
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = Exception("test error")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        tui._set_busy.assert_called_once_with(False)
+
+    def test_handle_error_writes_to_scrollback(self):
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = Exception("something broke")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        tui._renderer.append_system_message.assert_called_once()
+        call_args = tui._renderer.append_system_message.call_args
+        assert "something broke" in call_args[0][0]
+        assert call_args[1]["severity"] == "error"
+
+    def test_handle_error_sets_transient_with_severity(self):
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = Exception("something broke")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        tui._status_bar.show_transient.assert_called_once()
+        call_args = tui._status_bar.show_transient.call_args
+        assert call_args[1]["severity"] == "error"
+
+    def test_handle_error_resets_run_state(self):
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = Exception("test")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        assert tui._last_turn_user_preview is None
+        assert tui._run_start_time is None
+        assert tui._interrupt_requested_at is None
+
+    def test_handle_error_calls_interrupt_turn(self):
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = Exception("test")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        tui._renderer.interrupt_turn.assert_called_once()
+
+    def test_handle_error_refreshes_layers(self):
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = Exception("test")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        tui._refresh_layers.assert_called_once()
+
+    def test_handle_error_warning_severity_for_rate_limit(self):
+        """Rate limit errors should propagate warning severity to transient."""
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        exc = type("ModelRateLimitError", (Exception,), {})("rate limited")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        call_args = tui._status_bar.show_transient.call_args
+        assert call_args[1]["severity"] == "warning"
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

{comate_cli-0.3.2 → comate_cli-0.3.3}/tests/test_interrupt_exit_semantics.py

@@ -109,6 +109,9 @@ class _StubStatusBar:
     def set_mode(self, _mode: str) -> None:
         return None
 
+    def show_transient(self, _message: str, *, severity: str = "error") -> None:
+        return None
+
 
 class _StubKeyBindingHost(KeyBindingsMixin):
     def __init__(self) -> None:
@@ -285,6 +288,8 @@ class TestInterruptExitSemantics(unittest.IsolatedAsyncioTestCase):
         tui._open_plan_approval_menu = lambda approval: None
         tui._enter_question_mode = lambda questions: None
         tui._exit_question_mode = lambda: None
+        tui._queued_messages = []
+        tui._append_run_elapsed_to_history = lambda stop_reason=None: None
 
         await tui._consume_event_stream()
 

{comate_cli-0.3.2 → comate_cli-0.3.3}/tests/test_status_bar_transient.py

@@ -56,6 +56,33 @@ class TestStatusBarTransient(unittest.TestCase):
         sb.show_transient("second", duration_s=10.0)
         assert sb.transient_message == "second"
 
+    def test_show_transient_default_severity_is_info(self) -> None:
+        sb = _make_status_bar()
+        sb.show_transient("hello")
+        assert sb.transient_severity == "info"
+
+    def test_show_transient_with_error_severity(self) -> None:
+        sb = _make_status_bar()
+        sb.show_transient("fail", severity="error")
+        assert sb.transient_message == "fail"
+        assert sb.transient_severity == "error"
+
+    def test_show_transient_with_warning_severity(self) -> None:
+        sb = _make_status_bar()
+        sb.show_transient("warn", severity="warning")
+        assert sb.transient_severity == "warning"
+
+    def test_transient_severity_returns_info_when_no_message(self) -> None:
+        sb = _make_status_bar()
+        assert sb.transient_severity == "info"
+
+    def test_clear_transient_resets_severity(self) -> None:
+        sb = _make_status_bar()
+        sb.show_transient("err", duration_s=0.0, severity="error")
+        import time; time.sleep(0.01)
+        sb.clear_transient_if_expired()
+        assert sb.transient_severity == "info"
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)

{comate_cli-0.3.2 → comate_cli-0.3.3}/tests/test_tui_mcp_init_gate.py

@@ -55,13 +55,17 @@ class TestTUIMcpInitGate(unittest.IsolatedAsyncioTestCase):
         class _FakeStatusBar:
             def __init__(self) -> None:
                 self.transient_calls: list[tuple[str, float]] = []
-            def show_transient(self, msg: str, duration_s: float = 5.0) -> None:
+            def show_transient(self, msg: str, duration_s: float = 5.0,
+                               severity: str = "info") -> None:
                 self.transient_calls.append((msg, duration_s))
             def clear_transient_if_expired(self) -> bool:
                 return False
             @property
             def has_transient(self) -> bool:
                 return False
+            @property
+            def transient_severity(self) -> str:
+                return "info"
 
         fake_status_bar = _FakeStatusBar()
         tui._status_bar = fake_status_bar

{comate_cli-0.3.2 → comate_cli-0.3.3}/tests/test_tui_paste_placeholder.py

@@ -414,5 +414,57 @@ class TestTUIPastePlaceholder(unittest.TestCase):
         self.assertIsNone(hint)
 
 
+    def test_leading_space_escapes_slash_command(self) -> None:
+        """Leading space before / should send as user message, not slash command."""
+        tui = _build_tui(threshold=5)
+        tui._busy = False
+        tui._ui_mode = UIMode.NORMAL
+        tui._clear_input_area = lambda **_kw: None
+
+        captured: dict[str, str | None] = {"text": None, "display_text": None}
+
+        async def _fake_submit_user_message(
+            text: str,
+            *,
+            display_text: str | None = None,
+        ) -> None:
+            captured["text"] = text
+            captured["display_text"] = display_text
+
+        dispatched: list[str] = []
+
+        async def _fake_execute_command(command: str) -> None:
+            dispatched.append(command)
+
+        tui._submit_user_message = _fake_submit_user_message
+        tui._execute_command = _fake_execute_command
+
+        def _run_immediately(coro: object) -> None:
+            asyncio.run(coro)
+
+        tui._schedule_background = _run_immediately
+        tui._input_area = _FakeInputArea(" /aaa")
+
+        tui._submit_from_input()
+
+        self.assertEqual(dispatched, [])
+        self.assertEqual(captured["text"], "/aaa")
+
+    def test_leading_space_escapes_slash_command_when_busy(self) -> None:
+        """Leading space before / should enqueue as user message when busy."""
+        tui = _build_tui(threshold=5)
+        tui._busy = True
+        tui._ui_mode = UIMode.NORMAL
+        tui._clear_input_area = lambda **_kw: None
+        tui._execute_command = lambda _: None
+        tui._schedule_background = lambda _: None
+
+        tui._input_area = _FakeInputArea(" /help")
+        tui._submit_from_input()
+
+        self.assertEqual(len(tui._queued_messages), 1)
+        self.assertEqual(tui._queued_messages[0], "/help")
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

{comate_cli-0.3.2 → comate_cli-0.3.3}/uv.lock

@@ -364,7 +364,7 @@ wheels = [
 
 [[package]]
 name = "comate-agent-sdk"
-version = "0.3.1"
+version = "0.3.2"
 source = { editable = "../../" }
 dependencies = [
     { name = "aiohttp" },
@@ -429,7 +429,7 @@ dev = [
 
 [[package]]
 name = "comate-cli"
-version = "0.3.1"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "comate-agent-sdk" },

comate_cli-0.3.2/comate_cli/terminal_agent/error_display.py

@@ -1,46 +0,0 @@
-"""Unified error formatter for terminal agent"""
-from __future__ import annotations
-
-
-def format_error(exc: Exception) -> tuple[str, str | None]:
-    """Convert exception to user-friendly message.
-
-    Returns:
-        (error_message, suggestion) - Error message and optional suggestion
-    """
-    exc_type = type(exc).__name__
-    exc_msg = str(exc)
-
-    # LLM Provider errors
-    if exc_type == "ModelRateLimitError":
-        return "⚠️ Rate limit exceeded", "Wait a moment, or use /model to switch"
-
-    if exc_type == "ModelProviderError":
-        code = getattr(exc, 'status_code', None)
-        if code == 404:
-            return "⚠️ Model not found or invalid API path", "Check .agent/settings.json"
-        if code == 401:
-            return "⚠️ Invalid or expired API key", "Check api_key in .agent/settings.json"
-        if code == 403:
-            return "⚠️ Access denied to this model", "Check API key permissions"
-        if code and code >= 500:
-            return f"⚠️ Server error ({code})", "Try again later"
-        return f"⚠️ API error: {_truncate(exc_msg, 80)}", None
-
-    # Session errors
-    if exc_type == "ChatSessionClosedError":
-        return "⚠️ Session closed", "Please restart the CLI"
-
-    # Network errors (generic detection)
-    lower_msg = exc_msg.lower()
-    if "timeout" in lower_msg or "timed out" in lower_msg:
-        return "⚠️ Request timed out", "Check network connection, or try again"
-    if "connection" in lower_msg:
-        return "⚠️ Connection failed", "Check network and API endpoint"
-
-    # Generic fallback
-    return f"⚠️ Error: {_truncate(exc_msg, 60)}", "You can continue typing"
-
-
-def _truncate(s: str, max_len: int) -> str:
-    return s[:max_len] + "..." if len(s) > max_len else s