klaude-code 1.2.6__py3-none-any.whl → 1.8.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/prompt-jj-describe.md

@@ -0,0 +1,32 @@
+---
+description: Add description for current jj change
+---
+
+Run `jj status` and `jj diff --git` to see the current changes and add a description for the it.
+
+In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC, a la this example:<example>
+jj describe -m "$(cat <<'EOF'
+   Commit message here.
+   EOF
+   )"
+</example>
+
+Follow the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+```
+<type>(<scope>): <description>
+```
+
+Types:
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, no logic change)
+- `refactor`: Code refactoring (no feature or fix)
+- `test`: Adding or updating tests
+- `chore`: Build process, dependencies, or tooling changes
+
+Examples:
+- `feat(cli): add --verbose flag for debug output`
+- `fix(llm): handle API timeout errors gracefully`
+- `docs(readme): update installation instructions`
+- `refactor(core): simplify session state management`

klaude_code/command/prompt_command.py

@@ -2,9 +2,9 @@ from importlib.resources import files
 
 import yaml
 
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-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
+from klaude_code.trace import log_debug
 
 
 class PromptCommand(CommandABC):
@@ -41,7 +41,8 @@ class PromptCommand(CommandABC):
 
             self._metadata = {}
             self._content = raw_text
-        except Exception:
+        except (OSError, yaml.YAMLError) as e:
+            log_debug(f"Failed to load prompt template {self.template_name}: {e}")
             self._metadata = {"description": "Error loading template"}
             self._content = f"Error loading template: {self.template_name}"
 
