klaude-code 1.4.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

klaude_code/protocol/op.py

@@ -13,6 +13,7 @@ from uuid import uuid4
 
 from pydantic import BaseModel, Field
 
+from klaude_code.protocol.llm_param import Thinking
 from klaude_code.protocol.model import UserInputPayload
 
 if TYPE_CHECKING:
@@ -75,6 +76,17 @@ class ChangeModelOperation(Operation):
     session_id: str
     model_name: str
     save_as_default: bool = False
+    # When True, the executor must not auto-trigger an interactive thinking selector.
+    # This is required for in-prompt model switching where the terminal is already
+    # controlled by a prompt_toolkit PromptSession.
+    defer_thinking_selection: bool = False
+    # When False, do not emit WelcomeEvent (which renders a banner/panel).
+    # This is useful for in-prompt model switching where extra output is noisy.
+    emit_welcome_event: bool = True
+
+    # When False, do not emit the "Switched to: ..." developer message.
+    # This is useful for in-prompt model switching where extra output is noisy.
+    emit_switch_message: bool = True
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_change_model(self)
@@ -85,6 +97,9 @@ class ChangeThinkingOperation(Operation):
 
     type: OperationType = OperationType.CHANGE_THINKING
     session_id: str
+    thinking: Thinking | None = None
+    emit_welcome_event: bool = True
+    emit_switch_message: bool = True
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_change_thinking(self)

klaude_code/session/__init__.py

@@ -1,4 +1,4 @@
-from .selector import resume_select_session
+from .selector import SessionSelectOption, build_session_select_options, format_user_messages_display
 from .session import Session
 
-__all__ = ["Session", "resume_select_session"]
+__all__ = ["Session", "SessionSelectOption", "build_session_select_options", "format_user_messages_display"]

klaude_code/session/selector.py

@@ -1,7 +1,5 @@
 import time
-
-from klaude_code.trace import log, log_debug
-from klaude_code.ui.terminal.selector import SelectItem, select_one
+from dataclasses import dataclass
 
 from .session import Session
 
@@ -30,69 +28,71 @@ def _relative_time(ts: float) -> str:
         return f"{months} month{'s' if months != 1 else ''} ago"
 
 
-def resume_select_session() -> str | None:
+@dataclass(frozen=True, slots=True)
+class SessionSelectOption:
+    """Option data for session selection UI."""
+
+    session_id: str
+    user_messages: list[str]
+    messages_count: str
+    relative_time: str
+    model_name: str
+
+
+def _format_message(msg: str) -> str:
+    """Format a user message for display (strip and collapse newlines)."""
+    return msg.strip().replace("\n", " ")
+
+
+def format_user_messages_display(messages: list[str]) -> list[str]:
+    """Format user messages for display in session selection.
+
+    Shows up to 6 messages. If more than 6, shows first 3 and last 3 with ellipsis.
+    Each message is on its own line.
+
+    Args:
+        messages: List of user messages.
+
+    Returns:
+        List of formatted message lines for display.
+    """
+    if len(messages) <= 6:
+        return messages
+
+    # More than 6: show first 3, ellipsis, last 3
+    result = messages[:3]
+    result.append("⋮")
+    result.extend(messages[-3:])
+    return result
+
+
+def build_session_select_options() -> list[SessionSelectOption]:
+    """Build session selection options data.
+
+    Returns:
+        List of SessionSelectOption, or empty list if no sessions exist.
+    """
     sessions = Session.list_sessions()
     if not sessions:
-        log("No sessions found for this project.")
-        return None
-
-    try:
-        from prompt_toolkit.styles import Style
-
-        items: list[SelectItem[str]] = []
-        for s in sessions:
-            first_msg = s.first_user_message or "N/A"
-            first_msg = first_msg.strip().replace("\n", " ")
-
-            msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
-            model = s.model_name or "N/A"
-
-            title = [
-                ("class:msg", f"{first_msg}\n"),
-                ("class:meta", f"   {msg_count} · {_relative_time(s.updated_at)} · {model} · {s.id}\n\n"),
-            ]
-            items.append(
-                SelectItem(
-                    title=title,
-                    value=str(s.id),
-                    search_text=f"{first_msg} {model} {s.id}",
-                )
-            )
+        return []
 
