ripperdoc 0.2.9__py3-none-any.whl → 0.3.0__py3-none-any.whl

ripperdoc/utils/conversation_compaction.py

@@ -333,7 +333,7 @@ async def summarize_conversation(
         system_prompt=system_prompt,
         tools=[],
         max_thinking_tokens=0,
-        model="main",
+        model="quick",
     )
 
     result = extract_assistant_text(assistant_response)

ripperdoc/utils/file_watch.py

@@ -4,13 +4,20 @@ from __future__ import annotations
 
 import difflib
 import os
+import sys
+import threading
+from collections import OrderedDict
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Dict, Iterator, List, Optional, Tuple, Union
 
 from ripperdoc.utils.log import get_logger
 
 logger = get_logger()
 
+# Default limits for BoundedFileCache
+DEFAULT_MAX_ENTRIES = int(os.getenv("RIPPERDOC_FILE_CACHE_MAX_ENTRIES", "500"))
+DEFAULT_MAX_MEMORY_MB = float(os.getenv("RIPPERDOC_FILE_CACHE_MAX_MEMORY_MB", "50"))
+
 
 @dataclass
 class FileSnapshot:
@@ -20,6 +27,199 @@ class FileSnapshot:
     timestamp: float
     offset: int = 0
     limit: Optional[int] = None
