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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Integration tests for `ralph queue prune`.
//!
//! Responsibilities:
//! - Verify age/status filters remove the intended done tasks.
//! - Verify `--keep-last` protects most recent completions.
//! - Verify `--dry-run` does not mutate disk state.
//! - Verify safety rule: missing/invalid `completed_at` does not match age filter.
//!
//! Not handled here:
//! - Internal ordering/algorithm unit tests (covered near implementation).
//! - Snapshot testing of logs (prefer state assertions).
//!
//! Invariants/assumptions:
//! - Prune operates only on `.ralph/done.jsonc`.
//! - `--keep-last` uses `completed_at` ordering (missing/invalid treated oldest).

use anyhow::Result;
use chrono::{Duration, SecondsFormat, Utc};
use ralph::contracts::TaskStatus;

mod test_support;

fn rfc3339_days_ago(days: i64) -> String {
    (Utc::now() - Duration::days(days)).to_rfc3339_opts(SecondsFormat::Secs, true)
}

#[test]
fn queue_prune_dry_run_does_not_modify_done_file() -> Result<()> {
    let dir = test_support::temp_dir_outside_repo();
    test_support::git_init(dir.path())?;
    test_support::seed_ralph_dir(dir.path())?;

    let mut old = test_support::make_test_task("RQ-0100", "Old done", TaskStatus::Done);
    old.completed_at = Some(rfc3339_days_ago(45));
    let mut recent = test_support::make_test_task("RQ-0101", "Recent done", TaskStatus::Done);
    recent.completed_at = Some(rfc3339_days_ago(5));

    test_support::write_done(dir.path(), &[old, recent])?;

    let before = std::fs::read_to_string(dir.path().join(".ralph/done.jsonc"))?;
    let (status, _stdout, stderr) =
        test_support::run_in_dir(dir.path(), &["queue", "prune", "--dry-run", "--age", "30"]);
    anyhow::ensure!(status.success(), "prune dry-run failed\nstderr:\n{stderr}");
    let after = std::fs::read_to_string(dir.path().join(".ralph/done.jsonc"))?;

    anyhow::ensure!(before == after, "done.json mutated during --dry-run");
    Ok(())
}

#[test]
fn queue_prune_age_filter_respects_keep_last() -> Result<()> {
    let dir = test_support::temp_dir_outside_repo();
    test_support::git_init(dir.path())?;
    test_support::seed_ralph_dir(dir.path())?;

    let mut a = test_support::make_test_task("RQ-0200", "A", TaskStatus::Done);
    a.completed_at = Some(rfc3339_days_ago(40));
    let mut b = test_support::make_test_task("RQ-0201", "B", TaskStatus::Done);
    b.completed_at = Some(rfc3339_days_ago(35));
    let mut c = test_support::make_test_task("RQ-0202", "C", TaskStatus::Done);
    c.completed_at = Some(rfc3339_days_ago(31));
    let mut d = test_support::make_test_task("RQ-0203", "D", TaskStatus::Done);
    d.completed_at = Some(rfc3339_days_ago(5));

    test_support::write_done(dir.path(), &[a, b, c, d])?;

    let (status, _stdout, stderr) = test_support::run_in_dir(
        dir.path(),
        &["queue", "prune", "--age", "30", "--keep-last", "2"],
    );
    anyhow::ensure!(status.success(), "prune failed\nstderr:\n{stderr}");

    let done = test_support::read_done(dir.path())?;
    let ids: Vec<_> = done.tasks.iter().map(|t| t.id.as_str()).collect();

    anyhow::ensure!(
        ids.contains(&"RQ-0202") && ids.contains(&"RQ-0203"),
        "expected keep-last protection; got {ids:?}"
    );
    anyhow::ensure!(
        !ids.contains(&"RQ-0200") && !ids.contains(&"RQ-0201"),
        "expected old tasks pruned; got {ids:?}"
    );

    Ok(())
}

#[test]
fn queue_prune_missing_completed_at_does_not_match_age_filter() -> Result<()> {
    let dir = test_support::temp_dir_outside_repo();
    test_support::git_init(dir.path())?;
    test_support::seed_ralph_dir(dir.path())?;

    let mut old = test_support::make_test_task("RQ-0300", "Old", TaskStatus::Done);
    old.completed_at = Some(rfc3339_days_ago(60));

    let mut missing =
        test_support::make_test_task("RQ-0301", "Missing completed_at", TaskStatus::Done);
    missing.completed_at = None;

    let mut invalid =
        test_support::make_test_task("RQ-0302", "Invalid completed_at", TaskStatus::Done);
    invalid.completed_at = Some("not-a-timestamp".to_string());

    test_support::write_done(dir.path(), &[old, missing, invalid])?;

    let (status, _stdout, stderr) =
        test_support::run_in_dir(dir.path(), &["queue", "prune", "--age", "30"]);
    anyhow::ensure!(status.success(), "prune failed\nstderr:\n{stderr}");

    let done = test_support::read_done(dir.path())?;
    let ids: Vec<_> = done.tasks.iter().map(|t| t.id.as_str()).collect();

    anyhow::ensure!(
        !ids.contains(&"RQ-0300"),
        "expected old task pruned; got {ids:?}"
    );
    anyhow::ensure!(
        ids.contains(&"RQ-0301"),
        "missing completed_at should be kept for age filter; got {ids:?}"
    );
    anyhow::ensure!(
        ids.contains(&"RQ-0302"),
        "invalid completed_at should be kept for age filter; got {ids:?}"
    );

    Ok(())
}

#[test]
fn queue_prune_status_filter_works() -> Result<()> {
    let dir = test_support::temp_dir_outside_repo();
    test_support::git_init(dir.path())?;
    test_support::seed_ralph_dir(dir.path())?;

    let mut done_old = test_support::make_test_task("RQ-0400", "Old done", TaskStatus::Done);
    done_old.completed_at = Some(rfc3339_days_ago(45));

    let mut rejected_old =
        test_support::make_test_task("RQ-0401", "Old rejected", TaskStatus::Rejected);
    rejected_old.completed_at = Some(rfc3339_days_ago(45));

    test_support::write_done(dir.path(), &[done_old, rejected_old])?;

    // Only prune rejected tasks older than 30 days
    let (status, _stdout, stderr) = test_support::run_in_dir(
        dir.path(),
        &["queue", "prune", "--age", "30", "--status", "rejected"],
    );
    anyhow::ensure!(status.success(), "prune failed\nstderr:\n{stderr}");

    let done = test_support::read_done(dir.path())?;
    let ids: Vec<_> = done.tasks.iter().map(|t| t.id.as_str()).collect();

    anyhow::ensure!(
        ids.contains(&"RQ-0400"),
        "done task should be kept when filtering by rejected; got {ids:?}"
    );
    anyhow::ensure!(
        !ids.contains(&"RQ-0401"),
        "rejected task should be pruned; got {ids:?}"
    );

    Ok(())
}