second-brain-core 0.9.0

Core library for second-brain: KuzuDB graph storage, BGE embeddings, and weighted query engine
Documentation
use anyhow::Result;
use uuid::Uuid;

use super::Indexes;
use crate::sqlite_store::SqliteStore;

impl Indexes {
    /// Apply every outbox row past the watermark to both indexes, persist
    /// them, then advance the watermark and prune. Persisting BEFORE the
    /// watermark moves gives at-least-once delivery across a crash; replay is
    /// safe because both index upserts are delete-then-add.
    pub fn drain(&mut self, store: &SqliteStore) -> Result<usize> {
        self.require_writable()?;
        let watermark = store.index_watermark()?;
        let rows = store.outbox_after(watermark)?;
        let Some(last) = rows.last().map(|r| r.seq) else {
            return Ok(0);
        };
        let applied = rows.len();
        for row in rows {
            self.apply(store, row.memory_id)?;
        }
        self.persist()?;
        store.set_index_watermark(last)?;
        store.prune_outbox(last)?;
        Ok(applied)
    }

    /// The row's current store state decides the action, not the outbox op:
    /// a memory that is gone, superseded, archived, or embedding-less leaves
    /// the vector index, so stale ops replayed after a crash converge on the
    /// same end state.
    fn apply(&mut self, store: &SqliteStore, memory_id: Uuid) -> Result<()> {
        match store.memory_for_indexing(memory_id)? {
            Some(row) if row.hot => {
                if row.embedding.len() == super::EMBEDDING_DIM {
                    let key = store.vec_key(memory_id)?;
                    self.vector_mut().upsert(key, &row.embedding)?;
                } else if let Some(key) = store.existing_vec_key(memory_id)? {
                    self.vector_mut().remove(key)?;
                    store.delete_vec_key(memory_id)?;
                }
                self.lexical_mut().upsert(memory_id, &row.body)?;
                Ok(())
            }
            _ => {
                if let Some(key) = store.existing_vec_key(memory_id)? {
                    self.vector_mut().remove(key)?;
                    store.delete_vec_key(memory_id)?;
                }
                self.lexical_mut().remove(memory_id)?;
                Ok(())
            }
        }
    }

    /// Recreate both indexes from the store alone. Embeddings are stored in
    /// SQLite precisely so this never re-embeds.
    pub fn rebuild(&mut self, store: &SqliteStore) -> Result<usize> {
        self.require_writable()?;
        let snapshot_seq = store.max_outbox_seq()?;
        self.vector_mut().reset()?;
        self.lexical_mut().reset()?;
        let rows = store.all_indexable()?;
        let count = rows.len();
        for (memory_id, embedding, body) in rows {
            if embedding.len() == super::EMBEDDING_DIM {
                let key = store.vec_key(memory_id)?;
                self.vector_mut().upsert(key, &embedding)?;
            }
            self.lexical_mut().upsert(memory_id, &body)?;
        }
        self.persist()?;
        store.set_index_watermark(snapshot_seq)?;
        store.prune_outbox(snapshot_seq)?;
        Ok(count)
    }
}