klaude-code 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

klaude_code/tui/runner.py

@@ -0,0 +1,321 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import sys
+from uuid import uuid4
+
+from klaude_code import ui
+from klaude_code.app.runtime import (
+    AppInitConfig,
+    backfill_session_model_config,
+    cleanup_app_components,
+    handle_keyboard_interrupt,
+    initialize_app_components,
+    initialize_session,
+)
+from klaude_code.config import load_config
+from klaude_code.const import SIGINT_DOUBLE_PRESS_EXIT_TEXT
+from klaude_code.core.executor import Executor
+from klaude_code.log import log
+from klaude_code.protocol import events, llm_param, op
+from klaude_code.protocol.message import UserInputPayload
+from klaude_code.session.session import Session
+from klaude_code.tui.command import (
+    dispatch_command,
+    get_command_info_list,
+    has_interactive_command,
+)
+from klaude_code.tui.display import TUIDisplay
+from klaude_code.tui.input import build_repl_status_snapshot
+from klaude_code.tui.input.prompt_toolkit import PromptToolkitInput, REPLStatusSnapshot
+from klaude_code.tui.terminal.color import is_light_terminal_background
+from klaude_code.tui.terminal.control import install_sigint_double_press_exit, start_esc_interrupt_monitor
+from klaude_code.ui.terminal.title import update_terminal_title
+from klaude_code.update import get_update_message
+
+
+async def submit_user_input_payload(
+    *,
+    executor: Executor,
+    event_queue: asyncio.Queue[events.Event],
+    user_input: UserInputPayload,
+    session_id: str | None,
+) -> str | None:
+    """Parse/dispatch a user input payload (TUI commands) and submit operations.
+
+    This function is TUI-only: it supports slash command parsing and interactive prompts.
+
+    Returns a submission id that should be awaited, or None if there is nothing
+    to wait for (e.g. commands that only emit events).
+    """
+
+    sid = session_id or executor.context.current_session_id()
+    if sid is None:
+        raise RuntimeError("No active session")
+
+    agent = executor.context.current_agent
+    if agent is None or agent.session.id != sid:
+        await executor.submit_and_wait(op.InitAgentOperation(session_id=sid))
+        agent = executor.context.current_agent
+
+    if agent is None:
+        raise RuntimeError("Failed to initialize agent")
+
+    submission_id = uuid4().hex
+
+    # Render the raw user input in the TUI even when it resolves to an event-only command.
+    await executor.context.emit_event(
+        events.UserMessageEvent(content=user_input.text, session_id=sid, images=user_input.images)
+    )
+
+    cmd_result = await dispatch_command(user_input, agent, submission_id=submission_id)
+    operations: list[op.Operation] = list(cmd_result.operations or [])
+
+    run_ops = [candidate for candidate in operations if isinstance(candidate, op.RunAgentOperation)]
+    if len(run_ops) > 1:
+        raise ValueError("Multiple RunAgentOperation results are not supported")
+
+    for run_op in run_ops:
+        run_op.persist_user_input = cmd_result.persist_user_input
+        run_op.emit_user_message_event = False
+
+    if cmd_result.events:
+        for evt in cmd_result.events:
+            if cmd_result.persist_events and isinstance(evt, events.DeveloperMessageEvent):
+                agent.session.append_history([evt.item])
+            await executor.context.emit_event(evt)
+
+    submitted_ids: list[str] = []
+    for operation_item in operations:
+        submitted_ids.append(await executor.submit(operation_item))
+
+    if not submitted_ids:
+        # Ensure event-only commands are fully rendered before showing the next prompt.
+        await event_queue.join()
+        return None
+
+    if run_ops:
+        return run_ops[0].id
+    return submitted_ids[-1]
+
+
+async def run_interactive(init_config: AppInitConfig, session_id: str | None = None) -> None:
+    """Run the interactive REPL (TUI).
+
+    If session_id is None, a new session is created.
+    If session_id is provided, attempts to resume that session.
+    """
+
+    update_terminal_title()
+
+    cfg = load_config()
+    theme: str | None = cfg.theme
+    if theme is None:
+        detected = is_light_terminal_background()
+        if detected is True:
+            theme = "light"
+        elif detected is False:
+            theme = "dark"
+
+    display: ui.DisplayABC = TUIDisplay(theme=theme)
+    if init_config.debug:
+        display = ui.DebugEventDisplay(display)
+
+    components = await initialize_app_components(
+        init_config=init_config,
+        display=display,
+        on_model_change=update_terminal_title,
+    )
+
+    def _status_provider() -> REPLStatusSnapshot:
+        update_message = get_update_message()
+        return build_repl_status_snapshot(update_message)
+
+    def _stop_rich_bottom_ui() -> None:
+        active_display = components.display
+        if isinstance(active_display, TUIDisplay):
+            active_display.hide_progress_ui()
+        elif (
+            isinstance(active_display, ui.DebugEventDisplay)
+            and active_display.wrapped_display
+            and isinstance(active_display.wrapped_display, TUIDisplay)
+        ):
+            active_display.wrapped_display.hide_progress_ui()
+
+    is_light_background: bool | None = None
+    if theme == "light":
+        is_light_background = True
+    elif theme == "dark":
+        is_light_background = False
+
+    def _get_active_session_id() -> str | None:
+        """Get the current active session ID dynamically.
+
+        This is necessary because /clear creates a new session with a different id.
+        """
+
+        return components.executor.context.current_session_id()
+
+    async def _change_model_from_prompt(model_name: str) -> None:
+        sid = _get_active_session_id()
+        if not sid:
+            return
+        await components.executor.submit_and_wait(
+            op.ChangeModelOperation(
+                session_id=sid,
+                model_name=model_name,
+                save_as_default=False,
+                defer_thinking_selection=True,
+                emit_welcome_event=True,
+                emit_switch_message=False,
+            )
+        )
+
+    def _get_current_llm_config() -> llm_param.LLMConfigParameter | None:
+        agent = components.executor.context.current_agent
+        if agent is None:
+            return None
+        return agent.profile.llm_client.get_llm_config()
+
+    async def _change_thinking_from_prompt(thinking: llm_param.Thinking) -> None:
+        sid = _get_active_session_id()
+        if not sid:
+            return
+        await components.executor.submit_and_wait(
+            op.ChangeThinkingOperation(
+                session_id=sid,
+                thinking=thinking,
+                emit_welcome_event=True,
+                emit_switch_message=False,
+            )
+        )
+
+    input_provider: ui.InputProviderABC = PromptToolkitInput(
+        status_provider=_status_provider,
+        pre_prompt=_stop_rich_bottom_ui,
+        is_light_background=is_light_background,
+        get_current_model_config_name=lambda: (
+            components.executor.context.current_agent.session.model_config_name
+            if components.executor.context.current_agent is not None
+            else None
+        ),
+        on_change_model=_change_model_from_prompt,
+        get_current_llm_config=_get_current_llm_config,
+        on_change_thinking=_change_thinking_from_prompt,
+        command_info_provider=get_command_info_list,
+    )
+
+    loop = asyncio.get_running_loop()
+
+    def _get_tui_display() -> TUIDisplay | None:
+        active_display = components.display
+        if isinstance(active_display, TUIDisplay):
+            return active_display
+        if (
+            isinstance(active_display, ui.DebugEventDisplay)
+            and active_display.wrapped_display
+            and isinstance(active_display.wrapped_display, TUIDisplay)
+        ):
+            return active_display.wrapped_display
+        return None
+
+    @contextlib.contextmanager
+    def _double_ctrl_c_to_exit_while_running(*, window_seconds: float = 2.0):
+        """Require double Ctrl+C to exit while waiting for task completion."""
+
+        def _show_toast_once() -> None:
+            def _emit() -> None:
+                tui_display = _get_tui_display()
+                if tui_display is not None:
+                    with contextlib.suppress(Exception):
+                        tui_display.show_sigint_exit_toast(window_seconds=window_seconds)
+                    return
+                print(SIGINT_DOUBLE_PRESS_EXIT_TEXT, file=sys.stderr)
+
+            with contextlib.suppress(Exception):
+                loop.call_soon_threadsafe(_emit)
+                return
+            _emit()
+
+        def _hide_progress() -> None:
+            def _emit() -> None:
+                tui_display = _get_tui_display()
+                if tui_display is None:
+                    return
+                with contextlib.suppress(Exception):
+                    tui_display.hide_progress_ui()
+
+            with contextlib.suppress(Exception):
+                loop.call_soon_threadsafe(_emit)
+
+        restore_sigint = install_sigint_double_press_exit(
+            _show_toast_once,
+            _hide_progress,
+            window_seconds=window_seconds,
+        )
+        try:
+            yield
+        finally:
+            with contextlib.suppress(Exception):
+                restore_sigint()
+
+    exit_hint_printed = False
+
+    try:
+        await initialize_session(components.executor, components.event_queue, session_id=session_id)
+        backfill_session_model_config(
+            components.executor.context.current_agent,
+            init_config.model,
+            components.config.main_model,
+            is_new_session=session_id is None,
+        )
+
+        await input_provider.start()
+        async for user_input in input_provider.iter_inputs():
+            if user_input.text.strip().lower() in {"exit", ":q", "quit"}:
+                break
+            if user_input.text.strip() == "":
+                continue
+
+            active_session_id = _get_active_session_id()
+            is_interactive = has_interactive_command(user_input.text)
+
+            wait_id = await submit_user_input_payload(
+                executor=components.executor,
+                event_queue=components.event_queue,
+                user_input=user_input,
+                session_id=active_session_id,
+            )
+
+            if wait_id is None:
+                continue
+
+            if is_interactive:
+                with _double_ctrl_c_to_exit_while_running():
+                    await components.executor.wait_for(wait_id)
+                continue
+
+            async def _on_esc_interrupt() -> None:
+                await components.executor.submit(op.InterruptOperation(target_session_id=_get_active_session_id()))
+
+            stop_event, esc_task = start_esc_interrupt_monitor(_on_esc_interrupt)
+            try:
+                with _double_ctrl_c_to_exit_while_running():
+                    await components.executor.wait_for(wait_id)
+            finally:
+                stop_event.set()
+                with contextlib.suppress(Exception):
+                    await esc_task
+
+    except KeyboardInterrupt:
+        await handle_keyboard_interrupt(components.executor)
+        exit_hint_printed = True
+    finally:
+        await cleanup_app_components(components)
+
+        if not exit_hint_printed:
+            active_session_id = components.executor.context.current_session_id()
+            if active_session_id and Session.exists(active_session_id):
+                log(f"Session ID: {active_session_id}")
+                log(f"Resume with: klaude --resume-by-id {active_session_id}")

