crabtalk-runtime 0.0.17

Crabtalk agent runtime — tool dispatch, MCP, skills, and 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
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

//! Tests for SkillHandler — skill loading from directories.

use crabtalk_runtime::SkillHandler;
use std::fs;
use tempfile::TempDir;

fn write_skill(dir: &std::path::Path, name: &str) {
    let skill_dir = dir.join(name);
    fs::create_dir_all(&skill_dir).unwrap();
    let content =
        format!("---\nname: {name}\ndescription: test skill\n---\nSkill body for {name}.");
    fs::write(skill_dir.join("SKILL.md"), content).unwrap();
}

#[test]
fn load_from_single_dir() {
    let dir = TempDir::new().unwrap();
    write_skill(dir.path(), "greet");
    write_skill(dir.path(), "search");

    let handler = SkillHandler::load(vec![dir.path().to_path_buf()], &[]).unwrap();
    let reg = handler.registry.blocking_lock();
    assert_eq!(reg.skills.len(), 2);
    assert!(reg.contains("greet"));
    assert!(reg.contains("search"));
}

#[test]
fn load_from_multiple_dirs() {
    let dir1 = TempDir::new().unwrap();
    let dir2 = TempDir::new().unwrap();
    write_skill(dir1.path(), "skill-a");
    write_skill(dir2.path(), "skill-b");

    let handler = SkillHandler::load(
        vec![dir1.path().to_path_buf(), dir2.path().to_path_buf()],
        &[],
    )
    .unwrap();
    let reg = handler.registry.blocking_lock();
    assert_eq!(reg.skills.len(), 2);
}

#[test]
fn load_skips_missing_dir() {
    let dir = TempDir::new().unwrap();
    write_skill(dir.path(), "exists");

    let handler = SkillHandler::load(
        vec![
            std::path::PathBuf::from("/nonexistent/path"),
            dir.path().to_path_buf(),
        ],
        &[],
    )
    .unwrap();
    let reg = handler.registry.blocking_lock();
    assert_eq!(reg.skills.len(), 1);
    assert!(reg.contains("exists"));
}

#[test]
fn load_empty_dir() {
    let dir = TempDir::new().unwrap();
    let handler = SkillHandler::load(vec![dir.path().to_path_buf()], &[]).unwrap();
    let reg = handler.registry.blocking_lock();
    assert!(reg.skills.is_empty());
}

#[test]
fn load_conflict_first_dir_wins() {
    let dir1 = TempDir::new().unwrap();
    let dir2 = TempDir::new().unwrap();

    // Write different bodies so we can tell which one loaded
    let skill_dir = dir1.path().join("shared");
    fs::create_dir_all(&skill_dir).unwrap();
    fs::write(
        skill_dir.join("SKILL.md"),
        "---\nname: shared\ndescription: from dir1\n---\nfirst body",
    )
    .unwrap();

    let skill_dir = dir2.path().join("shared");
    fs::create_dir_all(&skill_dir).unwrap();
    fs::write(
        skill_dir.join("SKILL.md"),
        "---\nname: shared\ndescription: from dir2\n---\nsecond body",
    )
    .unwrap();

    let handler = SkillHandler::load(
        vec![dir1.path().to_path_buf(), dir2.path().to_path_buf()],
        &[],
    )
    .unwrap();
    let reg = handler.registry.blocking_lock();
    assert_eq!(reg.skills.len(), 1);
    // First dir wins — verify it's from dir1
    assert_eq!(reg.skills[0].description, "from dir1");
}

#[test]
fn load_skips_hidden_dirs() {
    let dir = TempDir::new().unwrap();
    write_skill(dir.path(), "visible");
    // Create a hidden directory
    let hidden = dir.path().join(".hidden");
    fs::create_dir_all(&hidden).unwrap();
    fs::write(
        hidden.join("SKILL.md"),
        "---\nname: hidden\ndescription: x\n---\nbody",
    )
    .unwrap();

    let handler = SkillHandler::load(vec![dir.path().to_path_buf()], &[]).unwrap();
    let reg = handler.registry.blocking_lock();
    assert_eq!(reg.skills.len(), 1);
    assert!(reg.contains("visible"));
    assert!(!reg.contains("hidden"));
}

#[test]
fn load_no_dirs() {
    let handler = SkillHandler::load(vec![], &[]).unwrap();
    let reg = handler.registry.blocking_lock();
    assert!(reg.skills.is_empty());
}