ripperdoc 0.2.9__py3-none-any.whl → 0.2.10__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
 
 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:
@@ -21,6 +28,198 @@ class FileSnapshot:
     offset: int = 0
     limit: Optional[int] = None
 
+    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
 class ChangedFileNotice:
@@ -30,10 +229,14 @@ class ChangedFileNotice:
     summary: str
 
 
+# Type alias for cache - supports both Dict and BoundedFileCache
+FileCacheType = 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,
@@ -79,7 +282,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] = []