remem-ai 0.6.7

Local-first coding agent memory for Claude Code and OpenAI Codex
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

/// Extract simple entities from text (project names, tools, concepts).
/// No LLM needed — rule-based extraction from title + content.
pub fn extract_entities(title: &str, content: &str) -> Vec<String> {
    let mut entities = Vec::new();
    let mut seen = std::collections::HashSet::new();
    let combined = format!("{} {}", title, content);

    for word in combined.split_whitespace() {
        let clean = word.trim_matches(|c: char| !c.is_alphanumeric() && c != '-' && c != '_');
        if clean.len() < 2 {
            continue;
        }
        if clean
            .chars()
            .next()
            .map(|c| c.is_uppercase())
            .unwrap_or(false)
            && clean.chars().any(|c| c.is_lowercase())
            && clean.len() >= 3
        {
            let lower = clean.to_lowercase();
            if !is_stop_word(&lower) && seen.insert(lower.clone()) {
                entities.push(clean.to_string());
            }
        }
        if clean.len() >= 2
            && clean.len() <= 8
            && clean
                .chars()
                .all(|c| c.is_uppercase() || c.is_ascii_digit())
        {
            let lower = clean.to_lowercase();
            if seen.insert(lower) {
                entities.push(clean.to_string());
            }
        }
    }

    let lower_combined = combined.to_lowercase();
    for term in technical_terms() {
        if lower_combined.contains(&term.to_lowercase()) && seen.insert(term.to_lowercase()) {
            entities.push(term.to_string());
        }
    }

    entities.truncate(10);
    entities
}

fn technical_terms() -> &'static [&'static str] {
    &[
        "remem",
        "sqlite",
        "sqlcipher",
        "fts5",
        "trigram",
        "axum",
        "tokio",
        "claude",
        "codex",
        "cursor",
        "aider",
        "mem0",
        "zep",
        "letta",
        "engram",
        "hindsight",
        "mcp",
        "hook",
        "ToolAdapter",
        "REST",
        "API",
    ]
}

fn is_stop_word(word: &str) -> bool {
    matches!(
        word,
        "the"
            | "and"
            | "for"
            | "with"
            | "from"
            | "that"
            | "this"
            | "into"
            | "when"
            | "what"
            | "how"
            | "not"
            | "are"
            | "was"
            | "has"
            | "had"
            | "will"
            | "can"
            | "all"
            | "but"
            | "use"
            | "new"
            | "add"
            | "set"
            | "run"
            | "get"
            | "let"
            | "some"
            | "none"
            | "used"
            | "using"
            | "session"
            | "request"
            | "context"
            | "decisions"
            | "learned"
    )
}