lorefs 0.1.0

A lightweight, high-performance Rust native SDK for File-First Agent Memory.
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

use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use crate::error::{MemoryError, Result};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoreConfig {
    pub base_dir: PathBuf,
    pub git_enabled: bool,
    pub pinned_files: Vec<String>,
    pub reflection_every_n_turns: usize,
    pub auto_commit: bool,
}

impl LoreConfig {
    pub fn builder() -> LoreConfigBuilder {
        LoreConfigBuilder::default()
    }
}

pub struct LoreConfigBuilder {
    base_dir: Option<PathBuf>,
    git_enabled: bool,
    pinned_files: Vec<String>,
    reflection_every_n_turns: usize,
    auto_commit: bool,
}

impl Default for LoreConfigBuilder {
    fn default() -> Self {
        Self {
            base_dir: Some(PathBuf::from(".lore")),
            git_enabled: true,
            pinned_files: vec![
                "system/persona.md".into(),
                "system/preferences.md".into(),
                "MEMORY.md".into(),
            ],
            reflection_every_n_turns: 30,
            auto_commit: true,
        }
    }
}

impl LoreConfigBuilder {
    pub fn base_dir<P: Into<PathBuf>>(mut self, path: P) -> Self {
        self.base_dir = Some(path.into());
        self
    }

    pub fn git_enabled(mut self, enabled: bool) -> Self {
        self.git_enabled = enabled;
        self
    }

    pub fn pinned_files(mut self, files: Vec<String>) -> Self {
        self.pinned_files = files;
        self
    }

    pub fn reflection_every_n_turns(mut self, n: usize) -> Self {
        self.reflection_every_n_turns = n;
        self
    }

    pub fn auto_commit(mut self, enabled: bool) -> Self {
        self.auto_commit = enabled;
        self
    }

    pub fn build(self) -> Result<LoreConfig> {
        Ok(LoreConfig {
            base_dir: self.base_dir.ok_or_else(|| MemoryError::Config("Base directory is required".into()))?,
            git_enabled: self.git_enabled,
            pinned_files: self.pinned_files,
            reflection_every_n_turns: self.reflection_every_n_turns,
            auto_commit: self.auto_commit,
        })
    }
}