crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/cache.py

@@ -1,276 +1,193 @@
+import asyncio
 import hashlib
-import json
-import time
-import typing as t
-from dataclasses import asdict, dataclass, field
+import logging
+from collections.abc import Awaitable
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Any
 
-from crackerjack.models.task import HookResult
-
-
-@dataclass
-class CacheEntry:
-    key: str
-    value: t.Any
-    created_at: float = field(default_factory=time.time)
-    accessed_at: float = field(default_factory=time.time)
-    ttl_seconds: int = 3600
-    access_count: int = 0
+from acb.adapters import AdapterNotInstalled, import_adapter
+from acb.depends import depends
 
-    @property
-    def is_expired(self) -> bool:
-        return (time.time() - self.created_at) > self.ttl_seconds
-
-    @property
-    def age_seconds(self) -> int:
-        return int(time.time() - self.created_at)
+from crackerjack.models.task import HookResult
 
-    def touch(self) -> None:
-        self.accessed_at = time.time()
-        self.access_count += 1
+logger = logging.getLogger(__name__)
 
-    def to_dict(self) -> dict[str, t.Any]:
-        return asdict(self)
+Cache: Any | None = None
+_cache_import_error: Exception | None = None
 
-    @classmethod
-    def from_dict(cls, data: dict[str, t.Any]) -> "CacheEntry":
-        return cls(**data)
+if import_adapter is not None:
+    try:
+        Cache = import_adapter("cache")
+    except AdapterNotInstalled as e:  # pragma: no cover - depends on env
+        _cache_import_error = e
+        Cache = None
+    except Exception as e:  # pragma: no cover - defensive
+        _cache_import_error = e
+        Cache = None
 
 
 @dataclass
 class CacheStats:
+    """Cache statistics compatible with legacy cache implementation."""
+
     hits: int = 0
     misses: int = 0
     evictions: int = 0
     total_entries: int = 0
-    total_size_bytes: int = 0
 
     @property
     def hit_rate(self) -> float:
-        total = self.hits + self.misses
-        return (self.hits / total * 100) if total > 0 else 0.0
+        total_requests = self.hits + self.misses
+        return (self.hits / total_requests * 100) if total_requests else 0.0
 
-    def to_dict(self) -> dict[str, t.Any]:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "hits": self.hits,
             "misses": self.misses,
             "evictions": self.evictions,
             "total_entries": self.total_entries,
             "hit_rate_percent": round(self.hit_rate, 2),
-            "total_size_mb": round(self.total_size_bytes / 1024 / 1024, 2),
         }
 
 
