ripperdoc 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

ripperdoc/tools/todo_tool.py

@@ -309,7 +309,7 @@ class TodoWriteTool(Tool[TodoWriteToolInput, TodoToolOutput]):
             ),
         ]
 
-    async def prompt(self, _safe_mode: bool = False) -> str:
+    async def prompt(self, _yolo_mode: bool = False) -> str:
         return TODO_WRITE_PROMPT
 
     def is_read_only(self) -> bool:
@@ -403,7 +403,7 @@ class TodoReadTool(Tool[TodoReadToolInput, TodoToolOutput]):
             ),
         ]
 
-    async def prompt(self, _safe_mode: bool = False) -> str:
+    async def prompt(self, _yolo_mode: bool = False) -> str:
         return (
             "Use TodoRead to fetch the current todo list before making progress or when you need "
             "to confirm the next action. You can request only the next actionable item or filter "

ripperdoc/tools/tool_search_tool.py

@@ -106,7 +106,7 @@ class ToolSearchTool(Tool[ToolSearchInput, ToolSearchOutput]):
             ),
         ]
 
-    async def prompt(self, safe_mode: bool = False) -> str:  # noqa: ARG002
+    async def prompt(self, yolo_mode: bool = False) -> str:  # noqa: ARG002
         return (
             "Search for a tool by providing a short description (e.g., 'query database', 'render notebook'). "
             "Use names to activate tools you've already discovered. "
@@ -193,7 +193,8 @@ class ToolSearchTool(Tool[ToolSearchInput, ToolSearchOutput]):
                 description = ""
                 logger.warning(
                     "[tool_search] Failed to build tool description: %s: %s",
-                    type(exc).__name__, exc,
+                    type(exc).__name__,
+                    exc,
                     extra={"tool_name": getattr(tool, "name", None)},
                 )
             doc_text = " ".join([name, tool.user_facing_name(), description])

ripperdoc/utils/conversation_compaction.py

@@ -34,6 +34,7 @@ RECENT_MESSAGES_AFTER_COMPACT = 8
 # Summary Prompt Generation
 # ─────────────────────────────────────────────────────────────────────────────
 
+
 def generate_summary_prompt(additional_instructions: Optional[str] = None) -> str:
     """Generate the system prompt for conversation summarization.
 
@@ -203,9 +204,11 @@ Please continue the conversation from where we left it off without asking the us
 # Data Classes
 # ─────────────────────────────────────────────────────────────────────────────
 
+
 @dataclass
 class CompactionResult:
     """Result of a conversation compaction operation."""
+
     messages: List[ConversationMessage]
     summary_text: str
     continuation_prompt: str
@@ -219,6 +222,7 @@ class CompactionResult:
 @dataclass
 class CompactionError:
     """Error during compaction."""
+
     error_type: str  # "not_enough_messages", "empty_summary", "exception"
     message: str
     exception: Optional[Exception] = None
@@ -329,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)
@@ -373,16 +377,15 @@ async def compact_conversation(
     messages_for_summary = micro.messages
 
     # Summarize the conversation
-    
+
     non_progress_messages = [
         m for m in messages_for_summary if getattr(m, "type", "") != "progress"
     ]
     try:
-        summary_text = await summarize_conversation(
-            non_progress_messages, custom_instructions
-        )
+        summary_text = await summarize_conversation(non_progress_messages, custom_instructions)
     except Exception as exc:
         import traceback
+
         logger.warning(
             "[compaction] Error during compaction: %s: %s\n%s",
             type(exc).__name__,
@@ -443,6 +446,7 @@ class ConversationCompactor:
     Deprecated: Use compact_conversation() function directly instead.
     This class is kept for backward compatibility.
     """
+
     # Keep CompactionResult as a nested class for backward compatibility
     CompactionResult = CompactionResult
 

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] = []
@@ -102,10 +305,16 @@ def detect_changed_files(
 
         try:
             new_content = _read_portion(file_path, snapshot.offset, snapshot.limit)
-        except (OSError, IOError, UnicodeDecodeError, ValueError) as exc:  # pragma: no cover - best-effort telemetry
+        except (
+            OSError,
+            IOError,
+            UnicodeDecodeError,
+            ValueError,
+        ) as exc:  # pragma: no cover - best-effort telemetry
             logger.warning(
                 "[file_watch] Failed reading changed file: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"file_path": file_path},
             )
             notices.append(

ripperdoc/utils/json_utils.py

@@ -21,7 +21,8 @@ def safe_parse_json(json_text: Optional[str], log_error: bool = True) -> Optiona
         if log_error:
             logger.debug(
                 "[json_utils] Failed to parse JSON: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"length": len(json_text)},
             )
         return None