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

use super::{EntityLinker, scoring::exact_key};
use crate::{
    domain::MemoryView,
    error::{MemoryError, Result},
    extraction::key::normalized,
};
use std::{collections::HashMap, hash::Hash};

#[derive(Debug, Clone)]
pub(super) enum IndexBucket {
    One(usize),
    Many(Vec<usize>),
}

impl EntityLinker {
    /// Builds reusable exact-match indexes from one temporal memory view.
    ///
    /// # Errors
    ///
    /// Rejects invalid catalog nodes, duplicate identifiers, and malformed
    /// aliases or external identifiers.
    pub fn from_view(view: &MemoryView) -> Result<Self> {
        let mut linker = Self {
            nodes: Vec::with_capacity(view.nodes.len()),
            by_id: HashMap::with_capacity(view.nodes.len()),
            by_label: HashMap::with_capacity(view.nodes.len()),
            by_alias: HashMap::with_capacity(view.nodes.len()),
            by_external_id: HashMap::with_capacity(view.nodes.len()),
        };
        for (index, node) in view.nodes.iter().enumerate() {
            node.validate()?;
            if linker.by_id.insert(node.id.clone(), index).is_some() {
                return Err(MemoryError::InvalidValue {
                    field: "entity_linker.catalog",
                    reason: "entity identifiers must be unique",
                });
            }
            let kind = normalized(&node.kind);
            linker.nodes.push(super::CatalogEntity {
                id: node.id.clone(),
                kind: kind.clone(),
                repository: node.repository.clone(),
                branch: node.branch.clone(),
            });
            insert_index(
                &mut linker.by_label,
                (kind.clone(), normalized(&node.label)),
                index,
            );
            for (key, value) in &node.attributes {
                if key == "alias" || key.starts_with("alias.") {
                    crate::domain::validate_text("entity_linker.alias", value)?;
                    insert_index(
                        &mut linker.by_alias,
                        (kind.clone(), normalized(value)),
                        index,
                    );
                } else if key.starts_with("external_id.") {
                    crate::domain::validate_text("entity_linker.external_id", value)?;
                    insert_index(
                        &mut linker.by_external_id,
                        (kind.clone(), key.clone(), exact_key(value)),
                        index,
                    );
                }
            }
        }
        Ok(linker)
    }
}

fn insert_index<K: Eq + Hash>(index: &mut HashMap<K, IndexBucket>, key: K, value: usize) {
    match index.entry(key) {
        std::collections::hash_map::Entry::Vacant(entry) => {
            entry.insert(IndexBucket::One(value));
        }
        std::collections::hash_map::Entry::Occupied(mut entry) => match entry.get_mut() {
            IndexBucket::One(first) => {
                let first = *first;
                entry.insert(IndexBucket::Many(vec![first, value]));
            }
            IndexBucket::Many(values) => values.push(value),
        },
    }
}