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

klaude_code/cli/config_cmd.py

@@ -12,7 +12,7 @@ from klaude_code.trace import log
 
 def list_models() -> None:
     """List all models and providers configuration"""
-    from klaude_code.config.list_model import display_models_and_providers
+    from klaude_code.cli.list_model import display_models_and_providers
     from klaude_code.ui.terminal.color import is_light_terminal_background
 
     config = load_config()

klaude_code/cli/debug.py

@@ -48,7 +48,7 @@ def open_log_file_in_editor(path: Path) -> None:
     editor = os.environ.get("EDITOR")
 
     if not editor:
-        for cmd in ["open", "xdg-open", "code", "nvim", "vim", "nano"]:
+        for cmd in ["open", "xdg-open", "code", "TextEdit", "notepad"]:
             try:
                 subprocess.run(["which", cmd], check=True, capture_output=True)
                 editor = cmd

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,8 +8,8 @@ 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.config import load_config
 from klaude_code.session import Session, resume_select_session
 from klaude_code.trace import DebugType, prepare_debug_log_file
 
@@ -22,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]:
@@ -79,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,
@@ -104,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(
@@ -147,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:
@@ -157,13 +146,8 @@ def exec_command(
     from klaude_code.config.select_model import select_model_from_config
 
     chosen_model = model
-    if select_model:
-        # Prefer the explicitly provided model as default; otherwise main model
-        config = load_config()
-        if config is None:
-            raise typer.Exit(1)
-        default_name = model or config.main_model
-        chosen_model = select_model_from_config(preferred=default_name)
+    if model or select_model:
+        chosen_model = select_model_from_config(preferred=model)
         if chosen_model is None:
             return
 
@@ -196,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(
@@ -240,10 +225,10 @@ 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 select_model:
+        if model or select_model:
             chosen_model = select_model_from_config(preferred=model)
             if chosen_model is None:
                 return
@@ -260,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/cli/runtime.py

@@ -8,6 +8,8 @@ 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 Agent, DefaultModelProfileProvider, VanillaModelProfileProvider
@@ -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,14 +93,20 @@ 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())
 
     theme: str | None = config.theme
-    if theme is None:
+    if theme is None and not init_config.is_exec_mode:
         # Auto-detect theme from terminal background when config does not specify a theme.
+        # Skip detection in exec mode to avoid TTY race conditions with parent process's
+        # ESC monitor when running as a subprocess.
         detected = is_light_terminal_background()
         if detected is True:
             theme = "light"
@@ -145,8 +152,30 @@ async def initialize_session(
     await executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
     await event_queue.join()
 
-    active_session_ids = executor.context.agent_manager.active_session_ids()
-    return active_session_ids[0] if active_session_ids else session_id
+    active_session_id = executor.context.current_session_id()
+    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:
@@ -190,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(
@@ -214,16 +249,12 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     # Create status provider for bottom toolbar
     def _status_provider() -> REPLStatusSnapshot:
-        agent: Agent | None = None
-        # Get the first active agent (there should only be one in interactive mode)
-        active_agents = components.executor.context.active_agents
-        if active_agents:
-            agent = next(iter(active_agents.values()), None)
-
         # Check for updates (returns None if uv not available)
         update_message = get_update_message()
 
-        return build_repl_status_snapshot(agent=agent, update_message=update_message)
+        return build_repl_status_snapshot(
+            agent=components.executor.context.current_agent, update_message=update_message
+        )
 
     # Set up input provider for interactive mode
     input_provider: ui.InputProviderABC = ui.PromptToolkitInput(status_provider=_status_provider)
@@ -262,14 +293,19 @@ 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.
 
             This is necessary because /clear command creates a new session with a different ID.
             """
-            active_ids = components.executor.context.agent_manager.active_session_ids()
-            return active_ids[0] if active_ids else None
+            return components.executor.context.current_session_id()
 
         # Input
         await input_provider.start()

klaude_code/{version.py → 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/command/__init__.py

@@ -28,6 +28,7 @@ def ensure_commands_loaded() -> None:
 
     # Import and register commands in display order
     from .clear_cmd import ClearCommand
+    from .debug_cmd import DebugCommand
     from .diff_cmd import DiffCommand
     from .export_cmd import ExportCommand
     from .export_online_cmd import ExportOnlineCommand
@@ -46,12 +47,13 @@ def ensure_commands_loaded() -> None:
     register(ThinkingCommand())
     register(ModelCommand())
     load_prompt_commands()
-    register(ClearCommand())
     register(StatusCommand())
     register(DiffCommand())
     register(HelpCommand())
     register(ReleaseNotesCommand())
     register(TerminalSetupCommand())
+    register(DebugCommand())
+    register(ClearCommand())
 
     # Load prompt-based commands (appended after built-in commands)
 
@@ -60,6 +62,7 @@ def ensure_commands_loaded() -> None:
 def __getattr__(name: str) -> object:
     _commands_map = {
         "ClearCommand": "clear_cmd",
+        "DebugCommand": "debug_cmd",
         "DiffCommand": "diff_cmd",
         "ExportCommand": "export_cmd",
         "ExportOnlineCommand": "export_online_cmd",

klaude_code/command/clear_cmd.py

@@ -1,11 +1,6 @@
-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.protocol import commands
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class ClearCommand(CommandABC):
     """Clear current session and start a new conversation"""
@@ -18,5 +13,5 @@ class ClearCommand(CommandABC):
     def summary(self) -> str:
         return "Clear conversation history and free up context"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         return CommandResult(actions=[InputAction.clear()])

klaude_code/command/command_abc.py

@@ -1,14 +1,37 @@
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING
+from typing import Protocol
 
 from pydantic import BaseModel
 
-from klaude_code.protocol import commands
+from klaude_code.llm import LLMClientABC
+from klaude_code.protocol import commands, llm_param
 from klaude_code.protocol import events as protocol_events
+from klaude_code.session.session import Session
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
+
+class AgentProfile(Protocol):
+    """Protocol for the agent's active model profile."""
+
+    @property
+    def llm_client(self) -> LLMClientABC: ...
+
+    @property
+    def system_prompt(self) -> str | None: ...
+
+    @property
+    def tools(self) -> list[llm_param.ToolSchema]: ...
+
+
+class Agent(Protocol):
+    """Protocol for Agent objects passed to commands."""
+
+    session: Session
+
+    @property
+    def profile(self) -> AgentProfile | None: ...
+
+    def get_llm_client(self) -> LLMClientABC: ...
 
 
 class InputActionType(str, Enum):
@@ -80,8 +103,13 @@ class CommandABC(ABC):
         """Whether this command support additional parameters."""
         return False
 
+    @property
+    def placeholder(self) -> str:
+        """Placeholder text for additional parameters in help display."""
+        return "additional instructions"
+
     @abstractmethod
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         """
         Execute the command.
 

klaude_code/command/debug_cmd.py

@@ -0,0 +1,79 @@
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.trace import DebugType, get_current_log_file, is_debug_enabled, set_debug_logging
+
+
+def _format_status() -> str:
+    """Format the current debug status for display."""
+    if not is_debug_enabled():
+        return "Debug: OFF"
+
+    log_file = get_current_log_file()
+    log_path_str = str(log_file) if log_file else "(console)"
+    return f"Debug: ON\nLog file: {log_path_str}"
+
+
+def _parse_debug_filters(raw: str) -> set[DebugType] | None:
+    filters: set[DebugType] = set()
+    for chunk in raw.split(","):
+        normalized = chunk.strip().lower().replace("-", "_")
+        if not normalized:
+            continue
+        try:
+            filters.add(DebugType(normalized))
+        except ValueError as exc:
+            raise ValueError(normalized) from exc
+    return filters or None
+
+
+class DebugCommand(CommandABC):
+    """Toggle debug mode and configure debug filters."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.DEBUG
+
+    @property
+    def summary(self) -> str:
+        return "Toggle debug mode (optional: filter types)"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "filter types"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        raw = raw.strip()
+
+        # /debug (no args) - enable debug
+        if not raw:
+            set_debug_logging(True, write_to_file=True)
+            return self._message_result(agent, _format_status())
+
+        # /debug <filters> - enable with filters
+        try:
+            filters = _parse_debug_filters(raw)
+            if filters:
+                set_debug_logging(True, write_to_file=True, filters=filters)
+                filter_names = ", ".join(sorted(dt.value for dt in filters))
+                return self._message_result(agent, f"Filters: {filter_names}\n{_format_status()}")
+        except ValueError:
+            pass
+
+        return self._message_result(agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}")
+
+    def _message_result(self, agent: "Agent", content: str) -> CommandResult:
+        return CommandResult(
+            events=[
+                events.DeveloperMessageEvent(
+                    session_id=agent.session.id,
+                    item=model.DeveloperMessageItem(
+                        content=content,
+                        command_output=model.CommandOutput(command_name=self.name),
+                    ),
+                )
+            ]
+        )

klaude_code/command/diff_cmd.py

@@ -1,13 +1,9 @@
 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 DiffCommand(CommandABC):
     """Show git diff for the current repository."""
@@ -20,7 +16,7 @@ class DiffCommand(CommandABC):
     def summary(self) -> str:
         return "Show git diff"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         try:
             # Check if current directory is in a git repository
             git_check = subprocess.run(

klaude_code/command/export_cmd.py

@@ -2,15 +2,11 @@ from __future__ import annotations
 
 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
 from klaude_code.session.export import build_export_html, get_default_export_path
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class ExportCommand(CommandABC):
     """Export the current session into a standalone HTML transcript."""
@@ -25,7 +21,11 @@ class ExportCommand(CommandABC):
 
     @property
     def support_addition_params(self) -> bool:
-        return False
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "output path"
 
     @property
     def is_interactive(self) -> bool:
@@ -33,7 +33,7 @@ class ExportCommand(CommandABC):
 
     async def run(self, raw: str, agent: Agent) -> CommandResult:
         try:
-            output_path = self._resolve_output_path("", agent)
+            output_path = self._resolve_output_path(raw, agent)
             html_doc = self._build_html(agent)
             output_path.parent.mkdir(parents=True, exist_ok=True)
             output_path.write_text(html_doc, encoding="utf-8")