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

klaude_code/tui/input/images.py

@@ -0,0 +1,227 @@
+"""Image handling for REPL input.
+
+This module provides:
+- IMAGE_SUFFIXES: Supported image file extensions
+- IMAGE_MARKER_RE: Regex for [image ...] markers
+- is_image_file(): Check if a path is an image file
+- format_image_marker(): Generate [image path] string
+- parse_image_marker_path(): Parse path from marker
+- capture_clipboard_tag(): Capture clipboard image and return an [image ...] marker
+- extract_images_from_text(): Parse [image ...] markers and return ImageURLPart list
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+import uuid
+from base64 import b64encode
+from pathlib import Path
+
+from klaude_code.const import get_system_temp
+from klaude_code.protocol.message import ImageURLPart
+
+# ---------------------------------------------------------------------------
+# Constants and marker syntax
+# ---------------------------------------------------------------------------
+
+IMAGE_SUFFIXES = frozenset({".png", ".jpg", ".jpeg", ".gif", ".webp"})
+
+IMAGE_MARKER_RE = re.compile(r'\[image (?P<path>"[^"]+"|[^\]]+)\]')
+
+
+def is_image_file(path: Path) -> bool:
+    """Check if a path points to an image file based on extension."""
+    return path.suffix.lower() in IMAGE_SUFFIXES
+
+
+def format_image_marker(path: str) -> str:
+    """Format a path as an [image ...] marker.
+
+    Paths with whitespace are quoted.
+    """
+    path_str = path.strip()
+    if any(ch.isspace() for ch in path_str):
+        return f'[image "{path_str}"]'
+    return f"[image {path_str}]"
+
+
+def parse_image_marker_path(raw: str) -> str:
+    """Parse the path from an [image ...] marker, removing quotes if present."""
+    s = raw.strip()
+    if len(s) >= 2 and s.startswith('"') and s.endswith('"'):
+        return s[1:-1]
+    return s
+
+
+# ---------------------------------------------------------------------------
+# Clipboard image capture
+# ---------------------------------------------------------------------------
+
+
+def _clipboard_images_dir() -> Path:
+    return Path(get_system_temp())
+
+
+def _grab_clipboard_image_macos(dest_path: Path) -> bool:
+    """Grab image from clipboard on macOS using pngpaste or osascript (JXA)."""
+    # Try pngpaste first (faster, if installed)
+    if shutil.which("pngpaste"):
+        try:
+            result = subprocess.run(
+                ["pngpaste", str(dest_path)],
+                capture_output=True,
+            )
+            return result.returncode == 0 and dest_path.exists() and dest_path.stat().st_size > 0
+        except OSError:
+            pass
+
+    # Fallback to osascript with JXA (JavaScript for Automation)
+    script = f'''
+ObjC.import("AppKit");
+var pb = $.NSPasteboard.generalPasteboard;
+var pngData = pb.dataForType($.NSPasteboardTypePNG);
+if (pngData.isNil()) {{
+    var tiffData = pb.dataForType($.NSPasteboardTypeTIFF);
+    if (tiffData.isNil()) {{
+        "false";
+    }} else {{
+        var bitmapRep = $.NSBitmapImageRep.imageRepWithData(tiffData);
+        pngData = bitmapRep.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $());
+    }}
+}}
+if (!pngData.isNil()) {{
+    pngData.writeToFileAtomically("{dest_path}", true);
+    "true";
+}} else {{
+    "false";
+}}
+'''
+    try:
+        result = subprocess.run(
+            ["osascript", "-l", "JavaScript", "-e", script],
+            capture_output=True,
+            text=True,
+        )
+        return (
+            result.returncode == 0 and "true" in result.stdout and dest_path.exists() and dest_path.stat().st_size > 0
+        )
+    except OSError:
+        return False
+
+
+def _grab_clipboard_image_linux(dest_path: Path) -> bool:
+    """Grab image from clipboard on Linux using xclip."""
+    if not shutil.which("xclip"):
+        return False
+    try:
+        result = subprocess.run(
+            ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"],
+            capture_output=True,
+        )
+        if result.returncode == 0 and result.stdout:
+            dest_path.write_bytes(result.stdout)
+            return True
+    except OSError:
+        pass
+    return False
+
+
+def _grab_clipboard_image_windows(dest_path: Path) -> bool:
+    """Grab image from clipboard on Windows using PowerShell."""
+    script = f'''
+    Add-Type -AssemblyName System.Windows.Forms
+    $img = [System.Windows.Forms.Clipboard]::GetImage()
+    if ($img -ne $null) {{
+        $img.Save("{dest_path}", [System.Drawing.Imaging.ImageFormat]::Png)
+        Write-Output "ok"
+    }}
+    '''
+    try:
+        result = subprocess.run(
+            ["powershell", "-Command", script],
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0 and "ok" in result.stdout and dest_path.exists()
+    except OSError:
+        return False
+
+
+def _grab_clipboard_image(dest_path: Path) -> bool:
+    """Grab image from clipboard and save to dest_path. Returns True on success."""
+    if sys.platform == "darwin":
+        return _grab_clipboard_image_macos(dest_path)
+    elif sys.platform == "win32":
+        return _grab_clipboard_image_windows(dest_path)
+    else:
+        return _grab_clipboard_image_linux(dest_path)
+
+
+def capture_clipboard_tag() -> str | None:
+    """Capture an image from clipboard and return an [image ...] marker."""
+
+    images_dir = _clipboard_images_dir()
+    try:
+        images_dir.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        return None
+
+    filename = f"klaude-image-{uuid.uuid4().hex}.png"
+    path = images_dir / filename
+
+    if not _grab_clipboard_image(path):
+        return None
+
+    return format_image_marker(str(path))
+
+
+# ---------------------------------------------------------------------------
+# Image extraction from text
+# ---------------------------------------------------------------------------
+
+
+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")
+
+        suffix = path.suffix.lower()
+        mime = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+        }.get(suffix)
+        if mime is None:
+            return None
+
+        data_url = f"data:{mime};base64,{encoded}"
+        return ImageURLPart(url=data_url, id=None)
+    except OSError:
+        return None
+
+
+def extract_images_from_text(text: str) -> list[ImageURLPart]:
+    """Extract images referenced by [image ...] markers in text."""
+
+    images: list[ImageURLPart] = []
+    for m in IMAGE_MARKER_RE.finditer(text):
+        raw = m.group("path")
+        path_str = parse_image_marker_path(raw)
+        if not path_str:
+            continue
+        p = Path(path_str).expanduser()
+        if not p.is_absolute():
+            p = (Path.cwd() / p).resolve()
+        image_part = _encode_image_file(str(p))
+        if image_part:
+            images.append(image_part)
+    return images

klaude_code/tui/input/key_bindings.py

@@ -7,8 +7,13 @@ with dependencies injected to avoid circular imports.
 from __future__ import annotations
 
 import contextlib
+import os
 import re
+import shutil
+import subprocess
+import sys
 from collections.abc import Callable
+from pathlib import Path
 from typing import cast
 
 from prompt_toolkit.application.current import get_app
@@ -17,11 +22,39 @@ from prompt_toolkit.filters import Always, Condition, Filter
 from prompt_toolkit.filters.app import has_completions
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.keys import Keys
+
+from klaude_code.tui.input.drag_drop import convert_dropped_text
+from klaude_code.tui.input.paste import expand_paste_markers, store_paste
+
+
+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
 
 
 def create_key_bindings(
     capture_clipboard_tag: Callable[[], str | None],
-    copy_to_clipboard: Callable[[str], None],
     at_token_pattern: re.Pattern[str],
     *,
     input_enabled: Filter | None = None,
@@ -31,8 +64,7 @@ def create_key_bindings(
     """Create REPL key bindings with injected dependencies.
 
     Args:
