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

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

@@ -1,8 +1,9 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.19
+Version: 1.2.21
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
+Requires-Dist: chardet>=5.2.0
 Requires-Dist: ddgs>=9.9.3
 Requires-Dist: openai>=1.102.0
 Requires-Dist: pillow>=12.0.0

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

@@ -4,12 +4,13 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.19"
+version = "1.2.21"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
     "anthropic>=0.66.0",
+    "chardet>=5.2.0",
     "ddgs>=9.9.3",
     "openai>=1.102.0",
     "pillow>=12.0.0",

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

@@ -194,6 +194,11 @@ def main_callback(
     ),
     continue_: bool = typer.Option(False, "--continue", "-c", help="Continue from latest session"),
     resume: bool = typer.Option(False, "--resume", "-r", help="Select a session to resume for this project"),
+    resume_by_id: str | None = typer.Option(
+        None,
+        "--resume-by-id",
+        help="Resume a session by its ID (must exist)",
+    ),
     select_model: bool = typer.Option(
         False,
         "--select-model",
@@ -224,6 +229,7 @@ def main_callback(
     if ctx.invoked_subcommand is None:
         from klaude_code.cli.runtime import AppInitConfig, run_interactive
         from klaude_code.config.select_model import select_model_from_config
+        from klaude_code.trace import log
 
         update_terminal_title()
 
@@ -236,6 +242,16 @@ def main_callback(
         # Resolve session id before entering asyncio loop
         # session_id=None means create a new session
         session_id: str | None = None
+
+        resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
+        if resume_by_id_value == "":
+            log(("Error: --resume-by-id cannot be empty", "red"))
+            raise typer.Exit(2)
+
+        if resume_by_id_value is not None and (resume or continue_):
+            log(("Error: --resume-by-id cannot be combined with --resume/--continue", "red"))
+            raise typer.Exit(2)
+
         if resume:
             session_id = resume_select_session()
             if session_id is None:
@@ -243,6 +259,13 @@ def main_callback(
         # If user didn't pick, allow fallback to --continue
         if session_id is None and continue_:
             session_id = Session.most_recent_session_id()
+
+        if resume_by_id_value is not None:
+            if not Session.exists(resume_by_id_value):
+                log((f"Error: session id '{resume_by_id_value}' not found for this project", "red"))
+                log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
+                raise typer.Exit(2)
+            session_id = resume_by_id_value
         # If still no session_id, leave as None to create a new session
 
         if session_id is not None and chosen_model is None:

{klaude_code-1.2.19 → klaude_code-1.2.21}/src/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 Session, 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())
@@ -207,6 +212,9 @@ async def _handle_keyboard_interrupt(executor: Executor) -> None:
     """Handle Ctrl+C by logging and sending a global interrupt."""
 
     log("Bye!")
+    session_id = executor.context.current_session_id()
+    if session_id and Session.exists(session_id):
+        log(("Resume with:", "dim"), (f"klaude --resume-by-id {session_id}", "green"))
     # Executor might already be stopping
     with contextlib.suppress(Exception):
         await executor.submit(op.InterruptOperation(target_session_id=None))
@@ -291,6 +299,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
 
+    exit_hint_printed = False
+
     try:
         await initialize_session(components.executor, components.event_queue, session_id=session_id)
         _backfill_session_model_config(
@@ -342,8 +352,15 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     except KeyboardInterrupt:
         await _handle_keyboard_interrupt(components.executor)
+        exit_hint_printed = True
     finally:
         # Restore original SIGINT handler
         with contextlib.suppress(Exception):
             restore_sigint()
         await cleanup_app_components(components)
+
+        if not exit_hint_printed:
+            active_session_id = components.executor.context.current_session_id()
+            if active_session_id and Session.exists(active_session_id):
+                log(f"Session ID: {active_session_id}")
+                log(f"Resume with: klaude --resume-by-id {active_session_id}")

{klaude_code-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.21/src/klaude_code/command/export_cmd.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, model, op
+
+
+class ExportCommand(CommandABC):
+    """Export the current session into a standalone HTML transcript."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.EXPORT
+
+    @property
+    def summary(self) -> str:
+        return "Export current session to HTML"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "output path"
+
+    @property
+    def is_interactive(self) -> bool:
+        return False
+
+    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()
+            if not candidate.is_absolute():
+                candidate = Path(agent.session.work_dir) / candidate
+            if candidate.suffix.lower() != ".html":
+                candidate = candidate.with_suffix(".html")
+            return candidate
+        return None

{klaude_code-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.21/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/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-1.2.19 → klaude_code-1.2.21}/src/klaude_code/command/thinking_cmd.py

@@ -10,6 +10,7 @@ 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"]
+RESPONSES_GEMINI_FLASH_LEVELS = ["minimal", "low", "medium", "high"]
 
 ANTHROPIC_LEVELS: list[tuple[str, int | None]] = [
     ("off", 0),
@@ -48,6 +49,13 @@ def _is_codex_max_model(model_name: str | None) -> bool:
     return "codex-max" in model_name.lower()
 
 
+def _is_gemini_flash_model(model_name: str | None) -> bool:
+    """Check if the model is Gemini 3 Flash."""
+    if not model_name:
+        return False
+    return "gemini-3-flash" in model_name.lower()
+
+
 def _get_levels_for_responses(model_name: str | None) -> list[str]:
     """Get thinking levels for responses protocol."""
     if _is_codex_max_model(model_name):
@@ -56,6 +64,8 @@ def _get_levels_for_responses(model_name: str | None) -> list[str]:
         return RESPONSES_GPT52_LEVELS
     if _is_gpt51_model(model_name):
         return RESPONSES_GPT51_LEVELS
+    if _is_gemini_flash_model(model_name):
+        return RESPONSES_GEMINI_FLASH_LEVELS
     return RESPONSES_LEVELS
 
 
@@ -169,7 +179,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")