klaude-code 1.4.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

klaude_code/cli/main.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import os
 import sys
 from pathlib import Path
@@ -10,18 +11,81 @@ from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 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.session import Session, resume_select_session
+from klaude_code.session import Session, build_session_select_options
 from klaude_code.trace import DebugType, prepare_debug_log_file
 
 
+def select_session_interactive() -> str | None:
+    """Interactive session selection for CLI.
+
+    Returns:
+        Selected session ID, or None if no session selected or no sessions exist.
+    """
+    from klaude_code.trace import log
+
+    options = build_session_select_options()
+    if not options:
+        log("No sessions found for this project.")
+        return None
+
+    from prompt_toolkit.styles import Style
+
+    from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+    items: list[SelectItem[str]] = []
+    for opt in options:
+        title = [
+            ("class:msg", f"{opt.first_user_message}\n"),
+            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
+        ]
+        items.append(
+            SelectItem(
+                title=title,
+                value=opt.session_id,
+                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
+            )
+        )
+
+    try:
+        return select_one(
+            message="Select a session to resume:",
+            items=items,
+            pointer="→",
+            style=Style(
+                [
+                    ("msg", ""),
+                    ("meta", "fg:ansibrightblack"),
+                    ("pointer", "bold fg:ansigreen"),
+                    ("highlighted", "fg:ansigreen"),
+                    ("search_prefix", "fg:ansibrightblack"),
+                    ("search_success", "noinherit fg:ansigreen"),
+                    ("search_none", "noinherit fg:ansired"),
+                    ("question", "bold"),
+                    ("text", ""),
+                ]
+            ),
+        )
+    except KeyboardInterrupt:
+        return None
+
+
 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.
-    if not sys.stdout.isatty():
+    #
+    # 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
-    sys.stdout.write(f"\033]0;{title}\007")
-    sys.stdout.flush()
+
+    stream.write(f"\033]0;{title}\007")
+    with contextlib.suppress(Exception):
+        stream.flush()
 
 
 def update_terminal_title(model_name: str | None = None) -> None:
