klaude-code 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/ui/modes/repl/key_bindings.py

@@ -0,0 +1,170 @@
+"""REPL keyboard bindings for prompt_toolkit.
+
+This module provides the factory function to create key bindings for the REPL input,
+with dependencies injected to avoid circular imports.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from typing import cast
+
+from prompt_toolkit.key_binding import KeyBindings
+
+
+def create_key_bindings(
+    capture_clipboard_tag: Callable[[], str | None],
+    copy_to_clipboard: Callable[[str], None],
+    at_token_pattern: re.Pattern[str],
+) -> KeyBindings:
+    """Create REPL key bindings with injected dependencies.
+
+    Args:
+        capture_clipboard_tag: Callable to capture clipboard image and return tag
+        copy_to_clipboard: Callable to copy text to system clipboard
+        at_token_pattern: Pattern to match @token for completion refresh
+
+    Returns:
+        KeyBindings instance with all REPL handlers configured
+    """
+    kb = KeyBindings()
+
+    @kb.add("c-v")
+    def _(event):  # type: ignore
+        """Paste image from clipboard as [Image #N]."""
+        tag = capture_clipboard_tag()
+        if tag:
+            try:
+                event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
+            except Exception:
+                pass
+
+    @kb.add("enter")
+    def _(event):  # type: ignore
+        buf = event.current_buffer  # type: ignore
+        doc = buf.document  # type: ignore
+
+        # If VS Code/Windsurf/Cursor sent a "\\" sentinel before Enter (Shift+Enter mapping),
+        # treat it as a request for a newline instead of submit.
+        # This allows Shift+Enter to insert a newline in our multiline prompt.
+        try:
+            if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
+                buf.delete_before_cursor()  # remove the sentinel backslash  # type: ignore[reportUnknownMemberType]
+                buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
+                return
+        except Exception:
+            # Fall through to default behavior if anything goes wrong
+            pass
+
+        # If the entire buffer is whitespace-only, insert a newline rather than submitting.
+        if len(buf.text.strip()) == 0:  # type: ignore
+            buf.insert_text("\n")  # type: ignore
+            return
+
+        # No need to persist manifest anymore - iter_inputs will handle image extraction
+        buf.validate_and_handle()  # type: ignore
+
+    @kb.add("c-j")
+    def _(event):  # type: ignore
+        event.current_buffer.insert_text("\n")  # type: ignore
+
+    @kb.add("c")
+    def _(event):  # type: ignore
+        """Copy selected text to system clipboard, or insert 'c' if no selection."""
+        buf = event.current_buffer  # type: ignore
+        if buf.selection_state:  # type: ignore[reportUnknownMemberType]
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            start, end = doc.selection_range()  # type: ignore[reportUnknownMemberType]
+            selected_text: str = doc.text[start:end]  # type: ignore[reportUnknownMemberType]
+
+            if selected_text:
+                copy_to_clipboard(selected_text)  # type: ignore[reportUnknownArgumentType]
+            buf.exit_selection()  # type: ignore[reportUnknownMemberType]
+        else:
+            buf.insert_text("c")  # type: ignore[reportUnknownMemberType]
+
+    @kb.add("backspace")
+    def _(event):  # type: ignore
+        """Ensure completions refresh on backspace when editing an @token.
+
+        We delete the character before cursor (default behavior), then explicitly
+        trigger completion refresh if the caret is still within an @... token.
+        """
+        buf = event.current_buffer  # type: ignore
+        # Handle selection: cut selection if present, otherwise delete one character
+        if buf.selection_state:  # type: ignore[reportUnknownMemberType]
+            buf.cut_selection()  # type: ignore[reportUnknownMemberType]
+        else:
+            buf.delete_before_cursor()  # type: ignore[reportUnknownMemberType]
+        # If the token pattern still applies, refresh completion popup
+        try:
+            text_before = buf.document.text_before_cursor  # type: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            # Check for both @ tokens and / tokens (slash commands on first line only)
+            should_refresh = False
+            if at_token_pattern.search(text_before):  # type: ignore[reportUnknownArgumentType]
+                should_refresh = True
+            elif buf.document.cursor_position_row == 0:  # type: ignore[reportUnknownMemberType]
+                # Check for slash command pattern without accessing protected attribute
+                text_before_str = cast(str, text_before or "")
+                if text_before_str.strip().startswith("/") and " " not in text_before_str:
+                    should_refresh = True
+
+            if should_refresh:
+                buf.start_completion(select_first=False)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            pass
+
+    @kb.add("left")
+    def _(event):  # type: ignore
+        """Support wrapping to previous line when pressing left at column 0."""
+        buf = event.current_buffer  # type: ignore
+        try:
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            row = cast(int, doc.cursor_position_row)  # type: ignore[reportUnknownMemberType]
+            col = cast(int, doc.cursor_position_col)  # type: ignore[reportUnknownMemberType]
+
+            # At the beginning of a non-first line: jump to previous line end.
+            if col == 0 and row > 0:
+                lines = cast(list[str], doc.lines)  # type: ignore[reportUnknownMemberType]
+                prev_row = row - 1
+                if 0 <= prev_row < len(lines):
+                    prev_line = lines[prev_row]
+                    new_index = doc.translate_row_col_to_index(prev_row, len(prev_line))  # type: ignore[reportUnknownMemberType]
+                    buf.cursor_position = new_index  # type: ignore[reportUnknownMemberType]
+                return
+
+            # Default behavior: move one character left when possible.
+            if doc.cursor_position > 0:  # type: ignore[reportUnknownMemberType]
+                buf.cursor_left()  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            pass
+
+    @kb.add("right")
+    def _(event):  # type: ignore
+        """Support wrapping to next line when pressing right at line end."""
+        buf = event.current_buffer  # type: ignore
+        try:
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            row = cast(int, doc.cursor_position_row)  # type: ignore[reportUnknownMemberType]
+            col = cast(int, doc.cursor_position_col)  # type: ignore[reportUnknownMemberType]
+            lines = cast(list[str], doc.lines)  # type: ignore[reportUnknownMemberType]
+
+            current_line = lines[row] if 0 <= row < len(lines) else ""
+            at_line_end = col >= len(current_line)
+            is_last_line = row >= len(lines) - 1 if lines else True
+
+            # At end of a non-last line: jump to next line start.
+            if at_line_end and not is_last_line:
+                next_row = row + 1
+                new_index = doc.translate_row_col_to_index(next_row, 0)  # type: ignore[reportUnknownMemberType]
+                buf.cursor_position = new_index  # type: ignore[reportUnknownMemberType]
+                return
+
+            # Default behavior: move one character right when possible.
+            if doc.cursor_position < len(doc.text):  # type: ignore[reportUnknownMemberType]
+                buf.cursor_right()  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            pass
+
+    return kb

klaude_code/ui/{repl → modes/repl}/renderer.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Any, Iterator
@@ -8,25 +7,25 @@ from typing import Any, Iterator
 from rich import box
 from rich.box import Box
 from rich.console import Console
-from rich.padding import Padding
+from rich.spinner import Spinner
 from rich.status import Status
 from rich.style import Style, StyleType
 from rich.text import Text
 
-from klaude_code.core.sub_agent import get_sub_agent_profile_by_tool
-from klaude_code.protocol import events, model, tools
-from klaude_code.ui.base.theme import ThemeKey, get_theme
+from klaude_code.protocol import events, model
+from klaude_code.ui.renderers import assistant as r_assistant
 from klaude_code.ui.renderers import developer as r_developer
-from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers import errors as r_errors
 from klaude_code.ui.renderers import metadata as r_metadata
-from klaude_code.ui.renderers import status as r_status
 from klaude_code.ui.renderers import sub_agent as r_sub_agent
+from klaude_code.ui.renderers import thinking as r_thinking
 from klaude_code.ui.renderers import tools as r_tools
 from klaude_code.ui.renderers import user_input as r_user_input
-from klaude_code.ui.renderers.common import create_grid, truncate_display
-from klaude_code.ui.rich_ext.markdown import NoInsetMarkdown
-from klaude_code.ui.rich_ext.quote import Quote
+from klaude_code.ui.rich import status as r_status
+from klaude_code.ui.rich.quote import Quote
+from klaude_code.ui.rich.status import ShimmerStatusText
+from klaude_code.ui.rich.theme import ThemeKey, get_theme
+from klaude_code.ui.utils.common import truncate_display
 
 
 @dataclass
@@ -42,8 +41,8 @@ class REPLRenderer:
         self.themes = get_theme(theme)
         self.console: Console = Console(theme=self.themes.app_theme)
         self.console.push_theme(self.themes.markdown_theme)
-        self.spinner: Status = self.console.status(
-            r_status.render_status_text("Thinking …", ThemeKey.SPINNER_STATUS_TEXT),
+        self._spinner: Status = self.console.status(
+            ShimmerStatusText("Thinking …", ThemeKey.SPINNER_STATUS_TEXT),
             spinner=r_status.spinner_name(),
             spinner_style=ThemeKey.SPINNER_STATUS,
         )
@@ -86,14 +85,6 @@ class REPLRenderer:
     def box_style(self) -> Box:
         return box.ROUNDED
 
-    @staticmethod
-    def _extract_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-        if ui_extra is None:
-            return None
-        if ui_extra.type == model.ToolResultUIExtraType.DIFF_TEXT:
-            return ui_extra.diff_text
-        return None
-
     @contextmanager
     def session_print_context(self, session_id: str) -> Iterator[None]:
         """Temporarily switch to sub-agent quote style."""
@@ -112,11 +103,10 @@ class REPLRenderer:
         self.console.print(*objects, style=style, end=end)
 
     def display_tool_call(self, e: events.ToolCallEvent) -> None:
+        # Handle sub-agent tool calls in replay mode
         if r_tools.is_sub_agent_tool(e.tool_name):
-            # In replay mode, render sub-agent call here
-            # In normal execution, handled by TaskStartEvent
             if e.is_replay:
-                state = self._build_sub_agent_state_from_tool_call(e)
+                state = r_sub_agent.build_sub_agent_state_from_tool_call(e)
                 if state is not None:
                     sub_agent_default_style = (
                         self.themes.sub_agent_colors[0] if self.themes.sub_agent_colors else Style()
@@ -128,36 +118,14 @@ class REPLRenderer:
                         )
                     )
             return
-        match e.tool_name:
-            case tools.READ:
-                self.print(r_tools.render_read_tool_call(e.arguments))
-            case tools.EDIT:
-                self.print(r_tools.render_edit_tool_call(e.arguments))
-            case tools.WRITE:
-                self.print(r_tools.render_write_tool_call(e.arguments))
-            case tools.MULTI_EDIT:
-                self.print(r_tools.render_multi_edit_tool_call(e.arguments))
-            case tools.BASH:
-                self.print(r_tools.render_generic_tool_call(e.tool_name, e.arguments, ">"))
-            case tools.APPLY_PATCH:
-                self.print(r_tools.render_apply_patch_tool_call(e.arguments))
-            case tools.TODO_WRITE:
-                self.print(r_tools.render_generic_tool_call("Update Todos", "", "◎"))
-            case tools.UPDATE_PLAN:
-                self.print(r_tools.render_update_plan_tool_call(e.arguments))
-            case tools.MERMAID:
-                self.print(r_tools.render_mermaid_tool_call(e.arguments))
-            case tools.MEMORY:
-                self.print(r_tools.render_memory_tool_call(e.arguments))
-            case tools.SKILL:
-                self.print(r_tools.render_generic_tool_call(e.tool_name, e.arguments, "◈"))
-            case _:
-                self.print(r_tools.render_generic_tool_call(e.tool_name, e.arguments))
+
+        renderable = r_tools.render_tool_call(e)
+        if renderable is not None:
+            self.print(renderable)
 
     def display_tool_call_result(self, e: events.ToolResultEvent) -> None:
+        # Handle sub-agent tool results in replay mode
         if r_tools.is_sub_agent_tool(e.tool_name):
-            # In replay mode, render sub-agent result here
-            # In normal execution, handled by TaskFinishEvent
             if e.is_replay:
                 sub_agent_default_style = self.themes.sub_agent_colors[0] if self.themes.sub_agent_colors else Style()
                 self.print(
@@ -171,82 +139,20 @@ class REPLRenderer:
                     )
                 )
             return
-        if e.status == "error" and e.ui_extra is None:
-            self.print(r_errors.render_error(Text(truncate_display(e.result))))
-            return
-
-        # Show truncation info if output was truncated and saved to file
-        truncation_info = r_tools.get_truncation_info(e)
-        if truncation_info:
-            self.print(r_tools.render_truncation_info(truncation_info))
-            return
 
-        diff_text = self._extract_diff_text(e.ui_extra)
-
-        match e.tool_name:
-            case tools.READ:
-                pass
-            case tools.EDIT | tools.MULTI_EDIT | tools.WRITE:
-                self.print(Padding.indent(r_diffs.render_diff(diff_text or ""), level=2))
-            case tools.MEMORY:
-                if diff_text:
-                    self.print(Padding.indent(r_diffs.render_diff(diff_text), level=2))
-                elif len(e.result.strip()) > 0:
-                    self.print(r_tools.render_generic_tool_result(e.result))
-            case tools.TODO_WRITE | tools.UPDATE_PLAN:
-                self.print(r_tools.render_todo(e))
-            case tools.MERMAID:
-                self.print(r_tools.render_mermaid_tool_result(e))
-            case _:
-                if e.tool_name in (tools.BASH, tools.APPLY_PATCH) and e.result.startswith("diff --git"):
-                    self.print(r_diffs.render_diff_panel(e.result, show_file_name=True))
-                    return
-                if e.tool_name == tools.APPLY_PATCH and diff_text:
-                    self.print(Padding.indent(r_diffs.render_diff(diff_text, show_file_name=True), level=2))
-                    return
-                if len(e.result.strip()) == 0:
-                    e.result = "(no content)"
-                self.print(r_tools.render_generic_tool_result(e.result))
-
-    def _build_sub_agent_state_from_tool_call(self, e: events.ToolCallEvent) -> model.SubAgentState | None:
-        profile = get_sub_agent_profile_by_tool(e.tool_name)
-        if profile is None:
-            return None
-        description = profile.name
-        prompt = ""
-        if e.arguments:
-            try:
-                payload: dict[str, object] = json.loads(e.arguments)
-            except json.JSONDecodeError:
-                payload = {}
-            desc_value = payload.get("description")
-            if isinstance(desc_value, str) and desc_value.strip():
-                description = desc_value.strip()
-            prompt_value = payload.get("prompt") or payload.get("task")
-            if isinstance(prompt_value, str):
-                prompt = prompt_value.strip()
-        return model.SubAgentState(
-            sub_agent_type=profile.name,
-            sub_agent_desc=description,
-            sub_agent_prompt=prompt,
-        )
+        renderable = r_tools.render_tool_result(e)
+        if renderable is not None:
+            self.print(renderable)
 
     def display_thinking(self, content: str) -> None:
-        if len(content.strip()) > 0:
+        renderable = r_thinking.render_thinking(
+            content,
+            code_theme=self.themes.code_theme,
+            style=ThemeKey.THINKING,
+        )
+        if renderable is not None:
             self.console.push_theme(theme=self.themes.thinking_markdown_theme)
-            self.print(
-                Padding.indent(
-                    NoInsetMarkdown(
-                        content.rstrip()
-                        .replace("**\n\n", "**  \n")
-                        .replace("\\n\\n\n\n", "")  # Weird case of Gemini 3
-                        .replace("****", "**\n\n**"),  # remove extra newlines after bold titles
-                        code_theme=self.themes.code_theme,
-                        style=self.console.get_style(ThemeKey.THINKING),
-                    ),
-                    level=2,
-                )
-            )
+            self.print(renderable)
             self.console.pop_theme()
             self.print()
 
@@ -257,16 +163,11 @@ class REPLRenderer:
                 case events.TurnStartEvent():
                     self.print()
                 case events.AssistantMessageEvent() as assistant_event:
-                    if len(assistant_event.content.strip()) > 0:
-                        grid = create_grid()
-                        grid.add_row(
-                            "•",
-                            NoInsetMarkdown(
-                                assistant_event.content.strip(),
-                                code_theme=self.themes.code_theme,
-                            ),
-                        )
-                        self.print(grid)
+                    renderable = r_assistant.render_assistant_message(
+                        assistant_event.content, code_theme=self.themes.code_theme
+                    )
+                    if renderable is not None:
+                        self.print(renderable)
                         self.print()
                 case events.ThinkingEvent() as thinking_event:
                     self.display_thinking(thinking_event.content)
