regcode 0.7.0__tar.gz → 0.8.1__tar.gz

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

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.7.0
+Version: 0.8.1
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.10
+Requires-Dist: boto3>=1.43.40
 Requires-Dist: click>=8.0
 Requires-Dist: crawl4ai>=0.4.0
 Requires-Dist: litellm>=1.83.17
@@ -10,6 +11,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.1}/pyproject.toml

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

{regcode-0.7.0 → regcode-0.8.1}/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.1"

regcode-0.8.1/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.1}/regcode/main.py

@@ -5,13 +5,13 @@ from __future__ import annotations
 import json
 import logging
 import sys
-import warnings
 from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any, Callable
 
 import litellm
+from pydantic import BaseModel
 
 from regcode.config import Config
 from regcode.conversation_manager import ConversationManager
@@ -427,19 +427,23 @@ 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,
         on_text_chunk: Callable[[str], None] | None = None,
+        response_format: BaseModel | None = None,
     ) -> str:
         """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).
+            response_format: Pydantic model for formatting the response.
 
         Returns:
             The agent's final response string.
@@ -447,20 +451,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
@@ -511,6 +535,8 @@ class Agent:
             elif self._tool_budget_exhausted:
                 # Explicitly tell the LLM no tools are available
                 completion_kwargs["tool_choice"] = "none"
+            if response_format is not None:
+                completion_kwargs["response_format"] = response_format
 
             response = litellm.completion(**completion_kwargs)
 
@@ -1321,7 +1347,7 @@ class Agent:
         max_tool_calls: int = 20,
         stream: bool = False,
         extra_instructions: str | None = None,
-        review_instruction: str | None = None,
+        response_format: BaseModel | None = None,
     ) -> str:
         """Perform a code review on the given directory.
 
@@ -1344,15 +1370,6 @@ class Agent:
         Returns:
             The agent's review response string.
         """
-        if review_instruction is not None:
-            warnings.warn(
-                "The 'review_instruction' parameter is deprecated; "
-                "use 'extra_instructions' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            if extra_instructions is None:
-                extra_instructions = review_instruction
         # Scan the directory structure
         dir_tree = self._scan_directory_tree(code_root_dir)
 
@@ -1376,6 +1393,7 @@ class Agent:
             messages=messages,
             max_tool_calls=max_tool_calls,
             stream=stream,
+            response_format=response_format
         )
 
     def cleanup(self) -> None: