kanbrain-core 0.4.1

The core of kanbrain (the `kb` command line and the kanban app): entries, markdown storage, tags and time tracking. Internal: its API follows kanbrain's versions and isn't meant for other crates.
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

use super::*;
use crate::projects;

/// What the hook says for `input`, run in a folder outside any project.
fn hook(event: HookEvent, input: &str, central: &Path) -> Option<String> {
    let outside = tempfile::tempdir().unwrap();
    respond(event, input, central, outside.path())
}

/// A central brain and a repository folder registered as project `shop`, with its card as `init` makes
/// it; the folders live as long as the returned ones.
fn project() -> (tempfile::TempDir, tempfile::TempDir, PathBuf) {
    let (central, code) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
    let dir = code.path().join("api/.brain");
    std::fs::create_dir_all(&dir).unwrap();
    projects::register(central.path(), "shop", &dir).unwrap();
    projects::write_repo_card(&dir, &projects::RepoCard { project: "shop".into(), repo: None, notes: String::new() })
        .unwrap();
    projects::ensure_description(central.path(), "shop").unwrap();
    let root = code.path().join("api");
    (central, code, root)
}

/// The hook's input as Claude Code sends it, from `cwd`.
fn input(cwd: &Path, stop_hook_active: bool) -> String {
    json!({ "hook_event_name": "Stop", "cwd": cwd, "stop_hook_active": stop_hook_active }).to_string()
}

#[test]
fn an_undescribed_project_is_asked_for_with_every_prompt_and_holds_the_turn_once() {
    let (central, _code, root) = project();
    let prompt = hook(HookEvent::Prompt, &input(&root, false), central.path()).expect("it asks");
    assert!(
        prompt.contains("Before anything else in this turn") && prompt.contains("`kb project describe -`"),
        "{prompt}"
    );
    assert!(!prompt.contains("role"), "one repository has no role to describe: {prompt}");

    let stop: Value =
        serde_json::from_str(&hook(HookEvent::Stop, &input(&root, false), central.path()).unwrap()).unwrap();
    let reminder = stop["hookSpecificOutput"]["additionalContext"].as_str().expect("the turn goes on with it");
    assert_eq!(stop["hookSpecificOutput"]["hookEventName"], "Stop");
    assert!(reminder.contains("Before ending this turn") && reminder.contains("`kb project describe -`"), "{reminder}");
    assert_eq!(hook(HookEvent::Stop, &input(&root, true), central.path()), None, "but only once: no loop");
}

#[test]
fn a_described_project_costs_nothing_and_outside_one_too() {
    let (central, _code, root) = project();
    projects::write_description(central.path(), "shop", "An online shop.").unwrap();
    for event in [HookEvent::Prompt, HookEvent::Stop] {
        assert_eq!(hook(event, &input(&root, false), central.path()), None);
    }
    let elsewhere = tempfile::tempdir().unwrap();
    assert_eq!(hook(HookEvent::Stop, &input(elsewhere.path(), false), central.path()), None, "not a project");
    let bad = respond(HookEvent::Stop, "not json", central.path(), elsewhere.path());
    assert_eq!(bad, None, "bad input falls back to the folder it runs in, and never breaks a session");
}

#[test]
fn with_several_repositories_this_ones_role_counts_too() {
    let (central, code, root) = project();
    let web = code.path().join("web/.brain");
    std::fs::create_dir_all(&web).unwrap();
    projects::register(central.path(), "shop", &web).unwrap();
    projects::write_description(central.path(), "shop", "An online shop.").unwrap();
    let prompt = hook(HookEvent::Prompt, &input(&root, false), central.path()).expect("the role is missing");
    assert!(prompt.contains("`kb project notes -`") && !prompt.contains("describe -"), "{prompt}");
    projects::write_repo_card(
        &root.join(".brain"),
        &projects::RepoCard { project: "shop".into(), repo: None, notes: "The API.".into() },
    )
    .unwrap();
    assert_eq!(hook(HookEvent::Prompt, &input(&root, false), central.path()), None);
}

#[test]
fn a_task_an_agent_started_and_never_commented_on_is_reminded_once() {
    let (central, _code, root) = project();
    projects::write_description(central.path(), "shop", "An online shop.").unwrap();
    let mut brain = crate::brain::Brain::open(Store::at(root.join(".brain")).unwrap()).unwrap();
    let new = |title: &str| crate::brain::NewEntry { title: title.into(), start: true, ..Default::default() };
    let users = brain.add(new("The user's")).unwrap();
    assert_eq!(hook(HookEvent::Stop, &input(&root, false), central.path()), None, "not the agent's to report");

    brain.author = Author::Agent;
    let task = brain.add(new("Cache sessions")).unwrap();
    assert_ne!(users, task);
    let other = brain.add(new("Expire sessions")).unwrap();
    let stop = hook(HookEvent::Stop, &input(&root, false), central.path()).expect("a reminder");
    assert!(stop.contains(&format!("`kb comment {task}`")), "{stop}");
    assert!(stop.contains(&format!("`kb comment {other}`")), "each one a subagent runs: {stop}");
    // Another session's, as far as this one knows: never told to finish what it didn't start.
    assert!(stop.contains("If you started it") && stop.contains("if you didn't, leave it alone"), "{stop}");
    assert!(!stop.contains("since you started it"), "{stop}");
    brain.add_comment(other, "expiry set to a day").unwrap();
    assert_eq!(hook(HookEvent::Stop, &input(&root, true), central.path()), None, "once a turn");
    brain.add_comment(task, "sessions cached; next: expiry").unwrap();
    assert_eq!(hook(HookEvent::Stop, &input(&root, false), central.path()), None);
}