regcode 0.6.3__tar.gz → 0.8.0__tar.gz

{regcode-0.6.3 → regcode-0.8.0}/AGENTS.md

@@ -3,25 +3,17 @@ Always make sure to comply to these rules. Under Project Stack, you will find te
 
 ## Project Stack:
 - `uv`: Dependency management for Python runtime
-- Alembic: Database migrations
-- FastAPI: Backend Logic
-- SQLAlchemy ORM: Python database ORM
-- PostgreSQL/SQLITE: Target databases
 - Pytest: Test suite under `tests`
-- NextJS/React: Frontend Code under `frontend/`
 - GitLab: Code Repository/ CI CD
 - .gitlab-ci.yml: Gitlab Runner Config
 - `ruff`: Linting and Code Quality Control
-- `docker`: Deployment is done via `docker-compose.yml`
 - `pyproject.toml`: Project Setup Config
 
 ## Coding/Implentation Instructions:
-- Always use `alembic` for database structure. Using `Base.create_all()` and similar syntax is PROHIBITED!
-- Use `alembic revision -m <revision explanation>` to create new revisions. Making arbitrary strings as versions etc. is PROHIBITED!
+
 - ALWAYS run `uv run ruff check --fix` after all changes at the end and fix linting issues
 - ALWAYS run `uv run pytest` to run test suite after all changes and fix issues shown by tests.
 - ALWAYS add test cases if relevant.
-- NEVER use emojis! Use icon packs (for example `lucid-react`) if needed. 
 - NEVER commit changes. It is upto user to review your code and commit and push it. Unless user specifically asks for it, commiting code is PROHIBITED!
 
 ## Project Vision

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

@@ -1,14 +1,16 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.6.3
+Version: 0.8.0
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0
 Requires-Dist: crawl4ai>=0.4.0
 Requires-Dist: litellm>=1.83.17
 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.6.3 → regcode-0.8.0}/pyproject.toml

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

{regcode-0.6.3 → 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.6.3 → regcode-0.8.0}/regcode/config.py

@@ -125,6 +125,7 @@ class Config(BaseModel):
     tool_budget: int = 20
     permissions: list[AgentPermission] = [AgentPermission.READ, AgentPermission.EXECUTE]
     toolset_config: ToolSetConfig = ToolSetConfig()
+    debug_mode: bool = False
 
     @classmethod
     def load(cls, path: str | None = None) -> "Config":