@@ -54,16 +55,23 @@ class PromptCommand(CommandABC):
     def support_addition_params(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
-        user_input = raw.strip() or "<none>"
+        user_input_text = user_input.text.strip() or "<none>"
 
         if "$ARGUMENTS" in template_content:
-            final_prompt = template_content.replace("$ARGUMENTS", user_input)
+            final_prompt = template_content.replace("$ARGUMENTS", user_input_text)
         else:
             final_prompt = template_content
-            if user_input:
-                final_prompt += f"\n\nAdditional Instructions:\n{user_input}"
-
-        return CommandResult(actions=[InputAction.run_agent(final_prompt)])
+            if user_input_text:
+                final_prompt += f"\n\nAdditional Instructions:\n{user_input_text}"
+
+        return CommandResult(
+            operations=[
+                op.RunAgentOperation(
+                    session_id=agent.session.id,
+                    input=model.UserInputPayload(text=final_prompt, images=user_input.images),
+                )
+            ]
+        )

klaude_code/command/refresh_cmd.py

@@ -1,10 +1,7 @@
-from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
-from klaude_code.protocol import commands, events
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
 
 
-@register_command
 class RefreshTerminalCommand(CommandABC):
     """Refresh terminal display"""
 
@@ -20,12 +17,13 @@ class RefreshTerminalCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         import os
 
         os.system("cls" if os.name == "nt" else "clear")
 
-        result = CommandResult(
+        return CommandResult(
             events=[
                 events.WelcomeEvent(
                     work_dir=str(agent.session.work_dir),
@@ -37,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

@@ -1,24 +1,82 @@
 from importlib.resources import files
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandResult
 from klaude_code.command.prompt_command import PromptCommand
-from klaude_code.core.agent import Agent
-from klaude_code.protocol import commands, events, model
+from klaude_code.protocol import commands, events, model, op
+from klaude_code.trace import log_debug
 
 if TYPE_CHECKING:
     from .command_abc import CommandABC
 
 _COMMANDS: dict[commands.CommandName | str, "CommandABC"] = {}
 
-T = TypeVar("T", bound="CommandABC")
 
+def _command_key_to_str(key: commands.CommandName | str) -> str:
+    if isinstance(key, commands.CommandName):
+        return key.value
+    return key
 
-def register_command(cls: type[T]) -> type[T]:
-    """Decorator to register a command class in the global registry."""
-    instance = cls()
-    _COMMANDS[instance.name] = instance
-    return cls
+
+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
 
 
 def load_prompt_commands():
@@ -30,52 +88,95 @@ def load_prompt_commands():
             if (name.startswith("prompt_") or name.startswith("prompt-")) and name.endswith(".md"):
                 cmd = PromptCommand(name)
                 _COMMANDS[cmd.name] = cmd
-    except Exception:
-        # If resource loading fails, just ignore
-        pass
+    except OSError as e:
+        log_debug(f"Failed to load prompt commands: {e}")
+
+
+def _ensure_commands_loaded() -> None:
+    """Ensure all commands are loaded (lazy initialization)."""
+    from klaude_code.command import ensure_commands_loaded
+
+    ensure_commands_loaded()
 
 
 def get_commands() -> dict[commands.CommandName | str, "CommandABC"]:
     """Get all registered commands."""
+    _ensure_commands_loaded()
     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:
-    return name in _COMMANDS
+    _ensure_commands_loaded()
+    return _resolve_command_key(name) is not None
 
 
-async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
+async def dispatch_command(user_input: model.UserInputPayload, agent: Agent, *, submission_id: str) -> CommandResult:
+    _ensure_commands_loaded()
     # Detect command name
+    raw = user_input.text
     if not raw.startswith("/"):
-        return CommandResult(actions=[InputAction.run_agent(raw)])
+        return CommandResult(
+            operations=[
+                op.RunAgentOperation(
+                    id=submission_id,
+                    session_id=agent.session.id,
+                    input=user_input,
+                )
+            ]
+        )
 
     splits = raw.split(" ", maxsplit=1)
     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)])
+        return CommandResult(
+            operations=[
+                op.RunAgentOperation(
+                    id=submission_id,
+                    session_id=agent.session.id,
+                    input=user_input,
+                )
+            ]
+        )
 
     command = _COMMANDS[command_key]
     command_identifier: commands.CommandName | str = command.name
 
     try:
-        return await command.run(rest, agent)
+        user_input_for_command = model.UserInputPayload(text=rest, images=user_input.images)
+        result = await command.run(agent, user_input_for_command)
+        ops = list(result.operations or [])
+        for operation in ops:
+            if isinstance(operation, op.RunAgentOperation):
+                operation.id = submission_id
+        if ops:
+            result.operations = ops
+        return result
     except Exception as e:
         command_output = (
             model.CommandOutput(command_name=command_identifier, is_error=True)
@@ -87,7 +188,7 @@ async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
                 events.DeveloperMessageEvent(
                     session_id=agent.session.id,
                     item=model.DeveloperMessageItem(
-                        content=f"Command {command_identifier} error: [{e.__class__.__name__}] {str(e)}",
+                        content=f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}",
                         command_output=command_output,
                     ),
                 )
@@ -96,15 +197,13 @@ async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
 
 
 def has_interactive_command(raw: str) -> bool:
+    _ensure_commands_loaded()
     if not raw.startswith("/"):
         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

@@ -0,0 +1,84 @@
+from pathlib import Path
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+
+
+def _read_changelog() -> str:
+    """Read CHANGELOG.md from project root."""
+    changelog_path = Path(__file__).parent.parent.parent.parent / "CHANGELOG.md"
+    if not changelog_path.exists():
+        return "CHANGELOG.md not found"
+    return changelog_path.read_text(encoding="utf-8")
+
+
+def _extract_releases(changelog: str, count: int = 1) -> str:
+    """Extract release sections from changelog in reverse order (oldest first).
+
+    Args:
+        changelog: The full changelog content.
+        count: Number of releases to extract (default 1).
+
+    Returns:
+        The content of the specified number of releases, with newest at bottom.
+    """
+    lines = changelog.split("\n")
+    releases: list[list[str]] = []
+    current_release: list[str] = []
+    version_count = 0
+
+    for line in lines:
+        # Skip [Unreleased] section header
+        if line.startswith("## [Unreleased]"):
+            continue
+
+        # Check for version header (e.g., ## [1.2.8] - 2025-12-01)
+        if line.startswith("## [") and "]" in line:
+            if current_release:
+                releases.append(current_release)
+            version_count += 1
+            if version_count > count:
+                break
+            current_release = [line]
+            continue
+
+        if version_count > 0:
+            current_release.append(line)
+
+    # Append the last release if exists
+    if current_release and version_count <= count:
+        releases.append(current_release)
+
+    if not releases:
+        return "No release notes found"
+
+    # Reverse to show oldest first, newest last
+    releases.reverse()
+    return "\n".join("\n".join(release) for release in releases).strip()
+
+
+class ReleaseNotesCommand(CommandABC):
+    """Display the latest release notes from CHANGELOG.md."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.RELEASE_NOTES
+
+    @property
+    def summary(self) -> str:
+        return "Show the latest release notes"
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+        changelog = _read_changelog()
+        content = _extract_releases(changelog, count=10)
+
+        event = events.DeveloperMessageEvent(
+            session_id=agent.session.id,
+            item=model.DeveloperMessageItem(
+                content=content,
+                command_output=model.CommandOutput(command_name=self.name),
+            ),
+        )
+
+        return CommandResult(events=[event])

klaude_code/command/resume_cmd.py

@@ -0,0 +1,111 @@
+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 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):
+    """Resume a previous session."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.RESUME
+
+    @property
+    def summary(self) -> str:
+        return "Resume a previous session"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count > 0:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection.",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        selected_session_id = await asyncio.to_thread(select_session_sync)
+        if selected_session_id is None:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(no session selected)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        return CommandResult(
+            operations=[op.ResumeSessionOperation(target_session_id=selected_session_id)],
+            persist_user_input=False,
+            persist_events=False,
+        )