klaude-code 1.2.15__py3-none-any.whl → 1.2.17__py3-none-any.whl

klaude_code/cli/main.py

@@ -13,7 +13,7 @@ from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, re
 from klaude_code.cli.session_cmd import register_session_commands
 from klaude_code.config import load_config
 from klaude_code.session import Session, resume_select_session
-from klaude_code.trace import prepare_debug_log_file
+from klaude_code.trace import DebugType, prepare_debug_log_file
 
 
 def set_terminal_title(title: str) -> None:
@@ -22,6 +22,63 @@ def set_terminal_title(title: str) -> None:
     sys.stdout.flush()
 
 
+def setup_terminal_title() -> None:
+    """Set terminal title to current folder name."""
+    folder_name = os.path.basename(os.getcwd())
+    set_terminal_title(f"{folder_name}: klaude")
+
+
+def prepare_debug_logging(debug: bool, debug_filter: str | None) -> tuple[bool, set[DebugType] | None, Path | None]:
+    """Resolve debug settings and prepare log file if debugging is enabled.
+
+    Returns:
+        A tuple of (debug_enabled, debug_filters, log_path).
+        log_path is None if debugging is disabled.
+    """
+    debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
+    log_path: Path | None = None
+    if debug_enabled:
+        log_path = prepare_debug_log_file()
+    return debug_enabled, debug_filters, log_path
+
+
+def read_input_content(cli_argument: str) -> str | None:
+    """Read and merge input from stdin and CLI argument.
+
+    Args:
+        cli_argument: The input content passed as CLI argument.
+
+    Returns:
+        The merged input content, or None if no input was provided.
+    """
+    from klaude_code.trace import log
+
+    parts: list[str] = []
+
+    # Handle stdin input
+    if not sys.stdin.isatty():
+        try:
+            stdin = sys.stdin.read().rstrip("\n")
+            if stdin:
+                parts.append(stdin)
+        except (OSError, ValueError) as e:
+            # Expected I/O-related errors when reading from stdin (e.g. broken pipe, closed stream).
+            log((f"Error reading from stdin: {e}", "red"))
+        except Exception as e:
+            # Unexpected errors are still reported but kept from crashing the CLI.
+            log((f"Unexpected error reading from stdin: {e}", "red"))
+
+    if cli_argument:
+        parts.append(cli_argument)
+
+    content = "\n".join(parts)
+    if len(content) == 0:
+        log(("Error: No input content provided", "red"))
+        return None
+
+    return content
+
+
 def _version_callback(value: bool) -> None:
     """Show version and exit."""
     if value:
@@ -90,33 +147,10 @@ def exec_command(
     ),
 ) -> None:
     """Execute non-interactively with provided input."""
-    from klaude_code.trace import log
-
-    # Set terminal title with current folder name
-    folder_name = os.path.basename(os.getcwd())
-    set_terminal_title(f"{folder_name}: klaude")
-
-    parts: list[str] = []
+    setup_terminal_title()
 
-    # Handle stdin input
-    if not sys.stdin.isatty():
-        try:
-            stdin = sys.stdin.read().rstrip("\n")
-            if stdin:
-                parts.append(stdin)
-        except (OSError, ValueError) as e:
-            # Expected I/O-related errors when reading from stdin (e.g. broken pipe, closed stream).
-            log((f"Error reading from stdin: {e}", "red"))
-        except Exception as e:
-            # Unexpected errors are still reported but kept from crashing the CLI.
-            log((f"Unexpected error reading from stdin: {e}", "red"))
-
-    if input_content:
-        parts.append(input_content)
-
-    input_content = "\n".join(parts)
-    if len(input_content) == 0:
-        log(("Error: No input content provided", "red"))
+    merged_input = read_input_content(input_content)
+    if merged_input is None:
         raise typer.Exit(1)
 
     from klaude_code.cli.runtime import AppInitConfig, run_exec
