klaude-code 2.9.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

klaude_code/tui/renderer.py

@@ -18,6 +18,7 @@ from rich.text import Text
 
 from klaude_code.const import (
     MARKDOWN_LEFT_MARGIN,
+    MARKDOWN_RIGHT_MARGIN,
     MARKDOWN_STREAM_LIVE_REPAINT_ENABLED,
     STATUS_DEFAULT_TEXT,
     STREAM_MAX_HEIGHT_SHRINK_RESET_LINES,
@@ -25,6 +26,7 @@ from klaude_code.const import (
 from klaude_code.protocol import events, model, tools
 from klaude_code.tui.commands import (
     AppendAssistant,
+    AppendBashCommandOutput,
     AppendThinking,
     EmitOsc94Error,
     EmitTmuxSignal,
@@ -33,6 +35,8 @@ from klaude_code.tui.commands import (
     PrintBlankLine,
     PrintRuleLine,
     RenderAssistantImage,
+    RenderBashCommandEnd,
+    RenderBashCommandStart,
     RenderCommand,
     RenderCommandOutput,
     RenderCompactionSummary,
@@ -56,7 +60,6 @@ from klaude_code.tui.commands import (
     TaskClockClear,
     TaskClockStart,
 )
-from klaude_code.tui.components import assistant as c_assistant
 from klaude_code.tui.components import command_output as c_command_output
 from klaude_code.tui.components import developer as c_developer
 from klaude_code.tui.components import errors as c_errors
@@ -67,7 +70,7 @@ from klaude_code.tui.components import thinking as c_thinking
 from klaude_code.tui.components import tools as c_tools
 from klaude_code.tui.components import user_input as c_user_input
 from klaude_code.tui.components import welcome as c_welcome
-from klaude_code.tui.components.common import truncate_head
+from klaude_code.tui.components.common import create_grid, truncate_head
 from klaude_code.tui.components.rich import status as r_status
 from klaude_code.tui.components.rich.live import CropAboveLive, SingleLine
 from klaude_code.tui.components.rich.markdown import MarkdownStream, NoInsetMarkdown, ThinkingMarkdown
@@ -165,9 +168,28 @@ class TUICommandRenderer:
         self._assistant_stream = _StreamState()
         self._thinking_stream = _StreamState()
 
+        # Replay mode reuses the same event/state machine but does not need streaming UI.
+        # When enabled, we avoid bottom Live rendering and defer markdown rendering until
+        # the corresponding stream End event.
+        self._replay_mode: bool = False
+
+        self._bash_stream_active: bool = False
+        self._bash_last_char_was_newline: bool = True
+
         self._sessions: dict[str, _SessionStatus] = {}
         self._current_sub_agent_color: Style | None = None
         self._sub_agent_color_index = 0
+        self._sub_agent_thinking_buffers: dict[str, str] = {}
+
+    def set_replay_mode(self, enabled: bool) -> None:
+        """Enable or disable replay rendering mode.
+
+        Replay mode is optimized for speed and stability:
+        - Avoid Rich Live / bottom status rendering.
+        - Defer markdown stream rendering until End events.
+        """
+
+        self._replay_mode = enabled
 
     # ---------------------------------------------------------------------
     # Session helpers
@@ -303,7 +325,9 @@ class TUICommandRenderer:
 
     def _bottom_renderable(self) -> RenderableType:
         stream_part: RenderableType = Group()
-        gap_part: RenderableType = Group()
+        # Keep a visible separation between the bottom status line (spinner)
+        # and the main terminal output.
+        gap_part: RenderableType = Text(" ") if (self._spinner_visible and self._bash_stream_active) else Group()
 
         if MARKDOWN_STREAM_LIVE_REPAINT_ENABLED:
             stream = self._stream_renderable
@@ -325,8 +349,7 @@ class TUICommandRenderer:
                 if pad_lines:
                     stream = Padding(stream, (0, 0, pad_lines, 0))
                 stream_part = stream
-
-            gap_part = Text("") if self._spinner_visible else Group()
+                gap_part = Text(" ") if (self._spinner_visible and self._bash_stream_active) else Group()
 
         status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
         return Group(stream_part, gap_part, status_part)
@@ -361,17 +384,19 @@ class TUICommandRenderer:
             mark=c_thinking.THINKING_MESSAGE_MARK,
             mark_style=ThemeKey.THINKING,
             left_margin=MARKDOWN_LEFT_MARGIN,
+            right_margin=MARKDOWN_RIGHT_MARGIN,
             markdown_class=ThinkingMarkdown,
         )
 
     def _new_assistant_mdstream(self) -> MarkdownStream:
+        live_sink = None if self._replay_mode else self.set_stream_renderable
         return MarkdownStream(
             mdargs={"code_theme": self.themes.code_theme},
             theme=self.themes.markdown_theme,
             console=self.console,
-            live_sink=self.set_stream_renderable,
-            mark=c_assistant.ASSISTANT_MESSAGE_MARK,
+            live_sink=live_sink,
             left_margin=MARKDOWN_LEFT_MARGIN,
+            right_margin=MARKDOWN_RIGHT_MARGIN,
             image_callback=self.display_image,
         )
 
@@ -381,6 +406,19 @@ class TUICommandRenderer:
     def _flush_assistant(self) -> None:
         self._assistant_stream.render()
 
+    def _render_sub_agent_thinking(self, content: str) -> None:
+        """Render sub-agent thinking content as a single block."""
+        normalized = c_thinking.normalize_thinking_content(content)
+        if not normalized.strip():
+            return
+        md = ThinkingMarkdown(normalized, code_theme=self.themes.code_theme, style=ThemeKey.THINKING)
+        self.console.push_theme(self.themes.thinking_markdown_theme)
+        grid = create_grid()
+        grid.add_row(Text(c_thinking.THINKING_MESSAGE_MARK, style=ThemeKey.THINKING), md)
+        self.print(grid)
+        self.console.pop_theme()
+        self.print()
+
     # ---------------------------------------------------------------------
     # Event-specific rendering helpers
     # ---------------------------------------------------------------------
@@ -447,6 +485,66 @@ class TUICommandRenderer:
             self.print(c_command_output.render_command_output(e))
             self.print()
 
+    def display_bash_command_start(self, e: events.BashCommandStartEvent) -> None:
+        # The user input line already shows `!cmd`; bash output is streamed as it arrives.
+        # We keep minimal rendering here to avoid adding noise.
+        self._bash_stream_active = True
+        self._bash_last_char_was_newline = True
+        if self._spinner_visible:
+            self._refresh_bottom_live()
+
+    def display_bash_command_delta(self, e: events.BashCommandOutputDeltaEvent) -> None:
+        if not self._bash_stream_active:
+            self._bash_stream_active = True
+            if self._spinner_visible:
+                self._refresh_bottom_live()
+
+        content = e.content
+        if content == "":
+            return
+
+        # Rich Live refreshes periodically (even when the renderable doesn't change).
+        # If we print bash output without a trailing newline while Live is active,
+        # the next refresh can overwrite the partial line.
+        #
+        # To keep streamed bash output stable, temporarily stop the bottom Live
+        # during the print, and only resume it once the output is back at a
+        # line boundary (i.e. chunk ends with "\n").
+        if self._bottom_live is not None:
+            with contextlib.suppress(Exception):
+                self._bottom_live.stop()
+            self._bottom_live = None
+
+        try:
+            # Do not use Renderer.print() here because it forces overflow="ellipsis",
+            # which would truncate long command output lines.
+            self.console.print(Text(content, style=ThemeKey.TOOL_RESULT), end="", overflow="ignore")
+            self._bash_last_char_was_newline = content.endswith("\n")
+        finally:
+            # Resume the bottom Live only when we're not in the middle of a line,
+            # otherwise periodic refresh can clobber the partial line.
+            if self._bash_last_char_was_newline and self._spinner_visible:
+                self._ensure_bottom_live_started()
+                self._refresh_bottom_live()
+
+    def display_bash_command_end(self, e: events.BashCommandEndEvent) -> None:
+        # Stop the bottom Live before finalizing bash output to prevent a refresh
+        # from interfering with the final line(s) written to stdout.
+        if self._bottom_live is not None:
+            with contextlib.suppress(Exception):
+                self._bottom_live.stop()
+            self._bottom_live = None
+
+        # Leave a blank line before the next prompt:
+        # - If the command output already ended with a newline, print one more "\n".
+        # - Otherwise, print "\n\n" to end the line and add one empty line.
+        if self._bash_stream_active:
+            sep = "\n" if self._bash_last_char_was_newline else "\n\n"
+            self.console.print(Text(sep), end="", overflow="ignore")
+
+        self._bash_stream_active = False
+        self._bash_last_char_was_newline = True
+
     def display_welcome(self, event: events.WelcomeEvent) -> None:
         self.print(c_welcome.render_welcome(event))
 
@@ -494,7 +592,6 @@ class TUICommandRenderer:
         if self.is_sub_agent_session(event.session_id):
             return
         self.print(c_metadata.render_task_metadata(event))
-        self.print()
 
     def display_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.is_sub_agent_session(event.session_id):
@@ -534,9 +631,9 @@ class TUICommandRenderer:
         )
         self.console.print(
             Rule(
-                Text("Context Compact", style=ThemeKey.COMPACTION_SUMMARY),
+                Text("Context Compacted", style=ThemeKey.COMPACTION_SUMMARY),
                 characters="=",
-                style=ThemeKey.COMPACTION_SUMMARY,
+                style=ThemeKey.LINES,
             )
         )
         self.print()
@@ -620,35 +717,56 @@ class TUICommandRenderer:
                     self.display_developer_message(event)
                 case RenderCommandOutput(event=event):
                     self.display_command_output(event)
+                case RenderBashCommandStart(event=event):
+                    self.display_bash_command_start(event)
+                case AppendBashCommandOutput(event=event):
+                    self.display_bash_command_delta(event)
+                case RenderBashCommandEnd(event=event):
+                    self.display_bash_command_end(event)
                 case RenderTurnStart(event=event):
                     self.display_turn_start(event)
-                case StartThinkingStream():
-                    if not self._thinking_stream.is_active:
+                case StartThinkingStream(session_id=session_id):
+                    if self.is_sub_agent_session(session_id):
+                        self._sub_agent_thinking_buffers[session_id] = ""
+                    elif not self._thinking_stream.is_active:
                         self._thinking_stream.start(self._new_thinking_mdstream())
-                case AppendThinking(content=content):
-                    if self._thinking_stream.is_active:
-                        first_delta = self._thinking_stream.buffer == ""
+                case AppendThinking(session_id=session_id, content=content):
+                    if self.is_sub_agent_session(session_id):
+                        if session_id in self._sub_agent_thinking_buffers:
+                            self._sub_agent_thinking_buffers[session_id] += content
+                    elif self._thinking_stream.is_active:
                         self._thinking_stream.append(content)
-                        if first_delta:
-                            self._thinking_stream.render(transform=c_thinking.normalize_thinking_content)
-                        self._flush_thinking()
-                case EndThinkingStream():
-                    finalized = self._thinking_stream.finalize(transform=c_thinking.normalize_thinking_content)
-                    if finalized:
-                        self.print()
-                case StartAssistantStream():
+                        if not self._replay_mode:
+                            first_delta = self._thinking_stream.buffer == ""
+                            if first_delta:
+                                self._thinking_stream.render(transform=c_thinking.normalize_thinking_content)
+                            self._flush_thinking()
+                case EndThinkingStream(session_id=session_id):
+                    if self.is_sub_agent_session(session_id):
+                        buf = self._sub_agent_thinking_buffers.pop(session_id, "")
+                        if buf.strip():
+                            with self.session_print_context(session_id):
+                                self._render_sub_agent_thinking(buf)
+                    else:
+                        had_content = bool(self._thinking_stream.buffer.strip())
+                        finalized = self._thinking_stream.finalize(transform=c_thinking.normalize_thinking_content)
+                        if finalized and had_content:
+                            self.print()
+                case StartAssistantStream(session_id=_):
                     if not self._assistant_stream.is_active:
                         self._assistant_stream.start(self._new_assistant_mdstream())
-                case AppendAssistant(content=content):
+                case AppendAssistant(session_id=_, content=content):
                     if self._assistant_stream.is_active:
-                        first_delta = self._assistant_stream.buffer == ""
                         self._assistant_stream.append(content)
-                        if first_delta:
-                            self._assistant_stream.render()
-                        self._flush_assistant()
-                case EndAssistantStream():
+                        if not self._replay_mode:
+                            first_delta = self._assistant_stream.buffer == ""
+                            if first_delta:
+                                self._assistant_stream.render()
+                            self._flush_assistant()
+                case EndAssistantStream(session_id=_):
+                    had_content = bool(self._assistant_stream.buffer.strip())
                     finalized = self._assistant_stream.finalize()
-                    if finalized:
+                    if finalized and had_content:
                         self.print()
                 case RenderThinkingHeader(session_id=session_id, header=header):
                     with self.session_print_context(session_id):

klaude_code/tui/runner.py

@@ -65,11 +65,27 @@ async def submit_user_input_payload(
 
     submission_id = uuid4().hex
 
+    # Normalize a leading full-width exclamation mark for consistent UI/history.
+    # (Bash mode is triggered only when the first character is `!`.)
+    text = user_input.text
+    if text.startswith("！"):
+        text = "!" + text[1:]
+        user_input = UserInputPayload(text=text, images=user_input.images)
+
     # Render the raw user input in the TUI even when it resolves to an event-only command.
     await executor.context.emit_event(
         events.UserMessageEvent(content=user_input.text, session_id=sid, images=user_input.images)
     )
 
+    # Bash mode: run a user-entered command without invoking the agent.
+    if user_input.text.startswith("!"):
+        command = user_input.text[1:].lstrip(" \t")
+        if command == "":
+            # Enter should be ignored in the input layer for this case; keep a guard here.
+            return None
+        bash_op = op.RunBashOperation(id=submission_id, session_id=sid, command=command)
+        return await executor.submit(bash_op)
+
     cmd_result = await dispatch_command(user_input, agent, submission_id=submission_id)
     operations: list[op.Operation] = list(cmd_result.operations or [])
 
@@ -304,6 +320,9 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             if is_interactive:
                 with _double_ctrl_c_to_exit_while_running():
                     await components.executor.wait_for(wait_id)
+                # Ensure all trailing events (e.g. final deltas / spinner stop) are rendered
+                # before handing control back to prompt_toolkit.
+                await components.event_queue.join()
                 continue
 
             async def _on_esc_interrupt() -> None:
@@ -313,6 +332,9 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             try:
                 with _double_ctrl_c_to_exit_while_running():
                     await components.executor.wait_for(wait_id)
+                # Ensure all trailing events (e.g. final deltas / spinner stop) are rendered
+                # before handing control back to prompt_toolkit.
+                await components.event_queue.join()
             finally:
                 stop_event.set()
                 with contextlib.suppress(Exception):

klaude_code/tui/terminal/image.py

@@ -17,6 +17,17 @@ _MAX_COLS = 80
 # Image formats that need conversion to PNG
 _NEEDS_CONVERSION = {".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff", ".tif"}
 
+# Approximate pixels per terminal column (typical for most terminals)
+_PIXELS_PER_COL = 9
+
+
+def _get_png_width(data: bytes) -> int | None:
+    """Extract width from PNG header (IHDR chunk)."""
+    # PNG signature (8 bytes) + IHDR length (4 bytes) + "IHDR" (4 bytes) + width (4 bytes)
+    if len(data) < 24 or data[:8] != b"\x89PNG\r\n\x1a\n":
+        return None
+    return int.from_bytes(data[16:20], "big")
+
 
 def _convert_to_png(path: Path) -> bytes | None:
     """Convert image to PNG using sips (macOS) or convert (ImageMagick)."""
@@ -63,9 +74,18 @@ def print_kitty_image(file_path: str | Path, *, file: IO[str] | None = None) ->
         out = file or sys.stdout
 
         term_size = shutil.get_terminal_size()
-        # Only specify columns, let Kitty auto-scale height to preserve aspect ratio
         target_cols = min(_MAX_COLS, term_size.columns)
-        size_param = f"c={target_cols}"
+
+        # Only set column width if image is wider than target, to avoid upscaling small images
+        size_param = ""
+        img_width = _get_png_width(data)
+        if img_width is not None:
+            img_cols = img_width // _PIXELS_PER_COL
+            if img_cols > target_cols:
+                size_param = f"c={target_cols}"
+        else:
+            # Fallback: always constrain if we can't determine image size
+            size_param = f"c={target_cols}"
         print("", file=out)
         _write_kitty_graphics(out, encoded, size_param=size_param)
         print("", file=out)
@@ -92,7 +112,8 @@ def _write_kitty_graphics(out: IO[str], encoded_data: str, *, size_param: str) -
 
         if i == 0:
             # First chunk: include control parameters
-            ctrl = f"a=T,f=100,{size_param},m={0 if is_last else 1}"
+            base_ctrl = f"a=T,f=100,{size_param}" if size_param else "a=T,f=100"
+            ctrl = f"{base_ctrl},m={0 if is_last else 1}"
             out.write(f"\033_G{ctrl};{chunk}\033\\")
         else:
             # Subsequent chunks: only m parameter needed

klaude_code/tui/terminal/notifier.py

@@ -64,9 +64,9 @@ class TerminalNotifier:
             return False
 
         output = resolve_stream(self.config.stream)
-        if not self._supports_osc9(output):
+        if not self._supports_notification(output):
             log_debug(
-                "Terminal notifier skipped: OSC 9 unsupported or not a TTY",
+                "Terminal notifier skipped: not a TTY",
                 debug_type=DebugType.TERMINAL,
             )
             return False
@@ -74,27 +74,26 @@ class TerminalNotifier:
         payload = self._render_payload(notification)
         return self._emit(payload, output)
 
-    def _render_payload(self, notification: Notification) -> str:
-        title = _compact(notification.title)
-        body = _compact(notification.body) if notification.body else None
-        if body:
-            return f"{title} - {body}"
-        return title
+    def _render_payload(self, notification: Notification) -> tuple[str, str]:
+        """Return (title, body) for OSC 777 notification."""
+        body = _compact(notification.body) if notification.body else _compact(notification.title)
+        return ("klaude", body)
 
-    def _emit(self, payload: str, output: TextIO) -> bool:
+    def _emit(self, payload: tuple[str, str], output: TextIO) -> bool:
         terminator = BEL if self.config.use_bel else ST
-        seq = f"\033]9;{payload}{terminator}"
+        title, body = payload
+        seq = f"\033]777;notify;{title};{body}{terminator}"
         try:
             output.write(seq)
             output.flush()
-            log_debug("Terminal notifier sent OSC 9 payload", debug_type=DebugType.TERMINAL)
+            log_debug("Terminal notifier sent OSC 777 payload", debug_type=DebugType.TERMINAL)
             return True
         except Exception as exc:
             log_debug(f"Terminal notifier send failed: {exc}", debug_type=DebugType.TERMINAL)
             return False
 
     @staticmethod
-    def _supports_osc9(stream: TextIO) -> bool:
+    def _supports_notification(stream: TextIO) -> bool:
         if sys.platform == "win32":
             return False
         if not getattr(stream, "isatty", lambda: False)():

klaude_code/tui/terminal/selector.py

@@ -111,7 +111,7 @@ def build_model_select_items(models: list[Any]) -> list[SelectItem[str]]:
             meta_str = " · ".join(meta_parts) if meta_parts else ""
             title: list[tuple[str, str]] = [
                 ("class:meta", f"{model_idx:>{num_width}}. "),
-                ("class:msg bold", first_line_prefix),
+                ("class:msg", first_line_prefix),
                 ("class:msg dim", " → "),
                 # Keep provider/model_id styling attribute-based (dim/bold) so that
                 # the selector's highlight color can still override uniformly.

klaude_code/ui/terminal/title.py

@@ -26,6 +26,8 @@ def update_terminal_title(model_name: str | None = None) -> None:
     """Update terminal title with folder name and optional model name."""
     folder_name = os.path.basename(os.getcwd())
     if model_name:
-        set_terminal_title(f"{folder_name}: klaude ✳ {model_name}")
+        # Strip provider suffix (e.g., opus@openrouter -> opus)
+        model_alias = model_name.split("@")[0]
+        set_terminal_title(f"klaude [{model_alias}] · {folder_name}")
     else:
-        set_terminal_title(f"{folder_name}: klaude")
+        set_terminal_title(f"klaude · {folder_name}")

{klaude_code-2.9.0.dist-info → klaude_code-2.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.9.0
+Version: 2.10.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0