scone-core 0.2.1

The Scone memory engine: episodic + temporal-fact dual store with hybrid recall, offline-first
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#![allow(clippy::unwrap_used)]
use scone_core::embed::HashEmbedder;
use scone_core::{Engine, IngestInput, IngestOutcome, auth};

fn engine(dir: &std::path::Path) -> Engine {
    Engine::open(dir, Box::new(HashEmbedder::new(64))).unwrap()
}

#[test]
fn ingest_note_stores_episode_chunks_and_bumps_revision() {
    let dir = tempfile::tempdir().unwrap();
    let mut e = engine(dir.path());
    let space = auth::resolve(&mut e, "default", true).unwrap();
    let before = e.space_revision(&space).unwrap();
    let out = e
        .ingest(
            &space,
            IngestInput::Note {
                text: "remember: the borrow checker is a friend".into(),
            },
        )
        .unwrap();
    let IngestOutcome::Ingested { episode_id, chunks } = out else {
        panic!("expected Ingested, got {out:?}");
    };
    assert!(chunks >= 1);
    assert_eq!(e.space_revision(&space).unwrap(), before + 1);
    let (content, kind) = e.episode_content(episode_id).unwrap();
    assert_eq!(content, "remember: the borrow checker is a friend");
    assert_eq!(kind, "note");
}

#[test]
fn duplicate_note_is_deduplicated_and_revision_unchanged() {
    let dir = tempfile::tempdir().unwrap();
    let mut e = engine(dir.path());
    let space = auth::resolve(&mut e, "default", true).unwrap();
    let first = e
        .ingest(
            &space,
            IngestInput::Note {
                text: "same".into(),
            },
        )
        .unwrap();
    let IngestOutcome::Ingested { episode_id, .. } = first else {
        panic!("expected Ingested");
    };
    let rev = e.space_revision(&space).unwrap();
    let second = e
        .ingest(
            &space,
            IngestInput::Note {
                text: "same".into(),
            },
        )
        .unwrap();
    assert!(matches!(
        second,
        IngestOutcome::Deduplicated { episode_id: id } if id == episode_id
    ));
    assert_eq!(e.space_revision(&space).unwrap(), rev);
}

#[test]
fn same_content_in_other_space_is_not_a_duplicate() {
    let dir = tempfile::tempdir().unwrap();
    let mut e = engine(dir.path());
    let a = auth::resolve(&mut e, "a", true).unwrap();
    let b = auth::resolve(&mut e, "b", true).unwrap();
    e.ingest(
        &a,
        IngestInput::Note {
            text: "same".into(),
        },
    )
    .unwrap();
    let out = e
        .ingest(
            &b,
            IngestInput::Note {
                text: "same".into(),
            },
        )
        .unwrap();
    assert!(matches!(out, IngestOutcome::Ingested { .. }));
}

#[test]
fn file_ingest_reads_utf8_and_rejects_binary_typed() {
    let dir = tempfile::tempdir().unwrap();
    let mut e = engine(dir.path());
    let space = auth::resolve(&mut e, "default", true).unwrap();
    let good = dir.path().join("note.md");
    std::fs::write(&good, "# heading\n\nbody text").unwrap();
    let out = e
        .ingest(&space, IngestInput::File { path: good.clone() })
        .unwrap();
    assert!(matches!(out, IngestOutcome::Ingested { .. }));
    let bad = dir.path().join("blob.bin");
    std::fs::write(&bad, [0xff, 0xfe, 0x00, 0x9f]).unwrap();
    let err = e
        .ingest(&space, IngestInput::File { path: bad })
        .unwrap_err();
    assert!(matches!(err, scone_core::SconeError::InvalidInput(_)));
}

#[test]
fn empty_note_is_rejected_typed() {
    let dir = tempfile::tempdir().unwrap();
    let mut e = engine(dir.path());
    let space = auth::resolve(&mut e, "default", true).unwrap();
    let err = e
        .ingest(&space, IngestInput::Note { text: "".into() })
        .unwrap_err();
    assert!(matches!(err, scone_core::SconeError::InvalidInput(_)));
}

#[test]
fn chunk_target_is_tunable() {
    let dir = tempfile::tempdir().unwrap();
    let mut e = engine(dir.path());
    e.set_chunk_target(100);
    let space = auth::resolve(&mut e, "default", true).unwrap();
    let text = "para one is long enough to matter for chunking purposes here.\n\n\
para two is also long enough to matter for chunking purposes here.\n\n\
para three is likewise long enough to matter for chunking here.";
    let out = e
        .ingest(&space, IngestInput::Note { text: text.into() })
        .unwrap();
    let IngestOutcome::Ingested { chunks, .. } = out else {
        panic!()
    };
    assert!(
        chunks >= 2,
        "small target must split paragraphs, got {chunks}"
    );
}