Add LRU caching layer for frequently accessed data

Co-authored-by: Mte90 <403283+Mte90@users.noreply.github.com>

Author: Copilot

cache.py

@@ -0,0 +1,129 @@
+"""
+Simple LRU cache implementation for frequently accessed data.
+"""
+import time
+import threading
+from typing import Any, Optional, Dict
+from collections import OrderedDict
+
+
+class LRUCache:
+    """
+    Thread-safe Least Recently Used (LRU) cache with TTL support.
+    """
+    
+    def __init__(self, max_size: int = 100, ttl: Optional[int] = None):
+        """
+        Initialize LRU cache.
+        
+        Args:
+            max_size: Maximum number of items to cache
+            ttl: Time-to-live in seconds (None for no expiration)
+        """
+        self.max_size = max_size
+        self.ttl = ttl
+        self._cache: OrderedDict = OrderedDict()
+        self._timestamps: Dict[str, float] = {}
+        self._lock = threading.Lock()
+        self._hits = 0
+        self._misses = 0
+    
+    def get(self, key: str) -> Optional[Any]:
+        """
+        Get value from cache.
+        
+        Args:
+            key: Cache key
+        
+        Returns:
+            Cached value or None if not found/expired
+        """
+        with self._lock:
+            if key not in self._cache:
+                self._misses += 1
+                return None
+            
+            # Check TTL
+            if self.ttl is not None:
+                timestamp = self._timestamps.get(key, 0)
+                if time.time() - timestamp > self.ttl:
+                    # Expired
+                    del self._cache[key]
+                    del self._timestamps[key]
+                    self._misses += 1
+                    return None
+            
+            # Move to end (most recently used)
+            self._cache.move_to_end(key)
+            self._hits += 1
+            return self._cache[key]
+    
+    def set(self, key: str, value: Any):
+        """
+        Set value in cache.
+        
+        Args:
+            key: Cache key
+            value: Value to cache
+        """
+        with self._lock:
+            if key in self._cache:
+                # Update existing
+                self._cache.move_to_end(key)
+            else:
+                # Add new
+                self._cache[key] = value
+                
+                # Evict oldest if over max_size
+                if len(self._cache) > self.max_size:
+                    oldest_key = next(iter(self._cache))
+                    del self._cache[oldest_key]
+                    if oldest_key in self._timestamps:
+                        del self._timestamps[oldest_key]
+            
+            self._cache[key] = value
+            self._timestamps[key] = time.time()
+    
+    def invalidate(self, key: str):
+        """Remove key from cache."""
+        with self._lock:
+            if key in self._cache:
+                del self._cache[key]
+            if key in self._timestamps:
+                del self._timestamps[key]
+    
+    def clear(self):
+        """Clear all cached items."""
+        with self._lock:
+            self._cache.clear()
+            self._timestamps.clear()
+            self._hits = 0
+            self._misses = 0
+    
+    def stats(self) -> Dict[str, Any]:
+        """Get cache statistics."""
+        with self._lock:
+            total = self._hits + self._misses
+            hit_rate = self._hits / total if total > 0 else 0
+            return {
+                "size": len(self._cache),
+                "max_size": self.max_size,
+                "hits": self._hits,
+                "misses": self._misses,
+                "hit_rate": hit_rate,
+                "ttl": self.ttl
+            }
+
+
+# Global caches for different data types
+# Project metadata cache (small, frequently accessed)
+project_cache = LRUCache(max_size=50, ttl=300)  # 5 minutes TTL
+
+# Project stats cache (small, changes during indexing)
+stats_cache = LRUCache(max_size=100, ttl=60)  # 1 minute TTL
+
+# Search results cache (larger, query results)
+search_cache = LRUCache(max_size=500, ttl=600)  # 10 minutes TTL
+
+# File content cache (medium size, for recently accessed files)
+file_cache = LRUCache(max_size=200, ttl=300)  # 5 minutes TTL

db.py

@@ -8,6 +8,7 @@
 import threading
 import queue
 from logger import get_logger
+from cache import project_cache, stats_cache, file_cache
 
 _LOG = get_logger(__name__)
 
@@ -282,7 +283,14 @@ def get_project_stats(database_path: str) -> Dict[str, Any]:
     """
     Get statistics for a project database.
     Returns file_count and embedding_count.
+    Uses caching with 60s TTL.
     """
+    # Check cache first
+    cache_key = f"stats:{database_path}"
+    cached = stats_cache.get(cache_key)
+    if cached is not None:
+        return cached
+    
     conn = _get_connection(database_path)
     try:
         cur = conn.cursor()
@@ -295,10 +303,14 @@ def get_project_stats(database_path: str) -> Dict[str, Any]:
         cur.execute("SELECT COUNT(*) FROM chunks WHERE embedding IS NOT NULL")
         embedding_count = cur.fetchone()[0]
 
-        return {
+        stats = {
             "file_count": int(file_count),
             "embedding_count": int(embedding_count)
         }
+        
+        # Cache the result
+        stats_cache.set(cache_key, stats)
+        return stats
     finally:
         conn.close()
 
@@ -330,6 +342,7 @@ def clear_project_data(database_path: str) -> None:
     """
     Clear all files and chunks from a project database.
     Used when re-indexing a project.
+    Invalidates caches.
     """
     conn = _get_connection(database_path)
     try:
@@ -339,6 +352,10 @@ def clear_project_data(database_path: str) -> None:
         # Delete files
         cur.execute("DELETE FROM files")
         conn.commit()
+        
+        # Invalidate caches
+        stats_cache.invalidate(f"stats:{database_path}")
+        file_cache.clear()  # Clear all file cache since we deleted everything
     finally:
         conn.close()
 
@@ -628,25 +645,34 @@ def _create():
 
             cur.execute("SELECT * FROM projects WHERE id = ?", (project_id,))
             row = cur.fetchone()
-            return dict(row) if row else None
+            result = dict(row) if row else None
+            # Cache the newly created project
+            if result:
+                project_cache.set(f"project:id:{project_id}", result)
+                project_cache.set(f"project:path:{project_path}", result)
+            return result
         finally:
             conn.close()
 
     try:
         result = _retry_on_db_locked(_create)
-        # Invalidate cache after creating a new project
-        _get_project_by_id_cached.cache_clear()
         return result
     except Exception as e:
         _LOG.error(f"Failed to create project: {e}")
         raise
 
 
 def get_project(project_path: str) -> Optional[Dict[str, Any]]:
-    """Get project metadata by path."""
+    """Get project metadata by path with caching."""
     _init_registry_db()
     project_path = os.path.abspath(project_path)
 
+    # Check cache first
+    cache_key = f"project:path:{project_path}"
+    cached = project_cache.get(cache_key)
+    if cached is not None:
+        return cached
+    
     registry_path = _get_projects_registry_path()
 
     def _get():
@@ -655,43 +681,44 @@ def _get():
             cur = conn.cursor()
             cur.execute("SELECT * FROM projects WHERE path = ?", (project_path,))
             row = cur.fetchone()
-            return dict(row) if row else None
+            result = dict(row) if row else None
+            if result:
+                project_cache.set(cache_key, result)
+            return result
         finally:
             conn.close()
 
     return _retry_on_db_locked(_get)
 
 
-@lru_cache(maxsize=128)
-def _get_project_by_id_cached(project_id: str, registry_path: str) -> Optional[tuple]:
-    """Internal cached function that returns immutable tuple."""
+def get_project_by_id(project_id: str) -> Optional[Dict[str, Any]]:
+    """Get project metadata by ID with caching."""
+    _init_registry_db()
+    
+    # Check cache first
+    cache_key = f"project:id:{project_id}"
+    cached = project_cache.get(cache_key)
+    if cached is not None:
+        return cached
+    
+    registry_path = _get_projects_registry_path()
+    
     def _get():
         conn = _get_connection(registry_path)
         try:
             cur = conn.cursor()
             cur.execute("SELECT * FROM projects WHERE id = ?", (project_id,))
             row = cur.fetchone()
-            if row:
-                # Convert row to tuple of key-value pairs for immutability
-                return tuple(dict(row).items())
-            return None
+            result = dict(row) if row else None
+            if result:
+                project_cache.set(cache_key, result)
+            return result
         finally:
             conn.close()
 
     return _retry_on_db_locked(_get)
 
 
-def get_project_by_id(project_id: str) -> Optional[Dict[str, Any]]:
-    """Get project metadata by ID with caching."""
-    _init_registry_db()
-    
-    registry_path = _get_projects_registry_path()
-    cached_result = _get_project_by_id_cached(project_id, registry_path)
-    
-    # Convert tuple back to dict
-    return dict(cached_result) if cached_result else None
-
-
 def list_projects() -> List[Dict[str, Any]]:
     """List all registered projects."""
     _init_registry_db()
@@ -737,7 +764,7 @@ def _update():
 
     _retry_on_db_locked(_update)
     # Invalidate cache after update
-    _get_project_by_id_cached.cache_clear()
+    project_cache.invalidate(f"project:id:{project_id}")
 
 
 def update_project_settings(project_id: str, settings: Dict[str, Any]):
@@ -761,7 +788,7 @@ def _update():
 
     _retry_on_db_locked(_update)
     # Invalidate cache after update
-    _get_project_by_id_cached.cache_clear()
+    project_cache.invalidate(f"project:id:{project_id}")
 
 
 def delete_project(project_id: str):
@@ -792,7 +819,9 @@ def _delete():
 
     _retry_on_db_locked(_delete)
     # Invalidate cache after deletion
-    _get_project_by_id_cached.cache_clear()
+    project_cache.invalidate(f"project:id:{project_id}")
+    if project.get("path"):
+        project_cache.invalidate(f"project:path:{project['path']}")
 
 
 def get_or_create_project(project_path: str, name: Optional[str] = None) -> Dict[str, Any]: