klaude-code 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/cli/main.py

@@ -9,12 +9,10 @@ import typer
 
 from klaude_code.cli.runtime import DEBUG_FILTER_HELP, AppInitConfig, resolve_debug_settings, run_exec, run_interactive
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.config import config_path, load_config
-from klaude_code.config.list_model import display_models_and_providers
-from klaude_code.config.select_model import select_model_from_config
+from klaude_code.config import config_path, display_models_and_providers, load_config, select_model_from_config
 from klaude_code.session import Session, resume_select_session
 from klaude_code.trace import log
-from klaude_code.ui.base.terminal_color import is_light_terminal_background
+from klaude_code.ui.terminal.color import is_light_terminal_background
 
 
 def set_terminal_title(title: str) -> None:
@@ -64,6 +62,7 @@ def list_models() -> None:
 
 
 @app.command("config")
+@app.command("conf", hidden=True)
 def edit_config() -> None:
     """Open the configuration file in $EDITOR or default system editor"""
     editor = os.environ.get("EDITOR")
@@ -150,6 +149,11 @@ def exec_command(
         "--vanilla",
         help="Vanilla mode exposes the model's raw API behavior: it provides only minimal tools (Bash, Read & Edit) and omits system prompts and reminders.",
     ),
+    stream_json: bool = typer.Option(
+        False,
+        "--stream-json",
+        help="Stream all events as JSON lines to stdout.",
+    ),
 ) -> None:
     """Execute non-interactively with provided input."""
 
@@ -195,6 +199,7 @@ def exec_command(
         vanilla=vanilla,
         is_exec_mode=True,
         debug_filters=debug_filters,
+        stream_json=stream_json,
     )
 
     asyncio.run(

klaude_code/cli/runtime.py

@@ -8,26 +8,20 @@ import typer
 from rich.text import Text
 
 from klaude_code import ui
-from klaude_code.command.registry import is_interactive_command
-from klaude_code.config import load_config
-from klaude_code.config.config import Config
+from klaude_code.command import has_interactive_command
+from klaude_code.config import Config, load_config
 from klaude_code.core.agent import DefaultModelProfileProvider, VanillaModelProfileProvider
-from klaude_code.core.executor import Executor
-from klaude_code.core.sub_agent import iter_sub_agent_profiles
-from klaude_code.core.tool.memory.skill_loader import SkillLoader
-from klaude_code.core.tool.memory.skill_tool import SkillTool
-from klaude_code.llm import LLMClients
-from klaude_code.protocol import op
-from klaude_code.protocol.events import EndEvent, Event
+from klaude_code.core.executor import Executor, LLMClients
+from klaude_code.core.tool import SkillLoader, SkillTool
+from klaude_code.protocol import events, op
+from klaude_code.protocol.model import UserInputPayload
+from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.trace import DebugType, log, set_debug_logging
-from klaude_code.ui.base.progress_bar import OSC94States, emit_osc94
-from klaude_code.ui.base.terminal_color import is_light_terminal_background
-from klaude_code.ui.base.terminal_control import (
-    install_sigint_double_press_exit,
-    start_esc_interrupt_monitor,
-)
-from klaude_code.ui.repl import build_repl_status_snapshot
-from klaude_code.ui.repl.input import REPLStatusSnapshot
+from klaude_code.ui.modes.repl import build_repl_status_snapshot
+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
 
 
@@ -52,7 +46,12 @@ def _parse_debug_filters(raw: str | None) -> set[DebugType] | None:
             filters.add(DebugType(normalized))
         except ValueError:  # pragma: no cover - user input validation
             valid_options = ", ".join(dt.value for dt in DebugType)
-            log((f"Invalid debug filter '{normalized}'. Valid options: {valid_options}", "red"))
+            log(
+                (
+                    f"Invalid debug filter '{normalized}'. Valid options: {valid_options}",
+                    "red",
+                )
+            )
             raise typer.Exit(2) from None
     return filters or None
 
@@ -72,6 +71,7 @@ class AppInitConfig:
     vanilla: bool
     is_exec_mode: bool = False
     debug_filters: set[DebugType] | None = None
+    stream_json: bool = False
 
 
 @dataclass
@@ -81,7 +81,7 @@ class AppComponents:
     config: Config
     executor: Executor
     executor_task: asyncio.Task[None]
-    event_queue: asyncio.Queue[Event]
+    event_queue: asyncio.Queue[events.Event]
     display: ui.DisplayABC
     display_task: asyncio.Task[None]
     theme: str | None
@@ -110,7 +110,12 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
         )
     except ValueError as exc:
         if init_config.model:
