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

use crate::agents::AgentRole;
use crate::reducer::effect::{Effect, EffectResult};
use crate::reducer::event::{PipelineEvent, PipelinePhase};
use crate::reducer::ui_event::UIEvent;

#[test]
fn test_effect_serialization() {
    let effect = Effect::AgentInvocation {
        role: AgentRole::Developer,
        agent: "claude".to_string(),
        model: None,
        prompt: "test".to_string(),
    };

    let json = serde_json::to_string(&effect).unwrap();
    let deserialized: Effect = serde_json::from_str(&json).unwrap();

    match deserialized {
        Effect::AgentInvocation {
            role,
            agent,
            model,
            prompt,
        } => {
            assert_eq!(role, AgentRole::Developer);
            assert_eq!(agent, "claude");
            assert!(model.is_none());
            assert_eq!(prompt, "test");
        }
        _ => panic!("Expected AgentInvocation effect"),
    }
}

#[test]
fn test_effect_result_event_only() {
    let event = PipelineEvent::pipeline_started();
    let result = EffectResult::event(event);

    assert!(matches!(
        result.event,
        PipelineEvent::Lifecycle(crate::reducer::event::LifecycleEvent::Started)
    ));
    assert!(result.ui_events.is_empty());
}

#[test]
fn test_effect_result_with_ui() {
    let event = PipelineEvent::development_iteration_completed(1, true);
    let ui_events = vec![UIEvent::IterationProgress {
        current: 1,
        total: 3,
    }];

    let result = EffectResult::with_ui(event, ui_events);

    assert!(matches!(
        result.event,
        PipelineEvent::Development(
            crate::reducer::event::DevelopmentEvent::IterationCompleted { .. }
        )
    ));
    assert_eq!(result.ui_events.len(), 1);
    assert!(matches!(
        result.ui_events[0],
        UIEvent::IterationProgress {
            current: 1,
            total: 3
        }
    ));
}

#[test]
fn test_effect_result_with_ui_event_builder() {
    let event = PipelineEvent::plan_generation_completed(1, true);

    let result = EffectResult::event(event).with_ui_event(UIEvent::PhaseTransition {
        from: Some(PipelinePhase::Planning),
        to: PipelinePhase::Development,
    });

    assert_eq!(result.ui_events.len(), 1);
    assert!(matches!(
        result.ui_events[0],
        UIEvent::PhaseTransition { .. }
    ));
}

#[test]
fn test_effect_result_multiple_ui_events() {
    let event = PipelineEvent::development_iteration_completed(2, true);

    let result = EffectResult::event(event)
        .with_ui_event(UIEvent::IterationProgress {
            current: 2,
            total: 5,
        })
        .with_ui_event(UIEvent::AgentActivity {
            agent: "claude".to_string(),
            message: "Completed iteration".to_string(),
        });

    assert_eq!(result.ui_events.len(), 2);
    assert!(matches!(
        result.ui_events[0],
        UIEvent::IterationProgress {
            current: 2,
            total: 5
        }
    ));
    assert!(matches!(result.ui_events[1], UIEvent::AgentActivity { .. }));
}