mneme-brain 0.2.5

Persistent memory system for AI coding agents — Rust + SQLite + FTS5 + MCP. Hybrid search, age encryption, CRDT P2P sync, WASM plugins, TUI with knowledge graph.
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

use mneme::export::{export_to_markdown, import_from_markdown};
use mneme::store::db::Database;
use mneme::store::memory::{CreateMemoryInput, Importance, MemoryType, Scope};
use std::path::PathBuf;
use uuid::Uuid;

fn setup_db() -> Database {
    let path = PathBuf::from(format!("/tmp/mneme_export_{}.db", Uuid::new_v4()));
    Database::open(&path).unwrap()
}

fn make_memory(title: &str) -> CreateMemoryInput {
    CreateMemoryInput {
        encrypt: false,
        project: "test-proj".to_string(),
        scope: Some(Scope::Project),
        title: title.to_string(),
        content: format!("Content of {}", title),
        what: Some("what field".to_string()),
        why: Some("why field".to_string()),
        context: None,
        learned: Some("learned field".to_string()),
        memory_type: MemoryType::Decision,
        importance: Importance::High,
        tags: vec!["rust".to_string(), "test".to_string()],
        topic_key: None,
        capture_prompt: None,
        valid_from: None,
        valid_until: None,
        provenance: None,
    }
}

#[test]
fn test_export_markdown_contains_title() {
    let db = setup_db();
    let store = db.memories();
    store.save(make_memory("JWT auth"), None, None).unwrap();
    let memories = store.list("test-proj", None, None, None, 100, 0).unwrap();

    let md = export_to_markdown(&memories, "test-proj");
    assert!(md.contains("JWT auth"));
    assert!(md.contains("# mneme export"));
}

#[test]
fn test_export_markdown_contains_type_and_importance() {
    let db = setup_db();
    let store = db.memories();
    store.save(make_memory("Test Memory"), None, None).unwrap();
    let memories = store.list("test-proj", None, None, None, 100, 0).unwrap();

    let md = export_to_markdown(&memories, "test-proj");
    assert!(md.contains("decision"));
    assert!(md.contains("high"));
}

#[test]
fn test_export_markdown_contains_tags() {
    let db = setup_db();
    let store = db.memories();
    store
        .save(make_memory("Tagged Memory"), None, None)
        .unwrap();
    let memories = store.list("test-proj", None, None, None, 100, 0).unwrap();

    let md = export_to_markdown(&memories, "test-proj");
    assert!(md.contains("`rust`"));
}

#[test]
fn test_export_empty_list_produces_header() {
    let md = export_to_markdown(&[], "empty-proj");
    assert!(md.contains("empty-proj"));
    assert!(md.contains("Total: 0"));
}

#[test]
fn test_import_markdown_roundtrip() {
    let db = setup_db();
    let store = db.memories();
    store
        .save(make_memory("Roundtrip Memory"), None, None)
        .unwrap();
    let memories = store.list("test-proj", None, None, None, 100, 0).unwrap();

    let md = export_to_markdown(&memories, "test-proj");
    let imported = import_from_markdown(&md).unwrap();

    assert_eq!(imported.len(), 1);
    assert_eq!(imported[0].title, "Roundtrip Memory");
}

#[test]
fn test_import_markdown_extracts_type() {
    let db = setup_db();
    let store = db.memories();
    store.save(make_memory("Type Test"), None, None).unwrap();
    let memories = store.list("test-proj", None, None, None, 100, 0).unwrap();

    let md = export_to_markdown(&memories, "test-proj");
    let imported = import_from_markdown(&md).unwrap();

    assert!(matches!(imported[0].memory_type, MemoryType::Decision));
}

#[test]
fn test_import_markdown_extracts_tags() {
    let db = setup_db();
    let store = db.memories();
    store.save(make_memory("Tags Test"), None, None).unwrap();
    let memories = store.list("test-proj", None, None, None, 100, 0).unwrap();

    let md = export_to_markdown(&memories, "test-proj");
    let imported = import_from_markdown(&md).unwrap();

    assert!(imported[0].tags.contains(&"rust".to_string()));
}

#[test]
fn test_import_empty_markdown_returns_empty() {
    let imported = import_from_markdown("# mneme export\nsin memorias\n").unwrap();
    assert!(imported.is_empty());
}