memrecd 0.4.0

Local-first AI memory with project isolation — for terminal, for private use
Documentation 
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

use anyhow::Result;
use chrono::Utc;
use std::sync::Arc;
use tracing::info;

use crate::importance::ImportanceCalculator;
use crate::storage::MemoryStorage;
use memrec_common::MemoryConfig;

pub struct LifecycleManager {
    storage: Arc<dyn MemoryStorage>,
    calculator: ImportanceCalculator,
    config: MemoryConfig,
}

impl LifecycleManager {
    pub fn new(
        storage: Arc<dyn MemoryStorage>,
        calculator: ImportanceCalculator,
        config: MemoryConfig,
    ) -> Self {
        Self {
            storage,
            calculator,
            config,
        }
    }

    pub async fn recalculate_importance(&self) -> Result<()> {
        info!("Recalculating importance for all memories");

        let memories = self.storage.list(1000).await?;

        for memory in memories {
            let new_importance = self.calculator.calculate(&memory);

            if memory.importance != new_importance {
                let mut updated = memory;
                updated.importance = new_importance;
                self.storage.update(&updated).await?;
            }
        }

        info!("Importance recalculation completed");
        Ok(())
    }

    pub async fn cleanup_cycle(&self) -> Result<()> {
        info!("Starting cleanup cycle");

        self.cleanup_deleted().await?;
        self.cleanup_low_importance().await?;

        info!("Cleanup cycle completed");
        Ok(())
    }

    async fn cleanup_deleted(&self) -> Result<()> {
        let deleted = self.storage.list_deleted().await?;
        let now = Utc::now();

        for memory in deleted {
            if let Some(deleted_at) = memory.deleted_at {
                let days_since_delete = (now - deleted_at).num_days();

                if days_since_delete > self.config.soft_delete_recovery_days as i64 {
                    info!(
                        "Hard deleting memory {} (deleted {} days ago)",
                        memory.id, days_since_delete
                    );
                    self.storage.delete(&memory.id).await?;
                }
            }
        }

        Ok(())
    }

    async fn cleanup_low_importance(&self) -> Result<()> {
        let low_importance = self
            .storage
            .list_by_importance(0.0, self.config.hard_delete_importance)
            .await?;

        let now = Utc::now();

        for memory in low_importance {
            let days_inactive = (now - memory.last_accessed).num_days();

            if days_inactive > self.config.hard_delete_inactive_days as i64 {
                info!(
                    "Deleting low importance memory {} (inactive {} days)",
                    memory.id, days_inactive
                );
                self.storage.delete(&memory.id).await?;
            }
        }

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::storage::{MemoryStore, RocksDBStore};
    use memrec_common::{Memory, MemoryType};
    use tempfile::tempdir;

    #[tokio::test]
    async fn test_recalculate_importance() {
        let dir = tempdir().unwrap();
        let rocksdb = RocksDBStore::open(dir.path()).unwrap();
        let storage = Arc::new(MemoryStore::new(rocksdb));

        let memory = Memory::new("test".to_string(), MemoryType::Knowledge);
        storage.save(&memory).await.unwrap();

        let calc = ImportanceCalculator::default();
        let config = MemoryConfig::default();

        let manager = LifecycleManager::new(storage.clone(), calc, config);

        manager.recalculate_importance().await.unwrap();

        let retrieved = storage.get(&memory.id).await.unwrap().unwrap();
        assert!(retrieved.importance > 0.0);
    }
}