selfware 0.6.1

Your personal AI workshop — software you own, software that lasts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Minimal local-first optimization module
//!
//! Provides basic offline support and response caching.

use std::collections::HashMap;

/// Local-first coordinator for offline support
#[derive(Debug)]
pub struct LocalFirstCoordinator {
    /// Cached responses
    response_cache: LocalCache<String>,
}

impl LocalFirstCoordinator {
    /// Create a new coordinator
    pub fn new() -> Self {
        Self {
            response_cache: LocalCache::new(),
        }
    }

    /// Cache a response
    pub fn cache_response(&mut self, key: &str, response: String, size_bytes: usize) {
        let entry = LocalCacheEntry {
            key: key.to_string(),
            value: response,
            size_bytes,
        };
        self.response_cache.put(entry);
    }

    /// Get statistics
    pub fn stats(&self) -> LocalFirstStats {
        let cache_stats = self.response_cache.stats();
        LocalFirstStats {
            offline_status: OfflineStatus::Online,
            bandwidth_saved_bytes: cache_stats.total_size_bytes,
            cache_stats,
        }
    }
}

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

/// Simple local cache for generic values
#[derive(Debug)]
pub struct LocalCache<T> {
    entries: HashMap<String, LocalCacheEntry<T>>,
    max_entries: usize,
}

#[derive(Debug, Clone)]
pub struct LocalCacheEntry<T> {
    key: String,
    #[allow(dead_code)]
    value: T,
    size_bytes: usize,
}

impl LocalCache<String> {
    /// Create a new cache with default settings
    pub fn new() -> Self {
        Self {
            entries: HashMap::new(),
            max_entries: 1000,
        }
    }

    /// Insert an entry
    pub fn put(&mut self, entry: LocalCacheEntry<String>) {
        if self.entries.len() >= self.max_entries {
            // Simple eviction: remove first entry
            if let Some(first_key) = self.entries.keys().next().cloned() {
                self.entries.remove(&first_key);
            }
        }
        self.entries.insert(entry.key.clone(), entry);
    }

    /// Get cache statistics
    pub fn stats(&self) -> CacheStats {
        let total_size_bytes: usize = self.entries.values().map(|e| e.size_bytes).sum();
        CacheStats {
            entry_count: self.entries.len(),
            total_size_bytes,
            hit_rate: 0.0, // Simplified - no tracking in minimal version
        }
    }
}

impl Default for LocalCache<String> {
    fn default() -> Self {
        Self::new()
    }
}

/// Cache statistics
#[derive(Debug, Clone)]
pub struct CacheStats {
    pub entry_count: usize,
    pub total_size_bytes: usize,
    pub hit_rate: f64,
}

/// Offline status
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OfflineStatus {
    Online,
    #[allow(dead_code)]
    Offline,
}

impl std::fmt::Display for OfflineStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            OfflineStatus::Online => write!(f, "Online"),
            OfflineStatus::Offline => write!(f, "Offline"),
        }
    }
}

/// Local-first statistics
#[derive(Debug, Clone)]
pub struct LocalFirstStats {
    pub offline_status: OfflineStatus,
    pub bandwidth_saved_bytes: usize,
    pub cache_stats: CacheStats,
}

#[cfg(test)]
#[path = "../../tests/unit/session/local_first/local_first_test.rs"]
mod tests;