aptitude 0.3.1

A test harness for validating AI agent behavior against steering guides
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

//! Configuration for output display.

use std::io::IsTerminal;

/// When to display output.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub enum OutputMode {
    /// Always show output regardless of test result.
    Always,
    /// Only show output when tests fail (default).
    #[default]
    OnFailure,
    /// Never show output.
    Never,
}

/// Configuration for output display.
///
/// Use the builder pattern to configure what gets displayed:
///
/// ```rust,ignore
/// use aptitude::output::{OutputConfig, OutputMode};
///
/// let config = OutputConfig::new()
///     .tool_calls(OutputMode::Always)
///     .response(OutputMode::OnFailure)
///     .truncate_at(80);
/// ```
#[derive(Debug, Clone)]
pub struct OutputConfig {
    /// When to show tool calls made during execution.
    pub tool_calls: OutputMode,
    /// When to show Claude's response output.
    pub response: OutputMode,
    /// Maximum characters before truncating parameter values.
    pub truncate_at: usize,
    /// Whether to use ANSI colors in output.
    pub colors_enabled: bool,
}

impl Default for OutputConfig {
    fn default() -> Self {
        Self {
            tool_calls: OutputMode::OnFailure,
            response: OutputMode::OnFailure,
            truncate_at: 1000,
            colors_enabled: std::io::stdout().is_terminal(),
        }
    }
}

impl OutputConfig {
    /// Create a new output configuration with defaults.
    ///
    /// Default: `OnFailure` for both tool calls and response,
    /// 1000 character truncation, colors auto-detected from TTY.
    pub fn new() -> Self {
        Self::default()
    }

    /// Configure when to show tool calls.
    pub fn tool_calls(mut self, mode: OutputMode) -> Self {
        self.tool_calls = mode;
        self
    }

    /// Configure when to show Claude's response.
    pub fn response(mut self, mode: OutputMode) -> Self {
        self.response = mode;
        self
    }

    /// Set the maximum characters before truncating parameter values.
    pub fn truncate_at(mut self, chars: usize) -> Self {
        self.truncate_at = chars;
        self
    }

    /// Enable or disable ANSI colors.
    pub fn colors(mut self, enabled: bool) -> Self {
        self.colors_enabled = enabled;
        self
    }

    /// Create a verbose configuration that always shows everything.
    pub fn verbose() -> Self {
        Self {
            tool_calls: OutputMode::Always,
            response: OutputMode::Always,
            ..Self::default()
        }
    }

    /// Create a quiet configuration that never shows output.
    pub fn quiet() -> Self {
        Self {
            tool_calls: OutputMode::Never,
            response: OutputMode::Never,
            ..Self::default()
        }
    }
}

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

    #[test]
    fn test_default_config() {
        let config = OutputConfig::new();
        assert_eq!(config.tool_calls, OutputMode::OnFailure);
        assert_eq!(config.response, OutputMode::OnFailure);
        assert_eq!(config.truncate_at, 1000);
    }

    #[test]
    fn test_verbose_config() {
        let config = OutputConfig::verbose();
        assert_eq!(config.tool_calls, OutputMode::Always);
        assert_eq!(config.response, OutputMode::Always);
    }

    #[test]
    fn test_quiet_config() {
        let config = OutputConfig::quiet();
        assert_eq!(config.tool_calls, OutputMode::Never);
        assert_eq!(config.response, OutputMode::Never);
    }

    #[test]
    fn test_builder_chain() {
        let config = OutputConfig::new()
            .tool_calls(OutputMode::Always)
            .response(OutputMode::Never)
            .truncate_at(100)
            .colors(false);

        assert_eq!(config.tool_calls, OutputMode::Always);
        assert_eq!(config.response, OutputMode::Never);
        assert_eq!(config.truncate_at, 100);
        assert!(!config.colors_enabled);
    }
}