+    encoding: str = "utf-8"
+
+    def memory_size(self) -> int:
+        """Estimate memory usage of this snapshot in bytes."""
+        # String memory: roughly 1 byte per char for ASCII, more for unicode
+        # Plus object overhead (~50 bytes for dataclass)
+        return sys.getsizeof(self.content) + 50
+
+
+class BoundedFileCache:
+    """Thread-safe LRU cache for FileSnapshots with memory and entry limits.
+
+    This cache prevents unbounded memory growth in long sessions by:
+    1. Limiting the maximum number of entries (LRU eviction)
+    2. Limiting total memory usage
+    3. Providing thread-safe access
+
+    Usage:
+        cache = BoundedFileCache(max_entries=500, max_memory_mb=50)
+        cache["/path/to/file"] = FileSnapshot(content="...", timestamp=123.0)
+        snapshot = cache.get("/path/to/file")
+    """
+
+    def __init__(
+        self,
+        max_entries: int = DEFAULT_MAX_ENTRIES,
+        max_memory_mb: float = DEFAULT_MAX_MEMORY_MB,
+    ) -> None:
+        """Initialize the bounded cache.
+
+        Args:
+            max_entries: Maximum number of file snapshots to keep
+            max_memory_mb: Maximum total memory usage in megabytes
+        """
+        self._max_entries = max(1, max_entries)
+        self._max_memory_bytes = int(max_memory_mb * 1024 * 1024)
+        self._cache: OrderedDict[str, FileSnapshot] = OrderedDict()
+        self._current_memory = 0
+        self._lock = threading.RLock()
+        self._eviction_count = 0
+
+    @property
+    def max_entries(self) -> int:
+        """Maximum number of entries allowed."""
+        return self._max_entries
+
+    @property
+    def max_memory_bytes(self) -> int:
+        """Maximum memory in bytes."""
+        return self._max_memory_bytes
+
+    @property
+    def current_memory(self) -> int:
+        """Current estimated memory usage in bytes."""
+        with self._lock:
+            return self._current_memory
+
+    @property
+    def eviction_count(self) -> int:
+        """Number of entries evicted due to limits."""
+        with self._lock:
+            return self._eviction_count
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._cache)
+
+    def __contains__(self, key: str) -> bool:
+        with self._lock:
+            return key in self._cache
+
+    def __getitem__(self, key: str) -> FileSnapshot:
+        with self._lock:
+            if key not in self._cache:
+                raise KeyError(key)
+            # Move to end (most recently used)
+            self._cache.move_to_end(key)
+            return self._cache[key]
+
+    def __setitem__(self, key: str, value: FileSnapshot) -> None:
+        with self._lock:
+            new_size = value.memory_size()
+
+            # If key exists, remove old entry first (atomic pop to avoid TOCTOU)
+            old_value = self._cache.pop(key, None)
+            if old_value is not None:
+                self._current_memory = max(0, self._current_memory - old_value.memory_size())
+
+            # Evict entries if needed (memory limit)
+            while self._current_memory + new_size > self._max_memory_bytes and self._cache:
+                self._evict_oldest()
+
+            # Evict entries if needed (entry limit)
+            while len(self._cache) >= self._max_entries:
+                self._evict_oldest()
+
+            # Add new entry
+            self._cache[key] = value
+            self._current_memory += new_size
+
+    def __delitem__(self, key: str) -> None:
+        with self._lock:
+            # Use atomic pop to avoid TOCTOU between check and delete
+            old_value = self._cache.pop(key, None)
+            if old_value is not None:
+                self._current_memory = max(0, self._current_memory - old_value.memory_size())
+
+    def _evict_oldest(self) -> None:
+        """Evict the least recently used entry. Must be called with lock held."""
+        if self._cache:
+            oldest_key, oldest_value = self._cache.popitem(last=False)
+            self._current_memory = max(0, self._current_memory - oldest_value.memory_size())
+            self._eviction_count += 1
+            logger.debug(
+                "[file_cache] Evicted entry due to cache limits",
+                extra={"evicted_path": oldest_key, "total_evictions": self._eviction_count},
+            )
+
+    def get(self, key: str, default: Optional[FileSnapshot] = None) -> Optional[FileSnapshot]:
+        """Get a snapshot, returning default if not found."""
+        with self._lock:
+            if key not in self._cache:
+                return default
+            self._cache.move_to_end(key)
+            return self._cache[key]
+
+    def pop(self, key: str, default: Optional[FileSnapshot] = None) -> Optional[FileSnapshot]:
+        """Remove and return a snapshot."""
+        with self._lock:
+            if key not in self._cache:
+                return default
+            value = self._cache.pop(key)
+            self._current_memory = max(0, self._current_memory - value.memory_size())
+            return value
+
+    def setdefault(self, key: str, default: FileSnapshot) -> FileSnapshot:
+        """Atomically get or set a snapshot.
+
+        If key exists, return its value (and mark as recently used).
+        If key doesn't exist, set it to default and return default.
+        This provides a thread-safe get-or-create operation.
+        """
+        with self._lock:
+            if key in self._cache:
+                self._cache.move_to_end(key)
+                return self._cache[key]
+            # Key doesn't exist - add it
+            new_size = default.memory_size()
+            # Evict if needed
+            while self._current_memory + new_size > self._max_memory_bytes and self._cache:
+                self._evict_oldest()
+            while len(self._cache) >= self._max_entries:
+                self._evict_oldest()
+            self._cache[key] = default
+            self._current_memory += new_size
+            return default
+
+    def clear(self) -> None:
+        """Remove all entries from the cache."""
+        with self._lock:
+            self._cache.clear()
+            self._current_memory = 0
+
+    def keys(self) -> List[str]:
+        """Return list of cached file paths."""
+        with self._lock:
+            return list(self._cache.keys())
+
+    def values(self) -> List[FileSnapshot]:
+        """Return list of cached snapshots."""
+        with self._lock:
+            return list(self._cache.values())
+
+    def items(self) -> List[Tuple[str, FileSnapshot]]:
+        """Return list of (path, snapshot) pairs."""
+        with self._lock:
+            return list(self._cache.items())
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over keys (not thread-safe for modifications during iteration)."""
+        with self._lock:
+            return iter(list(self._cache.keys()))
+
+    def stats(self) -> Dict[str, int]:
+        """Return cache statistics."""
+        with self._lock:
+            return {
+                "entries": len(self._cache),
+                "max_entries": self._max_entries,
+                "memory_bytes": self._current_memory,
+                "max_memory_bytes": self._max_memory_bytes,
+                "eviction_count": self._eviction_count,
+            }
 
 
 @dataclass
@@ -30,13 +230,18 @@ class ChangedFileNotice:
     summary: str
 
 
+# Type alias for cache - supports both Dict and BoundedFileCache
+FileCacheType = Union[Dict[str, FileSnapshot], BoundedFileCache]
+
+
 def record_snapshot(
     file_path: str,
     content: str,
-    cache: Dict[str, FileSnapshot],
+    cache: FileCacheType,
     *,
     offset: int = 0,
     limit: Optional[int] = None,
+    encoding: str = "utf-8",
 ) -> None:
     """Store the current contents and mtime for a file."""
     try:
@@ -44,12 +249,14 @@ def record_snapshot(
     except OSError:
         timestamp = 0.0
     cache[file_path] = FileSnapshot(
-        content=content, timestamp=timestamp, offset=offset, limit=limit
+        content=content, timestamp=timestamp, offset=offset, limit=limit, encoding=encoding
     )
 
 
-def _read_portion(file_path: str, offset: int, limit: Optional[int]) -> str:
-    with open(file_path, "r", encoding="utf-8", errors="replace") as handle:
+def _read_portion(
+    file_path: str, offset: int, limit: Optional[int], encoding: str = "utf-8"
+) -> str:
+    with open(file_path, "r", encoding=encoding, errors="replace") as handle:
         lines = handle.readlines()
     start = max(offset, 0)
     if limit is None:
@@ -79,7 +286,7 @@ def _build_diff_summary(old_content: str, new_content: str, file_path: str, max_
 
 
 def detect_changed_files(
-    cache: Dict[str, FileSnapshot], *, max_diff_lines: int = 80
+    cache: FileCacheType, *, max_diff_lines: int = 80
 ) -> List[ChangedFileNotice]:
     """Return notices for files whose mtime increased since they were read."""
     notices: List[ChangedFileNotice] = []
@@ -101,7 +308,9 @@ def detect_changed_files(
             continue
 
         try:
-            new_content = _read_portion(file_path, snapshot.offset, snapshot.limit)
+            new_content = _read_portion(
+                file_path, snapshot.offset, snapshot.limit, snapshot.encoding
+            )
         except (
             OSError,
             IOError,

ripperdoc/utils/image_utils.py

@@ -0,0 +1,125 @@
+"""Image processing utilities for Ripperdoc."""
+
+import base64
+import mimetypes
+from pathlib import Path
+from typing import Optional, Tuple
+
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+# Supported image formats
+SUPPORTED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"}
+SUPPORTED_IMAGE_MIME_TYPES = {"image/jpeg", "image/png", "image/gif", "image/webp", "image/bmp"}
+
+MAX_IMAGE_SIZE_BYTES = 32 * 1024 * 1024  # 32MB
+
+
+def is_image_file(file_path: Path) -> bool:
+    """Check if a file is a supported image format.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        True if the file has a supported image extension
+    """
+    return file_path.suffix.lower() in SUPPORTED_IMAGE_EXTENSIONS
+
+
+def detect_mime_type(file_path: Path) -> str:
+    """Detect the MIME type of an image file.
+
+    Args:
+        file_path: Path to the image file
+
+    Returns:
+        MIME type string (e.g., "image/jpeg", "image/png")
+    """
+    mime_type, _ = mimetypes.guess_type(file_path)
+    if mime_type in SUPPORTED_IMAGE_MIME_TYPES:
+        return mime_type
+
+    # Fallback to extension-based detection
+    ext = file_path.suffix.lower()
+    if ext in {".jpg", ".jpeg"}:
+        return "image/jpeg"
+    if ext == ".png":
+        return "image/png"
+    if ext == ".gif":
+        return "image/gif"
+    if ext == ".webp":
+        return "image/webp"
+    if ext == ".bmp":
+        return "image/bmp"
+    return "image/jpeg"  # Default fallback
+
+
+def read_image_as_base64(file_path: Path) -> Optional[Tuple[str, str]]:
+    """Read an image file and return its base64-encoded data and MIME type.
+
+    Args:
+        file_path: Absolute path to the image file
+
+    Returns:
+        (base64_data, mime_type) tuple or None if reading fails
+    """
+    if not file_path.exists():
+        logger.warning(
+            "[image_utils] Image file not found",
+            extra={"path": str(file_path)},
+        )
+        return None
+
+    if not file_path.is_file():
+        logger.warning(
+            "[image_utils] Not a file",
+            extra={"path": str(file_path)},
+        )
+        return None
+
+    # Check file size
+    file_size = file_path.stat().st_size
+    if file_size > MAX_IMAGE_SIZE_BYTES:
+        logger.warning(
+            "[image_utils] Image too large",
+            extra={
+                "path": str(file_path),
+                "size_bytes": file_size,
+                "max_bytes": MAX_IMAGE_SIZE_BYTES,
+            },
+        )
+        return None
+
+    if not is_image_file(file_path):
+        logger.warning(
+            "[image_utils] Not a supported image format",
+            extra={"path": str(file_path)},
+        )
+        return None
+
+    try:
+        with open(file_path, "rb") as f:
+            image_bytes = f.read()
+
+        base64_data = base64.b64encode(image_bytes).decode("utf-8")
+        mime_type = detect_mime_type(file_path)
+
+        logger.debug(
+            "[image_utils] Loaded image",
+            extra={
+                "path": str(file_path),
+                "size_bytes": len(image_bytes),
+                "mime_type": mime_type,
+            },
+        )
+
+        return (base64_data, mime_type)
+
+    except (OSError, IOError) as e:
+        logger.error(
+            "[image_utils] Failed to read image",
+            extra={"path": str(file_path), "error": str(e)},
+        )
+        return None

ripperdoc/utils/log.py

@@ -4,13 +4,40 @@ import json
 import logging
 import sys
 import os
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Optional
 
 from ripperdoc.utils.path_utils import sanitize_project_path
 
 
+class SpinnerSafeStreamHandler(logging.StreamHandler):
+    """StreamHandler that clears the current line before ERROR/WARNING messages.
+
+    This prevents log messages from appearing after a spinner's text,
+    which would cause formatting issues.
+    """
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Emit a log record, clearing the line first for ERROR/WARNING."""
+        try:
+            msg = self.format(record)
+            stream = self.stream
+
+            # Clear the current line before ERROR/WARNING to avoid spinner interference
+            if record.levelno >= logging.ERROR:
+                # Use \r to return to start, then clear with spaces, then \r again
+                stream.write("\r" + " " * 100 + "\r")
+            elif record.levelno >= logging.WARNING:
+                # Also clear for WARNING
+                stream.write("\r" + " " * 100 + "\r")
+
+            stream.write(msg + self.terminator)
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+
 _LOG_RECORD_FIELDS = {
     "name",
     "msg",
@@ -42,7 +69,7 @@ class StructuredFormatter(logging.Formatter):
     """Formatter with ISO timestamps and context."""
 
     def formatTime(self, record: logging.LogRecord, datefmt: Optional[str] = None) -> str:
-        timestamp = datetime.utcfromtimestamp(record.created)
+        timestamp = datetime.fromtimestamp(record.created, tz=timezone.utc)
         return timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
 
     def format(self, record: logging.LogRecord) -> str:
@@ -74,7 +101,7 @@ class RipperdocLogger:
 
         # Avoid adding duplicate handlers if an existing logger is reused.
         if not self.logger.handlers:
-            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler = SpinnerSafeStreamHandler(sys.stderr)
             console_handler.setLevel(level)
             console_formatter = logging.Formatter("%(levelname)s: %(message)s")
             console_handler.setFormatter(console_formatter)