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

klaude_code/app/__init__.py

@@ -0,0 +1,12 @@
+"""Application-layer runtime helpers.
+
+This package coordinates core execution (Executor) with frontend displays.
+Terminal-specific rendering and input handling live in `klaude_code.tui`.
+"""
+
+from .runtime import AppInitConfig, run_exec
+
+__all__ = [
+    "AppInitConfig",
+    "run_exec",
+]

klaude_code/app/runtime.py

@@ -0,0 +1,215 @@
+import asyncio
+import contextlib
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import typer
+
+from klaude_code import ui
+from klaude_code.config import Config, load_config
+from klaude_code.core.agent import Agent
+from klaude_code.core.agent_profile import DefaultModelProfileProvider, VanillaModelProfileProvider
+from klaude_code.core.executor import Executor
+from klaude_code.core.manager import build_llm_clients
+from klaude_code.log import DebugType, log, set_debug_logging
+from klaude_code.protocol import events, op
+from klaude_code.protocol.message import UserInputPayload
+from klaude_code.session.session import Session, close_default_store
+
+
+@dataclass
+class AppInitConfig:
+    """Configuration for initializing the application runtime."""
+
+    model: str | None
+    debug: bool
+    vanilla: bool
+    debug_filters: set[DebugType] | None = None
+    stream_json: bool = False
+
+
+@dataclass
+class AppComponents:
+    """Initialized runtime components."""
+
+    config: Config
+    executor: Executor
+    executor_task: asyncio.Task[None]
+    event_queue: asyncio.Queue[events.Event]
+    display: ui.DisplayABC
+    display_task: asyncio.Task[None]
+
+
+async def initialize_app_components(
+    *,
+    init_config: AppInitConfig,
+    display: ui.DisplayABC,
+    on_model_change: Callable[[str], None] | None = None,
+) -> AppComponents:
+    """Initialize LLM clients, executor, and display task."""
+    set_debug_logging(init_config.debug, filters=init_config.debug_filters)
+
+    config = load_config()
+
+    try:
+        llm_clients = build_llm_clients(
+            config,
+            model_override=init_config.model,
+        )
+    except ValueError as exc:
+        if init_config.model:
+            log(
+                (
+                    f"Error: model '{init_config.model}' is not defined in the config",
+                    "red",
+                )
+            )
+            log(("Hint: run `klaude list` to view available models", "yellow"))
+        else:
+            log((f"Error: failed to load the default model configuration: {exc}", "red"))
+        raise typer.Exit(2) from None
+
+    model_profile_provider = VanillaModelProfileProvider() if init_config.vanilla else DefaultModelProfileProvider()
+
+    event_queue: asyncio.Queue[events.Event] = asyncio.Queue()
+
+    executor = Executor(
+        event_queue,
+        llm_clients,
+        model_profile_provider=model_profile_provider,
+        on_model_change=on_model_change,
+    )
+
+    if on_model_change is not None:
+        on_model_change(llm_clients.main.model_name)
+
+    executor_task = asyncio.create_task(executor.start())
+
+    def _drain_background_task_exception(task: asyncio.Task[None], *, label: str) -> None:
+        def _on_done(t: asyncio.Task[None]) -> None:
+            with contextlib.suppress(asyncio.CancelledError):
+                exc = t.exception()
+                if exc is None:
+                    return
+                if isinstance(exc, KeyboardInterrupt):
+                    return
+                log((f"Background task '{label}' failed: {exc}", "red"))
+
+        task.add_done_callback(_on_done)
+
+    _drain_background_task_exception(executor_task, label="executor")
+
+    display_task = asyncio.create_task(display.consume_event_loop(event_queue))
+    _drain_background_task_exception(display_task, label="display")
+
+    return AppComponents(
+        config=config,
+        executor=executor,
+        executor_task=executor_task,
+        event_queue=event_queue,
+        display=display,
+        display_task=display_task,
+    )
+
+
+async def initialize_session(
+    executor: Executor,
+    event_queue: asyncio.Queue[events.Event],
+    session_id: str | None = None,
+) -> str | None:
+    """Initialize a session and return the active session id."""
+    await executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
+    await event_queue.join()
+
+    active_session_id = executor.context.current_session_id()
+    return active_session_id or session_id
+
+
+def backfill_session_model_config(
+    agent: Agent | None,
+    model_override: str | None,
+    default_model: str | None,
+    *,
+    is_new_session: bool,
+) -> None:
+    """Backfill model_config_name and model_thinking on newly created sessions."""
+    if agent is None or agent.session.model_config_name is not None:
+        return
+
+    if model_override is not None:
+        agent.session.model_config_name = model_override
+    elif is_new_session and default_model is not None:
+        agent.session.model_config_name = default_model
+    else:
+        return
+
+    if agent.session.model_thinking is None and agent.profile:
+        agent.session.model_thinking = agent.profile.llm_client.get_llm_config().thinking
+
+
+async def cleanup_app_components(components: AppComponents) -> None:
+    """Clean up all runtime components."""
+    try:
+        await components.executor.stop()
+        components.executor_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await components.executor_task
+        with contextlib.suppress(Exception):
+            await close_default_store()
+
+        await components.event_queue.put(events.EndEvent())
+        await components.display_task
+    finally:
+        # Ensure the terminal cursor is visible even if Rich's spinner did not stop cleanly.
+        with contextlib.suppress(Exception):
+            stream = getattr(sys, "__stdout__", None) or sys.stdout
+            stream.write("\033[?25h")
+            stream.flush()
+
+
+async def handle_keyboard_interrupt(executor: Executor) -> None:
+    """Handle Ctrl+C by logging and sending a global interrupt."""
+    log("Bye!")
+    session_id = executor.context.current_session_id()
+    if session_id and Session.exists(session_id):
+        log(("Resume with:", "dim"), (f"klaude --resume-by-id {session_id}", "green"))
+    with contextlib.suppress(Exception):
+        await executor.submit(op.InterruptOperation(target_session_id=None))
+
+
+async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
+    """Run a single task non-interactively (exec mode)."""
+    from klaude_code.ui.terminal.title import update_terminal_title
+
+    display = ui.create_exec_display(debug=init_config.debug, stream_json=init_config.stream_json)
+    components = await initialize_app_components(
+        init_config=init_config,
+        display=display,
+        on_model_change=update_terminal_title,
+    )
+
+    try:
+        session_id = await initialize_session(components.executor, components.event_queue)
+        backfill_session_model_config(
+            components.executor.context.current_agent,
+            init_config.model,
+            components.config.main_model,
+            is_new_session=True,
+        )
+
+        if session_id is None:
+            raise RuntimeError("No active session")
+
+        op_id = await components.executor.submit(
+            op.RunAgentOperation(
+                session_id=session_id,
+                input=UserInputPayload(text=input_content),
+            )
+        )
+        await components.executor.wait_for(op_id)
+        await components.event_queue.join()
+    except KeyboardInterrupt:
+        await handle_keyboard_interrupt(components.executor)
+    finally:
+        await cleanup_app_components(components)

