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

klaude_code/cli/runtime.py

@@ -17,6 +17,7 @@ from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
 from klaude_code.protocol import events, op
 from klaude_code.protocol.model import UserInputPayload
+from klaude_code.session.session import close_default_store
 from klaude_code.trace import DebugType, log, set_debug_logging
 from klaude_code.ui.modes.repl import build_repl_status_snapshot
 from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
@@ -184,6 +185,10 @@ async def cleanup_app_components(components: AppComponents) -> None:
         # Clean shutdown
         await components.executor.stop()
         components.executor_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await components.executor_task
+        with contextlib.suppress(Exception):
+            await close_default_store()
 
         # Signal UI to stop
         await components.event_queue.put(events.EndEvent())

klaude_code/command/__init__.py

@@ -1,4 +1,4 @@
-from .command_abc import CommandABC, CommandResult, InputAction, InputActionType
+from .command_abc import CommandABC, CommandResult
 from .registry import (
     dispatch_command,
     get_commands,
@@ -89,8 +89,6 @@ __all__ = [
     # "StatusCommand", "TerminalSetupCommand",
     "CommandABC",
     "CommandResult",
-    "InputAction",
-    "InputActionType",
     "dispatch_command",
     "ensure_commands_loaded",
     "get_commands",

klaude_code/command/clear_cmd.py

@@ -1,5 +1,5 @@
-from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
-from klaude_code.protocol import commands
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, model, op
 
 
 class ClearCommand(CommandABC):
@@ -13,5 +13,6 @@ 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)])

klaude_code/command/command_abc.py

@@ -1,11 +1,10 @@
 from abc import ABC, abstractmethod
-from enum import Enum
 from typing import Protocol
 
 from pydantic import BaseModel
 
 from klaude_code.llm import LLMClientABC
-from klaude_code.protocol import commands, llm_param
+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
 
@@ -34,40 +33,6 @@ class Agent(Protocol):
     def get_llm_client(self) -> LLMClientABC: ...
 
 
-class InputActionType(str, Enum):
-    """Supported input action kinds."""
-
-    RUN_AGENT = "run_agent"
-    CHANGE_MODEL = "change_model"
-    CLEAR = "clear"
-
-
-class InputAction(BaseModel):
-    """Structured executor action derived from a user input."""
-
-    type: InputActionType
-    text: str = ""
-    model_name: str | None = None
-
-    @classmethod
-    def run_agent(cls, text: str) -> "InputAction":
-        """Create a RunAgent action preserving the provided text."""
-
-        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."""
-
-        return cls(type=InputActionType.CHANGE_MODEL, model_name=model_name)
-
-    @classmethod
-    def clear(cls) -> "InputAction":
-        """Create a Clear action to reset the session."""
-
-        return cls(type=InputActionType.CLEAR)
-
-
 class CommandResult(BaseModel):
     """Result of a command execution."""
 
@@ -75,7 +40,7 @@ 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
 
 
 class CommandABC(ABC):
@@ -109,13 +74,13 @@ class CommandABC(ABC):
         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

@@ -45,8 +45,8 @@ class DebugCommand(CommandABC):
     def placeholder(self) -> str:
         return "filter types"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
-        raw = raw.strip()
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        raw = user_input.text.strip()
 
         # /debug (no args) - enable debug
         if not raw:

klaude_code/command/diff_cmd.py

@@ -16,7 +16,8 @@ class DiffCommand(CommandABC):
     def summary(self) -> str:
         return "Show git diff"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         try:
             # Check if current directory is in a git repository
             git_check = subprocess.run(

klaude_code/command/export_cmd.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
-import subprocess
 from pathlib import Path
 
 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
+from klaude_code.protocol import commands, model, op
 
 
 class ExportCommand(CommandABC):
@@ -31,34 +29,18 @@ class ExportCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
-        try:
-            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")
-            self._open_file(output_path)
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Session exported and opened: {output_path}",
-                    command_output=model.CommandOutput(command_name=self.name),
-                ),
-            )
-            return CommandResult(events=[event])
-        except Exception as exc:  # pragma: no cover - safeguard for unexpected errors
-            import traceback
-
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
-                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                ),
-            )
-            return CommandResult(events=[event])
-
-    def _resolve_output_path(self, raw: str, agent: Agent) -> Path:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        output_path = self._normalize_output_path(user_input.text, agent)
+        return CommandResult(
+            operations=[
+                op.ExportSessionOperation(
+                    session_id=agent.session.id,
+                    output_path=str(output_path) if output_path is not None else None,
+                )
+            ]
+        )
+
+    def _normalize_output_path(self, raw: str, agent: Agent) -> Path | None:
         trimmed = raw.strip()
         if trimmed:
             candidate = Path(trimmed).expanduser()
@@ -67,21 +49,4 @@ class ExportCommand(CommandABC):
             if candidate.suffix.lower() != ".html":
                 candidate = candidate.with_suffix(".html")
             return candidate
-        return get_default_export_path(agent.session)
-
-    def _open_file(self, path: Path) -> None:
-        try:
-            subprocess.run(["open", str(path)], check=True)
-        except FileNotFoundError as exc:  # pragma: no cover - depends on platform
-            msg = "`open` command not found; please open the HTML manually."
-            raise RuntimeError(msg) from exc
-        except subprocess.CalledProcessError as exc:  # pragma: no cover - depends on platform
-            msg = f"Failed to open HTML with `open`: {exc}"
-            raise RuntimeError(msg) from exc
-
-    def _build_html(self, agent: Agent) -> str:
-        profile = agent.profile
-        system_prompt = (profile.system_prompt if profile else "") or ""
-        tools = profile.tools if profile else []
-        model_name = profile.llm_client.model_name if profile else "unknown"
-        return build_export_html(agent.session, system_prompt, tools, model_name)
+        return None

klaude_code/command/export_online_cmd.py

@@ -33,7 +33,8 @@ class ExportOnlineCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         # Check if npx or surge is available
         surge_cmd = self._get_surge_command()
         if not surge_cmd:

klaude_code/command/help_cmd.py

@@ -13,7 +13,8 @@ class HelpCommand(CommandABC):
     def summary(self) -> str:
         return "Show help and available commands"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         lines: list[str] = [
             """
 Usage:

