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

klaude_code/tui/components/user_input.py

@@ -12,29 +12,52 @@ from klaude_code.tui.components.rich.theme import ThemeKey
 # patterns such as foo@bar.com as file references.
 AT_FILE_RENDER_PATTERN = re.compile(r'(?<!\S)@("([^"]+)"|\S+)')
 
-# Match $skill or ¥skill pattern at the beginning of the first line
-SKILL_RENDER_PATTERN = re.compile(r"^[$¥](\S+)")
+# Match $skill or ¥skill pattern inline (at start of line or after whitespace)
+SKILL_RENDER_PATTERN = re.compile(r"(?<!\S)[$¥](\S+)")
 
 USER_MESSAGE_MARK = "❯ "
 
 
-def render_at_pattern(
+def render_at_and_skill_patterns(
     text: str,
     at_style: str = ThemeKey.USER_INPUT_AT_PATTERN,
+    skill_style: str = ThemeKey.USER_INPUT_SKILL,
     other_style: str = ThemeKey.USER_INPUT,
 ) -> Text:
-    if "@" not in text:
+    """Render text with highlighted @file and $skill patterns."""
+    has_at = "@" in text
+    has_skill = "$" in text or "\u00a5" in text  # $ or ¥
+
+    if not has_at and not has_skill:
         return Text(text, style=other_style)
 
+    # Collect all matches with their styles
+    matches: list[tuple[int, int, str]] = []  # (start, end, style)
+
+    if has_at:
+        for match in AT_FILE_RENDER_PATTERN.finditer(text):
+            matches.append((match.start(), match.end(), at_style))
+
+    if has_skill:
+        for match in SKILL_RENDER_PATTERN.finditer(text):
+            skill_name = match.group(1)
+            if _is_valid_skill_name(skill_name):
+                matches.append((match.start(), match.end(), skill_style))
+
+    if not matches:
+        return Text(text, style=other_style)
+
+    # Sort by start position
+    matches.sort(key=lambda x: x[0])
+
     result = Text("")
     last_end = 0
-    for match in AT_FILE_RENDER_PATTERN.finditer(text):
-        start, end = match.span()
+    for start, end, style in matches:
+        if start < last_end:
+            continue  # Skip overlapping matches
         if start > last_end:
-            # Text before the @-pattern
             result.append_text(Text(text[last_end:start], other_style))
-        # The @-pattern itself (e.g. @path or @"path with spaces")
-        result.append_text(Text(text[start:end], at_style))
+        result.append_text(Text(text[start:end], style))
         last_end = end
 
     if last_end < len(text):
@@ -54,37 +77,25 @@ def render_user_input(content: str) -> RenderableType:
     """Render a user message as a group of quoted lines with styles.
 
     - Highlights slash command token on the first line
-    - Highlights $skill pattern on the first line if recognized
-    - Highlights @file patterns in all lines
+    - Highlights @file and $skill patterns in all lines
     """
     lines = content.strip().split("\n")
     renderables: list[RenderableType] = []
     for i, line in enumerate(lines):
-        line_text = render_at_pattern(line)
-
+        # Handle slash command on first line
         if i == 0 and line.startswith("/"):
             splits = line.split(" ", maxsplit=1)
             line_text = Text.assemble(
                 (splits[0], ThemeKey.USER_INPUT_SLASH_COMMAND),
                 " ",
-                render_at_pattern(splits[1]) if len(splits) > 1 else Text(""),
+                render_at_and_skill_patterns(splits[1]) if len(splits) > 1 else Text(""),
             )
             renderables.append(line_text)
             continue
 
-        if i == 0 and (line.startswith("$") or line.startswith("¥")):
-            m = SKILL_RENDER_PATTERN.match(line)
-            if m and _is_valid_skill_name(m.group(1)):
-                skill_token = m.group(0)  # e.g. "$skill-name"
-                rest = line[len(skill_token) :]
-                line_text = Text.assemble(
-                    (skill_token, ThemeKey.USER_INPUT_SKILL),
-                    render_at_pattern(rest) if rest else Text(""),
-                )
-                renderables.append(line_text)
-                continue
-
-        renderables.append(line_text)
+        # Render @file and $skill patterns
+        renderables.append(render_at_and_skill_patterns(line))
+
     grid = create_grid()
     grid.padding = (0, 0)
     mark = Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)

klaude_code/tui/input/AGENTS.md

@@ -0,0 +1,44 @@
+# tui/input Module
+
+REPL input handling: key bindings, paste/drag-drop conversion, and image attachment.
+
+## Data Flow
+
+```
+User Input (keyboard/paste/drag)
+    -> key_bindings.py (event dispatch)
+    -> [convert/fold] -> buffer text with markers
+    -> Enter submit -> expand markers, write history
+    -> iter_inputs() -> extract images -> UserInputPayload
+```
+
+## Marker Syntax
+
+| Marker | Purpose |
+|--------|---------|
+| `@<path>` | File/directory reference (triggers ReadTool) |
+| `[image <path>]` | Image attachment (encoded on submit) |
+| `[paste #N ...]` | Folded multi-line paste (expanded on submit) |
+
+## Files
+
+| File | Responsibility |
+|------|----------------|
+| `key_bindings.py` | Keyboard/paste event handlers; dispatches to converters; `copy_to_clipboard()` |
+| `prompt_toolkit.py` | PromptSession setup; `iter_inputs()` submit flow |
+| `drag_drop.py` | `file://` URI and path list to `@`/`[image]` conversion |
+| `images.py` | Image handling: marker syntax, Ctrl+V capture, `extract_images_from_text()` |
+| `paste.py` | `[paste #N ...]` fold/expand for large pastes |
+| `completers.py` | `@`/`/`/`$` completion providers |
+
+## Special Syntax Features (`@file`, `$skill`)
+
+These features span three modules that must stay in sync:
+
+| Stage | Module | Responsibility |
+|-------|--------|----------------|
+| Input | `completers.py` | Autocomplete paths/skills as user types |
+| Display | `components/user_input.py` | Highlight syntax in rendered messages |
+| Action | `core/reminders.py` | Inject file content / load skill for LLM |
+
+When adding or modifying syntax (e.g., new prefix like `#tag`), update all three.

klaude_code/tui/input/completers.py

@@ -38,7 +38,8 @@ from klaude_code.protocol.commands import CommandInfo
 AT_TOKEN_PATTERN = re.compile(r'(^|\s)@(?P<frag>"[^"]*"|[^\s]*)$')
 
 # Pattern to match $skill or ¥skill token for skill completion (used by key bindings).
