hippmem-engine 0.1.0

HIPPMEM native association memory engine — unified public Rust API orchestration layer
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

//! acceptance test: activation_log + feedback API.

use hippmem_core::model::enums::ContentType;
use hippmem_core::model::unit::WriteContext;
use hippmem_engine::{Engine, EngineConfig, FeedbackInput, UsageSignal, WriteMemoryInput};
use tempfile::tempdir;

fn ctx() -> WriteContext {
    WriteContext {
        conversation_id: Some(1),
        session_id: Some(1),
        project_id: None,
        task_id: None,
        user_id: None,
        local_time: hippmem_core::time::Timestamp(1_700_000_000_000),
        preceding_memory_ids: vec![],
        source_refs: vec![],
    }
}

#[test]
fn feedback_accepts_valid_signal() {
    let dir = tempdir().unwrap();
    let config = EngineConfig {
        store_dir: dir.path().join("hippmem.redb"),
        ..Default::default()
    };
    let engine = Engine::open(config).unwrap();

    engine
        .write(WriteMemoryInput {
            content: "test memory".into(),
            content_type: Some(ContentType::UserStatement),
            context: ctx(),
            importance_hint: None,
            source_refs: vec![],
        })
        .unwrap();

    // feedback with Referenced signal
    let result = engine.feedback(FeedbackInput {
        retrieval_id: 1,
        used_memory_ids: vec![],
        signal: UsageSignal::Referenced,
    });
    assert!(result.is_ok(), "feedback should succeed");

    // feedback with UserConfirmedCorrect
    let result = engine.feedback(FeedbackInput {
        retrieval_id: 2,
        used_memory_ids: vec![],
        signal: UsageSignal::UserConfirmedCorrect,
    });
    assert!(result.is_ok());

    // feedback with UserRejected
    let result = engine.feedback(FeedbackInput {
        retrieval_id: 3,
        used_memory_ids: vec![],
        signal: UsageSignal::UserRejected,
    });
    assert!(result.is_ok());

    engine.close().unwrap();
}

#[test]
fn feedback_persists_across_reopen() {
    let dir = tempdir().unwrap();
    let store_path = dir.path().join("hippmem.redb");

    {
        let engine = Engine::open(EngineConfig {
            store_dir: store_path.clone(),
            ..Default::default()
        })
        .unwrap();
        engine
            .feedback(FeedbackInput {
                retrieval_id: 42,
                used_memory_ids: vec![],
                signal: UsageSignal::TaskSucceeded,
            })
            .unwrap();
        engine.close().unwrap();
    }

    // reopen and verify
    {
        let engine = Engine::open(EngineConfig {
            store_dir: store_path.clone(),
            ..Default::default()
        })
        .unwrap();
        // feedback data should be persisted in activation_log; reopen should not error
        let result = engine.feedback(FeedbackInput {
            retrieval_id: 42,
            used_memory_ids: vec![],
            signal: UsageSignal::Referenced,
        });
        assert!(result.is_ok());
        engine.close().unwrap();
    }
}