-            log((f"Error: model '{init_config.model}' is not defined in the config", "red"))
+            log(
+                (
+                    f"Error: model '{init_config.model}' is not defined in the config",
+                    "red",
+                )
+            )
             log(("Hint: run `klaude list` to view available models", "yellow"))
         else:
             log((f"Error: failed to load the default model configuration: {exc}", "red"))
@@ -119,7 +124,7 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     model_profile_provider = VanillaModelProfileProvider() if init_config.vanilla else DefaultModelProfileProvider()
 
     # Create event queue for communication between executor and UI
-    event_queue: asyncio.Queue[Event] = asyncio.Queue()
+    event_queue: asyncio.Queue[events.Event] = asyncio.Queue()
 
     # Create executor with the LLM client
     executor = Executor(
@@ -140,15 +145,12 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
         elif detected is False:
             theme = "dark"
 
-    # Set up UI components
+    # Set up UI components using factory functions
     display: ui.DisplayABC
     if init_config.is_exec_mode:
-        # Use ExecDisplay for exec mode - only shows task results
-        display = ui.ExecDisplay()
+        display = ui.create_exec_display(debug=init_config.debug, stream_json=init_config.stream_json)
     else:
-        # Use REPLDisplay for interactive mode
-        repl_display = ui.REPLDisplay(theme=theme)
-        display = repl_display if not init_config.debug else ui.DebugEventDisplay(repl_display)
+        display = ui.create_default_display(debug=init_config.debug, theme=theme)
 
     # Start UI display task
     display_task = asyncio.create_task(display.consume_event_loop(event_queue))
@@ -172,7 +174,7 @@ async def cleanup_app_components(components: AppComponents) -> None:
         components.executor_task.cancel()
 
         # Signal UI to stop
-        await components.event_queue.put(EndEvent())
+        await components.event_queue.put(events.EndEvent())
         await components.display_task
     finally:
         # Always attempt to clear Ghostty progress bar and restore cursor visibility
@@ -214,15 +216,13 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
         session_id = uuid.uuid4().hex
 
         # Init Agent
-        init_id = await components.executor.submit(op.InitAgentOperation(session_id=session_id))
-        await components.executor.wait_for_completion(init_id)
+        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
         await components.event_queue.join()
 
         # Submit the input content directly
-        submission_id = await components.executor.submit(
-            op.UserInputOperation(content=input_content, session_id=session_id)
+        await components.executor.submit_and_wait(
+            op.UserInputOperation(input=UserInputPayload(text=input_content), session_id=session_id)
         )
-        await components.executor.wait_for_completion(submission_id)
 
     except KeyboardInterrupt:
         await _handle_keyboard_interrupt(components.executor)
@@ -284,25 +284,24 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     try:
         # Init Agent
-        init_id = await components.executor.submit(op.InitAgentOperation(session_id=session_id))
-        await components.executor.wait_for_completion(init_id)
+        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
         await components.event_queue.join()
         # Input
         await input_provider.start()
         async for user_input in input_provider.iter_inputs():
             # Handle special commands
-            if user_input.strip().lower() in {"exit", ":q", "quit"}:
+            if user_input.text.strip().lower() in {"exit", ":q", "quit"}:
                 break
-            elif user_input.strip() == "":
+            elif user_input.text.strip() == "":
                 continue
-            # Submit user input operation
+            # Submit user input operation - directly use the payload from iter_inputs
             submission_id = await components.executor.submit(
-                op.UserInputOperation(content=user_input, session_id=session_id)
+                op.UserInputOperation(input=user_input, session_id=session_id)
             )
             # If it's an interactive command (e.g., /model), avoid starting the ESC monitor
             # to prevent TTY conflicts with interactive prompts (questionary/prompt_toolkit).
-            if is_interactive_command(user_input):
-                await components.executor.wait_for_completion(submission_id)
+            if has_interactive_command(user_input.text):
+                await components.executor.wait_for(submission_id)
             else:
                 # Esc monitor for long-running, interruptible operations
                 async def _on_esc_interrupt() -> None:
@@ -311,7 +310,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 stop_event, esc_task = start_esc_interrupt_monitor(_on_esc_interrupt)
                 # Wait for this specific task to complete before accepting next input
                 try:
-                    await components.executor.wait_for_completion(submission_id)
+                    await components.executor.wait_for(submission_id)
                 finally:
                     # Stop ESC monitor and wait for it to finish cleaning up TTY
                     stop_event.set()

klaude_code/command/__init__.py

@@ -1,5 +1,5 @@
 from .clear_cmd import ClearCommand
-from .command_abc import CommandABC, CommandResult
+from .command_abc import CommandABC, CommandResult, InputAction, InputActionType
 from .diff_cmd import DiffCommand
 from .export_cmd import ExportCommand
 from .help_cmd import HelpCommand
@@ -10,9 +10,9 @@ from .model_cmd import ModelCommand
 from .refresh_cmd import RefreshTerminalCommand
 from .registry import (
     dispatch_command,
-    get_command_names,
     get_commands,
-    is_interactive_command,
+    has_interactive_command,
+    is_slash_command_name,
     load_prompt_commands,
     register_command,
 )
@@ -32,8 +32,10 @@ __all__ = [
     "register_command",
     "CommandABC",
     "CommandResult",
+    "InputAction",
+    "InputActionType",
     "dispatch_command",
     "get_commands",
-    "get_command_names",
-    "is_interactive_command",
+    "is_slash_command_name",
+    "has_interactive_command",
 ]

klaude_code/command/clear_cmd.py

@@ -1,10 +1,7 @@
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
 from klaude_code.command.registry import register_command
-from klaude_code.core import Agent
-from klaude_code.protocol.commands import CommandName
-from klaude_code.protocol.events import DeveloperMessageEvent
-from klaude_code.protocol.model import CommandOutput, DeveloperMessageItem
-from klaude_code.session.session import Session
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands
 
 
 @register_command
@@ -12,32 +9,12 @@ class ClearCommand(CommandABC):
     """Clear current session and start a new conversation"""
 
     @property
-    def name(self) -> CommandName:
-        return CommandName.CLEAR
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.CLEAR
 
     @property
     def summary(self) -> str:
         return "Clear conversation history and free up context"
 
     async def run(self, raw: str, agent: Agent) -> CommandResult:
-        # Create a new session instance to replace the current one
-        new_session = Session(work_dir=agent.session.work_dir)
-        new_session.model_name = agent.session.model_name
-
-        # Replace the agent's session with the new one
-        agent.session = new_session
-
-        # Save the new session
-        agent.session.save()
-
-        return CommandResult(
-            events=[
-                DeveloperMessageEvent(
-                    session_id=agent.session.id,
-                    item=DeveloperMessageItem(
-                        content="started new conversation",
-                        command_output=CommandOutput(command_name=self.name),
-                    ),
-                ),
-            ]
-        )
+        return CommandResult(actions=[InputAction.clear()])

klaude_code/command/command_abc.py

@@ -1,19 +1,55 @@
 from abc import ABC, abstractmethod
+from enum import Enum
 
 from pydantic import BaseModel
 
-from klaude_code.core import Agent
-from klaude_code.protocol.commands import CommandName
-from klaude_code.protocol.events import DeveloperMessageEvent, ReplayHistoryEvent, WelcomeEvent
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands
+from klaude_code.protocol import events as protocol_events
+
+
+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."""
 
-    agent_input: str | None = None  # Input to be submitted to agent, or None if no input needed
-    events: list[DeveloperMessageEvent | WelcomeEvent | ReplayHistoryEvent] | None = (
-        None  # List of UI events to display immediately
-    )
+    events: (
+        list[protocol_events.DeveloperMessageEvent | protocol_events.WelcomeEvent | protocol_events.ReplayHistoryEvent]
+        | None
+    ) = None  # List of UI events to display immediately
+    actions: list[InputAction] | None = None
 
 
 class CommandABC(ABC):
@@ -21,7 +57,7 @@ class CommandABC(ABC):
 
     @property
     @abstractmethod
-    def name(self) -> CommandName | str:
+    def name(self) -> commands.CommandName | str:
         """Command name without the leading slash."""
         pass
 

klaude_code/command/diff_cmd.py

@@ -3,10 +3,8 @@ from pathlib import Path
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core import Agent
-from klaude_code.protocol.commands import CommandName
-from klaude_code.protocol.events import DeveloperMessageEvent
-from klaude_code.protocol.model import CommandOutput, DeveloperMessageItem
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands, events, model
 
 
 @register_command
@@ -14,8 +12,8 @@ class DiffCommand(CommandABC):
     """Show git diff for the current repository."""
 
     @property
-    def name(self) -> CommandName:
-        return CommandName.DIFF
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.DIFF
 
     @property
     def summary(self) -> str:
@@ -34,28 +32,32 @@ class DiffCommand(CommandABC):
 
             if git_check.returncode != 0:
                 # Not in a git repository
-                event = DeveloperMessageEvent(
+                event = events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=DeveloperMessageItem(
+                    item=model.DeveloperMessageItem(
                         content="No in a git repo",
-                        command_output=CommandOutput(command_name=self.name, is_error=True),
+                        command_output=model.CommandOutput(command_name=self.name, is_error=True),
                     ),
                 )
                 return CommandResult(events=[event])
 
             # Run git diff in current directory
             result = subprocess.run(
-                ["git", "diff", "HEAD"], cwd=Path.cwd(), capture_output=True, text=True, timeout=10.0
+                ["git", "diff", "HEAD"],
+                cwd=Path.cwd(),
+                capture_output=True,
+                text=True,
+                timeout=10.0,
             )
 
             if result.returncode != 0:
                 # Git command failed
                 error_msg = result.stderr.strip() or "git diff command failed"
-                event = DeveloperMessageEvent(
+                event = events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=DeveloperMessageItem(
+                    item=model.DeveloperMessageItem(
                         content=f"Error: {error_msg}",
-                        command_output=CommandOutput(command_name=self.name, is_error=True),
+                        command_output=model.CommandOutput(command_name=self.name, is_error=True),
                     ),
                 )
                 return CommandResult(events=[event])
@@ -88,45 +90,49 @@ class DiffCommand(CommandABC):
 
             if not output_parts:
                 # No changes and no untracked files
-                event = DeveloperMessageEvent(
+                event = events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=DeveloperMessageItem(content="", command_output=CommandOutput(command_name=self.name)),
+                    item=model.DeveloperMessageItem(
+                        content="", command_output=model.CommandOutput(command_name=self.name)
+                    ),
                 )
                 return CommandResult(events=[event])
 
             # Has changes or untracked files
             combined_output = "\n\n".join(output_parts)
-            event = DeveloperMessageEvent(
+            event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=DeveloperMessageItem(
-                    content=combined_output, command_output=CommandOutput(command_name=self.name)
+                item=model.DeveloperMessageItem(
+                    content=combined_output,
+                    command_output=model.CommandOutput(command_name=self.name),
                 ),
             )
             return CommandResult(events=[event])
 
         except subprocess.TimeoutExpired:
-            event = DeveloperMessageEvent(
+            event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=DeveloperMessageItem(
+                item=model.DeveloperMessageItem(
                     content="Error: git diff command timeout",
-                    command_output=CommandOutput(command_name=self.name, is_error=True),
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
                 ),
             )
             return CommandResult(events=[event])
         except FileNotFoundError:
-            event = DeveloperMessageEvent(
+            event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=DeveloperMessageItem(
+                item=model.DeveloperMessageItem(
                     content="Error: git command not found",
-                    command_output=CommandOutput(command_name=self.name, is_error=True),
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
                 ),
             )
             return CommandResult(events=[event])
         except Exception as e:
-            event = DeveloperMessageEvent(
+            event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=DeveloperMessageItem(
-                    content=f"Error：{e}", command_output=CommandOutput(command_name=self.name, is_error=True)
+                item=model.DeveloperMessageItem(
+                    content=f"Error：{e}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
                 ),
             )
             return CommandResult(events=[event])

klaude_code/command/export_cmd.py

@@ -5,10 +5,8 @@ from pathlib import Path
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core import Agent
-from klaude_code.protocol.commands import CommandName
-from klaude_code.protocol.events import DeveloperMessageEvent
-from klaude_code.protocol.model import CommandOutput, DeveloperMessageItem
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands, events, model
 from klaude_code.session.export import build_export_html, get_default_export_path
 
 
@@ -17,8 +15,8 @@ class ExportCommand(CommandABC):
     """Export the current session into a standalone HTML transcript."""
 
     @property
-    def name(self) -> CommandName:
-        return CommandName.EXPORT
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.EXPORT
 
     @property
     def summary(self) -> str:
@@ -39,29 +37,23 @@ class ExportCommand(CommandABC):
             output_path.parent.mkdir(parents=True, exist_ok=True)
             output_path.write_text(html_doc, encoding="utf-8")
             self._open_file(output_path)
-            return CommandResult(
-                events=[
-                    DeveloperMessageEvent(
-                        session_id=agent.session.id,
-                        item=DeveloperMessageItem(
-                            content=f"Session exported and opened: {output_path}",
-                            command_output=CommandOutput(command_name=self.name),
-                        ),
-                    )
-                ]
+            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
-            return CommandResult(
-                events=[
-                    DeveloperMessageEvent(
-                        session_id=agent.session.id,
-                        item=DeveloperMessageItem(
-                            content=f"Failed to export session: {exc}",
-                            command_output=CommandOutput(command_name=self.name, is_error=True),
-                        ),
-                    )
-                ]
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Failed to export session: {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:
         trimmed = raw.strip()

klaude_code/command/help_cmd.py

@@ -1,9 +1,7 @@
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core import Agent
-from klaude_code.protocol.commands import CommandName
-from klaude_code.protocol.events import DeveloperMessageEvent
-from klaude_code.protocol.model import CommandOutput, DeveloperMessageItem
+from klaude_code.core.agent import Agent
+from klaude_code.protocol import commands, events, model
 
 
 @register_command
@@ -11,8 +9,8 @@ class HelpCommand(CommandABC):
     """Display help information for all available slash commands."""
 
     @property
-    def name(self) -> CommandName:
-        return CommandName.HELP
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.HELP
 
     @property
     def summary(self) -> str:
@@ -25,6 +23,7 @@ Usage:
   [b]@[/b] to mention file
   [b]esc[/b] to interrupt agent task
   [b]shift-enter[/b] or [b]ctrl-j[/b] for new line
+  [b]ctrl-v[/b] for pasting image
   [b]--continue[/b] or [b]--resume[/b] to continue an old session
   [b]--select-model[/b] to switch model
 
@@ -41,9 +40,12 @@ Available slash commands:"""
                 additional_instructions = " \\[additional instructions]" if cmd_obj.support_addition_params else ""
                 lines.append(f"  [b]/{cmd_name}[/b]{additional_instructions} — {cmd_obj.summary}")
 
-        event = DeveloperMessageEvent(
+        event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
-            item=DeveloperMessageItem(content="\n".join(lines), command_output=CommandOutput(command_name=self.name)),
+            item=model.DeveloperMessageItem(
+                content="\n".join(lines),
+                command_output=model.CommandOutput(command_name=self.name),
+            ),
         )
 
         return CommandResult(events=[event])