spec-ai 0.6.12

A framework for building AI agents with structured outputs, policy enforcement, and execution tracking
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

//! Style combining foreground, background, and modifiers

use super::{Color, Modifier};

/// A complete style with foreground, background, and modifiers
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]
pub struct Style {
    /// Foreground color
    pub fg: Color,
    /// Background color
    pub bg: Color,
    /// Style modifiers
    pub modifier: Modifier,
}

impl Style {
    /// Create a new default style
    pub const fn new() -> Self {
        Self {
            fg: Color::Reset,
            bg: Color::Reset,
            modifier: Modifier::NONE,
        }
    }

    /// Create a style with no color changes (reset)
    pub const fn reset() -> Self {
        Self::new()
    }

    /// Set foreground color
    pub const fn fg(mut self, color: Color) -> Self {
        self.fg = color;
        self
    }

    /// Set background color
    pub const fn bg(mut self, color: Color) -> Self {
        self.bg = color;
        self
    }

    /// Set modifier
    pub const fn modifier(mut self, modifier: Modifier) -> Self {
        self.modifier = modifier;
        self
    }

    /// Add bold modifier
    pub const fn bold(mut self) -> Self {
        self.modifier = self.modifier.union(Modifier::BOLD);
        self
    }

    /// Add dim modifier
    pub const fn dim(mut self) -> Self {
        self.modifier = self.modifier.union(Modifier::DIM);
        self
    }

    /// Add italic modifier
    pub const fn italic(mut self) -> Self {
        self.modifier = self.modifier.union(Modifier::ITALIC);
        self
    }

    /// Add underline modifier
    pub const fn underlined(mut self) -> Self {
        self.modifier = self.modifier.union(Modifier::UNDERLINED);
        self
    }

    /// Add strikethrough modifier
    pub const fn crossed_out(mut self) -> Self {
        self.modifier = self.modifier.union(Modifier::CROSSED_OUT);
        self
    }

    /// Add reversed modifier (swap fg/bg)
    pub const fn reversed(mut self) -> Self {
        self.modifier = self.modifier.union(Modifier::REVERSED);
        self
    }

    /// Combine this style with another, with other taking precedence
    /// for non-default values
    pub fn patch(self, other: Style) -> Self {
        Self {
            fg: if other.fg == Color::Reset {
                self.fg
            } else {
                other.fg
            },
            bg: if other.bg == Color::Reset {
                self.bg
            } else {
                other.bg
            },
            modifier: self.modifier | other.modifier,
        }
    }
}

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

    #[test]
    fn test_style_default() {
        let s = Style::new();
        assert_eq!(s.fg, Color::Reset);
        assert_eq!(s.bg, Color::Reset);
        assert!(s.modifier.is_empty());
    }

    #[test]
    fn test_style_builder() {
        let s = Style::new().fg(Color::Red).bg(Color::Blue).bold().italic();

        assert_eq!(s.fg, Color::Red);
        assert_eq!(s.bg, Color::Blue);
        assert!(s.modifier.contains(Modifier::BOLD));
        assert!(s.modifier.contains(Modifier::ITALIC));
    }

    #[test]
    fn test_style_patch() {
        let base = Style::new().fg(Color::Red).bold();
        let patch = Style::new().fg(Color::Blue);

        let combined = base.patch(patch);
        assert_eq!(combined.fg, Color::Blue); // Overridden
        assert!(combined.modifier.contains(Modifier::BOLD)); // Preserved
    }

    #[test]
    fn test_style_patch_reset_preserved() {
        let base = Style::new().fg(Color::Red);
        let patch = Style::new(); // All reset

        let combined = base.patch(patch);
        assert_eq!(combined.fg, Color::Red); // Reset doesn't override
    }
}