klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/command/export_cmd.py

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

klaude_code/command/export_online_cmd.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import secrets
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from rich.console import Console
+from rich.text import Text
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.session.export import build_export_html
+
+
+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, 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:
+            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])
+
+        try:
+            console = Console()
+            # Check login status inside status context since npx surge whoami can be slow
+            with console.status(Text("Checking surge.sh login status...", style="dim"), spinner_style="dim"):
+                logged_in = self._is_surge_logged_in(surge_cmd)
+
+            if not logged_in:
+                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])
+
+            with console.status(Text("Deploying to surge.sh...", style="dim"), spinner_style="dim"):
+                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/fork_session_cmd.py

@@ -0,0 +1,267 @@
+import asyncio
+import sys
+from dataclasses import dataclass
+from typing import Literal
+
+from prompt_toolkit.styles import Style
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.ui.modes.repl.clipboard import copy_to_clipboard
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+FORK_SELECT_STYLE = Style(
+    [
+        ("msg", ""),
+        ("meta", "fg:ansibrightblack"),
+        ("separator", "fg:ansibrightblack"),
+        ("assistant", "fg:ansiblue"),
+        ("pointer", "bold fg:ansigreen"),
+        ("search_prefix", "fg:ansibrightblack"),
+        ("search_success", "noinherit fg:ansigreen"),
+        ("search_none", "noinherit fg:ansired"),
+        ("question", "bold"),
+        ("text", ""),
+    ]
+)
+
+
+@dataclass
+class ForkPoint:
+    """A fork point in conversation history."""
+
+    history_index: int | None  # None means fork entire conversation
+    user_message: str
+    tool_call_stats: dict[str, int]  # tool_name -> count
+    last_assistant_summary: str
+
+
+def _truncate(text: str, max_len: int = 60) -> str:
+    """Truncate text to max_len, adding ellipsis if needed."""
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 3] + "..."
+
+
+def _build_fork_points(conversation_history: list[model.ConversationItem]) -> list[ForkPoint]:
+    """Build list of fork points from conversation history.
+
+    Fork points are:
+    - Each UserMessageItem position (for UI display, including first which would be empty session)
+    - The end of the conversation (fork entire conversation)
+    """
+    fork_points: list[ForkPoint] = []
+    user_indices: list[int] = []
+
+    for i, item in enumerate(conversation_history):
+        if isinstance(item, model.UserMessageItem):
+            user_indices.append(i)
+
+    # For each UserMessageItem, create a fork point at that position
+    for i, user_idx in enumerate(user_indices):
+        user_item = conversation_history[user_idx]
+        assert isinstance(user_item, model.UserMessageItem)
+
+        # Find the end of this "task" (next UserMessageItem or end of history)
+        next_user_idx = user_indices[i + 1] if i + 1 < len(user_indices) else len(conversation_history)
+
+        # Count tool calls by name and find last assistant message in this segment
+        tool_stats: dict[str, int] = {}
+        last_assistant_content = ""
+        for j in range(user_idx, next_user_idx):
+            item = conversation_history[j]
+            if isinstance(item, model.ToolCallItem):
+                tool_stats[item.name] = tool_stats.get(item.name, 0) + 1
+            elif isinstance(item, model.AssistantMessageItem) and item.content:
+                last_assistant_content = item.content
+
+        fork_points.append(
+            ForkPoint(
+                history_index=user_idx,
+                user_message=user_item.content or "(empty)",
+                tool_call_stats=tool_stats,
+                last_assistant_summary=_truncate(last_assistant_content) if last_assistant_content else "",
+            )
+        )
+
+    # Add the "fork entire conversation" option at the end
+    if user_indices:
+        fork_points.append(
+            ForkPoint(
+                history_index=None,  # None means fork entire conversation
+                user_message="",  # No specific message, this represents the end
+                tool_call_stats={},
+                last_assistant_summary="",
+            )
+        )
+
+    return fork_points
+
+
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+    """Build SelectItem list from fork points."""
+    items: list[SelectItem[int | None]] = []
+
+    for i, fp in enumerate(fork_points):
+        is_first = i == 0
+        is_last = i == len(fork_points) - 1
+
+        # Build the title
+        title_parts: list[tuple[str, str]] = []
+
+        # First line: separator (with special markers for first/last fork points)
+        if is_first and not is_last:
+            title_parts.append(("class:separator", "----- fork from here (empty session) -----\n\n"))
+        elif is_last:
+            title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
+        else:
+            title_parts.append(("class:separator", "----- fork from here -----\n\n"))
+
+        if not is_last:
+            # Second line: user message
+            title_parts.append(("class:msg", f"user:   {_truncate(fp.user_message, 70)}\n"))
+
+            # Third line: tool call stats (if any)
+            if fp.tool_call_stats:
+                tool_parts = [f"{name} × {count}" for name, count in fp.tool_call_stats.items()]
+                title_parts.append(("class:meta", f"tools:  {', '.join(tool_parts)}\n"))
+
+            # Fourth line: last assistant message summary (if any)
+            if fp.last_assistant_summary:
+                title_parts.append(("class:assistant", f"ai:     {fp.last_assistant_summary}\n"))
+
+        # Empty line at the end
+        title_parts.append(("class:text", "\n"))
+
+        items.append(
+            SelectItem(
+                title=title_parts,
+                value=fp.history_index,
+                search_text=fp.user_message if not is_last else "fork entire conversation",
+            )
+        )
+
+    return items
+
+
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+    """Interactive fork point selection (sync version for asyncio.to_thread).
+
+    Returns:
+        - int: history index to fork at (exclusive)
+        - None: fork entire conversation
+        - "cancelled": user cancelled selection
+    """
+    items = _build_select_items(fork_points)
+    if not items:
+        return None
+
+    # Default to the last option (fork entire conversation)
+    last_value = items[-1].value
+
+    # Non-interactive environments default to forking entire conversation
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return last_value
+
+    try:
+        result = select_one(
+            message="Select fork point (messages before this point will be included):",
+            items=items,
+            pointer="→",
+            style=FORK_SELECT_STYLE,
+            initial_value=last_value,
+            highlight_pointed_item=False,
+        )
+        if result is None:
+            return "cancelled"
+        return result
+    except KeyboardInterrupt:
+        return "cancelled"
+
+
+class ForkSessionCommand(CommandABC):
+    """Fork current session to a new session id and show a resume command."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.FORK_SESSION
+
+    @property
+    def summary(self) -> str:
+        return "Fork the current session and show a resume-by-id command"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count == 0:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(no messages to fork)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Build fork points from conversation history
+        fork_points = _build_fork_points(agent.session.conversation_history)
+
+        if not fork_points:
+            # Only one user message, just fork entirely
+            new_session = agent.session.fork()
+            await new_session.wait_for_flush()
+
+            resume_cmd = f"klaude --resume-by-id {new_session.id}"
+            copy_to_clipboard(resume_cmd)
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session forked successfully. New session id: {new_session.id}",
+                    command_output=model.CommandOutput(
+                        command_name=self.name,
+                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
+                    ),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Interactive selection
+        selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
+
+        if selected == "cancelled":
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(fork cancelled)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Perform the fork
+        new_session = agent.session.fork(until_index=selected)
+        await new_session.wait_for_flush()
+
+        # Build result message
+        fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
+
+        resume_cmd = f"klaude --resume-by-id {new_session.id}"
+        copy_to_clipboard(resume_cmd)
+
+        event = events.DeveloperMessageEvent(
+            session_id=agent.session.id,
+            item=model.DeveloperMessageItem(
+                content=f"Session forked ({fork_description}). New session id: {new_session.id}",
+                command_output=model.CommandOutput(
+                    command_name=self.name,
+                    ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
+                ),
+            ),
+        )
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

klaude_code/command/help_cmd.py

@@ -1,10 +1,7 @@
-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.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
 
-@register_command
 class HelpCommand(CommandABC):
     """Display help information for all available slash commands."""
 
@@ -16,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:
@@ -24,8 +22,9 @@ Usage:
   [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]ctrl-l[/b] to switch model
+  [b]ctrl-t[/b] to switch thinking level
   [b]--continue[/b] or [b]--resume[/b] to continue an old session
-  [b]--select-model[/b] to switch model
 
 Available slash commands:"""
         ]
