rho-coding-agent 2.9.1

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

use super::*;
use pretty_assertions::assert_eq;

// Covers: display labels must not replace machine values in host responses.
// Owner: pure questionnaire response construction (not terminal rendering).
#[test]
fn submission_preserves_machine_values_and_displays_labels() {
    for (choices, selection, expected_values, expected_display) in [
        (
            vec![("rust", "Rust"), ("go", "Go")],
            SelectionMode::One,
            vec!["rust"],
            "Rust",
        ),
        (
            vec![("yes", "Yes"), ("no", "No")],
            SelectionMode::One,
            vec!["yes"],
            "Yes",
        ),
        (
            vec![("unit_tests", "Unit tests"), ("e2e", "End to end")],
            SelectionMode::Many,
            vec!["unit_tests", "e2e"],
            "Unit tests, End to end",
        ),
    ] {
        let question = HostQuestion::new(
            "answer",
            "Choose",
            choices
                .into_iter()
                .map(|(value, label)| HostChoice::new(value, label))
                .collect(),
            selection,
        )
        .unwrap();
        let request = HostInputRequest::questionnaire("Setup", vec![question]).unwrap();
        let (host, display) = submit(request.clone(), |composer| {
            composer.toggle_active_choice();
            if selection == SelectionMode::Many {
                composer.move_active_choice_next();
                composer.toggle_active_choice();
            }
        });
        assert_eq!(
            host,
            HostInputResponse::new().answer("answer", expected_values)
        );
        assert_eq!(display, expected_display);
        request.validate(&host).unwrap();
    }
}

#[test]
fn focused_default_requires_selection_and_returns_its_value() {
    let question = HostQuestion::new(
        "prompt",
        "Prompt mode?",
        vec![
            HostChoice::new("replace", "Replace"),
            HostChoice::new("extend", "Extend"),
        ],
        SelectionMode::One,
    )
    .unwrap()
    .default_value(serde_json::json!("extend"))
    .default_selection(DefaultSelection::Focused);
    let request = HostInputRequest::questionnaire("Prompt", vec![question]).unwrap();
    let (host, display) = submit(request.clone(), |composer| {
        assert!(composer.submit().is_err());
        composer.toggle_active_choice();
    });
    assert_eq!(host, HostInputResponse::new().answer("prompt", ["extend"]));
    assert_eq!(display, "Extend");
    request.validate(&host).unwrap();
}

// Covers: optional omission differs from an explicitly registered empty fallback.
// Owner: typed questionnaire reply channel; no SDK/JSON/SDK conversion is needed.
#[test]
fn optional_answers_preserve_user_omission_and_explicit_fallback() {
    let question = HostQuestion::new(
        "language",
        "Language?",
        vec![HostChoice::new("rust", "Rust")],
        SelectionMode::One,
    )
    .unwrap()
    .optional();
    let request = HostInputRequest::questionnaire("Optional", vec![question]).unwrap();
    let (host, _) = submit(request.clone(), |_| {});
    assert_eq!(host, HostInputResponse::new());
    request.validate(&host).unwrap();

    let fallback = HostInputResponse::new().answer("language", Vec::<String>::new());
    let request = request
        .with_timeout_fallback(fallback, "Leave language unset")
        .unwrap();
    let (reply_tx, mut reply_rx) = tokio::sync::oneshot::channel();
    let mut composer =
        QuestionnaireComposer::new(request.clone(), QuestionnaireResponseChannel::new(reply_tx));
    let now = std::time::Instant::now();
    composer.start_timeout(std::num::NonZeroU64::new(1), now);
    assert!(composer
        .submit_timeout_if_due(now + std::time::Duration::from_secs(1))
        .is_some());
    let QuestionnaireReply::Answer(host) = reply_rx.try_recv().unwrap() else {
        panic!("expected fallback response");
    };
    assert_eq!(Some(&host), request.timeout_fallback());
    request.validate(&host).unwrap();
}

fn submit(
    request: HostInputRequest,
    interact: impl FnOnce(&mut QuestionnaireComposer),
) -> (HostInputResponse, String) {
    let (reply_tx, mut reply_rx) = tokio::sync::oneshot::channel();
    let mut composer =
        QuestionnaireComposer::new(request, QuestionnaireResponseChannel::new(reply_tx));
    interact(&mut composer);
    let submitted = composer.submit().unwrap();
    let QuestionnaireReply::Answer(response) = reply_rx.try_recv().unwrap() else {
        panic!("expected questionnaire answer");
    };
    (response, submitted.display)
}