klaude-code 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/ui/core/input.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator
+
+from klaude_code.protocol.model import UserInputPayload
+
+
+class InputProviderABC(ABC):
+    """
+    Abstract base class for user input providers.
+
+    An InputProvider is responsible for collecting user input and yielding it
+    to the application. Implementations handle the specifics of input collection,
+    such as terminal readline, prompt-toolkit sessions, or other input sources.
+
+    Lifecycle:
+        1. start() is called once before any inputs are requested.
+        2. iter_inputs() yields user input strings until the user exits.
+        3. stop() is called once when input collection is complete.
+
+    Typical Usage:
+        input_provider = PromptToolkitInput(status_provider=my_status_fn)
+        await input_provider.start()
+        try:
+            async for user_input in input_provider.iter_inputs():
+                if user_input.text.strip().lower() in {"exit", "quit"}:
+                    break
+                # Process user_input.text and user_input.images...
+        finally:
+            await input_provider.stop()
+
+    Thread Safety:
+        Input providers should be used from a single async task.
+    """
+
+    @abstractmethod
+    async def start(self) -> None:
+        """
+        Initialize the input provider before reading inputs.
+
+        Called once before iter_inputs(). Use this for any setup that needs
+        to happen before input collection begins (e.g., configuring terminal
+        settings, loading history).
+        """
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """
+        Clean up the input provider after input collection is complete.
+
+        Called once after iter_inputs() finishes. Use this for cleanup such
+        as saving history, restoring terminal state, or releasing resources.
+        """
+
+    @abstractmethod
+    async def iter_inputs(self) -> AsyncIterator[UserInputPayload]:
+        """
+        Yield user input payloads asynchronously.
+
+        This is the main method for collecting user input. Each yield returns
+        one complete user input payload containing text and optional images
+        (e.g., after the user presses Enter). The iterator completes when the
+        user signals end of input (e.g., Ctrl+D) or when the application
+        requests shutdown.
+
+        Yields:
+            UserInputPayload with text and optional images.
+        """
+        raise NotImplementedError
+        yield UserInputPayload(text="")  # pyright: ignore[reportUnreachable]

klaude_code/ui/modes/__init__.py

@@ -0,0 +1 @@
+# UI mode implementations

klaude_code/ui/modes/debug/__init__.py

@@ -0,0 +1 @@
+# Debug mode

klaude_code/ui/{base/debug_event_display.py → modes/debug/display.py}

@@ -1,18 +1,22 @@
 from typing import override
 
-from klaude_code.const import DEFAULT_DEBUG_LOG_FILE
-from klaude_code.protocol.events import Event
+from klaude_code import const
+from klaude_code.protocol import events
 from klaude_code.trace import DebugType, log_debug
-from klaude_code.ui.base.display_abc import DisplayABC
+from klaude_code.ui.core.display import DisplayABC
 
 
 class DebugEventDisplay(DisplayABC):
-    def __init__(self, wrapped_display: DisplayABC | None = None, log_file: str = DEFAULT_DEBUG_LOG_FILE):
+    def __init__(
+        self,
+        wrapped_display: DisplayABC | None = None,
+        log_file: str = const.DEFAULT_DEBUG_LOG_FILE,
+    ):
         self.wrapped_display = wrapped_display
         self.log_file = log_file
 
     @override
-    async def consume_event(self, event: Event) -> None:
+    async def consume_event(self, event: events.Event) -> None:
         log_debug(
             f"[{event.__class__.__name__}]",
             event.model_dump_json(exclude_none=True),

klaude_code/ui/modes/exec/__init__.py

@@ -0,0 +1 @@
+# Exec mode

klaude_code/ui/{base/exec_display.py → modes/exec/display.py}

@@ -1,8 +1,9 @@
+import sys
 from typing import override
 
 from klaude_code.protocol import events
-from klaude_code.ui.base.display_abc import DisplayABC
-from klaude_code.ui.base.progress_bar import OSC94States, emit_osc94
+from klaude_code.ui.core.display import DisplayABC
+from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 
 
 class ExecDisplay(DisplayABC):
@@ -35,3 +36,28 @@ class ExecDisplay(DisplayABC):
     async def stop(self) -> None:
         """Do nothing on stop."""
         pass
+
+
+class StreamJsonDisplay(DisplayABC):
+    """A display implementation that streams all events as JSON lines."""
+
+    @override
+    async def consume_event(self, event: events.Event) -> None:
+        """Stream each event as a JSON line."""
+        if isinstance(event, events.EndEvent):
+            return
+        event_type = type(event).__name__
+        json_data = event.model_dump_json()
+        # Output format: {"type": "EventName", "data": {...}}
+        print(f'{{"type": "{event_type}", "data": {json_data}}}', flush=True)
+        sys.stdout.flush()
+
+    @override
+    async def start(self) -> None:
+        """Do nothing on start."""
+        pass
+
+    @override
+    async def stop(self) -> None:
+        """Do nothing on stop."""
+        pass

klaude_code/ui/{repl → modes/repl}/__init__.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from klaude_code.protocol.model import AssistantMessageItem, ResponseMetadataItem, ToolCallItem
-from klaude_code.ui.repl.input import REPLStatusSnapshot
+from klaude_code.protocol import model
+from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
 
 if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
@@ -30,13 +30,13 @@ def build_repl_status_snapshot(agent: "Agent | None", update_message: str | None
 
         history = agent.session.conversation_history
         for item in history:
-            if isinstance(item, AssistantMessageItem):
+            if isinstance(item, model.AssistantMessageItem):
                 llm_calls += 1
-            elif isinstance(item, ToolCallItem):
+            elif isinstance(item, model.ToolCallItem):
                 tool_calls += 1
 
         for item in reversed(history):
-            if isinstance(item, ResponseMetadataItem):
+            if isinstance(item, model.ResponseMetadataItem):
                 usage = item.usage
                 if usage is not None and hasattr(usage, "context_usage_percent"):
                     context_usage_percent = usage.context_usage_percent
@@ -49,4 +49,3 @@ def build_repl_status_snapshot(agent: "Agent | None", update_message: str | None
         tool_calls=tool_calls,
         update_message=update_message,
     )
-

klaude_code/ui/modes/repl/clipboard.py

@@ -0,0 +1,152 @@
+"""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.model 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 Exception:
+            return None
+        if not isinstance(clipboard_data, Image.Image):
+            return None
+        try:
+            self._images_dir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            return None
+        filename = f"clipboard_{uuid.uuid4().hex[:8]}.png"
+        path = self._images_dir / filename
+        try:
+            clipboard_data.save(path, "PNG")
+        except Exception:
+            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(image_url=ImageURLPart.ImageURL(url=data_url, id=None))
+    except Exception:
+        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 Exception:
+        pass