comate-cli 0.5.5__tar.gz → 0.5.7__tar.gz

{comate_cli-0.5.5 → comate_cli-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.5.5
+Version: 0.5.7
 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.5 → comate_cli-0.5.7}/comate_cli/terminal_agent/event_renderer.py

@@ -1647,7 +1647,7 @@ class EventRenderer:
                     return (True, None)
                 if reason == "waiting_for_plan_approval":
                     return (False, None)
-                if reason == "interrupted":
+                if reason == "interrupted" and "error" not in event.metadata:
                     self._append_history_entry(
                         HistoryEntry(entry_type="system", text="Current task interrupted.", severity="warning")
                     )

{comate_cli-0.5.5 → comate_cli-0.5.7}/comate_cli/terminal_agent/selection_menu.py

@@ -288,14 +288,13 @@ class SelectionMenuUI:
             desc_style = "class:selection.description.selected" if is_selected else "class:selection.description"
 
             if self._state.layout_mode == "inline":
-                fragments.append(
-                    (
-                        line_style,
-                        self._inline_option_line(
-                            option=option,
-                            cursor=cursor,
-                            marker=marker,
-                        ),
+                fragments.extend(
+                    self._inline_option_fragments(
+                        option=option,
+                        cursor=cursor,
+                        marker=marker,
+                        line_style=line_style,
+                        desc_style=desc_style,
                     )
                 )
                 fragments.append(("", "\n"))
@@ -331,13 +330,15 @@ class SelectionMenuUI:
         )
         return fragments
 
-    def _inline_option_line(
+    def _inline_option_fragments(
         self,
         *,
         option: SelectionOption,
         cursor: str,
         marker: str,
-    ) -> str:
+        line_style: str,
+        desc_style: str,
+    ) -> list[tuple[str, str]]:
         total_width = max(20, int(self._state.inline_total_width or 100))
         prefix = f"  {cursor} {marker} "
         prefix_width = get_cwidth(prefix)
@@ -357,13 +358,16 @@ class SelectionMenuUI:
         name_padding = " " * max(0, name_width - get_cwidth(name_text))
 
         if desc_width <= 0:
-            return fit_single_line(f"{prefix}{name_text}", total_width)
+            return [(line_style, fit_single_line(f"{prefix}{name_text}", total_width))]
 
         description = option.description.strip()
         desc_text = fit_single_line(description, desc_width) if description else ""
         if desc_text:
-            return f"{prefix}{name_text}{name_padding}{' ' * gap_width}{desc_text}"
-        return f"{prefix}{name_text}{name_padding}"
+            return [
+                (line_style, f"{prefix}{name_text}{name_padding}"),
+                (desc_style, f"{' ' * gap_width}{desc_text}"),
+            ]
+        return [(line_style, f"{prefix}{name_text}{name_padding}")]
 
     def _normalized_page_size(self) -> int:
         options_count = len(self._state.options)

{comate_cli-0.5.5 → comate_cli-0.5.7}/comate_cli/terminal_agent/tui.py

@@ -179,9 +179,13 @@ class TerminalAgentTUI(
                 from prompt_toolkit.application import get_app
                 from prompt_toolkit.application.dummy import DummyApplication
                 app = get_app()
-                if not isinstance(app, DummyApplication):
-                    app.create_background_task(run_in_terminal(_write, in_executor=False))
-                    return
+                if isinstance(app, DummyApplication):
+                    _write()
+                else:
+                    # run_in_terminal() 自身已经会调度 Future；不能再交给
+                    # create_background_task() 二次包装，否则会触发重复执行竞态。
+                    run_in_terminal(_write, in_executor=False)
+                return
             except Exception:
                 pass
             _write()
@@ -222,6 +226,7 @@ class TerminalAgentTUI(
         self._renderer._show_thinking_cb = lambda: self._show_thinking
 
         self._custom_slash_commands: dict[str, CustomSlashCommand] = {}
+        self._skill_slash_command_names: set[str] = set()
         self._slash_registry = SlashCommandRegistry()
         self._build_slash_registry()
         self._slash_completer = SlashCommandCompleter(
@@ -237,6 +242,7 @@ class TerminalAgentTUI(
                 deduplicate=True,
             )
         )
+        self._sync_skill_slash_commands()
         self._loading_frame = 0
         self._fallback_loading_phrase = (
             random.choice(DEFAULT_STATUS_PHRASES)
@@ -719,6 +725,56 @@ class TerminalAgentTUI(
                 argument_hint=command.argument_hint,
             )
 
+    def _sync_skill_slash_commands(self) -> None:
+        """同步当前 runtime skills 到 slash command registry。"""
+        for name in list(getattr(self, "_skill_slash_command_names", set())):
+            self._slash_registry.unregister(name)
+        self._skill_slash_command_names = set()
+
+        agent = getattr(self._session, "_agent", None)
+        runtime_state = getattr(agent, "_runtime_state", None)
+        skills = list(getattr(runtime_state, "skills", []) or [])
+        seen_names: set[str] = set()
+
+        for skill in skills:
+            if not bool(getattr(skill, "user_invocable", True)):
+                continue
+
+            name = str(getattr(skill, "name", "")).strip()
+            if not name or name in seen_names:
+                continue
+            seen_names.add(name)
+
+            if self._slash_registry.resolve(name) is not None:
+                logger.warning(
+                    "Skill '%s' conflicts with an existing slash command, skipping",
+                    name,
+                )
+                continue
+
+            spec = SlashCommandSpec(
+                name=name,
+                description=str(getattr(skill, "description", "") or "").strip(),
+                execution_kind="hybrid",
+                argument_hint=getattr(skill, "argument_hint", None),
+            )
+
+            async def _handler(args: str, *, skill_name: str = name) -> None:
+                await self._slash_skill(skill_name=skill_name, args=args)
+
+            self._slash_registry.register(
+                spec=spec,
+                handler=_handler,
+                allow_when_busy=False,
+                source="skill",
+                argument_hint=spec.argument_hint,
+            )
+            self._skill_slash_command_names.add(name)
+
+        slash_completer = getattr(self, "_slash_completer", None)
+        if slash_completer is not None:
+            slash_completer.update_commands(self._slash_registry.command_specs())
+
     def _resolve_slash_spec(self, name: str) -> SlashCommandSpec | None:
         entry = self._slash_registry.resolve(name)
         if entry is None:
@@ -904,6 +960,7 @@ class TerminalAgentTUI(
             async for event in self._session.events():
                 if self._closing:
                     break
+                stop_error: Exception | None = None
                 self._maybe_cancel_tool_result_flash(event)
                 await self._animation_controller.on_event(event)
                 if isinstance(event, SessionInitEvent):
@@ -918,6 +975,36 @@ class TerminalAgentTUI(
                                 str(message_id),
                                 None,
                             )
+                    if event.reason is QueueDirtyReason.CONSUMED:
+                        consumed_human_displays: list[str] = []
+                        for message_id, origin in zip(event.message_ids, event.origins):
+                            if origin is not MessageOrigin.HUMAN:
+                                continue
+                            display_text = self._queued_display_by_message_id.pop(
+                                str(message_id),
+                                None,
+                            )
+                            if display_text:
+                                consumed_human_displays.append(display_text)
+                        if consumed_human_displays and not self._busy:
+                            self._session.run_controller.clear()
+                            self._interrupt_requested_at = None
+                            self._waiting_for_input = False
+                            self._pending_questions = None
+                            self._pending_plan_approval = None
+                            self._set_busy(True)
+                            self._run_start_time = time.monotonic()
+                            self._fallback_loading_phrase = (
+                                random.choice(DEFAULT_STATUS_PHRASES)
+                                if DEFAULT_STATUS_PHRASES
+                                else f"Thinking{ELLIPSIS}"
+                            )
+                            self._fallback_phrase_refresh_at = time.monotonic() + 3.0
+                            self._renderer.start_turn()
+                            await self._animation_controller.start()
+                            self._last_turn_user_preview = consumed_human_displays[-1]
+                        for display_text in consumed_human_displays:
+                            self._renderer.seed_user_message(display_text)
                     self._refresh_layers()
                     self._invalidate()
                 if isinstance(event, QueuedMessageInjectedEvent):
@@ -953,6 +1040,14 @@ class TerminalAgentTUI(
                     }
                 if isinstance(event, StopEvent):
                     stop_reason = str(event.reason or "")
+                    raw_stop_error = event.metadata.get("error")
+                    if raw_stop_error is not None:
+                        stop_error = (
+                            raw_stop_error
+                            if isinstance(raw_stop_error, Exception)
+                            else Exception(str(raw_stop_error))
+                        )
+                        stop_reason = "error"
                     if event.reason == "shutdown_request":
                         shutdown_recipients = event.metadata.get("shutdown_recipients", [])
                         if shutdown_recipients:
@@ -968,6 +1063,15 @@ class TerminalAgentTUI(
                     waiting_for_input = True
                     if new_questions is not None:
                         questions = new_questions
+                if stop_error is not None:
+                    from comate_cli.terminal_agent.error_display import format_error
+
+                    message, transient_summary, severity = format_error(stop_error)
+                    self._renderer.append_system_message(message, severity=severity)
+                    self._status_bar.show_transient(
+                        transient_summary,
+                        severity=severity,
+                    )
                 self._refresh_layers()
                 if isinstance(event, StopEvent):
                     background_turn = self._background_turn_source is not None
@@ -1487,6 +1591,9 @@ class TerminalAgentTUI(
 
             # Commands → SlashCommandRegistry with namespace prefix
             for cmd in plugin.commands:
+                if cmd.name in getattr(self, "_skill_slash_command_names", set()):
+                    self._slash_registry.unregister(cmd.name)
+                    self._skill_slash_command_names.discard(cmd.name)
                 spec = SlashCommandSpec(
                     name=cmd.name,  # already namespaced: "plugin-name:cmd-name"
                     description=cmd.description,
@@ -1544,8 +1651,10 @@ class TerminalAgentTUI(
         if any(p.agents for p in plugins):
             rebuild_agent_tool(agent)
 
+        if any(p.skills for p in plugins):
+            self._sync_skill_slash_commands()
         # Refresh tab-completion so new plugin commands appear
-        if any(p.commands for p in plugins):
+        elif any(p.commands for p in plugins):
             self._slash_completer.update_commands(self._slash_registry.command_specs())
 
     def _clear_plugin_resources(self) -> None:
@@ -1583,10 +1692,6 @@ class TerminalAgentTUI(
             self._custom_slash_commands.pop(cmd_name, None)
         self._plugin_command_names = set()
 
-        # Refresh tab-completion so removed commands disappear
-        if had_commands:
-            self._slash_completer.update_commands(self._slash_registry.command_specs())
-
         # Remove plugin MCP servers from frozen config
         has_mcp = any(p.mcp_servers for p in loaded)
         if has_mcp and agent.config.mcp_servers:
@@ -1610,3 +1715,5 @@ class TerminalAgentTUI(
             rebuild_skill_tool(agent)
         if had_agents:
             rebuild_agent_tool(agent)
+        if had_skills or had_commands:
+            self._sync_skill_slash_commands()

{comate_cli-0.5.5 → comate_cli-0.5.7}/comate_cli/terminal_agent/tui_parts/commands.py

@@ -4,14 +4,16 @@ import asyncio
 import logging
 import time
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 
 from prompt_toolkit.document import Document
 
 from comate_agent_sdk.agent.llm_levels import ALL_LEVELS
+from comate_agent_sdk.context import TokenCounter
 from comate_agent_sdk.context.items import ItemType
 from comate_agent_sdk.llm.messages import UserMessage
+from comate_agent_sdk.skill.execution import invoke_skill_by_name
 
 from comate_cli.terminal_agent.figures import (
     CHECK_MARK,
@@ -30,6 +32,9 @@ from comate_cli.terminal_agent.tui_parts.ui_mode import UIMode
 
 logger = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from comate_cli.terminal_agent.plugins.plugin_picker import PluginPickerAction
+
 
 class CommandsMixin:
     def _begin_llm_long_task(self) -> None:
@@ -165,7 +170,10 @@ class CommandsMixin:
                 terminal_width = None
 
         def on_confirm(value: str) -> None:
-            self._prefill_user_input(value)
+            self._prefill_user_input(
+                f"/{value} ",
+                preserve_trailing_space=True,
+            )
             self._refresh_layers()
 
         def on_cancel() -> None:
@@ -739,30 +747,86 @@ class CommandsMixin:
 
     def _active_session_skills(self) -> list[dict[str, str]]:
         agent = getattr(self._session, "_agent", None)
-        options = getattr(agent, "options", None)
-        loaded_skills = list(getattr(options, "skills", []) or [])
+        runtime_state = getattr(agent, "_runtime_state", None)
+        loaded_skills = list(getattr(runtime_state, "skills", []) or [])
+        registered_names = set(getattr(self, "_skill_slash_command_names", set()))
+        plugin_namespaces = {
+            str(getattr(plugin, "namespace", "")).strip()
+            for plugin in getattr(self, "_loaded_plugins", []) or []
+        }
+        plugin_namespaces.discard("")
+        token_counter = TokenCounter()
         seen_names: set[str] = set()
         active: list[dict[str, str]] = []
 
         for skill in loaded_skills:
-            if bool(getattr(skill, "disable_model_invocation", False)):
-                continue
-
             name = str(getattr(skill, "name", "")).strip()
-            if not name or name in seen_names:
+            if not name or name in seen_names or name not in registered_names:
                 continue
 
-            description = str(getattr(skill, "description", "")).strip()
+            description = str(getattr(skill, "description", "") or "").strip()
+            when_to_use = str(getattr(skill, "when_to_use", "") or "").strip()
+            frontmatter_text = " ".join(
+                part for part in (name, description, when_to_use) if part
+            )
+            token_count = token_counter.count(frontmatter_text)
+            source = (
+                "plugin"
+                if any(name.startswith(f"{namespace}:") for namespace in plugin_namespaces)
+                else "user"
+            )
             active.append(
                 {
                     "name": name,
-                    "description": description or "(No description)",
+                    "description": f"· {source} · ~{token_count} tok",
                 }
             )
             seen_names.add(name)
 
         return active
 
+    async def _slash_skill(self, *, skill_name: str, args: str) -> None:
+        normalized_args = args.strip()
+        result = await invoke_skill_by_name(
+            self._session._agent,
+            skill_name,
+            args=normalized_args or None,
+            invocation_source="user_slash",
+            flush=False,
+        )
+        if not result.success:
+            self._renderer.append_system_message(result.message, severity="error")
+            return
+        self._session._agent._context.add_message(
+            UserMessage(
+                content=self._format_skill_slash_metadata(
+                    skill_name=skill_name,
+                    args=normalized_args,
+                ),
+                is_meta=True,
+            )
+        )
+        self._session._agent._context.flush_pending_skill_items()
+
+        display_text = f"/{skill_name}"
+        if normalized_args:
+            display_text = f"{display_text} {normalized_args}"
+
+        model_prompt = "The requested skill has already been loaded. Continue using the injected skill instructions."
+        if normalized_args:
+            model_prompt = f"{model_prompt}\n\nArguments: {normalized_args}"
+        await self._submit_user_message(model_prompt, display_text=display_text)
+
+    @staticmethod
+    def _format_skill_slash_metadata(*, skill_name: str, args: str) -> str:
+        parts = [
+            f"<command-message>{skill_name}</command-message>",
+            f"<command-name>/{skill_name}</command-name>",
+        ]
+        if args:
+            parts.append(f"<command-args>{args}</command-args>")
+        return "\n".join(parts)
+
     async def _slash_custom(self, *, command_name: str, args: str) -> None:
         command = self._custom_slash_commands.get(command_name)
         if command is None:
@@ -1336,9 +1400,14 @@ class CommandsMixin:
                 return content_text
         return fallback.strip()
 
-    def _prefill_user_input(self, text: str) -> None:
-        normalized = str(text).strip()
-        if not normalized:
+    def _prefill_user_input(
+        self,
+        text: str,
+        *,
+        preserve_trailing_space: bool = False,
+    ) -> None:
+        normalized = str(text).rstrip("\r\n") if preserve_trailing_space else str(text).strip()
+        if not normalized.strip():
             return
         self._clear_paste_state()
         self._last_input_len = len(normalized)

{comate_cli-0.5.5 → comate_cli-0.5.7}/comate_cli/terminal_agent/tui_parts/key_bindings.py

@@ -13,6 +13,61 @@ from comate_cli.terminal_agent.tui_parts.ui_mode import UIMode
 
 
 class KeyBindingsMixin:
+    def _pop_human_queue_to_input(self, buffer) -> bool:  # type: ignore[no-untyped-def]
+        if str(getattr(buffer, "text", "") or "").strip():
+            return False
+
+        peek_queue = getattr(self._session, "peek_queue", None)
+        queued_messages = tuple(peek_queue()) if callable(peek_queue) else ()
+        human_messages = [
+            message
+            for message in queued_messages
+            if getattr(message, "origin", None) == MessageOrigin.HUMAN
+        ]
+        if not human_messages:
+            return False
+
+        def _editable_text(message) -> str:  # type: ignore[no-untyped-def]
+            content = getattr(message, "content", "")
+            if isinstance(content, str):
+                return content
+            if isinstance(content, list):
+                pieces: list[str] = []
+                for part in content:
+                    if isinstance(part, dict):
+                        part_type = str(part.get("type", ""))
+                        if part_type == "text":
+                            pieces.append(str(part.get("text", "")))
+                        elif "image" in part_type:
+                            pieces.append("[image]")
+                    else:
+                        pieces.append(str(part))
+                return "\n".join(piece for piece in pieces if piece)
+            return str(content)
+
+        text = "\n\n".join(
+            piece
+            for piece in (_editable_text(message) for message in human_messages)
+            if piece
+        )
+        buffer.text = text
+        buffer.cursor_position = len(text)
+        message_ids = tuple(
+            str(getattr(message, "message_id"))
+            for message in human_messages
+        )
+        cancel_many = getattr(self._session, "cancel_many", None)
+        if callable(cancel_many):
+            cancel_many(message_ids)
+        queued_display = getattr(self, "_queued_display_by_message_id", None)
+        if isinstance(queued_display, dict):
+            for message_id in message_ids:
+                queued_display.pop(message_id, None)
+        self._esc_press_count = 0
+        self._esc_last_pressed_at = time.monotonic()
+        self._invalidate()
+        return True
+
     def _build_key_bindings(self) -> KeyBindings:
         bindings = KeyBindings()
         normal_mode = Condition(lambda: self._ui_mode == UIMode.NORMAL)
@@ -341,6 +396,8 @@ class KeyBindingsMixin:
             if self._move_cursor_visual(buffer, backward=True):
                 self._invalidate()
                 return
+            if self._pop_human_queue_to_input(buffer):
+                return
             if self._should_handle_history():
                 buffer.auto_up(count=1)
 
@@ -377,53 +434,7 @@ class KeyBindingsMixin:
                 self._esc_last_pressed_at = now
                 return
 
-            peek_queue = getattr(self._session, "peek_queue", None)
-            queued_messages = tuple(peek_queue()) if callable(peek_queue) else ()
-            human_messages = [
-                message
-                for message in queued_messages
-                if getattr(message, "origin", None) == MessageOrigin.HUMAN
-            ]
-            if human_messages:
-                def _editable_text(message) -> str:  # type: ignore[no-untyped-def]
-                    content = getattr(message, "content", "")
-                    if isinstance(content, str):
-                        return content
-                    if isinstance(content, list):
-                        pieces: list[str] = []
-                        for part in content:
-                            if isinstance(part, dict):
-                                part_type = str(part.get("type", ""))
-                                if part_type == "text":
-                                    pieces.append(str(part.get("text", "")))
-                                elif "image" in part_type:
-                                    pieces.append("[image]")
-                            else:
-                                pieces.append(str(part))
-                        return "\n".join(piece for piece in pieces if piece)
-                    return str(content)
-
-                text = "\n\n".join(
-                    piece
-                    for piece in (_editable_text(message) for message in human_messages)
-                    if piece
-                )
-                buffer.text = text
-                buffer.cursor_position = len(text)
-                message_ids = tuple(
-                    str(getattr(message, "message_id"))
-                    for message in human_messages
-                )
-                cancel_many = getattr(self._session, "cancel_many", None)
-                if callable(cancel_many):
-                    cancel_many(message_ids)
-                queued_display = getattr(self, "_queued_display_by_message_id", None)
-                if isinstance(queued_display, dict):
-                    for message_id in message_ids:
-                        queued_display.pop(message_id, None)
-                self._esc_press_count = 0
-                self._esc_last_pressed_at = now
-                self._invalidate()
+            if self._pop_human_queue_to_input(buffer):
                 return
 
             if now - self._esc_last_pressed_at > self._esc_clear_window_seconds:

{comate_cli-0.5.5 → comate_cli-0.5.7}/comate_cli/terminal_agent/tui_parts/slash_command_registry.py

@@ -6,7 +6,7 @@ from typing import Any, Callable, Literal
 from comate_cli.terminal_agent.slash_commands import SlashCommandSpec
 
 
-SlashCommandSource = Literal["builtin", "custom"]
+SlashCommandSource = Literal["builtin", "custom", "skill"]
 
 
 @dataclass(frozen=True, slots=True)

{comate_cli-0.5.5 → comate_cli-0.5.7}/pyproject.toml

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

{comate_cli-0.5.5 → comate_cli-0.5.7}/tests/test_event_renderer_streaming.py

@@ -40,6 +40,16 @@ class TestQ11Fallback(unittest.TestCase):
         # 兜底走 _append_assistant_text → buffer 累
         self.assertEqual(renderer._assistant_buffer, "legacy hello")
 
+    def test_provider_error_stop_does_not_add_interrupted_message(self) -> None:
+        renderer = EventRenderer()
+        renderer.start_turn()
+        renderer.handle_event(
+            StopEvent(reason="interrupted", metadata={"error": Exception("Connection refused")})
+        )
+
+        texts = [entry.text for entry in renderer.history_entries()]
+        self.assertNotIn("Current task interrupted.", texts)
+
     def test_thinking_event_no_op_when_delta_received(self) -> None:
         renderer = EventRenderer()
         renderer.start_turn()

{comate_cli-0.5.5 → comate_cli-0.5.7}/tests/test_selection_menu.py

@@ -124,6 +124,40 @@ class TestSelectionMenu(unittest.TestCase):
         self.assertIn("Helps users", lines[0])
         self.assertNotIn("      Helps users", lines[0])
 
+    def test_inline_layout_styles_name_and_description_separately(self) -> None:
+        ui = SelectionMenuUI()
+        ok = ui.set_options(
+            title="menu",
+            options=[
+                {
+                    "value": "find-skills",
+                    "label": "find-skills",
+                    "description": "· user · ~12 tok",
+                }
+            ],
+            layout_mode="inline",
+            line_wrap=False,
+            inline_total_width=56,
+            inline_name_min_width=12,
+            inline_name_max_width=16,
+        )
+        self.assertTrue(ok)
+
+        fragments = ui._options_fragments()
+        self.assertTrue(
+            any(
+                style == "class:selection.option.selected" and "find-skills" in text
+                for style, text in fragments
+            )
+        )
+        self.assertTrue(
+            any(
+                style == "class:selection.description.selected"
+                and "· user · ~12 tok" in text
+                for style, text in fragments
+            )
+        )
+
     def test_context_lines_render_before_options(self) -> None:
         ui = SelectionMenuUI()
         ok = ui.set_options(