klaude-code 1.2.6__py3-none-any.whl

klaude_code/ui/rich/theme.py

@@ -0,0 +1,274 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from rich.style import Style
+from rich.theme import Theme
+
+
+@dataclass
+class Palette:
+    red: str
+    yellow: str
+    green: str
+    cyan: str
+    blue: str
+    orange: str
+    magenta: str
+    grey_blue: str
+    grey1: str
+    grey2: str
+    grey3: str
+    grey_green: str
+    purple: str
+    diff_add: str
+    diff_remove: str
+    code_theme: str
+    text_background: str
+
+
+LIGHT_PALETTE = Palette(
+    red="red",
+    yellow="yellow",
+    green="spring_green4",
+    cyan="cyan",
+    blue="#3678b7",
+    orange="#d77757",
+    magenta="magenta",
+    grey_blue="steel_blue",
+    grey1="#667e90",
+    grey2="#93a4b1",
+    grey3="#c4ced4",
+    grey_green="#96a696",
+    purple="slate_blue3",
+    diff_add="#2e5a32 on #e8f5e9",
+    diff_remove="#5a2e32 on #ffebee",
+    code_theme="ansi_light",
+    text_background="#f0f0f0",
+)
+
+DARK_PALETTE = Palette(
+    red="indian_red",
+    yellow="yellow",
+    green="sea_green3",
+    cyan="cyan",
+    blue="deep_sky_blue1",
+    orange="#e6704e",
+    magenta="magenta",
+    grey_blue="steel_blue",
+    grey1="#99aabb",
+    grey2="#778899",
+    grey3="#646464",
+    grey_green="#6d8672",
+    purple="#afbafe",
+    diff_add="#c8e6c9 on #2e4a32",
+    diff_remove="#ffcdd2 on #4a2e32",
+    code_theme="ansi_dark",
+    text_background="#2f3440",
+)
+
+
+class ThemeKey(str, Enum):
+    LINES = "lines"
+    # DIFF
+    DIFF_FILE_NAME = "diff.file_name"
+    DIFF_REMOVE = "diff.remove"
+    DIFF_ADD = "diff.add"
+    DIFF_STATS_ADD = "diff.stats.add"
+    DIFF_STATS_REMOVE = "diff.stats.remove"
+    # ERROR
+    ERROR = "error"
+    ERROR_BOLD = "error.bold"
+    INTERRUPT = "interrupt"
+    # METADATA
+    METADATA = "metadata"
+    METADATA_DIM = "metadata.dim"
+    METADATA_BOLD = "metadata.bold"
+    # SPINNER_STATUS
+    SPINNER_STATUS = "spinner.status"
+    SPINNER_STATUS_TEXT = "spinner.status.text"
+    # STATUS
+    STATUS_HINT = "status.hint"
+    # USER_INPUT
+    USER_INPUT = "user.input"
+    USER_INPUT_PROMPT = "user.input.prompt"
+    USER_INPUT_AT_PATTERN = "user.at_pattern"
+    USER_INPUT_SLASH_COMMAND = "user.slash_command"
+    # REMINDER
+    REMINDER = "reminder"
+    REMINDER_BOLD = "reminder.bold"
+    # TOOL
+    INVALID_TOOL_CALL_ARGS = "tool.invalid_tool_call_args"
+    TOOL_NAME = "tool.name"
+    TOOL_PARAM_FILE_PATH = "tool.param.file_path"
+    TOOL_PARAM = "tool.param"
+    TOOL_PARAM_BOLD = "tool.param.bold"
+    TOOL_RESULT = "tool.result"
+    TOOL_RESULT_BOLD = "tool.result.bold"
+    TOOL_MARK = "tool.mark"
+    TOOL_APPROVED = "tool.approved"
+    TOOL_REJECTED = "tool.rejected"
+    # THINKING
+    THINKING = "thinking"
+    THINKING_BOLD = "thinking.bold"
+    # TODO_ITEM
+    TODO_EXPLANATION = "todo.explanation"
+    TODO_PENDING_MARK = "todo.pending.mark"
+    TODO_COMPLETED_MARK = "todo.completed.mark"
+    TODO_IN_PROGRESS_MARK = "todo.in_progress.mark"
+    TODO_NEW_COMPLETED_MARK = "todo.new_completed.mark"
+    TODO_PENDING = "todo.pending"
+    TODO_COMPLETED = "todo.completed"
+    TODO_IN_PROGRESS = "todo.in_progress"
+    TODO_NEW_COMPLETED = "todo.new_completed"
+    # WELCOME
+    WELCOME_HIGHLIGHT_BOLD = "welcome.highlight.bold"
+    WELCOME_HIGHLIGHT = "welcome.highlight"
+    WELCOME_INFO = "welcome.info"
+    # WELCOME DEBUG
+    WELCOME_DEBUG_TITLE = "welcome.debug.title"
+    WELCOME_DEBUG_BORDER = "welcome.debug.border"
+    # RESUME
+    RESUME_FLAG = "resume.flag"
+    RESUME_INFO = "resume.info"
+    # CONFIGURATION DISPLAY
+    CONFIG_TABLE_HEADER = "config.table.header"
+    CONFIG_STATUS_OK = "config.status.ok"
+    CONFIG_STATUS_PRIMARY = "config.status.primary"
+    CONFIG_ITEM_NAME = "config.item.name"
+    CONFIG_PARAM_LABEL = "config.param.label"
+    CONFIG_PANEL_BORDER = "config.panel.border"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclass
+class Themes:
+    app_theme: Theme
+    markdown_theme: Theme
+    thinking_markdown_theme: Theme
+    code_theme: str
+    sub_agent_colors: list[Style]
+
+
+def get_theme(theme: str | None = None) -> Themes:
+    if theme == "light":
+        palette = LIGHT_PALETTE
+    else:
+        palette = DARK_PALETTE
+    return Themes(
+        app_theme=Theme(
+            styles={
+                ThemeKey.LINES.value: palette.grey3,
+                # DIFF
+                ThemeKey.DIFF_FILE_NAME.value: palette.blue,
+                ThemeKey.DIFF_REMOVE.value: palette.diff_remove,
+                ThemeKey.DIFF_ADD.value: palette.diff_add,
+                ThemeKey.DIFF_STATS_ADD.value: palette.green,
+                ThemeKey.DIFF_STATS_REMOVE.value: palette.red,
+                # ERROR
+                ThemeKey.ERROR.value: palette.red,
+                ThemeKey.ERROR_BOLD.value: "bold " + palette.red,
+                ThemeKey.INTERRUPT.value: "reverse bold " + palette.red,
+                # USER_INPUT
+                ThemeKey.USER_INPUT.value: palette.magenta,
+                ThemeKey.USER_INPUT_PROMPT.value: palette.magenta,
+                ThemeKey.USER_INPUT_AT_PATTERN.value: palette.purple,
+                ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold reverse " + palette.blue,
+                # METADATA
+                ThemeKey.METADATA.value: palette.grey_blue,
+                ThemeKey.METADATA_DIM.value: "dim " + palette.grey_blue,
+                ThemeKey.METADATA_BOLD.value: "bold " + palette.grey_blue,
+                # SPINNER_STATUS
+                ThemeKey.SPINNER_STATUS.value: palette.blue,
+                ThemeKey.SPINNER_STATUS_TEXT.value: palette.blue,
+                # STATUS
+                ThemeKey.STATUS_HINT.value: palette.grey2,
+                # REMINDER
+                ThemeKey.REMINDER.value: palette.grey1,
+                ThemeKey.REMINDER_BOLD.value: "bold " + palette.grey1,
+                # TOOL
+                ThemeKey.INVALID_TOOL_CALL_ARGS.value: palette.yellow,
+                ThemeKey.TOOL_NAME.value: "bold",
+                ThemeKey.TOOL_PARAM_FILE_PATH.value: palette.green,
+                ThemeKey.TOOL_PARAM.value: palette.green,
+                ThemeKey.TOOL_PARAM_BOLD.value: "bold " + palette.green,
+                ThemeKey.TOOL_RESULT.value: palette.grey_green,
+                ThemeKey.TOOL_RESULT_BOLD.value: "bold " + palette.grey_green,
+                ThemeKey.TOOL_MARK.value: "bold",
+                ThemeKey.TOOL_APPROVED.value: palette.green + " bold reverse",
+                ThemeKey.TOOL_REJECTED.value: palette.red + " bold reverse",
+                # THINKING
+                ThemeKey.THINKING.value: "italic " + palette.grey2,
+                ThemeKey.THINKING_BOLD.value: "bold italic " + palette.grey1,
+                # TODO_ITEM
+                ThemeKey.TODO_EXPLANATION.value: palette.grey1 + " italic",
+                ThemeKey.TODO_PENDING_MARK.value: "bold " + palette.grey1,
+                ThemeKey.TODO_COMPLETED_MARK.value: "bold " + palette.grey3,
+                ThemeKey.TODO_IN_PROGRESS_MARK.value: "bold " + palette.blue,
+                ThemeKey.TODO_NEW_COMPLETED_MARK.value: "bold " + palette.green,
+                ThemeKey.TODO_PENDING.value: palette.grey1,
+                ThemeKey.TODO_COMPLETED.value: palette.grey3 + " strike",
+                ThemeKey.TODO_IN_PROGRESS.value: "bold " + palette.blue,
+                ThemeKey.TODO_NEW_COMPLETED.value: "bold strike " + palette.green,
+                # WELCOME
+                ThemeKey.WELCOME_HIGHLIGHT_BOLD.value: "bold",
+                ThemeKey.WELCOME_HIGHLIGHT.value: palette.blue,
+                ThemeKey.WELCOME_INFO.value: palette.grey1,
+                # WELCOME DEBUG
+                ThemeKey.WELCOME_DEBUG_TITLE.value: "bold " + palette.red,
+                ThemeKey.WELCOME_DEBUG_BORDER.value: palette.red,
+                # RESUME
+                ThemeKey.RESUME_FLAG.value: "bold reverse " + palette.green,
+                ThemeKey.RESUME_INFO.value: palette.green,
+                # CONFIGURATION DISPLAY
+                ThemeKey.CONFIG_TABLE_HEADER.value: palette.green,
+                ThemeKey.CONFIG_STATUS_OK.value: palette.green,
+                ThemeKey.CONFIG_STATUS_PRIMARY.value: palette.yellow,
+                ThemeKey.CONFIG_ITEM_NAME.value: palette.cyan,
+                ThemeKey.CONFIG_PARAM_LABEL.value: palette.grey1,
+                ThemeKey.CONFIG_PANEL_BORDER.value: palette.grey3,
+            }
+        ),
+        markdown_theme=Theme(
+            styles={
+                "markdown.code": palette.purple,
+                "markdown.code.panel": palette.grey3,
+                "markdown.h1": "bold reverse",
+                "markdown.h1.border": palette.grey3,
+                "markdown.h2.border": palette.grey3,
+                "markdown.h3": "bold " + palette.grey1,
+                "markdown.h4": "bold " + palette.grey2,
+                "markdown.hr": palette.grey3,
+                "markdown.item.bullet": palette.grey2,
+                "markdown.item.number": palette.grey2,
+            }
+        ),
+        thinking_markdown_theme=Theme(
+            styles={
+                "markdown.code": palette.grey1 + " on " + palette.text_background,
+                "markdown.code.panel": palette.grey3,
+                "markdown.h1": "bold reverse",
+                "markdown.h1.border": palette.grey3,
+                "markdown.h2.border": palette.grey3,
+                "markdown.h3": "bold " + palette.grey1,
+                "markdown.h4": "bold " + palette.grey2,
+                "markdown.hr": palette.grey3,
+                "markdown.item.bullet": palette.grey2,
+                "markdown.item.number": palette.grey2,
+                "markdown.strong": "bold italic " + palette.grey1,
+            }
+        ),
+        code_theme=palette.code_theme,
+        sub_agent_colors=[
+            Style(color=palette.cyan),
+            Style(color=palette.green),
+            Style(color=palette.blue),
+            Style(color=palette.purple),
+            Style(color=palette.orange),
+            Style(color=palette.grey_blue),
+            Style(color=palette.red),
+            Style(color=palette.grey1),
+            Style(color=palette.yellow),
+        ],
+    )

