klaude-code 2.5.3__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/display.py

@@ -30,8 +30,18 @@ class TUIDisplay(DisplayABC):
 
     @override
     async def consume_event(self, event: events.Event) -> None:
+        if isinstance(event, events.ReplayHistoryEvent):
+            await self._renderer.execute(self._machine.begin_replay())
+            for item in event.events:
+                commands = self._machine.transition_replay(item)
+                if commands:
+                    await self._renderer.execute(commands)
+            await self._renderer.execute(self._machine.end_replay())
+            return
+
         commands = self._machine.transition(event)
-        await self._renderer.execute(commands)
+        if commands:
+            await self._renderer.execute(commands)
 
     @override
     async def start(self) -> None:

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
 
@@ -313,11 +309,13 @@ class _AtFilesCompleter(Completer):
             if not suggestions:
                 return []  # type: ignore[reportUnknownVariableType]
             start_position = token_start_in_input - len(text_before)
-            for s in suggestions[: self._max_results]:
+            suggestions_to_show = suggestions[: self._max_results]
+            align_width = self._display_align_width(suggestions_to_show)
+            for s in suggestions_to_show:
                 yield Completion(
                     text=self._format_completion_text(s, is_quoted=is_quoted),
                     start_position=start_position,
-                    display=self._format_display_label(s, 0),
+                    display=self._format_display_label(s, align_width),
                     display_meta=s,
                 )
             return []  # type: ignore[reportUnknownVariableType]
@@ -329,12 +327,14 @@ class _AtFilesCompleter(Completer):
 
         # Prepare Completion objects. Replace from the '@' character.
         start_position = token_start_in_input - len(text_before)  # negative
-        for s in suggestions[: self._max_results]:
+        suggestions_to_show = suggestions[: self._max_results]
+        align_width = self._display_align_width(suggestions_to_show)
+        for s in suggestions_to_show:
             # Insert formatted text (with quoting when needed) so that subsequent typing does not keep triggering
             yield Completion(
                 text=self._format_completion_text(s, is_quoted=is_quoted),
                 start_position=start_position,
-                display=self._format_display_label(s, 0),
+                display=self._format_display_label(s, align_width),
                 display_meta=s,
             )
 
@@ -543,9 +543,9 @@ class _AtFilesCompleter(Completer):
         Keep this unstyled so that the completion menu's selection style can
         fully override the selected row.
         """
-
-        _ = align_width
-        return self._display_name(suggestion)
+        name = self._display_name(suggestion)
+        # Pad to align_width + extra padding for visual separation from meta
+        return name.ljust(align_width + 6)
 
     def _display_align_width(self, suggestions: list[str]) -> int:
         """Calculate alignment width for display labels."""

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