systemprompt-extension 0.2.1

Compile-time extension framework for systemprompt.io AI governance infrastructure. Built on the inventory crate — registers schemas, API routes, jobs, and providers in the MCP governance pipeline.
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

use std::path::{Path, PathBuf};

pub trait AssetPaths: Send + Sync {
    fn storage_files(&self) -> &Path;
    fn web_dist(&self) -> &Path;
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AssetType {
    Css,
    Html,
    Image,
    Font,
    JavaScript,
}

#[derive(Debug, Clone)]
pub struct AssetDefinition {
    source: PathBuf,
    destination: &'static str,
    asset_type: AssetType,
    required: bool,
}

#[derive(Debug)]
pub struct AssetDefinitionBuilder {
    source: PathBuf,
    destination: &'static str,
    asset_type: AssetType,
    required: bool,
}

impl AssetDefinitionBuilder {
    pub fn new(
        source: impl Into<PathBuf>,
        destination: &'static str,
        asset_type: AssetType,
    ) -> Self {
        Self {
            source: source.into(),
            destination,
            asset_type,
            required: true,
        }
    }

    #[must_use]
    pub const fn optional(mut self) -> Self {
        self.required = false;
        self
    }

    #[must_use]
    pub fn build(self) -> AssetDefinition {
        AssetDefinition {
            source: self.source,
            destination: self.destination,
            asset_type: self.asset_type,
            required: self.required,
        }
    }
}

impl AssetDefinition {
    pub fn builder(
        source: impl Into<PathBuf>,
        destination: &'static str,
        asset_type: AssetType,
    ) -> AssetDefinitionBuilder {
        AssetDefinitionBuilder::new(source, destination, asset_type)
    }

    #[must_use]
    pub fn css(source: impl Into<PathBuf>, destination: &'static str) -> Self {
        Self::builder(source, destination, AssetType::Css).build()
    }

    #[must_use]
    pub fn html(source: impl Into<PathBuf>, destination: &'static str) -> Self {
        Self::builder(source, destination, AssetType::Html).build()
    }

    #[must_use]
    pub fn image(source: impl Into<PathBuf>, destination: &'static str) -> Self {
        Self::builder(source, destination, AssetType::Image).build()
    }

    #[must_use]
    pub fn font(source: impl Into<PathBuf>, destination: &'static str) -> Self {
        Self::builder(source, destination, AssetType::Font).build()
    }

    #[must_use]
    pub fn javascript(source: impl Into<PathBuf>, destination: &'static str) -> Self {
        Self::builder(source, destination, AssetType::JavaScript).build()
    }

    #[must_use]
    pub fn js(source: impl Into<PathBuf>, destination: &'static str) -> Self {
        Self::javascript(source, destination)
    }

    #[must_use]
    pub fn source(&self) -> &Path {
        &self.source
    }

    #[must_use]
    pub const fn destination(&self) -> &str {
        self.destination
    }

    #[must_use]
    pub const fn asset_type(&self) -> AssetType {
        self.asset_type
    }

    #[must_use]
    pub const fn is_required(&self) -> bool {
        self.required
    }
}