mur_core/

cache.rs

//! Three-layer cache system for MUR Commander.
//!
//! - L1: Struct cache — pre-loaded workflows, patterns, config, constitution
//! - L2: Query cache — search results and injection results
//! - L3: LLM response cache — prompt→response pairs to save API costs

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::time::Duration;

/// Cache entry with TTL tracking.
#[derive(Debug, Clone)]
pub struct CacheEntry<T> {
    pub value: T,
    pub created_at: DateTime<Utc>,
    pub ttl: Duration,
    pub hits: u64,
}

impl<T: Clone> CacheEntry<T> {
    pub fn new(value: T, ttl: Duration) -> Self {
        Self {
            value,
            created_at: Utc::now(),
            ttl,
            hits: 0,
        }
    }

    pub fn is_expired(&self) -> bool {
        let elapsed = Utc::now()
            .signed_duration_since(self.created_at)
            .to_std()
            .unwrap_or(Duration::ZERO);
        elapsed > self.ttl
    }
}

/// L1: Struct cache for frequently accessed data.
#[derive(Debug, Clone, Default)]
pub struct L1StructCache {
    entries: Arc<RwLock<HashMap<String, CacheEntry<String>>>>,
}

impl L1StructCache {
    pub fn new() -> Self {
        Self::default()
    }

    /// Store a value with a TTL.
    pub fn set(&self, key: &str, value: String, ttl: Duration) {
        if let Ok(mut entries) = self.entries.write() {
            entries.insert(key.to_string(), CacheEntry::new(value, ttl));
        }
    }

    /// Get a value if it exists and hasn't expired.
    pub fn get(&self, key: &str) -> Option<String> {
        if let Ok(mut entries) = self.entries.write() {
            if let Some(entry) = entries.get_mut(key) {
                if entry.is_expired() {
                    entries.remove(key);
                    return None;
                }
                entry.hits += 1;
                return Some(entry.value.clone());
            }
        }
        None
    }

    /// Invalidate a specific key.
    pub fn invalidate(&self, key: &str) {
        if let Ok(mut entries) = self.entries.write() {
            entries.remove(key);
        }
    }

    /// Invalidate all entries.
    pub fn clear(&self) {
        if let Ok(mut entries) = self.entries.write() {
            entries.clear();
        }
    }

    /// Get cache statistics.
    pub fn stats(&self) -> CacheStats {
        let entries = self.entries.read().unwrap_or_else(|e| e.into_inner());
        let total = entries.len();
        let expired = entries.values().filter(|e| e.is_expired()).count();
        let total_hits: u64 = entries.values().map(|e| e.hits).sum();
        CacheStats {
            entries: total,
            expired,
            hits: total_hits,
        }
    }
}

/// L2: Query result cache.
#[derive(Debug, Clone, Default)]
pub struct L2QueryCache {
    entries: Arc<RwLock<HashMap<String, CacheEntry<String>>>>,
}

impl L2QueryCache {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn set(&self, query: &str, result: String, ttl: Duration) {
        if let Ok(mut entries) = self.entries.write() {
            entries.insert(query.to_string(), CacheEntry::new(result, ttl));
        }
    }

    pub fn get(&self, query: &str) -> Option<String> {
        if let Ok(mut entries) = self.entries.write() {
            if let Some(entry) = entries.get_mut(query) {
                if entry.is_expired() {
                    entries.remove(query);
                    return None;
                }
                entry.hits += 1;
                return Some(entry.value.clone());
            }
        }
        None
    }

    pub fn clear(&self) {
        if let Ok(mut entries) = self.entries.write() {
            entries.clear();
        }
    }

    pub fn stats(&self) -> CacheStats {
        let entries = self.entries.read().unwrap_or_else(|e| e.into_inner());
        CacheStats {
            entries: entries.len(),
            expired: entries.values().filter(|e| e.is_expired()).count(),
            hits: entries.values().map(|e| e.hits).sum(),
        }
    }
}

/// L3: LLM response cache — exact prompt→response to avoid duplicate API calls.
#[derive(Debug, Clone, Default)]
pub struct L3LlmCache {
    entries: Arc<RwLock<HashMap<String, CacheEntry<LlmCacheEntry>>>>,
}

/// Cached LLM response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LlmCacheEntry {
    pub response: String,
    pub model: String,
    pub cost_saved: f64,
}

impl L3LlmCache {
    pub fn new() -> Self {
        Self::default()
    }

    /// Cache a prompt→response pair.
    pub fn set(&self, prompt_hash: &str, entry: LlmCacheEntry, ttl: Duration) {
        if let Ok(mut entries) = self.entries.write() {
            entries.insert(prompt_hash.to_string(), CacheEntry::new(entry, ttl));
        }
    }

