recall-echo 3.11.0

Persistent memory system with knowledge graph — for any LLM tool
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

//! Integration tests for graph garbage collection — four-phase sweep,
//! dry-run behavior, pipeline entity protection.

mod common;
use common::fixtures;
use common::TestDb;
use recall_echo::graph::gc::GcConfig;
use recall_echo::graph::types::NewRelationship;

#[tokio::test]
async fn gc_dry_run_no_mutations() {
    let db = TestDb::new().await;
    let entities = fixtures::simple_entities();
    let rels = fixtures::simple_relationships();

    for e in &entities {
        db.graph.add_entity(e.clone()).await.unwrap();
    }
    for r in &rels {
        db.graph.add_relationship(r.clone()).await.unwrap();
    }

    let before = db.graph.stats().await.unwrap();

    let config = GcConfig {
        dry_run: true,
        ..Default::default()
    };
    let report = db.graph.run_gc(&config).await.unwrap();

    let after = db.graph.stats().await.unwrap();

    // Dry run should not delete anything
    assert_eq!(
        before.entity_count, after.entity_count,
        "entities unchanged"
    );
    assert_eq!(
        before.relationship_count, after.relationship_count,
        "relationships unchanged"
    );
    // Report should still exist
    let _ = report;
}

#[tokio::test]
async fn gc_execute_removes_low_confidence_relationship() {
    let db = TestDb::new().await;
    let entities = fixtures::simple_entities();

    for e in &entities {
        db.graph.add_entity(e.clone()).await.unwrap();
    }

    // Create a very low confidence relationship
    let weak_rel = NewRelationship {
        from_entity: "Rust".to_string(),
        to_entity: "Daniel".to_string(),
        rel_type: "WEAK_LINK".to_string(),
        description: Some("barely connected".to_string()),
        confidence: Some(0.05),
        source: Some("test".to_string()),
    };
    db.graph.add_relationship(weak_rel).await.unwrap();

    let before = db.graph.stats().await.unwrap();
    assert_eq!(before.relationship_count, 1);

    let config = GcConfig {
        dry_run: false,
        dead_confidence: 0.2,
        dead_min_age_days: 0, // Don't require age for this test
        stale_days: 0,
        stale_confidence: 0.5,
        protect_pipeline: true,
    };
    let _report = db.graph.run_gc(&config).await.unwrap();

    let after = db.graph.stats().await.unwrap();
    // The weak relationship should have been removed (or at minimum flagged)
    // Note: GC behavior depends on age checks — if the rel was just created,
    // dead_min_age_days=0 should allow removal
    assert!(
        after.relationship_count <= before.relationship_count,
        "GC execute should not increase relationships"
    );
}

#[tokio::test]
async fn gc_protects_pipeline_entities() {
    let db = TestDb::new().await;

    // Create a pipeline-linked entity
    let pipeline_entity = recall_echo::graph::types::NewEntity {
        name: "Learning Thread".to_string(),
        entity_type: recall_echo::graph::types::EntityType::Thread,
        abstract_text: "A thought in development".to_string(),
        overview: None,
        content: None,
        attributes: Some(serde_json::json!({"pipeline_stage": "thoughts"})),
        source: Some("pipeline:learning".to_string()),
    };
    db.graph.add_entity(pipeline_entity).await.unwrap();

    let config = GcConfig {
        dry_run: false,
        protect_pipeline: true,
        ..Default::default()
    };
    let _report = db.graph.run_gc(&config).await.unwrap();

    // Pipeline entity should survive
    let found = db.graph.get_entity("Learning Thread").await.unwrap();
    assert!(
        found.is_some(),
        "pipeline entity should be protected from GC"
    );
}

#[tokio::test]
async fn gc_on_empty_graph() {
    let db = TestDb::new().await;

    let config = GcConfig::default();
    let report = db.graph.run_gc(&config).await.unwrap();

    // Should complete without error on empty graph
    let _ = report;
    let stats = db.graph.stats().await.unwrap();
    assert_eq!(stats.entity_count, 0);
}