-SKILL_TOKEN_PATTERN = re.compile(r"^[$¥](?P<frag>\S*)$")
+# Supports inline matching: after whitespace or at start of line.
+SKILL_TOKEN_PATTERN = re.compile(r"(^|\s)[$¥](?P<frag>\S*)$")
 
 
 def create_repl_completer(
@@ -130,10 +131,10 @@ class _SlashCommandCompleter(Completer):
 
 
 class _SkillCompleter(Completer):
-    """Complete skill names at the beginning of the first line.
+    """Complete skill names with $ or ¥ prefix.
 
     Behavior:
-    - Only triggers when cursor is on first line and text matches $ or ¥…
+    - Triggers when cursor is after $ or ¥ (at start of line or after whitespace)
     - Shows available skills with descriptions
     - Inserts trailing space after completion
     """
@@ -145,19 +146,16 @@ class _SkillCompleter(Completer):
         document: Document,
         complete_event,  # type: ignore[override]
     ) -> Iterable[Completion]:
-        # Only complete on first line
-        if document.cursor_position_row != 0:
-            return
-
         text_before = document.current_line_before_cursor
         m = self._SKILL_TOKEN_RE.search(text_before)
         if not m:
             return
 
         frag = m.group("frag").lower()
-        # Get the prefix character ($ or ¥)
-        prefix_char = text_before[0]
-        token_start = len(text_before) - len(f"{prefix_char}{m.group('frag')}")
+        # Calculate token start: the match includes optional leading whitespace
+        # The actual token is $frag or ¥frag (1 char prefix + frag)
+        token_len = 1 + len(m.group("frag"))  # $ or ¥ + frag
+        token_start = len(text_before) - token_len
         start_position = token_start - len(text_before)  # negative offset
 
         # Get available skills from SkillTool
@@ -204,8 +202,6 @@ class _SkillCompleter(Completer):
 
     def is_skill_context(self, document: Document) -> bool:
         """Check if current context is a skill completion."""
-        if document.cursor_position_row != 0:
-            return False
         text_before = document.current_line_before_cursor
         return bool(self._SKILL_TOKEN_RE.search(text_before))
 
@@ -228,8 +224,8 @@ class _ComboCompleter(Completer):
             yield from self._slash_completer.get_completions(document, complete_event)
             return
 
-        # Try skill completion (only on first line with $ prefix)
-        if document.cursor_position_row == 0 and self._skill_completer.is_skill_context(document):
+        # Try skill completion (with $ or ¥ prefix)
+        if self._skill_completer.is_skill_context(document):
             yield from self._skill_completer.get_completions(document, complete_event)
             return
 

klaude_code/tui/input/drag_drop.py

@@ -0,0 +1,197 @@
+"""Drag-and-drop / paste helpers for the REPL input.
+
+Terminals typically implement drag-and-drop as a bracketed paste of either:
+- A file URL (e.g. "file:///Users/me/foo.txt")
+- A shell-escaped path (e.g. "/Users/me/My\\ File.txt")
+
+We convert these into the input formats that Klaude already supports:
+- Regular files/dirs -> @path (quoted when needed)
+- Image files -> [image <path>] markers (resolved to ImageURLPart on submit)
+"""
+
+from __future__ import annotations
+
+import contextlib
+import re
+import shlex
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+from klaude_code.tui.input.images import format_image_marker, is_image_file
+
+_FILE_URI_RE = re.compile(r"file://\S+")
+
+
+def _format_at_token(path_str: str) -> str:
+    """Format a file path for the @ reader, quoting when whitespace exists."""
+
+    if any(ch.isspace() for ch in path_str):
+        return f'@"{path_str}"'
+    return f"@{path_str}"
+
+
+def _normalize_path_for_at(path: Path, *, cwd: Path) -> str:
+    """Return a stable, display-friendly path string for @ references."""
+
+    # Use absolute() instead of resolve() to avoid expanding symlinks.
+    # On macOS, /var -> /private/var, and users expect /var paths to stay as /var.
+    try:
+        resolved = path.absolute()
+    except OSError:
+        resolved = path
+
+    cwd_resolved = cwd
+    with contextlib.suppress(OSError):
+        cwd_resolved = cwd.absolute()
+
+    as_dir = False
+    try:
+        as_dir = resolved.exists() and resolved.is_dir()
+    except OSError:
+        as_dir = False
+
+    # Prefer relative paths under CWD to match completer output.
+    candidate: str
+    try:
+        rel = resolved.relative_to(cwd_resolved)
+        candidate = rel.as_posix()
+    except ValueError:
+        candidate = resolved.as_posix()
+
+    if as_dir and candidate and not candidate.endswith("/"):
+        candidate += "/"
+    return candidate
+
+
+def _file_uri_to_path(uri: str) -> Path | None:
+    """Parse a file:// URI to a filesystem path."""
+
+    try:
+        parsed = urlparse(uri)
+    except Exception:
+        return None
+
+    if parsed.scheme != "file":
+        return None
+
+    # Common forms:
+    # - file:///Users/me/foo.txt
+    # - file://localhost/Users/me/foo.txt
+    # - file:///C:/Users/me/foo.txt (Windows)
+    raw_path = unquote(parsed.path or "")
+    if not raw_path:
+        return None
+
+    if re.match(r"^/[A-Za-z]:/", raw_path):
+        # Windows drive letter URIs often include an extra leading slash.
+        raw_path = raw_path[1:]
+
+    return Path(raw_path)
+
+
+def _replace_file_uris(
+    text: str,
+    *,
+    cwd: Path,
+) -> tuple[str, bool]:
+    """Replace all file://... occurrences in text.
+
+    Returns (new_text, changed).
+    """
+
+    changed = False
+
+    def _replace(match: re.Match[str]) -> str:
+        nonlocal changed
+        uri = match.group(0)
+
+        # Strip trailing punctuation that is very likely not part of the URI.
+        trail = ""
+        while uri and uri[-1] in ")],.;:!?":
+            trail = uri[-1] + trail
+            uri = uri[:-1]
+
+        path = _file_uri_to_path(uri)
+        if path is None:
+            return match.group(0)
+
+        try:
+            is_image = path.exists() and path.is_file() and is_image_file(path)
+        except OSError:
+            is_image = False
+
+        if is_image:
+            changed = True
+            return format_image_marker(_normalize_path_for_at(path, cwd=cwd)) + trail
+
+        token = _format_at_token(_normalize_path_for_at(path, cwd=cwd))
+        changed = True
+        return token + trail
+
+    out = _FILE_URI_RE.sub(_replace, text)
+    return out, changed
+
+
+def _looks_like_path_list(text: str) -> list[str] | None:
+    """Return tokens if text looks like a pure path list, else None."""
+
+    stripped = text.strip()
+    if not stripped:
+        return None
+
+    # Avoid converting when the paste already contains our input syntax.
+    if "@" in stripped or "[image " in stripped:
+        return None
+
+    try:
+        tokens = shlex.split(stripped, posix=True)
+    except ValueError:
+        return None
+
+    if not tokens:
+        return None
+
+    # Heuristic: all tokens must exist on disk.
+    for tok in tokens:
+        p = Path(tok).expanduser()
+        try:
+            if not p.exists():
+                return None
+        except OSError:
+            return None
+
+    return tokens
+
+
+def convert_dropped_text(
+    text: str,
+    *,
+    cwd: Path,
+) -> str:
+    """Convert drag-and-drop text into @ tokens and/or image markers."""
+
+    out, changed = _replace_file_uris(text, cwd=cwd)
+    if changed:
+        return out
+
+    tokens = _looks_like_path_list(text)
+    if not tokens:
+        return text
+
+    converted: list[str] = []
+    for tok in tokens:
+        p = Path(tok).expanduser()
+        try:
+            is_img = p.exists() and p.is_file() and is_image_file(p)
+        except OSError:
+            is_img = False
+
+        if is_img:
+            converted.append(format_image_marker(_normalize_path_for_at(p, cwd=cwd)))
+            continue
+
+        converted.append(_format_at_token(_normalize_path_for_at(p, cwd=cwd)))
+
+    # Preserve trailing newline if present (common for bracketed paste payloads).
+    suffix = "\n" if text.endswith("\n") else ""
+    return " ".join(converted) + suffix

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