lunaris-memory 0.8.0

Lunaris agent memory engine — umbrella crate (Apache-2.0)
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

//! Plan 13-01 — re-export shim for the canonical audit types that now live in
//! `lunaris-core::audit`. This file preserves the old `use crate::audit::*`
//! import surface so `crates/lunaris/src/forget.rs` and every downstream test
//! keeps compiling without modification.
//!
//! The actual type definitions, serde shape, and `publish_audit_event` helper
//! are at `crates/lunaris-core/src/audit.rs`. Wire-shape byte-identity is
//! locked by the fixture-parity test at
//! `crates/lunaris-core/tests/audit_event_fixture_parity.rs`.
//!
//! ## Bridge `From` impls
//!
//! `ForgetReceipt` (at `crates/lunaris/src/forget.rs`) uses the domain types
//! `ForgetTarget` / `ScopeSpec` / `IndexKind`. The canonical enum in
//! `lunaris-core::audit` uses local mirror types (`ForgetTargetData`,
//! `ScopeSpecData`, `IndexKindData`, `ForgetReceiptData`) to stay leaf-pure.
//! The `From<&ForgetReceipt> for ForgetReceiptData` impl below does the
//! field-by-field map so `Lunaris::forget` can keep passing a `ForgetReceipt`
//! to the typed helper via `.into()`.

pub use lunaris_core::audit::{
    AUDIT_TOPIC, AuditEvent, FactIdData, ForgetReceiptData, ForgetTargetData, IndexKindData,
    PublishError, Publisher, ScopeSpecData, publish_audit_event,
};

use crate::forget::{ForgetReceipt, ForgetTarget, IndexKind, ScopeSpec};

impl From<&ForgetTarget> for ForgetTargetData {
    fn from(t: &ForgetTarget) -> Self {
        match t {
            ForgetTarget::Id(u) => ForgetTargetData::Id(*u),
            ForgetTarget::Scope(s) => ForgetTargetData::Scope(s.into()),
            ForgetTarget::Before(h) => ForgetTargetData::Before(*h),
        }
    }
}

impl From<&ScopeSpec> for ScopeSpecData {
    fn from(s: &ScopeSpec) -> Self {
        match s {
            ScopeSpec::BySource(v) => ScopeSpecData::BySource(v.clone()),
            ScopeSpec::ByMetadata(k, v) => ScopeSpecData::ByMetadata(k.clone(), v.clone()),
            ScopeSpec::ByEpisode(u) => ScopeSpecData::ByEpisode(*u),
        }
    }
}

impl From<&IndexKind> for IndexKindData {
    fn from(i: &IndexKind) -> Self {
        match i {
            IndexKind::Kv => IndexKindData::Kv,
            IndexKind::Vector => IndexKindData::Vector,
            IndexKind::Graph => IndexKindData::Graph,
        }
    }
}

impl From<&ForgetReceipt> for ForgetReceiptData {
    fn from(r: &ForgetReceipt) -> Self {
        Self {
            target: (&r.target).into(),
            indices_affected: r.indices_affected.iter().map(Into::into).collect(),
            rows_written: r.rows_written,
            rows_deleted: r.rows_deleted,
            audit_lsn: r.audit_lsn,
            preview: r.preview,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::forget::{ForgetTarget, IndexKind, ScopeSpec};
    use lunaris_core::storage::types::Lsn;
    use ulid::Ulid;

    #[test]
    fn re_exported_audit_topic_matches() {
        assert_eq!(AUDIT_TOPIC, "__lunaris_audit__");
    }

    #[test]
    fn forget_receipt_bridge_round_trips_every_target_variant() {
        let lsn = Lsn { wall_ms: 1, counter: 2 };
        // Id variant
        let id = Ulid::new();
        let r1 = ForgetReceipt {
            target: ForgetTarget::Id(id),
            indices_affected: vec![IndexKind::Kv, IndexKind::Vector, IndexKind::Graph],
            matched: 7,
            rows_written: 3,
            rows_deleted: 4,
            audit_lsn: lsn,
            preview: true,
        };
        let d1: ForgetReceiptData = (&r1).into();
        assert_eq!(d1.target, ForgetTargetData::Id(id));
        assert_eq!(
            d1.indices_affected,
            vec![IndexKindData::Kv, IndexKindData::Vector, IndexKindData::Graph]
        );
        assert_eq!(d1.rows_written, 3);
        assert_eq!(d1.rows_deleted, 4);
        assert!(d1.preview);

        // Scope::BySource
        let r2 = ForgetReceipt {
            target: ForgetTarget::Scope(ScopeSpec::BySource("src".into())),
            ..r1.clone()
        };
        let d2: ForgetReceiptData = (&r2).into();
        assert_eq!(d2.target, ForgetTargetData::Scope(ScopeSpecData::BySource("src".into())));

        // Scope::ByMetadata
        let r3 = ForgetReceipt {
            target: ForgetTarget::Scope(ScopeSpec::ByMetadata("k".into(), "v".into())),
            ..r1.clone()
        };
        let d3: ForgetReceiptData = (&r3).into();
        assert_eq!(
            d3.target,
            ForgetTargetData::Scope(ScopeSpecData::ByMetadata("k".into(), "v".into()))
        );

        // Scope::ByEpisode
        let r4 =
            ForgetReceipt { target: ForgetTarget::Scope(ScopeSpec::ByEpisode(id)), ..r1.clone() };
        let d4: ForgetReceiptData = (&r4).into();
        assert_eq!(d4.target, ForgetTargetData::Scope(ScopeSpecData::ByEpisode(id)));
    }
}