mori-cli 0.1.0

mori — the git for cognition. Compile context with the Locus SDK and keep it in a per-repo SurrealKV file.
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

use std::fs;
use std::path::{Path, PathBuf};

use anyhow::{bail, Context, Result};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

pub const REPO_DIR: &str = ".mori";
const CONFIG_FILE: &str = "config.json";
const INDEX_FILE: &str = "index.json";
const STASH_FILE: &str = "stash.json";
const KV_DIR: &str = "kv";

#[derive(Debug, Clone)]
pub struct Repo {
    pub root: PathBuf,
}

impl Repo {
    pub fn mori_dir(&self) -> PathBuf {
        self.root.join(REPO_DIR)
    }

    pub fn config_path(&self) -> PathBuf {
        self.mori_dir().join(CONFIG_FILE)
    }

    pub fn index_path(&self) -> PathBuf {
        self.mori_dir().join(INDEX_FILE)
    }

    pub fn stash_path(&self) -> PathBuf {
        self.mori_dir().join(STASH_FILE)
    }

    /// Directory SurrealKV owns. The adapter opens `surrealkv://<this path>`.
    pub fn kv_dir(&self) -> PathBuf {
        self.mori_dir().join(KV_DIR)
    }

    pub fn load_config(&self) -> Result<RepoConfig> {
        let text = fs::read_to_string(self.config_path())
            .with_context(|| format!("reading {}", self.config_path().display()))?;
        Ok(serde_json::from_str(&text).context("parsing .mori/config.json")?)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepoConfig {
    pub version: u32,
    pub default_session: String,
    pub created_at: DateTime<Utc>,
}

/// Walk from `start` toward the filesystem root looking for `.mori/config.json`.
pub fn find_repo(start: &Path) -> Result<Repo> {
    let mut current = if start.is_dir() {
        start.to_path_buf()
    } else {
        start.parent().unwrap_or(start).to_path_buf()
    };

    loop {
        let candidate = current.join(REPO_DIR).join(CONFIG_FILE);
        if candidate.is_file() {
            return Ok(Repo { root: current });
        }
        if !current.pop() {
            break;
        }
    }

    bail!("not a mori repository (or any parent). Run `mori init` first");
}

/// Create `.mori` with a config and an empty index. Does not open the database.
pub fn init_repo(path: &Path, default_session: &str) -> Result<Repo> {
    let root = if path.as_os_str().is_empty() {
        std::env::current_dir()?
    } else {
        path.to_path_buf()
    };
    fs::create_dir_all(&root).with_context(|| format!("creating {}", root.display()))?;
    let root = root.canonicalize().unwrap_or(root);

    let repo = Repo { root: root.clone() };
    if repo.config_path().exists() {
        bail!(
            "mori repository already exists at {}",
            repo.mori_dir().display()
        );
    }

    let session = default_session.trim();
    if session.is_empty() {
        bail!("session name cannot be empty");
    }

    fs::create_dir_all(repo.mori_dir())?;
    let config = RepoConfig {
        version: 1,
        default_session: session.to_string(),
        created_at: Utc::now(),
    };
    fs::write(
        repo.config_path(),
        serde_json::to_string_pretty(&config)? + "\n",
    )?;
    fs::write(repo.index_path(), "{}\n")?;
    Ok(repo)
}