klaude-code 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

klaude_code/cli/main.py

@@ -62,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")
@@ -148,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."""
 
@@ -193,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,15 +8,14 @@ import typer
 from rich.text import Text
 
 from klaude_code import ui
-from klaude_code.command import is_interactive_command
+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.executor import Executor, LLMClients
 from klaude_code.core.tool import SkillLoader, SkillTool
-from klaude_code.llm import LLMClients
 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.modes.repl import build_repl_status_snapshot
 from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
@@ -72,6 +71,7 @@ class AppInitConfig:
     vanilla: bool
     is_exec_mode: bool = False
     debug_filters: set[DebugType] | None = None
+    stream_json: bool = False
 
 
 @dataclass
@@ -148,7 +148,7 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     # Set up UI components using factory functions
     display: ui.DisplayABC
     if init_config.is_exec_mode:
-        display = ui.create_exec_display(debug=init_config.debug)
+        display = ui.create_exec_display(debug=init_config.debug, stream_json=init_config.stream_json)
     else:
         display = ui.create_default_display(debug=init_config.debug, theme=theme)
 
@@ -300,7 +300,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             )
             # 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.text):
+            if has_interactive_command(user_input.text):
                 await components.executor.wait_for(submission_id)
             else:
                 # Esc monitor for long-running, interruptible operations

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,12 +10,13 @@ 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,
 )
+from .status_cmd import StatusCommand
 from .terminal_setup_cmd import TerminalSetupCommand
 
 # Dynamically load prompt commands
@@ -28,12 +29,15 @@ __all__ = [
     "ModelCommand",
     "ExportCommand",
     "RefreshTerminalCommand",
+    "StatusCommand",
     "TerminalSetupCommand",
     "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,8 +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.agent import Agent
-from klaude_code.protocol import commands, events, model
-from klaude_code.session.session import Session
+from klaude_code.protocol import commands
 
 
 @register_command
@@ -18,24 +17,4 @@ class ClearCommand(CommandABC):
         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=[
-                events.DeveloperMessageEvent(
-                    session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content="started new conversation",
-                        command_output=model.CommandOutput(command_name=self.name),
-                    ),
-                ),
-            ]
-        )
+        return CommandResult(actions=[InputAction.clear()])

klaude_code/command/command_abc.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from enum import Enum
 
 from pydantic import BaseModel
 
@@ -7,14 +8,48 @@ 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[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):

klaude_code/command/export_cmd.py

@@ -37,29 +37,25 @@ 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=[
-                    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),
-                        ),
-                    )
-                ]
+            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=[
-                    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),
-                        ),
-                    )
-                ]
+            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:
         trimmed = raw.strip()

klaude_code/command/help_cmd.py

@@ -23,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
 

klaude_code/command/model_cmd.py

@@ -1,12 +1,10 @@
 import asyncio
 
-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.config import load_config, select_model_from_config
+from klaude_code.config import select_model_from_config
 from klaude_code.core.agent import Agent
-from klaude_code.llm import create_llm_client
 from klaude_code.protocol import commands, events, model
-from klaude_code.trace import DebugType, log_debug
 
 
 @register_command
@@ -42,29 +40,4 @@ class ModelCommand(CommandABC):
                 ]
             )
 
-        config = load_config()
-        assert config is not None
-        llm_config = config.get_model_config(selected_model)
-
-        log_debug(
-            "Updated LLM config",
-            llm_config.model_dump_json(exclude_none=True),
-            style="yellow",
-            debug_type=DebugType.LLM_CONFIG,
-        )
-
-        llm_client = create_llm_client(llm_config)
-        agent.set_model_profile(agent.build_model_profile(llm_client))
-
-        return CommandResult(
-            events=[
-                events.DeveloperMessageEvent(
-                    session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=f"switched to model: {selected_model}",
-                        command_output=model.CommandOutput(command_name=self.name),
-                    ),
-                ),
-                events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)),
-            ]
-        )
+        return CommandResult(actions=[InputAction.change_model(selected_model)])

klaude_code/command/{prompt-update-dev-doc.md → prompt-dev-docs-update.md}

@@ -1,6 +1,6 @@
 ---
 description: Update dev documentation before context compaction
-argument-hint: Optional - specific context or tasks to focus on (leave empty for comprehensive update)
+from: https://github.com/diet103/claude-code-infrastructure-showcase/blob/main/.claude/commands/dev-docs-update.md
 ---
 
 We're approaching context limits. Please update the development documentation to ensure seamless continuation after context reset.
@@ -50,6 +50,7 @@ If switching to a new conversation:
 - Any uncommitted changes that need attention
 - Test commands to verify work
 
-## Additional Context: $ARGUMENTS
+## Additional Context:
+$ARGUMENTS
 
 **Priority**: Focus on capturing information that would be hard to rediscover or reconstruct from code alone.

klaude_code/command/{prompt-dev-doc.md → prompt-dev-docs.md}

@@ -1,9 +1,10 @@
 ---
 description: Create a comprehensive strategic plan with structured task breakdown
-argument-hint: Describe what you need planned (e.g., "refactor authentication system", "implement microservices")
+from: https://github.com/diet103/claude-code-infrastructure-showcase/blob/main/.claude/commands/dev-docs.md
 ---
 
-You are an elite strategic planning specialist. Create a comprehensive, actionable plan for: $ARGUMENTS
+Create a comprehensive, actionable plan for: 
+$ARGUMENTS
 
 ## Instructions
 

klaude_code/command/prompt-init.md

@@ -1,6 +1,6 @@
 ---
 description: Create an AGENTS.md file with instructions for agent
-argument-hint: Additional user instructions
+from: https://github.com/openai/codex/blob/main/codex-rs/tui/prompt_for_init_command.md
 ---
 
 Generate/Update a file named AGENTS.md that serves as a contributor guide for this repository.
@@ -42,7 +42,4 @@ Commit & Pull Request Guidelines
 - Summarize commit message conventions found in the project’s Git history.
 - Outline pull request requirements (descriptions, linked issues, screenshots, etc.).
 
-(Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.
-
-Additional Instructions:
-$ARGUMENTS
+(Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.

klaude_code/command/prompt_command.py

@@ -2,7 +2,7 @@ from importlib.resources import files
 
 import yaml
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
 from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands
 
@@ -57,7 +57,7 @@ class PromptCommand(CommandABC):
     async def run(self, raw: str, agent: Agent) -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
-        user_input = raw.strip()
+        user_input = raw.strip() or "<none>"
 
         if "$ARGUMENTS" in template_content:
             final_prompt = template_content.replace("$ARGUMENTS", user_input)
@@ -66,4 +66,4 @@ class PromptCommand(CommandABC):
             if user_input:
                 final_prompt += f"\n\nAdditional Instructions:\n{user_input}"
 
-        return CommandResult(agent_input=final_prompt)
+        return CommandResult(actions=[InputAction.run_agent(final_prompt)])

klaude_code/command/registry.py

@@ -1,7 +1,7 @@
 from importlib.resources import files
 from typing import TYPE_CHECKING, TypeVar
 
-from klaude_code.command.command_abc import CommandResult
+from klaude_code.command.command_abc import CommandResult, InputAction
 from klaude_code.command.prompt_command import PromptCommand
 from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
@@ -40,15 +40,14 @@ def get_commands() -> dict[commands.CommandName | str, "CommandABC"]:
     return _COMMANDS.copy()
 
 
-def get_command_names() -> list[str]:
-    """Get all registered command names for completion."""
-    return [str(k) for k in _COMMANDS.keys()]
+def is_slash_command_name(name: str) -> bool:
+    return name in _COMMANDS
 
 
 async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
     # Detect command name
     if not raw.startswith("/"):
-        return CommandResult(agent_input=raw)
+        return CommandResult(actions=[InputAction.run_agent(raw)])
 
     splits = raw.split(" ", maxsplit=1)
     command_name_raw = splits[0][1:]
@@ -70,7 +69,7 @@ async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
             pass
 
     if command_key is None:
-        return CommandResult(agent_input=raw)
+        return CommandResult(actions=[InputAction.run_agent(raw)])
 
     command = _COMMANDS[command_key]
     command_identifier: commands.CommandName | str = command.name
@@ -96,7 +95,7 @@ async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
         )
 
 
-def is_interactive_command(raw: str) -> bool:
+def has_interactive_command(raw: str) -> bool:
     if not raw.startswith("/"):
         return False
     splits = raw.split(" ", maxsplit=1)

klaude_code/command/status_cmd.py

@@ -0,0 +1,111 @@
+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, model
+from klaude_code.session.session import Session
+
+
+def accumulate_session_usage(session: Session) -> tuple[model.Usage, int]:
+    """Accumulate usage statistics from all ResponseMetadataItems in session history.
+
+    Returns:
+        A tuple of (accumulated_usage, task_count)
+    """
+    total = model.Usage()
+    task_count = 0
+
+    for item in session.conversation_history:
+        if isinstance(item, model.ResponseMetadataItem) and item.usage:
+            task_count += 1
+            usage = item.usage
+            total.input_tokens += usage.input_tokens
+            total.cached_tokens += usage.cached_tokens
+            total.reasoning_tokens += usage.reasoning_tokens
+            total.output_tokens += usage.output_tokens
+            total.total_tokens += usage.total_tokens
+
+            # Accumulate costs
+            if usage.input_cost is not None:
+                total.input_cost = (total.input_cost or 0.0) + usage.input_cost
+            if usage.output_cost is not None:
+                total.output_cost = (total.output_cost or 0.0) + usage.output_cost
+            if usage.cache_read_cost is not None:
+                total.cache_read_cost = (total.cache_read_cost or 0.0) + usage.cache_read_cost
+            if usage.total_cost is not None:
+                total.total_cost = (total.total_cost or 0.0) + usage.total_cost
+
+            # Keep the latest context_usage_percent
+            if usage.context_usage_percent is not None:
+                total.context_usage_percent = usage.context_usage_percent
+
+    return total, task_count
+
+
+def _format_tokens(tokens: int) -> str:
+    """Format token count with K/M suffix for readability."""
+    if tokens >= 1_000_000:
+        return f"{tokens / 1_000_000:.2f}M"
+    if tokens >= 1_000:
+        return f"{tokens / 1_000:.1f}K"
+    return str(tokens)
+
+
+def _format_cost(cost: float | None) -> str:
+    """Format cost in USD."""
+    if cost is None:
+        return "-"
+    if cost < 0.01:
+        return f"${cost:.4f}"
+    return f"${cost:.2f}"
+
+
+def format_status_content(usage: model.Usage) -> str:
+    """Format session status as comma-separated text."""
+    parts: list[str] = []
+
+    parts.append(f"Input: {_format_tokens(usage.input_tokens)}")
+    if usage.cached_tokens > 0:
+        parts.append(f"Cached: {_format_tokens(usage.cached_tokens)}")
+    parts.append(f"Output: {_format_tokens(usage.output_tokens)}")
+    parts.append(f"Total: {_format_tokens(usage.total_tokens)}")
+
+    if usage.total_cost is not None:
+        parts.append(f"Cost: {_format_cost(usage.total_cost)}")
+
+    return ", ".join(parts)
+
+
+@register_command
+class StatusCommand(CommandABC):
+    """Display session usage statistics."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.STATUS
+
+    @property
+    def summary(self) -> str:
+        return "Show session usage statistics"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        session = agent.session
+        usage, task_count = accumulate_session_usage(session)
+
+        event = events.DeveloperMessageEvent(
+            session_id=session.id,
+            item=model.DeveloperMessageItem(
+                content=format_status_content(usage),
+                command_output=model.CommandOutput(
+                    command_name=self.name,
+                    ui_extra=model.ToolResultUIExtra(
+                        type=model.ToolResultUIExtraType.SESSION_STATUS,
+                        session_status=model.SessionStatusUIExtra(
+                            usage=usage,
+                            task_count=task_count,
+                        ),
+                    ),
+                ),
+            ),
+        )
+
+        return CommandResult(events=[event])

