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

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/refresh_cmd.py

@@ -23,7 +23,7 @@ class RefreshTerminalCommand(CommandABC):
 
         os.system("cls" if os.name == "nt" else "clear")
 
-        result = CommandResult(
+        return CommandResult(
             events=[
                 events.WelcomeEvent(
                     work_dir=str(agent.session.work_dir),
@@ -35,7 +35,7 @@ class RefreshTerminalCommand(CommandABC):
                     updated_at=agent.session.updated_at,
                     is_load=False,
                 ),
-            ]
+            ],
+            persist_user_input=False,
+            persist_events=False,
         )
-
-        return result

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,68 @@
 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, format_user_messages_display
+from klaude_code.trace import log
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+SESSION_SELECT_STYLE = Style(
+    [
+        ("msg", "fg:ansibrightblack"),
+        ("meta", ""),
+        ("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 idx, opt in enumerate(options, 1):
+        display_msgs = format_user_messages_display(opt.user_messages)
+        title: list[tuple[str, str]] = []
+        title.append(("fg:ansibrightblack", f"{idx:2}. "))
+        title.append(
+            ("class:meta", f"{opt.relative_time} · {opt.messages_count} · {opt.model_name} · {opt.session_id}\n")
+        )
+        for msg in display_msgs:
+            if msg == "⋮":
+                title.append(("class:msg", f"    {msg}\n"))
+            else:
+                title.append(("class:msg", f"    > {msg}\n"))
+        title.append(("", "\n"))
+
+        search_text = " ".join(opt.user_messages) + f" {opt.model_name} {opt.session_id}"
+        items.append(
+            SelectItem(
+                title=title,
+                value=opt.session_id,
+                search_text=search_text,
+            )
+        )
+
+    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 +93,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,

klaude_code/command/thinking_cmd.py

@@ -1,171 +1,37 @@
 import asyncio
-from typing import Literal, cast
 
 from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, events, llm_param, model
+from klaude_code.config.thinking import get_thinking_picker_data, parse_thinking_value
+from klaude_code.protocol import commands, events, llm_param, model, op
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
-ReasoningEffort = Literal["high", "medium", "low", "minimal", "none", "xhigh"]
-
-# Thinking level options for different protocols
-RESPONSES_LEVELS = ["low", "medium", "high"]
-RESPONSES_GPT51_LEVELS = ["none", "low", "medium", "high"]
-RESPONSES_GPT52_LEVELS = ["none", "low", "medium", "high", "xhigh"]
-RESPONSES_CODEX_MAX_LEVELS = ["medium", "high", "xhigh"]
-RESPONSES_GEMINI_FLASH_LEVELS = ["minimal", "low", "medium", "high"]
-
-ANTHROPIC_LEVELS: list[tuple[str, int | None]] = [
-    ("off", 0),
-    ("low (2048 tokens)", 2048),
-    ("medium (8192 tokens)", 8192),
-    ("high (31999 tokens)", 31999),
-]
-
-
-def _is_openrouter_model_with_reasoning_effort(model_name: str | None) -> bool:
-    """Check if the model is GPT series, Grok or Gemini 3."""
-    if not model_name:
-        return False
-    model_lower = model_name.lower()
-    return model_lower.startswith(("openai/gpt-", "x-ai/grok-", "google/gemini-3"))
-
-
-def _is_gpt51_model(model_name: str | None) -> bool:
-    """Check if the model is GPT-5.1."""
-    if not model_name:
-        return False
-    return model_name.lower() in ["gpt-5.1", "openai/gpt-5.1", "gpt-5.1-codex-2025-11-13"]
-
-
-def _is_gpt52_model(model_name: str | None) -> bool:
-    """Check if the model is GPT-5.2."""
-    if not model_name:
-        return False
-    return model_name.lower() in ["gpt-5.2", "openai/gpt-5.2"]
-
-
-def _is_codex_max_model(model_name: str | None) -> bool:
-    """Check if the model is GPT-5.1-codex-max."""
-    if not model_name:
-        return False
-    return "codex-max" in model_name.lower()
-
-
-def _is_gemini_flash_model(model_name: str | None) -> bool:
-    """Check if the model is Gemini 3 Flash."""
-    if not model_name:
-        return False
-    return "gemini-3-flash" in model_name.lower()
-
-
-def should_auto_trigger_thinking(model_name: str | None) -> bool:
-    """Check if model should auto-trigger thinking selection on switch."""
-    if not model_name:
-        return False
-    model_lower = model_name.lower()
-    return "gpt-5" in model_lower or "gemini-3" in model_lower or "opus" in model_lower
-
-
-def _get_levels_for_responses(model_name: str | None) -> list[str]:
-    """Get thinking levels for responses protocol."""
-    if _is_codex_max_model(model_name):
-        return RESPONSES_CODEX_MAX_LEVELS
-    if _is_gpt52_model(model_name):
-        return RESPONSES_GPT52_LEVELS
-    if _is_gpt51_model(model_name):
-        return RESPONSES_GPT51_LEVELS
-    if _is_gemini_flash_model(model_name):
-        return RESPONSES_GEMINI_FLASH_LEVELS
-    return RESPONSES_LEVELS
-
-
-def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
-    """Format the current thinking configuration for display."""
-    thinking = config.thinking
-    if not thinking:
-        return "not configured"
-
-    protocol = config.protocol
-
-    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
-        if thinking.reasoning_effort:
-            return f"reasoning_effort={thinking.reasoning_effort}"
-        return "not set"
-
-    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-        if thinking.type == "disabled":
-            return "off"
-        if thinking.type == "enabled":
-            return f"enabled (budget_tokens={thinking.budget_tokens})"
-        return "not set"
-
-    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
-        if _is_openrouter_model_with_reasoning_effort(config.model):
-            if thinking.reasoning_effort:
-                return f"reasoning_effort={thinking.reasoning_effort}"
-        else:
-            if thinking.type == "disabled":
-                return "off"
-            if thinking.type == "enabled":
-                return f"enabled (budget_tokens={thinking.budget_tokens})"
-        return "not set"
-
-    if protocol == llm_param.LLMClientProtocol.OPENAI:
-        if thinking.type == "disabled":
-            return "off"
-        if thinking.type == "enabled":
-            return f"enabled (budget_tokens={thinking.budget_tokens})"
-        return "not set"
-
-    return "unknown protocol"
-
-
 SELECT_STYLE = Style(
     [
         ("instruction", "ansibrightblack"),
         ("pointer", "ansigreen"),
         ("highlighted", "ansigreen"),
         ("text", "ansibrightblack"),
-        ("question", ""),
+        ("question", "bold"),
     ]
 )
 
 
-def _select_responses_thinking_sync(model_name: str | None) -> llm_param.Thinking | None:
-    """Select thinking level for responses/codex protocol (sync version)."""
-    levels = _get_levels_for_responses(model_name)
-    items: list[SelectItem[str]] = [
-        SelectItem(title=[("class:text", level + "\n")], value=level, search_text=level) for level in levels
-    ]
-
-    try:
-        result = select_one(
-            message="Select reasoning effort:",
-            items=items,
-            pointer="→",
-            style=SELECT_STYLE,
-            use_search_filter=False,
-        )
-
-        if result is None:
-            return None
-        return llm_param.Thinking(reasoning_effort=cast(ReasoningEffort, result))
-    except KeyboardInterrupt:
+def _select_thinking_sync(config: llm_param.LLMConfigParameter) -> llm_param.Thinking | None:
+    """Select thinking level (sync version)."""
+    data = get_thinking_picker_data(config)
+    if data is None:
         return None
 
-
-def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
-    """Select thinking level for anthropic/openai_compatible protocol (sync version)."""
-    items: list[SelectItem[int]] = [
-        SelectItem(title=[("class:text", label + "\n")], value=tokens or 0, search_text=label)
-        for label, tokens in ANTHROPIC_LEVELS
+    items: list[SelectItem[str]] = [
+        SelectItem(title=[("class:text", opt.label + "\n")], value=opt.value, search_text=opt.label)
+        for opt in data.options
     ]
 
     try:
         result = select_one(
-            message="Select thinking level:",
+            message=data.message,
             items=items,
             pointer="→",
             style=SELECT_STYLE,
@@ -173,9 +39,7 @@ def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
         )
         if result is None:
             return None
-        if result == 0:
-            return llm_param.Thinking(type="disabled", budget_tokens=0)
-        return llm_param.Thinking(type="enabled", budget_tokens=result)
+        return parse_thinking_value(result)
     except KeyboardInterrupt:
         return None
 
@@ -185,24 +49,7 @@ async def select_thinking_for_protocol(config: llm_param.LLMConfigParameter) ->
 
     Returns the selected Thinking config, or None if user cancelled.
     """
-    protocol = config.protocol
-    model_name = config.model
-
-    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
-        return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-
-    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-        return await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
-        if _is_openrouter_model_with_reasoning_effort(model_name):
-            return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-        return await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-    if protocol == llm_param.LLMClientProtocol.OPENAI:
-        return await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-    return None
+    return await asyncio.to_thread(_select_thinking_sync, config)
 
 
 class ThinkingCommand(CommandABC):
@@ -222,46 +69,30 @@ class ThinkingCommand(CommandABC):
 
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         del user_input  # unused
-        if not agent.profile:
-            return self._no_change_result(agent, "No profile configured")
+        if agent.profile is None:
+            return CommandResult(events=[])
 
         config = agent.profile.llm_client.get_llm_config()
-        current = format_current_thinking(config)
-
         new_thinking = await select_thinking_for_protocol(config)
-        if new_thinking is None:
-            return self._no_change_result(agent, "(no change)")
 
-        # Apply the new thinking configuration
-        config.thinking = new_thinking
-        agent.session.model_thinking = new_thinking
-        new_status = format_current_thinking(config)
-
-        return CommandResult(
-            events=[
-                events.DeveloperMessageEvent(
-                    session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=f"Thinking changed: {current} -> {new_status}",
-                        command_output=model.CommandOutput(command_name=self.name),
-                    ),
-                ),
-                events.WelcomeEvent(
-                    work_dir=str(agent.session.work_dir),
-                    llm_config=config,
-                ),
-            ]
-        )
+        if new_thinking is None:
+            return CommandResult(
+                events=[
+                    events.DeveloperMessageEvent(
+                        session_id=agent.session.id,
+                        item=model.DeveloperMessageItem(
+                            content="(no change)",
+                            command_output=model.CommandOutput(command_name=self.name),
+                        ),
+                    )
+                ]
+            )
 
-    def _no_change_result(self, agent: "Agent", message: str) -> CommandResult:
         return CommandResult(
-            events=[
-                events.DeveloperMessageEvent(
+            operations=[
+                op.ChangeThinkingOperation(
                     session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=message,
-                        command_output=model.CommandOutput(command_name=self.name),
-                    ),
+                    thinking=new_thinking,
                 )
             ]
         )