@@ -302,3 +203,79 @@ class REPLRenderer:
         with self.session_print_context(e.session_id):
             self.print(r_developer.render_command_output(e))
             self.print()
+
+    def display_welcome(self, event: events.WelcomeEvent) -> None:
+        self.print(r_metadata.render_welcome(event, box_style=self.box_style()))
+
+    def display_user_message(self, event: events.UserMessageEvent) -> None:
+        self.print(r_user_input.render_user_input(event.content))
+
+    def display_task_start(self, event: events.TaskStartEvent) -> None:
+        self.register_session(event.session_id, event.sub_agent_state)
+        if event.sub_agent_state is not None:
+            with self.session_print_context(event.session_id):
+                self.print(
+                    r_sub_agent.render_sub_agent_call(
+                        event.sub_agent_state,
+                        self.get_session_sub_agent_color(event.session_id),
+                    )
+                )
+
+    def display_turn_start(self, event: events.TurnStartEvent) -> None:
+        if not self.is_sub_agent_session(event.session_id):
+            self.print()
+
+    def display_assistant_message(self, content: str) -> None:
+        renderable = r_assistant.render_assistant_message(content, code_theme=self.themes.code_theme)
+        if renderable is not None:
+            self.print(renderable)
+            self.print()
+
+    def display_response_metadata(self, event: events.ResponseMetadataEvent) -> None:
+        with self.session_print_context(event.session_id):
+            self.print(r_metadata.render_response_metadata(event))
+            self.print()
+
+    def display_task_finish(self, event: events.TaskFinishEvent) -> None:
+        if self.is_sub_agent_session(event.session_id):
+            with self.session_print_context(event.session_id):
+                self.print(
+                    r_sub_agent.render_sub_agent_result(
+                        event.task_result,
+                        code_theme=self.themes.code_theme,
+                    )
+                )
+
+    def display_interrupt(self) -> None:
+        self.print(r_user_input.render_interrupt())
+
+    def display_error(self, event: events.ErrorEvent) -> None:
+        self.print(
+            r_errors.render_error(
+                self.console.render_str(truncate_display(event.error_message)),
+                indent=0,
+            )
+        )
+
+    def display_thinking_prefix(self) -> None:
+        self.print(r_thinking.thinking_prefix())
+
+    # -------------------------------------------------------------------------
+    # Spinner control methods
+    # -------------------------------------------------------------------------
+
+    def spinner_start(self) -> None:
+        """Start the spinner animation."""
+        self._spinner.start()
+
+    def spinner_stop(self) -> None:
+        """Stop the spinner animation."""
+        self._spinner.stop()
+
+    def spinner_update(self, status_text: str | Text) -> None:
+        """Update the spinner status text."""
+        self._spinner.update(ShimmerStatusText(status_text, ThemeKey.SPINNER_STATUS_TEXT))
+
+    def spinner_renderable(self) -> Spinner:
+        """Return the spinner's renderable for embedding in other components."""
+        return self._spinner.renderable

