copilot suggestions

Author: qchapp

src/ai_agent/agent/tools/repo_info_tool.py

@@ -84,7 +84,7 @@ async def tool_repo_summary(input: RepoSummaryInput) -> RepoSummaryOutput:
 
     await _REPO_INFO_LOCK.acquire()
     try:
-        raw = db.get(_REPO_INFO_NS, cache_key)
+        raw = await asyncio.to_thread(db.get, _REPO_INFO_NS, cache_key)
         if raw is not None:
             cached = RepoSummaryOutput.model_validate_json(raw)
             log.info(f"Repo info cache hit for {effective_url}")
@@ -120,7 +120,8 @@ async def tool_repo_summary(input: RepoSummaryInput) -> RepoSummaryOutput:
     await _REPO_INFO_LOCK.acquire()
     try:
         if result.source != "error" and REPO_INFO_CACHE_TTL_SECONDS > 0:
-            db.set(
+            await asyncio.to_thread(
+                db.set,
                 _REPO_INFO_NS,
                 cache_key,
                 result.model_dump_json(),

src/ai_agent/utils/cache_db.py

@@ -76,8 +76,15 @@ def __init__(self, db_path: str | Path | None = None) -> None:
     # Public API
     # ------------------------------------------------------------------
 
-    def get(self, namespace: str, key: str) -> Optional[str]:
-        """Return the cached value or *None* if missing / expired."""
+    def get(
+        self, namespace: str, key: str, *, track_lru: bool = True
+    ) -> Optional[str]:
+        """Return the cached value or *None* if missing / expired.
+
+        *track_lru* (default ``True``) updates *accessed_at* on a hit so that
+        LRU eviction in :meth:`set` works correctly.  Pass ``False`` when the
+        namespace has no capacity limit and you want to avoid the extra write.
+        """
         now = time.time()
         with self._lock:
             row = self._conn.execute(
@@ -95,12 +102,13 @@ def get(self, namespace: str, key: str) -> Optional[str]:
                 )
                 self._conn.commit()
                 return None
-            # Touch for LRU tracking
-            self._conn.execute(
-                "UPDATE cache SET accessed_at = ? WHERE namespace = ? AND key = ?",
-                (now, namespace, key),
-            )
-            self._conn.commit()
+            if track_lru:
+                # Touch accessed_at so LRU eviction in set() stays accurate.
+                self._conn.execute(
+                    "UPDATE cache SET accessed_at = ? WHERE namespace = ? AND key = ?",
+                    (now, namespace, key),
+                )
+                self._conn.commit()
             return value
 
     def set(
@@ -179,6 +187,36 @@ def clear(self, namespace: Optional[str] = None) -> None:
                 self._conn.execute("DELETE FROM cache")
             self._conn.commit()
 
+    def sweep_expired(self) -> int:
+        """Delete all expired rows across every namespace.
+
+        Returns the number of rows removed.  Designed to be called from a
+        background thread or an atexit hook without touching private state.
+        """
+        now = time.time()
+        with self._lock:
+            deleted = self._conn.execute(
+                "DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at <= ?",
+                (now,),
+            ).rowcount
+            self._conn.commit()
+        return deleted
+
+    def vacuum_and_close(self) -> None:
+        """Sweep expired rows, VACUUM the database, then close the connection.
+
+        VACUUM must run outside any open transaction; this method handles the
+        ``isolation_level`` toggling safely with a ``finally`` guard.
+        """
+        self.sweep_expired()
+        with self._lock:
+            try:
+                self._conn.isolation_level = None
+                self._conn.execute("VACUUM")
+            finally:
+                self._conn.isolation_level = ""
+        self.close()
+
     def close(self) -> None:
         """Close the underlying database connection."""
         try:
@@ -206,6 +244,16 @@ def get_cache_db() -> CacheDB:
     return _db
 
 
+def get_cache_db_or_none() -> Optional[CacheDB]:
+    """Return the singleton if it has already been initialised, else ``None``.
+
+    Unlike :func:`get_cache_db` this never creates the database — useful for
+    background housekeeping that should be a no-op before the first real cache
+    access.
+    """
+    return _db
+
+
 def reset_cache_db(db: Optional[CacheDB] = None) -> None:
     """Replace the singleton — mainly useful for tests.
 

src/ai_agent/utils/shutdown.py

@@ -39,18 +39,13 @@
 
 def _sweep_cache_db() -> None:
     """Delete expired rows from the cache DB (lightweight, runs periodically)."""
-    from ai_agent.utils.cache_db import _db  # noqa: PLC0415
+    from ai_agent.utils.cache_db import get_cache_db_or_none  # noqa: PLC0415
 
-    if _db is None:
+    db = get_cache_db_or_none()
+    if db is None:
         return
     try:
-        now = time.time()
-        with _db._lock:
-            deleted = _db._conn.execute(
-                "DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at <= ?",
-                (now,),
-            ).rowcount
-            _db._conn.commit()
+        deleted = db.sweep_expired()
         if deleted:
             log.debug("Cache sweep: removed %d expired row(s).", deleted)
     except Exception:
@@ -59,23 +54,14 @@ def _sweep_cache_db() -> None:
 
 def _vacuum_and_close_cache_db() -> None:
     """Final shutdown: VACUUM and close the cache DB (runs via atexit)."""
-    from ai_agent.utils.cache_db import _db, get_cache_db  # noqa: PLC0415
+    from ai_agent.utils.cache_db import get_cache_db_or_none  # noqa: PLC0415
 
-    if _db is None:
+    db = get_cache_db_or_none()
+    if db is None:
         return
     try:
-        db = get_cache_db()
-        _sweep_cache_db()
-        with db._lock:
-            # VACUUM must run outside any transaction.
-            previous_isolation_level = db._conn.isolation_level
-            try:
-                db._conn.isolation_level = None
-                db._conn.execute("VACUUM")
-            finally:
-                db._conn.isolation_level = previous_isolation_level
+        db.vacuum_and_close()
         log.info("Cache DB shutdown: VACUUM complete.")
-        db.close()
     except Exception:
         log.exception("Cache DB shutdown cleanup failed.")