klaude-code 1.2.24__py3-none-any.whl → 1.2.26__py3-none-any.whl

klaude_code/ui/modes/repl/renderer.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
+import contextlib
 from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Any
 
-from rich.console import Console
+from rich.console import Console, Group, RenderableType
+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
 
@@ -23,8 +24,9 @@ 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 truncate_display
 from klaude_code.ui.rich import status as r_status
+from klaude_code.ui.rich.live import CropAboveLive, SingleLine
 from klaude_code.ui.rich.quote import Quote
-from klaude_code.ui.rich.status import ShimmerStatusText
+from klaude_code.ui.rich.status import BreathingSpinner, ShimmerStatusText
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
 
 
@@ -42,10 +44,18 @@ 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(
-            ShimmerStatusText(const.STATUS_DEFAULT_TEXT),
-            spinner=r_status.spinner_name(),
-            spinner_style=ThemeKey.STATUS_SPINNER,
+        self._bottom_live: CropAboveLive | None = None
+        self._stream_renderable: RenderableType | None = None
+        self._stream_max_height: int = 0
+        self._stream_last_height: int = 0
+        self._stream_last_width: int = 0
+        self._spinner_visible: bool = False
+
+        self._status_text: ShimmerStatusText = ShimmerStatusText(const.STATUS_DEFAULT_TEXT)
+        self._status_spinner: Spinner = BreathingSpinner(
+            r_status.spinner_name(),
+            text=SingleLine(self._status_text),
+            style=ThemeKey.STATUS_SPINNER,
         )
 
         self.session_map: dict[str, SessionStatus] = {}
@@ -235,7 +245,11 @@ class REPLRenderer:
     def display_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.is_sub_agent_session(event.session_id):
             session_status = self.session_map.get(event.session_id)
-            description = session_status.sub_agent_state.sub_agent_desc if session_status and session_status.sub_agent_state else None
+            description = (
+                session_status.sub_agent_state.sub_agent_desc
+                if session_status and session_status.sub_agent_state
+                else None
+            )
             panel_style = self.get_session_sub_agent_background(event.session_id)
             with self.session_print_context(event.session_id):
                 self.print(
@@ -265,16 +279,94 @@ class REPLRenderer:
 
     def spinner_start(self) -> None:
         """Start the spinner animation."""
-        self._spinner.start()
+        self._spinner_visible = True
+        self._ensure_bottom_live_started()
+        self._refresh_bottom_live()
 
     def spinner_stop(self) -> None:
         """Stop the spinner animation."""
-        self._spinner.stop()
+        self._spinner_visible = False
+        self._refresh_bottom_live()
 
     def spinner_update(self, status_text: str | Text, right_text: Text | None = None) -> None:
         """Update the spinner status text with optional right-aligned text."""
-        self._spinner.update(ShimmerStatusText(status_text, right_text))
+        self._status_text = ShimmerStatusText(status_text, right_text)
+        self._status_spinner.update(text=SingleLine(self._status_text), style=ThemeKey.STATUS_SPINNER)
+        self._refresh_bottom_live()
 
     def spinner_renderable(self) -> Spinner:
         """Return the spinner's renderable for embedding in other components."""
-        return self._spinner.renderable
+        return self._status_spinner
+
+    def set_stream_renderable(self, renderable: RenderableType | None) -> None:
+        """Set the current streaming renderable displayed above the status line."""
+
+        if renderable is None:
+            self._stream_renderable = None
+            self._stream_max_height = 0
+            self._stream_last_height = 0
+            self._stream_last_width = 0
+            self._refresh_bottom_live()
+            return
+
+        self._ensure_bottom_live_started()
+        self._stream_renderable = renderable
+
+        height = len(self.console.render_lines(renderable, self.console.options, pad=False))
+        self._stream_last_height = height
+        self._stream_last_width = self.console.size.width
+        self._stream_max_height = max(self._stream_max_height, height)
+        self._refresh_bottom_live()
+
+    def _ensure_bottom_live_started(self) -> None:
+        if self._bottom_live is not None:
+            return
+        self._bottom_live = CropAboveLive(
+            Text(""),
+            console=self.console,
+            refresh_per_second=30,
+            transient=True,
+            redirect_stdout=False,
+            redirect_stderr=False,
+        )
+        self._bottom_live.start()
+
+    def _bottom_renderable(self) -> RenderableType:
+        stream_part: RenderableType = Group()
+        gap_part: RenderableType = Group()
+
+        if const.MARKDOWN_STREAM_LIVE_REPAINT_ENABLED:
+            stream = self._stream_renderable
+            if stream is not None:
+                current_width = self.console.size.width
+                if self._stream_last_width != current_width:
+                    height = len(self.console.render_lines(stream, self.console.options, pad=False))
+                    self._stream_last_height = height
+                    self._stream_last_width = current_width
+                    self._stream_max_height = max(self._stream_max_height, height)
+                else:
+                    height = self._stream_last_height
+
+                pad_lines = max(self._stream_max_height - height, 0)
+                if pad_lines:
+                    stream = Padding(stream, (0, 0, pad_lines, 0))
+                stream_part = stream
+
+            gap_part = Text("") if self._spinner_visible else Group()
+
+        status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
+        return Group(stream_part, gap_part, status_part)
+
+    def _refresh_bottom_live(self) -> None:
+        if self._bottom_live is None:
+            return
+        self._bottom_live.update(self._bottom_renderable(), refresh=True)
+
+    def stop_bottom_live(self) -> None:
+        if self._bottom_live is None:
+            return
+        with contextlib.suppress(Exception):
+            # Avoid cursor restore when stopping right before prompt_toolkit.
+            self._bottom_live.transient = False
+            self._bottom_live.stop()
+        self._bottom_live = None

klaude_code/ui/renderers/sub_agent.py

@@ -68,24 +68,22 @@ def render_sub_agent_result(
     panel_style: Style | None = None,
 ) -> RenderableType:
     stripped_result = result.strip()
-
-    # Add markdown heading if description is provided
-    if description:
-        stripped_result = f"# {description}\n\n{stripped_result}"
-
     result_panel_style = panel_style or ThemeKey.SUB_AGENT_RESULT_PANEL
 
     # Use rich JSON for structured output
     if has_structured_output:
         try:
-            return Panel.fit(
-                Group(
-                    Text(
-                        "use /export to view full output",
-                        style=ThemeKey.TOOL_RESULT,
-                    ),
-                    JSON(stripped_result),
+            group_elements: list[RenderableType] = [
+                Text(
+                    "use /export to view full output",
+                    style=ThemeKey.TOOL_RESULT,
                 ),
+                JSON(stripped_result),
+            ]
+            if description:
+                group_elements.insert(0, NoInsetMarkdown(f"# {description}", code_theme=code_theme, style=style or ""))
+            return Panel.fit(
+                Group(*group_elements),
                 box=box.SIMPLE,
                 border_style=ThemeKey.LINES,
                 style=result_panel_style,
@@ -94,6 +92,10 @@ def render_sub_agent_result(
             # Fall back to markdown if not valid JSON
             pass
 
+    # Add markdown heading if description is provided for non-structured output
+    if description:
+        stripped_result = f"# {description}\n\n{stripped_result}"
+
     lines = stripped_result.splitlines()
     if len(lines) > const.SUB_AGENT_RESULT_MAX_LINES:
         hidden_count = len(lines) - const.SUB_AGENT_RESULT_MAX_LINES

klaude_code/ui/renderers/thinking.py

@@ -10,7 +10,7 @@ from klaude_code.ui.rich.markdown import ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
 # UI markers
-THINKING_MESSAGE_MARK = "⠶"
+THINKING_MESSAGE_MARK = "⸫"
 
 
 def normalize_thinking_content(content: str) -> str:

klaude_code/ui/renderers/tools.py

@@ -19,7 +19,7 @@ from klaude_code.ui.rich.theme import ThemeKey
 # Tool markers (Unicode symbols for UI display)
 MARK_GENERIC = "⚒"
 MARK_BASH = "→"
-MARK_PLAN = "▪"
+MARK_PLAN = "Ξ"
 MARK_READ = "←"
 MARK_EDIT = "±"
 MARK_WRITE = "+"
@@ -528,19 +528,28 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
 def _extract_diff(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
     if isinstance(ui_extra, model.DiffUIExtra):
         return ui_extra
+    if isinstance(ui_extra, model.MultiUIExtra):
+        for item in ui_extra.items:
+            if isinstance(item, model.DiffUIExtra):
+                return item
     return None
 
 
 def _extract_markdown_doc(ui_extra: model.ToolResultUIExtra | None) -> model.MarkdownDocUIExtra | None:
     if isinstance(ui_extra, model.MarkdownDocUIExtra):
         return ui_extra
+    if isinstance(ui_extra, model.MultiUIExtra):
+        for item in ui_extra.items:
+            if isinstance(item, model.MarkdownDocUIExtra):
+                return item
     return None
 
 
 def render_markdown_doc(md_ui: model.MarkdownDocUIExtra, *, code_theme: str) -> RenderableType:
     """Render markdown document content in a panel."""
+    header = render_path(md_ui.file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     return Panel.fit(
-        NoInsetMarkdown(md_ui.content, code_theme=code_theme),
+        Group(header, Text(""), NoInsetMarkdown(md_ui.content, code_theme=code_theme)),
         box=box.SIMPLE,
         border_style=ThemeKey.LINES,
         style=ThemeKey.WRITE_MARKDOWN_PANEL,
@@ -562,6 +571,19 @@ def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai"
         error_msg = truncate_display(e.result)
         return r_errors.render_error(error_msg)
 
+    # Render multiple ui blocks if present
+    if isinstance(e.ui_extra, model.MultiUIExtra) and e.ui_extra.items:
+        rendered: list[RenderableType] = []
+        for item in e.ui_extra.items:
+            if isinstance(item, model.MarkdownDocUIExtra):
+                rendered.append(Padding.indent(render_markdown_doc(item, code_theme=code_theme), level=2))
+            elif isinstance(item, model.DiffUIExtra):
+                show_file_name = e.tool_name == tools.APPLY_PATCH
+                rendered.append(
+                    Padding.indent(r_diffs.render_structured_diff(item, show_file_name=show_file_name), level=2)
+                )
+        return Group(*rendered) if rendered else None
+
     # Show truncation info if output was truncated and saved to file
     truncation_info = get_truncation_info(e)
     if truncation_info:
@@ -580,6 +602,8 @@ def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai"
                 return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
             return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
         case tools.APPLY_PATCH:
+            if md_ui:
+                return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
             if diff_ui:
                 return Padding.indent(r_diffs.render_structured_diff(diff_ui, show_file_name=True), level=2)
             if len(e.result.strip()) == 0:

klaude_code/ui/rich/code_panel.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from rich.cells import cell_len
 from rich.console import ConsoleRenderable, RichCast
 from rich.jupyter import JupyterMixin
-from rich.measure import Measurement, measure_renderables
+from rich.measure import Measurement
 from rich.segment import Segment
 from rich.style import StyleType
 
@@ -58,17 +59,29 @@ class CodePanel(JupyterMixin):
         self.expand = expand
         self.padding = padding
 
+    @staticmethod
+    def _measure_max_line_cells(lines: list[list[Segment]]) -> int:
+        max_cells = 0
+        for line in lines:
+            plain = "".join(segment.text for segment in line).rstrip()
+            max_cells = max(max_cells, cell_len(plain))
+        return max_cells
+
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         border_style = console.get_style(self.border_style)
         max_width = options.max_width
         pad = self.padding
 
+        max_content_width = max(max_width - pad * 2, 1)
+
         # Measure the content width (account for padding)
         if self.expand:
-            content_width = max_width - pad * 2
+            content_width = max_content_width
         else:
-            content_width = console.measure(self.renderable, options=options.update(width=max_width - pad * 2)).maximum
-            content_width = min(content_width, max_width - pad * 2)
+            probe_options = options.update(width=max_content_width)
+            probe_lines = console.render_lines(self.renderable, probe_options, pad=False)
+            content_width = self._measure_max_line_cells(probe_lines)
+            content_width = max(1, min(content_width, max_content_width))
 
         # Render content lines
         child_options = options.update(width=content_width)
@@ -108,5 +121,11 @@ class CodePanel(JupyterMixin):
     def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
         if self.expand:
             return Measurement(options.max_width, options.max_width)
-        width = measure_renderables(console, options, [self.renderable]).maximum + self.padding * 2
+        max_width = options.max_width
+        max_content_width = max(max_width - self.padding * 2, 1)
+        probe_options = options.update(width=max_content_width)
+        probe_lines = console.render_lines(self.renderable, probe_options, pad=False)
+        content_width = self._measure_max_line_cells(probe_lines)
+        content_width = max(1, min(content_width, max_content_width))
+        width = content_width + self.padding * 2
         return Measurement(width, width)

klaude_code/ui/rich/live.py

@@ -63,3 +63,20 @@ class CropAboveLive(Live):
 
     def update(self, renderable: RenderableType, refresh: bool = True) -> None:  # type: ignore[override]
         super().update(CropAbove(renderable, style=self._crop_style), refresh=refresh)
+
+
+class SingleLine:
+    """Render only the first line of a renderable.
+
+    This is used to ensure dynamic UI elements (spinners / status) never wrap
+    to multiple lines, which would appear as a vertical "jump".
+    """
+
+    def __init__(self, renderable: RenderableType) -> None:
+        self.renderable = renderable
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        line_options = options.update(no_wrap=True, overflow="ellipsis", height=1)
+        lines = console.render_lines(self.renderable, line_options, pad=False)
+        if lines:
+            yield from lines[0]