basemind 0.21.1

Full AI context layer over MCP — tree-sitter code-map, document RAG (PDF/Office/HTML/email + OCR + reranker), shared agent memory, on-demand web crawl, git history + blame + per-symbol diff. 300+ languages, 10+ coding-agent harnesses, content-addressed Fjall + LanceDB.
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

//! End-to-end smoke tests for `basemind init` — the re-runnable onboarding flow.
//!
//! These shell the built binary (`CARGO_BIN_EXE_basemind`) against a tempdir and assert the
//! observable filesystem effects: the `basemind.toml` scaffold, the `.gitignore` entry, and the
//! idempotent delimited rules block injected into CLAUDE.md / AGENTS.md / an ai-rulez rule file.

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

const BEGIN_MARKER: &str = "<!-- BEGIN basemind (managed by `basemind init`) -->";
const END_MARKER: &str = "<!-- END basemind -->";

fn tmpdir() -> tempfile::TempDir {
    tempfile::tempdir().expect("create tempdir")
}

/// Run `basemind --root <root> init <extra args...>` and assert success.
fn run_init(root: &Path, extra: &[&str]) -> String {
    let mut cmd = Command::new(env!("CARGO_BIN_EXE_basemind"));
    cmd.arg("--root").arg(root).arg("init");
    for a in extra {
        cmd.arg(a);
    }
    let output = cmd.output().expect("spawn basemind init");
    let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
    let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
    assert!(
        output.status.success(),
        "init failed: status={:?}\nstdout:\n{stdout}\nstderr:\n{stderr}",
        output.status
    );
    format!("{stdout}{stderr}")
}

fn count_markers(haystack: &str) -> usize {
    haystack.matches(BEGIN_MARKER).count()
}

#[test]
fn fresh_dir_writes_config_gitignore_and_claude_block() {
    let dir = tmpdir();
    let root = dir.path();
    run_init(root, &["--yes"]);

    let config = root.join("basemind.toml");
    assert!(config.exists(), "basemind.toml should be written");
    let config_text = std::fs::read_to_string(&config).expect("read config");
    assert!(config_text.contains("[scan]"), "scaffold content present");

    let gitignore = std::fs::read_to_string(root.join(".gitignore")).expect("read .gitignore");
    assert!(
        gitignore.lines().any(|l| l.trim().trim_matches('/') == ".basemind"),
        ".basemind should be gitignored, got:\n{gitignore}"
    );

    let claude = std::fs::read_to_string(root.join("CLAUDE.md")).expect("CLAUDE.md created");
    assert_eq!(count_markers(&claude), 1, "exactly one managed block");
    assert!(claude.contains(END_MARKER), "END marker present");
    assert!(claude.contains("basemind"), "block advertises basemind usage");
}

#[test]
fn init_is_idempotent_single_block_and_print_shows_no_change() {
    let dir = tmpdir();
    let root = dir.path();
    run_init(root, &["--yes"]);
    run_init(root, &["--yes"]);

    let claude = std::fs::read_to_string(root.join("CLAUDE.md")).expect("read CLAUDE.md");
    assert_eq!(
        count_markers(&claude),
        1,
        "second run must not duplicate the block:\n{claude}"
    );

    // ~keep A --print dry-run after convergence must report no pending changes.
    let out = run_init(root, &["--yes", "--print"]);
    let lower = out.to_lowercase();
    assert!(
        lower.contains("no change") || lower.contains("up to date") || lower.contains("up-to-date"),
        "--print should report no pending changes, got:\n{out}"
    );
}

#[test]
fn existing_claude_content_is_preserved_verbatim() {
    let dir = tmpdir();
    let root = dir.path();
    let handwritten = "# My Project\n\nSome hand-written guidance.\n\nDo not delete me.\n";
    std::fs::write(root.join("CLAUDE.md"), handwritten).expect("seed CLAUDE.md");

    run_init(root, &["--yes"]);

    let claude = std::fs::read_to_string(root.join("CLAUDE.md")).expect("read CLAUDE.md");
    assert!(
        claude.contains(handwritten.trim_end()),
        "pre-existing content must survive verbatim:\n{claude}"
    );
    assert_eq!(count_markers(&claude), 1, "block appended once");
    // ~keep The managed block must come AFTER the user content (appended at EOF).
    let user_idx = claude.find("Do not delete me.").expect("user content present");
    let block_idx = claude.find(BEGIN_MARKER).expect("block present");
    assert!(block_idx > user_idx, "block appended after user content");
}

