remem-ai 0.5.65

Persistent memory for Claude Code and Codex — single binary, automatic context
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

use serde::Serialize;

use super::Memory;

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct MemoryStalenessLabel {
    pub status: String,
    pub age: &'static str,
    pub source_anchor: &'static str,
    pub label: String,
}

pub fn memory_staleness_label(memory: &Memory, now_epoch: i64) -> MemoryStalenessLabel {
    let age = age_staleness(memory.updated_at_epoch, now_epoch);
    let source_anchor = "untracked";
    MemoryStalenessLabel {
        status: memory.status.clone(),
        age,
        source_anchor,
        label: format!(
            "status={}; staleness={age}; source_anchor={source_anchor}",
            memory.status
        ),
    }
}

pub fn memory_staleness(memory: &Memory, now_epoch: i64) -> String {
    format!(
        "status={}; staleness={}",
        memory.status,
        age_staleness(memory.updated_at_epoch, now_epoch)
    )
}

pub fn age_staleness_label(updated_at_epoch: i64, now_epoch: i64) -> String {
    format!("staleness={}", age_staleness(updated_at_epoch, now_epoch))
}

pub fn age_staleness(updated_at_epoch: i64, now_epoch: i64) -> &'static str {
    let age_days = now_epoch.saturating_sub(updated_at_epoch) / 86_400;
    if age_days <= 30 {
        "fresh"
    } else if age_days <= 90 {
        "aging"
    } else {
        "old"
    }
}

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

    fn memory(updated_at_epoch: i64, status: &str) -> Memory {
        Memory {
            id: 1,
            session_id: None,
            project: "/repo".to_string(),
            topic_key: None,
            title: "Staleness fixture".to_string(),
            text: "body".to_string(),
            memory_type: "decision".to_string(),
            files: None,
            created_at_epoch: updated_at_epoch,
            updated_at_epoch,
            status: status.to_string(),
            branch: None,
            scope: "project".to_string(),
        }
    }

    #[test]
    fn labels_memory_status_age_and_untracked_source_anchor() {
        let label = memory_staleness_label(&memory(1_700_000_000, "active"), 1_700_000_000);

        assert_eq!(label.status, "active");
        assert_eq!(label.age, "fresh");
        assert_eq!(label.source_anchor, "untracked");
        assert_eq!(
            label.label,
            "status=active; staleness=fresh; source_anchor=untracked"
        );
        assert_eq!(
            memory_staleness(&memory(1_700_000_000, "active"), 1_700_000_000),
            "status=active; staleness=fresh"
        );
    }

    #[test]
    fn classifies_age_buckets() {
        let now = 1_700_000_000;

        assert_eq!(age_staleness(now - 30 * 86_400, now), "fresh");
        assert_eq!(age_staleness(now - 31 * 86_400, now), "aging");
        assert_eq!(age_staleness(now - 91 * 86_400, now), "old");
    }
}