regcode 0.7.0__tar.gz → 0.8.0__tar.gz

{regcode-0.7.0 → regcode-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.7.0
+Version: 0.8.0
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0
@@ -10,6 +10,7 @@ Requires-Dist: mlflow>=3.14.0
 Requires-Dist: pathspec>=1.1.1
 Requires-Dist: pydantic-monty>=0.0.18
 Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pytest>=8.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: ruff>=0.8

{regcode-0.7.0 → regcode-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "regcode"
-version = "0.7.0"
+version = "0.8.0"
 description = "Minimalistic coding agent with Python API and CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -16,6 +16,7 @@ dependencies = [
     "mlflow>=3.14.0",
     "textual>=2.0.0",
     "pathspec>=1.1.1",
+    "pyperclip>=1.9.0",
 ]
 
 [project.scripts]

{regcode-0.7.0 → regcode-0.8.0}/regcode/__init__.py

@@ -2,4 +2,4 @@ from regcode.config import Config
 from regcode.main import Agent, AgentStatus, ToolCall
 
 __all__ = ["Agent", "Config", "AgentStatus", "ToolCall"]
-__version__ = "0.6.3"
+__version__ = "0.8.0"

regcode-0.8.0/regcode/clipboard.py

@@ -0,0 +1,378 @@
+"""Clipboard utilities for image and text detection, with base64 encoding.
+
+Supports Wayland (wl-paste) and X11 (xclip/xsel) and WSL clipboard backends.
+Detects image vs text content and provides base64 encoding for images.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import mimetypes
+import subprocess
+from dataclasses import dataclass
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ClipboardContent:
+    """Represents clipboard content with type information."""
+
+    content: str  # Base64 for images, raw text for text
+    content_type: str  # "image" or "text"
+    mime_type: str  # e.g., "image/png", "text/plain"
+    is_image: bool
+
+
+# Image extensions to MIME types mapping
+IMAGE_EXTENSIONS: dict[str, str] = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".tiff": "image/tiff",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".avif": "image/avif",
+}
+
+
+def detect_image_mime_type(ext: str) -> str:
+    """Detect MIME type from file extension."""
+    ext = ext.lower()
+    return IMAGE_EXTENSIONS.get(ext, "application/octet-stream")
+
+
+def get_clipboard_backend() -> str:
+    """Detect which clipboard backend is available.
+
+    Returns one of: 'wl-clipboard', 'xclip', 'xsel', 'wsl', or empty string.
+    """
+    # Check Wayland first
+    try:
+        result = subprocess.run(
+            ["which", "wl-paste"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            return "wl-clipboard"
+    except (FileNotFoundError, OSError):
+        pass
+
+    # Check X11
+    try:
+        result = subprocess.run(
+            ["which", "xclip"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            return "xclip"
+    except (FileNotFoundError, OSError):
+        pass
+
+    try:
+        result = subprocess.run(
+            ["which", "xsel"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            return "xsel"
+    except (FileNotFoundError, OSError):
+        pass
+
+    # Check WSL clipboard integration (clip.exe + powershell.exe)
+    try:
+        result = subprocess.run(
+            ["which", "clip.exe"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            result2 = subprocess.run(
+                ["which", "powershell.exe"],
+                capture_output=True,
+                text=True,
+            )
+            if result2.returncode == 0:
+                return "wsl"
+    except (FileNotFoundError, OSError):
+        pass
+
+    return ""
+
+
+def read_clipboard_text(backend: str) -> str:
+    """Read plain text from clipboard.
+
+    Args:
+        backend: Clipboard backend to use ('wl-clipboard', 'xclip', 'xsel', 'wsl', '')
+
+    Returns:
+        Text content from clipboard, or empty string on failure.
+    """
+    try:
+        if backend == "wl-clipboard":
+            result = subprocess.run(
+                ["wl-paste", "-t", "text/plain"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+        elif backend == "xclip":
+            result = subprocess.run(
+                ["xclip", "-selection", "clipboard", "-o"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+        elif backend == "xsel":
+            result = subprocess.run(
+                ["xsel", "--clipboard", "--output"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+        elif backend == "wsl":
+            # WSL clipboard: use PowerShell to read clipboard
+            ps_script = (
+                "[Convert]::ToBase64String("
+                "[Text.Encoding]::UTF8.GetBytes((Get-Clipboard -Raw)))"
+            )
+            result = subprocess.run(
+                [
+                    "powershell.exe",
+                    "-noprofile",
+                    "-command",
+                    ps_script,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                try:
+                    base64_data = result.stdout.strip()
+                    decoded_bytes = base64.b64decode(base64_data)
+                    text = decoded_bytes.decode("utf-8")
+                    # Normalize Windows line endings to Unix for terminal display
+                    text = text.replace("\r\n", "\n").replace("\r", "\n")
+                    return text.strip()
+                except Exception:
+                    return ""
+            return ""
+        else:
+            return ""
+
+        if result.returncode == 0:
+            text = result.stdout
+            # Normalize Windows line endings to Unix for terminal display
+            text = text.replace("\r\n", "\n").replace("\r", "\n")
+            return text.strip()
+        else:
+            logger.debug("Failed to read text from clipboard: %s", result.stderr)
+            return ""
+    except (subprocess.TimeoutExpired, OSError, subprocess.SubprocessError) as e:
+        logger.debug("Error reading clipboard text: %s", e)
+        return ""
+
+
+def read_clipboard_image(backend: str) -> Optional[bytes]:
+    """Read raw image bytes from clipboard.
+
+    Args:
+        backend: Clipboard backend to use
+
+    Returns:
+        Raw image bytes, or None if clipboard doesn't contain an image.
+    """
+    try:
+        if backend == "wl-clipboard":
+            result = subprocess.run(
+                ["wl-paste", "-t", "image/png"],
+                capture_output=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and len(result.stdout) > 0:
+                return result.stdout
+        elif backend == "xclip":
+            # xclip doesn't support direct image output, need to check with xwd
+            # This is a fallback - primary Wayland support is through wl-clipboard
+            result = subprocess.run(
+                ["wl-paste", "-t", "image/png"],
+                capture_output=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and len(result.stdout) > 0:
+                return result.stdout
+        elif backend == "wsl":
+            # WSL: load Windows Forms assembly and read clipboard image
+            ps_script = (
+                "Add-Type -AssemblyName System.Windows.Forms; "
+                "$ms = New-Object IO.MemoryStream; "
+                "[System.Windows.Forms.Clipboard]::GetImage().Save($ms, "
+                "[System.Drawing.Imaging.ImageFormat]::Png); "
+                "[Convert]::ToBase64String($ms.ToArray())"
+            )
+            result = subprocess.run(
+                [
+                    "powershell.exe",
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    ps_script,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                try:
+                    # PowerShell wraps base64 with newlines, remove all whitespace
+                    clean = result.stdout.replace("\n", "").replace("\r", "").strip()
+                    return base64.b64decode(clean)
+                except Exception:
+                    logger.debug("Failed to decode WSL clipboard image base64")
+                    return None
+    except (subprocess.TimeoutExpired, OSError, subprocess.SubprocessError) as e:
+        logger.debug("Error reading clipboard image: %s", e)
+
+    return None
+
+
+def clipboard_is_image(backend: str) -> bool:
+    """Check if clipboard contains an image.
+
+    Args:
+        backend: Clipboard backend to use
+
+    Returns:
+        True if clipboard contains an image, False otherwise.
+    """
+    try:
+        if backend == "wl-clipboard":
+            result = subprocess.run(
+                ["wl-paste", "-t", "image/png"],
+                capture_output=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and len(result.stdout) > 0:
+                # Verify it's actually a PNG
+                if result.stdout[:8] == b"\x89PNG\r\n\x1a\n":
+                    return True
+        elif backend in ("xclip", "xsel"):
+            # For X11, check if we can extract image
+            return read_clipboard_image(backend) is not None
+        elif backend == "wsl":
+            # For WSL, try to get image via PowerShell
+            return read_clipboard_image(backend) is not None
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+    return False
+
+
+def get_image_mime_type(data: bytes) -> str:
+    """Detect MIME type from image data bytes.
+
+    Args:
+        data: Raw image bytes
+
+    Returns:
+        MIME type string (e.g., "image/png")
+    """
+    # Check PNG signature
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        return "image/png"
+
+    # Check JPEG signature
+    if data[:2] == b"\xff\xd8":
+        return "image/jpeg"
+
+    # Check GIF signature
+    if data[:4] in (b"GIF87a", b"GIF89a"):
+        return "image/gif"
+
+    # Check WebP signature
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "image/webp"
+
+    # Fallback: try to detect from magic bytes
+    mime_type = mimetypes.guess_type("image.tmp")
+    if mime_type and mime_type[0]:
+        return mime_type[0]
+
+    return "application/octet-stream"
+
+
+def encode_image_to_base64(data: bytes, mime_type: str = "") -> str:
+    """Encode image bytes to base64 data URL.
+
+    Args:
+        data: Raw image bytes
+        mime_type: MIME type of the image
+
+    Returns:
+        Base64 data URL string (e.g., "data:image/png;base64,...")
+    """
+    if not mime_type:
+        mime_type = get_image_mime_type(data)
+
+    base64_data = base64.b64encode(data).decode("utf-8")
+    return f"data:{mime_type};base64,{base64_data}"
+
+
+def get_clipboard_content() -> ClipboardContent:
+    """Get clipboard content, auto-detecting image vs text.
+
+    Returns:
+        ClipboardContent with detected type and base64-encoded data for images.
+    """
+    backend = get_clipboard_backend()
+    if not backend:
+        return ClipboardContent(
+            content="",
+            content_type="text",
+            mime_type="text/plain",
+            is_image=False,
+        )
+
+    # Check if clipboard contains an image
+    if clipboard_is_image(backend):
+        image_data = read_clipboard_image(backend)
+        if image_data is not None:
+            mime_type = get_image_mime_type(image_data)
+            base64_data = encode_image_to_base64(image_data, mime_type)
+            return ClipboardContent(
+                content=base64_data,
+                content_type="image",
+                mime_type=mime_type,
+                is_image=True,
+            )
+
+    # Fall back to text
+    text_content = read_clipboard_text(backend)
+    return ClipboardContent(
+        content=text_content,
+        content_type="text",
+        mime_type="text/plain",
+        is_image=False,
+    )
+
+
+def read_multiline_text(backend: str) -> str:
+    """Read potentially multiline text from clipboard.
+
+    Args:
+        backend: Clipboard backend to use
+
+    Returns:
+        Multiline text content from clipboard.
+    """
+    return read_clipboard_text(backend)

{regcode-0.7.0 → regcode-0.8.0}/regcode/main.py

@@ -427,7 +427,7 @@ class Agent:
 
     def chat(
         self,
-        message: str | None = None,
+        message: str | list[dict[str, Any]] | None = None,
         stream: bool = False,
         max_tool_calls: int = 10,
         messages: list[dict[str, Any]] | None = None,
@@ -436,7 +436,9 @@ class Agent:
         """Send a message and get a response, with automatic tool use.
 
         Args:
-            message: User message (required if 'messages' not provided).
+            message: User message string, or multimodal list of content parts.
+                     Multimodal example: [{"type": "text", "text": "describe"},
+                     {"type": "image_url", "image_url": {"url": "data:..."}}]
             stream: Whether to stream the final response.
             max_tool_calls: Maximum number of tool call turns.
             messages: Pre-built message list (overrides 'message' parameter).
@@ -447,20 +449,40 @@ class Agent:
         if messages is None:
             if message is None:
                 raise ValueError("Either 'message' or 'messages' must be provided")
+            # Build user message content based on type
+            if isinstance(message, str):
+                user_content: str | list[dict[str, Any]] = message
+            elif isinstance(message, list):
+                # Multimodal message — already in litellm format
+                user_content = message
+            else:
+                raise ValueError(
+                    f"message must be str or list[dict], got {type(message).__name__}"
+                )
             messages = [
                 {"role": "system", "content": self._build_system_prompt()},
                 *self._history,
-                {"role": "user", "content": message},
+                {"role": "user", "content": user_content},
             ]
 
         # Add messages to context manager for compaction tracking
         # Only add messages not already in history to avoid double-counting
-        existing_content_keys = {
-            (msg.get("role"), msg.get("content", ""))
-            for msg in self._history
-        }
+        existing_content_keys: set[tuple] = set()
+        for msg in self._history:
+            content = msg.get("content")
+            # Multimodal content (list) is unhashable — convert to string key
+            if isinstance(content, list):
+                content_key = json.dumps(content, sort_keys=True)
+            else:
+                content_key = content or ""
+            existing_content_keys.add((msg.get("role"), content_key))
         for msg in messages:
-            if (msg.get("role"), msg.get("content", "")) not in existing_content_keys:
+            content = msg.get("content")
+            if isinstance(content, list):
+                content_key = json.dumps(content, sort_keys=True)
+            else:
+                content_key = content or ""
+            if (msg.get("role"), content_key) not in existing_content_keys:
                 self.context_manager.add_message(msg)
 
         # Check if compaction is needed

regcode-0.8.0/regcode/paste.py

@@ -0,0 +1,188 @@
+"""Paste utility for file-based paste handling.
+
+Intercepts paste events, saves content to temporary files, and generates
+file references for the TUI. On message submission, file references are
+detected and processed appropriately.
+"""
+
+from __future__ import annotations
+
+import base64
+import mimetypes
+import re
+import tempfile
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+
+@dataclass
+class PasteEntry:
+    """Represents a single paste entry saved to a temp file."""
+
+    file_path: Path
+    mime_type: str
+    is_image: bool
+    content: str  # For images: base64 data URI; for text: raw text
+
+
+def detect_mime_type(text: str) -> str:
+    """Detect MIME type from text content.
+
+    Checks if text looks like base64-encoded image data.
+    """
+    if _looks_like_base64_image(text):
+        try:
+            raw = base64.b64decode(text)
+            return _detect_image_from_bytes(raw)
+        except Exception:
+            pass
+
+    return "text/plain"
+
+
+def _looks_like_base64_image(text: str) -> bool:
+    """Check if text looks like base64-encoded image data."""
+    if len(text) < 20:
+        return False
+
+    # Check if text is mostly base64 characters
+    b64_pattern = re.compile(r"^[A-Za-z0-9+/=\s]+$")
+    if not b64_pattern.match(text):
+        return False
+
+    # Check for common image prefixes
+    for prefix in [
+        "iVBORw",  # PNG
+        "/9j/",  # JPEG
+        "R0lGOD",  # GIF
+        "RklGRVBI",  # WebP (RIFF)
+    ]:
+        if text.startswith(prefix):
+            return True
+
+    return False
+
+
+def _detect_image_from_bytes(data: bytes) -> str:
+    """Detect MIME type from image bytes."""
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        return "image/png"
+    if data[:2] == b"\xff\xd8":
+        return "image/jpeg"
+    if data[:4] in (b"GIF87a", b"GIF89a"):
+        return "image/gif"
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "image/webp"
+    if data[:3] == b"BM":
+        return "image/bmp"
+    return "image/unknown"
+
+
+def save_paste_content(content: str) -> PasteEntry:
+    """Save paste content to a temporary file.
+
+    Args:
+        content: The raw text content from clipboard.
+
+    Returns:
+        PasteEntry with file path, MIME type, and metadata.
+    """
+    file_id = uuid.uuid4().hex[:12]
+    mime_type = detect_mime_type(content)
+    is_image = mime_type.startswith("image/")
+
+    if is_image:
+        try:
+            raw_bytes = base64.b64decode(content)
+            # Use system temp dir with unique filename
+            ext = mimetypes.guess_extension(mime_type) or ".png"
+            if ext == ".jpe":
+                ext = ".jpg"
+            if ext == ".jfif":
+                ext = ".jpg"
+            file_path = Path(tempfile.gettempdir()) / f"regcode_paste_{file_id}{ext}"
+            file_path.write_bytes(raw_bytes)
+        except Exception:
+            file_path = Path(tempfile.gettempdir()) / f"regcode_paste_{file_id}.txt"
+            file_path.write_text(content, encoding="utf-8")
+            mime_type = "text/plain"
+            is_image = False
+    else:
+        file_path = Path(tempfile.gettempdir()) / f"regcode_paste_{file_id}.txt"
+        file_path.write_text(content, encoding="utf-8")
+
+    return PasteEntry(
+        file_path=file_path,
+        mime_type=mime_type,
+        is_image=is_image,
+        content=content,
+    )
+
+
+def create_file_reference(paste_entry: PasteEntry) -> str:
+    """Create a [FILE: ...] reference string for display in input box."""
+    return f"[FILE: {paste_entry.file_path}]"
+
+
+def parse_file_references(text: str) -> List[PasteEntry]:
+    """Parse [FILE: ...] references from text.
+
+    Args:
+        text: Text that may contain [FILE: ...] references.
+
+    Returns:
+        List of PasteEntry objects for each file reference found.
+    """
+    pattern = r"\[FILE:\s*([^]]+?)\s*\]"
+    matches = re.finditer(pattern, text)
+
+    entries = []
+    for match in matches:
+        file_path_str = match.group(1).strip()
+        file_path = Path(file_path_str)
+
+        if not file_path.exists():
+            continue
+
+        # Determine MIME type from extension
+        mime_type = mimetypes.guess_type(str(file_path))[0] or "text/plain"
+        is_image = mime_type.startswith("image/")
+
+        # Read content
+        try:
+            if is_image:
+                raw_bytes = file_path.read_bytes()
+                base64_data = base64.b64encode(raw_bytes).decode("utf-8")
+                content = f"data:{mime_type};base64,{base64_data}"
+            else:
+                content = file_path.read_text(encoding="utf-8")
+        except Exception:
+            continue
+
+        entries.append(
+            PasteEntry(
+                file_path=file_path,
+                mime_type=mime_type,
+                is_image=is_image,
+                content=content,
+            )
+        )
+
+    return entries
+
+
+def remove_file_references(text: str) -> str:
+    """Remove [FILE: ...] references from text."""
+    return re.sub(r"\[FILE:\s*[^]]+?\s*\]", "", text).strip()
+
+
+def cleanup_paste_files(entries: List[PasteEntry]) -> None:
+    """Remove paste files after processing."""
+    for entry in entries:
+        try:
+            if entry.file_path.exists():
+                entry.file_path.unlink()
+        except OSError:
+            pass