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

use super::TextSpan;
use crate::{
    domain::{Confidence, validate_text},
    error::Result,
    time::Timestamp,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ExtractedRelation {
    pub local_id: String,
    pub source: String,
    pub relation: String,
    pub target: String,
    pub confidence: Confidence,
    pub valid_from: Option<Timestamp>,
    pub valid_until: Option<Timestamp>,
    pub span: Option<TextSpan>,
}

impl ExtractedRelation {
    /// Creates a provider-local relation between two mentions.
    ///
    /// # Errors
    ///
    /// Rejects invalid identifiers or relation text.
    pub fn new(
        local_id: impl Into<String>,
        source: impl Into<String>,
        relation: impl Into<String>,
        target: impl Into<String>,
        confidence: Confidence,
    ) -> Result<Self> {
        let relation = Self {
            local_id: local_id.into(),
            source: source.into(),
            relation: relation.into(),
            target: target.into(),
            confidence,
            valid_from: None,
            valid_until: None,
            span: None,
        };
        relation.validate()?;
        Ok(relation)
    }

    #[must_use]
    pub const fn valid_from(mut self, value: Timestamp) -> Self {
        self.valid_from = Some(value);
        self
    }

    #[must_use]
    pub const fn valid_until(mut self, value: Timestamp) -> Self {
        self.valid_until = Some(value);
        self
    }

    #[must_use]
    pub const fn with_span(mut self, span: TextSpan) -> Self {
        self.span = Some(span);
        self
    }

    pub(crate) fn validate(&self) -> Result<()> {
        validate_text("extracted_relation.local_id", &self.local_id)?;
        validate_text("extracted_relation.source", &self.source)?;
        validate_text("extracted_relation.relation", &self.relation)?;
        validate_text("extracted_relation.target", &self.target)
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ExtractionOutput {
    pub entities: Vec<super::ExtractedEntity>,
    pub relations: Vec<ExtractedRelation>,
}