nika 0.35.4

Semantic YAML workflow engine for AI tasks - DAG execution, MCP integration, multi-provider LLM support
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

//! Verbosity control for CLI output.

use std::fmt;
use std::str::FromStr;

/// Controls how much telemetry is displayed during `nika run`.
///
/// Levels (most -> least verbose):
/// - `max`: All events, previews, sparklines, full summary (DEFAULT)
/// - `default`: Task lifecycle + provider + MCP + errors
/// - `min`: Task checkmark/cross lines only + compact summary
/// - `json`: Raw NDJSON events to stdout
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub enum DetailLevel {
    #[default]
    Max,
    Default,
    Min,
    Json,
}

impl DetailLevel {
    pub fn show_sub_events(&self) -> bool {
        matches!(self, Self::Max | Self::Default)
    }

    pub fn show_previews(&self) -> bool {
        matches!(self, Self::Max)
    }

    pub fn show_sparklines(&self) -> bool {
        matches!(self, Self::Max)
    }

    pub fn show_full_summary(&self) -> bool {
        matches!(self, Self::Max | Self::Default)
    }

    pub fn show_layer_separators(&self) -> bool {
        matches!(self, Self::Max)
    }

    pub fn is_json(&self) -> bool {
        matches!(self, Self::Json)
    }

    pub fn show_template_events(&self) -> bool {
        matches!(self, Self::Max)
    }
}

impl fmt::Display for DetailLevel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Max => write!(f, "max"),
            Self::Default => write!(f, "default"),
            Self::Min => write!(f, "min"),
            Self::Json => write!(f, "json"),
        }
    }
}

impl FromStr for DetailLevel {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "max" => Ok(Self::Max),
            "default" => Ok(Self::Default),
            "min" => Ok(Self::Min),
            "json" => Ok(Self::Json),
            _ => Err(format!(
                "invalid detail level '{}': expected max, default, min, or json",
                s
            )),
        }
    }
}

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

    #[test]
    fn test_detail_level_from_str() {
        assert_eq!(DetailLevel::from_str("max").unwrap(), DetailLevel::Max);
        assert_eq!(
            DetailLevel::from_str("default").unwrap(),
            DetailLevel::Default
        );
        assert_eq!(DetailLevel::from_str("min").unwrap(), DetailLevel::Min);
        assert_eq!(DetailLevel::from_str("json").unwrap(), DetailLevel::Json);
        assert_eq!(DetailLevel::from_str("MAX").unwrap(), DetailLevel::Max);
        assert!(DetailLevel::from_str("invalid").is_err());
    }

    #[test]
    fn test_default_is_max() {
        assert_eq!(DetailLevel::default(), DetailLevel::Max);
    }

    #[test]
    fn test_visibility_max() {
        let d = DetailLevel::Max;
        assert!(d.show_sub_events());
        assert!(d.show_previews());
        assert!(d.show_sparklines());
        assert!(d.show_full_summary());
        assert!(d.show_layer_separators());
        assert!(d.show_template_events());
        assert!(!d.is_json());
    }

    #[test]
    fn test_visibility_default() {
        let d = DetailLevel::Default;
        assert!(d.show_sub_events());
        assert!(!d.show_previews());
        assert!(!d.show_sparklines());
        assert!(d.show_full_summary());
        assert!(!d.show_layer_separators());
        assert!(!d.show_template_events());
        assert!(!d.is_json());
    }

    #[test]
    fn test_visibility_min() {
        let d = DetailLevel::Min;
        assert!(!d.show_sub_events());
        assert!(!d.show_previews());
        assert!(!d.show_sparklines());
        assert!(!d.show_full_summary());
        assert!(!d.show_layer_separators());
        assert!(!d.show_template_events());
        assert!(!d.is_json());
    }

    #[test]
    fn test_visibility_json() {
        let d = DetailLevel::Json;
        assert!(!d.show_sub_events());
        assert!(d.is_json());
    }
}