    /// Look up a cached response by prompt hash.
    pub fn get(&self, prompt_hash: &str) -> Option<LlmCacheEntry> {
        if let Ok(mut entries) = self.entries.write() {
            if let Some(entry) = entries.get_mut(prompt_hash) {
                if entry.is_expired() {
                    entries.remove(prompt_hash);
                    return None;
                }
                entry.hits += 1;
                return Some(entry.value.clone());
            }
        }
        None
    }

    /// Get total cost saved by cache hits.
    pub fn total_cost_saved(&self) -> f64 {
        self.entries
            .read()
            .map(|entries| {
                entries
                    .values()
                    .filter(|e| e.hits > 0)
                    .map(|e| e.value.cost_saved * e.hits as f64)
                    .sum()
            })
            .unwrap_or(0.0)
    }

    pub fn clear(&self) {
        if let Ok(mut entries) = self.entries.write() {
            entries.clear();
        }
    }

    pub fn stats(&self) -> CacheStats {
        let entries = self.entries.read().unwrap_or_else(|e| e.into_inner());
        CacheStats {
            entries: entries.len(),
            expired: entries.values().filter(|e| e.is_expired()).count(),
            hits: entries.values().map(|e| e.hits).sum(),
        }
    }
}

/// Cache statistics.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CacheStats {
    pub entries: usize,
    pub expired: usize,
    pub hits: u64,
}

/// Combined three-layer cache.
#[derive(Debug, Clone)]
pub struct CacheSystem {
    pub l1: L1StructCache,
    pub l2: L2QueryCache,
    pub l3: L3LlmCache,
}

impl CacheSystem {
    pub fn new() -> Self {
        Self {
            l1: L1StructCache::new(),
            l2: L2QueryCache::new(),
            l3: L3LlmCache::new(),
        }
    }

    /// Get combined stats for all layers.
    pub fn all_stats(&self) -> (CacheStats, CacheStats, CacheStats) {
        (self.l1.stats(), self.l2.stats(), self.l3.stats())
    }

    /// Clear all cache layers.
    pub fn clear_all(&self) {
        self.l1.clear();
        self.l2.clear();
        self.l3.clear();
    }
}

impl Default for CacheSystem {
    fn default() -> Self {
        Self::new()
    }
}

/// Compute a simple hash of a prompt for L3 cache keys.
pub fn prompt_hash(prompt: &str) -> String {
    use sha2::{Digest, Sha256};
    let mut hasher = Sha256::new();
    hasher.update(prompt.as_bytes());
    format!("{:x}", hasher.finalize())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_l1_set_get() {
        let cache = L1StructCache::new();
        cache.set("key1", "value1".into(), Duration::from_secs(60));
        assert_eq!(cache.get("key1"), Some("value1".into()));
        assert_eq!(cache.get("missing"), None);
    }

    #[test]
    fn test_l1_expiration() {
        let cache = L1StructCache::new();
        cache.set("key1", "value1".into(), Duration::from_secs(0));
        // Expired immediately
        std::thread::sleep(Duration::from_millis(10));
        assert_eq!(cache.get("key1"), None);
    }

    #[test]
    fn test_l1_invalidate() {
        let cache = L1StructCache::new();
        cache.set("key1", "value1".into(), Duration::from_secs(60));
        cache.invalidate("key1");
        assert_eq!(cache.get("key1"), None);
    }

    #[test]
    fn test_l1_stats() {
        let cache = L1StructCache::new();
        cache.set("k1", "v1".into(), Duration::from_secs(60));
        cache.set("k2", "v2".into(), Duration::from_secs(60));
        cache.get("k1");
        cache.get("k1");
        let stats = cache.stats();
        assert_eq!(stats.entries, 2);
        assert_eq!(stats.hits, 2);
    }

    #[test]
    fn test_l3_cost_saved() {
        let cache = L3LlmCache::new();
        cache.set(
            "hash1",
            LlmCacheEntry {
                response: "cached response".into(),
                model: "sonnet".into(),
                cost_saved: 0.05,
            },
            Duration::from_secs(3600),
        );
        // Hit it twice
        cache.get("hash1");
        cache.get("hash1");
        let saved = cache.total_cost_saved();
        assert!((saved - 0.10).abs() < 0.001);
    }

    #[test]
    fn test_prompt_hash() {
        let h1 = prompt_hash("hello");
        let h2 = prompt_hash("hello");
        let h3 = prompt_hash("world");
        assert_eq!(h1, h2);
        assert_ne!(h1, h3);
        assert_eq!(h1.len(), 64); // SHA-256 hex
    }

    #[test]
    fn test_cache_system() {
        let system = CacheSystem::new();
        system.l1.set("k", "v".into(), Duration::from_secs(60));
        let (l1, l2, l3) = system.all_stats();
        assert_eq!(l1.entries, 1);
        assert_eq!(l2.entries, 0);
        assert_eq!(l3.entries, 0);

        system.clear_all();
        let (l1, _, _) = system.all_stats();
        assert_eq!(l1.entries, 0);
    }
}