klaude_code/config/config.py

@@ -6,8 +6,8 @@ from typing import Any, cast
 import yaml
 from pydantic import BaseModel, Field, ValidationError, model_validator
 
-from klaude_code.core.sub_agent import iter_sub_agent_profiles
 from klaude_code.protocol import llm_param
+from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.trace import log
 
 config_path = Path.home() / ".klaude" / "klaude-config.yaml"

klaude_code/config/list_model.py

@@ -4,7 +4,7 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.config import Config
-from klaude_code.core.sub_agent import iter_sub_agent_profiles
+from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
 
 

klaude_code/const/__init__.py

@@ -109,7 +109,7 @@ STATUS_SHIMMER_PADDING = 10
 # Duration in seconds for one full shimmer sweep across the text
 STATUS_SHIMMER_SWEEP_SECONDS = 2
 # Half-width of the shimmer band in characters
-STATUS_SHIMMER_BAND_HALF_WIDTH = 3.0
+STATUS_SHIMMER_BAND_HALF_WIDTH = 5.0
 # Scale factor applied to shimmer intensity when blending colors
 STATUS_SHIMMER_ALPHA_SCALE = 0.7
 

klaude_code/core/agent.py

@@ -74,11 +74,8 @@ class Agent:
         self,
         session: Session,
         profile: AgentProfile,
-        *,
-        model_profile_provider: ModelProfileProvider | None = None,
     ):
         self.session: Session = session
-        self.model_profile_provider: ModelProfileProvider = model_profile_provider or DefaultModelProfileProvider()
         self.profile: AgentProfile | None = None
         # Active task executor, if any
         self._current_task: TaskExecutor | None = None
@@ -156,14 +153,8 @@ class Agent:
         """Apply a fully constructed profile to the agent."""
 
         self.profile = profile
-        self.session.model_name = profile.llm_client.model_name
-
-    def build_model_profile(
-        self,
-        llm_client: LLMClientABC,
-        sub_agent_type: tools.SubAgentType | None = None,
-    ) -> AgentProfile:
-        return self.model_profile_provider.build_profile(llm_client, sub_agent_type)
+        if not self.session.model_name:
+            self.session.model_name = profile.llm_client.model_name
 
     def get_llm_client(self) -> LLMClientABC:
         return self._require_profile().llm_client