@@ -133,11 +167,7 @@ def exec_command(
         if chosen_model is None:
             return
 
-    debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
-
-    log_path: Path | None = None
-    if debug_enabled:
-        log_path = prepare_debug_log_file()
+    debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
 
     init_config = AppInitConfig(
         model=chosen_model,
@@ -154,7 +184,7 @@ def exec_command(
     asyncio.run(
         run_exec(
             init_config=init_config,
-            input_content=input_content,
+            input_content=merged_input,
         )
     )
 
@@ -210,10 +240,8 @@ def main_callback(
         from klaude_code.cli.runtime import AppInitConfig, run_interactive
         from klaude_code.config.select_model import select_model_from_config
 
-        # Set terminal title with current folder name
-        folder_name = os.path.basename(os.getcwd())
-        set_terminal_title(f"{folder_name}: klaude")
-        # Interactive mode
+        setup_terminal_title()
+
         chosen_model = model
         if select_model:
             chosen_model = select_model_from_config(preferred=model)
@@ -232,11 +260,7 @@ def main_callback(
             session_id = Session.most_recent_session_id()
         # If still no session_id, leave as None to create a new session
 
-        debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
-
-        log_path: Path | None = None
-        if debug_enabled:
-            log_path = prepare_debug_log_file()
+        debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
 
         init_config = AppInitConfig(
             model=chosen_model,

klaude_code/cli/runtime.py

@@ -127,6 +127,28 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     )
 
 
+async def initialize_session(
+    executor: Executor,
+    event_queue: asyncio.Queue[events.Event],
+    session_id: str | None = None,
+) -> str | None:
+    """Initialize a session and return the active session ID.
+
+    Args:
+        executor: The executor to submit operations to.
+        event_queue: The event queue for synchronization.
+        session_id: Optional session ID to resume. If None, creates a new session.
+
+    Returns:
+        The active session ID, or None if no session is active.
+    """
+    await executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
+    await event_queue.join()
+
+    active_session_ids = executor.context.agent_manager.active_session_ids()
+    return active_session_ids[0] if active_session_ids else session_id
+
+
 async def cleanup_app_components(components: AppComponents) -> None:
     """Clean up all application components."""
     try:
@@ -167,13 +189,7 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
     components = await initialize_app_components(init_config)
 
     try:
-        # Initialize a new session (session_id=None means create new)
-        await components.executor.submit_and_wait(op.InitAgentOperation())
-        await components.event_queue.join()
-
-        # Get the session_id from the newly created agent
-        session_ids = components.executor.context.agent_manager.active_session_ids()
-        session_id = session_ids[0] if session_ids else None
+        session_id = await initialize_session(components.executor, components.event_queue)
 
         # Submit the input content directly
         await components.executor.submit_and_wait(
@@ -245,12 +261,15 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
 
     try:
-        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
-        await components.event_queue.join()
+        await initialize_session(components.executor, components.event_queue, session_id=session_id)
+
+        def _get_active_session_id() -> str | None:
+            """Get the current active session ID dynamically.
 
-        # Get the actual session_id (may have been auto-generated if None was passed)
-        active_session_ids = components.executor.context.agent_manager.active_session_ids()
-        active_session_id = active_session_ids[0] if active_session_ids else session_id
+            This is necessary because /clear command creates a new session with a different ID.
+            """
+            active_ids = components.executor.context.agent_manager.active_session_ids()
+            return active_ids[0] if active_ids else None
 
         # Input
         await input_provider.start()
@@ -261,6 +280,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             elif user_input.text.strip() == "":
                 continue
             # Submit user input operation - directly use the payload from iter_inputs
+            # Use dynamic session_id lookup to handle /clear creating new sessions
+            active_session_id = _get_active_session_id()
             submission_id = await components.executor.submit(
                 op.UserInputOperation(input=user_input, session_id=active_session_id)
             )
@@ -271,7 +292,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             else:
                 # Esc monitor for long-running, interruptible operations
                 async def _on_esc_interrupt() -> None:
-                    await components.executor.submit(op.InterruptOperation(target_session_id=active_session_id))
+                    await components.executor.submit(op.InterruptOperation(target_session_id=_get_active_session_id()))
 
                 stop_event, esc_task = start_esc_interrupt_monitor(_on_esc_interrupt)
                 # Wait for this specific task to complete before accepting next input

klaude_code/command/__init__.py

@@ -30,6 +30,7 @@ def ensure_commands_loaded() -> None:
     from .clear_cmd import ClearCommand
     from .diff_cmd import DiffCommand
     from .export_cmd import ExportCommand
+    from .export_online_cmd import ExportOnlineCommand
     from .help_cmd import HelpCommand
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
@@ -40,6 +41,7 @@ def ensure_commands_loaded() -> None:
 
     # Register in desired display order
     register(ExportCommand())
+    register(ExportOnlineCommand())
     register(RefreshTerminalCommand())
     register(ThinkingCommand())
     register(ModelCommand())
@@ -60,6 +62,7 @@ def __getattr__(name: str) -> object:
         "ClearCommand": "clear_cmd",
         "DiffCommand": "diff_cmd",
         "ExportCommand": "export_cmd",
+        "ExportOnlineCommand": "export_online_cmd",
         "HelpCommand": "help_cmd",
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",

klaude_code/command/export_cmd.py

@@ -25,7 +25,7 @@ class ExportCommand(CommandABC):
 
     @property
     def support_addition_params(self) -> bool:
-        return True
+        return False
 
     @property
     def is_interactive(self) -> bool:
@@ -33,7 +33,7 @@ class ExportCommand(CommandABC):
 
     async def run(self, raw: str, agent: Agent) -> CommandResult:
         try:
-            output_path = self._resolve_output_path(raw, agent)
+            output_path = self._resolve_output_path("", 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")

klaude_code/command/export_online_cmd.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import secrets
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.session.export import build_export_html
+
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
+
+class ExportOnlineCommand(CommandABC):
+    """Export and deploy the current session to surge.sh as a static webpage."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.EXPORT_ONLINE
+
+    @property
+    def summary(self) -> str:
+        return "Export and deploy session to surge.sh"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return False
+
+    @property
+    def is_interactive(self) -> bool:
+        return False
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        # Check if npx or surge is available
+        surge_cmd = self._get_surge_command()
+        if not surge_cmd:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="surge.sh CLI not found. Install with: npm install -g surge",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        # Check if user is logged in to surge
+        if not self._is_surge_logged_in(surge_cmd):
+            login_cmd = " ".join([*surge_cmd, "login"])
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        try:
+            html_doc = self._build_html(agent)
+            domain = self._generate_domain()
+            url = self._deploy_to_surge(surge_cmd, html_doc, domain)
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session deployed to: {url}",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event])
+        except Exception as exc:
+            import traceback
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Failed to deploy session: {exc}\n{traceback.format_exc()}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+    def _get_surge_command(self) -> list[str] | None:
+        """Check if surge CLI is available, prefer npx if available."""
+        # Check for npx first (more common)
+        if shutil.which("npx"):
+            return ["npx", "surge"]
+        # Check for globally installed surge
+        if shutil.which("surge"):
+            return ["surge"]
+        return None
+
+    def _is_surge_logged_in(self, surge_cmd: list[str]) -> bool:
+        """Check if user is logged in to surge.sh via 'surge whoami'."""
+        try:
+            cmd = [*surge_cmd, "whoami"]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            # If logged in, whoami returns 0 and prints the email
+            # If not logged in, it returns non-zero or prints "Not Authenticated"
+            if result.returncode != 0:
+                return False
+            output = (result.stdout + result.stderr).lower()
+            if "not authenticated" in output or "not logged in" in output:
+                return False
+            return bool(result.stdout.strip())
+        except (subprocess.TimeoutExpired, OSError):
+            return False
+
+    def _generate_domain(self) -> str:
+        """Generate a random subdomain for surge.sh."""
+        random_suffix = secrets.token_hex(4)
+        return f"klaude-session-{random_suffix}.surge.sh"
+
+    def _deploy_to_surge(self, surge_cmd: list[str], html_content: str, domain: str) -> str:
+        """Deploy HTML content to surge.sh and return the URL."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            html_path = Path(tmpdir) / "index.html"
+            html_path.write_text(html_content, encoding="utf-8")
+
+            # Run surge with --domain flag
+            cmd = [*surge_cmd, tmpdir, "--domain", domain]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr or result.stdout or "Unknown error"
+                raise RuntimeError(f"Surge deployment failed: {error_msg}")
+
+            return f"https://{domain}"
+
+    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)

klaude_code/command/prompt-handoff.md

@@ -0,0 +1,33 @@
+---
+description: Write a HANDOFF.md for another agent to continue the conversation
+from: amp-cli https://ampcode.com/manual#handoff
+---
+
+Write a HANDOFF.md file in the current working directory for another agent to continue this conversation.
+
+Extract relevant context from the conversation above to facilitate continuing this work. Write from my perspective (first person: "I did...", "I told you...").
+
+Consider what would be useful to know based on my request below. Relevant questions include:
+- What did I just do or implement?
+- What instructions did I give you that are still relevant (e.g., follow patterns in the codebase)?
+- Did I provide a plan or spec that should be included?
+- What important information did I share (certain libraries, patterns, constraints, preferences)?
+- What key technical details did I discover (APIs, methods, patterns)?
+- What caveats, limitations, or open questions remain?
+
+Extract only what matters for the specific request below. Skip irrelevant questions. Choose an appropriate length based on the complexity of the request.
+
+Focus on capabilities and behavior, not file-by-file changes. Avoid excessive implementation details (variable names, storage keys, constants) unless critical.
+
+Format: Plain text with bullets. No markdown headers, no bold/italic, no code fences. Use workspace-relative paths for files.
+
+List file or directory paths (workspace-relative) relevant to accomplishing the goal in the following format:
+<example>
+@src/project/main.py
+@src/project/llm/
+</example>
+
+My request:
+$ARGUMENTS
+
+<system>If the request section is empty, ask for clarification about the goal</system>

klaude_code/command/thinking_cmd.py

@@ -211,7 +211,11 @@ class ThinkingCommand(CommandABC):
                         content=f"Thinking changed: {current} -> {new_status}",
                         command_output=model.CommandOutput(command_name=self.name),
                     ),
-                )
+                ),
+                events.WelcomeEvent(
+                    work_dir=str(agent.session.work_dir),
+                    llm_config=config,
+                ),
             ]
         )
 

klaude_code/config/config.py

@@ -23,20 +23,20 @@ class Config(BaseModel):
     provider_list: list[llm_param.LLMConfigProviderParameter]
     model_list: list[ModelConfig]
     main_model: str
-    subagent_models: dict[str, str] = Field(default_factory=dict)
+    sub_agent_models: dict[str, str] = Field(default_factory=dict)
     theme: str | None = None
 
     @model_validator(mode="before")
     @classmethod
-    def _normalize_subagent_models(cls, data: dict[str, Any]) -> dict[str, Any]:
-        raw_val: Any = data.get("subagent_models") or {}
+    def _normalize_sub_agent_models(cls, data: dict[str, Any]) -> dict[str, Any]:
+        raw_val: Any = data.get("sub_agent_models") or {}
         raw_models: dict[str, Any] = cast(dict[str, Any], raw_val) if isinstance(raw_val, dict) else {}
         normalized: dict[str, str] = {}
         key_map = {p.name.lower(): p.name for p in iter_sub_agent_profiles()}
         for key, value in dict(raw_models).items():
             canonical = key_map.get(str(key).lower(), str(key))
             normalized[canonical] = str(value)
-        data["subagent_models"] = normalized
+        data["sub_agent_models"] = normalized
         return data
 
     def get_main_model_config(self) -> llm_param.LLMConfigParameter:
@@ -79,8 +79,8 @@ class Config(BaseModel):
 
 def get_example_config() -> Config:
     return Config(
-        main_model="gpt-5.1",
-        subagent_models={"explore": "haiku", "oracle": "gpt-5.1-high"},
+        main_model="opus",
+        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.1", "webagent": "haiku", "task": "opus"},
         provider_list=[
             llm_param.LLMConfigProviderParameter(
                 provider_name="openai",
@@ -93,6 +93,11 @@ def get_example_config() -> Config:
                 protocol=llm_param.LLMClientProtocol.OPENROUTER,
                 api_key="your-openrouter-api-key",
             ),
+            llm_param.LLMConfigProviderParameter(
+                provider_name="anthropic",
+                protocol=llm_param.LLMClientProtocol.ANTHROPIC,
+                api_key="your-anthropic-api-key",
+            ),
         ],
         model_list=[
             ModelConfig(
@@ -100,31 +105,25 @@ def get_example_config() -> Config:
                 provider="openai",
                 model_params=llm_param.LLMConfigModelParameter(
                     model="gpt-5.1-2025-11-13",
-                    max_tokens=32000,
                     verbosity="medium",
                     thinking=llm_param.Thinking(
-                        reasoning_effort="medium",
+                        reasoning_effort="high",
                         reasoning_summary="auto",
-                        type="enabled",
-                        budget_tokens=None,
                     ),
-                    context_limit=368000,
+                    context_limit=400000,
                 ),
             ),
             ModelConfig(
-                model_name="gpt-5.1-high",
-                provider="openai",
+                model_name="opus",
+                provider="anthropic",
                 model_params=llm_param.LLMConfigModelParameter(
-                    model="gpt-5.1-2025-11-13",
-                    max_tokens=32000,
-                    verbosity="medium",
+                    model="claude-opus-4-5-20251101",
+                    verbosity="high",
                     thinking=llm_param.Thinking(
-                        reasoning_effort="high",
-                        reasoning_summary="auto",
                         type="enabled",
-                        budget_tokens=None,
+                        budget_tokens=31999,
                     ),
-                    context_limit=368000,
+                    context_limit=200000,
                 ),
             ),
             ModelConfig(
@@ -136,7 +135,7 @@ def get_example_config() -> Config:
                     provider_routing=llm_param.OpenRouterProviderRouting(
                         sort="throughput",
                     ),
-                    context_limit=168000,
+                    context_limit=200000,
                 ),
             ),
         ],

klaude_code/config/list_model.py

@@ -198,7 +198,7 @@ def display_models_and_providers(config: Config):
     )
 
     for profile in iter_sub_agent_profiles():
