klaude-code 2.5.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

klaude_code/protocol/events/streaming.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from .base import ResponseEvent
-
-
-class ThinkingStartEvent(ResponseEvent):
-    pass
-
-
-class ThinkingDeltaEvent(ResponseEvent):
-    content: str
-
-
-class ThinkingEndEvent(ResponseEvent):
-    pass
-
-
-class AssistantTextStartEvent(ResponseEvent):
-    pass
-
-
-class AssistantTextDeltaEvent(ResponseEvent):
-    content: str
-
-
-class AssistantTextEndEvent(ResponseEvent):
-    pass
-
-
-class AssistantImageDeltaEvent(ResponseEvent):
-    file_path: str
-
-
-class ToolCallStartEvent(ResponseEvent):
-    tool_call_id: str
-    tool_name: str
-
-
-class ResponseCompleteEvent(ResponseEvent):
-    """Final snapshot of the model response."""
-
-    content: str
-    thinking_text: str | None = None

klaude_code/protocol/events/system.py

@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-from pydantic import Field
-
-from klaude_code.protocol import llm_param
-from klaude_code.protocol.events.chat import DeveloperMessageEvent, UserMessageEvent
-from klaude_code.protocol.events.lifecycle import TaskFinishEvent, TaskStartEvent, TurnStartEvent
-from klaude_code.protocol.events.metadata import TaskMetadataEvent
-from klaude_code.protocol.events.streaming import AssistantImageDeltaEvent, ResponseCompleteEvent
-from klaude_code.protocol.events.tools import ToolCallEvent, ToolResultEvent
-
-from .base import Event
-
-
-class WelcomeEvent(Event):
-    work_dir: str
-    llm_config: llm_param.LLMConfigParameter
-    show_klaude_code_info: bool = True
-    loaded_skills: dict[str, list[str]] = Field(default_factory=dict)
-
-
-class ErrorEvent(Event):
-    error_message: str
-    can_retry: bool = False
-
-
-class InterruptEvent(Event):
-    pass
-
-
-class EndEvent(Event):
-    """Global display shutdown."""
-
-    session_id: str = "__app__"
-
-
-type ReplayEventUnion = (
-    TaskStartEvent
-    | TaskFinishEvent
-    | TurnStartEvent
-    | AssistantImageDeltaEvent
-    | ResponseCompleteEvent
-    | ToolCallEvent
-    | ToolResultEvent
-    | UserMessageEvent
-    | TaskMetadataEvent
-    | InterruptEvent
-    | DeveloperMessageEvent
-    | ErrorEvent
-)
-
-
-class ReplayHistoryEvent(Event):
-    events: list[ReplayEventUnion]
-    updated_at: float
-    is_load: bool = True

klaude_code/protocol/events/tools.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-
-from klaude_code.protocol import model
-
-from .base import ResponseEvent
-
-
-class ToolCallEvent(ResponseEvent):
-    tool_call_id: str
-    tool_name: str
-    arguments: str
-
-
-class ToolResultEvent(ResponseEvent):
-    tool_call_id: str
-    tool_name: str
-    result: str
-    ui_extra: model.ToolResultUIExtra | None = None
-    status: Literal["success", "error", "aborted"]
-    task_metadata: model.TaskMetadata | None = None
-    is_last_in_turn: bool = True
-
-    @property
-    def is_error(self) -> bool:
-        return self.status in ("error", "aborted")

klaude_code/tui/command/terminal_setup_cmd.py

