remem-ai 0.4.3

Persistent memory for Claude Code — single binary, zero subprocesses
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use super::super::promote_summary_to_memories;
use super::super::slug::content_hash;
use crate::memory::tests_helper::setup_memory_schema;

#[test]
fn test_promote_multi_decisions() {
    let conn = rusqlite::Connection::open_in_memory().unwrap();
    setup_memory_schema(&conn);

    let decisions = "• Use RwLock instead of Mutex for concurrent read support\n\
                     • Switch to trigram tokenizer for CJK text search\n\
                     • Set compression threshold to 100 observations";
    let count = promote_summary_to_memories(
        &conn,
        "session-1",
        "test/proj",
        Some("Optimize search and concurrency"),
        Some(decisions),
        None,
        None,
    )
    .unwrap();
    assert_eq!(count, 3);

    let memories = crate::memory::get_recent_memories(&conn, "test/proj", 10).unwrap();
    let titles: Vec<&str> = memories
        .iter()
        .map(|memory| memory.title.as_str())
        .collect();
    assert!(
        titles.iter().any(|title| title.contains("RwLock")),
        "title should contain keyword from content: {:?}",
        titles
    );
    assert!(
        titles.iter().any(|title| title.contains("trigram")),
        "title should contain keyword from content: {:?}",
        titles
    );
}

#[test]
fn test_promote_multi_learned() {
    let conn = rusqlite::Connection::open_in_memory().unwrap();
    setup_memory_schema(&conn);

    let learned = "- FTS5 trigram tokenizer handles CJK without word boundaries\n\
                   - WAL mode allows concurrent reads with single writer";
    let count = promote_summary_to_memories(
        &conn,
        "session-1",
        "test/proj",
        Some("Research storage"),
        None,
        Some(learned),
        None,
    )
    .unwrap();
    assert_eq!(count, 2);
}

#[test]
fn test_promote_preference_defaults_to_project_scope() {
    let conn = rusqlite::Connection::open_in_memory().unwrap();
    setup_memory_schema(&conn);

    let count = promote_summary_to_memories(
        &conn,
        "session-1",
        "test/proj",
        Some("Capture local preference"),
        None,
        None,
        Some("Always run project-specific smoke tests"),
    )
    .unwrap();
    assert_eq!(count, 1);

    let memories = crate::memory::get_recent_memories(&conn, "test/proj", 10).unwrap();
    assert_eq!(memories.len(), 1);
    assert_eq!(memories[0].memory_type, "preference");
    assert_eq!(memories[0].scope, "project");
}

#[test]
fn test_promote_content_format() {
    let conn = rusqlite::Connection::open_in_memory().unwrap();
    setup_memory_schema(&conn);

    let decisions = "Switched from unicode61 to trigram tokenizer for better CJK support";
    promote_summary_to_memories(
        &conn,
        "session-1",
        "test/proj",
        Some("Fix search"),
        Some(decisions),
        None,
        None,
    )
    .unwrap();

    let memories = crate::memory::get_recent_memories(&conn, "test/proj", 10).unwrap();
    assert_eq!(memories.len(), 1);
    assert!(
        !memories[0].text.contains("**Request**"),
        "content should not have boilerplate: {}",
        memories[0].text
    );
    assert!(
        memories[0].text.contains("[Context:"),
        "content should have compact context: {}",
        memories[0].text
    );
}

#[test]
fn test_content_hash_dedup() {
    let hash1 = content_hash("Use FTS5 trigram tokenizer for CJK support");
    let hash2 = content_hash("Use FTS5 trigram tokenizer for CJK support");
    assert_eq!(hash1, hash2);

    let hash3 = content_hash("Switch to WAL mode for concurrent reads");
    assert_ne!(hash1, hash3);
}

#[test]
fn test_cross_session_dedup() {
    let conn = rusqlite::Connection::open_in_memory().unwrap();
    setup_memory_schema(&conn);

    let decision = "Use FTS5 trigram tokenizer for CJK text search support";
    promote_summary_to_memories(
        &conn,
        "session-1",
        "test/proj",
        Some("Optimize search"),
        Some(decision),
        None,
        None,
    )
    .unwrap();

    promote_summary_to_memories(
        &conn,
        "session-2",
        "test/proj",
        Some("Database performance tuning"),
        Some(decision),
        None,
        None,
    )
    .unwrap();

    let memories = crate::memory::get_recent_memories(&conn, "test/proj", 10).unwrap();
    assert_eq!(
        memories.len(),
        1,
        "same decision should dedup across sessions"
    );
}