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

klaude_code/ui/modes/repl/event_handler.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Awaitable, Callable
 
 from rich.text import Text
 
@@ -10,6 +10,7 @@ from klaude_code.protocol import events
 from klaude_code.ui.core.stage_manager import Stage, StageManager
 from klaude_code.ui.modes.repl.renderer import REPLRenderer
 from klaude_code.ui.rich.markdown import MarkdownStream
+from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 from klaude_code.ui.utils.debouncer import Debouncer
@@ -41,7 +42,7 @@ class StreamState:
     This design ensures buffer and mdstream are always in sync.
     """
 
-    def __init__(self, interval: float, flush_handler: Callable[["StreamState"], Awaitable[None]]):
+    def __init__(self, interval: float, flush_handler: Callable[[StreamState], Awaitable[None]]):
         self._active: ActiveStream | None = None
         self._flush_handler = flush_handler
         self.debouncer = Debouncer(interval=interval, callback=self._debounced_flush)
@@ -199,10 +200,14 @@ class DisplayEventHandler:
         self.assistant_stream = StreamState(
             interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_assistant_buffer
         )
+        self.thinking_stream = StreamState(
+            interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_thinking_buffer
+        )
         self.spinner_status = SpinnerStatusState()
 
         self.stage_manager = StageManager(
             finish_assistant=self._finish_assistant_stream,
+            finish_thinking=self._finish_thinking_stream,
             on_enter_thinking=self._print_thinking_prefix,
         )
 
@@ -222,6 +227,8 @@ class DisplayEventHandler:
                 self._on_turn_start(e)
             case events.ThinkingEvent() as e:
                 await self._on_thinking(e)
+            case events.ThinkingDeltaEvent() as e:
+                await self._on_thinking_delta(e)
             case events.AssistantMessageDeltaEvent() as e:
                 await self._on_assistant_delta(e)
             case events.AssistantMessageEvent() as e:
@@ -252,6 +259,8 @@ class DisplayEventHandler:
     async def stop(self) -> None:
         await self.assistant_stream.debouncer.flush()
         self.assistant_stream.debouncer.cancel()
+        await self.thinking_stream.debouncer.flush()
+        self.thinking_stream.debouncer.cancel()
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Private event handlers
@@ -285,8 +294,41 @@ class DisplayEventHandler:
     async def _on_thinking(self, event: events.ThinkingEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
             return
+        # If streaming was active, finalize it
+        if self.thinking_stream.is_active:
+            await self._finish_thinking_stream()
+        else:
+            # Non-streaming path (history replay or models without delta support)
+            await self.stage_manager.enter_thinking_stage()
+            self.renderer.display_thinking(event.content)
+
+    async def _on_thinking_delta(self, event: events.ThinkingDeltaEvent) -> None:
+        if self.renderer.is_sub_agent_session(event.session_id):
+            return
+
+        first_delta = not self.thinking_stream.is_active
+        if first_delta:
+            self.renderer.console.push_theme(self.renderer.themes.thinking_markdown_theme)
+            mdstream = MarkdownStream(
+                mdargs={
+                    "code_theme": self.renderer.themes.code_theme,
+                    "style": self.renderer.console.get_style(ThemeKey.THINKING),
+                },
+                theme=self.renderer.themes.thinking_markdown_theme,
+                console=self.renderer.console,
+                spinner=self.renderer.spinner_renderable(),
+                indent=2,
+            )
+            self.thinking_stream.start(mdstream)
+            self.renderer.spinner_stop()
+
+        self.thinking_stream.append(event.content)
+
+        if first_delta and self.thinking_stream.mdstream is not None:
+            self.thinking_stream.mdstream.update(self.thinking_stream.buffer)
+
         await self.stage_manager.enter_thinking_stage()
-        self.renderer.display_thinking(event.content)
+        self.thinking_stream.debouncer.schedule()
 
     async def _on_assistant_delta(self, event: events.AssistantMessageDeltaEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
@@ -419,6 +461,22 @@ class DisplayEventHandler:
             assert mdstream is not None
             mdstream.update(state.buffer)
 
+    async def _flush_thinking_buffer(self, state: StreamState) -> None:
+        if state.is_active:
+            mdstream = state.mdstream
+            assert mdstream is not None
+            mdstream.update(state.buffer)
+
+    async def _finish_thinking_stream(self) -> None:
+        if self.thinking_stream.is_active:
+            self.thinking_stream.debouncer.cancel()
+            mdstream = self.thinking_stream.mdstream
+            assert mdstream is not None
+            mdstream.update(self.thinking_stream.buffer, final=True)
+            self.thinking_stream.finish()
+            self.renderer.console.pop_theme()
+            self.renderer.spinner_start()
+
     def _maybe_notify_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.notifier is None:
             return
@@ -453,10 +511,10 @@ class DisplayEventHandler:
                 if len(todo.content) > 0:
                     status_text = todo.content
         status_text = status_text.replace("\n", "")
-        return self._truncate_status_text(status_text, max_length=100)
+        return self._truncate_status_text(status_text, max_length=50)
 
     def _truncate_status_text(self, text: str, max_length: int) -> str:
         if len(text) <= max_length:
             return text
         truncated = text[:max_length]
-        return truncated + "..."
+        return truncated + "…"

klaude_code/ui/modes/repl/key_bindings.py

@@ -6,6 +6,7 @@ with dependencies injected to avoid circular imports.
 
 from __future__ import annotations
 
+import contextlib
 import re
 from collections.abc import Callable
 from typing import cast
@@ -35,10 +36,8 @@ def create_key_bindings(
         """Paste image from clipboard as [Image #N]."""
         tag = capture_clipboard_tag()
         if tag:
-            try:
+            with contextlib.suppress(Exception):
                 event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
-            except Exception:
-                pass
 
     @kb.add("enter")
     def _(event):  # type: ignore

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

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/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

@@ -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.13.dist-info}/METADATA

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