@@ -1,248 +0,0 @@
-import os
-import subprocess
-from pathlib import Path
-
-from klaude_code.protocol import commands, events, message
-
-from .command_abc import Agent, CommandABC, CommandResult
-
-
-class TerminalSetupCommand(CommandABC):
-    """Setup shift+enter newline functionality in terminal"""
-
-    @property
-    def name(self) -> commands.CommandName:
-        return commands.CommandName.TERMINAL_SETUP
-
-    @property
-    def summary(self) -> str:
-        return "Install shift+enter key binding for newlines"
-
-    @property
-    def is_interactive(self) -> bool:
-        return False
-
-    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
-        del user_input  # unused
-        term_program = os.environ.get("TERM_PROGRAM", "").lower()
-
-        try:
-            if term_program == "ghostty":
-                message = self._setup_ghostty()
-            elif term_program == "iterm.app":
-                message = self._setup_iterm()
-            elif term_program == "vscode":
-                # VS Code family terminals (VS Code, Windsurf, Cursor) all report TERM_PROGRAM=vscode
-                message = self._setup_vscode_family()
-            else:
-                # Provide generic manual configuration guide for unknown or unsupported terminals
-                message = self._setup_generic(term_program)
-
-            return self._create_success_result(agent, message)
-
-        except Exception as e:
-            return self._create_error_result(agent, f"Error configuring terminal: {e!s}")
-
-    def _setup_ghostty(self) -> str:
-        """Configure shift+enter newline for Ghostty terminal"""
-        config_dir = Path.home() / ".config" / "ghostty"
-        config_file = config_dir / "config"
-
-        keybind_line = 'keybind="shift+enter=text:\\n"'
-
-        # Ensure config directory exists
-        config_dir.mkdir(parents=True, exist_ok=True)
-
-        # Check if configuration already exists in config file
-        if config_file.exists():
-            content = config_file.read_text()
-            if keybind_line in content or 'keybind="shift+enter=' in content:
-                return "Ghostty terminal shift+enter newline configuration already exists"
-
-        # Add configuration
-        with config_file.open("a", encoding="utf-8") as f:
-            if config_file.exists() and not config_file.read_text().endswith("\n"):
-                f.write("\n")
-            f.write(f"{keybind_line}\n")
-
-        return f"Added shift+enter newline configuration for Ghostty terminal to {config_file}"
-
-    def _setup_iterm(self) -> str:
-        """Configure shift+enter newline for iTerm terminal using defaults command"""
-        try:
-            # First check if iTerm preferences exist
-            prefs_path = Path.home() / "Library" / "Preferences" / "com.googlecode.iterm2.plist"
-            if not prefs_path.exists():
-                return "iTerm preferences file not found. Please open iTerm first to create initial preferences."
-
-            # Check if the key binding already exists
-            check_cmd = ["defaults", "read", "com.googlecode.iterm2", "New Bookmarks"]
-
-            try:
-                result = subprocess.run(check_cmd, capture_output=True, text=True, check=True)
-                # If we can read bookmarks, iTerm is properly configured
-            except subprocess.CalledProcessError:
-                return "Unable to read iTerm configuration. Please ensure iTerm is properly installed and has been opened at least once."
-
-            # Add to the default profile's keyboard map
-            add_keymap_cmd = [
-                "defaults",
-                "write",
-                "com.googlecode.iterm2",
-                "GlobalKeyMap",
-                "-dict-add",
-                # Do not include quotes when passing args as a list (no shell)
-                "0x0d-0x20000",
-                # Pass Property List dict directly; \n should be literal backslash-n so iTerm parses newline
-                '{Action=12;Text="\\\\n";}',
-            ]
-            # Execute without shell so arguments are passed correctly
-            result = subprocess.run(add_keymap_cmd, capture_output=True, text=True)
-            print(result.stdout, result.stderr)
-            if result.returncode == 0:
-                return "Successfully configured Shift+Enter for newline in iTerm. Please restart iTerm for changes to take effect."
-            else:
-                # Fallback to manual instructions if defaults command fails
-                return (
-                    "Automatic configuration failed. Please manually configure:\n"
-                    "1. Open iTerm -> Preferences (⌘,)\n"
-                    "2. Go to Profiles -> Keys -> Key Mappings\n"
-                    "3. Click '+' to add: Shift+Enter -> Send Text -> \\n"
-                )
-
-        except Exception as e:
-            raise Exception(f"Error configuring iTerm: {e!s}") from e
-
-    def _setup_vscode_family(self) -> str:
-        """Configure shift+enter newline for VS Code family terminals (VS Code, Windsurf, Cursor).
-
-        These editors share TERM_PROGRAM=vscode and use keybindings.json under their respective
-        Application Support folders. We ensure the required keybinding exists; if not, we append it.
-        """
-        base_dir = Path.home() / "Library" / "Application Support"
-        targets = [
-            ("VS Code", base_dir / "Code" / "User" / "keybindings.json"),
-            ("Windsurf", base_dir / "Windsurf" / "User" / "keybindings.json"),
-            ("Cursor", base_dir / "Cursor" / "User" / "keybindings.json"),
-        ]
-
-        mapping_block = r"""    {
-        "key": "shift+enter",
-        "command": "workbench.action.terminal.sendSequence",
-        "args": {
-            "text": "\\\r\n"
-        },
-        "when": "terminalFocus"
-    }"""
-
-        results: list[str] = []
-
-        for name, file_path in targets:
-            try:
-                _, msg = self._ensure_vscode_keybinding(file_path, mapping_block)
-                results.append(f"{name}: {msg}")
-            except Exception as e:  # pragma: no cover - protect against any unexpected FS issue
-                results.append(f"{name}: failed to update keybindings ({e})")
-
-        return "\n".join(results)
-
-    def _ensure_vscode_keybinding(self, path: Path, mapping_block: str) -> tuple[bool, str]:
-        """Ensure the VS Code-style keybinding exists in the given keybindings.json file.
-
-        Returns (added, message).
-        - added=True if we created or modified the file to include the mapping
-        - added=False if mapping already present or file couldn't be safely modified
-        """
-        path.parent.mkdir(parents=True, exist_ok=True)
-
-        # If file does not exist, create with the mapping in an array
-        if not path.exists():
-            content = "[\n  " + mapping_block + "\n]\n"
-            path.write_text(content, encoding="utf-8")
-            return True, f"created {path} with Shift+Enter mapping"
-
-        # Read existing content
-        raw = path.read_text(encoding="utf-8")
-        text = raw
-
-        # Quick detection: if both key and command exist together anywhere, assume configured
-        if '"key": "shift+enter"' in text and "workbench.action.terminal.sendSequence" in text:
-            return False, "already configured"
-
-        stripped = text.strip()
-        # If file is empty, write a fresh array
-        if stripped == "":
-            content = "[\n  " + mapping_block + "\n]\n"
-            path.write_text(content, encoding="utf-8")
-            return True, "initialized empty keybindings.json with mapping"
-
-        # If the content contains a top-level array (allowing header comments), append before the final ]
-        open_idx = text.find("[")
-        close_idx = text.rfind("]")
-        if open_idx != -1 and close_idx != -1 and open_idx < close_idx:
-            before = text[:close_idx].rstrip()
-            after = text[close_idx:]
-
-            # Heuristic: treat as non-empty if there's an object marker between [ and ]
-            inner = text[open_idx + 1 : close_idx]
-            has_item = "{" in inner
-
-            # Construct new content by adding optional comma, newline, then our block
-            new_content = before + ("," if has_item else "") + "\n" + mapping_block + "\n" + after
-
-            path.write_text(new_content, encoding="utf-8")
-            return True, "appended mapping"
-
-        # Not an array – avoid modifying to prevent corrupting user config
-        return (
-            False,
-            "unsupported keybindings.json format (not an array); please add mapping manually",
-        )
-
-    def _setup_generic(self, term_program: str) -> str:
-        """Provide generic manual configuration guide for unknown or unsupported terminals"""
-        if term_program:
-            intro = f"Terminal type '{term_program}' is not specifically supported, but you can manually configure shift+enter newline functionality."
-        else:
-            intro = "Unable to detect terminal type, but you can manually configure shift+enter newline functionality."
-
-        message = (
-            f"{intro}\n\n"
-            "General steps to configure shift+enter for newline:\n"
-            "1. Open your terminal's preferences/settings\n"
-            "2. Look for 'Key Bindings', 'Key Mappings', or 'Keyboard' section\n"
-            "3. Add a new key binding:\n"
-            "   - Key combination: Shift+Enter\n"
-            "   - Action: Send text or Insert text\n"
-            "   - Text to send: \\n (literal newline character)\n"
-            "4. Save the configuration\n\n"
-            "Note: The exact steps may vary depending on your terminal application. "
-            "Currently supported terminals with automatic configuration: Ghostty, iTerm.app, VS Code family (VS Code, Windsurf, Cursor)"
-        )
-
-        return message
-
-    def _create_success_result(self, agent: "Agent", msg: str) -> CommandResult:
-        """Create success result"""
-        return CommandResult(
-            events=[
-                events.CommandOutputEvent(
-                    session_id=agent.session.id,
-                    command_name=self.name,
-                    content=msg,
-                )
-            ]
-        )
-
-    def _create_error_result(self, agent: "Agent", msg: str) -> CommandResult:
-        """Create error result"""
-        return CommandResult(
-            events=[
-                events.CommandOutputEvent(
-                    session_id=agent.session.id,
-                    command_name=self.name,
-                    content=msg,
-                    is_error=True,
-                )
-            ]
-        )

