crabtalk 0.0.22

Crabtalk library
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

//! Integration tests for the hook-level memory facade.

use crabtalk::hooks::Memory;
use tempfile::tempdir;

fn test_memory() -> Memory {
    let dir = tempdir().unwrap();
    Memory::open(dir.path().join("memory.db")).unwrap()
}

#[test]
fn remember_and_recall() {
    let mem = test_memory();

    mem.remember(
        "luna-vet".to_owned(),
        "User's dog Luna has vet appointments on Thursdays. Luna is a golden retriever. Vet is Dr. Chen.".to_owned(),
        vec![],
    );

    let result = mem.recall("luna vet", 5);
    assert!(result.contains("luna-vet"), "should find luna-vet entry");
    assert!(result.contains("Dr. Chen"), "should contain entry content");
}

#[test]
fn recall_ranks_by_relevance() {
    let mem = test_memory();

    mem.remember(
        "weather".to_owned(),
        "User prefers sunny weather. Likes to go outside when sunny.".to_owned(),
        vec![],
    );
    mem.remember(
        "rust-project".to_owned(),
        "User works on a Rust project called Crabtalk. Crabtalk is an AI companion daemon written in Rust.".to_owned(),
        vec![],
    );
    mem.remember(
        "cooking".to_owned(),
        "User enjoys cooking Italian food. Favorite dish is carbonara.".to_owned(),
        vec![],
    );

    let result = mem.recall("rust crabtalk", 5);
    assert!(
        result.starts_with("## rust-project"),
        "rust-project should rank first, got: {result}"
    );
}

#[test]
fn forget_removes_entry() {
    let mem = test_memory();

    mem.remember(
        "temp-note".to_owned(),
        "Temporary note. Should be deleted soon.".to_owned(),
        vec![],
    );

    let result = mem.recall("temporary", 5);
    assert!(result.contains("temp-note"));

    let result = mem.forget("temp-note");
    assert!(result.contains("forgot"));

    let result = mem.recall("temporary", 5);
    assert_eq!(result, "no memories found");
}

#[test]
fn forget_nonexistent_returns_error() {
    let mem = test_memory();
    let result = mem.forget("does-not-exist");
    assert!(result.contains("no entry named"));
}

#[test]
fn remember_updates_existing() {
    let mem = test_memory();

    mem.remember(
        "user-pref".to_owned(),
        "User preference. Likes terse responses.".to_owned(),
        vec![],
    );
    mem.remember(
        "user-pref".to_owned(),
        "User preference updated. Likes detailed responses now.".to_owned(),
        vec![],
    );

    let result = mem.recall("preference", 5);
    assert!(result.contains("detailed responses"));
    assert!(!result.contains("terse responses"));
}

#[test]
fn recall_empty_memory() {
    let mem = test_memory();
    let result = mem.recall("anything", 5);
    assert_eq!(result, "no memories found");
}

#[test]
fn recall_respects_limit() {
    let mem = test_memory();

    for i in 0..10 {
        mem.remember(
            format!("note-{i}"),
            format!("Note number {i} about testing. Content for test note {i}."),
            vec![],
        );
    }

    let result = mem.recall("testing note", 3);
    let entries: Vec<&str> = result.split("\n---\n").collect();
    assert!(
        entries.len() <= 3,
        "should return at most 3 entries, got {}",
        entries.len()
    );
}

#[test]
fn aliases_boost_search() {
    let mem = test_memory();
    mem.remember(
        "deploy".to_owned(),
        "Production rollout steps and gate flipping.".to_owned(),
        vec!["ship".to_owned(), "release".to_owned()],
    );

    let result = mem.recall("ship", 5);
    assert!(result.contains("deploy"));
}