weavatrix-memory 0.3.2

Event-sourced bitemporal evidence memory and budgeted context retrieval for coding agents
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

use crate::{
    error::{MemoryError, Result},
    id::{AgentId, EventId, SessionId, StreamId},
    time::Timestamp,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NewEvent<E> {
    pub id: EventId,
    pub event_type: String,
    pub occurred_at: Timestamp,
    pub recorded_at: Timestamp,
    pub agent_id: AgentId,
    pub session_id: SessionId,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation_id: Option<EventId>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub causation_id: Option<EventId>,
    pub payload: E,
}

impl<E> NewEvent<E> {
    /// Creates an uncommitted event with caller-controlled time and identity.
    ///
    /// # Errors
    ///
    /// Rejects an empty event type or surrounding whitespace.
    pub fn new(
        id: EventId,
        event_type: impl Into<String>,
        occurred_at: Timestamp,
        recorded_at: Timestamp,
        agent_id: AgentId,
        session_id: SessionId,
        payload: E,
    ) -> Result<Self> {
        let event_type = event_type.into();
        if event_type.is_empty() || event_type.trim() != event_type {
            return Err(MemoryError::InvalidValue {
                field: "event_type",
                reason: "must be non-empty without surrounding whitespace",
            });
        }
        if occurred_at > recorded_at {
            return Err(MemoryError::InvalidValue {
                field: "occurred_at",
                reason: "must not be later than recorded_at",
            });
        }
        Ok(Self {
            id,
            event_type,
            occurred_at,
            recorded_at,
            agent_id,
            session_id,
            correlation_id: None,
            causation_id: None,
            payload,
        })
    }

    #[must_use]
    pub fn correlated_with(mut self, id: EventId) -> Self {
        self.correlation_id = Some(id);
        self
    }

    #[must_use]
    pub fn caused_by(mut self, id: EventId) -> Self {
        self.causation_id = Some(id);
        self
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EventMetadata {
    pub id: EventId,
    pub stream_id: StreamId,
    pub stream_version: u64,
    pub global_position: u64,
    pub event_type: String,
    pub occurred_at: Timestamp,
    pub recorded_at: Timestamp,
    pub agent_id: AgentId,
    pub session_id: SessionId,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation_id: Option<EventId>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub causation_id: Option<EventId>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StoredEvent<E> {
    pub metadata: EventMetadata,
    pub payload: E,
}