ralph-workflow 0.7.18

PROMPT-driven multi-agent orchestrator for git repos
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
145
146

//! Functional and other language review guidelines
//!
//! Contains guidelines for Elixir, Scala, and Swift projects.

use super::base::ReviewGuidelines;

/// Add Elixir-specific guidelines to the review
pub fn add_elixir_guidelines(guidelines: ReviewGuidelines) -> ReviewGuidelines {
    ReviewGuidelines {
        quality_checks: guidelines
            .quality_checks
            .into_iter()
            .chain([
                "Use pattern matching effectively".to_string(),
                "Follow pipe operator conventions".to_string(),
                "Use dialyzer for type checking".to_string(),
            ])
            .collect(),
        performance_checks: guidelines
            .performance_checks
            .into_iter()
            .chain([
                "Use streams for large data processing".to_string(),
                "Consider GenServer state design".to_string(),
            ])
            .collect(),
        idioms: guidelines
            .idioms
            .into_iter()
            .chain([
                "Let it crash - use supervisors".to_string(),
                "Use with for happy path chaining".to_string(),
            ])
            .collect(),
        ..guidelines
    }
}

pub fn add_scala_guidelines(guidelines: ReviewGuidelines) -> ReviewGuidelines {
    ReviewGuidelines {
        quality_checks: guidelines
            .quality_checks
            .into_iter()
            .chain([
                "Use immutable collections".to_string(),
                "Prefer Option over null".to_string(),
                "Use pattern matching".to_string(),
                "Follow functional programming principles".to_string(),
            ])
            .collect(),
        anti_patterns: guidelines
            .anti_patterns
            .into_iter()
            .chain([
                "Avoid mutable state".to_string(),
                "Don't use return statements".to_string(),
                "Avoid throwing exceptions".to_string(),
            ])
            .collect(),
        ..guidelines
    }
}

pub fn add_swift_guidelines(guidelines: ReviewGuidelines) -> ReviewGuidelines {
    ReviewGuidelines {
        quality_checks: guidelines
            .quality_checks
            .into_iter()
            .chain([
                "Use optionals correctly".to_string(),
                "Follow Swift API design guidelines".to_string(),
                "Use value types where appropriate".to_string(),
                "Leverage Swift's type inference".to_string(),
            ])
            .collect(),
        security_checks: guidelines
            .security_checks
            .into_iter()
            .chain([
                "Use Keychain for sensitive data".to_string(),
                "Validate URL schemes".to_string(),
            ])
            .collect(),
        anti_patterns: guidelines
            .anti_patterns
            .into_iter()
            .chain([
                "Avoid force unwrapping (!)".to_string(),
                "Don't use implicitly unwrapped optionals unnecessarily".to_string(),
            ])
            .collect(),
        ..guidelines
    }
}

#[cfg(test)]
mod tests {
    use super::{
        add_elixir_guidelines, add_scala_guidelines, add_swift_guidelines, ReviewGuidelines,
    };

    #[test]
    fn test_elixir_guidelines() {
        let guidelines = add_elixir_guidelines(ReviewGuidelines::default());

        // Should have Elixir-specific checks
        assert!(guidelines
            .quality_checks
            .iter()
            .any(|c| c.contains("pattern matching") || c.contains("pipe")));
        assert!(guidelines
            .idioms
            .iter()
            .any(|c| c.contains("crash") || c.contains("supervisor")));
    }

    #[test]
    fn test_scala_guidelines() {
        let guidelines = add_scala_guidelines(ReviewGuidelines::default());

        // Should have Scala-specific checks
        assert!(guidelines
            .quality_checks
            .iter()
            .any(|c| c.contains("immutable") || c.contains("Option")));
        assert!(guidelines
            .anti_patterns
            .iter()
            .any(|c| c.contains("mutable")));
    }

    #[test]
    fn test_swift_guidelines() {
        let guidelines = add_swift_guidelines(ReviewGuidelines::default());

        // Should have Swift-specific checks
        assert!(guidelines
            .quality_checks
            .iter()
            .any(|c| c.contains("optional")));
        assert!(guidelines
            .anti_patterns
            .iter()
            .any(|c| c.contains("force unwrapping") || c.contains('!')));
    }
}