klaude-code 1.4.3__py3-none-any.whl → 1.6.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,7 +11,8 @@ 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.command.resume_cmd import select_session_sync
+from klaude_code.session import Session
 from klaude_code.trace import DebugType, prepare_debug_log_file
 
 
@@ -18,10 +20,19 @@ 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 +158,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 +293,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 +308,7 @@ def main_callback(
         session_id: str | None = None
 
         if resume:
-            session_id = resume_select_session()
+            session_id = select_session_sync()
             if session_id is None:
                 return
         # If user didn't pick, allow fallback to --continue
@@ -343,7 +354,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/fork_session_cmd.py

@@ -1,5 +1,182 @@
+import asyncio
+import sys
+from dataclasses import dataclass
+from typing import Literal
+
+from prompt_toolkit.styles import Style
+
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+FORK_SELECT_STYLE = Style(
+    [
+        ("msg", ""),
+        ("meta", "fg:ansibrightblack"),
+        ("separator", "fg:ansibrightblack"),
+        ("assistant", "fg:ansiblue"),
+        ("pointer", "bold fg:ansigreen"),
+        ("search_prefix", "fg:ansibrightblack"),
+        ("search_success", "noinherit fg:ansigreen"),
+        ("search_none", "noinherit fg:ansired"),
+        ("question", "bold"),
+        ("text", ""),
+    ]
+)
+
+
+@dataclass
+class ForkPoint:
+    """A fork point in conversation history."""
+
+    history_index: int | None  # None means fork entire conversation
+    user_message: str
+    tool_call_stats: dict[str, int]  # tool_name -> count
+    last_assistant_summary: str
+
+
+def _truncate(text: str, max_len: int = 60) -> str:
+    """Truncate text to max_len, adding ellipsis if needed."""
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 3] + "..."
+
+
+def _build_fork_points(conversation_history: list[model.ConversationItem]) -> list[ForkPoint]:
+    """Build list of fork points from conversation history.
+
+    Fork points are:
+    - Each UserMessageItem position (for UI display, including first which would be empty session)
+    - The end of the conversation (fork entire conversation)
+    """
+    fork_points: list[ForkPoint] = []
+    user_indices: list[int] = []
+
+    for i, item in enumerate(conversation_history):
+        if isinstance(item, model.UserMessageItem):
+            user_indices.append(i)
+
+    # For each UserMessageItem, create a fork point at that position
+    for i, user_idx in enumerate(user_indices):
+        user_item = conversation_history[user_idx]
+        assert isinstance(user_item, model.UserMessageItem)
+
+        # Find the end of this "task" (next UserMessageItem or end of history)
+        next_user_idx = user_indices[i + 1] if i + 1 < len(user_indices) else len(conversation_history)
+
+        # Count tool calls by name and find last assistant message in this segment
+        tool_stats: dict[str, int] = {}
+        last_assistant_content = ""
+        for j in range(user_idx, next_user_idx):
+            item = conversation_history[j]
+            if isinstance(item, model.ToolCallItem):
+                tool_stats[item.name] = tool_stats.get(item.name, 0) + 1
+            elif isinstance(item, model.AssistantMessageItem) and item.content:
+                last_assistant_content = item.content
+
+        fork_points.append(
+            ForkPoint(
+                history_index=user_idx,
+                user_message=user_item.content or "(empty)",
+                tool_call_stats=tool_stats,
+                last_assistant_summary=_truncate(last_assistant_content) if last_assistant_content else "",
+            )
+        )
+
+    # Add the "fork entire conversation" option at the end
+    if user_indices:
+        fork_points.append(
+            ForkPoint(
+                history_index=None,  # None means fork entire conversation
+                user_message="",  # No specific message, this represents the end
+                tool_call_stats={},
+                last_assistant_summary="",
+            )
+        )
+
+    return fork_points
+
+
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+    """Build SelectItem list from fork points."""
+    items: list[SelectItem[int | None]] = []
+
+    for i, fp in enumerate(fork_points):
+        is_first = i == 0
+        is_last = i == len(fork_points) - 1
+
+        # Build the title
+        title_parts: list[tuple[str, str]] = []
+
+        # First line: separator (with special markers for first/last fork points)
+        if is_first and not is_last:
+            title_parts.append(("class:separator", "----- fork from here (empty session) -----\n\n"))
+        elif is_last:
+            title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
+        else:
+            title_parts.append(("class:separator", "----- fork from here -----\n\n"))
+
+        if not is_last:
+            # Second line: user message
+            title_parts.append(("class:msg", f"user:   {_truncate(fp.user_message, 70)}\n"))
+
+            # Third line: tool call stats (if any)
+            if fp.tool_call_stats:
+                tool_parts = [f"{name} × {count}" for name, count in fp.tool_call_stats.items()]
+                title_parts.append(("class:meta", f"tools:  {', '.join(tool_parts)}\n"))
+
+            # Fourth line: last assistant message summary (if any)
+            if fp.last_assistant_summary:
+                title_parts.append(("class:assistant", f"ai:     {fp.last_assistant_summary}\n"))
+
+        # Empty line at the end
+        title_parts.append(("class:text", "\n"))
+
+        items.append(
+            SelectItem(
+                title=title_parts,
+                value=fp.history_index,
+                search_text=fp.user_message if not is_last else "fork entire conversation",
+            )
+        )
+
+    return items
+
+
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+    """Interactive fork point selection (sync version for asyncio.to_thread).
+
+    Returns:
+        - int: history index to fork at (exclusive)
+        - None: fork entire conversation
+        - "cancelled": user cancelled selection
+    """
+    items = _build_select_items(fork_points)
+    if not items:
+        return None
+
+    # Default to the last option (fork entire conversation)
+    last_value = items[-1].value
+
+    # Non-interactive environments default to forking entire conversation
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return last_value
+
+    try:
+        result = select_one(
+            message="Select fork point (messages before this point will be included):",
+            items=items,
+            pointer="→",
+            style=FORK_SELECT_STYLE,
+            initial_value=last_value,
+            highlight_pointed_item=False,
+        )
+        if result is None:
+            return "cancelled"
+        return result
+    except KeyboardInterrupt:
+        return "cancelled"
 
 
 class ForkSessionCommand(CommandABC):
@@ -13,6 +190,10 @@ class ForkSessionCommand(CommandABC):
     def summary(self) -> str:
         return "Fork the current session and show a resume-by-id command"
 
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         del user_input  # unused
 
@@ -26,13 +207,50 @@ class ForkSessionCommand(CommandABC):
             )
             return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
-        new_session = agent.session.fork()
+        # Build fork points from conversation history
+        fork_points = _build_fork_points(agent.session.conversation_history)
+
+        if not fork_points:
+            # Only one user message, just fork entirely
+            new_session = agent.session.fork()
+            await new_session.wait_for_flush()
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session forked successfully. New session id: {new_session.id}",
+                    command_output=model.CommandOutput(
+                        command_name=self.name,
+                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
+                    ),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Interactive selection
+        selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
+
+        if selected == "cancelled":
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(fork cancelled)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Perform the fork
+        new_session = agent.session.fork(until_index=selected)
         await new_session.wait_for_flush()
 
+        # Build result message
+        fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
+
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
             item=model.DeveloperMessageItem(
-                content=f"Session forked successfully. New session id: {new_session.id}",
+                content=f"Session forked ({fork_description}). New session id: {new_session.id}",
                 command_output=model.CommandOutput(
                     command_name=self.name,
                     ui_extra=model.SessionIdUIExtra(session_id=new_session.id),

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: