consciousness/src/hippocampus/memory.rs

// hippocampus/memory.rs — In-memory view of a graph node
//
// MemoryNode is a lightweight representation of a loaded node:
// key, content, links, version, weight. Used by the agent for
// context tracking and by the CLI for rendering.

use super::store::Store;

/// A memory node loaded into the agent's working memory.
#[derive(Debug, Clone)]
pub struct MemoryNode {
    pub key: String,
    pub content: String,
    pub links: Vec<(String, f32)>,  // (target_key, strength)
    pub version: u32,
    pub weight: f32,
}

impl MemoryNode {
    /// Load a node from the store by key.
    pub fn load(key: &str) -> Option<Self> {
        let store = Store::load().ok()?;
        Self::from_store(&store, key)
    }

    /// Load from an already-open store.
    pub fn from_store(store: &Store, key: &str) -> Option<Self> {
        let node = store.nodes.get(key)?;

        let mut neighbors: std::collections::HashMap<&str, f32> = std::collections::HashMap::new();
        for r in &store.relations {
            if r.deleted { continue; }
            if r.source_key == key {
                let e = neighbors.entry(&r.target_key).or_insert(0.0);
                *e = e.max(r.strength);
            } else if r.target_key == key {
                let e = neighbors.entry(&r.source_key).or_insert(0.0);
                *e = e.max(r.strength);
            }
        }

        let mut links: Vec<(String, f32)> = neighbors.into_iter()
            .map(|(k, s)| (k.to_string(), s))
            .collect();
        links.sort_by(|a, b| b.1.total_cmp(&a.1));

        Some(MemoryNode {
            key: key.to_string(),
            content: node.content.clone(),
            links,
            version: node.version,
            weight: node.weight,
        })
    }

    /// Render for inclusion in the context window.
    pub fn render(&self) -> String {
        let mut out = self.content.clone();

        // Footer: links not already referenced inline
        let footer: Vec<&(String, f32)> = self.links.iter()
            .filter(|(target, _)| !self.content.contains(target.as_str()))
            .collect();

        if !footer.is_empty() {
            let total = footer.len();
            out.push_str("\n\n---\nLinks:");
            for (target, strength) in footer.iter().take(15) {
                out.push_str(&format!("\n  ({:.2})  `{}`", strength, target));
            }
            if total > 15 {
                out.push_str(&format!("\n  ... and {} more (memory_links({{\"{}\"}}))",
                    total - 15, self.key));
            }
        }
        out
    }
}