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

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)
 

klaude_code/tui/machine.py

@@ -160,7 +160,7 @@ class ActivityState:
             if self._sub_agent_tool_calls:
                 _append_counts(self._sub_agent_tool_calls)
                 if self._tool_calls:
-                    activity_text.append(" , ")
+                    activity_text.append(", ")
 
             if self._tool_calls:
                 _append_counts(self._tool_calls)

klaude_code/tui/runner.py

@@ -312,4 +312,4 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             active_session_id = components.executor.context.current_session_id()
             if active_session_id and Session.exists(active_session_id):
                 log(f"Session ID: {active_session_id}")
-                log(f"Resume with: klaude --resume-by-id {active_session_id}")
+                log(f"Resume with: klaude --resume {active_session_id}")

klaude_code/tui/terminal/image.py

@@ -1,34 +1,65 @@
 from __future__ import annotations
 
+import base64
 import sys
 from pathlib import Path
 from typing import IO
 
+# Kitty graphics protocol chunk size (4096 is the recommended max)
+_CHUNK_SIZE = 4096
+
 
 def print_kitty_image(file_path: str | Path, *, height: int | None = None, file: IO[str] | None = None) -> None:
     """Print an image to the terminal using Kitty graphics protocol.
 
     This intentionally bypasses Rich rendering to avoid interleaving Live refreshes
     with raw escape sequences.
-    """
 
