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

//! Runner list command.
//!
//! Responsibilities:
//! - List all available runners with brief descriptions.

use anyhow::Result;
use serde::Serialize;

use crate::cli::runner::RunnerFormat;
use crate::contracts::Runner;
use crate::runner::default_model_for_runner;

#[derive(Debug, Clone, Serialize)]
pub struct RunnerInfo {
    pub id: String,
    pub name: String,
    pub provider: String,
    pub default_model: String,
}

fn get_all_runners() -> Vec<RunnerInfo> {
    vec![
        RunnerInfo {
            id: "claude".into(),
            name: "Anthropic Claude Code".into(),
            provider: "Anthropic".into(),
            default_model: default_model_for_runner(&Runner::Claude)
                .as_str()
                .to_string(),
        },
        RunnerInfo {
            id: "codex".into(),
            name: "OpenAI Codex CLI".into(),
            provider: "OpenAI".into(),
            default_model: default_model_for_runner(&Runner::Codex)
                .as_str()
                .to_string(),
        },
        RunnerInfo {
            id: "opencode".into(),
            name: "Opencode".into(),
            provider: "Flexible".into(),
            default_model: default_model_for_runner(&Runner::Opencode)
                .as_str()
                .to_string(),
        },
        RunnerInfo {
            id: "gemini".into(),
            name: "Google Gemini CLI".into(),
            provider: "Google".into(),
            default_model: default_model_for_runner(&Runner::Gemini)
                .as_str()
                .to_string(),
        },
        RunnerInfo {
            id: "cursor".into(),
            name: "Cursor Agent".into(),
            provider: "Cursor".into(),
            default_model: default_model_for_runner(&Runner::Cursor)
                .as_str()
                .to_string(),
        },
        RunnerInfo {
            id: "kimi".into(),
            name: "Kimi CLI".into(),
            provider: "Moonshot AI".into(),
            default_model: default_model_for_runner(&Runner::Kimi).as_str().to_string(),
        },
        RunnerInfo {
            id: "pi".into(),
            name: "Pi Coding Agent".into(),
            provider: "Pi".into(),
            default_model: default_model_for_runner(&Runner::Pi).as_str().to_string(),
        },
    ]
}

pub fn handle_list(format: RunnerFormat) -> Result<()> {
    let runners = get_all_runners();

    match format {
        RunnerFormat::Text => {
            println!("Available runners:\n");
            for r in &runners {
                println!("  {:12} {} (default: {})", r.id, r.name, r.default_model);
            }
            println!("\nUse 'ralph runner capabilities <id>' for details.");
        }
        RunnerFormat::Json => {
            println!("{}", serde_json::to_string_pretty(&runners)?);
        }
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn get_all_runners_returns_all_built_ins() {
        let runners = get_all_runners();
        assert_eq!(runners.len(), 7);

        let ids: Vec<_> = runners.iter().map(|r| r.id.as_str()).collect();
        assert!(ids.contains(&"claude"));
        assert!(ids.contains(&"codex"));
        assert!(ids.contains(&"opencode"));
        assert!(ids.contains(&"gemini"));
        assert!(ids.contains(&"cursor"));
        assert!(ids.contains(&"kimi"));
        assert!(ids.contains(&"pi"));
    }

    #[test]
    fn runner_info_has_required_fields() {
        let runners = get_all_runners();
        for r in &runners {
            assert!(!r.id.is_empty(), "runner {} has empty id", r.name);
            assert!(!r.name.is_empty(), "runner {} has empty name", r.id);
            assert!(!r.provider.is_empty(), "runner {} has empty provider", r.id);
            assert!(
                !r.default_model.is_empty(),
                "runner {} has empty default_model",
                r.id
            );
        }
    }
}