-        sub_model_name = config.subagent_models.get(profile.name)
+        sub_model_name = config.sub_agent_models.get(profile.name)
         if not sub_model_name:
             continue
         console.print(

klaude_code/const/__init__.py

@@ -105,6 +105,9 @@ UI_REFRESH_RATE_FPS = 20
 # Number of lines to keep visible at bottom of markdown streaming window
 MARKDOWN_STREAM_LIVE_WINDOW = 20
 
+# Status hint text shown after spinner status
+STATUS_HINT_TEXT = " (esc to interrupt)"
+
 # Status shimmer animation
 # Horizontal padding used when computing shimmer band position
 STATUS_SHIMMER_PADDING = 10

klaude_code/core/executor.py

@@ -96,7 +96,7 @@ class ExecutorContext:
         # Delegate responsibilities to helper components
         self.agent_manager = AgentManager(event_queue, llm_clients, resolved_profile_provider)
         self.task_manager = TaskManager()
-        self.subagent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
+        self.sub_agent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
 
     async def emit_event(self, event: events.Event) -> None:
         """Emit an event to the UI display system."""
@@ -240,7 +240,7 @@ class ExecutorContext:
 
             # Inject subtask runner into tool context for nested Task tool usage
             async def _runner(state: model.SubAgentState) -> SubAgentResult:
-                return await self.subagent_manager.run_subagent(agent, state)
+                return await self.sub_agent_manager.run_sub_agent(agent, state)
 
             token = current_run_subtask_callback.set(_runner)
             try:

klaude_code/core/manager/llm_clients_builder.py

@@ -32,7 +32,7 @@ def build_llm_clients(
     sub_clients: dict[SubAgentType, LLMClientABC] = {}
 
     for profile in iter_sub_agent_profiles():
-        model_name = config.subagent_models.get(profile.name)
+        model_name = config.sub_agent_models.get(profile.name)
         if not model_name:
             continue