Skip to main content

ralph_workflow/cli/reducer/
state.rs

1//! CLI argument state.
2//!
3//! This module defines the state structure that accumulates CLI argument values
4//! as events are processed through the reducer.
5
6use serde::{Deserialize, Serialize};
7
8/// Preset type for iteration count defaults.
9///
10/// Each preset defines default values for developer iterations and reviewer reviews.
11/// These can be overridden by explicit -D/-R flags.
12#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
13pub enum PresetType {
14    /// Quick mode: 1 dev iteration, 1 review pass (-Q)
15    Quick,
16    /// Rapid mode: 2 dev iterations, 1 review pass (-U)
17    Rapid,
18    /// Long mode: 15 dev iterations, 10 review passes (-L)
19    Long,
20    /// Standard mode: 5 dev iterations, 2 review passes (-S)
21    Standard,
22    /// Thorough mode: 10 dev iterations, 5 review passes (-T)
23    Thorough,
24}
25
26impl PresetType {
27    /// Get the (`developer_iters`, `reviewer_reviews`) counts for this preset.
28    #[must_use]
29    pub const fn iteration_counts(self) -> (u32, u32) {
30        match self {
31            Self::Quick => (1, 1),
32            Self::Rapid => (2, 1),
33            Self::Long => (15, 10),
34            Self::Standard => (5, 2),
35            Self::Thorough => (10, 5),
36        }
37    }
38
39    /// Get the developer iterations for this preset.
40    #[must_use]
41    pub const fn developer_iters(self) -> u32 {
42        self.iteration_counts().0
43    }
44
45    /// Get the reviewer reviews for this preset.
46    #[must_use]
47    pub const fn reviewer_reviews(self) -> u32 {
48        self.iteration_counts().1
49    }
50}
51
52/// CLI argument state (intermediate representation before Config).
53///
54/// This struct accumulates parsed CLI argument values as events are processed.
55/// Values of `None` indicate the argument was not specified and should fall back
56/// to config file or default values.
57#[derive(Clone, Debug, Default, Serialize, Deserialize)]
58pub struct CliState {
59    // ===== Verbosity =====
60    /// Explicit verbosity level (0-4)
61    pub verbosity: Option<u8>,
62    /// Quiet mode flag (--quiet)
63    pub quiet_mode: bool,
64    /// Full mode flag (--full)
65    pub full_mode: bool,
66    /// Debug mode flag (--debug)
67    pub debug_mode: bool,
68
69    // ===== Preset =====
70    /// Which preset was applied (last wins if multiple specified)
71    pub preset_applied: Option<PresetType>,
72
73    // ===== Iteration Counts =====
74    /// Explicit developer iterations (-D/--developer-iters)
75    pub developer_iters: Option<u32>,
76    /// Explicit reviewer reviews (-R/--reviewer-reviews)
77    pub reviewer_reviews: Option<u32>,
78
79    // ===== Agent Selection =====
80    /// Developer agent name
81    pub developer_agent: Option<String>,
82    /// Reviewer agent name
83    pub reviewer_agent: Option<String>,
84    /// Developer model override
85    pub developer_model: Option<String>,
86    /// Reviewer model override
87    pub reviewer_model: Option<String>,
88    /// Developer provider override
89    pub developer_provider: Option<String>,
90    /// Reviewer provider override
91    pub reviewer_provider: Option<String>,
92    /// Reviewer JSON parser override
93    pub reviewer_json_parser: Option<String>,
94
95    // ===== Configuration =====
96    /// Isolation mode setting (None = use config default, Some(false) = disabled)
97    pub isolation_mode: Option<bool>,
98    /// Review depth level
99    pub review_depth: Option<String>,
100    /// Git user name for commits
101    pub git_user_name: Option<String>,
102    /// Git user email for commits
103    pub git_user_email: Option<String>,
104    /// Show streaming metrics flag
105    pub streaming_metrics: bool,
106
107    // ===== Agent Preset =====
108    /// Named agent preset (default, opencode)
109    pub agent_preset: Option<String>,
110
111    // ===== Processing Status =====
112    /// Whether CLI processing is complete
113    pub complete: bool,
114}
115
116impl CliState {
117    /// Create a new initial state.
118    #[must_use]
119    pub fn initial() -> Self {
120        Self::default()
121    }
122
123    /// Resolve final developer iterations count.
124    ///
125    /// Priority order:
126    /// 1. Explicit -D/--developer-iters flag
127    /// 2. Preset default (if a preset was applied)
128    /// 3. Config default (passed as argument)
129    #[must_use]
130    pub fn resolved_developer_iters(&self, config_default: u32) -> u32 {
131        self.developer_iters.unwrap_or_else(|| {
132            self.preset_applied
133                .map_or(config_default, PresetType::developer_iters)
134        })
135    }
136
137    /// Resolve final reviewer reviews count.
138    ///
139    /// Priority order:
140    /// 1. Explicit -R/--reviewer-reviews flag
141    /// 2. Preset default (if a preset was applied)
142    /// 3. Config default (passed as argument)
143    #[must_use]
144    pub fn resolved_reviewer_reviews(&self, config_default: u32) -> u32 {
145        self.reviewer_reviews.unwrap_or_else(|| {
146            self.preset_applied
147                .map_or(config_default, PresetType::reviewer_reviews)
148        })
149    }
150}
151
152#[cfg(test)]
153mod tests {
154    use super::*;
155
156    #[test]
157    fn test_preset_iteration_counts() {
158        assert_eq!(PresetType::Quick.iteration_counts(), (1, 1));
159        assert_eq!(PresetType::Rapid.iteration_counts(), (2, 1));
160        assert_eq!(PresetType::Long.iteration_counts(), (15, 10));
161        assert_eq!(PresetType::Standard.iteration_counts(), (5, 2));
162        assert_eq!(PresetType::Thorough.iteration_counts(), (10, 5));
163    }
164
165    #[test]
166    fn test_preset_individual_accessors() {
167        assert_eq!(PresetType::Quick.developer_iters(), 1);
168        assert_eq!(PresetType::Quick.reviewer_reviews(), 1);
169        assert_eq!(PresetType::Long.developer_iters(), 15);
170        assert_eq!(PresetType::Long.reviewer_reviews(), 10);
171    }
172
173    #[test]
174    fn test_initial_state() {
175        let state = CliState::initial();
176        assert!(!state.complete);
177        assert!(state.preset_applied.is_none());
178        assert!(state.developer_iters.is_none());
179        assert!(state.reviewer_reviews.is_none());
180        assert!(!state.quiet_mode);
181        assert!(!state.streaming_metrics);
182    }
183
184    #[test]
185    fn test_resolved_iters_explicit_override() {
186        let state = CliState {
187            preset_applied: Some(PresetType::Quick),
188            developer_iters: Some(10),
189            reviewer_reviews: Some(5),
190            ..CliState::initial()
191        };
192
193        // Explicit values take precedence over preset
194        assert_eq!(state.resolved_developer_iters(99), 10);
195        assert_eq!(state.resolved_reviewer_reviews(99), 5);
196    }
197
198    #[test]
199    fn test_resolved_iters_preset_fallback() {
200        let state = CliState {
201            preset_applied: Some(PresetType::Long),
202            ..CliState::initial()
203        };
204
205        // Preset values used when no explicit override
206        assert_eq!(state.resolved_developer_iters(99), 15);
207        assert_eq!(state.resolved_reviewer_reviews(99), 10);
208    }
209
210    #[test]
211    fn test_resolved_iters_config_fallback() {
212        let state = CliState::initial();
213
214        // Config defaults used when no preset or explicit override
215        assert_eq!(state.resolved_developer_iters(5), 5);
216        assert_eq!(state.resolved_reviewer_reviews(2), 2);
217    }
218
219    #[test]
220    fn test_state_serialization() {
221        let state = CliState {
222            preset_applied: Some(PresetType::Thorough),
223            developer_agent: Some("claude".to_string()),
224            ..CliState::initial()
225        };
226
227        let json = serde_json::to_string(&state).unwrap();
228        let deserialized: CliState = serde_json::from_str(&json).unwrap();
229
230        assert_eq!(state.preset_applied, deserialized.preset_applied);
231        assert_eq!(state.developer_agent, deserialized.developer_agent);
232    }
233}