skillnet 0.3.0

Reconcile and manage local AI skill mirrors; calibration data for the multi-phase-plan skill.
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

use std::collections::{BTreeMap, BTreeSet};

use super::config::{
    CatalogConfig, VALID_GLOBAL_CATEGORIES, VALID_PROJECT_CATEGORIES, VALID_SCOPES, VALID_STATUSES,
};
use super::entry::SkillEntry;

pub(super) fn validate_entries(entries: &[SkillEntry], config: &CatalogConfig) -> Vec<String> {
    let mut errors = Vec::new();
    let categories = VALID_GLOBAL_CATEGORIES
        .iter()
        .chain(VALID_PROJECT_CATEGORIES.iter())
        .copied()
        .collect::<BTreeSet<_>>();
    let qualified_names = entries
        .iter()
        .map(|entry| entry.qualified_name.as_str())
        .collect::<BTreeSet<_>>();
    let names = entries
        .iter()
        .map(|entry| entry.name.as_str())
        .collect::<BTreeSet<_>>();

    for entry in entries {
        if entry.description.is_empty() {
            errors.push(format!("{}: missing description", entry.qualified_name));
        }
        match &entry.category {
            Some(category) if categories.contains(category.as_str()) => {}
            Some(category) => errors.push(format!(
                "{}: unknown category `{category}`",
                entry.qualified_name
            )),
            None => errors.push(format!("{}: missing category", entry.qualified_name)),
        }
        if !VALID_SCOPES.contains(&entry.scope.as_str()) {
            errors.push(format!(
                "{}: unknown scope `{}`",
                entry.qualified_name, entry.scope
            ));
        }
        if !VALID_STATUSES.contains(&entry.status.as_str()) {
            errors.push(format!(
                "{}: unknown status `{}`",
                entry.qualified_name, entry.status
            ));
        }
        for related in &entry.related_skills {
            if !qualified_names.contains(related.as_str()) && !names.contains(related.as_str()) {
                errors.push(format!(
                    "{}: related skill `{related}` does not exist",
                    entry.qualified_name
                ));
            }
        }
        if entry.line_count > config.settings.large_skill_line_threshold
            && !entry.tags.iter().any(|tag| tag == "large-skill")
        {
            errors.push(format!(
                "{}: large skill has {} lines but is not tagged `large-skill`",
                entry.qualified_name, entry.line_count
            ));
        }
    }

    for (name, duplicates) in duplicates_by_name(entries) {
        if duplicates.len() > 1
            && duplicates
                .iter()
                .all(|entry| entry.collision_note.is_none())
        {
            errors.push(format!(
                "duplicate skill `{name}` lacks collision notes: {}",
                duplicates
                    .iter()
                    .map(|entry| entry.qualified_name.as_str())
                    .collect::<Vec<_>>()
                    .join(", ")
            ));
        }
    }
    errors
}

pub(super) fn duplicates_by_name(entries: &[SkillEntry]) -> BTreeMap<&str, Vec<&SkillEntry>> {
    let mut by_name = BTreeMap::<&str, Vec<&SkillEntry>>::new();
    for entry in entries {
        by_name.entry(entry.name.as_str()).or_default().push(entry);
    }
    by_name
}