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

//! Tests for phase transitions and state preservation across the pipeline.

use super::*;
use crate::common::domain_types::{AgentName, ModelName};

#[test]
fn test_complete_pipeline_phase_flow() {
    let mut state = create_test_state();
    // This test validates the minimal end-to-end phase progression.
    // Use a single review pass so the post-review commit advances to FinalValidation.
    state.total_reviewer_passes = 1;

    // Planning -> Development
    state = reduce(state, PipelineEvent::planning_phase_started());
    assert_eq!(state.phase, PipelinePhase::Planning);

    state = reduce(state, PipelineEvent::planning_phase_completed());
    assert_eq!(state.phase, PipelinePhase::Development);

    // Development -> Review
    state = reduce(state, PipelineEvent::development_phase_started());
    assert_eq!(state.phase, PipelinePhase::Development);

    state = reduce(state, PipelineEvent::development_phase_completed());
    assert_eq!(state.phase, PipelinePhase::Review);

    // Review -> CommitMessage
    state = reduce(state, PipelineEvent::review_phase_started());
    assert_eq!(state.phase, PipelinePhase::Review);

    state = reduce(state, PipelineEvent::review_phase_completed(false));
    assert_eq!(state.phase, PipelinePhase::CommitMessage);

    // CommitMessage -> FinalValidation
    state = reduce(
        state,
        PipelineEvent::commit_created("abc123".to_string(), "test".to_string()),
    );
    assert_eq!(state.phase, PipelinePhase::FinalValidation);

    // FinalValidation -> Complete
    state = reduce(state, PipelineEvent::pipeline_completed());
    assert_eq!(state.phase, PipelinePhase::Complete);
}

#[test]
fn test_phase_transitions_preserve_iteration_count() {
    let mut state = PipelineState {
        iteration: 3,
        total_iterations: 5,
        ..create_test_state()
    };

    let original_iteration = state.iteration;

    // Transition through phases
    state = reduce(state, PipelineEvent::planning_phase_started());
    assert_eq!(state.iteration, original_iteration);

    state = reduce(state, PipelineEvent::planning_phase_completed());
    assert_eq!(state.iteration, original_iteration);

    state = reduce(state, PipelineEvent::development_phase_started());
    assert_eq!(state.iteration, original_iteration);
}

#[test]
fn test_phase_transitions_preserve_reviewer_pass() {
    let mut state = PipelineState {
        reviewer_pass: 2,
        total_reviewer_passes: 3,
        ..create_test_state()
    };

    let original_pass = state.reviewer_pass;

    // Transition to commit phase
    state = reduce(state, PipelineEvent::review_phase_completed(false));
    assert_eq!(state.reviewer_pass, original_pass);

    // CommitCreated is the moment the pipeline advances the reviewer pass.
    state = reduce(
        state,
        PipelineEvent::commit_created("abc".to_string(), "test".to_string()),
    );
    assert_eq!(state.reviewer_pass, original_pass + 1);
}

#[test]
fn test_commit_skipped_transitions_preserve_phase_history() {
    let state = PipelineState {
        phase: PipelinePhase::CommitMessage,
        iteration: 5,
        reviewer_pass: 2,
        ..create_test_state()
    };

    let new_state = reduce(
        state.clone(),
        PipelineEvent::commit_skipped("No changes".to_string()),
    );

    // Should transition to FinalValidation
    assert_eq!(new_state.phase, PipelinePhase::FinalValidation);
    // Should preserve counters
    assert_eq!(new_state.iteration, state.iteration);
    assert_eq!(new_state.reviewer_pass, state.reviewer_pass);
}

#[test]
fn test_state_preservation_through_agent_events() {
    let state = PipelineState {
        phase: PipelinePhase::Development,
        iteration: 3,
        reviewer_pass: 1,
        review_issues_found: true,
        ..create_test_state()
    };

    // Agent events should not modify phase or counters
    let new_state = reduce(
        state.clone(),
        PipelineEvent::agent_invocation_started(
            crate::agents::AgentRole::Developer,
            AgentName::from("test"),
            Some(ModelName::from("test-model")),
        ),
    );

    assert_eq!(new_state.phase, state.phase);
    assert_eq!(new_state.iteration, state.iteration);
    assert_eq!(new_state.reviewer_pass, state.reviewer_pass);
    assert_eq!(new_state.review_issues_found, state.review_issues_found);
}