klaude_code/command/model_cmd.py

@@ -1,8 +1,8 @@
 import asyncio
 
-from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.config.select_model import select_model_from_config
-from klaude_code.protocol import commands, events, model
+from klaude_code.protocol import commands, events, model, op
 
 
 class ModelCommand(CommandABC):
@@ -28,8 +28,8 @@ class ModelCommand(CommandABC):
     def placeholder(self) -> str:
         return "model name"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
-        selected_model = await asyncio.to_thread(select_model_from_config, preferred=raw)
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        selected_model = await asyncio.to_thread(select_model_from_config, preferred=user_input.text)
 
         current_model = agent.profile.llm_client.model_name if agent.profile else None
         if selected_model is None or selected_model == current_model:
@@ -45,4 +45,6 @@ class ModelCommand(CommandABC):
                 ]
             )
 
-        return CommandResult(actions=[InputAction.change_model(selected_model)])
+        return CommandResult(
+            operations=[op.ChangeModelOperation(session_id=agent.session.id, model_name=selected_model)]
+        )

klaude_code/command/prompt-jj-workspace.md

@@ -0,0 +1,18 @@
+---
+description: Create a jj workspace before starting work to enable parallel Clauding
+---
+<task>
+$ARGUMENTS
+</task>
+<system>
+You are now in jj-workspace mode. Before working on any task, you MUST first create a dedicated jj workspace. This allows multiple Claude sessions to work in parallel without conflicts.
+
+If the <task> above is empty, inform the user that you are ready to work in jj-workspace mode and waiting for a task description. Once provided, follow the steps below.
+
+When a task is provided, follow these steps:
+1. Generate a short, descriptive workspace name based on the task (e.g., `workspace-add-login` or `workspace-fix-typo`)
+2. Run `jj workspace add <workspace-name>` to create the workspace
+3. Change into the workspace directory: `cd <workspace-name>`
+4. Describe the change: `jj describe -m '<brief task description>'`
+5. Continue all subsequent work within this workspace directory
+</system>

klaude_code/command/prompt_command.py

@@ -2,8 +2,8 @@ from importlib.resources import files
 
 import yaml
 
-from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
-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
 
 
@@ -55,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,5 +1,5 @@
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, events
+from klaude_code.protocol import commands, events, model
 
 
 class RefreshTerminalCommand(CommandABC):
@@ -17,7 +17,8 @@ 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")

klaude_code/command/registry.py

@@ -1,9 +1,9 @@
 from importlib.resources import files
 from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import Agent, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandResult
 from klaude_code.command.prompt_command import PromptCommand
-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:
@@ -110,11 +110,20 @@ def is_slash_command_name(name: str) -> bool:
     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:]
@@ -122,13 +131,29 @@ async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
 
     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)

klaude_code/command/release_notes_cmd.py

@@ -68,7 +68,8 @@ class ReleaseNotesCommand(CommandABC):
     def summary(self) -> str:
         return "Show the latest release notes"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         changelog = _read_changelog()
         content = _extract_releases(changelog, count=10)
 

klaude_code/command/status_cmd.py

@@ -132,7 +132,8 @@ class StatusCommand(CommandABC):
     def summary(self) -> str:
         return "Show session usage statistics"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         session = agent.session
         aggregated = accumulate_session_usage(session)
 

klaude_code/command/terminal_setup_cmd.py

@@ -21,7 +21,8 @@ class TerminalSetupCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         term_program = os.environ.get("TERM_PROGRAM", "").lower()
 
         try:

klaude_code/command/thinking_cmd.py

@@ -169,7 +169,8 @@ class ThinkingCommand(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
         if not agent.profile:
             return self._no_change_result(agent, "No profile configured")