looprs 0.1.11

Concise coding assistant REPL
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
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

// Parser for SKILL.md files with YAML frontmatter

use anyhow::{Context, Result};
use serde::Deserialize;
use std::path::Path;

#[derive(Debug, Deserialize)]
struct SkillFrontmatter {
    name: String,
    description: Option<String>,
    triggers: Vec<String>,
}

/// Parse SKILL.md file with YAML frontmatter  
pub fn parse_skill_file(path: &Path, content: &str) -> Result<super::Skill> {
    // Split frontmatter from content
    let parts: Vec<&str> = content.splitn(3, "---").collect();

    if parts.len() < 3 {
        anyhow::bail!("Invalid SKILL.md format: missing YAML frontmatter delimiters");
    }

    // Parse YAML frontmatter
    let frontmatter: SkillFrontmatter =
        serde_yaml::from_str(parts[1]).context("Failed to parse YAML frontmatter")?;

    // Validate required fields
    if frontmatter.name.is_empty() {
        anyhow::bail!("Skill name cannot be empty");
    }
    if frontmatter.triggers.is_empty() {
        anyhow::bail!("Skill must have at least one trigger");
    }

    Ok(super::Skill {
        name: frontmatter.name,
        description: frontmatter.description,
        triggers: frontmatter.triggers,
        content: parts[2].trim().to_string(),
        source_path: path.to_path_buf(),
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn test_parse_valid_skill_with_description() {
        let content = r#"---
name: rust-testing
description: Guide for writing Rust tests
triggers:
  - "rust test"
  - "cargo test"
---

# Rust Testing

This is the skill content.
"#;

        let path = PathBuf::from("/test/rust-testing/SKILL.md");
        let skill = parse_skill_file(&path, content).unwrap();

        assert_eq!(skill.name, "rust-testing");
        assert_eq!(
            skill.description,
            Some("Guide for writing Rust tests".to_string())
        );
        assert_eq!(skill.triggers, vec!["rust test", "cargo test"]);
        assert_eq!(
            skill.content,
            "# Rust Testing\n\nThis is the skill content."
        );
        assert_eq!(skill.source_path, path);
    }

    #[test]
    fn test_parse_skill_without_description() {
        let content = r#"---
name: minimal-skill
triggers:
  - "test"
---

# Minimal Skill

Content only.
"#;

        let path = PathBuf::from("/test/minimal/SKILL.md");
        let skill = parse_skill_file(&path, content).unwrap();

        assert_eq!(skill.name, "minimal-skill");
        assert_eq!(skill.description, None);
        assert_eq!(skill.triggers, vec!["test"]);
        assert_eq!(skill.content, "# Minimal Skill\n\nContent only.");
    }

    #[test]
    fn test_parse_missing_frontmatter() {
        let content = "# Just Content\n\nNo frontmatter.";
        let path = PathBuf::from("/test/SKILL.md");

        let result = parse_skill_file(&path, content);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("missing YAML frontmatter")
        );
    }

    #[test]
    fn test_parse_empty_name() {
        let content = r#"---
name: ""
triggers:
  - "test"
---
Content
"#;
        let path = PathBuf::from("/test/SKILL.md");

        let result = parse_skill_file(&path, content);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("name cannot be empty")
        );
    }

    #[test]
    fn test_parse_no_triggers() {
        let content = r#"---
name: test-skill
triggers: []
---
Content
"#;
        let path = PathBuf::from("/test/SKILL.md");

        let result = parse_skill_file(&path, content);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("at least one trigger")
        );
    }
}