klaude_code/tui/input/clipboard.py

@@ -1,152 +0,0 @@
-"""Clipboard and image handling for REPL input.
-
-This module provides:
-- ClipboardCaptureState: Captures clipboard images and maps tags to file paths
-- capture_clipboard_tag(): Capture clipboard image and return tag
-- extract_images_from_text(): Parse tags and return ImageURLPart list
-- copy_to_clipboard(): Copy text to system clipboard
-"""
-
-from __future__ import annotations
-
-import re
-import shutil
-import subprocess
-import sys
-import uuid
-from base64 import b64encode
-from pathlib import Path
-
-from PIL import Image, ImageGrab
-
-from klaude_code.protocol.message import ImageURLPart
-
-# Directory for storing clipboard images
-CLIPBOARD_IMAGES_DIR = Path.home() / ".klaude" / "clipboard" / "images"
-
-# Pattern to match [Image #N] tags in user input
-_IMAGE_TAG_RE = re.compile(r"\[Image #(\d+)\]")
-
-
-class ClipboardCaptureState:
-    """Captures clipboard images and maps tags to file paths in memory."""
-
-    def __init__(self, images_dir: Path | None = None):
-        self._images_dir = images_dir or CLIPBOARD_IMAGES_DIR
-        self._pending: dict[str, str] = {}  # tag -> path mapping
-        self._counter = 1
-
-    def capture_from_clipboard(self) -> str | None:
-        """Capture image from clipboard, save to disk, and return a tag like [Image #N]."""
-        try:
-            clipboard_data = ImageGrab.grabclipboard()
-        except OSError:
-            return None
-        if not isinstance(clipboard_data, Image.Image):
-            return None
-        try:
-            self._images_dir.mkdir(parents=True, exist_ok=True)
-        except OSError:
-            return None
-        filename = f"clipboard_{uuid.uuid4().hex[:8]}.png"
-        path = self._images_dir / filename
-        try:
-            clipboard_data.save(path, "PNG")
-        except OSError:
-            return None
-        tag = f"[Image #{self._counter}]"
-        self._counter += 1
-        self._pending[tag] = str(path)
-        return tag
-
-    def get_pending_images(self) -> dict[str, str]:
-        """Return the current tag-to-path mapping for pending images."""
-        return dict(self._pending)
-
-    def flush(self) -> dict[str, str]:
-        """Flush pending images and return tag-to-path mapping, then reset state."""
-        result = dict(self._pending)
-        self._pending = {}
-        self._counter = 1
-        return result
-
-
-# Module-level singleton instance
-clipboard_state = ClipboardCaptureState()
-
-
-def capture_clipboard_tag() -> str | None:
-    """Capture image from clipboard and return tag like [Image #N].
-
-    Uses the module-level clipboard_state singleton. Returns None if no image
-    is available in the clipboard or capture fails.
-    """
-    return clipboard_state.capture_from_clipboard()
-
-
-def extract_images_from_text(text: str) -> list[ImageURLPart]:
-    """Extract images from pending clipboard state based on tags in text.
-
-    Parses [Image #N] tags in the text, looks up corresponding image paths
-    in the clipboard state, and creates ImageURLPart objects from them.
-    Flushes the clipboard state after extraction.
-    """
-    pending_images = clipboard_state.flush()
-    if not pending_images:
-        return []
-
-    # Find all [Image #N] tags in text
-    found_tags = set(_IMAGE_TAG_RE.findall(text))
-    if not found_tags:
-        return []
-
-    images: list[ImageURLPart] = []
-    for tag, path in pending_images.items():
-        # Extract the number from the tag and check if it's referenced
-        match = _IMAGE_TAG_RE.match(tag)
-        if match and match.group(1) in found_tags:
-            image_part = _encode_image_file(path)
-            if image_part:
-                images.append(image_part)
-
-    return images
-
-
-def _encode_image_file(file_path: str) -> ImageURLPart | None:
-    """Encode an image file as base64 data URL and create ImageURLPart."""
-    try:
-        path = Path(file_path)
-        if not path.exists():
-            return None
-        with open(path, "rb") as f:
-            encoded = b64encode(f.read()).decode("ascii")
-        # Clipboard images are always saved as PNG
-        data_url = f"data:image/png;base64,{encoded}"
-        return ImageURLPart(url=data_url, id=None)
-    except OSError:
-        return None
-
-
-def copy_to_clipboard(text: str) -> None:
-    """Copy text to system clipboard using platform-specific commands."""
-    try:
-        if sys.platform == "darwin":
-            subprocess.run(["pbcopy"], input=text.encode("utf-8"), check=True)
-        elif sys.platform == "win32":
-            subprocess.run(["clip"], input=text.encode("utf-16"), check=True)
-        else:
-            # Linux: try xclip first, then xsel
-            if shutil.which("xclip"):
-                subprocess.run(
-                    ["xclip", "-selection", "clipboard"],
-                    input=text.encode("utf-8"),
-                    check=True,
-                )
-            elif shutil.which("xsel"):
-                subprocess.run(
-                    ["xsel", "--clipboard", "--input"],
-                    input=text.encode("utf-8"),
-                    check=True,
-                )
-    except (OSError, subprocess.SubprocessError):
-        pass