cruise 0.1.35

YAML-driven coding agent workflow orchestrator
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

use inquire::{InquireError, Select};

use crate::error::{CruiseError, Result};
use crate::step::OptionChoice;

/// Result of executing an option step.
#[derive(Debug, Clone)]
pub struct OptionResult {
    /// Next step name chosen by the user (None = end of workflow).
    pub next_step: Option<String>,

    /// Text entered by the user when a text-input choice was selected.
    pub text_input: Option<String>,
}

/// Display an interactive selection menu and return the user's choice.
///
/// # Errors
///
/// Returns an error if the user interaction fails or the choices list is invalid.
pub fn run_option(choices: &[OptionChoice], description: Option<&str>) -> Result<OptionResult> {
    if let Some(desc) = description {
        crate::display::print_bordered(desc, Some("Plan"));
    }

    // Build the label list shown to the user.
    let labels: Vec<&str> = choices.iter().map(super::OptionChoice::label).collect();

    if labels.is_empty() {
        // Nothing to select -- continue to the next step.
        return Ok(OptionResult {
            next_step: None,
            text_input: None,
        });
    }

    let selected_label = match Select::new("Select an option", labels).prompt() {
        Ok(label) => label,
        Err(InquireError::OperationCanceled | InquireError::OperationInterrupted) => {
            return Err(CruiseError::StepPaused);
        }
        Err(e) => {
            return Err(crate::error::CruiseError::Other(format!(
                "selection error: {e}"
            )));
        }
    };

    let selection = choices
        .iter()
        .position(|c| c.label() == selected_label)
        .ok_or_else(|| crate::error::CruiseError::Other("selected item not found".to_string()))?;

    match &choices[selection] {
        OptionChoice::Selector { next, .. } => Ok(OptionResult {
            next_step: next.clone(),
            text_input: None,
        }),
        OptionChoice::TextInput { label, next } => {
            let text = crate::multiline_input::prompt_multiline(label)?.into_result()?;

            Ok(OptionResult {
                next_step: next.clone(),
                text_input: Some(text),
            })
        }
    }
}

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

    #[test]
    fn test_option_choice_selector() {
        let choice = OptionChoice::Selector {
            label: "Option A".to_string(),
            next: Some("step_a".to_string()),
        };
        match choice {
            OptionChoice::Selector { label, next } => {
                assert_eq!(label, "Option A");
                assert_eq!(next, Some("step_a".to_string()));
            }
            OptionChoice::TextInput { .. } => panic!("Expected Selector"),
        }
    }

    #[test]
    fn test_option_choice_text_input() {
        let choice = OptionChoice::TextInput {
            label: "Enter text".to_string(),
            next: Some("next_step".to_string()),
        };
        match choice {
            OptionChoice::TextInput { label, next } => {
                assert_eq!(label, "Enter text");
                assert_eq!(next, Some("next_step".to_string()));
            }
            OptionChoice::Selector { .. } => panic!("Expected TextInput"),
        }
    }

    #[test]
    fn test_option_result_with_next() {
        let result = OptionResult {
            next_step: Some("implement".to_string()),
            text_input: None,
        };
        assert_eq!(result.next_step, Some("implement".to_string()));
        assert!(result.text_input.is_none());
    }

    #[test]
    fn test_option_result_with_text_input() {
        let result = OptionResult {
            next_step: Some("planning".to_string()),
            text_input: Some("user input".to_string()),
        };
        assert_eq!(result.text_input, Some("user input".to_string()));
    }

    #[test]
    fn test_option_result_no_fields() {
        let result = OptionResult {
            next_step: None,
            text_input: None,
        };
        assert!(result.next_step.is_none());
    }
}