second-brain-core 0.13.2

Core library for second-brain: SQLite storage with vector and lexical indexes, BGE embeddings, and hybrid retrieval
Documentation
use second_brain_core::{
    schema::{Memory, MemoryType},
    sqlite_store::SqliteStore,
    store::{Store, StoreAdmin},
};

fn memory(content: &str) -> Memory {
    Memory::new(
        content.to_string(),
        MemoryType::Semantic,
        "test".to_string(),
        String::new(),
    )
}

#[test]
fn record_access_adds_no_log_row() {
    let store = SqliteStore::in_memory("test-machine-access".to_string()).unwrap();
    let m = memory("access bump test");
    store.store_memory(&m).unwrap();

    assert_eq!(
        store.sync_log_since(0).unwrap().len(),
        1,
        "store_memory must produce exactly one sync_log row"
    );

    for _ in 0..3 {
        let mut bumped = m.clone();
        bumped.access_count += 1;
        store.record_access(&bumped).unwrap();
    }

    assert_eq!(
        store.sync_log_since(0).unwrap().len(),
        1,
        "record_access must not append any sync_log rows"
    );
}

#[test]
fn write_creates_node_and_log_row() {
    let store = SqliteStore::in_memory("test-machine".to_string()).unwrap();
    let m = memory("sync log test");
    store.store_memory(&m).unwrap();

    let machine_id = store.machine_id().to_string();
    let entries = store.sync_log_since(0).unwrap();
    assert_eq!(entries.len(), 1, "expected exactly one sync_log row");

    let entry = &entries[0];
    assert_eq!(entry.origin_machine_id, machine_id);
    assert!(
        entry.origin_seq >= second_brain_core::sqlite_store::NEW_LAYOUT_MIN,
        "an own record carries an incarnation key"
    );
    assert_eq!(entry.id, format!("{}:{}", machine_id, entry.origin_seq));

    assert_eq!(store.memory_count().unwrap(), 1);
}

#[test]
fn sequential_writes_raise_local_seq() {
    let store = SqliteStore::in_memory("test-machine-seq".to_string()).unwrap();
    store.store_memory(&memory("first memory")).unwrap();
    store.store_memory(&memory("second memory")).unwrap();

    let entries = store.sync_log_since(0).unwrap();
    assert_eq!(entries.len(), 2, "expected two sync_log rows");
    assert!(entries[1].local_seq > entries[0].local_seq);
}

#[test]
fn sync_log_page_bounds_and_orders() {
    let store = SqliteStore::in_memory("test-machine-page".to_string()).unwrap();
    for i in 0..5 {
        store.store_memory(&memory(&format!("memory {i}"))).unwrap();
    }

    let all: Vec<i64> = store
        .sync_log_since(0)
        .unwrap()
        .iter()
        .map(|e| e.local_seq)
        .collect();
    let page = store.sync_log_page(all[0] as u64, Some(2)).unwrap();
    assert_eq!(
        page.iter().map(|e| e.local_seq).collect::<Vec<_>>(),
        all[1..3]
    );
    assert_eq!(store.max_sync_seq().unwrap(), all[4] as u64);
}

#[test]
fn paged_export_cursor_covers_every_entry_exactly_once() {
    let store = SqliteStore::in_memory("test-machine-cursor".to_string()).unwrap();
    for i in 0..25 {
        store.store_memory(&memory(&format!("memory {i}"))).unwrap();
    }

    const BATCH: usize = 4;
    let mut cursor = 0u64;
    let mut seen: Vec<u64> = Vec::new();
    loop {
        let page = store.sync_log_page(cursor, Some(BATCH)).unwrap();
        if page.is_empty() {
            break;
        }
        let count = page.len();
        cursor = page.iter().map(|e| e.local_seq as u64).max().unwrap();
        seen.extend(page.iter().map(|e| e.local_seq as u64));
        if count < BATCH {
            break;
        }
    }

    let full: Vec<u64> = store
        .sync_log_since(0)
        .unwrap()
        .iter()
        .map(|e| e.local_seq as u64)
        .collect();

    assert_eq!(
        seen, full,
        "advancing the cursor by each page's max local_seq must yield the unpaged log exactly"
    );
    assert_eq!(seen.len(), 25);
}