#[test]
fn ai_rulez_present_writes_rule_file_and_leaves_claude_untouched() {
    let dir = tmpdir();
    let root = dir.path();
    std::fs::create_dir_all(root.join(".ai-rulez")).expect("mkdir .ai-rulez");
    std::fs::write(root.join(".ai-rulez/config.toml"), "version = \"4.0\"\n").expect("seed ai-rulez config");
    // ~keep A CLAUDE.md that is a generated artifact must NOT be edited when ai-rulez owns the rules.
    std::fs::write(root.join("CLAUDE.md"), "# generated\n").expect("seed CLAUDE.md");

    run_init(root, &["--yes"]);

    let rule = root.join(".ai-rulez/rules/basemind-usage.md");
    assert!(rule.exists(), "ai-rulez rule file should be written");
    let rule_text = std::fs::read_to_string(&rule).expect("read rule");
    assert!(rule_text.contains("basemind"), "rule advertises basemind");

    let claude = std::fs::read_to_string(root.join("CLAUDE.md")).expect("read CLAUDE.md");
    assert!(
        !claude.contains(BEGIN_MARKER),
        "ai-rulez path must NOT inject into CLAUDE.md:\n{claude}"
    );
}

#[test]
fn agents_md_is_used_when_it_is_the_only_rules_file() {
    let dir = tmpdir();
    let root = dir.path();
    std::fs::write(root.join("AGENTS.md"), "# Agents\n\nkeep me\n").expect("seed AGENTS.md");

    run_init(root, &["--yes"]);

    let agents = std::fs::read_to_string(root.join("AGENTS.md")).expect("read AGENTS.md");
    assert_eq!(count_markers(&agents), 1, "block injected into AGENTS.md");
    assert!(agents.contains("keep me"), "pre-existing AGENTS.md content preserved");
    assert!(
        !root.join("CLAUDE.md").exists(),
        "CLAUDE.md must not be created when AGENTS.md already owns the rules"
    );
}

#[test]
fn print_dry_run_writes_nothing_on_a_fresh_repo() {
    let dir = tmpdir();
    let root = dir.path();
    let out = run_init(root, &["--yes", "--print"]);

    assert!(!root.join("basemind.toml").exists(), "--print must not write config");
    assert!(!root.join(".gitignore").exists(), "--print must not write .gitignore");
    assert!(!root.join("CLAUDE.md").exists(), "--print must not write rules");
    assert!(
        out.to_lowercase().contains("would") || out.to_lowercase().contains("would change"),
        "--print should report the pending changes it would make, got:\n{out}"
    );
}

#[test]
fn rules_target_none_touches_no_rules_file() {
    let dir = tmpdir();
    let root = dir.path();
    run_init(root, &["--yes", "--rules-target", "none"]);

    assert!(root.join("basemind.toml").exists(), "config still written");
    assert!(!root.join("CLAUDE.md").exists(), "no CLAUDE.md created");
    assert!(!root.join("AGENTS.md").exists(), "no AGENTS.md created");
    assert!(
        !root.join(".ai-rulez/rules/basemind-usage.md").exists(),
        "no ai-rulez rule created"
    );
}

#[test]
fn no_rules_flag_touches_no_rules_file() {
    let dir = tmpdir();
    let root = dir.path();
    run_init(root, &["--yes", "--no-rules"]);

    assert!(root.join("basemind.toml").exists(), "config still written");
    assert!(!root.join("CLAUDE.md").exists(), "no CLAUDE.md created");
}

#[test]
fn init_refuses_to_corrupt_a_file_with_a_broken_marker() {
    let dir = tmpdir();
    let root = dir.path();
    // ~keep A CLAUDE.md with a BEGIN marker but no END (e.g. a hand-edit or bad merge dropped the END line).
    // ~keep init must bail rather than append a second block and later collapse the intervening user content.
    let broken = format!("# My Project\n\nkeep me\n\n{BEGIN_MARKER}\nstale rules\n\ntrailing user content\n");
    std::fs::write(root.join("CLAUDE.md"), &broken).expect("seed broken CLAUDE.md");

    let output = Command::new(env!("CARGO_BIN_EXE_basemind"))
        .arg("--root")
        .arg(root)
        .arg("init")
        .arg("--yes")
        .output()
        .expect("spawn basemind init");
    assert!(!output.status.success(), "init must fail on a malformed marker");

    let after = std::fs::read_to_string(root.join("CLAUDE.md")).expect("read CLAUDE.md");
    assert_eq!(after, broken, "the file must be left byte-for-byte untouched on bail");
}

#[test]
fn existing_config_is_kept_not_clobbered() {
    let dir = tmpdir();
    let root = dir.path();
    let sentinel = "# my custom config\n\"$schema\" = \"v1\"\n";
    std::fs::write(root.join("basemind.toml"), sentinel).expect("seed config");

    run_init(root, &["--yes", "--no-rules"]);

    let config = std::fs::read_to_string(root.join("basemind.toml")).expect("read config");
    assert_eq!(config, sentinel, "existing config must be kept verbatim");
}