ralph-agent-loop 0.4.0

A Rust CLI for managing AI agent loops with a structured JSON task queue
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

//! Integration tests for continuous execution mode (`--wait-when-empty` / `--continuous`).
//!
//! Responsibilities:
//! - Test CLI argument parsing for continuous mode flags
//!
//! Not handled here:
//! - Full lifecycle tests (requires mock runner)
//! - Parallel mode tests

use std::process::Command;

mod test_support;

/// Test that --wait-when-empty flag parses correctly.
#[test]
fn run_loop_wait_when_empty_flag_parses() {
    let ralph = test_support::ralph_bin();

    // Test that the flag is recognized (will fail for other reasons, not unknown flag)
    let output = Command::new(&ralph)
        .arg("run")
        .arg("loop")
        .arg("--wait-when-empty")
        .arg("--help")
        .output()
        .expect("Failed to run ralph");

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    // Should succeed (help works)
    assert!(
        output.status.success(),
        "--wait-when-empty flag should be recognized. stdout: {}, stderr: {}",
        stdout,
        stderr
    );

    // Help should mention the flag
    assert!(
        stdout.contains("wait-when-empty") || stdout.contains("continuous"),
        "Help should mention continuous mode flags"
    );
}

/// Test that --continuous alias parses correctly.
#[test]
fn run_loop_continuous_alias_parses() {
    let ralph = test_support::ralph_bin();

    // Test that the alias is recognized
    let output = Command::new(&ralph)
        .arg("run")
        .arg("loop")
        .arg("--continuous")
        .arg("--help")
        .output()
        .expect("Failed to run ralph");

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    // Should succeed (help works)
    assert!(
        output.status.success(),
        "--continuous flag should be recognized. stdout: {}, stderr: {}",
        stdout,
        stderr
    );
}

/// Test that --empty-poll-ms flag parses correctly.
#[test]
fn run_loop_empty_poll_ms_flag_parses() {
    let ralph = test_support::ralph_bin();

    // Test that the flag is recognized
    let output = Command::new(&ralph)
        .arg("run")
        .arg("loop")
        .arg("--empty-poll-ms")
        .arg("5000")
        .arg("--help")
        .output()
        .expect("Failed to run ralph");

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    // Should succeed (help works)
    assert!(
        output.status.success(),
        "--empty-poll-ms flag should be recognized. stdout: {}, stderr: {}",
        stdout,
        stderr
    );

    // Help should mention the flag
    assert!(
        stdout.contains("empty-poll-ms"),
        "Help should mention empty-poll-ms flag"
    );
}

/// Test that --wait-when-empty conflicts with --parallel.
#[test]
fn run_loop_wait_when_empty_conflicts_with_parallel() {
    let ralph = test_support::ralph_bin();

    let output = Command::new(&ralph)
        .arg("run")
        .arg("loop")
        .arg("--wait-when-empty")
        .arg("--parallel")
        .output()
        .expect("Failed to run ralph");

    let stderr = String::from_utf8_lossy(&output.stderr);

    // Should fail due to conflict
    assert!(
        !output.status.success(),
        "--wait-when-empty should conflict with --parallel"
    );
    assert!(
        stderr.contains("cannot be used with") || stderr.contains("conflict"),
        "Error should mention conflict: {}",
        stderr
    );
}