systemprompt-cli 0.2.2

Unified CLI for systemprompt.io AI governance: agent orchestration, MCP governance, analytics, profiles, cloud deploy, and self-hosted operations.
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

use std::collections::HashSet;
use std::fs;

use systemprompt_models::content_config::ContentConfigRaw;

use super::super::paths::WebPaths;
use super::super::types::{TemplatesConfig, ValidationIssue};

pub fn validate_templates(
    profile: &systemprompt_models::Profile,
    web_paths: &WebPaths,
    errors: &mut Vec<ValidationIssue>,
    warnings: &mut Vec<ValidationIssue>,
) {
    let templates_dir = &web_paths.templates;
    let templates_yaml_path = templates_dir.join("templates.yaml");

    if !templates_yaml_path.exists() {
        warnings.push(ValidationIssue {
            source: "templates".to_string(),
            message: format!(
                "templates.yaml not found at {}",
                templates_yaml_path.display()
            ),
            suggestion: Some("Create a templates.yaml file".to_string()),
        });
        return;
    }

    let Ok(content) = fs::read_to_string(&templates_yaml_path) else {
        errors.push(ValidationIssue {
            source: "templates".to_string(),
            message: "Failed to read templates.yaml".to_string(),
            suggestion: None,
        });
        return;
    };

    let Ok(templates_config) = serde_yaml::from_str::<TemplatesConfig>(&content) else {
        errors.push(ValidationIssue {
            source: "templates".to_string(),
            message: "Failed to parse templates.yaml".to_string(),
            suggestion: Some("Check YAML syntax".to_string()),
        });
        return;
    };

    for name in templates_config.templates.keys() {
        let html_path = templates_dir.join(format!("{}.html", name));
        if !html_path.exists() {
            errors.push(ValidationIssue {
                source: "templates".to_string(),
                message: format!("Missing HTML file for template '{}'", name),
                suggestion: Some(format!("Create {}", html_path.display())),
            });
        }
    }

    let content_config_path = profile.paths.content_config();
    let Ok(content) = fs::read_to_string(&content_config_path) else {
        return;
    };
    let Ok(content_config) = serde_yaml::from_str::<ContentConfigRaw>(&content) else {
        return;
    };

    let content_type_names: HashSet<&String> = content_config.content_sources.keys().collect();

    for (template_name, entry) in &templates_config.templates {
        for ct in &entry.content_types {
            if !content_type_names.contains(ct) {
                warnings.push(ValidationIssue {
                    source: "templates".to_string(),
                    message: format!(
                        "Template '{}' references unknown content type '{}'",
                        template_name, ct
                    ),
                    suggestion: Some("Add the content type to content config".to_string()),
                });
            }
        }
    }

    let template_content_types: HashSet<&String> = templates_config
        .templates
        .values()
        .flat_map(|e| e.content_types.iter())
        .collect();

    for name in content_type_names {
        if !template_content_types.contains(name) {
            warnings.push(ValidationIssue {
                source: "templates".to_string(),
                message: format!("Content type '{}' has no associated template", name),
                suggestion: Some("Link a template to this content type".to_string()),
            });
        }
    }
}