klaude_code/ui/terminal/__init__.py

@@ -0,0 +1 @@
+# Terminal utilities

klaude_code/ui/terminal/color.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+import os
+import re
+import select
+import sys
+import termios
+import time
+import tty
+from typing import BinaryIO, Final
+
+from klaude_code.trace import DebugType, log_debug
+
+ST: Final[bytes] = b"\x1b\\"  # ESC \
+BEL: Final[int] = 7
+
+# Match OSC 11 response like: ESC ] 11 ; <payload> BEL/ST
+_OSC_BG_REGEX = re.compile(r"\x1b]11;([^\x07\x1b\\]*)")
+
+# Cache for the last successfully detected terminal background RGB.
+_last_bg_rgb: tuple[int, int, int] | None = None
+
+
+def is_light_terminal_background(timeout: float = 0.5) -> bool | None:
+    """Detect whether the current terminal background is light.
+
+    Returns True for light background, False for dark, and None if detection fails.
+    """
+
+    rgb = _query_color_slot(slot=11, timeout=timeout)
+    if rgb is None:
+        return None
+
+    global _last_bg_rgb
+    _last_bg_rgb = rgb
+
+    r, g, b = rgb
+    # Same luminance formula as codex-rs: 0.299*r + 0.587*g + 0.114*b > 128.0
+    y = 0.299 * float(r) + 0.587 * float(g) + 0.114 * float(b)
+    return y > 128.0
+
+
+def get_last_terminal_background_rgb() -> tuple[int, int, int] | None:
+    """Return the last detected terminal background RGB, if available.
+
+    The value is populated as a side effect of ``is_light_terminal_background``
+    (which queries OSC 11). If detection has not run or failed, this returns
+    None.
+    """
+
+    return _last_bg_rgb
+
+
+def _query_color_slot(slot: int, timeout: float) -> tuple[int, int, int] | None:
+    """Query an OSC color slot (10=fg, 11=bg) and return RGB if possible.
+
+    This sends OSC `ESC ] slot ; ? ESC \\` to the controlling TTY and then
+    reads back the response directly from `/dev/tty`, consuming the bytes so
+    they do not leak into the next shell prompt.
+    """
+
+    if sys.platform == "win32":
+        return None
+
+    term = os.getenv("TERM", "").lower()
+    if term in {"", "dumb"}:
+        return None
+
+    try:
+        with open("/dev/tty", "r+b", buffering=0) as tty_fp:
+            fd = tty_fp.fileno()
+            if not os.isatty(fd):
+                return None
+
+            try:
+                old_attrs = termios.tcgetattr(fd)
+            except Exception as exc:  # termios.error and others
+                log_debug(
+                    f"Failed to get termios attributes for /dev/tty: {exc}",
+                    debug_type=DebugType.TERMINAL,
+                )
+                old_attrs = None
+
+            try:
+                if old_attrs is not None:
+                    # Put tty into cbreak mode so we can read the OSC response bytes immediately.
+                    tty.setcbreak(fd)
+
+                _send_osc_query(tty_fp, slot)
+                raw = _read_osc_response(fd, timeout=timeout)
+            finally:
+                if old_attrs is not None:
+                    try:
+                        termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
+                    except Exception as exc:  # best-effort restore
+                        log_debug(
+                            f"Failed to restore termios attributes for /dev/tty: {exc}",
+                            debug_type=DebugType.TERMINAL,
+                        )
+
+    except OSError as exc:
+        log_debug(
+            f"Failed to open /dev/tty for OSC color query: {exc}",
+            debug_type=DebugType.TERMINAL,
+        )
+        return None
+
+    if raw is None or not raw:
+        return None
+
+    return _parse_osc_color_response(raw)
+
+
+def _send_osc_query(tty_fp: BinaryIO, slot: int) -> None:
+    """Send OSC color query for the given slot to the TTY."""
+
+    seq = f"\x1b]{slot};?\x1b\\".encode("ascii", errors="ignore")
+    try:
+        tty_fp.write(seq)
+        tty_fp.flush()
+    except Exception as exc:
+        log_debug(
+            f"Failed to write OSC color query to /dev/tty: {exc}",
+            debug_type=DebugType.TERMINAL,
+        )
+
+
+def _read_osc_response(fd: int, timeout: float) -> bytes | None:
+    """Read a single OSC response terminated by BEL or ST from the TTY.
+
+    The bytes are consumed from `/dev/tty` so that the terminal's reply does
+    not become visible as part of the next shell prompt.
+    """
+
+    deadline = time.monotonic() + max(timeout, 0.0)
+    buf = bytearray()
+
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            break
+
+        readable, _, _ = select.select([fd], [], [], remaining)
+        if not readable:
+            continue
+
+        try:
+            chunk = os.read(fd, 1024)
+        except Exception as exc:
+            log_debug(
+                f"Failed to read OSC color response from /dev/tty: {exc}",
+                debug_type=DebugType.TERMINAL,
+            )
+            break
+
+        if not chunk:
+            break
+
+        buf.extend(chunk)
+
+        # BEL terminator
+        if BEL in buf:
+            idx = buf.index(BEL)
+            return bytes(buf[: idx + 1])
+
+        # ST terminator (ESC \), may span chunks so search the whole buffer
+        st_index = buf.find(ST)
+        if st_index != -1:
+            return bytes(buf[: st_index + len(ST)])
+
+    if buf:
+        return bytes(buf)
+    return None
+
+
+def _parse_osc_color_response(data: bytes) -> tuple[int, int, int] | None:
+    """Extract an RGB triple from an OSC 11 response payload.
+
+    Supports typical xterm-style responses like `ESC ] 11 ; rgb:rrrr/gggg/bbbb BEL` or
+    `ESC ] 11 ; #rrggbb BEL`.
+    """
+
+    try:
+        text = data.decode("ascii", errors="ignore")
+    except Exception:
+        return None
+
+    match = _OSC_BG_REGEX.search(text)
+    if not match:
+        return None
+
+    payload = match.group(1).strip()
+    # In case the terminal adds extra metadata separated by ';', only use the first field.
+    payload = payload.split(";", 1)[0].strip()
+
+    rgb = _parse_rgb_spec(payload)
+    return rgb
+
+
+def _parse_rgb_spec(spec: str) -> tuple[int, int, int] | None:
+    """Parse a color specification like `rgb:rrrr/gggg/bbbb` or `#rrggbb`."""
+
+    spec = spec.strip()
+
+    # xterm-style rgb:rrrr/gggg/bbbb where each component is 1-4 hex digits
+    if spec.lower().startswith("rgb:"):
+        body = spec[4:]
+        parts = body.split("/")
+        if len(parts) != 3:
+            return None
+        try:
+            r = _scale_hex_component(parts[0])
+            g = _scale_hex_component(parts[1])
+            b = _scale_hex_component(parts[2])
+        except ValueError:
+            return None
+        return r, g, b
+
+    # Simple #rrggbb response
+    if spec.startswith("#") and len(spec) == 7:
+        try:
+            r = int(spec[1:3], 16)
+            g = int(spec[3:5], 16)
+            b = int(spec[5:7], 16)
+        except ValueError:
+            return None
+        return r, g, b
+
+    return None
+
+
+def _scale_hex_component(component: str) -> int:
+    """Scale 1-4 digit hex component to 0-255 range."""
+
+    if not component:
+        raise ValueError("empty component")
+
+    value = int(component, 16)
+    max_value = (16 ** len(component)) - 1
+    if max_value <= 0:
+        raise ValueError("invalid component width")
+
+    scaled = round((value / float(max_value)) * 255.0)
+    return max(0, min(255, int(scaled)))

