klaude-code 2.5.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

klaude_code/tui/machine.py

@@ -19,6 +19,7 @@ from klaude_code.tui.commands import (
     EmitTmuxSignal,
     EndAssistantStream,
     EndThinkingStream,
+    PrintBlankLine,
     PrintRuleLine,
     RenderAssistantImage,
     RenderCommand,
@@ -26,7 +27,6 @@ from klaude_code.tui.commands import (
     RenderDeveloperMessage,
     RenderError,
     RenderInterrupt,
-    RenderReplayHistory,
     RenderTaskFinish,
     RenderTaskMetadata,
     RenderTaskStart,
@@ -160,7 +160,7 @@ class ActivityState:
             if self._sub_agent_tool_calls:
                 _append_counts(self._sub_agent_tool_calls)
                 if self._tool_calls:
-                    activity_text.append(" , ")
+                    activity_text.append(", ")
 
             if self._tool_calls:
                 _append_counts(self._tool_calls)
@@ -382,17 +382,25 @@ class DisplayStateMachine:
         self._spinner.set_toast_status(None)
         return self._spinner_update_commands()
 
+    def begin_replay(self) -> list[RenderCommand]:
+        self._spinner.reset()
+        return [SpinnerStop(), PrintBlankLine()]
+
+    def end_replay(self) -> list[RenderCommand]:
+        return [SpinnerStop()]
+
+    def transition_replay(self, event: events.Event) -> list[RenderCommand]:
+        return self._transition(event, is_replay=True)
+
     def transition(self, event: events.Event) -> list[RenderCommand]:
+        return self._transition(event, is_replay=False)
+
+    def _transition(self, event: events.Event, *, is_replay: bool) -> list[RenderCommand]:
         session_id = getattr(event, "session_id", "__app__")
         s = self._session(session_id)
         cmds: list[RenderCommand] = []
 
         match event:
-            case events.ReplayHistoryEvent() as e:
-                cmds.append(RenderReplayHistory(e))
-                cmds.append(SpinnerStop())
-                return cmds
-
             case events.WelcomeEvent() as e:
                 cmds.append(RenderWelcome(e))
                 return cmds
@@ -408,13 +416,16 @@ class DisplayStateMachine:
                 s.model_id = e.model_id
                 if not s.is_sub_agent:
                     self._set_primary_if_needed(e.session_id)
-                    cmds.append(TaskClockStart())
+                    if not is_replay:
+                        cmds.append(TaskClockStart())
                 else:
                     s.sub_agent_thinking_header = SubAgentThinkingHeaderState()
 
-                cmds.append(SpinnerStart())
+                if not is_replay:
+                    cmds.append(SpinnerStart())
                 cmds.append(RenderTaskStart(e))
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.DeveloperMessageEvent() as e:
@@ -427,9 +438,10 @@ class DisplayStateMachine:
 
             case events.TurnStartEvent() as e:
                 cmds.append(RenderTurnStart(e))
-                self._spinner.clear_for_new_turn()
-                self._spinner.set_reasoning_status(None)
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    self._spinner.clear_for_new_turn()
+                    self._spinner.set_reasoning_status(None)
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.ThinkingStartEvent() as e:
@@ -441,9 +453,11 @@ class DisplayStateMachine:
                 s.thinking_tail = ""
                 # Ensure the status reflects that reasoning has started even
                 # before we receive any deltas (or a bold header).
-                self._spinner.set_reasoning_status(STATUS_THINKING_TEXT)
+                if not is_replay:
+                    self._spinner.set_reasoning_status(STATUS_THINKING_TEXT)
                 cmds.append(StartThinkingStream(session_id=e.session_id))
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.ThinkingDeltaEvent() as e:
@@ -463,7 +477,7 @@ class DisplayStateMachine:
 
                 # Update reasoning status for spinner (based on bounded tail).
                 # Only extract headers for models that use markdown bold headers in thinking.
-                if s.should_extract_reasoning_header:
+                if not is_replay and s.should_extract_reasoning_header:
                     s.thinking_tail = (s.thinking_tail + e.content)[-8192:]
                     header = extract_last_bold_header(normalize_thinking_content(s.thinking_tail))
                     if header:
@@ -478,26 +492,31 @@ class DisplayStateMachine:
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = False
-                self._spinner.clear_default_reasoning_status()
+                if not is_replay:
+                    self._spinner.clear_default_reasoning_status()
                 cmds.append(EndThinkingStream(session_id=e.session_id))
-                cmds.append(SpinnerStart())
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.append(SpinnerStart())
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.AssistantTextStartEvent() as e:
                 if s.is_sub_agent:
-                    self._spinner.set_composing(True)
-                    cmds.extend(self._spinner_update_commands())
+                    if not is_replay:
+                        self._spinner.set_composing(True)
+                        cmds.extend(self._spinner_update_commands())
                     return cmds
                 if not self._is_primary(e.session_id):
                     return []
 
                 s.assistant_stream_active = True
                 s.assistant_char_count = 0
-                self._spinner.set_composing(True)
-                self._spinner.clear_tool_calls()
+                if not is_replay:
+                    self._spinner.set_composing(True)
+                    self._spinner.clear_tool_calls()
                 cmds.append(StartAssistantStream(session_id=e.session_id))
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.AssistantTextDeltaEvent() as e:
@@ -507,24 +526,29 @@ class DisplayStateMachine:
                     return []
 
                 s.assistant_char_count += len(e.content)
-                self._spinner.set_buffer_length(s.assistant_char_count)
+                if not is_replay:
+                    self._spinner.set_buffer_length(s.assistant_char_count)
                 cmds.append(AppendAssistant(session_id=e.session_id, content=e.content))
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.AssistantTextEndEvent() as e:
                 if s.is_sub_agent:
-                    self._spinner.set_composing(False)
-                    cmds.extend(self._spinner_update_commands())
+                    if not is_replay:
+                        self._spinner.set_composing(False)
+                        cmds.extend(self._spinner_update_commands())
                     return cmds
                 if not self._is_primary(e.session_id):
                     return []
 
                 s.assistant_stream_active = False
-                self._spinner.set_composing(False)
+                if not is_replay:
+                    self._spinner.set_composing(False)
                 cmds.append(EndAssistantStream(session_id=e.session_id))
-                cmds.append(SpinnerStart())
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.append(SpinnerStart())
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.AssistantImageDeltaEvent() as e:
@@ -536,9 +560,10 @@ class DisplayStateMachine:
                     return []
                 if not self._is_primary(e.session_id):
                     return []
-                self._spinner.set_composing(False)
-                cmds.append(SpinnerStart())
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    self._spinner.set_composing(False)
+                    cmds.append(SpinnerStart())
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.ToolCallStartEvent() as e:
@@ -553,18 +578,20 @@ class DisplayStateMachine:
                         primary.thinking_stream_active = False
                         cmds.append(EndThinkingStream(session_id=primary.session_id))
 
-                self._spinner.set_composing(False)
+                if not is_replay:
+                    self._spinner.set_composing(False)
 
                 # Skip activity state for fast tools on non-streaming models (e.g., Gemini)
                 # to avoid flash-and-disappear effect
-                if not s.should_skip_tool_activity(e.tool_name):
+                if not is_replay and not s.should_skip_tool_activity(e.tool_name):
                     tool_active_form = get_tool_active_form(e.tool_name)
                     if is_sub_agent_tool(e.tool_name):
                         self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
                     else:
                         self._spinner.add_tool_call(tool_active_form)
 
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.ToolCallEvent() as e:
@@ -583,7 +610,7 @@ class DisplayStateMachine:
                 return cmds
 
             case events.ToolResultEvent() as e:
-                if is_sub_agent_tool(e.tool_name):
+                if not is_replay and is_sub_agent_tool(e.tool_name):
                     self._spinner.finish_sub_agent_tool_call(e.tool_call_id, get_tool_active_form(e.tool_name))
                     cmds.extend(self._spinner_update_commands())
 
@@ -601,9 +628,10 @@ class DisplayStateMachine:
 
             case events.TodoChangeEvent() as e:
                 todo_text = _extract_active_form_text(e)
-                self._spinner.set_todo_status(todo_text)
-                self._spinner.clear_for_new_turn()
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    self._spinner.set_todo_status(todo_text)
+                    self._spinner.clear_for_new_turn()
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.UsageEvent() as e:
@@ -613,7 +641,7 @@ class DisplayStateMachine:
                 if not self._is_primary(e.session_id):
                     return []
                 context_percent = e.usage.context_usage_percent
-                if context_percent is not None:
+                if not is_replay and context_percent is not None:
                     self._spinner.set_context_percent(context_percent)
                     cmds.extend(self._spinner_update_commands())
                 return cmds
@@ -624,37 +652,43 @@ class DisplayStateMachine:
             case events.TaskFinishEvent() as e:
                 cmds.append(RenderTaskFinish(e))
                 if not s.is_sub_agent:
-                    cmds.append(TaskClockClear())
-                    self._spinner.reset()
-                    cmds.append(SpinnerStop())
-                    cmds.append(PrintRuleLine())
-                    cmds.append(EmitTmuxSignal())
+                    if not is_replay:
+                        cmds.append(TaskClockClear())
+                        self._spinner.reset()
+                        cmds.append(SpinnerStop())
+                        cmds.append(PrintRuleLine())
+                        cmds.append(EmitTmuxSignal())
                 else:
                     s.sub_agent_thinking_header = None
                 return cmds
 
             case events.InterruptEvent() as e:
-                self._spinner.reset()
-                cmds.append(SpinnerStop())
+                if not is_replay:
+                    self._spinner.reset()
+                    cmds.append(SpinnerStop())
                 cmds.append(EndThinkingStream(session_id=e.session_id))
                 cmds.append(EndAssistantStream(session_id=e.session_id))
-                cmds.append(TaskClockClear())
+                if not is_replay:
+                    cmds.append(TaskClockClear())
                 cmds.append(RenderInterrupt(session_id=e.session_id))
                 return cmds
 
             case events.ErrorEvent() as e:
-                cmds.append(EmitOsc94Error())
+                if not is_replay:
+                    cmds.append(EmitOsc94Error())
                 cmds.append(RenderError(e))
-                if not e.can_retry:
+                if not is_replay and not e.can_retry:
                     self._spinner.reset()
                     cmds.append(SpinnerStop())
-                cmds.extend(self._spinner_update_commands())
+                if not is_replay:
+                    cmds.extend(self._spinner_update_commands())
                 return cmds
 
             case events.EndEvent():
-                self._spinner.reset()
-                cmds.append(SpinnerStop())
-                cmds.append(TaskClockClear())
+                if not is_replay:
+                    self._spinner.reset()
+                    cmds.append(SpinnerStop())
+                    cmds.append(TaskClockClear())
                 return cmds
 
             case _:

klaude_code/tui/renderer.py

@@ -35,7 +35,6 @@ from klaude_code.tui.commands import (
     RenderDeveloperMessage,
     RenderError,
     RenderInterrupt,
-    RenderReplayHistory,
     RenderTaskFinish,
     RenderTaskMetadata,
     RenderTaskStart,
@@ -437,67 +436,10 @@ class TUICommandRenderer:
             Text.assemble(
                 (c_thinking.THINKING_MESSAGE_MARK, ThemeKey.THINKING),
                 " ",
-                (stripped, ThemeKey.THINKING_BOLD),
+                (stripped, ThemeKey.THINKING),
             )
         )
 
-    async def replay_history(self, history_events: events.ReplayHistoryEvent) -> None:
-        tool_call_dict: dict[str, events.ToolCallEvent] = {}
-        self.print()
-        for event in history_events.events:
-            event_session_id = getattr(event, "session_id", history_events.session_id)
-            is_sub_agent = self.is_sub_agent_session(event_session_id)
-
-            with self.session_print_context(event_session_id):
-                match event:
-                    case events.TaskStartEvent() as e:
-                        self.display_task_start(e)
-                    case events.TurnStartEvent():
-                        self.print()
-                    case events.AssistantImageDeltaEvent() as e:
-                        self.display_image(e.file_path)
-                    case events.ResponseCompleteEvent() as e:
-                        if is_sub_agent:
-                            if self._should_display_sub_agent_thinking_header(event_session_id) and e.thinking_text:
-                                header = c_thinking.extract_last_bold_header(
-                                    c_thinking.normalize_thinking_content(e.thinking_text)
-                                )
-                                if header:
-                                    self.display_thinking_header(header)
-                            continue
-                        if e.thinking_text:
-                            self.display_thinking(e.thinking_text)
-                        renderable = c_assistant.render_assistant_message(e.content, code_theme=self.themes.code_theme)
-                        if renderable is not None:
-                            self.print(renderable)
-                            self.print()
-                    case events.DeveloperMessageEvent() as e:
-                        self.display_developer_message(e)
-                    case events.UserMessageEvent() as e:
-                        if is_sub_agent:
-                            continue
-                        self.print(c_user_input.render_user_input(e.content))
-                    case events.ToolCallEvent() as e:
-                        tool_call_dict[e.tool_call_id] = e
-                    case events.ToolResultEvent() as e:
-                        tool_call_event = tool_call_dict.get(e.tool_call_id)
-                        if tool_call_event is not None:
-                            self.display_tool_call(tool_call_event)
-                        tool_call_dict.pop(e.tool_call_id, None)
-                        if is_sub_agent:
-                            continue
-                        self.display_tool_call_result(e)
-                    case events.TaskMetadataEvent() as e:
-                        self.print(c_metadata.render_task_metadata(e))
-                        self.print()
-                    case events.InterruptEvent():
-                        self.print()
-                        self.print(c_user_input.render_interrupt())
-                    case events.ErrorEvent() as e:
-                        self.display_error(e)
-                    case events.TaskFinishEvent() as e:
-                        self.display_task_finish(e)
-
     def display_developer_message(self, e: events.DeveloperMessageEvent) -> None:
         if not c_developer.need_render_developer_message(e):
             return
@@ -615,9 +557,6 @@ class TUICommandRenderer:
     async def execute(self, commands: list[RenderCommand]) -> None:
         for cmd in commands:
             match cmd:
-                case RenderReplayHistory(event=event):
-                    await self.replay_history(event)
-                    self.spinner_stop()
                 case RenderWelcome(event=event):
                     self.display_welcome(event)
                 case RenderUserMessage(event=event):

klaude_code/tui/runner.py

@@ -312,4 +312,4 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             active_session_id = components.executor.context.current_session_id()
             if active_session_id and Session.exists(active_session_id):
                 log(f"Session ID: {active_session_id}")
-                log(f"Resume with: klaude --resume-by-id {active_session_id}")
+                log(f"Resume with: klaude --resume {active_session_id}")

klaude_code/tui/terminal/image.py

@@ -1,34 +1,65 @@
 from __future__ import annotations
 
+import base64
 import sys
 from pathlib import Path
 from typing import IO
 
+# Kitty graphics protocol chunk size (4096 is the recommended max)
+_CHUNK_SIZE = 4096
+
 
 def print_kitty_image(file_path: str | Path, *, height: int | None = None, file: IO[str] | None = None) -> None:
     """Print an image to the terminal using Kitty graphics protocol.
 
     This intentionally bypasses Rich rendering to avoid interleaving Live refreshes
     with raw escape sequences.
-    """
 
+    Args:
+        file_path: Path to the image file (PNG recommended).
+        height: Display height in terminal rows. If None, uses terminal default.
+        file: Output file stream. Defaults to stdout.
+    """
     path = Path(file_path) if isinstance(file_path, str) else file_path
     if not path.exists():
         print(f"Image not found: {path}", file=file or sys.stdout, flush=True)
         return
 
     try:
-        from term_image.image import KittyImage  # type: ignore[import-untyped]
-
-        KittyImage.forced_support = True  # type: ignore[reportUnknownMemberType]
-        img = KittyImage.from_file(path)  # type: ignore[reportUnknownMemberType]
-        if height is not None:
-            img.height = height  # type: ignore[reportUnknownMemberType]
-
+        data = path.read_bytes()
+        encoded = base64.standard_b64encode(data).decode("ascii")
         out = file or sys.stdout
+
         print("", file=out)
-        print(str(img), file=out)
+        _write_kitty_graphics(out, encoded, height=height)
         print("", file=out)
         out.flush()
     except Exception:
         print(f"Saved image: {path}", file=file or sys.stdout, flush=True)
+
+
+def _write_kitty_graphics(out: IO[str], encoded_data: str, *, height: int | None = None) -> None:
+    """Write Kitty graphics protocol escape sequences.
+
+    Protocol format: ESC _ G <control>;<payload> ESC \\
+    - a=T: direct transmission (data in payload)
+    - f=100: PNG format (auto-detected by Kitty)
+    - r=N: display height in rows
+    - m=1: more data follows, m=0: last chunk
+    """
+    total_len = len(encoded_data)
+
+    for i in range(0, total_len, _CHUNK_SIZE):
+        chunk = encoded_data[i : i + _CHUNK_SIZE]
+        is_last = i + _CHUNK_SIZE >= total_len
+
+        if i == 0:
+            # First chunk: include control parameters
+            ctrl = "a=T,f=100"
+            if height is not None:
+                ctrl += f",r={height}"
+            ctrl += f",m={0 if is_last else 1}"
+            out.write(f"\033_G{ctrl};{chunk}\033\\")
+        else:
+            # Subsequent chunks: only m parameter needed
+            out.write(f"\033_Gm={0 if is_last else 1};{chunk}\033\\")

klaude_code/tui/terminal/selector.py

@@ -389,7 +389,7 @@ def _build_search_container(
     frame: bool = True,
 ) -> tuple[Window, Container]:
     """Build the search input container with placeholder."""
-    placeholder_text = f"{search_placeholder} · ↑↓ to select · esc to quit"
+    placeholder_text = f"{search_placeholder} · ↑↓ to select · enter/tab to confirm · esc to quit"
 
     search_prefix_window = Window(
         FormattedTextControl([("class:search_prefix", "/ ")]),
@@ -522,6 +522,23 @@ def select_one[T](
             return
         event.app.exit(result=value)
 
+    @kb.add(Keys.Tab, eager=True)
+    def _(event: KeyPressEvent) -> None:
+        """Accept the currently pointed item."""
+        indices, _ = _filter_items(items, get_filter_text())
+        if not indices:
+            event.app.exit(result=None)
+            return
+
+        nonlocal pointed_at
+        pointed_at = _coerce_pointed_at_to_selectable(items, indices, pointed_at)
+        idx = indices[pointed_at % len(indices)]
+        value = items[idx].value
+        if value is None:
+            event.app.exit(result=None)
+            return
+        event.app.exit(result=value)
+
     @kb.add(Keys.Escape, eager=True)
     def _(event: KeyPressEvent) -> None:
         nonlocal pointed_at
@@ -702,6 +719,28 @@ class SelectOverlay[T]:
             if hasattr(result, "__await__"):
                 event.app.create_background_task(cast(Coroutine[Any, Any, None], result))
 
+        @kb.add(Keys.Tab, filter=is_open_filter, eager=True)
+        def _(event: KeyPressEvent) -> None:
+            indices, _ = self._get_visible_indices()
+            if not indices:
+                self.close()
+                return
+
+            self._pointed_at = _coerce_pointed_at_to_selectable(self._items, indices, self._pointed_at)
+            idx = indices[self._pointed_at % len(indices)]
+            value = self._items[idx].value
+            if value is None:
+                self.close()
+                return
+            self.close()
+
+            if self._on_select is None:
+                return
+
+            result = self._on_select(value)
+            if hasattr(result, "__await__"):
+                event.app.create_background_task(cast(Coroutine[Any, Any, None], result))
+
         @kb.add(Keys.Escape, filter=is_open_filter, eager=True)
         def _(event: KeyPressEvent) -> None:
             if self._use_search_filter and self._search_buffer is not None and self._search_buffer.text:
@@ -757,9 +796,20 @@ class SelectOverlay[T]:
             dont_extend_height=Always(),
             always_hide_cursor=Always(),
         )
+        def get_list_height() -> int:
+            # Dynamic height: min of configured height and available terminal space
+            # Overhead: header(1) + spacer(1) + search(1) + frame borders(2) + prompt area(3)
+            overhead = 8
+            try:
+                terminal_height = get_app().output.get_size().rows
+                available = max(3, terminal_height - overhead)
+                return min(self._list_height, available)
+            except Exception:
+                return self._list_height
+
         list_window = Window(
             FormattedTextControl(get_choices_tokens),
-            height=self._list_height,
+            height=get_list_height,
             scroll_offsets=ScrollOffsets(top=0, bottom=2),
             allow_scroll_beyond_bottom=True,
             dont_extend_height=Always(),