klaude-code 1.2.18__tar.gz → 1.2.19__tar.gz

{klaude_code-1.2.18 → klaude_code-1.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.18
+Version: 1.2.19
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: ddgs>=9.9.3
@@ -41,6 +41,21 @@ To update:
 uv tool upgrade klaude-code
 ```
 
+Or use the built-in alias command:
+
+```bash
+klaude update
+klaude upgrade
+```
+
+To show version:
+
+```bash
+klaude --version
+klaude -v
+klaude version
+```
+
 ## Usage
 
 ### Interactive Mode
@@ -50,7 +65,7 @@ klaude [--model <name>] [--select-model]
 ```
 
 **Options:**
-- `--version`/`-V`: Show version and exit.
+- `--version`/`-V`/`-v`: Show version and exit.
 - `--model`/`-m`: Preferred model name (exact match picks immediately; otherwise opens the interactive selector filtered by this value).
 - `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
 - `--continue`/`-c`: Resume the most recent session.

{klaude_code-1.2.18 → klaude_code-1.2.19}/README.md

@@ -23,6 +23,21 @@ To update:
 uv tool upgrade klaude-code
 ```
 
+Or use the built-in alias command:
+
+```bash
+klaude update
+klaude upgrade
+```
+
+To show version:
+
+```bash
+klaude --version
+klaude -v
+klaude version
+```
+
 ## Usage
 
 ### Interactive Mode
@@ -32,7 +47,7 @@ klaude [--model <name>] [--select-model]
 ```
 
 **Options:**
-- `--version`/`-V`: Show version and exit.
+- `--version`/`-V`/`-v`: Show version and exit.
 - `--model`/`-m`: Preferred model name (exact match picks immediately; otherwise opens the interactive selector filtered by this value).
 - `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
 - `--continue`/`-c`: Resume the most recent session.

{klaude_code-1.2.18 → klaude_code-1.2.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.18"
+version = "1.2.19"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-1.2.18 → klaude_code-1.2.19}/src/klaude_code/cli/main.py

@@ -1,8 +1,6 @@
 import asyncio
 import os
 import sys
-from importlib.metadata import PackageNotFoundError
-from importlib.metadata import version as pkg_version
 from pathlib import Path
 
 import typer
@@ -10,6 +8,7 @@ import typer
 from klaude_code.cli.auth_cmd import register_auth_commands
 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.trace import DebugType, prepare_debug_log_file
@@ -21,10 +20,13 @@ def set_terminal_title(title: str) -> None:
     sys.stdout.flush()
 
 
-def setup_terminal_title() -> None:
-    """Set terminal title to current folder name."""
+def update_terminal_title(model_name: str | None = None) -> None:
+    """Update terminal title with folder name and optional model name."""
     folder_name = os.path.basename(os.getcwd())
-    set_terminal_title(f"{folder_name}: klaude")
+    if model_name:
+        set_terminal_title(f"{folder_name}: klaude ✳ {model_name}")
+    else:
+        set_terminal_title(f"{folder_name}: klaude")
 
 
 def prepare_debug_logging(debug: bool, debug_filter: str | None) -> tuple[bool, set[DebugType] | None, Path | None]:
@@ -78,20 +80,6 @@ def read_input_content(cli_argument: str) -> str | None:
     return content
 
 
-def _version_callback(value: bool) -> None:
-    """Show version and exit."""
-    if value:
-        try:
-            ver = pkg_version("klaude-code")
-        except PackageNotFoundError:
-            # Package is not installed or has no metadata; show a generic version string.
-            ver = "unknown"
-        except Exception:
-            ver = "unknown"
-        print(f"klaude-code {ver}")
-        raise typer.Exit(0)
-
-
 app = typer.Typer(
     add_completion=False,
     pretty_exceptions_enable=False,
@@ -103,6 +91,8 @@ register_session_commands(app)
 register_auth_commands(app)
 register_config_commands(app)
 
+register_self_update_commands(app)
+
 
 @app.command("exec")
 def exec_command(
@@ -146,7 +136,7 @@ def exec_command(
     ),
 ) -> None:
     """Execute non-interactively with provided input."""
-    setup_terminal_title()
+    update_terminal_title()
 
     merged_input = read_input_content(input_content)
     if merged_input is None:
@@ -190,8 +180,9 @@ def main_callback(
         False,
         "--version",
         "-V",
+        "-v",
         help="Show version and exit",
-        callback=_version_callback,
+        callback=version_option_callback,
         is_eager=True,
     ),
     model: str | None = typer.Option(
@@ -234,7 +225,7 @@ def main_callback(
         from klaude_code.cli.runtime import AppInitConfig, run_interactive
         from klaude_code.config.select_model import select_model_from_config
 
-        setup_terminal_title()
+        update_terminal_title()
 
         chosen_model = model
         if model or select_model:
@@ -254,6 +245,35 @@ def main_callback(
             session_id = Session.most_recent_session_id()
         # If still no session_id, leave as None to create a new session
 
+        if session_id is not None and chosen_model is None:
+            from klaude_code.config import load_config
+            from klaude_code.trace import log
+
+            session_meta = Session.load_meta(session_id)
+            cfg = load_config()
+
+            if cfg is not None and session_meta.model_config_name:
+                if any(m.model_name == session_meta.model_config_name for m in cfg.model_list):
+                    chosen_model = session_meta.model_config_name
+                else:
+                    log(
+                        (
+                            f"Warning: session model '{session_meta.model_config_name}' is not defined in config; falling back to default",
+                            "yellow",
+                        )
+                    )
+
+            if cfg is not None and chosen_model is None and session_meta.model_name:
+                raw_model = session_meta.model_name.strip()
+                if raw_model:
+                    matches = [
+                        m.model_name
+                        for m in cfg.model_list
+                        if (m.model_params.model or "").strip().lower() == raw_model.lower()
+                    ]
+                    if len(matches) == 1:
+                        chosen_model = matches[0]
+
         debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
 
         init_config = AppInitConfig(

{klaude_code-1.2.18 → klaude_code-1.2.19}/src/klaude_code/cli/runtime.py

@@ -8,9 +8,11 @@ import typer
 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.config import Config, load_config
-from klaude_code.core.agent import DefaultModelProfileProvider, VanillaModelProfileProvider
+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
@@ -21,7 +23,6 @@ from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
 from klaude_code.ui.terminal.color import is_light_terminal_background
 from klaude_code.ui.terminal.control import install_sigint_double_press_exit, start_esc_interrupt_monitor
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
-from klaude_code.version import get_update_message
 
 
 class PrintCapable(Protocol):
@@ -92,8 +93,12 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
         event_queue,
         llm_clients,
         model_profile_provider=model_profile_provider,
+        on_model_change=update_terminal_title,
     )
 
+    # Update terminal title with initial model name
+    update_terminal_title(llm_clients.main.model_name)
+
     # Start executor in background
     executor_task = asyncio.create_task(executor.start())
 
@@ -151,6 +156,28 @@ async def initialize_session(
     return active_session_id or session_id
 
 
+def _backfill_session_model_config(
+    agent: Agent | None,
+    model_override: str | None,
+    default_model: str,
+    is_new_session: bool,
+) -> None:
+    """Backfill model_config_name and model_thinking on newly created sessions."""
+    if agent is None or agent.session.model_config_name is not None:
+        return
+
+    if model_override is not None:
+        agent.session.model_config_name = model_override
+    elif is_new_session:
+        agent.session.model_config_name = default_model
+    else:
+        return
+
+    if agent.session.model_thinking is None and agent.profile:
+        agent.session.model_thinking = agent.profile.llm_client.get_llm_config().thinking
+    # Don't save here - session will be saved when first message is sent via append_history()
+
+
 async def cleanup_app_components(components: AppComponents) -> None:
     """Clean up all application components."""
     try:
@@ -192,6 +219,12 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
 
     try:
         session_id = await initialize_session(components.executor, components.event_queue)
+        _backfill_session_model_config(
+            components.executor.context.current_agent,
+            init_config.model,
+            components.config.main_model,
+            is_new_session=True,
+        )
 
         # Submit the input content directly
         await components.executor.submit_and_wait(
@@ -260,6 +293,12 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     try:
         await initialize_session(components.executor, components.event_queue, session_id=session_id)
+        _backfill_session_model_config(
+            components.executor.context.current_agent,
+            init_config.model,
+            components.config.main_model,
+            is_new_session=session_id is None,
+        )
 
         def _get_active_session_id() -> str | None:
             """Get the current active session ID dynamically.

klaude_code-1.2.18/src/klaude_code/version.py → klaude_code-1.2.19/src/klaude_code/cli/self_update.py

@@ -1,4 +1,4 @@
-"""Version checking utilities for klaude-code."""
+"""Self-update and version utilities for klaude-code."""
 
 from __future__ import annotations
 
@@ -8,8 +8,14 @@ import subprocess
 import threading
 import time
 import urllib.request
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as pkg_version
 from typing import NamedTuple
 
+import typer
+
+from klaude_code.trace import log
+
 PACKAGE_NAME = "klaude-code"
 PYPI_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
 CHECK_INTERVAL_SECONDS = 3600  # Check at most once per hour
@@ -160,4 +166,106 @@ def get_update_message() -> str | None:
     info = check_for_updates()
     if info is None or not info.update_available:
         return None
-    return f"New version available: {info.latest}. Please run `uv tool upgrade {PACKAGE_NAME}` to upgrade."
+    return f"New version available: {info.latest}. Please run `klaude upgrade` to upgrade."
+
+
+def _print_version() -> None:
+    try:
+        ver = pkg_version(PACKAGE_NAME)
+    except PackageNotFoundError:
+        ver = "unknown"
+    except Exception:
+        ver = "unknown"
+    print(f"{PACKAGE_NAME} {ver}")
+
+
+def version_option_callback(value: bool) -> None:
+    """Show version and exit."""
+    if value:
+        _print_version()
+        raise typer.Exit(0)
+
+
+def version_command() -> None:
+    """Show version and exit."""
+
+    _print_version()
+
+
+def update_command(
+    check: bool = typer.Option(
+        False,
+        "--check",
+        help="Check for updates and exit without upgrading",
+    ),
+) -> None:
+    """Upgrade klaude-code when installed via `uv tool`."""
+
+    info = check_for_updates_blocking()
+
+    if check:
+        if info is None:
+            log(("Error: `uv` is not available; cannot check for updates.", "red"))
+            log(f"Install uv, then run `uv tool upgrade {PACKAGE_NAME}`.")
+            raise typer.Exit(1)
+
+        installed_display = info.installed or "unknown"
+        latest_display = info.latest or "unknown"
+        status = "update available" if info.update_available else "up to date"
+
+        log(f"{PACKAGE_NAME} installed: {installed_display}")
+        log(f"{PACKAGE_NAME} latest:    {latest_display}")
+        log(f"Status: {status}")
+
+        if info.update_available:
+            log("Run `klaude upgrade` to upgrade.")
+
+        return
+
+    if shutil.which("uv") is None:
+        log(("Error: `uv` not found in PATH.", "red"))
+        log(f"To update, install uv and run `uv tool upgrade {PACKAGE_NAME}`.")
+        raise typer.Exit(1)
+
+    log(f"Running `uv tool upgrade {PACKAGE_NAME}`...")
+    result = subprocess.run(["uv", "tool", "upgrade", PACKAGE_NAME], check=False)
+    if result.returncode != 0:
+        log((f"Error: update failed (exit code {result.returncode}).", "red"))
+        raise typer.Exit(result.returncode or 1)
+
+    log("Update complete. Please re-run `klaude` to use the new version.")
+
+
+def register_self_update_commands(app: typer.Typer) -> None:
+    """Register self-update and version subcommands to the given Typer app."""
+
+    app.command("update")(update_command)
+    app.command("upgrade", help="Alias for `klaude update`.")(update_command)
+    app.command("version", help="Alias for `klaude --version`.")(version_command)
+
+
+def check_for_updates_blocking() -> VersionInfo | None:
+    """Check for updates to klaude-code synchronously.
+
+    This is intended for CLI commands (e.g. `klaude update --check`) that need
+    a deterministic result instead of the async cached behavior.
+
+    Returns:
+        VersionInfo if uv is available, otherwise None.
+    """
+
+    if not _has_uv():
+        return None
+
+    installed = _get_installed_version()
+    latest = _get_latest_version()
+
+    update_available = False
+    if installed and latest:
+        update_available = _compare_versions(installed, latest)
+
+    return VersionInfo(
+        installed=installed,
+        latest=latest,
+        update_available=update_available,
+    )

{klaude_code-1.2.18 → klaude_code-1.2.19}/src/klaude_code/command/export_online_cmd.py

@@ -6,6 +6,9 @@ import subprocess
 import tempfile
 from pathlib import Path
 
+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
@@ -56,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-1.2.18 → klaude_code-1.2.19}/src/klaude_code/command/registry.py

@@ -12,6 +12,68 @@ if TYPE_CHECKING:
 _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
@@ -45,7 +107,7 @@ 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:
@@ -58,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)])
 
@@ -106,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-1.2.18 → klaude_code-1.2.19}/src/klaude_code/command/thinking_cmd.py

@@ -6,9 +6,9 @@ from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, llm_param, model
 
 # Thinking level options for different protocols
-RESPONSES_LEVELS = ["minimal", "low", "medium", "high"]
-RESPONSES_GPT51_LEVELS = ["none", "minimal", "low", "medium", "high"]
-RESPONSES_GPT52_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"]
+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]] = [
@@ -206,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-1.2.18 → klaude_code-1.2.19}/src/klaude_code/core/executor.py

@@ -90,11 +90,13 @@ class InputActionExecutor:
         sub_agent_manager: SubAgentManager,
         model_profile_provider: ModelProfileProvider,
         emit_event: Callable[[events.Event], Awaitable[None]],
+        on_model_change: Callable[[str], None] | None = None,
     ) -> None:
         self._task_manager = task_manager
         self._sub_agent_manager = sub_agent_manager
         self._model_profile_provider = model_profile_provider
         self._emit_event = emit_event
+        self._on_model_change = on_model_change
 
     async def run(self, action: InputAction, operation: op.UserInputOperation, agent: Agent) -> None:
         """Dispatch and execute a single input action."""
@@ -208,6 +210,9 @@ class InputActionExecutor:
         llm_client = create_llm_client(llm_config)
         agent.set_model_profile(self._model_profile_provider.build_profile(llm_client))
 
+        agent.session.model_config_name = model_name
+        agent.session.model_thinking = llm_config.thinking
+
         developer_item = model.DeveloperMessageItem(
             content=f"switched to model: {model_name}",
             command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
@@ -217,11 +222,16 @@ class InputActionExecutor:
         await self._emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
         await self._emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
 
+        if self._on_model_change is not None:
+            self._on_model_change(llm_client.model_name)
+
     async def _apply_clear(self, agent: Agent) -> None:
         """Start a new conversation for the agent and notify the UI."""
 
         new_session = Session(work_dir=agent.session.work_dir)
         new_session.model_name = agent.session.model_name
+        new_session.model_config_name = agent.session.model_config_name
+        new_session.model_thinking = agent.session.model_thinking
 
         agent.session = new_session
         agent.session.save()
@@ -249,6 +259,7 @@ class ExecutorContext:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
         self.event_queue: asyncio.Queue[events.Event] = event_queue
         self.llm_clients: LLMClients = llm_clients
@@ -263,6 +274,7 @@ class ExecutorContext:
             sub_agent_manager=self.sub_agent_manager,
             model_profile_provider=resolved_profile_provider,
             emit_event=self.emit_event,
+            on_model_change=on_model_change,
         )
         self._agent: Agent | None = None
 
@@ -302,6 +314,13 @@ class ExecutorContext:
 
         session = Session.create() if session_id is None else Session.load(session_id)
 
+        if (
+            session.model_thinking is not None
+            and session.model_name
+            and session.model_name == self.llm_clients.main.model_name
+        ):
+            self.llm_clients.main.get_llm_config().thinking = session.model_thinking
+
         profile = self.model_profile_provider.build_profile(self.llm_clients.main)
         agent = Agent(session=session, profile=profile)
 
@@ -439,8 +458,9 @@ class Executor:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
-        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider)
+        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider, on_model_change)
         self.submission_queue: asyncio.Queue[op.Submission] = asyncio.Queue()
         # Track completion events for all submissions (not just those with ActiveTask)
         self._completion_events: dict[str, asyncio.Event] = {}