@@ -37,8 +36,8 @@ Available slash commands:"""
 
         if commands:
             for cmd_name, cmd_obj in sorted(commands.items()):
-                additional_instructions = " \\[additional instructions]" if cmd_obj.support_addition_params else ""
-                lines.append(f"  [b]/{cmd_name}[/b]{additional_instructions} — {cmd_obj.summary}")
+                placeholder = f" \\[{cmd_obj.placeholder}]" if cmd_obj.support_addition_params else ""
+                lines.append(f"  [b]/{cmd_name}[/b]{placeholder} — {cmd_obj.summary}")
 
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,

klaude_code/command/model_cmd.py

@@ -1,13 +1,47 @@
 import asyncio
 
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.command.registry import register_command
-from klaude_code.config import select_model_from_config
-from klaude_code.core.agent import Agent
-from klaude_code.protocol import commands, events, model
+from prompt_toolkit.styles import Style
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.command.model_select import select_model_interactive
+from klaude_code.protocol import commands, events, model, op
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+SELECT_STYLE = Style(
+    [
+        ("instruction", "ansibrightblack"),
+        ("pointer", "ansigreen"),
+        ("highlighted", "ansigreen"),
+        ("text", "ansibrightblack"),
+        ("question", "bold"),
+    ]
+)
+
+
+def _confirm_change_default_model_sync(selected_model: str) -> bool:
+    items: list[SelectItem[bool]] = [
+        SelectItem(title=[("class:text", "No  (session only)\n")], value=False, search_text="No"),
+        SelectItem(
+            title=[("class:text", "Yes (save as default main_model in ~/.klaude/klaude-config.yaml)\n")],
+            value=True,
+            search_text="Yes",
+        ),
+    ]
+
+    try:
+        result = select_one(
+            message=f"Save '{selected_model}' as default model?",
+            items=items,
+            pointer="→",
+            style=SELECT_STYLE,
+            use_search_filter=False,
+        )
+    except KeyboardInterrupt:
+        return False
+
+    return bool(result)
 
 
-@register_command
 class ModelCommand(CommandABC):
     """Display or change the model configuration."""
 
@@ -23,8 +57,16 @@ class ModelCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
-        selected_model = await asyncio.to_thread(select_model_from_config, preferred=raw)
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "model name"
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        selected_model = await asyncio.to_thread(select_model_interactive, 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:
@@ -39,5 +81,13 @@ class ModelCommand(CommandABC):
                     )
                 ]
             )
-
-        return CommandResult(actions=[InputAction.change_model(selected_model)])
+        save_as_default = await asyncio.to_thread(_confirm_change_default_model_sync, selected_model)
+        return CommandResult(
+            operations=[
+                op.ChangeModelOperation(
+                    session_id=agent.session.id,
+                    model_name=selected_model,
+                    save_as_default=save_as_default,
+                )
+            ]
+        )