rho-coding-agent 2.5.0

A fast Rust agent harness with a small footprint and opinionated defaults
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

use clap::Parser;
use pretty_assertions::assert_eq;
use serde_json::json;

use super::*;
use crate::doctor::{DoctorCheck, DoctorCheckId, DoctorStatus};

// Covers: `rho doctor --json` emits summary counts plus sections with
// snake_case status and tagged check ids.
// Owner: CLI (pure serialization)
#[test]
fn json_document_carries_summary_and_sections() {
    let report = DoctorReport::from_checks(vec![
        DoctorCheck::new(
            DoctorCheckId::ProviderAuth {
                auth_mode: "openai-api-key".into(),
            },
            "OpenAI API key",
            DoctorStatus::Ok,
            "authenticated",
        ),
        DoctorCheck::new(DoctorCheckId::Mcp, "MCP", DoctorStatus::Warn, "degraded")
            .with_hint("run /mcp for details"),
    ]);

    let document = serde_json::to_value(DoctorDocument::new(&report)).unwrap();

    assert_eq!(
        document,
        json!({
            "summary": { "ok": 1, "info": 0, "warn": 1, "fail": 0, "checking": 0 },
            "sections": [
                {
                    "id": "authentication",
                    "checks": [{
                        "id": { "kind": "provider_auth", "auth_mode": "openai-api-key" },
                        "label": "OpenAI API key",
                        "status": "ok",
                        "summary": "authenticated"
                    }]
                },
                {
                    "id": "extensions",
                    "checks": [{
                        "id": { "kind": "mcp" },
                        "label": "MCP",
                        "status": "warn",
                        "summary": "degraded",
                        "hint": "run /mcp for details"
                    }]
                }
            ]
        })
    );
}

// Covers: a probe that outlives the deadline is aborted and reported as timed
// out; finished probes keep their results.
// Owner: CLI (paused tokio clock, no child processes)
#[tokio::test(start_paused = true)]
async fn collect_probes_times_out_slow_tasks() {
    let fast = tokio::spawn(async { DoctorProbeOutcome::Rtk { available: true } });
    let slow = tokio::spawn(async {
        tokio::time::sleep(Duration::from_secs(60)).await;
        DoctorProbeOutcome::Rtk { available: true }
    });

    let outcomes = collect_probes(
        vec![(DoctorProbeId::Rtk, fast), (DoctorProbeId::Claude, slow)],
        Duration::from_secs(1),
    )
    .await;

    assert!(matches!(
        outcomes[0],
        DoctorProbeOutcome::Rtk { available: true }
    ));
    assert!(matches!(
        outcomes[1],
        DoctorProbeOutcome::TimedOut(DoctorProbeId::Claude)
    ));
}

// Covers: `rho --provider ollama doctor` must print a report even when the
// model cache is empty; catalog resolution cannot abort the command.
// Owner: CLI (pure selection)
#[test]
fn provider_override_with_empty_cache_still_selects_the_host() {
    let mut config = crate::config::Config::default();
    let cli = Cli::try_parse_from(["rho", "--provider", "ollama", "doctor"]).unwrap();
    apply_doctor_overrides(&mut config, &cli).unwrap();
    assert_eq!(config.provider, "ollama");
}

// Covers: unknown --provider still fails instead of producing a silent report.
// Owner: CLI (pure selection)
#[test]
fn unknown_provider_override_still_errors() {
    let mut config = crate::config::Config::default();
    let cli = Cli::try_parse_from(["rho", "--provider", "not-a-real-host", "doctor"]).unwrap();
    let err = apply_doctor_overrides(&mut config, &cli).unwrap_err();
    assert!(
        err.to_string().contains("unknown provider"),
        "expected unknown provider, got {err:#}"
    );
}

fn model_aliases(pairs: &[(&str, &str)]) -> crate::model_aliases::ModelAliases {
    crate::model_aliases::ModelAliases::from_entries(
        pairs
            .iter()
            .map(|(name, value)| (name.to_string(), value.to_string()))
            .collect(),
    )
    .unwrap()
}

// Covers: doctor must reject the same override errors as `rho run` instead
// of storing the raw `--model` string. Empty cache is the only exception.
// Owner: CLI (pure selection)
#[test]
fn doctor_overrides_reject_errors_that_run_rejects() {
    for (name, args, aliases, raw_model) in [
        (
            "unknown model",
            &["rho", "--model", "definitely-not-a-model", "doctor"] as &[&str],
            &[] as &[(&str, &str)],
            "definitely-not-a-model",
        ),
        (
            "undefined alias",
            &["rho", "--model", "@missing", "doctor"],
            &[],
            "@missing",
        ),
        (
            "provider conflicts with alias host",
            &["rho", "--provider", "openai", "--model", "@other", "doctor"],
            &[("other", "anthropic/claude-sonnet-4-5")],
            "@other",
        ),
    ] {
        let mut config = crate::config::Config {
            model_aliases: model_aliases(aliases),
            ..crate::config::Config::default()
        };
        let cli = Cli::try_parse_from(args).unwrap();
        assert!(
            apply_doctor_overrides(&mut config, &cli).is_err(),
            "{name} must fail"
        );
        assert_ne!(
            config.model, raw_model,
            "{name} must not store the raw --model flag"
        );
    }
}