basemind 0.0.1

Code-map MCP server + scanner — content-addressed, Fjall-backed inverted index over tree-sitter outlines
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
139
140
141
142
143
144
145
146
147
148

//! Integration tests for the sha-keyed git cache.

use std::fs;
use std::path::Path;
use std::process::Command;

use basemind::git::Repo;
use basemind::git_cache::{GIT_CACHE_DIR, GitCache};
use tempfile::TempDir;

fn run(repo: &Path, args: &[&str]) {
    let status = Command::new("git")
        .args(args)
        .current_dir(repo)
        .env("GIT_AUTHOR_NAME", "t")
        .env("GIT_AUTHOR_EMAIL", "t@e.x")
        .env("GIT_COMMITTER_NAME", "t")
        .env("GIT_COMMITTER_EMAIL", "t@e.x")
        .status()
        .expect("git in PATH");
    assert!(status.success(), "git {args:?} failed");
}

fn three_commit_repo() -> TempDir {
    let dir = tempfile::tempdir().unwrap();
    let root = dir.path();
    run(root, &["init", "-q"]);
    run(root, &["config", "commit.gpgsign", "false"]);
    for i in 0..3 {
        fs::write(root.join("a.rs"), format!("pub fn v{i}() {{}}\n")).unwrap();
        run(root, &["add", "a.rs"]);
        run(root, &["commit", "-qm", &format!("rev {i}")]);
    }
    dir
}

#[test]
fn commit_files_cache_round_trip() {
    let dir = three_commit_repo();
    let root = dir.path();
    let basemind_dir = root.join(".basemind");
    fs::create_dir_all(&basemind_dir).unwrap();
    let cache = GitCache::open(&basemind_dir, 8, true).unwrap();
    let repo = Repo::discover(root).unwrap();
    let head = repo.resolve_rev("HEAD").unwrap();

    // First call: cold — populates RAM and disk.
    let first = cache.commit_files(&repo, &head).unwrap();
    assert!(!first.is_empty(), "expected commit_files to be non-empty");

    // Disk artifact exists at the sha-keyed path.
    let on_disk = basemind_dir
        .join(GIT_CACHE_DIR)
        .join("commit_files")
        .join(format!("{head}.msgpack"));
    assert!(on_disk.exists(), "commit_files disk entry missing");

    // RAM hit: same Arc identity.
    let second = cache.commit_files(&repo, &head).unwrap();
    assert!(
        std::sync::Arc::ptr_eq(&first, &second),
        "RAM hit must return the same Arc"
    );
}

#[test]
fn log_cache_round_trip() {
    let dir = three_commit_repo();
    let root = dir.path();
    let basemind_dir = root.join(".basemind");
    fs::create_dir_all(&basemind_dir).unwrap();
    let cache = GitCache::open(&basemind_dir, 8, true).unwrap();
    let repo = Repo::discover(root).unwrap();
    let head = repo.resolve_rev("HEAD").unwrap();

    let first = cache.log(&repo, &head, None, 10, true).unwrap();
    assert_eq!(first.len(), 3, "three commits expected");

    let second = cache.log(&repo, &head, None, 10, true).unwrap();
    assert!(
        std::sync::Arc::ptr_eq(&first, &second),
        "second log call should hit RAM"
    );

    // Disk persists.
    let log_dir = basemind_dir.join(GIT_CACHE_DIR).join("log");
    let entries: Vec<_> = fs::read_dir(&log_dir).unwrap().flatten().collect();
    assert_eq!(entries.len(), 1, "exactly one log disk entry expected");
}

#[test]
fn disk_persistence_survives_reopen() {
    let dir = three_commit_repo();
    let root = dir.path();
    let basemind_dir = root.join(".basemind");
    fs::create_dir_all(&basemind_dir).unwrap();
    let repo = Repo::discover(root).unwrap();
    let head = repo.resolve_rev("HEAD").unwrap();

    {
        let cache = GitCache::open(&basemind_dir, 8, true).unwrap();
        cache.commit_files(&repo, &head).unwrap();
    }
    // New cache instance — RAM is empty, but disk should still hit.
    let cache = GitCache::open(&basemind_dir, 8, true).unwrap();
    let arc = cache.commit_files(&repo, &head).unwrap();
    assert!(!arc.is_empty(), "second cache should populate from disk");
}

#[test]
fn clear_removes_disk_files() {
    let dir = three_commit_repo();
    let root = dir.path();
    let basemind_dir = root.join(".basemind");
    fs::create_dir_all(&basemind_dir).unwrap();
    let cache = GitCache::open(&basemind_dir, 8, true).unwrap();
    let repo = Repo::discover(root).unwrap();
    let head = repo.resolve_rev("HEAD").unwrap();
    cache.commit_files(&repo, &head).unwrap();
    cache.log(&repo, &head, None, 10, true).unwrap();

    let removed = cache.clear().unwrap();
    assert!(
        removed >= 2,
        "expected at least the two seeded entries; got {removed}"
    );

    // Recompute hits cold path now.
    cache.commit_files(&repo, &head).unwrap();
}

#[test]
fn ram_only_mode_skips_disk_writes() {
    let dir = three_commit_repo();
    let root = dir.path();
    let basemind_dir = root.join(".basemind");
    fs::create_dir_all(&basemind_dir).unwrap();
    let cache = GitCache::open(&basemind_dir, 8, false).unwrap();
    let repo = Repo::discover(root).unwrap();
    let head = repo.resolve_rev("HEAD").unwrap();
    cache.commit_files(&repo, &head).unwrap();

    let on_disk = basemind_dir.join(GIT_CACHE_DIR);
    assert!(
        !on_disk.exists(),
        "persist=false must not create the cache dir"
    );
}