skm-disclose 0.1.0

Progressive disclosure and context management for 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

//! Disclosure level types.

use std::path::PathBuf;

use skm_core::SkillName;
use serde::{Deserialize, Serialize};

/// Disclosure level for a skill.
///
/// - Level 0 (Catalog): Name + description only (~30-50 tokens/skill)
/// - Level 1 (Activated): Full SKILL.md body loaded (~2000-5000 tokens)
/// - Level 2 (Referenced): Additional files from scripts/, references/ loaded on demand
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum DisclosureLevel {
    /// Level 0: Only name and description in context.
    Catalog,

    /// Level 1: Full SKILL.md instructions loaded.
    Activated,

    /// Level 2: Additional reference files loaded.
    Referenced,
}

impl DisclosureLevel {
    /// Get the numeric level (0, 1, or 2).
    pub fn level(&self) -> u8 {
        match self {
            Self::Catalog => 0,
            Self::Activated => 1,
            Self::Referenced => 2,
        }
    }

    /// Check if this level includes full instructions.
    pub fn has_instructions(&self) -> bool {
        matches!(self, Self::Activated | Self::Referenced)
    }
}

impl Default for DisclosureLevel {
    fn default() -> Self {
        Self::Catalog
    }
}

/// A skill loaded at some disclosure level.
#[derive(Debug, Clone)]
pub struct LoadedSkill {
    /// The skill name.
    pub name: SkillName,

    /// Current disclosure level.
    pub level: DisclosureLevel,

    /// Tokens used by this skill in context.
    pub tokens_used: usize,

    /// Reference files loaded (for Level 2).
    pub loaded_files: Vec<PathBuf>,
}

impl LoadedSkill {
    /// Create a new loaded skill entry.
    pub fn new(name: SkillName, level: DisclosureLevel, tokens_used: usize) -> Self {
        Self {
            name,
            level,
            tokens_used,
            loaded_files: Vec::new(),
        }
    }

    /// Add a loaded reference file.
    pub fn add_file(&mut self, path: PathBuf, additional_tokens: usize) {
        self.loaded_files.push(path);
        self.tokens_used += additional_tokens;
        self.level = DisclosureLevel::Referenced;
    }
}

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

    #[test]
    fn test_disclosure_level_ordering() {
        assert_eq!(DisclosureLevel::Catalog.level(), 0);
        assert_eq!(DisclosureLevel::Activated.level(), 1);
        assert_eq!(DisclosureLevel::Referenced.level(), 2);
    }

    #[test]
    fn test_has_instructions() {
        assert!(!DisclosureLevel::Catalog.has_instructions());
        assert!(DisclosureLevel::Activated.has_instructions());
        assert!(DisclosureLevel::Referenced.has_instructions());
    }

    #[test]
    fn test_loaded_skill() {
        let name = SkillName::new("test").unwrap();
        let mut skill = LoadedSkill::new(name, DisclosureLevel::Activated, 1000);

        assert_eq!(skill.tokens_used, 1000);
        assert!(skill.loaded_files.is_empty());

        skill.add_file(PathBuf::from("references/data.md"), 500);

        assert_eq!(skill.tokens_used, 1500);
        assert_eq!(skill.level, DisclosureLevel::Referenced);
        assert_eq!(skill.loaded_files.len(), 1);
    }
}