klaude-code 1.2.6__py3-none-any.whl

klaude_code/ui/rich/markdown.py

@@ -0,0 +1,308 @@
+# copy from https://github.com/Aider-AI/aider/blob/main/aider/mdstream.py
+from __future__ import annotations
+
+import io
+import time
+from typing import Any, ClassVar
+
+from rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
+from rich.live import Live
+from rich.markdown import CodeBlock, Heading, Markdown
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.spinner import Spinner
+from rich.style import Style
+from rich.syntax import Syntax
+from rich.text import Text
+from rich.theme import Theme
+
+from klaude_code import const
+
+
+class NoInsetCodeBlock(CodeBlock):
+    """A code block with syntax highlighting and no padding."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        code = str(self.text).rstrip()
+        syntax = Syntax(
+            code,
+            self.lexer_name,
+            theme=self.theme,
+            word_wrap=True,
+            padding=(0, 1),
+        )
+        yield Panel.fit(syntax, padding=0, border_style="markdown.code.panel")
+
+
+class LeftHeading(Heading):
+    """A heading class that renders left-justified."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        text = self.text
+        text.justify = "left"  # Override justification
+        # if self.tag == "h1":
+        #     from rich.panel import Panel
+        #     from rich import box
+        #     # Draw a border around h1s, but keep text left-aligned
+        #     yield Panel(
+        #         text,
+        #         box=box.SQUARE,
+        #         style="markdown.h1.border",
+        #     )
+        if self.tag == "h2":
+            text.stylize(Style(bold=True, underline=False))
+            yield Rule(title=text, characters="-", style="markdown.h2.border", align="left")
+        else:
+            yield text
+
+
+class NoInsetMarkdown(Markdown):
+    """Markdown with code blocks that have no padding and left-justified headings."""
+
+    elements: ClassVar[dict[str, type[Any]]] = {
+        **Markdown.elements,
+        "fence": NoInsetCodeBlock,
+        "code_block": NoInsetCodeBlock,
+        "heading_open": LeftHeading,
+    }
+
+
+class MarkdownStream:
+    """Streaming markdown renderer that progressively displays content with a live updating window.
+
+    Uses rich.console and rich.live to render markdown content with smooth scrolling
+    and partial updates. Maintains a sliding window of visible content while streaming
+    in new markdown text.
+    """
+
+    def __init__(
+        self,
+        mdargs: dict[str, Any] | None = None,
+        theme: Theme | None = None,
+        console: Console | None = None,
+        spinner: Spinner | None = None,
+        mark: str | None = None,
+        indent: int = 0,
+    ) -> None:
+        """Initialize the markdown stream.
+
+        Args:
+            mdargs (dict, optional): Additional arguments to pass to rich Markdown renderer
+            theme (Theme, optional): Theme for rendering markdown
+            console (Console, optional): External console to use for rendering
+            mark (str | None, optional): Marker shown before the first non-empty line when indent >= 2
+            indent (int, optional): Number of spaces to indent all rendered lines on the left
+        """
+        self.printed: list[str] = []  # Stores lines that have already been printed
+
+        if mdargs:
+            self.mdargs: dict[str, Any] = mdargs
+        else:
+            self.mdargs = {}
+
+        # Defer Live creation until the first update.
+        self.live: Live | None = None
+        self._live_started: bool = False
+
+        # Streaming control
+        self.when: float = 0.0  # Timestamp of last update
+        self.min_delay: float = 1.0 / 20  # Minimum time between updates (20fps)
+        self.live_window: int = const.MARKDOWN_STREAM_LIVE_WINDOW
+        # Track the maximum height the live window has ever reached
+        # so we only pad when it shrinks from a previous height,
+        # instead of always padding to live_window from the start.
+        self._live_window_seen_height: int = 0
+
+        self.theme = theme
+        self.console = console
+        self.spinner: Spinner | None = spinner
+        self.mark: str | None = mark
+        self.indent: int = max(indent, 0)
+
+        # Defer Live creation until the first update
+        self.live: Live | None = None
+        self._live_started: bool = False
+
+    def _render_markdown_to_lines(self, text: str) -> list[str]:
+        """Render markdown text to a list of lines.
+
+        Args:
+            text (str): Markdown text to render
+
+        Returns:
+            list: List of rendered lines with line endings preserved
+        """
+        # Render the markdown to a string buffer
+        string_io = io.StringIO()
+
+        # Determine console width and adjust for left indent so that
+        # the rendered content plus indent does not exceed the available width.
+        if self.console is not None:
+            base_width = self.console.options.max_width
+        else:
+            probe_console = Console(theme=self.theme)
+            base_width = probe_console.options.max_width
+
+        effective_width = max(base_width - self.indent, 1)
+
+        # Use external console for consistent theming, or create temporary one
+        temp_console = Console(
+            file=string_io,
+            force_terminal=True,
+            theme=self.theme,
+            width=effective_width,
+        )
+
+        markdown = NoInsetMarkdown(text, **self.mdargs)
+        temp_console.print(markdown)
+        output = string_io.getvalue()
+
+        # Split rendered output into lines, strip trailing spaces, and apply left indent.
+        lines = output.splitlines(keepends=True)
+        indent_prefix = " " * self.indent if self.indent > 0 else ""
+        processed_lines: list[str] = []
+        mark_applied = False
+        use_mark = bool(self.mark) and self.indent >= 2
+
+        for line in lines:
+            stripped = line.rstrip()
+
+            # Apply mark to the first non-empty line only when indent is at least 2.
+            if use_mark and not mark_applied and stripped:
+                stripped = f"{self.mark} {stripped}"
+                mark_applied = True
+            elif indent_prefix:
+                stripped = indent_prefix + stripped
+
+            if line.endswith("\n"):
+                stripped += "\n"
+            processed_lines.append(stripped)
+
+        return processed_lines
+
+    def __del__(self) -> None:
+        """Destructor to ensure Live display is properly cleaned up."""
+        if self.live:
+            try:
+                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.
+
+        Args:
+            text (str): The markdown text received so far
+            final (bool): If True, this is the final update and we should clean up
+
+        Splits the output into "stable" older lines and the "last few" lines
+        which aren't considered stable. They may shift around as new chunks
+        are appended to the markdown text.
+
+        The stable lines emit to the console above the Live window.
+        The unstable lines emit into the Live window so they can be repainted.
+
+        Markdown going to the console works better in terminal scrollback buffers.
+        The live window doesn't play nice with terminal scrollback.
+        """
+        # On the first call, start the Live renderer
+        if not self._live_started:
+            initial_content = self._live_renderable(Text(""), final=False)
+            self.live = Live(
+                initial_content,
+                refresh_per_second=1.0 / self.min_delay,
+                console=self.console,
+            )
+            self.live.start()
+            self._live_started = True
+
+        # If live rendering isn't available (e.g., after a final update), stop.
+        if self.live is None:
+            return
+
+        now = time.time()
+        # Throttle updates to maintain smooth rendering
+        if not final and now - self.when < self.min_delay:
+            return
+        self.when = now
+
+        # Measure render time and adjust min_delay to maintain smooth rendering
+        start = time.time()
+        lines = self._render_markdown_to_lines(text)
+        render_time = time.time() - start
+
+        # Set min_delay to render time plus a small buffer
+        self.min_delay = min(max(render_time * 10, 1.0 / 20), 2)
+
+        num_lines = len(lines)
+
+        # How many lines have "left" the live window and are now considered stable?
+        # Or if final, consider all lines to be stable.
+        if not final:
+            num_lines = max(num_lines - self.live_window, 0)
+
+        # If there is new stable content, append only the new part
+        # Update Live window to prevent visual duplication
+        if final or num_lines > 0:
+            # Lines to append to stable area
+            num_printed = len(self.printed)
+            to_append_count = num_lines - num_printed
+
+            if to_append_count > 0:
+                # Print new stable lines above Live window
+                append_chunk = lines[num_printed:num_lines]
+                append_chunk_text = Text.from_ansi("".join(append_chunk))
+                live = self.live
+                assert live is not None
+                live.console.print(append_chunk_text)  # Print above Live area
+
+                # Track printed stable lines
+                self.printed = lines[:num_lines]
+
+        # Handle final update cleanup
+        if final:
+            live = self.live
+            assert live is not None
+            live.update(Text(""))
+            live.stop()
+            self.live = None
+            return
+
+        # Update Live window to prevent timing issues
+        # with console.print above. We pad the live region
+        # so that its height stays stable when it shrinks
+        # from a previously reached height, avoiding spinner jitter.
+        rest_lines = lines[num_lines:]
+
+        if not final:
+            current_height = len(rest_lines)
+
+            # Update the maximum height we've seen so far for this live window.
+            if current_height > self._live_window_seen_height:
+                # Never exceed configured live_window, even if logic changes later.
+                self._live_window_seen_height = min(current_height, self.live_window)
+
+            target_height = min(self._live_window_seen_height, self.live_window)
+            if target_height > 0 and current_height < target_height:
+                pad_count = target_height - current_height + 1
+                # Pad after the existing lines so spinner visually stays at the bottom.
+                rest_lines = rest_lines + ["\n"] * pad_count
+
+        rest = "".join(rest_lines)
+        rest = Text.from_ansi(rest)
+        live = self.live
+        assert live is not None
+        live_renderable = self._live_renderable(rest, final)
+        live.update(live_renderable)
+
+    def _live_renderable(self, rest: Text, final: bool) -> RenderableType:
+        if final or not self.spinner:
+            return rest
+        else:
+            return Group(rest, Text(), self.spinner)
+
+    def find_minimal_suffix(self, text: str, match_lines: int = 50) -> None:
+        """
+        Splits text into chunks on blank lines "\n\n".
+        """
+        return None

klaude_code/ui/rich/quote.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.segment import Segment
+from rich.style import Style
+
+
+class Quote:
+    """Wrapper to add quote prefix to any content"""
+
+    def __init__(self, content: Any, prefix: str = "▌ ", style: str | Style = "magenta"):
+        self.content = content
+        self.prefix = prefix
+        self.style = style
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        # Reduce width to leave space for prefix
+        prefix_width = len(self.prefix)
+        render_options = options.update(width=options.max_width - prefix_width)
+
+        # Get style
+        quote_style = console.get_style(self.style) if isinstance(self.style, str) else self.style
+
+        # Add prefix to each line
+        prefix_segment = Segment(self.prefix, quote_style)
+        new_line = Segment("\n")
+
+        # Render content as lines
+        lines = console.render_lines(self.content, render_options)
+
+        for line in lines:
+            yield prefix_segment
+            yield from line
+            yield new_line

klaude_code/ui/rich/searchable_text.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Iterable, List, Sequence, Tuple
+
+
+class SearchableFormattedText:
+    """
+    Wrapper for prompt_toolkit formatted text that also supports string-like
+    methods used by questionary's search filter (e.g., ``.lower()``).
+
+    This allows using ``use_search_filter=True`` with a formatted ``Choice.title``.
+
+    - ``fragments``: A sequence of (style, text) tuples accepted by
+      prompt_toolkit's ``to_formatted_text``.
+    - ``plain``: Optional plain text for searching. If omitted, it is derived by
+      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)
+        if plain is None:
+            plain = "".join(text for _, text in self._fragments)
+        self._plain = plain
+
+    # Recognized by prompt_toolkit's to_formatted_text(value)
+    def __pt_formatted_text__(
+        self,
+    ) -> Iterable[Tuple[str, str]]:  # pragma: no cover - passthrough
+        return self._fragments
+
+    # Provide a human-readable representation.
+    def __str__(self) -> str:  # pragma: no cover - utility
+        return self._plain
+
+    # Minimal string API to satisfy questionary's search filter logic.
+    def lower(self) -> str:
+        return self._plain.lower()
+
+    def upper(self) -> str:  # pragma: no cover - convenience
+        return self._plain.upper()
+
+    # Expose the plain text if needed elsewhere.
+    @property
+    def plain(self) -> str:
+        return self._plain
+
+
+class SearchableFormattedList(list[Tuple[str, str]]):
+    """
+    List variant compatible with questionary's expected ``Choice.title`` type.
+
+    - Behaves like ``List[Tuple[str, str]]`` for rendering (so ``isinstance(..., list)`` works),
+      preserving existing styling behavior in questionary.
+    - Provides ``.lower()``/``.upper()`` returning the plain text for search filtering.
+    """
+
+    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)
+        self._plain = plain
+
+    def lower(self) -> str:
+        return self._plain.lower()
+
+    def upper(self) -> str:  # pragma: no cover - convenience
+        return self._plain.upper()
+
+    @property
+    def plain(self) -> str:
+        return self._plain

