klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

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
@@ -57,7 +63,7 @@ def _get_installed_version() -> str | None:
                         ver = ver[1:]
                     return ver
         return None
-    except Exception:
+    except (OSError, subprocess.SubprocessError):
         return None
 
 
@@ -67,7 +73,7 @@ def _get_latest_version() -> str | None:
         with urllib.request.urlopen(PYPI_URL, timeout=5) as response:
             data = json.loads(response.read().decode())
             return data.get("info", {}).get("version")
-    except Exception:
+    except (OSError, json.JSONDecodeError, ValueError):
         return None
 
 
@@ -93,7 +99,7 @@ def _compare_versions(installed: str, latest: str) -> bool:
         installed_tuple = _parse_version(installed)
         latest_tuple = _parse_version(latest)
         return latest_tuple > installed_tuple
-    except Exception:
+    except ValueError:
         return False
 
 
@@ -160,4 +166,107 @@ 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 (ValueError, TypeError):
+        # Catch invalid package name format or type errors
+        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/cli/session_cmd.py

@@ -7,31 +7,47 @@ from klaude_code.trace import log
 
 
 def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) -> bool:
-    """Show session list and confirm deletion using questionary."""
-    import questionary
+    """Show session list and confirm deletion using prompt_toolkit."""
+
+    from prompt_toolkit.styles import Style
+
+    from klaude_code.ui.terminal.selector import SelectItem, select_one
 
     def _fmt(ts: float) -> str:
         try:
             return time.strftime("%m-%d %H:%M:%S", time.localtime(ts))
-        except Exception:
+        except (OSError, OverflowError, ValueError):
             return str(ts)
 
     log(f"Sessions to delete ({len(sessions)}):")
     for s in sessions:
         msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
-        first_msg = (s.first_user_message or "").strip().replace("\n", " ")[:50]
-        if len(s.first_user_message or "") > 50:
+        first_msg_text = s.user_messages[0] if s.user_messages else ""
+        first_msg = first_msg_text.strip().replace("\n", " ")[:50]
+        if len(first_msg_text) > 50:
             first_msg += "..."
         log(f"  {_fmt(s.updated_at)}  {msg_count_display:>3} msgs  {first_msg}")
 