klaude_code/cli/auth_cmd.py

@@ -6,8 +6,8 @@ import webbrowser
 import typer
 from prompt_toolkit.styles import Style
 
-from klaude_code.trace import log
-from klaude_code.ui.terminal.selector import SelectItem, select_one
+from klaude_code.log import log
+from klaude_code.tui.terminal.selector import SelectItem, select_one
 
 _SELECT_STYLE = Style(
     [

klaude_code/cli/config_cmd.py

@@ -7,7 +7,7 @@ import sys
 import typer
 
 from klaude_code.config import config_path, create_example_config, example_config_path, load_config
-from klaude_code.trace import log
+from klaude_code.log import log
 
 
 def list_models(
@@ -15,7 +15,7 @@ def list_models(
 ) -> None:
     """List all models and providers configuration"""
     from klaude_code.cli.list_model import display_models_and_providers
-    from klaude_code.ui.terminal.color import is_light_terminal_background
+    from klaude_code.tui.terminal.color import is_light_terminal_background
 
     config = load_config()
 

klaude_code/cli/cost_cmd.py

@@ -10,9 +10,9 @@ from rich.box import Box
 from rich.console import Console
 from rich.table import Table
 
-from klaude_code.command.status_cmd import format_cost, format_tokens
 from klaude_code.protocol import model
 from klaude_code.session.codec import decode_jsonl_line
+from klaude_code.tui.command.status_cmd import format_cost, format_tokens
 
 ASCII_HORIZONAL = Box(" -- \n    \n -- \n    \n -- \n -- \n    \n -- \n")
 

klaude_code/cli/debug.py

@@ -1,12 +1,10 @@
 """Debug utilities for CLI."""
 
-import subprocess
-import sys
 from pathlib import Path
 
 import typer
 
-from klaude_code.trace import DebugType, log
+from klaude_code.log import DebugType, log, prepare_debug_log_file
 
 DEBUG_FILTER_HELP = "Comma-separated debug types: " + ", ".join(dt.value for dt in DebugType)
 
@@ -41,38 +39,16 @@ def resolve_debug_settings(flag: bool, raw_filters: str | None) -> tuple[bool, s
     return effective_flag, filters
 
 
-def open_log_file_in_editor(path: Path) -> None:
-    """Open the given log file in a text editor without blocking the CLI."""
+def prepare_debug_logging(debug: bool, debug_filter: str | None) -> tuple[bool, set[DebugType] | None, Path | None]:
+    """Resolve debug settings and prepare log file if enabled.
 
-    editor = ""
+    Returns:
+        A tuple of (debug_enabled, debug_filters, log_path).
+        log_path is None if debugging is disabled.
+    """
 
-    for cmd in ["code", "TextEdit", "notepad"]:
-        try:
-            subprocess.run(["which", cmd], check=True, capture_output=True)
-            editor = cmd
-            break
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            continue
-
-    if not editor:
-        if sys.platform == "darwin":
-            editor = "open"
-        elif sys.platform == "win32":
-            editor = "notepad"
-        else:
-            editor = "xdg-open"
-
-    try:
-        # Detach stdin to prevent the editor from interfering with terminal input state.
-        # Without this, the spawned process inherits the parent's TTY and can disrupt
-        # prompt_toolkit's keyboard handling (e.g., history navigation with up/down keys).
-        subprocess.Popen(
-            [editor, str(path)],
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-    except FileNotFoundError:
-        log((f"Error: Editor '{editor}' not found", "red"))
-    except Exception as exc:  # pragma: no cover - best effort
-        log((f"Warning: failed to open log file in editor: {exc}", "yellow"))
+    debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
+    log_path: Path | None = None
+    if debug_enabled:
+        log_path = prepare_debug_log_file()
+    return debug_enabled, debug_filters, log_path

klaude_code/cli/list_model.py

@@ -9,9 +9,9 @@ from klaude_code.config import Config
 from klaude_code.config.config import ModelConfig, ProviderConfig, parse_env_var_syntax
 from klaude_code.protocol.llm_param import LLMClientProtocol
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
-from klaude_code.ui.rich.quote import Quote
-from klaude_code.ui.rich.theme import ThemeKey, get_theme
-from klaude_code.ui.utils.common import format_model_params
+from klaude_code.tui.components.rich.quote import Quote
+from klaude_code.tui.components.rich.theme import ThemeKey, get_theme
+from klaude_code.ui.common import format_model_params
 
 
 def _get_codex_status_rows() -> list[tuple[Text, Text]]:

klaude_code/cli/main.py

@@ -1,62 +1,17 @@
 import asyncio
-import contextlib
-import os
 import sys
-from pathlib import Path
 
 import typer
 
 from klaude_code.cli.auth_cmd import register_auth_commands
 from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.cost_cmd import register_cost_commands
-from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
+from klaude_code.cli.debug import DEBUG_FILTER_HELP, prepare_debug_logging
 from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.command.resume_cmd import select_session_sync
 from klaude_code.session import Session
-from klaude_code.trace import DebugType, prepare_debug_log_file
-
-
-def set_terminal_title(title: str) -> None:
-    """Set terminal window title using ANSI escape sequence."""
-    # Never write terminal control sequences when stdout is not a TTY (pipes/CI/redirects).
-    # This avoids corrupting machine-readable output (e.g., JSON streaming) and log captures.
-    #
-    # Use the original stdout to bypass prompt_toolkit's `patch_stdout()`. Writing OSC
-    # sequences to the patched stdout can cause them to appear as visible text.
-    stream = getattr(sys, "__stdout__", None) or sys.stdout
-    try:
-        if not stream.isatty():
-            return
-    except Exception:
-        return
-
-    stream.write(f"\033]0;{title}\007")
-    with contextlib.suppress(Exception):
-        stream.flush()
-
-
-def update_terminal_title(model_name: str | None = None) -> None:
-    """Update terminal title with folder name and optional model name."""
-    folder_name = os.path.basename(os.getcwd())
-    if model_name:
-        set_terminal_title(f"{folder_name}: klaude ✳ {model_name}")
-    else:
-        set_terminal_title(f"{folder_name}: klaude")
-
-
-def prepare_debug_logging(debug: bool, debug_filter: str | None) -> tuple[bool, set[DebugType] | None, Path | None]:
-    """Resolve debug settings and prepare log file if debugging is enabled.
-
-    Returns:
-        A tuple of (debug_enabled, debug_filters, log_path).
-        log_path is None if debugging is disabled.
-    """
-    debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
-    log_path: Path | None = None
-    if debug_enabled:
-        log_path = prepare_debug_log_file()
-    return debug_enabled, debug_filters, log_path
+from klaude_code.tui.command.resume_cmd import select_session_sync
+from klaude_code.ui.terminal.title import update_terminal_title
 
 
 def read_input_content(cli_argument: str) -> str | None:
@@ -68,7 +23,7 @@ def read_input_content(cli_argument: str) -> str | None:
     Returns:
         The merged input content, or None if no input was provided.
     """
-    from klaude_code.trace import log
+    from klaude_code.log import log
 
     parts: list[str] = []
 
@@ -169,9 +124,9 @@ def exec_command(
     if merged_input is None:
         raise typer.Exit(1)
 
-    from klaude_code.cli.runtime import AppInitConfig, run_exec
-    from klaude_code.command.model_select import select_model_interactive
+    from klaude_code.app.runtime import AppInitConfig, run_exec
     from klaude_code.config import load_config
+    from klaude_code.tui.command.model_select import select_model_interactive
 
     chosen_model = model
     if model or select_model:
@@ -188,7 +143,7 @@ def exec_command(
             # Save the selection as default
             config.main_model = chosen_model
             from klaude_code.config.config import config_path
-            from klaude_code.trace import log
+            from klaude_code.log import log
 
             asyncio.run(config.save())
             log(f"Saved main_model={chosen_model} to {config_path}", style="cyan")
@@ -199,13 +154,14 @@ def exec_command(
         model=chosen_model,
         debug=debug_enabled,
         vanilla=vanilla,
-        is_exec_mode=True,
         debug_filters=debug_filters,
         stream_json=stream_json,
     )
 
     if log_path:
-        open_log_file_in_editor(log_path)
+        from klaude_code.log import log
+
+        log(f"Debug log: {log_path}", style="dim")
 
     asyncio.run(
         run_exec(
@@ -269,7 +225,7 @@ def main_callback(
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:
-        from klaude_code.trace import log
+        from klaude_code.log import log
 
         resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
         if resume_by_id_value == "":
@@ -304,8 +260,9 @@ def main_callback(
             )
             return
 
-        from klaude_code.cli.runtime import AppInitConfig, run_interactive
-        from klaude_code.command.model_select import select_model_interactive
+        from klaude_code.app.runtime import AppInitConfig
+        from klaude_code.tui.command.model_select import select_model_interactive
+        from klaude_code.tui.runner import run_interactive
 
         update_terminal_title()
 
@@ -333,7 +290,7 @@ def main_callback(
 
         if session_id is not None and chosen_model is None:
             from klaude_code.config import load_config
-            from klaude_code.trace import log
+            from klaude_code.log import log
 
             session_meta = Session.load_meta(session_id)
             cfg = load_config()
@@ -372,7 +329,7 @@ def main_callback(
                 # Save the selection as default
                 cfg.main_model = chosen_model
                 from klaude_code.config.config import config_path
-                from klaude_code.trace import log
+                from klaude_code.log import log
 
                 asyncio.run(cfg.save())
                 log(f"Saved main_model={chosen_model} to {config_path}", style="dim")
@@ -387,7 +344,7 @@ def main_callback(
         )
 
         if log_path:
-            open_log_file_in_editor(log_path)
+            log(f"Debug log: {log_path}", style="dim")
 
         asyncio.run(
             run_interactive(