klaude_code/ui/rich/status.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import math
+import time
+
+import rich.status as rich_status
+from rich._spinners import SPINNERS
+from rich.color import Color
+from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+from rich.spinner import Spinner as RichSpinner
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+
+from klaude_code import const
+from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.ui.terminal.color import get_last_terminal_background_rgb
+
+BREATHING_SPINNER_NAME = "dot"
+
+SPINNERS.update(
+    {
+        BREATHING_SPINNER_NAME: {
+            "interval": 100,
+            # Frames content is ignored by the custom breathing spinner implementation,
+            # but we keep a single-frame list for correct width measurement.
+            "frames": ["⏺"],
+        }
+    }
+)
+
+_process_start: float | None = None
+
+
+def _elapsed_since_start() -> float:
+    """Return seconds elapsed since first call in this process."""
+    global _process_start
+    now = time.perf_counter()
+    if _process_start is None:
+        _process_start = now
+    return now - _process_start
+
+
+def _shimmer_profile(main_text: str) -> list[tuple[str, float]]:
+    """Compute per-character shimmer intensity for a horizontal band.
+
+    Returns a list of (character, intensity) where intensity is in [0, 1].
+    """
+
+    chars = list(main_text)
+    if not chars:
+        return []
+
+    padding = const.STATUS_SHIMMER_PADDING
+    char_count = len(chars)
+    period = char_count + padding * 2
+
+    # Keep a roughly constant shimmer speed (characters per second)
+    # regardless of text length by deriving a character velocity from a
+    # baseline text length and the configured sweep duration.
+    # The baseline is chosen to be close to the default
+    # "Thinking … (esc to interrupt)" status line.
+    baseline_chars = 30
+    base_period = baseline_chars + padding * 2
+    sweep_seconds = const.STATUS_SHIMMER_SWEEP_SECONDS
+    char_speed = base_period / sweep_seconds if sweep_seconds > 0 else base_period
+
+    elapsed = _elapsed_since_start()
+    pos_f = (elapsed * char_speed) % float(period)
+    pos = int(pos_f)
+    band_half_width = const.STATUS_SHIMMER_BAND_HALF_WIDTH
+
+    profile: list[tuple[str, float]] = []
+    for index, ch in enumerate(chars):
+        i_pos = index + padding
+        dist = abs(i_pos - pos)
+        if dist <= band_half_width:
+            x = math.pi * (dist / band_half_width)
+            intensity = 0.5 * (1.0 + math.cos(x))
+        else:
+            intensity = 0.0
+        profile.append((ch, intensity))
+    return profile
+
+
+def _shimmer_style(console: Console, base_style: Style, intensity: float) -> Style:
+    """Compute shimmer style for a single character.
+
+    When intensity is 0, returns the base style. As intensity increases, the
+    foreground color is blended towards the terminal background color, similar
+    to codex-rs shimmer's use of default_fg/default_bg and blend().
+    """
+
+    if intensity <= 0.0:
+        return base_style
+
+    alpha = max(0.0, min(1.0, intensity * const.STATUS_SHIMMER_ALPHA_SCALE))
+
+    base_color = base_style.color or Color.default()
+    base_triplet = base_color.get_truecolor()
+    bg_triplet = Color.default().get_truecolor(foreground=False)
+
+    base_r, base_g, base_b = base_triplet
+    bg_r, bg_g, bg_b = bg_triplet
+
+    r = int(bg_r * alpha + base_r * (1.0 - alpha))
+    g = int(bg_g * alpha + base_g * (1.0 - alpha))
+    b = int(bg_b * alpha + base_b * (1.0 - alpha))
+
+    shimmer_color = Color.from_rgb(r, g, b)
+    return base_style + Style(color=shimmer_color)
+
+
+def _breathing_intensity() -> float:
+    """Compute breathing intensity in [0, 1] for the spinner.
+
+    Intensity follows a smooth cosine curve over the configured period, starting
+    from 0 (fully blended into background), rising to 1 (full style color),
+    then returning to 0, giving a subtle "breathing" effect.
+    """
+
+    period = max(const.SPINNER_BREATH_PERIOD_SECONDS, 0.1)
+    elapsed = _elapsed_since_start()
+    phase = (elapsed % period) / period
+    return 0.5 * (1.0 - math.cos(2.0 * math.pi * phase))
+
+
+def _breathing_style(console: Console, base_style: Style, intensity: float) -> Style:
+    """Blend a base style's foreground color toward terminal background.
+
+    When intensity is 0, the color matches the background (effectively
+    "transparent"); when intensity is 1, the color is the base style color.
+    """
+
+    base_color = base_style.color or Color.default()
+    base_triplet = base_color.get_truecolor()
+    base_r, base_g, base_b = base_triplet
+
+    cached_bg = get_last_terminal_background_rgb()
+    if cached_bg is not None:
+        bg_r, bg_g, bg_b = cached_bg
+    else:
+        bg_triplet = Color.default().get_truecolor(foreground=False)
+        bg_r, bg_g, bg_b = bg_triplet
+
+    intensity_clamped = max(0.0, min(1.0, intensity))
+    r = int(bg_r * (1.0 - intensity_clamped) + base_r * intensity_clamped)
+    g = int(bg_g * (1.0 - intensity_clamped) + base_g * intensity_clamped)
+    b = int(bg_b * (1.0 - intensity_clamped) + base_b * intensity_clamped)
+
+    breathing_color = Color.from_rgb(r, g, b)
+    return base_style + Style(color=breathing_color)
+
+
+class ShimmerStatusText:
+    """Renderable status line with shimmer effect on the main text and hint."""
+
+    def __init__(self, main_text: str | Text, main_style: ThemeKey) -> None:
+        self._main_text = main_text if isinstance(main_text, Text) else Text(main_text)
+        self._main_style = main_style
+        self._hint_text = Text(" (esc to interrupt)")
+        self._hint_style = ThemeKey.STATUS_HINT
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        result = Text()
+        main_style = console.get_style(str(self._main_style))
+        hint_style = console.get_style(str(self._hint_style))
+
+        combined_text = self._main_text.plain + self._hint_text.plain
+        split_index = len(self._main_text.plain)
+
+        for index, (ch, intensity) in enumerate(_shimmer_profile(combined_text)):
+            if index < split_index:
+                # Get style from main_text, merge with main_style
+                char_style = self._main_text.get_style_at_offset(console, index)
+                base_style = main_style + char_style
+            else:
+                base_style = hint_style
+            style = _shimmer_style(console, base_style, intensity)
+            result.append(ch, style=style)
+
+        yield result
+
+
+def spinner_name() -> str:
+    return BREATHING_SPINNER_NAME
+
+
+class BreathingSpinner(RichSpinner):
+    """Custom spinner that animates color instead of glyphs.
+
+    The spinner always renders a single "⏺" glyph whose foreground color
+    smoothly interpolates between the terminal background and the spinner
+    style color, producing a breathing effect.
+    """
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:  # type: ignore[override]
+        if self.name != BREATHING_SPINNER_NAME:
+            # Fallback to Rich's default behavior for other spinners.
+            yield from super().__rich_console__(console, options)
+            return
+
+        yield self._render_breathing(console)
+
+    def _resolve_base_style(self, console: Console) -> Style:
+        style = self.style
+        if isinstance(style, Style):
+            return style
+        if style is None:
+            return Style()
+        style_name = str(style).strip()
+        if not style_name:
+            return Style()
+        return console.get_style(style_name)
+
+    def _render_breathing(self, console: Console) -> RenderableType:
+        base_style = self._resolve_base_style(console)
+        intensity = _breathing_intensity()
+        style = _breathing_style(console, base_style, intensity)
+
+        glyph = self.frames[0] if self.frames else "⏺"
+        frame = Text(glyph, style=style)
+
+        if not self.text:
+            return frame
+        if isinstance(self.text, (str, Text)):
+            return Text.assemble(frame, " ", self.text)
+
+        table = Table.grid(padding=1)
+        table.add_row(frame, self.text)
+        return table
+
+
+# Monkey-patch Rich's Status module to use the breathing spinner implementation
+# for the configured spinner name, while preserving default behavior elsewhere.
+try:
+    rich_status.Spinner = BreathingSpinner  # type: ignore[assignment]
+except Exception:
+    # Best-effort patch; if it fails we silently fall back to default spinner.
+    pass