klaude_code/tui/terminal/__init__.py

@@ -0,0 +1,56 @@
+# Terminal utilities
+import os
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def supports_osc8_hyperlinks() -> bool:
+    """Check if the current terminal supports OSC 8 hyperlinks.
+
+    Based on known terminal support. Returns False for unknown terminals.
+    """
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    term = os.environ.get("TERM", "").lower()
+
+    # Known terminals that do NOT support OSC 8
+    unsupported = ("warp", "apple_terminal")
+    if any(t in term_program for t in unsupported):
+        return False
+
+    # Known terminals that support OSC 8
+    supported = (
+        "iterm.app",
+        "ghostty",
+        "wezterm",
+        "kitty",
+        "alacritty",
+        "hyper",
+        "contour",
+        "vscode",
+    )
+    if any(t in term_program for t in supported):
+        return True
+
+    # Kitty sets TERM to xterm-kitty
+    if "kitty" in term:
+        return True
+
+    # Ghostty sets TERM to xterm-ghostty
+    if "ghostty" in term:
+        return True
+
+    # Windows Terminal
+    if os.environ.get("WT_SESSION"):
+        return True
+
+    # VTE-based terminals (GNOME Terminal, etc.) version 0.50+
+    vte_version = os.environ.get("VTE_VERSION", "")
+    if vte_version:
+        try:
+            if int(vte_version) >= 5000:
+                return True
+        except ValueError:
+            pass
+
+    # Default to False for unknown terminals
+    return False

