comate-cli 0.7.0a8__tar.gz → 0.7.0a9__tar.gz

{comate_cli-0.7.0a8 → comate_cli-0.7.0a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.0a8
+Version: 0.7.0a9
 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.7.0a8 → comate_cli-0.7.0a9}/comate_cli/terminal_agent/animations.py

@@ -9,7 +9,7 @@ from enum import Enum
 from rich.console import RenderableType
 from rich.text import Text
 
-from comate_agent_sdk.agent.events import StopEvent, TextEvent, ToolCallEvent, ToolResultEvent, UserQuestionEvent
+from comate_agent_sdk.agent.events import StopEvent, ToolCallEvent, ToolResultEvent, UserQuestionEvent
 
 from comate_cli.terminal_agent.figures import (
     BREATH_DOT_GLYPHS as _FIGURES_BREATH_DOT_GLYPHS,
@@ -238,6 +238,27 @@ BREATH_DOT_COLORS: tuple[str, ...] = (
 )
 BREATH_DOT_GLYPHS: tuple[str, ...] = _FIGURES_BREATH_DOT_GLYPHS
 
+LOADING_SPINNER_FRAMES: tuple[str, ...] = (
+    "⠋",
+    "⠙",
+    "⠹",
+    "⠸",
+    "⠼",
+    "⠴",
+    "⠦",
+    "⠧",
+    "⠇",
+    "⠏",
+)
+
+HIDDEN_THINKING_BADGES: tuple[str, ...] = (
+    "ultra thinking",
+    "deep reasoning",
+    "thinking deeper",
+    "extended thinking",
+    "working through it",
+)
+
 
 def breathing_dot_color(frame: int) -> str:
     """Return the breathing dot color for a given animation frame."""
@@ -252,6 +273,11 @@ def breathing_dot_glyph(now_monotonic: float | None = None) -> str:
     return BREATH_DOT_GLYPHS[phase]
 
 
+def loading_spinner_glyph(frame: int) -> str:
+    """Return the compact spinner glyph for the main loading line."""
+    return LOADING_SPINNER_FRAMES[frame % len(LOADING_SPINNER_FRAMES)]
+
+
 def _lerp_rgb(
     start_rgb: tuple[int, int, int],
     end_rgb: tuple[int, int, int],
@@ -385,11 +411,9 @@ class SubmissionAnimator:
             return Text("")
 
         phrase = self._status_hint if self._status_hint else (self._shuffled[self._phrase_idx] + ELLIPSIS)
-        dot_color = breathing_dot_color(self._frame)
-        now_monotonic = time.monotonic()
         dot = Text(
-            f"{breathing_dot_glyph(now_monotonic)} ",
-            style=f"bold {dot_color}",
+            f"{loading_spinner_glyph(self._frame)} ",
+            style="bold #9CA3AF",
         )
         sweep = _cyan_sweep_text(phrase, frame=self._frame)
         return Text.assemble(dot, sweep)

{comate_cli-0.7.0a8 → comate_cli-0.7.0a9}/comate_cli/terminal_agent/event_renderer.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import random
 import re
 import threading
 import time
@@ -37,6 +38,7 @@ from comate_agent_sdk.agent.events import (
 from rich.console import RenderableType
 from rich.text import Text
 
+from comate_cli.terminal_agent.animations import HIDDEN_THINKING_BADGES
 from comate_cli.terminal_agent.figures import (
     BOTTOM_LEFT_CROP,
     BULLET_OPERATOR,
@@ -292,6 +294,7 @@ class EventRenderer:
         self._show_thinking_cb: Callable[[], bool] = lambda: True
         self._turn_received_text_delta: bool = False
         self._turn_received_thinking_delta: bool = False
+        self._hidden_thinking_badge_text: str = ""
         self._text_delta_started: bool = False
         self._active_text_message_id: str | None = None
         # ━━━━━ spec §4.1 新管道状态字段（Phase 1.2 引入，Phase 4-6 接入） ━━━━━
@@ -473,6 +476,10 @@ class EventRenderer:
         """
         if not delta:
             return
+        if self._show_thinking_cb():
+            self._hidden_thinking_badge_text = ""
+        elif not self._hidden_thinking_badge_text:
+            self._hidden_thinking_badge_text = random.choice(HIDDEN_THINKING_BADGES)
         self._thinking_batch += delta
         while "\n" in self._thinking_batch:
             line, self._thinking_batch = self._thinking_batch.split("\n", 1)
@@ -564,6 +571,7 @@ class EventRenderer:
         """
         if not delta:
             return
+        self._hidden_thinking_badge_text = ""
         if self._thinking_batch:
             self._flush_thinking_batch()
         self._text_pending += delta
@@ -604,6 +612,7 @@ class EventRenderer:
             self._flush_thinking_batch()
         # ⑤ aux
         self._loading_aux_text = ""
+        self._hidden_thinking_badge_text = ""
 
     def _drop_all_pending(self) -> None:
         """spec §6.4：interrupt_turn 调用。
@@ -614,6 +623,7 @@ class EventRenderer:
         self._container = None
         self._thinking_batch = ""
         self._loading_aux_text = ""
+        self._hidden_thinking_badge_text = ""
         self._text_delta_started = False
         self._active_text_message_id = None
 
@@ -657,6 +667,7 @@ class EventRenderer:
         self._container = None
         self._thinking_batch = ""
         self._loading_aux_text = ""
+        self._hidden_thinking_badge_text = ""
         self._rebuild_loading_line()
 
     def seed_user_message(
@@ -775,6 +786,7 @@ class EventRenderer:
         self._thinking_batch = ""
         self._loading_aux_text = ""
         self._loading_state = LoadingState.idle()
+        self._hidden_thinking_badge_text = ""
         self._current_tasks = []
         self._current_task_title = None
         self._task_started_at_monotonic = None
@@ -830,6 +842,10 @@ class EventRenderer:
         拼接到 spinner phrase。无容器时返回 ""。"""
         return self._loading_aux_text
 
+    def hidden_thinking_badge_text(self) -> str:
+        """Return the loading-line badge shown while hidden thinking streams."""
+        return self._hidden_thinking_badge_text
+
     def append_subtitle(
         self,
         text: str,
@@ -1210,11 +1226,6 @@ class EventRenderer:
         if state.is_task:
             subagent_name = state.subagent_name or "Agent"
             description = state.subagent_description or state.title
-            if description and description != subagent_name:
-                task_title = f"{subagent_name}({description})"
-            else:
-                task_title = subagent_name
-
             model_name = ""
             if metadata and isinstance(metadata, dict):
                 model_name = metadata.get("model_name", "")
@@ -1617,6 +1628,7 @@ class EventRenderer:
                 self._pending_tool_starts.clear()
                 # Safety net: if any running tool rows remain, stop event means this turn is ending.
                 self._running_tools.clear()
+                self._hidden_thinking_badge_text = ""
                 self._rebuild_loading_line()
                 if reason == "waiting_for_input":
                     return (True, None)

{comate_cli-0.7.0a8 → comate_cli-0.7.0a9}/comate_cli/terminal_agent/tui.py

@@ -189,7 +189,7 @@ class TerminalAgentTUI(
         self._pending_questions: list[dict[str, Any]] | None = None
         self._pending_plan_approval: dict[str, str] | None = None
         self._ui_mode = UIMode.NORMAL
-        self._show_thinking = True  # Ctrl+T 开关，默认打开
+        self._show_thinking = False  # Ctrl+T 开关，默认关闭
         self._renderer._show_thinking_cb = lambda: self._show_thinking
 
         self._custom_slash_commands: dict[str, CustomSlashCommand] = {}

{comate_cli-0.7.0a8 → comate_cli-0.7.0a9}/comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -9,7 +9,12 @@ from rich.console import Console
 
 from comate_agent_sdk.agent.queue_types import MessageOrigin, QueuedMessage
 
-from comate_cli.terminal_agent.animations import _cyan_sweep_text, breathing_dot_color, breathing_dot_glyph
+from comate_cli.terminal_agent.animations import (
+    _cyan_sweep_text,
+    breathing_dot_color,
+    breathing_dot_glyph,
+    loading_spinner_glyph,
+)
 from comate_cli.terminal_agent.figures import (
     BOTTOM_LEFT_CROP,
     BULLET,
@@ -18,7 +23,6 @@ from comate_cli.terminal_agent.figures import (
     DOWN_ARROW,
     ELLIPSIS,
     FAST_PLAY_ICON,
-    HEAVY_HORIZONTAL,
     PAUSE_ICON,
     TASK_IN_PROGRESS,
     TASK_PENDING,
@@ -480,6 +484,7 @@ class RenderPanelsMixin:
         if self._animator.is_active:
             renderable = self._animator.renderable()
             frags = self._rich_text_to_pt_fragments(renderable)
+            frags = self._append_hidden_thinking_badge_fragment(frags)
             return self._append_loading_tip_fragment(
                 self._append_run_elapsed_fragment(frags)
             )
@@ -500,9 +505,31 @@ class RenderPanelsMixin:
             phrase = f"{phrase}  {BULLET_OPERATOR} {aux}"
 
         return self._append_loading_tip_fragment(
-            self._animated_loading_fragments(phrase)
+            self._animated_loading_fragments(
+                phrase,
+                badge=self._hidden_thinking_badge_text(),
+            )
         )
 
+    def _hidden_thinking_badge_text(self) -> str:
+        badge_fn = getattr(self._renderer, "hidden_thinking_badge_text", None)
+        if not callable(badge_fn):
+            return ""
+        return str(badge_fn() or "").strip()
+
+    def _append_hidden_thinking_badge_fragment(
+        self,
+        frags: list[tuple[str, str]],
+    ) -> list[tuple[str, str]]:
+        badge = self._hidden_thinking_badge_text()
+        if not badge:
+            return frags
+        tail: list[tuple[str, str]] = []
+        trimmed = list(frags)
+        while trimmed and trimmed[-1][1] == "\n":
+            tail.insert(0, trimmed.pop())
+        return trimmed + [("", "  "), ("fg:#FBBF24 bold", badge)] + tail
+
     def _visible_loading_tip(self) -> str:
         tip = str(getattr(self, "_loading_tip_text", "") or "").strip()
         if not tip:
@@ -534,9 +561,15 @@ class RenderPanelsMixin:
     def _loading_height_with_tip(self) -> int:
         return 2 if self._visible_loading_tip() else 1
 
-    def _animated_loading_fragments(self, phrase: str) -> list[tuple[str, str]]:
-        """用与工具调用一致的呼吸圆点 + 流光走字渲染 loading 文案."""
+    def _animated_loading_fragments(
+        self,
+        phrase: str,
+        *,
+        badge: str = "",
+    ) -> list[tuple[str, str]]:
+        """用低噪音 spinner + 流光走字渲染 loading 文案."""
         width = self._terminal_width()
+        badge = badge.strip()
 
         # 若正在计时，预先计算时间后缀宽度，给 phrase 预留空间
         run_start: float | None = getattr(self, "_run_start_time", None)
@@ -547,21 +580,23 @@ class RenderPanelsMixin:
                 f"  ({self._format_run_elapsed(elapsed)} • ctrl+c to interrupt)"
             )
 
-        # glyph(1) + space(1) = 2，再减去时间后缀宽度
-        phrase_budget = width - 4 - get_cwidth(elapsed_suffix)
+        badge_suffix = f"  {badge}" if badge else ""
+
+        # glyph(1) + space(1) = 2，再减去 badge / 时间后缀宽度
+        phrase_budget = width - 2 - get_cwidth(badge_suffix) - get_cwidth(elapsed_suffix)
         clipped = fit_single_line(phrase, max(phrase_budget, 8))
 
         frame = self._loading_frame
-        dot_color = breathing_dot_color(frame)
-        now_monotonic = time.monotonic()
 
         # 构建 Rich Text（与 SubmissionAnimator.renderable 相同结构）
         from rich.text import Text as RichText
 
-        dot = RichText(f"{breathing_dot_glyph(now_monotonic)} ", style=f"bold {dot_color}")
+        dot = RichText(f"{loading_spinner_glyph(frame)} ", style="bold #9CA3AF")
         sweep = _cyan_sweep_text(clipped, frame=frame)
         combined = RichText.assemble(dot, sweep)
         frags = self._rich_text_to_pt_fragments(combined)
+        if badge:
+            frags = frags + [("", "  "), ("fg:#FBBF24 bold", badge)]
         if elapsed_suffix:
             frags = frags + [("fg:#6B7280", elapsed_suffix)]
         return frags

{comate_cli-0.7.0a8 → comate_cli-0.7.0a9}/pyproject.toml

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

{comate_cli-0.7.0a8 → comate_cli-0.7.0a9}/tests/test_completion_status_panel.py

@@ -56,6 +56,7 @@ class _FakeRenderer:
         self.running_subagents = False
         self.running_tools = False
         self.auto_compacting = False
+        self.hidden_thinking_badge = ""
         self.todo_lines: list[str] = []
         self.tool_entries: list[tuple[int, str]] = [(0, "Agent(task) · 1s · +1 tool uses")]
 
@@ -77,6 +78,9 @@ class _FakeRenderer:
     def loading_aux_text(self) -> str:
         return ""
 
+    def hidden_thinking_badge_text(self) -> str:
+        return self.hidden_thinking_badge
+
     def compute_required_tool_panel_lines(self) -> int:
         return len(self.tool_entries)
 
@@ -291,6 +295,45 @@ class TestCompletionStatusPanel(unittest.TestCase):
         self.assertNotIn("Tip:", text)
         self.assertEqual(tui._loading_height(), 1)
 
+    def test_loading_text_uses_braille_spinner(self) -> None:
+        tui = _FakeTUI(None, width=80)
+        tui._busy = True
+        tui._loading_frame = 0
+
+        text = _join_fragments(tui._loading_text())
+
+        self.assertTrue(text.startswith("⠋ Thinking"))
+        self.assertNotIn("○ Thinking", text)
+
+    def test_loading_text_appends_hidden_thinking_badge_after_phrase(self) -> None:
+        tui = _FakeTUI(None, width=80)
+        tui._busy = True
+        tui._renderer.hidden_thinking_badge = "ultra thinking"
+
+        fragments = tui._loading_text()
+        text = _join_fragments(fragments)
+
+        self.assertIn("Thinking  ultra thinking", text)
+        self.assertTrue(
+            any(
+                style == "fg:#FBBF24 bold" and badge == "ultra thinking"
+                for style, badge in fragments
+            )
+        )
+
+    def test_loading_text_appends_hidden_thinking_badge_to_active_animator(self) -> None:
+        tui = _FakeTUI(None, width=80)
+        tui._busy = True
+        tui._renderer.hidden_thinking_badge = "deep reasoning"
+        tui._animator = SimpleNamespace(
+            is_active=True,
+            renderable=lambda: Text("Generating..."),
+        )
+
+        text = _join_fragments(tui._loading_text())
+
+        self.assertIn("Generating...  deep reasoning", text)
+
     def test_loading_tip_renders_as_temporary_subtitle_line(self) -> None:
         tui = _FakeTUI(None, width=80)
         tui._busy = True

{comate_cli-0.7.0a8 → comate_cli-0.7.0a9}/tests/test_event_renderer_streaming.py

@@ -12,7 +12,6 @@ from comate_agent_sdk.agent.events import (
 from comate_cli.terminal_agent.event_renderer import (
     ContainerState,
     EventRenderer,
-    FenceMatch,
 )
 
 
@@ -61,6 +60,38 @@ class TestQ11Fallback(unittest.TestCase):
         # delta 路径仍待 batch flush，TextEvent 不补 thinking entry
         self.assertEqual(thinking_entries, [])
 
+    def test_hidden_thinking_delta_exposes_loading_badge_without_history(self) -> None:
+        renderer = EventRenderer()
+        renderer._show_thinking_cb = lambda: False
+        renderer.start_turn()
+
+        renderer.handle_event(ThinkingDeltaEvent(delta="hidden reasoning\n", message_id="m1"))
+
+        thinking_entries = [
+            entry for entry in renderer.history_entries() if entry.entry_type == "thinking"
+        ]
+        self.assertEqual(thinking_entries, [])
+        self.assertIn(
+            renderer.hidden_thinking_badge_text(),
+            {
+                "ultra thinking",
+                "deep reasoning",
+                "thinking deeper",
+                "extended thinking",
+                "working through it",
+            },
+        )
+
+    def test_hidden_thinking_badge_clears_when_text_stream_starts(self) -> None:
+        renderer = EventRenderer()
+        renderer._show_thinking_cb = lambda: False
+        renderer.start_turn()
+        renderer.handle_event(ThinkingDeltaEvent(delta="hidden reasoning", message_id="m1"))
+
+        renderer.handle_event(TextDeltaEvent(delta="answer", message_id="m1"))
+
+        self.assertEqual(renderer.hidden_thinking_badge_text(), "")
+
     def test_thinking_event_legacy_fallback_when_no_delta(self) -> None:
         renderer = EventRenderer()
         renderer.start_turn()

comate_cli-0.7.0a9/tests/test_tui_thinking_display.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from prompt_toolkit.history import InMemoryHistory
+
+from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+
+class _FakeStatusBar:
+    def set_mode(self, _mode: str) -> None:
+        return None
+
+
+class _FakeRenderer:
+    def __init__(self) -> None:
+        self._show_thinking_cb = lambda: True
+
+    def set_tool_result_registry(self, _registry: object) -> None:
+        return None
+
+    def append_system_message(self, *_args, **_kwargs) -> None:
+        return None
+
+    def has_active_todos(self) -> bool:
+        return False
+
+    def has_running_tools(self) -> bool:
+        return False
+
+
+class _FakeSession:
+    session_id = "session-1"
+    _cwd = Path.cwd()
+
+    def __init__(self) -> None:
+        self._agent = SimpleNamespace(
+            _team=SimpleNamespace(team_message_event_callback=None),
+            _runtime_state=SimpleNamespace(skills=[]),
+        )
+
+    def get_mode(self) -> str:
+        return "act"
+
+
+class TestTuiThinkingDisplay(unittest.TestCase):
+    def test_thinking_display_defaults_to_hidden(self) -> None:
+        renderer = _FakeRenderer()
+
+        with (
+            patch(
+                "comate_cli.terminal_agent.tui.discover_custom_slash_commands",
+                return_value=SimpleNamespace(warnings=(), commands=()),
+            ),
+            patch.object(
+                TerminalAgentTUI,
+                "_create_input_history",
+                return_value=InMemoryHistory(),
+            ),
+        ):
+            tui = TerminalAgentTUI(_FakeSession(), _FakeStatusBar(), renderer)  # type: ignore[arg-type]
+
+        self.assertFalse(tui._show_thinking)
+        self.assertFalse(renderer._show_thinking_cb())
+
+
+if __name__ == "__main__":
+    unittest.main()