-        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", ""),
-                ]
-            ),
+    options: list[SessionSelectOption] = []
+    for s in sessions:
+        user_messages = [_format_message(m) for m in s.user_messages if m.strip()]
+        if not user_messages:
+            user_messages = ["N/A"]
+
+        msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
+        model = s.model_name or "N/A"
+
+        options.append(
+            SessionSelectOption(
+                session_id=str(s.id),
+                user_messages=user_messages,
+                messages_count=msg_count,
+                relative_time=_relative_time(s.updated_at),
+                model_name=model,
+            )
         )
-    except Exception as e:
-        log_debug(f"Failed to use prompt_toolkit for session select, {e}")
-
-        for i, s in enumerate(sessions, 1):
-            first_msg = (s.first_user_message or "N/A").strip().replace("\n", " ")
-            if len(first_msg) > 60:
-                first_msg = first_msg[:59] + "…"
-            msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} msgs"
-            model = s.model_name or "N/A"
-            print(f"{i}. {first_msg}")
-            print(f"   {_relative_time(s.updated_at)} · {msg_count} · {model}")
-        try:
-            raw = input("Select a session number: ").strip()
-            idx = int(raw)
-            if 1 <= idx <= len(sessions):
-                return str(sessions[idx - 1].id)
-        except (ValueError, EOFError):
-            return None
-    return None
+
+    return options

klaude_code/session/session.py

@@ -197,11 +197,16 @@ class Session(BaseModel):
         )
         self._store.append_and_flush(session_id=self.id, items=items, meta=meta)
 
-    def fork(self, *, new_id: str | None = None) -> Session:
+    def fork(self, *, new_id: str | None = None, until_index: int | None = None) -> Session:
         """Create a new session as a fork of the current session.
 
         The forked session copies metadata and conversation history, but does not
         modify the current session.
+
+        Args:
+            new_id: Optional ID for the forked session.
+            until_index: If provided, only copy conversation history up to (but not including) this index.
+                         If None, copy all history.
         """
 
         forked = Session.create(id=new_id, work_dir=self.work_dir)
@@ -213,7 +218,8 @@ class Session(BaseModel):
         forked.file_tracker = {k: v.model_copy(deep=True) for k, v in self.file_tracker.items()}
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
-        items = [it.model_copy(deep=True) for it in self.conversation_history]
+        history_to_copy = self.conversation_history[:until_index] if until_index is not None else self.conversation_history
+        items = [it.model_copy(deep=True) for it in history_to_copy]
         if items:
             forked.append_history(items)
 
@@ -338,7 +344,7 @@ class Session(BaseModel):
         updated_at: float
         work_dir: str
         path: str
-        first_user_message: str | None = None
+        user_messages: list[str] = []
         messages_count: int = -1
         model_name: str | None = None
 
@@ -346,10 +352,11 @@ class Session(BaseModel):
     def list_sessions(cls) -> list[SessionMetaBrief]:
         store = get_default_store()
 
-        def _get_first_user_message(session_id: str) -> str | None:
+        def _get_user_messages(session_id: str) -> list[str]:
             events_path = store.paths.events_file(session_id)
             if not events_path.exists():
-                return None
+                return []
+            messages: list[str] = []
             try:
                 for line in events_path.read_text(encoding="utf-8").splitlines():
                     obj_raw = json.loads(line)
@@ -360,15 +367,14 @@ class Session(BaseModel):
                         continue
                     data_raw = obj.get("data")
                     if not isinstance(data_raw, dict):
-                        return None
+                        continue
                     data = cast(dict[str, Any], data_raw)
                     content = data.get("content")
                     if isinstance(content, str):
-                        return content
-                    return None
+                        messages.append(content)
             except (OSError, json.JSONDecodeError):
-                return None
-            return None
+                pass
+            return messages
 
         items: list[Session.SessionMetaBrief] = []
         for meta_path in store.iter_meta_files():
@@ -382,7 +388,7 @@ class Session(BaseModel):
             created = float(data.get("created_at", meta_path.stat().st_mtime))
             updated = float(data.get("updated_at", meta_path.stat().st_mtime))
             work_dir = str(data.get("work_dir", ""))
-            first_user_message = _get_first_user_message(sid)
+            user_messages = _get_user_messages(sid)
             messages_count = int(data.get("messages_count", -1))
             model_name = data.get("model_name") if isinstance(data.get("model_name"), str) else None
 
