agent-skills-rs 0.3.1

Library and CLI for installing agent skills
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

use crate::types::Skill;
use anyhow::Result;
use std::path::Path;

/// Trait for skill content providers (GitHub, GitLab, etc.)
pub trait SkillProvider: Send + Sync {
    /// Discover skills from the provider
    fn discover_skills(&self, url: &str, subpath: Option<&str>) -> Result<Vec<Skill>>;

    /// Fetch skill content to a local directory
    fn fetch_skill(&self, skill: &Skill, dest: &Path) -> Result<()>;

    /// Get folder hash for a skill (for lock file)
    fn get_folder_hash(&self, skill: &Skill) -> Result<String>;
}

/// Mock provider for testing
pub struct MockProvider {
    skills: Vec<Skill>,
    folder_hash: String,
}

impl MockProvider {
    pub fn new(skills: Vec<Skill>) -> Self {
        Self {
            skills,
            folder_hash: "mock-hash-123".to_string(),
        }
    }

    pub fn with_hash(mut self, hash: String) -> Self {
        self.folder_hash = hash;
        self
    }
}

impl SkillProvider for MockProvider {
    fn discover_skills(&self, _url: &str, _subpath: Option<&str>) -> Result<Vec<Skill>> {
        Ok(self.skills.clone())
    }

    fn fetch_skill(&self, skill: &Skill, dest: &Path) -> Result<()> {
        std::fs::create_dir_all(dest)?;
        std::fs::write(dest.join("SKILL.md"), &skill.raw_content)?;
        Ok(())
    }

    fn get_folder_hash(&self, _skill: &Skill) -> Result<String> {
        Ok(self.folder_hash.clone())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::SkillMetadata;
    use tempfile::TempDir;

    #[test]
    fn test_mock_provider_discover() {
        let skill = Skill {
            name: "test-skill".to_string(),
            description: "Test skill".to_string(),
            path: None,
            raw_content: "---\nname: test-skill\ndescription: Test skill\n---\n\n# Test"
                .to_string(),
            metadata: SkillMetadata::default(),
            auxiliary_files: Default::default(),
        };

        let provider = MockProvider::new(vec![skill.clone()]);
        let discovered = provider
            .discover_skills("https://example.com", None)
            .unwrap();

        assert_eq!(discovered.len(), 1);
        assert_eq!(discovered[0].name, "test-skill");
    }

    #[test]
    fn test_mock_provider_fetch() {
        let skill = Skill {
            name: "test-skill".to_string(),
            description: "Test skill".to_string(),
            path: None,
            raw_content: "---\nname: test-skill\ndescription: Test skill\n---\n\n# Test"
                .to_string(),
            metadata: SkillMetadata::default(),
            auxiliary_files: Default::default(),
        };

        let provider = MockProvider::new(vec![skill.clone()]);
        let temp_dir = TempDir::new().unwrap();

        provider.fetch_skill(&skill, temp_dir.path()).unwrap();

        assert!(temp_dir.path().join("SKILL.md").exists());
        let content = std::fs::read_to_string(temp_dir.path().join("SKILL.md")).unwrap();
        assert_eq!(content, skill.raw_content);
    }

    #[test]
    fn test_mock_provider_hash() {
        let skill = Skill {
            name: "test-skill".to_string(),
            description: "Test skill".to_string(),
            path: None,
            raw_content: "test".to_string(),
            metadata: SkillMetadata::default(),
            auxiliary_files: Default::default(),
        };

        let provider =
            MockProvider::new(vec![skill.clone()]).with_hash("custom-hash-456".to_string());

        let hash = provider.get_folder_hash(&skill).unwrap();
        assert_eq!(hash, "custom-hash-456");
    }
}