klaude_code/{ui → tui}/terminal/color.py

@@ -9,7 +9,7 @@ import time
 import tty
 from typing import BinaryIO, Final
 
-from klaude_code.trace import DebugType, log_debug
+from klaude_code.log import DebugType, log_debug
 
 ST: Final[bytes] = b"\x1b\\"  # ESC \
 BEL: Final[int] = 7

klaude_code/{ui → tui}/terminal/control.py

@@ -12,7 +12,7 @@ from collections.abc import Callable, Coroutine
 from types import FrameType
 from typing import Any
 
-from klaude_code.trace import log
+from klaude_code.log import log
 
 
 def start_esc_interrupt_monitor(

klaude_code/{ui → tui}/terminal/notifier.py

@@ -8,7 +8,7 @@ from enum import Enum
 from typing import TextIO, cast
 
 from klaude_code.const import NOTIFY_COMPACT_LIMIT
-from klaude_code.trace import DebugType, log_debug
+from klaude_code.log import DebugType, log_debug
 
 # Environment variable for tmux test signal channel
 TMUX_SIGNAL_ENV = "KLAUDE_TEST_SIGNAL"

klaude_code/{ui → tui}/terminal/selector.py

@@ -238,9 +238,31 @@ def _build_choices_tokens[T](
     return tokens
 
 
-def _build_rounded_frame(body: Container) -> HSplit:
+def _build_rounded_frame(body: Container, *, padding_x: int = 0, padding_y: int = 0) -> HSplit:
     """Build a rounded border frame around the given container."""
     border = partial(Window, style="class:frame.border", height=1)
+    pad = partial(Window, style="class:frame", char=" ", always_hide_cursor=Always())
+
+    inner: Container = body
+    if padding_y > 0:
+        inner = HSplit(
+            [
+                pad(height=padding_y, dont_extend_height=Always()),
+                body,
+                pad(height=padding_y, dont_extend_height=Always()),
+            ],
+            padding=0,
+            style="class:frame",
+        )
+
+    middle_children: list[Container] = [border(width=1, char="│")]
+    if padding_x > 0:
+        middle_children.append(pad(width=padding_x))
+    middle_children.append(inner)
+    if padding_x > 0:
+        middle_children.append(pad(width=padding_x))
+    middle_children.append(border(width=1, char="│"))
+
     top = VSplit(
         [
             border(width=1, char="╭"),
@@ -250,14 +272,7 @@ def _build_rounded_frame(body: Container) -> HSplit:
         height=1,
         padding=0,
     )
-    middle = VSplit(
-        [
-            border(width=1, char="│"),
-            body,
-            border(width=1, char="│"),
-        ],
-        padding=0,
-    )
+    middle = VSplit(middle_children, padding=0)
     bottom = VSplit(
         [
             border(width=1, char="╰"),
@@ -273,6 +288,8 @@ def _build_rounded_frame(body: Container) -> HSplit:
 def _build_search_container(
     search_buffer: Buffer,
     search_placeholder: str,
+    *,
+    frame: bool = True,
 ) -> tuple[Window, Container]:
     """Build the search input container with placeholder."""
     placeholder_text = f"{search_placeholder} · ↑↓ to select · esc to quit"
@@ -303,8 +320,10 @@ def _build_search_container(
         content=input_window,
         floats=[Float(content=placeholder_window, top=0, left=0)],
     )
-    framed = _build_rounded_frame(VSplit([search_prefix_window, search_input_container], padding=0))
-    return input_window, framed
+    search_row: Container = VSplit([search_prefix_window, search_input_container], padding=0)
+    if frame:
+        return input_window, _build_rounded_frame(search_row)
+    return input_window, search_row
 
 
 # ---------------------------------------------------------------------------
@@ -436,7 +455,7 @@ def select_one[T](
 
     base_style = Style(
         [
-            ("frame.border", "fg:ansibrightblack"),
+            ("frame.border", "fg:ansibrightblack dim"),
             ("frame.label", "fg:ansibrightblack italic"),
             ("search_prefix", "fg:ansibrightblack"),
             ("search_placeholder", "fg:ansibrightblack italic"),
@@ -619,17 +638,17 @@ class SelectOverlay[T]:
         search_container: Container | None = None
         if self._use_search_filter and self._search_buffer is not None:
             self._search_input_window, search_container = _build_search_container(
-                self._search_buffer, self._search_placeholder
+                self._search_buffer,
+                self._search_placeholder,
+                frame=False,
             )
 
         root_children: list[Container] = [header_window, spacer_window, list_window]
         if search_container is not None:
             root_children.append(search_container)
 
-        return ConditionalContainer(
-            content=HSplit(root_children, padding=0),
-            filter=Condition(lambda: self._is_open),
-        )
+        framed_content = _build_rounded_frame(HSplit(root_children, padding=0), padding_x=1)
+        return ConditionalContainer(content=framed_content, filter=Condition(lambda: self._is_open))
 
     @property
     def is_open(self) -> bool:

klaude_code/ui/__init__.py

@@ -1,56 +1,16 @@
-"""
-UI Module - Display and Input Abstractions for klaude-code
-
-This module provides the UI layer for klaude-code, including display modes
-and input providers. The UI is designed around three main concepts:
+"""UI interfaces and lightweight displays.
 
-Display Modes:
-- REPLDisplay: Interactive terminal mode with Rich rendering, spinners, and live updates
-- ExecDisplay: Non-interactive exec mode that only outputs task results
-- DebugEventDisplay: Decorator that logs all events for debugging purposes
+This package intentionally contains only frontend-agnostic interfaces and
+minimal display implementations.
 
-Input Providers:
-- PromptToolkitInput: Interactive input with prompt-toolkit (completions, keybindings)
-
-Factory Functions:
-- create_default_display(): Creates the appropriate display for interactive mode
-- create_exec_display(): Creates the appropriate display for exec mode
+Terminal (Rich/prompt-toolkit) UI lives in `klaude_code.tui`.
 """
 
 # --- Abstract Interfaces ---
 from .core.display import DisplayABC
 from .core.input import InputProviderABC
-from .modes.debug.display import DebugEventDisplay
-from .modes.exec.display import ExecDisplay, StreamJsonDisplay
-
-# --- Display Mode Implementations ---
-from .modes.repl.display import REPLDisplay
-
-# --- Input Implementations ---
-from .modes.repl.input_prompt_toolkit import PromptToolkitInput
-from .terminal.notifier import TerminalNotifier
-
-
-def create_default_display(
-    debug: bool = False,
-    theme: str | None = None,
-    notifier: TerminalNotifier | None = None,
-) -> DisplayABC:
-    """
-    Create the default display for interactive REPL mode.
-
-    Args:
-        debug: If True, wrap the display with DebugEventDisplay to log all events.
-        theme: Optional theme name ("light" or "dark") for syntax highlighting.
-        notifier: Optional terminal notifier for desktop notifications.
-
-    Returns:
-        A DisplayABC implementation suitable for interactive use.
-    """
-    repl_display = REPLDisplay(theme=theme, notifier=notifier)
-    if debug:
-        return DebugEventDisplay(repl_display)
-    return repl_display
+from .debug_mode import DebugEventDisplay
+from .exec_mode import ExecDisplay, StreamJsonDisplay
 
 
 def create_exec_display(debug: bool = False, stream_json: bool = False) -> DisplayABC:
@@ -77,10 +37,6 @@ __all__ = [
     "DisplayABC",
     "ExecDisplay",
     "InputProviderABC",
-    "PromptToolkitInput",
-    "REPLDisplay",
     "StreamJsonDisplay",
-    "TerminalNotifier",
-    "create_default_display",
     "create_exec_display",
 ]

klaude_code/ui/core/display.py

@@ -1,8 +1,8 @@
 from abc import ABC, abstractmethod
 from asyncio import Queue
 
+from klaude_code.log import log
 from klaude_code.protocol import events
-from klaude_code.trace import log
 
 
 class DisplayABC(ABC):
@@ -11,7 +11,7 @@ class DisplayABC(ABC):
 
     A Display is responsible for rendering events from the executor to the user.
     Implementations can range from simple text output (ExecDisplay) to rich
-    interactive terminals (REPLDisplay) or debugging wrappers (DebugEventDisplay).
+    interactive terminals (TUIDisplay) or debugging wrappers (DebugEventDisplay).
 
     Lifecycle:
         1. start() is called once before any events are consumed.
@@ -19,7 +19,7 @@ class DisplayABC(ABC):
         3. stop() is called once when the display is shutting down (after EndEvent).
 
     Typical Usage:
-        display = create_default_display()
+        # See klaude_code.tui.display.TUIDisplay for the interactive terminal frontend.
         await display.consume_event_loop(event_queue)
 
         # Or manually:

klaude_code/ui/core/input.py

@@ -20,7 +20,8 @@ class InputProviderABC(ABC):
         3. stop() is called once when input collection is complete.
 
     Typical Usage:
-        input_provider = PromptToolkitInput(status_provider=my_status_fn)
+        # For the interactive terminal input implementation, see
+        # klaude_code.tui.input.prompt_toolkit.PromptToolkitInput.
         await input_provider.start()
         try:
             async for user_input in input_provider.iter_inputs():

klaude_code/ui/{modes/debug/display.py → debug_mode.py}

@@ -2,8 +2,8 @@ import os
 from typing import override
 
 from klaude_code.const import DEFAULT_DEBUG_LOG_FILE
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import events
-from klaude_code.trace import DebugType, log_debug
 from klaude_code.ui.core.display import DisplayABC
 
 

klaude_code/ui/{modes/exec/display.py → exec_mode.py}

@@ -3,7 +3,6 @@ from typing import override
 
 from klaude_code.protocol import events
 from klaude_code.ui.core.display import DisplayABC
-from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 
 
 class ExecDisplay(DisplayABC):
@@ -14,12 +13,10 @@ class ExecDisplay(DisplayABC):
         """Only handle TaskFinishEvent."""
         match event:
             case events.TaskStartEvent():
-                emit_osc94(OSC94States.INDETERMINATE)
+                pass
             case events.ErrorEvent() as e:
-                emit_osc94(OSC94States.HIDDEN)
                 print(f"Error: {e.error_message}")
             case events.TaskFinishEvent() as e:
-                emit_osc94(OSC94States.HIDDEN)
                 # Print the task result when task finishes
                 if e.task_result.strip():
                     print(e.task_result)