remem-ai 0.3.8

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

use rusqlite::{params, Connection};

use super::{search_memories_fts_filtered, search_memories_like_filtered};
use crate::memory::tests_helper::setup_memory_schema;
use crate::memory::{insert_memory, search_memories_fts, search_memories_like};

#[test]
fn test_memory_fts_search() {
    let conn = Connection::open_in_memory().expect("in-memory db should open");
    setup_memory_schema(&conn);

    insert_memory(
        &conn,
        Some("s1"),
        "proj",
        None,
        "FTS5 trigram tokenizer 支持 CJK",
        "Switched to trigram for Chinese search support.",
        "decision",
        None,
    )
    .expect("first memory should insert");
    insert_memory(
        &conn,
        Some("s1"),
        "proj",
        None,
        "Auth middleware rewrite",
        "Rewrote auth middleware for compliance.",
        "architecture",
        None,
    )
    .expect("second memory should insert");

    let results = search_memories_fts(&conn, "trigram", Some("proj"), None, 10, 0)
        .expect("fts search should succeed");
    assert_eq!(results.len(), 1);
    assert!(results[0].title.contains("trigram"));
}

#[test]
fn test_memory_like_fallback() {
    let conn = Connection::open_in_memory().expect("in-memory db should open");
    setup_memory_schema(&conn);

    insert_memory(
        &conn,
        Some("s1"),
        "proj",
        None,
        "DB schema migration",
        "Updated schema from v7 to v8.",
        "decision",
        None,
    )
    .expect("memory should insert");

    let results = search_memories_like(&conn, &["DB"], Some("proj"), None, 10, 0)
        .expect("like search should succeed");
    assert_eq!(results.len(), 1);
    assert!(results[0].title.contains("DB"));
}

#[test]
fn search_memories_filtered_respects_branch_and_active_state() {
    let conn = Connection::open_in_memory().expect("in-memory db should open");
    setup_memory_schema(&conn);

    let main_id = insert_memory(
        &conn,
        Some("s1"),
        "proj",
        None,
        "Main branch trigram",
        "content alpha",
        "decision",
        None,
    )
    .expect("main memory should insert");
    let null_branch_id = insert_memory(
        &conn,
        Some("s1"),
        "proj",
        None,
        "Shared branch trigram",
        "content alpha",
        "decision",
        None,
    )
    .expect("shared memory should insert");
    let archived_id = insert_memory(
        &conn,
        Some("s1"),
        "proj",
        None,
        "Archived trigram",
        "content alpha",
        "decision",
        None,
    )
    .expect("archived memory should insert");

    conn.execute(
        "UPDATE memories SET branch = 'main' WHERE id = ?1",
        params![main_id],
    )
    .expect("main branch should update");
    conn.execute(
        "UPDATE memories SET branch = 'feature', status = 'archived' WHERE id = ?1",
        params![archived_id],
    )
    .expect("archived memory should update");

    let fts_results = search_memories_fts_filtered(
        &conn,
        "trigram",
        Some("proj"),
        Some("decision"),
        10,
        0,
        false,
        Some("main"),
    )
    .expect("filtered fts search should succeed");
    assert_eq!(fts_results.len(), 2);
    assert_eq!(fts_results[0].id, main_id);
    assert_eq!(fts_results[1].id, null_branch_id);

    let like_results = search_memories_like_filtered(
        &conn,
        &["alpha"],
        Some("proj"),
        Some("decision"),
        10,
        0,
        true,
        Some("feature"),
    )
    .expect("filtered like search should succeed");
    assert_eq!(like_results.len(), 2);
    let mut like_ids = like_results
        .iter()
        .map(|memory| memory.id)
        .collect::<Vec<_>>();
    like_ids.sort_unstable();
    assert_eq!(like_ids, vec![null_branch_id, archived_id]);
}