second-brain-core 0.13.4

Core library for second-brain: SQLite storage with vector and lexical indexes, BGE embeddings, and hybrid retrieval
Documentation
use std::collections::HashMap;

use anyhow::Result;
use chrono::{DateTime, Utc};
use rusqlite::{OptionalExtension, Transaction, params_from_iter};
use uuid::Uuid;

use super::SqliteStore;
use crate::schema::{Memory, Relation, RelationType, Tier};

const MAX_CHAIN: usize = 64;

#[derive(Debug, Clone)]
pub struct Corrected {
    pub memory: Memory,
    /// The replacement id was already this memory's replacement, so nothing
    /// was written: a queued call replayed after it landed.
    pub replayed: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CorrectRefusal {
    NotFound,
    Retired,
    AlreadyCorrected {
        current: Uuid,
    },
    /// The replacement's client id names another memory or a deleted one.
    IdTaken,
}

impl SqliteStore {
    /// Stores `replacement` in the corrected memory's project and scope, supersedes the
    /// old memory with it and links them by a `supersedes` relation carrying
    /// `evidence`, in one transaction. The sync log gets the replacement's
    /// Create before the relation, so a peer never sees a dangling edge.
    pub fn correct_memory(
        &self,
        old_id: Uuid,
        mut replacement: Memory,
        evidence: &str,
    ) -> Result<Result<Corrected, CorrectRefusal>> {
        self.with_txn(|tx| {
            let Some(old) = Self::memory_on_tx(tx, old_id)? else {
                return Ok(Err(CorrectRefusal::NotFound));
            };
            if old.superseded_by == Some(replacement.id) {
                let memory = Self::memory_on_tx(tx, replacement.id)?.unwrap_or(replacement);
                return Ok(Ok(Corrected {
                    memory,
                    replayed: true,
                }));
            }
            if let Some(by) = old.superseded_by {
                return Ok(Err(CorrectRefusal::AlreadyCorrected {
                    current: Self::current_replacement(tx, by)?,
                }));
            }
            if old.tier == Tier::Archived {
                return Ok(Err(CorrectRefusal::Retired));
            }
            if Self::memory_on_tx(tx, replacement.id)?.is_some()
                || Self::tombstoned(tx, replacement.id)?
            {
                return Ok(Err(CorrectRefusal::IdTaken));
            }

            replacement.project_path = old.project_path.clone();
            replacement.scope = old.scope;
            self.store_memory_on_tx(tx, &replacement)?;
            self.supersede_on_tx(tx, old_id, replacement.id)?;
            self.store_relation_on_tx(
                tx,
                &Relation {
                    from_id: replacement.id,
                    to_id: old_id,
                    relation_type: RelationType::Supersedes,
                    strength: 1.0,
                    context: Some(evidence.to_string()),
                },
            )?;
            Ok(Ok(Corrected {
                memory: replacement,
                replayed: false,
            }))
        })
    }

    /// When each of `ids` that replaced another memory was written, keyed by
    /// id; ids that replaced nothing are absent.
    pub fn corrected_at(&self, ids: &[Uuid]) -> Result<HashMap<Uuid, DateTime<Utc>>> {
        if ids.is_empty() {
            return Ok(HashMap::new());
        }
        let marks = vec!["?"; ids.len()].join(",");
        let conn = self.reader();
        let mut stmt = conn.prepare(&format!(
            "SELECT DISTINCT m.id, m.created_at FROM relations r \
             JOIN memories m ON m.id = r.from_id \
             WHERE r.relation_type = 'supersedes' AND r.from_id IN ({marks})"
        ))?;
        let rows = stmt.query_map(params_from_iter(ids.iter().map(Uuid::to_string)), |r| {
            Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
        })?;
        let mut out = HashMap::new();
        for row in rows {
            let (id, at) = row?;
            if let (Ok(id), Ok(at)) = (Uuid::parse_str(&id), DateTime::parse_from_rfc3339(&at)) {
                out.insert(id, at.with_timezone(&Utc));
            }
        }
        Ok(out)
    }

    /// The evidence recorded when `replacement` corrected another memory.
    pub fn correction_evidence(&self, replacement: Uuid) -> Result<Option<String>> {
        let conn = self.reader();
        let context: Option<Option<String>> = conn
            .query_row(
                "SELECT context FROM relations WHERE from_id = ?1 AND relation_type = 'supersedes'",
                [replacement.to_string()],
                |r| r.get(0),
            )
            .optional()?;
        Ok(context.flatten())
    }

    fn current_replacement(tx: &Transaction<'_>, mut id: Uuid) -> Result<Uuid> {
        for _ in 0..MAX_CHAIN {
            match Self::memory_on_tx(tx, id)?.and_then(|m| m.superseded_by) {
                Some(next) => id = next,
                None => break,
            }
        }
        Ok(id)
    }
}