-        capture_clipboard_tag: Callable to capture clipboard image and return tag
-        copy_to_clipboard: Callable to copy text to system clipboard
+        capture_clipboard_tag: Callable to capture clipboard image and return [image ...] marker
         at_token_pattern: Pattern to match @token for completion refresh
 
     Returns:
@@ -41,6 +73,51 @@ def create_key_bindings(
     kb = KeyBindings()
     enabled = input_enabled if input_enabled is not None else Always()
 
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    swallow_next_control_j = False
+
+    def _data_requests_newline(data: str) -> bool:
+        """Return True when incoming key data should insert a newline.
+
+        Different terminals and editor-integrated terminals can emit different
+        sequences for Shift+Enter/Alt+Enter. We treat these as "insert newline"
+        instead of "submit".
+        """
+
+        if not data:
+            return False
+
+        # Pure LF or LF-prefixed sequences (e.g. when modifiers are encoded).
+        if data == "\n" or (ord(data[0]) == 10 and len(data) > 1):
+            return True
+
+        # Known escape sequences observed in some terminals.
+        if data in {
+            "\x1b\r",  # Alt+Enter (ESC + CR)
+            "\x1b[13;2~",  # Shift+Enter (some terminals)
+            "\x1b[27;2;13~",  # Shift+Enter (xterm "CSI 27" modified keys)
+            "\\\r",  # Backslash+Enter sentinel (some editor terminals)
+        }:
+            return True
+
+        # Any payload that contains both ESC and CR.
+        return len(data) > 1 and "\x1b" in data and "\r" in data
+
+    def _insert_newline(event: KeyPressEvent, *, strip_trailing_backslash: bool = False) -> None:
+        buf = event.current_buffer
+        if strip_trailing_backslash:
+            try:
+                doc = buf.document  # type: ignore[reportUnknownMemberType]
+                if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
+                    buf.delete_before_cursor()  # type: ignore[reportUnknownMemberType]
+            except Exception:
+                pass
+
+        with contextlib.suppress(Exception):
+            buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
+        with contextlib.suppress(Exception):
+            event.app.invalidate()  # type: ignore[reportUnknownMemberType]
+
     def _can_move_cursor_visually_within_wrapped_line(delta_visible_y: int) -> bool:
         """Return True when Up/Down should move within a wrapped visual line.
 
@@ -233,28 +310,85 @@ def create_key_bindings(
 
     @kb.add("c-v", filter=enabled)
     def _(event: KeyPressEvent) -> None:
-        """Paste image from clipboard as [Image #N]."""
-        tag = capture_clipboard_tag()
-        if tag:
+        """Paste image from clipboard as an `[image ...]` marker."""
+        marker = capture_clipboard_tag()
+        if marker:
+            with contextlib.suppress(Exception):
+                event.current_buffer.insert_text(marker)  # pyright: ignore[reportUnknownMemberType]
+
+    @kb.add(Keys.BracketedPaste, filter=enabled)
+    def _(event: KeyPressEvent) -> None:
+        """Handle bracketed paste.
+
+        - Large multi-line pastes are folded into a marker: `[paste #N ...]`.
+        - Otherwise, try to convert dropped file URLs/paths into @ tokens or `[image ...]` markers.
+        """
+
+        data = getattr(event, "data", "")
+        if not isinstance(data, str) or not data:
+            return
+
+        pasted_lines = data.splitlines()
+        line_count = max(1, len(pasted_lines))
+        total_chars = len(data)
+
+        should_fold = line_count > 10 or total_chars > 1000
+        if should_fold:
+            marker = store_paste(data)
+            if marker and not marker.endswith((" ", "\t", "\n")):
+                marker += " "
             with contextlib.suppress(Exception):
-                event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
+                event.current_buffer.insert_text(marker)  # pyright: ignore[reportUnknownMemberType]
+            return
+
+        converted = convert_dropped_text(data, cwd=Path.cwd())
+        if converted != data and converted and not converted.endswith((" ", "\t", "\n")):
+            converted += " "
+
+        buf = event.current_buffer
+        try:
+            if buf.selection_state:  # type: ignore[reportUnknownMemberType]
+                buf.cut_selection()  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            pass
+
+        with contextlib.suppress(Exception):
+            buf.insert_text(converted)  # type: ignore[reportUnknownMemberType]
+
+    @kb.add("escape", "enter", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
+        """Alt+Enter inserts a newline."""
+
+        _insert_newline(event)
+
+    @kb.add("escape", "[", "1", "3", ";", "2", "~", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
+        """Shift+Enter sequence used by some terminals inserts a newline."""
+
+        _insert_newline(event)
 
     @kb.add("enter", filter=enabled)
     def _(event: KeyPressEvent) -> None:
+        nonlocal swallow_next_control_j
+
         buf = event.current_buffer
         doc = buf.document  # type: ignore
 
-        # If VS Code/Windsurf/Cursor sent a "\\" sentinel before Enter (Shift+Enter mapping),
-        # treat it as a request for a newline instead of submit.
-        # This allows Shift+Enter to insert a newline in our multiline prompt.
-        try:
-            if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
-                buf.delete_before_cursor()  # remove the sentinel backslash  # type: ignore[reportUnknownMemberType]
-                buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
-                return
-        except (AttributeError, TypeError):
-            # Fall through to default behavior if anything goes wrong
-            pass
+        data = getattr(event, "data", "")
+        if isinstance(data, str) and _data_requests_newline(data):
+            _insert_newline(event)
+            return
+
+        # VS Code-family terminals often implement Shift+Enter via a "\\" sentinel
+        # before Enter. Only enable this heuristic under TERM_PROGRAM=vscode.
+        if term_program == "vscode":
+            try:
+                if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
+                    swallow_next_control_j = True
+                    _insert_newline(event, strip_trailing_backslash=True)
+                    return
+            except (AttributeError, TypeError):
+                pass
 
         # When completions are visible, Enter accepts the current selection.
         # This aligns with common TUI completion UX: navigation doesn't modify
@@ -262,6 +396,21 @@ def create_key_bindings(
         if not _should_submit_instead_of_accepting_completion(buf) and _accept_current_completion(buf):
             return
 
+        # Before submitting, expand any folded paste markers so that:
+        # - the actual request contains the full pasted content
+        # - prompt_toolkit history stores the expanded content
+        # Also convert any remaining file:// drops that bypassed bracketed paste.
+        try:
+            current_text = buf.text  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            current_text = ""
+        prepared = expand_paste_markers(current_text)
+        prepared = convert_dropped_text(prepared, cwd=Path.cwd())
+        if prepared != current_text:
+            with contextlib.suppress(Exception):
+                buf.text = prepared  # type: ignore[reportUnknownMemberType]
+                buf.cursor_position = len(prepared)  # type: ignore[reportUnknownMemberType]
+
         # If the entire buffer is whitespace-only, insert a newline rather than submitting.
         if len(buf.text.strip()) == 0:  # type: ignore
             buf.insert_text("\n")  # type: ignore
@@ -310,6 +459,11 @@ def create_key_bindings(
 
     @kb.add("c-j", filter=enabled)
     def _(event: KeyPressEvent) -> None:
+        nonlocal swallow_next_control_j
+        if swallow_next_control_j:
+            swallow_next_control_j = False
+            return
+
         event.current_buffer.insert_text("\n")  # type: ignore
 
     @kb.add("c", filter=enabled)
@@ -322,7 +476,7 @@ def create_key_bindings(
             selected_text: str = doc.text[start:end]  # type: ignore[reportUnknownMemberType]
 
             if selected_text:
-                copy_to_clipboard(selected_text)  # type: ignore[reportUnknownArgumentType]
+                copy_to_clipboard(selected_text)
             buf.exit_selection()  # type: ignore[reportUnknownMemberType]
         else:
             buf.insert_text("c")  # type: ignore[reportUnknownMemberType]

klaude_code/tui/input/paste.py

@@ -0,0 +1,71 @@
+"""Fold large multi-line pastes into a short marker.
+
+prompt_toolkit already parses terminal bracketed paste mode and exposes the
+pasted payload via a `<bracketed-paste>` key event.
+
+We keep the editor buffer small by inserting a marker like:
+- `[paste #3 +42 lines]`  (when many lines)
+- `[paste #3 1205 chars]` (when very long)
+
+On submit, markers are expanded back to the original pasted content.
+"""
+
+from __future__ import annotations
+
+import re
+
+_PASTE_MARKER_RE = re.compile(r"\[paste #(?P<id>\d+)(?: (?P<meta>\+\d+ lines|\d+ chars))?\]")
+
+
+class PasteBufferState:
+    def __init__(self) -> None:
+        self._next_id = 1
+        self._pastes: dict[int, str] = {}
+
+    def store(self, text: str) -> str:
+        paste_id = self._next_id
+        self._next_id += 1
+
+        lines = text.splitlines()
+        line_count = max(1, len(lines))
+        total_chars = len(text)
+
+        if line_count > 10:
+            marker = f"[paste #{paste_id} +{line_count} lines]"
+        else:
+            marker = f"[paste #{paste_id} {total_chars} chars]"
+
+        self._pastes[paste_id] = text
+        return marker
+
+    def expand_markers(self, text: str) -> str:
+        used: set[int] = set()
+
+        def _replace(m: re.Match[str]) -> str:
+            try:
+                paste_id = int(m.group("id"))
+            except (TypeError, ValueError):
+                return m.group(0)
+
+            content = self._pastes.get(paste_id)
+            if content is None:
+                return m.group(0)
+
+            used.add(paste_id)
+            return content
+
+        out = _PASTE_MARKER_RE.sub(_replace, text)
+        for pid in used:
+            self._pastes.pop(pid, None)
+        return out
+
+
+paste_state = PasteBufferState()
+
+
+def store_paste(text: str) -> str:
+    return paste_state.store(text)
+
+
+def expand_paste_markers(text: str) -> str:
+    return paste_state.expand_markers(text)

klaude_code/tui/input/prompt_toolkit.py

@@ -36,9 +36,14 @@ from klaude_code.protocol import llm_param
 from klaude_code.protocol.commands import CommandInfo
 from klaude_code.protocol.message import UserInputPayload
 from klaude_code.tui.components.user_input import USER_MESSAGE_MARK
-from klaude_code.tui.input.clipboard import capture_clipboard_tag, copy_to_clipboard, extract_images_from_text
 from klaude_code.tui.input.completers import AT_TOKEN_PATTERN, create_repl_completer
+from klaude_code.tui.input.drag_drop import convert_dropped_text
+from klaude_code.tui.input.images import (
+    capture_clipboard_tag,
+    extract_images_from_text,
+)
 from klaude_code.tui.input.key_bindings import create_key_bindings
+from klaude_code.tui.input.paste import expand_paste_markers
 from klaude_code.tui.terminal.color import is_light_terminal_background
 from klaude_code.tui.terminal.selector import SelectItem, SelectOverlay, build_model_select_items
 from klaude_code.ui.core.input import InputProviderABC
@@ -271,7 +276,6 @@ class PromptToolkitInput(InputProviderABC):
 
         kb = create_key_bindings(
             capture_clipboard_tag=capture_clipboard_tag,
-            copy_to_clipboard=copy_to_clipboard,
             at_token_pattern=AT_TOKEN_PATTERN,
             input_enabled=input_enabled,
             open_model_picker=self._open_model_picker,
@@ -333,7 +337,7 @@ class PromptToolkitInput(InputProviderABC):
             pointer="→",
             use_search_filter=True,
             search_placeholder="type to search",
-            list_height=10,
+            list_height=20,
             on_select=self._handle_model_selected,
         )
         self._model_picker = model_picker
@@ -669,6 +673,12 @@ class PromptToolkitInput(InputProviderABC):
                 with contextlib.suppress(Exception):
                     self._post_prompt()
 
+            # Expand folded paste markers back into the original content.
+            line = expand_paste_markers(line)
+
+            # Convert drag-and-drop file:// URIs that may have bypassed bracketed paste.
+            line = convert_dropped_text(line, cwd=Path.cwd())
+
             # Extract images referenced in the input text
             images = extract_images_from_text(line)