@@ -393,7 +399,7 @@ class Session(BaseModel):
                     updated_at=updated,
                     work_dir=work_dir,
                     path=str(meta_path),
-                    first_user_message=first_user_message,
+                    user_messages=user_messages,
                     messages_count=messages_count,
                     model_name=model_name,
                 )

klaude_code/ui/modes/repl/completers.py

@@ -19,7 +19,7 @@ import re
 import shutil
 import subprocess
 import time
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from pathlib import Path
 from typing import NamedTuple
 
@@ -27,7 +27,7 @@ from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.document import Document
 from prompt_toolkit.formatted_text import FormattedText
 
-from klaude_code.command import CommandABC, get_commands
+from klaude_code.protocol.commands import CommandInfo
 from klaude_code.trace.log import DebugType, log_debug
 
 # Pattern to match @token for completion refresh (used by key bindings).
@@ -40,12 +40,18 @@ AT_TOKEN_PATTERN = re.compile(r'(^|\s)@(?P<frag>"[^"]*"|[^\s]*)$')
 SKILL_TOKEN_PATTERN = re.compile(r"^[$¥](?P<frag>\S*)$")
 
 
-def create_repl_completer() -> Completer:
+def create_repl_completer(
+    command_info_provider: Callable[[], list[CommandInfo]] | None = None,
+) -> Completer:
     """Create and return the combined REPL completer.
 
+    Args:
+        command_info_provider: Optional callable that returns command metadata.
+            If None, slash command completion is disabled.
+
     Returns a completer that handles both @ file paths and / slash commands.
     """
-    return _ComboCompleter()
+    return _ComboCompleter(command_info_provider=command_info_provider)
 
 
 class _CmdResult(NamedTuple):
@@ -66,6 +72,9 @@ class _SlashCommandCompleter(Completer):
 
     _SLASH_TOKEN_RE = re.compile(r"^/(?P<frag>\S*)$")
 
+    def __init__(self, command_info_provider: Callable[[], list[CommandInfo]] | None = None) -> None:
+        self._command_info_provider = command_info_provider
+
     def get_completions(
         self,
         document: Document,
@@ -75,6 +84,9 @@ class _SlashCommandCompleter(Completer):
         if document.cursor_position_row != 0:
             return
 
+        if self._command_info_provider is None:
+            return
+
         text_before = document.current_line_before_cursor
         m = self._SLASH_TOKEN_RE.search(text_before)
         if not m:
@@ -84,20 +96,20 @@ class _SlashCommandCompleter(Completer):
         token_start = len(text_before) - len(f"/{frag}")
         start_position = token_start - len(text_before)  # negative offset
 
-        # Get available commands
-        commands = get_commands()
+        # Get available commands from provider
+        command_infos = self._command_info_provider()
 
         # Filter commands that match the fragment (preserve registration order)
-        matched: list[tuple[str, CommandABC, str]] = []
-        for cmd_name, cmd_obj in commands.items():
-            if cmd_name.startswith(frag):
-                hint = f" [{cmd_obj.placeholder}]" if cmd_obj.support_addition_params else ""
-                matched.append((cmd_name, cmd_obj, hint))
+        matched: list[tuple[str, CommandInfo, str]] = []
+        for cmd_info in command_infos:
+            if cmd_info.name.startswith(frag):
+                hint = f" [{cmd_info.placeholder}]" if cmd_info.support_addition_params else ""
+                matched.append((cmd_info.name, cmd_info, hint))
 
         if not matched:
             return
 
-        for cmd_name, cmd_obj, hint in matched:
+        for cmd_name, cmd_info, hint in matched:
             completion_text = f"/{cmd_name} "
             # Use FormattedText to style the hint (placeholder) in bright black
             display = FormattedText([("", cmd_name), ("ansibrightblack", hint)]) if hint else cmd_name
@@ -105,7 +117,7 @@ class _SlashCommandCompleter(Completer):
                 text=completion_text,
                 start_position=start_position,
                 display=display,
-                display_meta=str(cmd_obj.summary),
+                display_meta=cmd_info.summary,
             )
 
     def is_slash_command_context(self, document: Document) -> bool:
@@ -200,9 +212,9 @@ class _SkillCompleter(Completer):
 class _ComboCompleter(Completer):
     """Combined completer that handles @ file paths, / slash commands, and $ skills."""
 