-class InMemoryCache:
-    def __init__(self, max_entries: int = 1000, default_ttl: int = 3600) -> None:
-        self.max_entries = max_entries
-        self.default_ttl = default_ttl
-        self._cache: dict[str, CacheEntry] = {}
-        self.stats = CacheStats()
-
-    def get(self, key: str) -> t.Any | None:
-        entry = self._cache.get(key)
-
-        if entry is None:
-            self.stats.misses += 1
-            return None
-
-        if entry.is_expired:
-            del self._cache[key]
-            self.stats.misses += 1
-            self.stats.evictions += 1
-            return None
-
-        entry.touch()
-        self.stats.hits += 1
-        return entry.value
-
-    def set(self, key: str, value: t.Any, ttl_seconds: int | None = None) -> None:
-        if ttl_seconds is None:
-            ttl_seconds = self.default_ttl
-
-        if len(self._cache) >= self.max_entries:
-            self._evict_lru()
-
-        self._cache[key] = CacheEntry(
-            key=key,
-            value=value,
-            ttl_seconds=ttl_seconds,
+def get_cache() -> Any:
+    """Return the configured cache backend from ACB."""
+    if Cache is None or depends is None:
+        reason = (
+            f"{type(_cache_import_error).__name__}: {_cache_import_error}"
+            if _cache_import_error is not None
+            else "cache adapter import failed"
         )
-
-        self.stats.total_entries = len(self._cache)
-
-    def invalidate(self, key: str) -> bool:
-        if key in self._cache:
-            del self._cache[key]
-            self.stats.total_entries = len(self._cache)
-            return True
-        return False
-
-    def clear(self) -> None:
-        evicted = len(self._cache)
-        self._cache.clear()
-        self.stats.evictions += evicted
-        self.stats.total_entries = 0
-
-    def cleanup_expired(self) -> int:
-        expired_keys = [key for key, entry in self._cache.items() if entry.is_expired]
-
-        for key in expired_keys:
-            del self._cache[key]
-
-        self.stats.evictions += len(expired_keys)
-        self.stats.total_entries = len(self._cache)
-        return len(expired_keys)
-
-    def _evict_lru(self) -> None:
-        if not self._cache:
-            return
-
-        lru_key = min(self._cache.keys(), key=lambda k: self._cache[k].accessed_at)
-
-        del self._cache[lru_key]
-        self.stats.evictions += 1
-
-
-class FileCache:
-    def __init__(self, cache_dir: Path, namespace: str = "crackerjack") -> None:
-        self.cache_dir = cache_dir / namespace
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self.stats = CacheStats()
-
-    def get(self, key: str) -> t.Any | None:
-        cache_file = self._get_cache_file(key)
-
-        if not cache_file.exists():
-            self.stats.misses += 1
-            return None
-
-        try:
-            with cache_file.open(encoding="utf-8") as f:
-                data = json.load(f)
-                entry = CacheEntry.from_dict(data)
-
-            if entry.is_expired:
-                cache_file.unlink(missing_ok=True)
-                self.stats.misses += 1
-                self.stats.evictions += 1
-                return None
-
-            entry.touch()
-
-            with cache_file.open("w", encoding="utf-8") as f:
-                json.dump(entry.to_dict(), f)
-
-            self.stats.hits += 1
-            return entry.value
-
-        except (json.JSONDecodeError, FileNotFoundError, OSError, KeyError):
-            self.stats.misses += 1
-            cache_file.unlink(missing_ok=True)
-            return None
-
-    def set(self, key: str, value: t.Any, ttl_seconds: int = 3600) -> None:
-        cache_file = self._get_cache_file(key)
-
-        entry = CacheEntry(
-            key=key,
-            value=value,
-            ttl_seconds=ttl_seconds,
+        msg = (
+            "ACB cache adapter is unavailable. "
+            f"Resolve adapter configuration before continuing ({reason})."
         )
-
-        try:
-            with cache_file.open("w", encoding="utf-8") as f:
-                json.dump(entry.to_dict(), f)
-        except (json.JSONDecodeError, OSError, KeyError):
-            pass
-
-    def invalidate(self, key: str) -> bool:
-        cache_file = self._get_cache_file(key)
-        if cache_file.exists():
-            cache_file.unlink()
-            return True
-        return False
-
-    def clear(self) -> None:
-        for cache_file in self.cache_dir.glob("*.cache"):
-            cache_file.unlink(missing_ok=True)
-
-    def cleanup_expired(self) -> int:
-        removed = 0
-        for cache_file in self.cache_dir.glob("*.cache"):
-            try:
-                with cache_file.open(encoding="utf-8") as f:
-                    data = json.load(f)
-                    entry = CacheEntry.from_dict(data)
-
-                if entry.is_expired:
-                    cache_file.unlink()
-                    removed += 1
-            except (json.JSONDecodeError, FileNotFoundError, OSError, KeyError):
-                cache_file.unlink(missing_ok=True)
-                removed += 1
-
-        self.stats.evictions += removed
-        return removed
-
-    def _get_cache_file(self, key: str) -> Path:
-        safe_key = hashlib.md5(key.encode(), usedforsecurity=False).hexdigest()
-        return self.cache_dir / f"{safe_key}.cache"
+        raise RuntimeError(msg)
+    try:
+        return depends.get_sync(Cache)
+    except Exception as exception:  # pragma: no cover - runtime safety
+        # Check if the error is specifically about the adapter not being found
+        error_msg = str(exception).lower()
+        if "adapter" in error_msg and "not found" in error_msg and "cache" in error_msg:
+            # Instead of raising an error, return None to trigger fallback behavior
+            import logging
+
+            logging.getLogger(__name__).warning(
+                "ACB cache adapter not found or not installed, using fallback behavior"
+            )
+            return None
+        else:
+            msg = (
+                "Failed to resolve ACB cache adapter via dependency injection. "
+                "Ensure adapters.yml specifies a valid cache adapter."
+            )
+            raise RuntimeError(msg) from exception
 
 
 class CrackerjackCache:
-    # Expensive hooks that benefit from disk caching across sessions
+    """ACB-backed cache adapter with in-memory fallback when adapter missing."""
+
     EXPENSIVE_HOOKS = {
-        "pyright",
-        "bandit",
-        "vulture",
-        "complexipy",
-        "refurb",
-        "gitleaks",
-        "detect-secrets",
+        # Type checking and analysis
+        "pyright",  # Legacy, keep for backward compatibility
+        "zuban",  # Fast Rust-based type checking
+        "skylos",  # Rust-based dead code detection
+        # Security and vulnerability scanning
+        "bandit",  # Python security linter
+        "gitleaks",  # Secret scanning
+        "semgrep",  # SAST scanning
+        "pyscn",  # Security scanning
+        "pip-audit",  # Dependency vulnerability scanning
+        # Code quality and complexity
+        "vulture",  # Dead code detection (Python)
+        "complexipy",  # Complexity analysis
+        "refurb",  # Python code modernization
+        # Schema and data validation
+        "check-jsonschema",  # JSON schema validation (8466+ files)
+        # Text and formatting
+        "codespell",  # Spell checking across entire codebase
+        "ruff-check",  # Comprehensive Python linting
+        "mdformat",  # Markdown formatting
     }
 
-    # TTL configuration for different cache types (in seconds)
     HOOK_DISK_TTLS = {
-        "pyright": 86400,  # 24 hours - type checking is stable
-        "bandit": 86400 * 3,  # 3 days - security patterns change slowly
-        "vulture": 86400 * 2,  # 2 days - dead code detection is stable
-        "complexipy": 86400,  # 24 hours - complexity analysis
-        "refurb": 86400,  # 24 hours - code improvements
-        "gitleaks": 86400 * 7,  # 7 days - secret detection is very stable
-        "detect-secrets": 86400 * 7,  # 7 days - secret detection
+        # Type checking - daily updates as code changes
+        "pyright": 86400,  # 1 day
+        "zuban": 86400,  # 1 day
+        "skylos": 86400 * 2,  # 2 days - dead code analysis less volatile
+        # Security - longer TTLs, check periodically for new vulnerabilities
+        "bandit": 86400 * 3,  # 3 days
+        "gitleaks": 86400 * 7,  # 7 days - secrets rarely change once clean
+        "semgrep": 86400 * 3,  # 3 days - security rules change occasionally
+        "pyscn": 86400 * 3,  # 3 days
+        "pip-audit": 86400,  # 1 day - check daily for new CVEs
+        # Code quality
+        "vulture": 86400 * 2,  # 2 days
+        "complexipy": 86400,  # 1 day
+        "refurb": 86400,  # 1 day
+        # Validation and formatting - longest TTLs
+        "check-jsonschema": 86400 * 7,  # 7 days - schemas rarely change
+        "codespell": 86400 * 7,  # 7 days - spelling errors are rare
+        "ruff-check": 86400,  # 1 day - linting rules can change
+        "mdformat": 86400 * 7,  # 7 days - markdown style rarely changes
     }
 
-    # Agent version for cache invalidation when agent logic changes
     AGENT_VERSION = "1.0.0"
 
     def __init__(
         self,
         cache_dir: Path | None = None,
         enable_disk_cache: bool = True,
+        backend: Any | None = None,
     ) -> None:
-        if cache_dir:
-            self.cache_dir = cache_dir
-        else:
-            self.cache_dir = Path.cwd() / ".crackerjack" / "cache"
-
+        self.cache_dir = cache_dir or Path.cwd() / ".crackerjack" / "cache"
         self.enable_disk_cache = enable_disk_cache
+        self.stats = CacheStats()
+
+        if backend is not None:
+            self._backend = backend
+        else:
+            # Try to get ACB cache adapter, fallback to None if unavailable
+            try:
+                self._backend = get_cache()
+            except RuntimeError:
+                # ACB cache adapter not available - use in-memory fallback
+                logger.info("ACB cache adapter unavailable, using in-memory cache")
+                self._backend = None
 
-        self.hook_results_cache = InMemoryCache(max_entries=500, default_ttl=1800)
-        self.file_hash_cache = InMemoryCache(max_entries=2000)
-        self.config_cache = InMemoryCache(max_entries=100, default_ttl=7200)
+    @staticmethod
+    def _run_async(coro: Awaitable[Any]) -> Any:
+        async def _await(value: Awaitable[Any]) -> Any:
+            return await value
 
-        if enable_disk_cache:
-            self.disk_cache = FileCache(self.cache_dir)
+        try:
+            return asyncio.run(_await(coro))
+        except RuntimeError as exception:
+            message = str(exception)
+            if "asyncio.run()" not in message:
+                raise
+            loop = asyncio.new_event_loop()
+            try:
+                return loop.run_until_complete(_await(coro))
+            finally:
+                loop.close()
 
     def get_hook_result(
         self,
         hook_name: str,
         file_hashes: list[str],
     ) -> HookResult | None:
+        if self._backend is None:
+            self.stats.misses += 1
+            return None
         cache_key = self._get_hook_cache_key(hook_name, file_hashes)
-        return self.hook_results_cache.get(cache_key)
+        result = self._run_async(self._backend.get(cache_key))
+        if result is None:
+            self.stats.misses += 1
+        else:
+            self.stats.hits += 1
+        return result
 
     def set_hook_result(
         self,
@@ -278,8 +195,11 @@ class CrackerjackCache:
         file_hashes: list[str],
         result: HookResult,
     ) -> None:
+        if self._backend is None:
+            return
         cache_key = self._get_hook_cache_key(hook_name, file_hashes)
-        self.hook_results_cache.set(cache_key, result, ttl_seconds=1800)
+        self._run_async(self._backend.set(cache_key, result, ttl=1800))
+        self.stats.total_entries += 1
 
     def get_expensive_hook_result(
         self,
@@ -287,20 +207,25 @@ class CrackerjackCache:
         file_hashes: list[str],
         tool_version: str | None = None,
     ) -> HookResult | None:
-        """Get hook result with disk cache fallback for expensive hooks."""
-        # Always check memory first for speed
+        if self._backend is None:
+            self.stats.misses += 1
+            return None
         result = self.get_hook_result(hook_name, file_hashes)
-        if result:
+        if result is not None:
             return result
-
-        # Fall back to disk cache for expensive hooks
-        if self.enable_disk_cache and hook_name in self.EXPENSIVE_HOOKS:
-            cache_key = self._get_versioned_hook_cache_key(
-                hook_name, file_hashes, tool_version
-            )
-            return self.disk_cache.get(cache_key)
-
-        return None
+        if not self.enable_disk_cache or hook_name not in self.EXPENSIVE_HOOKS:
+            return None
+        cache_key = self._get_versioned_hook_cache_key(
+            hook_name,
+            file_hashes,
+            tool_version,
+        )
+        result = self._run_async(self._backend.get(cache_key))
+        if result is None:
+            self.stats.misses += 1
+        else:
+            self.stats.hits += 1
+        return result
 
     def set_expensive_hook_result(
         self,
@@ -309,119 +234,126 @@ class CrackerjackCache:
         result: HookResult,
         tool_version: str | None = None,
     ) -> None:
-        """Set hook result in both memory and disk cache for expensive hooks."""
-        # Always set[t.Any] in memory for current session
+        if self._backend is None:
+            return
         self.set_hook_result(hook_name, file_hashes, result)
-
-        # Also persist to disk for expensive hooks
-        if self.enable_disk_cache and hook_name in self.EXPENSIVE_HOOKS:
-            cache_key = self._get_versioned_hook_cache_key(
-                hook_name, file_hashes, tool_version
-            )
-            ttl = self.HOOK_DISK_TTLS.get(hook_name, 86400)  # Default 24 hours
-            self.disk_cache.set(cache_key, result, ttl_seconds=ttl)
+        if not self.enable_disk_cache or hook_name not in self.EXPENSIVE_HOOKS:
+            return
+        cache_key = self._get_versioned_hook_cache_key(
+            hook_name,
+            file_hashes,
+            tool_version,
+        )
+        ttl = self.HOOK_DISK_TTLS.get(hook_name, 86400)
+        self._run_async(self._backend.set(cache_key, result, ttl=ttl))
 
     def get_file_hash(self, file_path: Path) -> str | None:
+        if self._backend is None:
+            self.stats.misses += 1
+            return None
         stat = file_path.stat()
-        cache_key = f"file_hash: {file_path}: {stat.st_mtime}: {stat.st_size}"
-        return self.file_hash_cache.get(cache_key)
+        cache_key = f"file_hash:{file_path}:{stat.st_mtime}:{stat.st_size}"
+        result = self._run_async(self._backend.get(cache_key))
+        if result is None:
+            self.stats.misses += 1
+        else:
+            self.stats.hits += 1
+        return result
 
     def set_file_hash(self, file_path: Path, file_hash: str) -> None:
+        if self._backend is None:
+            return
         stat = file_path.stat()
-        cache_key = f"file_hash: {file_path}: {stat.st_mtime}: {stat.st_size}"
-        self.file_hash_cache.set(cache_key, file_hash, ttl_seconds=3600)
+        cache_key = f"file_hash:{file_path}:{stat.st_mtime}:{stat.st_size}"
+        self._run_async(self._backend.set(cache_key, file_hash, ttl=3600))
+        self.stats.total_entries += 1
 
-    def get_config_data(self, config_key: str) -> t.Any | None:
-        return self.config_cache.get(f"config: {config_key}")
+    def get_config_data(self, config_key: str) -> Any | None:
+        if self._backend is None:
+            self.stats.misses += 1
+            return None
+        result = self._run_async(self._backend.get(f"config:{config_key}"))
+        if result is None:
+            self.stats.misses += 1
+        else:
+            self.stats.hits += 1
+        return result
 
-    def set_config_data(self, config_key: str, data: t.Any) -> None:
-        self.config_cache.set(f"config: {config_key}", data, ttl_seconds=7200)
+    def set_config_data(self, config_key: str, data: Any) -> None:
+        if self._backend is None:
+            return
+        self._run_async(self._backend.set(f"config:{config_key}", data, ttl=7200))
+        self.stats.total_entries += 1
 
-    def get(self, key: str, default: t.Any = None) -> t.Any:
-        """General purpose get method for metrics and other data."""
-        return self.config_cache.get(key) or default
+    def get(self, key: str, default: Any = None) -> Any:
+        if self._backend is None:
+            return default
+        result = self._run_async(self._backend.get(key))
+        return result if result is not None else default
 
-    def set(self, key: str, value: t.Any, ttl_seconds: int | None = None) -> None:
-        """General purpose set method for metrics and other data."""
-        ttl = ttl_seconds or 3600  # Default 1 hour
-        self.config_cache.set(key, value, ttl_seconds=ttl)
+    def set(self, key: str, value: Any, ttl_seconds: int | None = None) -> None:
+        if self._backend is None:
+            return
+        ttl = ttl_seconds if ttl_seconds is not None else 3600
+        self._run_async(self._backend.set(key, value, ttl=ttl))
 
-    def get_agent_decision(self, agent_name: str, issue_hash: str) -> t.Any | None:
-        """Get cached AI agent decision based on issue content."""
-        if not self.enable_disk_cache:
+    def get_agent_decision(self, agent_name: str, issue_hash: str) -> Any | None:
+        if self._backend is None or not self.enable_disk_cache:
             return None
-
         cache_key = f"agent:{agent_name}:{issue_hash}:{self.AGENT_VERSION}"
-        return self.disk_cache.get(cache_key)
+        return self._run_async(self._backend.get(cache_key))
 
     def set_agent_decision(
-        self, agent_name: str, issue_hash: str, decision: t.Any
+        self,
+        agent_name: str,
+        issue_hash: str,
+        decision: Any,
     ) -> None:
-        """Cache AI agent decision for future use."""
-        if not self.enable_disk_cache:
+        if self._backend is None or not self.enable_disk_cache:
             return
-
         cache_key = f"agent:{agent_name}:{issue_hash}:{self.AGENT_VERSION}"
-        self.disk_cache.set(cache_key, decision, ttl_seconds=604800)  # 7 days
+        self._run_async(self._backend.set(cache_key, decision, ttl=604800))
 
-    def get_quality_baseline(self, git_hash: str) -> dict[str, t.Any] | None:
-        """Get quality baseline metrics for a specific git commit."""
-        if not self.enable_disk_cache:
+    def get_quality_baseline(self, git_hash: str) -> dict[str, Any] | None:
+        if self._backend is None or not self.enable_disk_cache:
             return None
+        return self._run_async(self._backend.get(f"baseline:{git_hash}"))
 
-        return self.disk_cache.get(f"baseline:{git_hash}")
-
-    def set_quality_baseline(self, git_hash: str, metrics: dict[str, t.Any]) -> None:
-        """Store quality baseline metrics for a git commit."""
-        if not self.enable_disk_cache:
+    def set_quality_baseline(
+        self,
+        git_hash: str,
+        metrics: dict[str, Any],
+    ) -> None:
+        if self._backend is None or not self.enable_disk_cache:
             return
+        self._run_async(self._backend.set(f"baseline:{git_hash}", metrics, ttl=2592000))
 
-        self.disk_cache.set(
-            f"baseline:{git_hash}", metrics, ttl_seconds=2592000
-        )  # 30 days
-
-    def invalidate_hook_cache(self, hook_name: str | None = None) -> None:
-        if hook_name:
-            keys_to_remove = [
-                key
-                for key in self.hook_results_cache._cache
-                if key.startswith(f"hook_result: {hook_name}: ")
-            ]
-            for key in keys_to_remove:
-                self.hook_results_cache.invalidate(key)
-        else:
-            self.hook_results_cache.clear()
-
-    def cleanup_all(self) -> dict[str, int]:
-        results = {
-            "hook_results": self.hook_results_cache.cleanup_expired(),
-            "file_hashes": self.file_hash_cache.cleanup_expired(),
-            "config": self.config_cache.cleanup_expired(),
-        }
-
-        if self.enable_disk_cache:
-            results["disk_cache"] = self.disk_cache.cleanup_expired()
-
-        return results
+    @staticmethod
+    def invalidate_hook_cache(hook_name: str | None = None) -> None:
+        logger.warning(
+            "ACB cache fallback does not support selective invalidation (hook=%s).",
+            hook_name,
+        )
 
-    def get_cache_stats(self) -> dict[str, t.Any]:
-        stats = {
-            "hook_results": self.hook_results_cache.stats.to_dict(),
-            "file_hashes": self.file_hash_cache.stats.to_dict(),
-            "config": self.config_cache.stats.to_dict(),
+    @staticmethod
+    def cleanup_all() -> dict[str, int]:
+        return {
+            "hook_results": 0,
+            "file_hashes": 0,
+            "config": 0,
+            "disk_cache": 0,
         }
 
-        if self.enable_disk_cache:
-            stats["disk_cache"] = self.disk_cache.stats.to_dict()
-
-        return stats
+    def get_cache_stats(self) -> dict[str, Any]:
+        return {"acb_cache": self.stats.to_dict()}
 
-    def _get_hook_cache_key(self, hook_name: str, file_hashes: list[str]) -> str:
+    @staticmethod
+    def _get_hook_cache_key(hook_name: str, file_hashes: list[str]) -> str:
         hash_signature = hashlib.md5(
-            ", ".join(sorted(file_hashes)).encode(),
+            ",".join(sorted(file_hashes)).encode(),
             usedforsecurity=False,
         ).hexdigest()
-        return f"hook_result: {hook_name}: {hash_signature}"
+        return f"hook_result:{hook_name}:{hash_signature}"
 
     def _get_versioned_hook_cache_key(
         self,
@@ -429,10 +361,9 @@ class CrackerjackCache:
         file_hashes: list[str],
         tool_version: str | None = None,
     ) -> str:
-        """Get cache key with tool version for disk cache invalidation."""
-        hash_signature = hashlib.md5(
-            ", ".join(sorted(file_hashes)).encode(),
-            usedforsecurity=False,
-        ).hexdigest()
         version_part = f":{tool_version}" if tool_version else ""
-        return f"hook_result: {hook_name}: {hash_signature}{version_part}"
+        base_key = self._get_hook_cache_key(hook_name, file_hashes)
+        return f"{base_key}{version_part}"
+
+
+__all__ = ["CrackerjackCache", "CacheStats", "Cache", "get_cache"]