klaude_code/ui/renderers/assistant.py

@@ -0,0 +1,21 @@
+from rich.console import RenderableType
+
+from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.rich.markdown import NoInsetMarkdown
+
+
+def render_assistant_message(content: str, *, code_theme: str) -> RenderableType | None:
+    """Render assistant message for replay history display.
+
+    Returns None if content is empty.
+    """
+    stripped = content.strip()
+    if len(stripped) == 0:
+        return None
+
+    grid = create_grid()
+    grid.add_row(
+        "•",
+        NoInsetMarkdown(stripped, code_theme=code_theme),
+    )
+    return grid

klaude_code/ui/renderers/common.py

@@ -1,24 +1,8 @@
 from rich.table import Table
 
-from klaude_code.const import TRUNCATE_DISPLAY_MAX_LINE_LENGTH, TRUNCATE_DISPLAY_MAX_LINES
-
 
 def create_grid() -> Table:
     grid = Table.grid(padding=(0, 1))
     grid.add_column(no_wrap=True)
     grid.add_column(overflow="fold")
     return grid
-
-
-def truncate_display(
-    text: str, max_lines: int = TRUNCATE_DISPLAY_MAX_LINES, max_line_length: int = TRUNCATE_DISPLAY_MAX_LINE_LENGTH
-) -> str:
-    lines = text.split("\n")
-    if len(lines) > max_lines:
-        lines = lines[:max_lines] + ["… (more " + str(len(lines) - max_lines) + " lines)"]
-    for i, line in enumerate(lines):
-        if len(line) > max_line_length:
-            lines[i] = (
-                line[:max_line_length] + "… (more " + str(len(line) - max_line_length) + " characters in this line)"
-            )
-    return "\n".join(lines)

klaude_code/ui/renderers/developer.py

@@ -2,12 +2,12 @@ from rich.console import Group, RenderableType
 from rich.padding import Padding
 from rich.text import Text
 
-from klaude_code.protocol import events
-from klaude_code.protocol.commands import CommandName
-from klaude_code.ui.base.theme import ThemeKey
+from klaude_code.protocol import commands, events
 from klaude_code.ui.renderers import diffs as r_diffs
-from klaude_code.ui.renderers.common import create_grid, truncate_display
+from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.renderers.tools import render_path
+from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.ui.utils.common import truncate_display
 
 
 def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
@@ -16,7 +16,7 @@ def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
         or e.item.external_file_changes
         or e.item.todo_use
         or e.item.at_files
-        or e.item.clipboard_images
+        or e.item.user_image_count
     )
 
 
@@ -56,7 +56,10 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
 
     if e.item.todo_use:
         grid = create_grid()
-        grid.add_row(Text("  +", style=ThemeKey.REMINDER), Text("Todo hasn't been updated recently", ThemeKey.REMINDER))
+        grid.add_row(
+            Text("  +", style=ThemeKey.REMINDER),
+            Text("Todo hasn't been updated recently", ThemeKey.REMINDER),
+        )
         parts.append(grid)
 
     if e.item.at_files:
@@ -65,21 +68,18 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
             grid.add_row(
                 Text("  +", style=ThemeKey.REMINDER),
                 Text.assemble(
-                    (f"{at_file.operation} ", ThemeKey.REMINDER), render_path(at_file.path, ThemeKey.REMINDER_BOLD)
+                    (f"{at_file.operation} ", ThemeKey.REMINDER),
+                    render_path(at_file.path, ThemeKey.REMINDER_BOLD),
                 ),
             )
         parts.append(grid)
 
-    if ci := e.item.clipboard_images:
+    if uic := e.item.user_image_count:
         grid = create_grid()
-        for img_tag in ci:
-            grid.add_row(
-                Text("  +", style=ThemeKey.REMINDER),
-                Text.assemble(
-                    ("Read ", ThemeKey.REMINDER),
-                    Text(f"{img_tag} Image", style=ThemeKey.REMINDER_BOLD),
-                ),
-            )
+        grid.add_row(
+            Text("  +", style=ThemeKey.REMINDER),
+            Text(f"Attached {uic} image{'s' if uic > 1 else ''}", style=ThemeKey.REMINDER),
+        )
         parts.append(grid)
 
     return Group(*parts) if parts else Text("")
@@ -91,11 +91,11 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
         return Text("")
 
     match e.item.command_output.command_name:
-        case CommandName.DIFF:
+        case commands.CommandName.DIFF:
             if e.item.content is None or len(e.item.content) == 0:
                 return Padding.indent(Text("(no changes)", style=ThemeKey.TOOL_RESULT), level=2)
             return r_diffs.render_diff_panel(e.item.content, show_file_name=True)
-        case CommandName.HELP:
+        case commands.CommandName.HELP:
             return Padding.indent(Text.from_markup(e.item.content or ""), level=2)
         case _:
             content = e.item.content or "(no content)"