+    Args:
+        file_path: Path to the image file (PNG recommended).
+        height: Display height in terminal rows. If None, uses terminal default.
+        file: Output file stream. Defaults to stdout.
+    """
     path = Path(file_path) if isinstance(file_path, str) else file_path
     if not path.exists():
         print(f"Image not found: {path}", file=file or sys.stdout, flush=True)
         return
 
     try:
-        from term_image.image import KittyImage  # type: ignore[import-untyped]
-
-        KittyImage.forced_support = True  # type: ignore[reportUnknownMemberType]
-        img = KittyImage.from_file(path)  # type: ignore[reportUnknownMemberType]
-        if height is not None:
-            img.height = height  # type: ignore[reportUnknownMemberType]
-
+        data = path.read_bytes()
+        encoded = base64.standard_b64encode(data).decode("ascii")
         out = file or sys.stdout
+
         print("", file=out)
-        print(str(img), file=out)
+        _write_kitty_graphics(out, encoded, height=height)
         print("", file=out)
         out.flush()
     except Exception:
         print(f"Saved image: {path}", file=file or sys.stdout, flush=True)
+
+
+def _write_kitty_graphics(out: IO[str], encoded_data: str, *, height: int | None = None) -> None:
+    """Write Kitty graphics protocol escape sequences.
+
+    Protocol format: ESC _ G <control>;<payload> ESC \\
+    - a=T: direct transmission (data in payload)
+    - f=100: PNG format (auto-detected by Kitty)
+    - r=N: display height in rows
+    - m=1: more data follows, m=0: last chunk
+    """
+    total_len = len(encoded_data)
+
+    for i in range(0, total_len, _CHUNK_SIZE):
+        chunk = encoded_data[i : i + _CHUNK_SIZE]
+        is_last = i + _CHUNK_SIZE >= total_len
+
+        if i == 0:
+            # First chunk: include control parameters
+            ctrl = "a=T,f=100"
+            if height is not None:
+                ctrl += f",r={height}"
+            ctrl += f",m={0 if is_last else 1}"
+            out.write(f"\033_G{ctrl};{chunk}\033\\")
+        else:
+            # Subsequent chunks: only m parameter needed
+            out.write(f"\033_Gm={0 if is_last else 1};{chunk}\033\\")

klaude_code/tui/terminal/selector.py

@@ -389,7 +389,7 @@ def _build_search_container(
     frame: bool = True,
 ) -> tuple[Window, Container]:
     """Build the search input container with placeholder."""
-    placeholder_text = f"{search_placeholder} · ↑↓ to select · esc to quit"
+    placeholder_text = f"{search_placeholder} · ↑↓ to select · enter/tab to confirm · esc to quit"
 
     search_prefix_window = Window(
         FormattedTextControl([("class:search_prefix", "/ ")]),
@@ -522,6 +522,23 @@ def select_one[T](
             return
         event.app.exit(result=value)
 
+    @kb.add(Keys.Tab, eager=True)
+    def _(event: KeyPressEvent) -> None:
+        """Accept the currently pointed item."""
+        indices, _ = _filter_items(items, get_filter_text())
+        if not indices:
+            event.app.exit(result=None)
+            return
+
+        nonlocal pointed_at
+        pointed_at = _coerce_pointed_at_to_selectable(items, indices, pointed_at)
+        idx = indices[pointed_at % len(indices)]
+        value = items[idx].value
+        if value is None:
+            event.app.exit(result=None)
+            return
+        event.app.exit(result=value)
+
     @kb.add(Keys.Escape, eager=True)
     def _(event: KeyPressEvent) -> None:
         nonlocal pointed_at
@@ -702,6 +719,28 @@ class SelectOverlay[T]:
             if hasattr(result, "__await__"):
                 event.app.create_background_task(cast(Coroutine[Any, Any, None], result))
 
+        @kb.add(Keys.Tab, filter=is_open_filter, eager=True)
+        def _(event: KeyPressEvent) -> None:
+            indices, _ = self._get_visible_indices()
+            if not indices:
+                self.close()
+                return
+
+            self._pointed_at = _coerce_pointed_at_to_selectable(self._items, indices, self._pointed_at)
+            idx = indices[self._pointed_at % len(indices)]
+            value = self._items[idx].value
+            if value is None:
+                self.close()
+                return
+            self.close()
+
+            if self._on_select is None:
+                return
+
+            result = self._on_select(value)
+            if hasattr(result, "__await__"):
+                event.app.create_background_task(cast(Coroutine[Any, Any, None], result))
+
         @kb.add(Keys.Escape, filter=is_open_filter, eager=True)
         def _(event: KeyPressEvent) -> None:
             if self._use_search_filter and self._search_buffer is not None and self._search_buffer.text:
@@ -757,9 +796,20 @@ class SelectOverlay[T]:
             dont_extend_height=Always(),
             always_hide_cursor=Always(),
         )
+        def get_list_height() -> int:
+            # Dynamic height: min of configured height and available terminal space
+            # Overhead: header(1) + spacer(1) + search(1) + frame borders(2) + prompt area(3)
+            overhead = 8
+            try:
+                terminal_height = get_app().output.get_size().rows
+                available = max(3, terminal_height - overhead)
+                return min(self._list_height, available)
+            except Exception:
+                return self._list_height
+
         list_window = Window(
             FormattedTextControl(get_choices_tokens),
-            height=self._list_height,
+            height=get_list_height,
             scroll_offsets=ScrollOffsets(top=0, bottom=2),
             allow_scroll_beyond_bottom=True,
             dont_extend_height=Always(),

{klaude_code-2.6.0.dist-info → klaude_code-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.6.0
+Version: 2.7.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -9,15 +9,13 @@ Requires-Dist: diff-match-patch>=20241021
 Requires-Dist: google-genai>=1.56.0
 Requires-Dist: markdown-it-py>=4.0.0
 Requires-Dist: openai>=1.102.0
-Requires-Dist: pillow>=9.1,<11.0
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.1.0
-Requires-Dist: term-image>=0.7.2
 Requires-Dist: trafilatura>=2.0.0
 Requires-Dist: typer>=0.17.3
-Requires-Python: >=3.13, <3.14
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 
 # Klaude Code
@@ -61,20 +59,22 @@ klaude upgrade
 ## Usage
 
 ```bash
-klaude [--model <name>] [--select-model]
+klaude [--model [<name>]] [--continue] [--resume [<id>]]
 ```
 
 **Options:**
-- `--model`/`-m`: Preferred model name (exact match picks immediately; otherwise opens the interactive selector filtered by this value).
-- `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
+- `--model`/`-m`: Choose a model.
+  - `--model` (no value): opens the interactive selector.
+  - `--model <value>`: resolves `<value>` to a single model; if it can't, it opens the interactive selector filtered by `<value>`.
 - `--continue`/`-c`: Resume the most recent session.
-- `--resume`/`-r`: Select a session to resume for this project.
-- `--resume-by-id <id>`: Resume a session by its ID directly.
+- `--resume`/`-r`: Resume a session.
+  - `--resume` (no value): select a session to resume for this project.
+  - `--resume <id>`: resume a session by its ID directly.
 - `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit, Write) and no system prompts.
 
 **Model selection behavior:**
 - Default: uses `main_model` from config.
-- `--select-model`: always prompts you to pick.
+- `--model` (no value): always prompts you to pick.
 - `--model <value>`: tries to resolve `<value>` to a single model; if it can't, it prompts with a filtered list (and falls back to showing all models if there are no matches).
 
 **Debug Options:**