klaude-code 1.2.12__py3-none-any.whl → 1.2.14__py3-none-any.whl

klaude_code/ui/modes/repl/renderer.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Any, Iterator
+from typing import Any
 
 from rich import box
 from rich.box import Box
@@ -98,48 +99,21 @@ class REPLRenderer:
     def print(self, *objects: Any, style: StyleType | None = None, end: str = "\n") -> None:
         if self.current_sub_agent_color:
             if objects:
-                self.console.print(Quote(*objects, style=self.current_sub_agent_color))
+                content = objects[0] if len(objects) == 1 else objects
+                self.console.print(Quote(content, style=self.current_sub_agent_color))
             return
         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):
-            if e.is_replay:
-                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()
-                    )
-                    self.print(
-                        Quote(
-                            r_sub_agent.render_sub_agent_call(state, sub_agent_default_style),
-                            style=sub_agent_default_style,
-                        )
-                    )
             return
-
         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):
-            if e.is_replay:
-                sub_agent_default_style = self.themes.sub_agent_colors[0] if self.themes.sub_agent_colors else Style()
-                self.print(
-                    Quote(
-                        r_sub_agent.render_sub_agent_result(
-                            e.result,
-                            code_theme=self.themes.code_theme,
-                            style=sub_agent_default_style,
-                        ),
-                        style=sub_agent_default_style,
-                    )
-                )
             return
-
         renderable = r_tools.render_tool_result(e)
         if renderable is not None:
             self.print(renderable)
@@ -159,39 +133,55 @@ class REPLRenderer:
     async def replay_history(self, history_events: events.ReplayHistoryEvent) -> None:
         tool_call_dict: dict[str, events.ToolCallEvent] = {}
         for event in history_events.events:
-            match event:
-                case events.TurnStartEvent():
-                    self.print()
-                case events.AssistantMessageEvent() as assistant_event:
-                    renderable = r_assistant.render_assistant_message(
-                        assistant_event.content, code_theme=self.themes.code_theme
-                    )
-                    if renderable is not None:
-                        self.print(renderable)
+            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.AssistantMessageEvent() as e:
+                        if is_sub_agent:
+                            continue
+                        renderable = r_assistant.render_assistant_message(
+                            e.content, code_theme=self.themes.code_theme
+                        )
+                        if renderable is not None:
+                            self.print(renderable)
+                            self.print()
+                    case events.ThinkingEvent() as e:
+                        if is_sub_agent:
+                            continue
+                        self.display_thinking(e.content)
+                    case events.DeveloperMessageEvent() as e:
+                        self.display_developer_message(e)
+                        self.display_command_output(e)
+                    case events.UserMessageEvent() as e:
+                        if is_sub_agent:
+                            continue
+                        self.print(r_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(r_metadata.render_task_metadata(e))
+                        self.print()
+                    case events.InterruptEvent():
                         self.print()
-                case events.ThinkingEvent() as thinking_event:
-                    self.display_thinking(thinking_event.content)
-                case events.DeveloperMessageEvent() as developer_event:
-                    self.display_developer_message(developer_event)
-                    self.display_command_output(developer_event)
-                case events.UserMessageEvent() as user_event:
-                    self.print(r_user_input.render_user_input(user_event.content))
-                case events.ToolCallEvent() as tool_call_event:
-                    tool_call_dict[tool_call_event.tool_call_id] = tool_call_event
-                case events.ToolResultEvent() as tool_result_event:
-                    tool_call_event = tool_call_dict.get(tool_result_event.tool_call_id)
-                    if tool_call_event is not None:
-                        self.display_tool_call(tool_call_event)
-                    tool_call_dict.pop(tool_result_event.tool_call_id, None)
-                    self.display_tool_call_result(tool_result_event)
-                case events.TaskMetadataEvent() as metadata_event:
-                    self.print(r_metadata.render_task_metadata(metadata_event))
-                    self.print()
-                case events.InterruptEvent():
-                    self.print()
-                    self.print(r_user_input.render_interrupt())
-                case events.ErrorEvent() as e:
-                    self.display_error(e)
+                        self.print(r_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 r_developer.need_render_developer_message(e):

klaude_code/ui/renderers/diffs.py

@@ -73,10 +73,7 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
         if line.startswith("--- "):
             raw = line[4:].strip()
             if raw != "/dev/null":
-                if raw.startswith(("a/", "b/")):
-                    from_file_name = raw[2:]
-                else:
-                    from_file_name = raw
+                from_file_name = raw[2:] if raw.startswith(("a/", "b/")) else raw
             continue
 
         # Parse file name from diff headers

klaude_code/ui/renderers/tools.py

@@ -239,6 +239,10 @@ def render_todo(tr: events.ToolResultEvent) -> RenderableType:
                 mark = "✔"
                 mark_style = ThemeKey.TODO_NEW_COMPLETED_MARK if is_new_completed else ThemeKey.TODO_COMPLETED_MARK
                 text_style = ThemeKey.TODO_NEW_COMPLETED if is_new_completed else ThemeKey.TODO_COMPLETED
+            case _:
+                mark = "?"
+                mark_style = ThemeKey.TODO_PENDING_MARK
+                text_style = ThemeKey.TODO_PENDING
         text = Text(todo.content)
         text.stylize(text_style)
         todo_grid.add_row(Text(mark, style=mark_style), text)

klaude_code/ui/rich/markdown.py

@@ -1,6 +1,7 @@
 # copy from https://github.com/Aider-AI/aider/blob/main/aider/mdstream.py
 from __future__ import annotations
 
+import contextlib
 import io
 import time
 from typing import Any, ClassVar
@@ -183,10 +184,9 @@ class MarkdownStream:
     def __del__(self) -> None:
         """Destructor to ensure Live display is properly cleaned up."""
         if self.live:
-            try:
+            # Ignore any errors during cleanup
+            with contextlib.suppress(Exception):
                 self.live.stop()
-            except Exception:
-                pass  # Ignore any errors during cleanup
 
     def update(self, text: str, final: bool = False) -> None:
         """Update the displayed markdown content.

klaude_code/ui/rich/searchable_text.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable, List, Sequence, Tuple
+from collections.abc import Iterable, Sequence
 
 
 class SearchableFormattedText:
@@ -16,8 +16,8 @@ class SearchableFormattedText:
       concatenating the text parts of the fragments.
     """
 
-    def __init__(self, fragments: Sequence[Tuple[str, str]], plain: str | None = None):
-        self._fragments: List[Tuple[str, str]] = list(fragments)
+    def __init__(self, fragments: Sequence[tuple[str, str]], plain: str | None = None):
+        self._fragments: list[tuple[str, str]] = list(fragments)
         if plain is None:
             plain = "".join(text for _, text in self._fragments)
         self._plain = plain
@@ -25,7 +25,7 @@ class SearchableFormattedText:
     # Recognized by prompt_toolkit's to_formatted_text(value)
     def __pt_formatted_text__(
         self,
-    ) -> Iterable[Tuple[str, str]]:  # pragma: no cover - passthrough
+    ) -> Iterable[tuple[str, str]]:  # pragma: no cover - passthrough
         return self._fragments
 
     # Provide a human-readable representation.
@@ -45,7 +45,7 @@ class SearchableFormattedText:
         return self._plain
 
 
-class SearchableFormattedList(list[Tuple[str, str]]):
+class SearchableFormattedList(list[tuple[str, str]]):
     """
     List variant compatible with questionary's expected ``Choice.title`` type.
 
@@ -54,7 +54,7 @@ class SearchableFormattedList(list[Tuple[str, str]]):
     - Provides ``.lower()``/``.upper()`` returning the plain text for search filtering.
     """
 
-    def __init__(self, fragments: Sequence[Tuple[str, str]], plain: str | None = None):
+    def __init__(self, fragments: Sequence[tuple[str, str]], plain: str | None = None):
         super().__init__(fragments)
         if plain is None:
             plain = "".join(text for _, text in fragments)

klaude_code/ui/rich/status.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import math
 import time
 
@@ -233,8 +234,6 @@ class BreathingSpinner(RichSpinner):
 
 # Monkey-patch Rich's Status module to use the breathing spinner implementation
 # for the configured spinner name, while preserving default behavior elsewhere.
-try:
+# Best-effort patch; if it fails we silently fall back to default spinner.
+with contextlib.suppress(Exception):
     rich_status.Spinner = BreathingSpinner  # type: ignore[assignment]
-except Exception:
-    # Best-effort patch; if it fails we silently fall back to default spinner.
-    pass

klaude_code/ui/rich/theme.py

@@ -43,7 +43,7 @@ LIGHT_PALETTE = Palette(
     diff_add="#2e5a32 on #e8f5e9",
     diff_remove="#5a2e32 on #ffebee",
     code_theme="ansi_light",
-    text_background="#f0f0f0",
+    text_background="#e0e0e0",
 )
 
 DARK_PALETTE = Palette(
@@ -153,10 +153,7 @@ class Themes:
 
 
 def get_theme(theme: str | None = None) -> Themes:
-    if theme == "light":
-        palette = LIGHT_PALETTE
-    else:
-        palette = DARK_PALETTE
+    palette = LIGHT_PALETTE if theme == "light" else DARK_PALETTE
     return Themes(
         app_theme=Theme(
             styles={

klaude_code/ui/terminal/control.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import os
 import select
 import signal
@@ -75,19 +76,15 @@ def start_esc_interrupt_monitor(
                     r2, _, _ = select.select([sys.stdin], [], [], 0.0)
 
                 if seq == "":
-                    try:
+                    # Best-effort only; failures here should not crash the UI.
+                    with contextlib.suppress(Exception):
                         asyncio.run_coroutine_threadsafe(on_interrupt(), loop)
-                    except Exception:
-                        # Best-effort only; failures here should not crash the UI.
-                        pass
                     stop.set()
         except Exception as exc:  # pragma: no cover - environment dependent
             log((f"esc monitor error: {exc}", "r red"))
         finally:
-            try:
+            with contextlib.suppress(Exception):
                 termios.tcsetattr(fd, termios.TCSADRAIN, old)
-            except Exception:
-                pass
 
     esc_task: asyncio.Task[None] = asyncio.create_task(asyncio.to_thread(_esc_monitor, stop_event))
     return stop_event, esc_task
@@ -119,18 +116,14 @@ def install_sigint_double_press_exit(
         now = time.monotonic()
         if now - last_sigint_time <= window_seconds:
             # Second press within window: hide progress UI and exit.
-            try:
+            with contextlib.suppress(Exception):
                 hide_progress()
-            except Exception:
-                pass
             raise KeyboardInterrupt
 
         # First press: remember timestamp and show toast.
         last_sigint_time = now
-        try:
+        with contextlib.suppress(Exception):
             show_toast()
-        except Exception:
-            pass
 
     try:
         signal.signal(signal.SIGINT, _handler)
@@ -139,9 +132,7 @@ def install_sigint_double_press_exit(
         return lambda: None
 
     def restore() -> None:
-        try:
+        with contextlib.suppress(Exception):
             signal.signal(signal.SIGINT, original_handler)
-        except Exception:
-            pass
 
     return restore

klaude_code/ui/terminal/notifier.py

@@ -39,7 +39,7 @@ class TerminalNotifierConfig:
     stream: TextIO | None = None
 
     @classmethod
-    def from_env(cls) -> "TerminalNotifierConfig":
+    def from_env(cls) -> TerminalNotifierConfig:
         env = os.getenv("KLAUDE_NOTIFY", "").strip().lower()
         if env in {"0", "off", "false", "disable", "disabled"}:
             return cls(enabled=False)
@@ -95,9 +95,7 @@ class TerminalNotifier:
         if not getattr(stream, "isatty", lambda: False)():
             return False
         term = os.getenv("TERM", "")
-        if term.lower() in {"", "dumb"}:
-            return False
-        return True
+        return term.lower() not in {"", "dumb"}
 
 
 def _compact(text: str, limit: int = 160) -> str:

klaude_code/ui/utils/common.py

@@ -99,7 +99,7 @@ def truncate_display(
 ) -> str:
     lines = text.split("\n")
     if len(lines) > max_lines:
-        lines = lines[:max_lines] + ["… (more " + str(len(lines) - max_lines) + " 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] = (

klaude_code/ui/utils/debouncer.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Awaitable, Callable, Optional
+from collections.abc import Awaitable, Callable
 
 
 class Debouncer:
@@ -15,7 +15,7 @@ class Debouncer:
         """
         self.interval = interval
         self.callback = callback
-        self._task: Optional[asyncio.Task[None]] = None
+        self._task: asyncio.Task[None] | None = None
 
     def cancel(self) -> None:
         """Cancel current debounce task"""

{klaude_code-1.2.12.dist-info → klaude_code-1.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.12
+Version: 1.2.14
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: openai>=1.102.0