fn to_record(
    entry: &second_brain_core::schema::SyncEntry,
) -> second_brain_core::schema::SyncRecord {
    second_brain_core::schema::SyncRecord {
        local_seq: entry.local_seq as u64,
        origin_machine_id: entry.origin_machine_id.clone(),
        origin_seq: entry.origin_seq as u64,
        op: entry.op,
        node_type: entry.node_type,
        node_id: entry.node_id.clone(),
        timestamp: entry.timestamp,
        data: entry
            .data
            .as_deref()
            .map(|d| serde_json::from_str(d).unwrap()),
    }
}

fn embedded(content: &str) -> Memory {
    let mut m = memory(content);
    m.embedding = vec![0.5; 384];
    m
}

#[test]
fn archive_replicates_tier_and_evicts_on_the_peer() {
    use second_brain_core::schema::{SyncOp, Tier};
    use second_brain_core::store::ApplyOutcome;

    let a = SqliteStore::in_memory("machine-a".to_string()).unwrap();
    let b = SqliteStore::in_memory("machine-b".to_string()).unwrap();
    let m = embedded("archive me on both sides");
    a.store_memory(&m).unwrap();
    for entry in a.sync_log_since(0).unwrap() {
        b.apply_record(&to_record(&entry)).unwrap();
    }
    let before = b.get_memory(m.id).unwrap().unwrap();
    assert_eq!(before.tier, Tier::Hot);
    let outbox_before = b.outbox_after(0).unwrap().len();

    let seq = a.max_sync_seq().unwrap();
    a.archive_memory(m.id).unwrap();

    let local = a.get_memory_with_embedding(m.id).unwrap().unwrap();
    assert_eq!(local.tier, Tier::Archived);
    assert!(
        local.archived_segment.is_none(),
        "local cold rows carry no segment"
    );
    assert_eq!(local.content, m.content, "content stays intact");
    assert_eq!(local.embedding.len(), 384, "embedding stays intact");
    assert!(
        local.updated_at > before.updated_at,
        "archive must bump updated_at"
    );
    let last = a.outbox_after(0).unwrap().pop().unwrap();
    assert_eq!((last.memory_id, last.op.as_str()), (m.id, "delete"));

    let entries = a.sync_log_since(seq).unwrap();
    assert_eq!(entries.len(), 1);
    assert_eq!(entries[0].op, SyncOp::Update);
    let outcome = b.apply_record(&to_record(&entries[0])).unwrap();
    assert_eq!(outcome, ApplyOutcome::Updated);

    let peer = b.get_memory_with_embedding(m.id).unwrap().unwrap();
    assert_eq!(peer.tier, Tier::Archived);
    assert_eq!(peer.embedding.len(), 384, "the peer keeps its embedding");
    let peer_outbox = b.outbox_after(0).unwrap();
    assert_eq!(peer_outbox.len(), outbox_before + 1);
    assert_eq!(peer_outbox.last().unwrap().memory_id, m.id);
    assert_eq!(
        b.indexable_count().unwrap(),
        0,
        "an archived row must leave the peer's indexable set"
    );
}

#[test]
fn supersede_replicates_to_the_peer() {
    use second_brain_core::schema::SyncOp;

    let a = SqliteStore::in_memory("machine-a".to_string()).unwrap();
    let b = SqliteStore::in_memory("machine-b".to_string()).unwrap();
    let old = embedded("first version");
    let new = embedded("second version");
    a.store_memory(&old).unwrap();
    a.store_memory(&new).unwrap();
    for entry in a.sync_log_since(0).unwrap() {
        b.apply_record(&to_record(&entry)).unwrap();
    }

    let seq = a.max_sync_seq().unwrap();
    a.supersede_memory(old.id, new.id).unwrap();

    let entries = a.sync_log_since(seq).unwrap();
    assert_eq!(entries.len(), 1);
    assert_eq!(entries[0].op, SyncOp::Update);
    b.apply_record(&to_record(&entries[0])).unwrap();

    let peer = b.get_memory_with_embedding(old.id).unwrap().unwrap();
    assert_eq!(peer.superseded_by, Some(new.id));
    assert_eq!(peer.embedding.len(), 384);
    assert_eq!(b.indexable_count().unwrap(), 1);
}