comate-cli 0.5.8__tar.gz → 0.6.0__tar.gz

{comate_cli-0.5.8 → comate_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.5.8
+Version: 0.6.0
 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.5.8 → comate_cli-0.6.0}/comate_cli/terminal_agent/history_printer.py

@@ -87,6 +87,7 @@ def render_history_group(
     terminal_width: int,
     render_markdown_to_plain: Callable[..., str],
     prev_was_assistant: bool = False,
+    prev_was_thinking: bool = False,
     assume_run_continues_at_tail: bool = False,
 ) -> Group | None:
     if not entries:
@@ -98,6 +99,7 @@ def render_history_group(
     # printer 这一层被识别为"连续 assistant entry 的 run"——只在 run 起始处加 `●`，
     # 后续行用 2 空格缩进保持视觉对齐。`prev_was_assistant` 把 run 状态跨 drain 传过来。
     renderables: list[Any] = []
+    needs_leading_gap_after_thinking = prev_was_thinking
     for idx, entry in enumerate(entries):
         is_assistant = entry.entry_type == "assistant"
         in_run_continuation = is_assistant and prev_was_assistant
@@ -116,10 +118,15 @@ def render_history_group(
             ):
                 continue
 
-        # Thinking entries: 灰色显示，无前缀
+        # Thinking entries: 灰色显示，无前缀。thinking 流式文本里的空白行
+        # 只属于模型输出内容，不应把同一个 thinking block 视觉上切散。
         if entry.entry_type == "thinking":
             content = str(entry.text)
-            content_lines = content.splitlines() or [""]
+            content_lines = [line for line in content.splitlines() if line.strip()]
+            if not content_lines:
+                prev_was_assistant = False
+                continue
+            needs_leading_gap_after_thinking = False
             line_text = Text()
             line_text.append("  ", style="dim")
             line_text.append(content_lines[0], style="dim")
@@ -138,6 +145,10 @@ def render_history_group(
             prev_was_assistant = False
             continue
 
+        if needs_leading_gap_after_thinking:
+            renderables.append(Text(""))
+            needs_leading_gap_after_thinking = False
+
         # Elapsed entries: 灰色显示，无前缀
         if entry.entry_type == "elapsed":
             line_text = Text()

{comate_cli-0.5.8 → comate_cli-0.6.0}/comate_cli/terminal_agent/tui.py

@@ -270,6 +270,7 @@ class TerminalAgentTUI(
         # 拆成 N 条 entry，跨 drain 时需要用这个 seed 让 history_printer 把 run 续上
         # （否则每次 drain 都重新加一个 `●`）。
         self._last_drained_was_assistant = False
+        self._last_drained_thinking_tail_needs_gap = False
         self._render_dirty = True
         self._diff_panel_visible = False
         self._diff_panel_scroll = 0

{comate_cli-0.5.8 → comate_cli-0.6.0}/comate_cli/terminal_agent/tui_parts/history_sync.py

@@ -30,12 +30,14 @@ class HistorySyncMixin:
     # message 拆成 N 条 entry，需要 seed 让 history_printer 把 run 续上）。class-level
     # default 让所有 host（含测试 dummy）无需显式初始化也能用。
     _last_drained_was_assistant: bool = False
+    _last_drained_thinking_tail_needs_gap: bool = False
 
     async def _replay_scrollback_after_rewind(self) -> None:
         """清屏并重建 scrollback：Logo + 当前会话历史。"""
         self._renderer.reset_history_view()
         self._printed_history_index = 0
         self._last_drained_was_assistant = False
+        self._last_drained_thinking_tail_needs_gap = False
 
         def _clear_and_print_logo() -> None:
             out = sys.__stdout__ or sys.stdout
@@ -289,11 +291,16 @@ class HistorySyncMixin:
             terminal_width=self._terminal_width(),
             render_markdown_to_plain=render_markdown_to_plain,
             prev_was_assistant=self._last_drained_was_assistant,
+            prev_was_thinking=self._last_drained_thinking_tail_needs_gap,
             assume_run_continues_at_tail=getattr(self, "_busy", False),
         )
         if group is None:
             return
+        busy = getattr(self, "_busy", False)
         self._last_drained_was_assistant = pending[-1].entry_type == "assistant"
+        self._last_drained_thinking_tail_needs_gap = (
+            pending[-1].entry_type == "thinking" and busy
+        )
 
         def _print() -> None:
             width = self._terminal_width()
@@ -336,11 +343,16 @@ class HistorySyncMixin:
             terminal_width=self._terminal_width(),
             render_markdown_to_plain=render_markdown_to_plain,
             prev_was_assistant=self._last_drained_was_assistant,
+            prev_was_thinking=self._last_drained_thinking_tail_needs_gap,
             assume_run_continues_at_tail=getattr(self, "_busy", False),
         )
         if group is None:
             return
+        busy = getattr(self, "_busy", False)
         self._last_drained_was_assistant = pending[-1].entry_type == "assistant"
+        self._last_drained_thinking_tail_needs_gap = (
+            pending[-1].entry_type == "thinking" and busy
+        )
         print_history_group_sync(console, group)
 
     def _pending_history_entries(self) -> list[HistoryEntry]:

{comate_cli-0.5.8 → comate_cli-0.6.0}/pyproject.toml

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

{comate_cli-0.5.8 → comate_cli-0.6.0}/tests/test_history_printer.py

@@ -299,11 +299,12 @@ class TestAssumeRunContinuesAtTail(unittest.TestCase):
     assume_run_continues_at_tail=True 让 history_printer 把 batch 末尾的 assistant
     entry 当作 "run 仍在续" 处理，不加 trailing 空行。"""
 
-    def _render_lines(
+    def _render_str(
         self,
         entries: list[HistoryEntry],
         *,
         prev_was_assistant: bool = False,
+        prev_was_thinking: bool = False,
         assume_run_continues_at_tail: bool = False,
     ) -> list[str]:
         console = Console(file=None, force_terminal=True, width=120)
@@ -311,13 +312,32 @@ class TestAssumeRunContinuesAtTail(unittest.TestCase):
             console, entries, terminal_width=120,
             render_markdown_to_plain=_identity_md,
             prev_was_assistant=prev_was_assistant,
+            prev_was_thinking=prev_was_thinking,
             assume_run_continues_at_tail=assume_run_continues_at_tail,
         )
         if group is None:
-            return []
+            return ""
         with console.capture() as capture:
             console.print(group, soft_wrap=True)
-        return _strip_ansi(capture.get()).split("\n")
+        return _strip_ansi(capture.get())
+
+    def _render_lines(
+        self,
+        entries: list[HistoryEntry],
+        *,
+        prev_was_assistant: bool = False,
+        prev_was_thinking: bool = False,
+        assume_run_continues_at_tail: bool = False,
+    ) -> list[str]:
+        output = self._render_str(
+            entries,
+            prev_was_assistant=prev_was_assistant,
+            prev_was_thinking=prev_was_thinking,
+            assume_run_continues_at_tail=assume_run_continues_at_tail,
+        )
+        if output == "":
+            return []
+        return output.split("\n")
 
     def test_default_off_preserves_trailing_blank_line(self) -> None:
         """默认 False：保持原行为，末尾 assistant entry 后加 trailing 空行。"""
@@ -394,12 +414,73 @@ class TestAssumeRunContinuesAtTail(unittest.TestCase):
         first_idx = lines.index("  line one")
         self.assertEqual(lines[first_idx + 1], "  line two", msg=lines)
 
+    def test_thinking_internal_blank_lines_are_collapsed(self) -> None:
+        entries = [
+            HistoryEntry(
+                entry_type="thinking",
+                text="line one\n\nline two\n  \nline three\n",
+            ),
+        ]
+        lines = self._render_lines(entries)
+        first_idx = lines.index("  line one")
+        self.assertEqual(
+            lines[first_idx : first_idx + 3],
+            ["  line one", "  line two", "  line three"],
+            msg=lines,
+        )
+
+    def test_thinking_keeps_boundary_blank_lines(self) -> None:
+        entries = [
+            HistoryEntry(entry_type="user", text="hello"),
+            HistoryEntry(entry_type="thinking", text="line one\n\nline two\n"),
+            HistoryEntry(entry_type="assistant", text="hi\n"),
+        ]
+        lines = self._render_lines(entries)
+        user_idx = lines.index("> hello")
+        thinking_idx = lines.index("  line one")
+        assistant_idx = lines.index("⏺ hi")
+
+        self.assertEqual(lines[user_idx + 1], "", msg=lines)
+        self.assertEqual(thinking_idx, user_idx + 2, msg=lines)
+        self.assertEqual(lines[thinking_idx + 1], "  line two", msg=lines)
+        self.assertEqual(lines[thinking_idx + 2], "", msg=lines)
+        self.assertEqual(assistant_idx, thinking_idx + 3, msg=lines)
+
     def test_assume_tail_suppresses_trailing_blank_for_thinking_tail(self) -> None:
         entry = HistoryEntry(entry_type="thinking", text="streamed thought\n")
         lines = self._render_lines([entry], assume_run_continues_at_tail=True)
         non_empty = [ln for ln in lines if ln.strip() != ""]
         self.assertEqual(non_empty, ["  streamed thought"], msg=lines)
 
+    def test_cross_batch_thinking_to_assistant_keeps_boundary_blank_line(self) -> None:
+        first = self._render_str(
+            [HistoryEntry(entry_type="thinking", text="thought\n")],
+            assume_run_continues_at_tail=True,
+        )
+        second = self._render_str(
+            [HistoryEntry(entry_type="assistant", text="answer\n")],
+            prev_was_thinking=True,
+        )
+        merged = (first + second).split("\n")
+        thinking_idx = merged.index("  thought")
+        assistant_idx = merged.index("⏺ answer")
+
+        self.assertEqual(merged[thinking_idx + 1], "", msg=merged)
+        self.assertEqual(assistant_idx, thinking_idx + 2, msg=merged)
+
+    def test_cross_batch_thinking_to_thinking_does_not_insert_blank_line(self) -> None:
+        first = self._render_str(
+            [HistoryEntry(entry_type="thinking", text="line one\n")],
+            assume_run_continues_at_tail=True,
+        )
+        second = self._render_str(
+            [HistoryEntry(entry_type="thinking", text="line two\n")],
+            prev_was_thinking=True,
+        )
+        merged = (first + second).split("\n")
+        first_idx = merged.index("  line one")
+        self.assertEqual(merged[first_idx + 1], "  line two", msg=merged)
+
     def test_split_thinking_batch_visual_matches_single_batch(self) -> None:
         entries = [
             HistoryEntry(entry_type="thinking", text="line one\n"),
@@ -410,7 +491,7 @@ class TestAssumeRunContinuesAtTail(unittest.TestCase):
         first = self._render_lines(
             entries[:2], assume_run_continues_at_tail=True,
         )
-        second = self._render_lines(entries[2:])
+        second = self._render_lines(entries[2:], prev_was_thinking=True)
         merged = first + second
 
         single_content = [ln for ln in single_lines if ln.strip() != ""]

{comate_cli-0.5.8 → comate_cli-0.6.0}/tests/test_skills_slash_command.py

@@ -5,6 +5,7 @@ from types import SimpleNamespace
 
 from comate_agent_sdk.context import ContextIR, TokenCounter
 from comate_agent_sdk.context.items import ItemType
+from comate_agent_sdk.skill.bundled import get_builtin_skills
 from comate_agent_sdk.skill.models import SkillDefinition
 from comate_cli.terminal_agent.slash_commands import SlashCommandSpec
 from comate_cli.terminal_agent.tui import TerminalAgentTUI
@@ -381,6 +382,52 @@ class TestSkillSlashRegistration(unittest.TestCase):
         self.assertEqual(app._skill_slash_command_names, {"demo"})
         self.assertIn("demo", {spec.name for spec in completer.updated_specs})
 
+    def test_sync_registers_builtin_skillify_with_argument_hint(self) -> None:
+        registry = SlashCommandRegistry()
+        completer = _FakeSlashCompleter()
+        app = TerminalAgentTUI.__new__(TerminalAgentTUI)
+        app._session = _build_session(list(get_builtin_skills()))
+        app._slash_registry = registry
+        app._skill_slash_command_names = set()
+        app._slash_completer = completer
+
+        app._sync_skill_slash_commands()
+
+        skillify = registry.resolve("skillify")
+        self.assertIsNotNone(skillify)
+        assert skillify is not None
+        self.assertEqual(skillify.source, "skill")
+        self.assertEqual(skillify.spec.execution_kind, "hybrid")
+        self.assertIsNotNone(skillify.spec.argument_hint)
+        self.assertIn("description", skillify.spec.argument_hint or "")
+        self.assertEqual(app._skill_slash_command_names, {"skillify"})
+        self.assertIn("skillify", {spec.name for spec in completer.updated_specs})
+
+    def test_custom_slash_skillify_takes_precedence_over_builtin_skill(self) -> None:
+        registry = SlashCommandRegistry()
+        registry.register(
+            spec=SlashCommandSpec(
+                name="skillify",
+                description="custom skillify",
+                execution_kind="local",
+            ),
+            handler=_noop_handler,
+        )
+        completer = _FakeSlashCompleter()
+        app = TerminalAgentTUI.__new__(TerminalAgentTUI)
+        app._session = _build_session(list(get_builtin_skills()))
+        app._slash_registry = registry
+        app._skill_slash_command_names = set()
+        app._slash_completer = completer
+
+        app._sync_skill_slash_commands()
+
+        skillify = registry.resolve("skillify")
+        self.assertIsNotNone(skillify)
+        assert skillify is not None
+        self.assertEqual(skillify.source, "builtin")
+        self.assertEqual(app._skill_slash_command_names, set())
+
 
 if __name__ == "__main__":
     unittest.main()

{comate_cli-0.5.8 → comate_cli-0.6.0}/uv.lock

@@ -389,7 +389,7 @@ wheels = [
 
 [[package]]
 name = "comate-agent-sdk"
-version = "0.6.7"
+version = "0.6.9"
 source = { editable = "../../" }
 dependencies = [
     { name = "aiohttp" },
@@ -461,7 +461,7 @@ dev = [
 
 [[package]]
 name = "comate-cli"
-version = "0.5.6"
+version = "0.5.8"
 source = { editable = "." }
 dependencies = [
     { name = "charset-normalizer" },