@@ -147,19 +211,19 @@ def exec_command(
         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.config import load_config
-    from klaude_code.config.select_model import select_model_from_config
 
     chosen_model = model
     if model or select_model:
-        chosen_model = select_model_from_config(preferred=model)
+        chosen_model = select_model_interactive(preferred=model)
         if chosen_model is None:
             raise typer.Exit(1)
     else:
         # Check if main_model is configured; if not, trigger interactive selection
         config = load_config()
         if config.main_model is None:
-            chosen_model = select_model_from_config()
+            chosen_model = select_model_interactive()
             if chosen_model is None:
                 raise typer.Exit(1)
             # Save the selection as default
@@ -282,13 +346,13 @@ def main_callback(
             return
 
         from klaude_code.cli.runtime import AppInitConfig, run_interactive
-        from klaude_code.config.select_model import select_model_from_config
+        from klaude_code.command.model_select import select_model_interactive
 
         update_terminal_title()
 
         chosen_model = model
         if model or select_model:
-            chosen_model = select_model_from_config(preferred=model)
+            chosen_model = select_model_interactive(preferred=model)
             if chosen_model is None:
                 return
 
@@ -297,7 +361,7 @@ def main_callback(
         session_id: str | None = None
 
         if resume:
-            session_id = resume_select_session()
+            session_id = select_session_interactive()
             if session_id is None:
                 return
         # If user didn't pick, allow fallback to --continue
@@ -343,7 +407,7 @@ def main_callback(
 
             cfg = load_config()
             if cfg.main_model is None:
-                chosen_model = select_model_from_config()
+                chosen_model = select_model_interactive()
                 if chosen_model is None:
                     raise typer.Exit(1)
                 # Save the selection as default

klaude_code/cli/runtime.py

@@ -3,6 +3,7 @@ import contextlib
 import sys
 from dataclasses import dataclass
 from typing import Any, Protocol
+from uuid import uuid4
 
 import typer
 from rich.text import Text
@@ -10,12 +11,13 @@ from rich.text import Text
 from klaude_code import ui
 from klaude_code.cli.main import update_terminal_title
 from klaude_code.cli.self_update import get_update_message
-from klaude_code.command import has_interactive_command
+from klaude_code.command import dispatch_command, get_command_info_list, has_interactive_command, is_slash_command_name
 from klaude_code.config import Config, load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, VanillaModelProfileProvider
 from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
-from klaude_code.protocol import events, op
+from klaude_code.protocol import events, llm_param, op
+from klaude_code.protocol import model as protocol_model
 from klaude_code.protocol.model import UserInputPayload
 from klaude_code.session.session import Session, close_default_store
 from klaude_code.trace import DebugType, log, set_debug_logging
@@ -57,6 +59,79 @@ class AppComponents:
     theme: str | None
 
 
+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 and submit resulting operations.
+
+    The UI/CLI layer owns slash command parsing and any interactive prompts.
+    Core only executes concrete operations.
+
+    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
+
+    await executor.context.emit_event(
+        events.UserMessageEvent(content=user_input.text, session_id=sid, images=user_input.images)
+    )
+
+    result = await dispatch_command(user_input, agent, submission_id=submission_id)
+    operations: list[op.Operation] = list(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")
+
+    persisted_user_input = run_ops[0].input if run_ops else user_input
+
+    if result.persist_user_input:
+        agent.session.append_history(
+            [
+                protocol_model.UserMessageItem(
+                    content=persisted_user_input.text,
+                    images=persisted_user_input.images,
+                )
+            ]
+        )
+
+    if result.events:
+        for evt in result.events:
+            if 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 initialize_app_components(init_config: AppInitConfig) -> AppComponents:
     """Initialize all application components (LLM clients, executor, UI)."""
     set_debug_logging(init_config.debug, filters=init_config.debug_filters)
@@ -232,10 +307,15 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
             is_new_session=True,
         )
 
-        # Submit the input content directly
-        await components.executor.submit_and_wait(
-            op.UserInputOperation(input=UserInputPayload(text=input_content), session_id=session_id)
+        wait_id = await submit_user_input_payload(
+            executor=components.executor,
+            event_queue=components.event_queue,
+            user_input=UserInputPayload(text=input_content),
+            session_id=session_id,
         )
+        if wait_id is not None:
+            await components.executor.wait_for(wait_id)
+            await components.event_queue.join()
 
     except KeyboardInterrupt:
         await _handle_keyboard_interrupt(components.executor)
@@ -281,10 +361,66 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
     elif components.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 command 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=False,
+                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=False,
+                emit_switch_message=False,
+            )
+        )
+
+    # Inject command name checker into user_input renderer (for slash command highlighting)
+    from klaude_code.ui.renderers.user_input import set_command_name_checker
+
+    set_command_name_checker(is_slash_command_name)
+
     input_provider: ui.InputProviderABC = ui.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,
     )
 
     # --- Custom Ctrl+C handler: double-press within 2s to exit, single press shows toast ---
@@ -330,13 +466,6 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             is_new_session=session_id is None,
         )
 
-        def _get_active_session_id() -> str | None:
-            """Get the current active session ID dynamically.
-
-            This is necessary because /clear command creates a new session with a different ID.
-            """
-            return components.executor.context.current_session_id()
-
         # Input
         await input_provider.start()
         async for user_input in input_provider.iter_inputs():
@@ -345,30 +474,38 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 break
             elif user_input.text.strip() == "":
                 continue
-            # Submit user input operation - directly use the payload from iter_inputs
-            # Use dynamic session_id lookup to handle /clear creating new sessions
+            # Use dynamic session_id lookup to handle /clear creating new sessions.
+            # UI/CLI parses commands and submits concrete operations; core executes operations.
             active_session_id = _get_active_session_id()
-            submission_id = await components.executor.submit(
-                op.UserInputOperation(input=user_input, session_id=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 it's an interactive command (e.g., /model), avoid starting the ESC monitor
-            # to prevent TTY conflicts with interactive prompt_toolkit UIs.
-            if has_interactive_command(user_input.text):
-                await components.executor.wait_for(submission_id)
-            else:
-                # Esc monitor for long-running, interruptible operations
-                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)
-                # Wait for this specific task to complete before accepting next input
-                try:
-                    await components.executor.wait_for(submission_id)
-                finally:
-                    # Stop ESC monitor and wait for it to finish cleaning up TTY
-                    stop_event.set()
-                    with contextlib.suppress(Exception):
-                        await esc_task
+
+            if wait_id is None:
+                continue
+
+            if is_interactive:
+                await components.executor.wait_for(wait_id)
+                continue
+
+            # Esc monitor for long-running, interruptible operations
+            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)
+            # Wait for this specific task to complete before accepting next input
+            try:
+                await components.executor.wait_for(wait_id)
+            finally:
+                # Stop ESC monitor and wait for it to finish cleaning up TTY
+                stop_event.set()
+                with contextlib.suppress(Exception):
+                    await esc_task
 
     except KeyboardInterrupt:
         await _handle_keyboard_interrupt(components.executor)

klaude_code/command/__init__.py

@@ -1,6 +1,8 @@
 from .command_abc import CommandABC, CommandResult
 from .registry import (
     dispatch_command,
+    get_command_info_list,
+    get_command_names,
     get_commands,
     has_interactive_command,
     is_slash_command_name,
@@ -94,6 +96,8 @@ __all__ = [
     "CommandResult",
     "dispatch_command",
     "ensure_commands_loaded",
+    "get_command_info_list",
+    "get_command_names",
     "get_commands",
     "has_interactive_command",
     "is_slash_command_name",

klaude_code/command/help_cmd.py

@@ -22,8 +22,9 @@ Usage:
   [b]esc[/b] to interrupt agent task
   [b]shift-enter[/b] or [b]ctrl-j[/b] for new line
   [b]ctrl-v[/b] for pasting image
+  [b]ctrl-l[/b] to switch model
+  [b]ctrl-t[/b] to switch thinking level
   [b]--continue[/b] or [b]--resume[/b] to continue an old session
-  [b]--select-model[/b] to switch model
 
 Available slash commands:"""
         ]

klaude_code/command/model_cmd.py

@@ -3,7 +3,7 @@ import asyncio
 from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.config.select_model import select_model_from_config
+from klaude_code.command.model_select import select_model_interactive
 from klaude_code.protocol import commands, events, model, op
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
@@ -13,7 +13,7 @@ SELECT_STYLE = Style(
         ("pointer", "ansigreen"),
         ("highlighted", "ansigreen"),
         ("text", "ansibrightblack"),
-        ("question", ""),
+        ("question", "bold"),
     ]
 )
 
@@ -29,8 +29,6 @@ def _confirm_change_default_model_sync(selected_model: str) -> bool:
     ]
 
     try:
-        # Add a blank line between the model selector and this confirmation prompt.
-        print("")
         result = select_one(
             message=f"Save '{selected_model}' as default model?",
             items=items,
@@ -68,7 +66,7 @@ class ModelCommand(CommandABC):
         return "model name"
 
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
-        selected_model = await asyncio.to_thread(select_model_from_config, preferred=user_input.text)
+        selected_model = await asyncio.to_thread(select_model_interactive, preferred=user_input.text)
 
         current_model = agent.profile.llm_client.model_name if agent.profile else None
         if selected_model is None or selected_model == current_model:

klaude_code/command/model_select.py

@@ -0,0 +1,84 @@
+"""Interactive model selection for CLI."""
+
+import sys
+
+from klaude_code.config.config import load_config
+from klaude_code.config.select_model import match_model_from_config
+from klaude_code.trace import log
+
+
+def select_model_interactive(preferred: str | None = None) -> str | None:
+    """Interactive single-choice model selector.
+
+    This function combines matching logic with interactive UI selection.
+    For CLI usage.
+
+    If preferred is provided:
+    - Exact match: return immediately
+    - Single partial match (case-insensitive): return immediately
+    - Otherwise: fall through to interactive selection
+    """
+    result = match_model_from_config(preferred)
+
+    if result.error_message:
+        return None
+
+    if result.matched_model:
+        return result.matched_model
+
+    # Non-interactive environments (CI/pipes) should never enter an interactive prompt.
+    # If we couldn't resolve to a single model deterministically above, fail with a clear hint.
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        log(("Error: cannot use interactive model selection without a TTY", "red"))
+        log(("Hint: pass --model <config-name> or set main_model in ~/.klaude/klaude-config.yaml", "yellow"))
+        if preferred:
+            log((f"Hint: '{preferred}' did not resolve to a single configured model", "yellow"))
+        return None
+
+    # Interactive selection
+    from prompt_toolkit.styles import Style
+
+    from klaude_code.ui.terminal.selector import build_model_select_items, select_one
+
+    config = load_config()
+    names = [m.model_name for m in result.filtered_models]
+
+    try:
+        items = build_model_select_items(result.filtered_models)
+
+        message = f"Select a model (filtered by '{result.filter_hint}'):" if result.filter_hint else "Select a model:"
+        selected = select_one(
+            message=message,
+            items=items,
+            pointer="->",
+            use_search_filter=True,
+            initial_value=config.main_model,
+            style=Style(
+                [
+                    ("pointer", "ansigreen"),
+                    ("highlighted", "ansigreen"),
+                    ("msg", ""),
+                    ("meta", "fg:ansibrightblack"),
+                    ("text", "ansibrightblack"),
+                    ("question", "bold"),
+                    ("search_prefix", "ansibrightblack"),
+                    # search filter colors at the bottom
+                    ("search_success", "noinherit fg:ansigreen"),
+                    ("search_none", "noinherit fg:ansired"),
+                ]
+            ),
+        )
+        if isinstance(selected, str) and selected in names:
+            return selected
+    except KeyboardInterrupt:
+        return None
+    except Exception as e:
+        log((f"Failed to use prompt_toolkit for model selection: {e}", "yellow"))
+        # Never return an unvalidated model name here.
+        # If we can't interactively select, fall back to a known configured model.
+        if isinstance(preferred, str) and preferred in names:
+            return preferred
+        if config.main_model and config.main_model in names:
+            return config.main_model
+
+    return None

klaude_code/command/registry.py

@@ -105,6 +105,29 @@ def get_commands() -> dict[commands.CommandName | str, "CommandABC"]:
     return _COMMANDS.copy()
 
 
+def get_command_info_list() -> list[commands.CommandInfo]:
+    """Get lightweight command metadata for UI purposes.
+
+    Returns CommandInfo list in registration order (display order).
+    """
+    _ensure_commands_loaded()
+    return [
+        commands.CommandInfo(
+            name=_command_key_to_str(cmd.name),
+            summary=cmd.summary,
+            support_addition_params=cmd.support_addition_params,
+            placeholder=cmd.placeholder,
+        )
+        for cmd in _COMMANDS.values()
+    ]
+
+
+def get_command_names() -> frozenset[str]:
+    """Get all registered command names as a frozen set for fast lookup."""
+    _ensure_commands_loaded()
+    return frozenset(_command_key_to_str(key) for key in _COMMANDS)
+
+
 def is_slash_command_name(name: str) -> bool:
     _ensure_commands_loaded()
     return _resolve_command_key(name) is not None

klaude_code/command/resume_cmd.py

@@ -1,8 +1,58 @@
 import asyncio
 
+from prompt_toolkit.styles import Style
+
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model, op
-from klaude_code.session.selector import resume_select_session
+from klaude_code.session.selector import build_session_select_options
+from klaude_code.trace import log
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+SESSION_SELECT_STYLE = Style(
+    [
+        ("msg", ""),
+        ("meta", "fg:ansibrightblack"),
+        ("pointer", "bold fg:ansigreen"),
+        ("highlighted", "fg:ansigreen"),
+        ("search_prefix", "fg:ansibrightblack"),
+        ("search_success", "noinherit fg:ansigreen"),
+        ("search_none", "noinherit fg:ansired"),
+        ("question", "bold"),
+        ("text", ""),
+    ]
+)
+
+
+def _select_session_sync() -> str | None:
+    """Interactive session selection (sync version for asyncio.to_thread)."""
+    options = build_session_select_options()
+    if not options:
+        log("No sessions found for this project.")
+        return None
+
+    items: list[SelectItem[str]] = []
+    for opt in options:
+        title = [
+            ("class:msg", f"{opt.first_user_message}\n"),
+            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
+        ]
+        items.append(
+            SelectItem(
+                title=title,
+                value=opt.session_id,
+                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
+            )
+        )
+
+    try:
+        return select_one(
+            message="Select a session to resume:",
+            items=items,
+            pointer="→",
+            style=SESSION_SELECT_STYLE,
+        )
+    except KeyboardInterrupt:
+        return None
 
 
 class ResumeCommand(CommandABC):
@@ -33,7 +83,7 @@ class ResumeCommand(CommandABC):
             )
             return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
-        selected_session_id = await asyncio.to_thread(resume_select_session)
+        selected_session_id = await asyncio.to_thread(_select_session_sync)
         if selected_session_id is None:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,