klaude-code 1.2.17__py3-none-any.whl → 1.2.19__py3-none-any.whl

klaude_code/command/export_online_cmd.py

@@ -5,15 +5,14 @@ import shutil
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from rich.console import Console
+from rich.text import Text
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.export import build_export_html
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class ExportOnlineCommand(CommandABC):
     """Export and deploy the current session to surge.sh as a static webpage."""
@@ -60,9 +59,11 @@ class ExportOnlineCommand(CommandABC):
             return CommandResult(events=[event])
 
         try:
-            html_doc = self._build_html(agent)
-            domain = self._generate_domain()
-            url = self._deploy_to_surge(surge_cmd, html_doc, domain)
+            console = Console()
+            with console.status(Text("Deploying to surge.sh...", style="dim"), spinner_style="dim"):
+                html_doc = self._build_html(agent)
+                domain = self._generate_domain()
+                url = self._deploy_to_surge(surge_cmd, html_doc, domain)
 
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,

klaude_code/command/help_cmd.py

@@ -1,11 +1,6 @@
-from typing import TYPE_CHECKING
-
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class HelpCommand(CommandABC):
     """Display help information for all available slash commands."""
@@ -18,7 +13,7 @@ class HelpCommand(CommandABC):
     def summary(self) -> str:
         return "Show help and available commands"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         lines: list[str] = [
             """
 Usage:
@@ -39,8 +34,8 @@ Available slash commands:"""
 
         if commands:
             for cmd_name, cmd_obj in sorted(commands.items()):
-                additional_instructions = " \\[additional instructions]" if cmd_obj.support_addition_params else ""
-                lines.append(f"  [b]/{cmd_name}[/b]{additional_instructions} — {cmd_obj.summary}")
+                placeholder = f" \\[{cmd_obj.placeholder}]" if cmd_obj.support_addition_params else ""
+                lines.append(f"  [b]/{cmd_name}[/b]{placeholder} — {cmd_obj.summary}")
 
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,

klaude_code/command/model_cmd.py

@@ -1,13 +1,9 @@
 import asyncio
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
 from klaude_code.config.select_model import select_model_from_config
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class ModelCommand(CommandABC):
     """Display or change the model configuration."""
@@ -24,7 +20,15 @@ class ModelCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "model name"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         selected_model = await asyncio.to_thread(select_model_from_config, preferred=raw)
 
         current_model = agent.profile.llm_client.model_name if agent.profile else None

klaude_code/command/prompt_command.py

@@ -1,15 +1,11 @@
 from importlib.resources import files
-from typing import TYPE_CHECKING
 
 import yaml
 
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
 from klaude_code.protocol import commands
 from klaude_code.trace import log_debug
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class PromptCommand(CommandABC):
     """Command that loads a prompt from a markdown file."""
@@ -59,7 +55,7 @@ class PromptCommand(CommandABC):
     def support_addition_params(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
         user_input = raw.strip() or "<none>"

klaude_code/command/refresh_cmd.py

@@ -1,11 +1,6 @@
-from typing import TYPE_CHECKING
-
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class RefreshTerminalCommand(CommandABC):
     """Refresh terminal display"""
@@ -22,7 +17,7 @@ class RefreshTerminalCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         import os
 
         os.system("cls" if os.name == "nt" else "clear")

klaude_code/command/registry.py

@@ -1,19 +1,79 @@
 from importlib.resources import files
 from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandResult, InputAction
 from klaude_code.command.prompt_command import PromptCommand
 from klaude_code.protocol import commands, events, model
 from klaude_code.trace import log_debug
 
 if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
     from .command_abc import CommandABC
 
 _COMMANDS: dict[commands.CommandName | str, "CommandABC"] = {}
 
 
+def _command_key_to_str(key: commands.CommandName | str) -> str:
+    if isinstance(key, commands.CommandName):
+        return key.value
+    return key
+
+
+def _resolve_command_key(command_name_raw: str) -> commands.CommandName | str | None:
+    """Resolve raw command token to a registered command key.
+
+    Resolution order:
+    1) Exact match
+    2) Enum conversion (for standard commands)
+    3) Prefix match (supports abbreviations like `exp` -> `export`)
+
+    Prefix match rules:
+    - If there's exactly one prefix match, use it.
+    - If multiple matches exist and one command name is a prefix of all others,
+      treat it as the base command and use it (e.g. `export` over `export-online`).
+    - Otherwise, consider it ambiguous and return None.
+    """
+
+    if not command_name_raw:
+        return None
+
+    # Exact string match (works for both Enum and str keys because CommandName is a str Enum)
+    if command_name_raw in _COMMANDS:
+        return command_name_raw
+
+    # Enum conversion for standard commands
+    try:
+        enum_key = commands.CommandName(command_name_raw)
+    except ValueError:
+        enum_key = None
+    else:
+        if enum_key in _COMMANDS:
+            return enum_key
+
+    # Prefix match across all registered names
+    matching_keys: list[commands.CommandName | str] = []
+    matching_names: list[str] = []
+    for key in _COMMANDS:
+        key_str = _command_key_to_str(key)
+        if key_str.startswith(command_name_raw):
+            matching_keys.append(key)
+            matching_names.append(key_str)
+
+    if len(matching_keys) == 1:
+        return matching_keys[0]
+
+    if len(matching_keys) > 1:
+        # Prefer the base command when one is a prefix of all other matches.
+        base_matches = [
+            key
+            for key, key_name in zip(matching_keys, matching_names, strict=True)
+            if all(other.startswith(key_name) for other in matching_names if other != key_name)
+        ]
+        if len(base_matches) == 1:
+            return base_matches[0]
+
+    return None
+
+
 def register(cmd: "CommandABC") -> None:
     """Register a command instance. Order of registration determines display order."""
     _COMMANDS[cmd.name] = cmd
@@ -47,10 +107,10 @@ def get_commands() -> dict[commands.CommandName | str, "CommandABC"]:
 
 def is_slash_command_name(name: str) -> bool:
     _ensure_commands_loaded()
-    return name in _COMMANDS
+    return _resolve_command_key(name) is not None
 
 
-async def dispatch_command(raw: str, agent: "Agent") -> CommandResult:
+async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
     _ensure_commands_loaded()
     # Detect command name
     if not raw.startswith("/"):
@@ -60,21 +120,7 @@ async def dispatch_command(raw: str, agent: "Agent") -> CommandResult:
     command_name_raw = splits[0][1:]
     rest = " ".join(splits[1:]) if len(splits) > 1 else ""
 
-    # Try to match against registered commands (both Enum and string keys)
-    command_key = None
-
-    # First try exact string match
-    if command_name_raw in _COMMANDS:
-        command_key = command_name_raw
-    else:
-        # Then try Enum conversion for standard commands
-        try:
-            enum_key = commands.CommandName(command_name_raw)
-            if enum_key in _COMMANDS:
-                command_key = enum_key
-        except ValueError:
-            pass
-
+    command_key = _resolve_command_key(command_name_raw)
     if command_key is None:
         return CommandResult(actions=[InputAction.run_agent(raw)])
 
@@ -108,11 +154,8 @@ def has_interactive_command(raw: str) -> bool:
         return False
     splits = raw.split(" ", maxsplit=1)
     command_name_raw = splits[0][1:]
-    try:
-        command_name = commands.CommandName(command_name_raw)
-    except ValueError:
-        return False
-    if command_name not in _COMMANDS:
+    command_key = _resolve_command_key(command_name_raw)
+    if command_key is None:
         return False
-    command = _COMMANDS[command_name]
+    command = _COMMANDS[command_key]
     return command.is_interactive

klaude_code/command/release_notes_cmd.py

@@ -1,12 +1,8 @@
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 def _read_changelog() -> str:
     """Read CHANGELOG.md from project root."""
@@ -72,7 +68,7 @@ class ReleaseNotesCommand(CommandABC):
     def summary(self) -> str:
         return "Show the latest release notes"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         changelog = _read_changelog()
         content = _extract_releases(changelog, count=10)
 

klaude_code/command/status_cmd.py

@@ -1,12 +1,7 @@
-from typing import TYPE_CHECKING
-
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.session import Session
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class AggregatedUsage(model.BaseModel):
     """Aggregated usage statistics including per-model breakdown."""
@@ -137,7 +132,7 @@ class StatusCommand(CommandABC):
     def summary(self) -> str:
         return "Show session usage statistics"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         session = agent.session
         aggregated = accumulate_session_usage(session)
 

klaude_code/command/terminal_setup_cmd.py

@@ -1,14 +1,10 @@
 import os
 import subprocess
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class TerminalSetupCommand(CommandABC):
     """Setup shift+enter newline functionality in terminal"""
@@ -25,7 +21,7 @@ class TerminalSetupCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         term_program = os.environ.get("TERM_PROGRAM", "").lower()
 
         try:

klaude_code/command/thinking_cmd.py

@@ -1,18 +1,14 @@
 import asyncio
-from typing import TYPE_CHECKING
 
 import questionary
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, llm_param, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
-
 # Thinking level options for different protocols
-RESPONSES_LEVELS = ["minimal", "low", "medium", "high"]
-RESPONSES_GPT51_LEVELS = ["none", "minimal", "low", "medium", "high"]
+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"]
 
 ANTHROPIC_LEVELS: list[tuple[str, int | None]] = [
@@ -35,7 +31,14 @@ 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 ["gpt5.1", "openai/gpt-5.1", "gpt-5.1-codex-2025-11-13"]
+    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:
@@ -49,6 +52,8 @@ 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
     return RESPONSES_LEVELS
@@ -164,7 +169,7 @@ class ThinkingCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         if not agent.profile:
             return self._no_change_result(agent, "No profile configured")
 
@@ -201,6 +206,7 @@ class ThinkingCommand(CommandABC):
 
         # Apply the new thinking configuration
         config.thinking = new_thinking
+        agent.session.model_thinking = new_thinking
         new_status = _format_current_thinking(config)
 
         return CommandResult(

klaude_code/config/select_model.py

@@ -1,35 +1,111 @@
-from klaude_code.config.config import load_config
+from klaude_code.config.config import ModelConfig, load_config
 from klaude_code.trace import log
 
 
+def _normalize_model_key(value: str) -> str:
+    """Normalize a model identifier for loose matching.
+
+    This enables aliases like:
+    - gpt52 -> gpt-5.2
+    - gpt5.2 -> gpt-5.2
+
+    Strategy: case-fold + keep only alphanumeric characters.
+    """
+
+    return "".join(ch for ch in value.casefold() if ch.isalnum())
+
+
 def select_model_from_config(preferred: str | None = None) -> str | None:
     """
     Interactive single-choice model selector.
     for `--select-model`
+
+    If preferred is provided:
+    - Exact match: return immediately
+    - Single partial match (case-insensitive): return immediately
+    - Otherwise: fall through to interactive selection
     """
     config = load_config()
     assert config is not None
-    models = sorted(config.model_list, key=lambda m: m.model_name.lower())
+    models: list[ModelConfig] = sorted(config.model_list, key=lambda m: m.model_name.lower())
 
     if not models:
         raise ValueError("No models configured. Please update your config.yaml")
 
     names: list[str] = [m.model_name for m in models]
 
+    # Try to match preferred model name
+    filtered_models = models
+    if preferred and preferred.strip():
+        preferred = preferred.strip()
+        # Exact match
+        if preferred in names:
+            return preferred
+
+        preferred_lower = preferred.lower()
+        # Case-insensitive exact match (model_name or model_params.model)
+        exact_ci_matches = [
+            m
+            for m in models
+            if preferred_lower == m.model_name.lower() or preferred_lower == (m.model_params.model or "").lower()
+        ]
+        if len(exact_ci_matches) == 1:
+            return exact_ci_matches[0].model_name
+
+        # Normalized matching (e.g. gpt52 == gpt-5.2, gpt52 in gpt-5.2-2025-...)
+        preferred_norm = _normalize_model_key(preferred)
+        normalized_matches: list[ModelConfig] = []
+        if preferred_norm:
+            normalized_matches = [
+                m
+                for m in models
+                if preferred_norm == _normalize_model_key(m.model_name)
+                or preferred_norm == _normalize_model_key(m.model_params.model or "")
+            ]
+            if len(normalized_matches) == 1:
+                return normalized_matches[0].model_name
+
+            if not normalized_matches and len(preferred_norm) >= 4:
+                normalized_matches = [
+                    m
+                    for m in models
+                    if preferred_norm in _normalize_model_key(m.model_name)
+                    or preferred_norm in _normalize_model_key(m.model_params.model or "")
+                ]
+                if len(normalized_matches) == 1:
+                    return normalized_matches[0].model_name
+
+        # Partial match (case-insensitive) on model_name or model_params.model.
+        # If normalized matching found candidates (even if multiple), prefer those as the filter set.
+        matches = normalized_matches or [
+            m
+            for m in models
+            if preferred_lower in m.model_name.lower() or preferred_lower in (m.model_params.model or "").lower()
+        ]
+        if len(matches) == 1:
+            return matches[0].model_name
+        if matches:
+            # Multiple matches: filter the list for interactive selection
+            filtered_models = matches
+        else:
+            # No matches: show all models without filter hint
+            preferred = None
+
     try:
         import questionary
 
         choices: list[questionary.Choice] = []
 
-        max_model_name_length = max(len(m.model_name) for m in models)
-        for m in models:
+        max_model_name_length = max(len(m.model_name) for m in filtered_models)
+        for m in filtered_models:
             star = "★ " if m.model_name == config.main_model else "  "
             title = f"{star}{m.model_name:<{max_model_name_length}}   →  {m.model_params.model or 'N/A'} @ {m.provider}"
             choices.append(questionary.Choice(title=title, value=m.model_name))
 
         try:
+            message = f"Select a model (filtered by '{preferred}'):" if preferred else "Select a model:"
             result = questionary.select(
-                message="Select a model:",
+                message=message,
                 choices=choices,
                 pointer="→",
                 instruction="↑↓ to move • Enter to select",

klaude_code/const/__init__.py

@@ -50,7 +50,7 @@ READ_CHAR_LIMIT_PER_LINE = 2000
 READ_GLOBAL_LINE_CAP = 2000
 
 # Maximum total characters to read
-READ_MAX_CHARS = 60000
+READ_MAX_CHARS = 50000
 
 # Maximum file size in KB for text files
 READ_MAX_KB = 256