-    return (
-        questionary.confirm(
-            message,
-            default=False,
-            style=questionary.Style([("question", "bold")]),
-        ).ask()
-        or False
+    items: list[SelectItem[bool]] = [
+        SelectItem(title=[("class:text", "No\n")], value=False, search_text="No"),
+        SelectItem(title=[("class:text", "Yes\n")], value=True, search_text="Yes"),
+    ]
+
+    result = select_one(
+        message=message,
+        items=items,
+        pointer="→",
+        style=Style(
+            [
+                ("question", "bold"),
+                ("pointer", "ansigreen"),
+                ("highlighted", "ansigreen"),
+                ("text", ""),
+            ]
+        ),
+        use_search_filter=False,
     )
+    return bool(result)
 
 
 def session_clean(
@@ -46,10 +62,9 @@ def session_clean(
         log(f"No sessions with fewer than {min_messages} messages found.")
         return
 
-    if not yes:
-        if not _session_confirm(to_delete, "Delete these sessions?"):
-            log("Aborted.")
-            return
+    if not yes and not _session_confirm(to_delete, "Delete these sessions?"):
+        log("Aborted.")
+        return
 
     deleted = Session.clean_small_sessions(min_messages)
     log(f"Deleted {deleted} session(s).")
@@ -65,16 +80,17 @@ def session_clean_all(
         log("No sessions found.")
         return
 
-    if not yes:
-        if not _session_confirm(sessions, "Delete ALL sessions? This cannot be undone."):
-            log("Aborted.")
-            return
+    if not yes and not _session_confirm(sessions, "Delete ALL sessions? This cannot be undone."):
+        log("Aborted.")
+        return
 
     deleted = Session.clean_all_sessions()
     log(f"Deleted {deleted} session(s).")
 
 
-def register_session_commands(session_app: typer.Typer) -> None:
+def register_session_commands(app: typer.Typer) -> None:
     """Register session subcommands to the given Typer app."""
+    session_app = typer.Typer(help="Manage sessions for the current project")
     session_app.command("clean")(session_clean)
     session_app.command("clean-all")(session_clean_all)
+    app.add_typer(session_app, name="session")

klaude_code/command/__init__.py

@@ -1,43 +1,104 @@
-from .clear_cmd import ClearCommand
-from .command_abc import CommandABC, CommandResult, InputAction, InputActionType
-from .diff_cmd import DiffCommand
-from .export_cmd import ExportCommand
-from .help_cmd import HelpCommand
-
-# InitCommand is now dynamically loaded via prompt_init.md
-# from .init_cmd import InitCommand
-from .model_cmd import ModelCommand
-from .refresh_cmd import RefreshTerminalCommand
+from .command_abc import CommandABC, CommandResult
 from .registry import (
     dispatch_command,
+    get_command_info_list,
+    get_command_names,
     get_commands,
     has_interactive_command,
     is_slash_command_name,
     load_prompt_commands,
-    register_command,
+    register,
 )
-from .status_cmd import StatusCommand
-from .terminal_setup_cmd import TerminalSetupCommand
 
-# Dynamically load prompt commands
-load_prompt_commands()
+# Lazy load commands to avoid heavy imports at module load time
+_commands_loaded = False
+
+
+def ensure_commands_loaded() -> None:
+    """Ensure all commands are loaded (lazy initialization).
+
+    This function is called internally by registry functions like get_commands(),
+    dispatch_command(), etc. It can also be called explicitly if early loading is desired.
+
+    Commands are registered in display order - the order here determines
+    the order shown in slash command completion.
+    """
+    global _commands_loaded
+    if _commands_loaded:
+        return
+    _commands_loaded = True
+
+    # Import and register commands in display order
+    from .clear_cmd import ClearCommand
+    from .debug_cmd import DebugCommand
+    from .export_cmd import ExportCommand
+    from .export_online_cmd import ExportOnlineCommand
+    from .fork_session_cmd import ForkSessionCommand
+    from .help_cmd import HelpCommand
+    from .model_cmd import ModelCommand
+    from .refresh_cmd import RefreshTerminalCommand
+    from .release_notes_cmd import ReleaseNotesCommand
+    from .resume_cmd import ResumeCommand
+    from .status_cmd import StatusCommand
+    from .terminal_setup_cmd import TerminalSetupCommand
+    from .thinking_cmd import ThinkingCommand
+
+    # Register in desired display order
+    register(ExportCommand())
+    register(ExportOnlineCommand())
+    register(RefreshTerminalCommand())
+    register(ThinkingCommand())
+    register(ModelCommand())
+    register(ForkSessionCommand())
+    register(ResumeCommand())
+    load_prompt_commands()
+    register(StatusCommand())
+    register(HelpCommand())
+    register(ReleaseNotesCommand())
+    register(TerminalSetupCommand())
+    register(DebugCommand())
+    register(ClearCommand())
+
+    # Load prompt-based commands (appended after built-in commands)
+
+
+# Lazy accessors for command classes
+def __getattr__(name: str) -> object:
+    _commands_map = {
+        "ClearCommand": "clear_cmd",
+        "DebugCommand": "debug_cmd",
+        "ExportCommand": "export_cmd",
+        "ExportOnlineCommand": "export_online_cmd",
+        "ForkSessionCommand": "fork_session_cmd",
+        "HelpCommand": "help_cmd",
+        "ModelCommand": "model_cmd",
+        "RefreshTerminalCommand": "refresh_cmd",
+        "ReleaseNotesCommand": "release_notes_cmd",
+        "ResumeCommand": "resume_cmd",
+        "StatusCommand": "status_cmd",
+        "TerminalSetupCommand": "terminal_setup_cmd",
+        "ThinkingCommand": "thinking_cmd",
+    }
+    if name in _commands_map:
+        import importlib
+
+        module = importlib.import_module(f".{_commands_map[name]}", __package__)
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 __all__ = [
-    "ClearCommand",
-    "DiffCommand",
-    "HelpCommand",
-    "ModelCommand",
-    "ExportCommand",
-    "RefreshTerminalCommand",
-    "StatusCommand",
-    "TerminalSetupCommand",
-    "register_command",
+    # Command classes are lazily loaded via __getattr__
+    # "ClearCommand", "DiffCommand", "HelpCommand", "ModelCommand",
+    # "ExportCommand", "RefreshTerminalCommand", "ReleaseNotesCommand",
+    # "StatusCommand", "TerminalSetupCommand",
     "CommandABC",
     "CommandResult",
-    "InputAction",
-    "InputActionType",
     "dispatch_command",
+    "ensure_commands_loaded",
+    "get_command_info_list",
+    "get_command_names",
     "get_commands",
-    "is_slash_command_name",
     "has_interactive_command",
+    "is_slash_command_name",
 ]

klaude_code/command/clear_cmd.py

@@ -1,10 +1,7 @@
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
-from klaude_code.protocol import commands
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, model, op
 
 
-@register_command
 class ClearCommand(CommandABC):
     """Clear current session and start a new conversation"""
 
@@ -16,5 +13,9 @@ class ClearCommand(CommandABC):
     def summary(self) -> str:
         return "Clear conversation history and free up context"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
-        return CommandResult(actions=[InputAction.clear()])
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+        return CommandResult(
+            operations=[op.ClearSessionOperation(session_id=agent.session.id)],
+            persist_user_input=False,
+        )

klaude_code/command/command_abc.py

@@ -1,45 +1,36 @@
 from abc import ABC, abstractmethod
-from enum import Enum
+from typing import Protocol
 
 from pydantic import BaseModel
 
-from klaude_code.core.agent import Agent
-from klaude_code.protocol import commands
+from klaude_code.llm import LLMClientABC
+from klaude_code.protocol import commands, llm_param, model, op
 from klaude_code.protocol import events as protocol_events
+from klaude_code.session.session import Session
 
 
-class InputActionType(str, Enum):
-    """Supported input action kinds."""
+class AgentProfile(Protocol):
+    """Protocol for the agent's active model profile."""
 
-    RUN_AGENT = "run_agent"
-    CHANGE_MODEL = "change_model"
-    CLEAR = "clear"
-
-
-class InputAction(BaseModel):
-    """Structured executor action derived from a user input."""
+    @property
+    def llm_client(self) -> LLMClientABC: ...
 
-    type: InputActionType
-    text: str = ""
-    model_name: str | None = None
+    @property
+    def system_prompt(self) -> str | None: ...
 
-    @classmethod
-    def run_agent(cls, text: str) -> "InputAction":
-        """Create a RunAgent action preserving the provided text."""
+    @property
+    def tools(self) -> list[llm_param.ToolSchema]: ...
 
-        return cls(type=InputActionType.RUN_AGENT, text=text)
 
-    @classmethod
-    def change_model(cls, model_name: str) -> "InputAction":
-        """Create a ChangeModel action for the provided model name."""
+class Agent(Protocol):
+    """Protocol for Agent objects passed to commands."""
 
-        return cls(type=InputActionType.CHANGE_MODEL, model_name=model_name)
+    session: Session
 
-    @classmethod
-    def clear(cls) -> "InputAction":
-        """Create a Clear action to reset the session."""
+    @property
+    def profile(self) -> AgentProfile | None: ...
 
-        return cls(type=InputActionType.CLEAR)
+    def get_llm_client(self) -> LLMClientABC: ...
 
 
 class CommandResult(BaseModel):
@@ -49,7 +40,11 @@ class CommandResult(BaseModel):
         list[protocol_events.DeveloperMessageEvent | protocol_events.WelcomeEvent | protocol_events.ReplayHistoryEvent]
         | None
     ) = None  # List of UI events to display immediately
-    actions: list[InputAction] | None = None
+    operations: list[op.Operation] | None = None
+
+    # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
+    persist_user_input: bool = True
+    persist_events: bool = True
 
 
 class CommandABC(ABC):
@@ -77,14 +72,19 @@ 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, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         """
         Execute the command.
 
         Args:
-            raw: The full command string as typed by user (e.g., "/help" or "/model gpt-4")
-            session_id: Current session ID, may be None if no session initialized yet
+            agent: The agent instance
+            user_input: User input with text containing command arguments (without command name)
 
         Returns:
             CommandResult: Result of the command execution

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, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        raw = user_input.text.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),
+                    ),
+                )
+            ]
+        )