aisp 0.1.0

AISP 5.1 document validation library - AI Symbolic Protocol with <2% ambiguity
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

//! Quality tier definitions for AISP documents
//!
//! Tiers represent the quality level of an AISP specification based on
//! its semantic density (δ).

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// Quality tier enumeration
///
/// Tiers are assigned based on semantic density (δ):
/// - **⊘ Reject**: δ < 0.20 — Document is too sparse
/// - **◊⁻ Bronze**: δ ≥ 0.20 — Draft/review quality
/// - **◊ Silver**: δ ≥ 0.40 — Development/testing
/// - **◊⁺ Gold**: δ ≥ 0.60 — Staging/pre-production
/// - **◊⁺⁺ Platinum**: δ ≥ 0.75 — Production deployment
#[repr(u8)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Tier {
    /// ⊘: δ < 0.20 — Rejected
    Reject = 0,
    /// ◊⁻: δ ≥ 0.20 — Bronze
    Bronze = 1,
    /// ◊: δ ≥ 0.40 — Silver
    Silver = 2,
    /// ◊⁺: δ ≥ 0.60 — Gold
    Gold = 3,
    /// ◊⁺⁺: δ ≥ 0.75 — Platinum
    Platinum = 4,
}

impl Tier {
    /// Compute tier from semantic density score
    ///
    /// # Arguments
    /// * `delta` - Semantic density δ ∈ [0, 1]
    ///
    /// # Example
    /// ```rust
    /// use aisp::Tier;
    ///
    /// assert_eq!(Tier::from_delta(0.80), Tier::Platinum);
    /// assert_eq!(Tier::from_delta(0.65), Tier::Gold);
    /// assert_eq!(Tier::from_delta(0.45), Tier::Silver);
    /// assert_eq!(Tier::from_delta(0.25), Tier::Bronze);
    /// assert_eq!(Tier::from_delta(0.10), Tier::Reject);
    /// ```
    #[inline]
    pub fn from_delta(delta: f32) -> Self {
        if delta >= 0.75 {
            Self::Platinum
        } else if delta >= 0.60 {
            Self::Gold
        } else if delta >= 0.40 {
            Self::Silver
        } else if delta >= 0.20 {
            Self::Bronze
        } else {
            Self::Reject
        }
    }

    /// Get the Unicode tier symbol
    ///
    /// # Example
    /// ```rust
    /// use aisp::Tier;
    ///
    /// assert_eq!(Tier::Platinum.symbol(), "◊⁺⁺");
    /// assert_eq!(Tier::Reject.symbol(), "⊘");
    /// ```
    pub const fn symbol(self) -> &'static str {
        match self {
            Self::Reject => "⊘",
            Self::Bronze => "◊⁻",
            Self::Silver => "◊",
            Self::Gold => "◊⁺",
            Self::Platinum => "◊⁺⁺",
        }
    }

    /// Get the tier name
    ///
    /// # Example
    /// ```rust
    /// use aisp::Tier;
    ///
    /// assert_eq!(Tier::Platinum.name(), "Platinum");
    /// ```
    pub const fn name(self) -> &'static str {
        match self {
            Self::Reject => "Reject",
            Self::Bronze => "Bronze",
            Self::Silver => "Silver",
            Self::Gold => "Gold",
            Self::Platinum => "Platinum",
        }
    }

    /// Get the minimum delta threshold for this tier
    pub const fn threshold(self) -> f32 {
        match self {
            Self::Reject => 0.0,
            Self::Bronze => 0.20,
            Self::Silver => 0.40,
            Self::Gold => 0.60,
            Self::Platinum => 0.75,
        }
    }

    /// Check if tier meets minimum production requirement (Gold or better)
    pub const fn is_production_ready(self) -> bool {
        matches!(self, Self::Gold | Self::Platinum)
    }
}

impl Default for Tier {
    fn default() -> Self {
        Self::Reject
    }
}

impl core::fmt::Display for Tier {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{} {}", self.symbol(), self.name())
    }
}

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

    #[test]
    fn test_tier_thresholds() {
        assert_eq!(Tier::from_delta(0.75), Tier::Platinum);
        assert_eq!(Tier::from_delta(0.74), Tier::Gold);
        assert_eq!(Tier::from_delta(0.60), Tier::Gold);
        assert_eq!(Tier::from_delta(0.59), Tier::Silver);
        assert_eq!(Tier::from_delta(0.40), Tier::Silver);
        assert_eq!(Tier::from_delta(0.39), Tier::Bronze);
        assert_eq!(Tier::from_delta(0.20), Tier::Bronze);
        assert_eq!(Tier::from_delta(0.19), Tier::Reject);
    }

    #[test]
    fn test_tier_ordering() {
        assert!(Tier::Platinum > Tier::Gold);
        assert!(Tier::Gold > Tier::Silver);
        assert!(Tier::Silver > Tier::Bronze);
        assert!(Tier::Bronze > Tier::Reject);
    }
}