klaude_code/ui/terminal/control.py

@@ -0,0 +1,147 @@
+import asyncio
+import os
+import select
+import signal
+import sys
+import termios
+import threading
+import time
+import tty
+from collections.abc import Callable, Coroutine
+from types import FrameType
+from typing import Any
+
+from klaude_code.trace import log
+
+
+def start_esc_interrupt_monitor(
+    on_interrupt: Callable[[], Coroutine[Any, Any, None]],
+) -> tuple[threading.Event, asyncio.Task[None]]:
+    """Start a background monitor that triggers a callback on bare ESC.
+
+    This utility watches stdin for a *single* ESC key press (not part of an escape
+    sequence like arrow keys). When detected, it schedules the provided
+    ``on_interrupt`` coroutine on the current event loop.
+
+    Returns a tuple of ``(stop_event, esc_task)``:
+    - ``stop_event`` can be set to request the monitor to stop.
+    - ``esc_task`` is the asyncio task running the monitor thread; callers should
+      ``await`` it during shutdown to restore TTY state safely.
+
+    If stdin is not a TTY or the platform does not support ``termios`` semantics,
+    a no-op task is returned so callers can use the same shutdown code path.
+    """
+
+    stop_event = threading.Event()
+    loop = asyncio.get_running_loop()
+
+    # Fallback for non-interactive or non-POSIX environments.
+    if not sys.stdin.isatty() or os.name != "posix":
+
+        async def _noop() -> None:  # type: ignore[return-type]
+            return None
+
+        return stop_event, asyncio.create_task(_noop())
+
+    def _esc_monitor(stop: threading.Event) -> None:
+        try:
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+        except Exception as exc:  # pragma: no cover - environment dependent
+            log((f"esc monitor init error: {exc}", "r red"))
+            return
+
+        try:
+            tty.setcbreak(fd)
+            while not stop.is_set():
+                rlist, _, _ = select.select([sys.stdin], [], [], 0.05)
+                if not rlist:
+                    continue
+                try:
+                    ch = os.read(fd, 1).decode(errors="ignore")
+                except Exception:
+                    continue
+                if ch != "\x1b":
+                    continue
+
+                # Peek following characters to distinguish bare ESC from sequences.
+                seq = ""
+                r2, _, _ = select.select([sys.stdin], [], [], 0.005)
+                while r2:
+                    try:
+                        seq += os.read(fd, 1).decode(errors="ignore")
+                    except Exception:
+                        break
+                    r2, _, _ = select.select([sys.stdin], [], [], 0.0)
+
+                if seq == "":
+                    try:
+                        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:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)  # type: ignore[name-defined]
+            except Exception:
+                pass
+
+    esc_task: asyncio.Task[None] = asyncio.create_task(asyncio.to_thread(_esc_monitor, stop_event))
+    return stop_event, esc_task
+
+
+def install_sigint_double_press_exit(
+    show_toast: Callable[[], None],
+    hide_progress: Callable[[], None],
+    *,
+    window_seconds: float = 2.0,
+) -> Callable[[], None]:
+    """Install a SIGINT handler that requires a double press to exit.
+
+    Behavior:
+    - First Ctrl+C within ``window_seconds``: calls ``show_toast`` to inform the
+      user that a second press will exit.
+    - Second Ctrl+C within the time window: calls ``hide_progress`` and raises
+      ``KeyboardInterrupt`` to unwind the current asyncio loop.
+
+    Returns a ``restore()`` function that should be called during shutdown to
+    restore the original SIGINT handler.
+    """
+
+    last_sigint_time: float = 0.0
+    original_handler = signal.getsignal(signal.SIGINT)
+
+    def _handler(signum: int, frame: FrameType | None) -> None:
+        nonlocal last_sigint_time
+        now = time.monotonic()
+        if now - last_sigint_time <= window_seconds:
+            # Second press within window: hide progress UI and exit.
+            try:
+                hide_progress()
+            except Exception:
+                pass
+            raise KeyboardInterrupt
+
+        # First press: remember timestamp and show toast.
+        last_sigint_time = now
+        try:
+            show_toast()
+        except Exception:
+            pass
+
+    try:
+        signal.signal(signal.SIGINT, _handler)
+    except Exception:  # pragma: no cover - platform dependent
+        # If installing the handler fails, restore() will be a no-op.
+        return lambda: None
+
+    def restore() -> None:
+        try:
+            signal.signal(signal.SIGINT, original_handler)
+        except Exception:
+            pass
+
+    return restore