-    def __init__(self) -> None:
+    def __init__(self, command_info_provider: Callable[[], list[CommandInfo]] | None = None) -> None:
         self._at_completer = _AtFilesCompleter()
-        self._slash_completer = _SlashCommandCompleter()
+        self._slash_completer = _SlashCommandCompleter(command_info_provider=command_info_provider)
         self._skill_completer = _SkillCompleter()
 
     def get_completions(

klaude_code/ui/modes/repl/event_handler.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from rich.cells import cell_len
 from rich.rule import Rule
 from rich.text import Text
 
@@ -15,7 +14,7 @@ from klaude_code.ui.renderers.thinking import THINKING_MESSAGE_MARK, normalize_t
 from klaude_code.ui.rich import status as r_status
 from klaude_code.ui.rich.markdown import MarkdownStream, ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
-from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
+from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier, emit_tmux_signal
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 
 
@@ -265,11 +264,27 @@ class SpinnerStatusState:
 
         return result
 
-    def get_context_text(self) -> Text | None:
-        """Get context usage text for right-aligned display."""
-        if self._context_percent is None:
+    def get_right_text(self) -> r_status.DynamicText | None:
+        """Get right-aligned status text (elapsed time and optional context %)."""
+
+        elapsed_text = r_status.current_elapsed_text()
+        has_context = self._context_percent is not None
+
+        if elapsed_text is None and not has_context:
             return None
-        return Text(f"{self._context_percent:.1f}%", style=ThemeKey.METADATA_DIM)
+
+        def _render() -> Text:
+            parts: list[str] = []
+            if self._context_percent is not None:
+                parts.append(f"{self._context_percent:.1f}%")
+            current_elapsed = r_status.current_elapsed_text()
+            if current_elapsed is not None:
+                if parts:
+                    parts.append(" · ")
+                parts.append(current_elapsed)
+            return Text("".join(parts), style=ThemeKey.METADATA_DIM)
+
+        return r_status.DynamicText(_render)
 
 
 class DisplayEventHandler:
@@ -509,6 +524,7 @@ class DisplayEventHandler:
             self.spinner_status.reset()
             self.renderer.spinner_stop()
             self.renderer.console.print(Rule(characters="─", style=ThemeKey.LINES))
+            emit_tmux_signal()  # Signal test harness if KLAUDE_TEST_SIGNAL is set
         await self.stage_manager.transition_to(Stage.WAITING)
         self._maybe_notify_task_finish(event)
 
@@ -549,11 +565,10 @@ class DisplayEventHandler:
     def _update_spinner(self) -> None:
         """Update spinner text from current status state."""
         status_text = self.spinner_status.get_status()
-        context_text = self.spinner_status.get_context_text()
-        status_text = self._truncate_spinner_status_text(status_text, right_text=context_text)
+        right_text = self.spinner_status.get_right_text()
         self.renderer.spinner_update(
             status_text,
-            context_text,
+            right_text,
         )
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
@@ -611,27 +626,3 @@ class DisplayEventHandler:
                 if len(todo.content) > 0:
                     status_text = todo.content
         return status_text.replace("\n", " ").strip()
-
-    def _truncate_spinner_status_text(self, status_text: Text, *, right_text: Text | None) -> Text:
-        """Truncate spinner status to a single line based on terminal width.
-
-        Rich wraps based on terminal cell width (CJK chars count as 2). Use
-        cell-aware truncation to prevent the status from wrapping into two lines.
-        """
-
-        terminal_width = self.renderer.console.size.width
-
-        # BreathingSpinner renders as a 2-column Table.grid(padding=1):
-        # 1 cell for glyph + 1 cell of padding between columns (collapsed).
-        spinner_prefix_cells = 2
-
-        hint_cells = cell_len(r_status.current_hint_text())
-        right_cells = cell_len(right_text.plain) if right_text is not None else 0
-
-        max_main_cells = terminal_width - spinner_prefix_cells - hint_cells - right_cells - 1
-        # rich.text.Text.truncate behaves unexpectedly for 0; clamp to at least 1.
-        max_main_cells = max(1, max_main_cells)
-
-        truncated = status_text.copy()
-        truncated.truncate(max_main_cells, overflow="ellipsis", pad=False)
-        return truncated