engram-memory 0.5.0

Core binary and shared infrastructure for Engram memory system
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

use engram_consolidate::ConsolidateError;
use engram_core::CoreError;
use engram_hnsw::HnswError;
use engram_llm_client::ApiError;
use engram_storage::StorageError;

#[test]
fn config_not_found_display() {
    let error = CoreError::ConfigNotFound;
    assert_eq!(error.to_string(), "[6001] config not found");
}

#[test]
fn config_parse_error_display() {
    let error = CoreError::ConfigParseError("bad toml".into());
    assert_eq!(error.to_string(), "[6002] config parse error: bad toml");
}

#[test]
fn invalid_provider_display() {
    let error = CoreError::InvalidProvider("unknown".into());
    assert_eq!(error.to_string(), "[6003] invalid provider: unknown");
}

#[test]
fn index_corrupted_display() {
    let error = CoreError::IndexCorrupted("bad magic".into());
    assert_eq!(error.to_string(), "[6004] index corrupted: bad magic");
}

#[test]
fn rebuild_failed_display() {
    let error = CoreError::RebuildFailed("disk full".into());
    assert_eq!(error.to_string(), "[6005] rebuild failed: disk full");
}

#[test]
fn socket_error_display() {
    let error = CoreError::SocketError("connection refused".into());
    assert_eq!(error.to_string(), "[6006] socket error: connection refused");
}

#[test]
fn dispatch_error_display() {
    let error = CoreError::DispatchError("unknown method".into());
    assert_eq!(error.to_string(), "[6007] dispatch error: unknown method");
}

#[test]
fn from_storage_error() {
    let storage = StorageError::NotFound("memory id=42".into());
    let core: CoreError = storage.into();
    assert!(core.to_string().contains("[1002]"));
}

#[test]
fn from_hnsw_error() {
    let hnsw = HnswError::RebuildRequired;
    let core: CoreError = hnsw.into();
    assert!(core.to_string().contains("[3003]"));
}

#[test]
fn from_api_error() {
    let api = ApiError::InvalidApiKey("bad key".into());
    let core: CoreError = api.into();
    assert!(core.to_string().contains("[2004]"));
}

#[test]
fn from_consolidate_error() {
    let consolidate = ConsolidateError::NoCandidates;
    let core: CoreError = consolidate.into();
    assert!(core.to_string().contains("[5001]"));
}

#[test]
fn error_source_delegates_for_storage() {
    use std::error::Error;
    let storage = StorageError::NotFound("test".into());
    let core = CoreError::Storage(storage);
    assert!(core.source().is_some());
}

#[test]
fn error_source_none_for_own_variants() {
    use std::error::Error;
    let core = CoreError::ConfigNotFound;
    assert!(core.source().is_none());
}

#[test]
fn trainer_failed_display() {
    let error = CoreError::TrainerFailed("/usr/bin/engram-trainer".into());
    assert_eq!(
        error.to_string(),
        "[6013] trainer failed: /usr/bin/engram-trainer"
    );
}

#[test]
fn trainer_timeout_display() {
    let error = CoreError::TrainerTimeout;
    assert_eq!(error.to_string(), "[6014] trainer timeout");
}

#[test]
fn trainer_malformed_output_display() {
    let error = CoreError::TrainerMalformedOutput("invalid json at line 3".into());
    assert_eq!(
        error.to_string(),
        "[6015] trainer malformed output: invalid json at line 3"
    );
}