argonauts-app 0.1.0

Argonauts Code's app controller and run host: the conversation, routing, choosing Captain or crew, and the run host each run has.
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

//! A picture sent with your message reaches the main session's CLI as part of its prompt, and
//! only with the message it was sent with.

use argonauts_core::app::{AppEvent, ConversationEvent, UiCommand};
use argonauts_core::events::session::InputPartKind;
use argonauts_core::pictures::Picture;
use argonauts_testkit::FakeSession;

use crate::controller::test_support::TestDriver;

fn turn_ended(event: &AppEvent) -> bool {
    matches!(
        event,
        AppEvent::Conversation {
            event: ConversationEvent::TurnFinished { .. } | ConversationEvent::TurnFailed { .. }
        }
    )
}

fn pictures_of(
    spec: &argonauts_core::session_runner::SessionSpec,
) -> Vec<(String, Option<String>)> {
    spec.prompt
        .iter()
        .filter(|part| part.kind == InputPartKind::Picture)
        .map(|part| (part.label.clone(), part.source.clone()))
        .collect()
}

#[tokio::test]
async fn a_picture_goes_with_its_message_to_the_main_session_and_no_further() {
    let mut driver = TestDriver::start().await;
    driver.directory.taking_tools("claude-code");
    let shot = driver.repo.root().join("shot.png");
    std::fs::write(&shot, [0x89, b'P', b'N', b'G']).unwrap();
    driver
        .agent
        .push(FakeSession::completed("The button overlaps the title."));
    driver.agent.push(FakeSession::completed("Yes."));
    driver
        .send(UiCommand::Submit {
            text: "what's off on this screen? [Image #1]".to_owned(),
            workflow_requested: false,
            pictures: vec![Picture {
                number: 1,
                path: shot.clone(),
            }],
        })
        .await;
    driver.until(turn_ended).await;
    driver.submit("is that all?").await;
    driver.until(turn_ended).await;
    let specs = driver.agent.specs();
    assert_eq!(
        pictures_of(&specs[0]),
        [("[Image #1]".to_owned(), Some(shot.display().to_string()))]
    );
    assert!(
        specs[0].prompt[0].text.contains("[Image #1]"),
        "the words keep their chip"
    );
    assert!(
        pictures_of(&specs[1]).is_empty(),
        "the next message has none"
    );
    driver.exit().await;
}

fn with_picture(text: &str, number: u32, path: &std::path::Path) -> UiCommand {
    UiCommand::Submit {
        text: text.to_owned(),
        workflow_requested: false,
        pictures: vec![Picture {
            number,
            path: path.to_path_buf(),
        }],
    }
}

#[tokio::test]
async fn messages_typed_while_a_turn_runs_each_keep_their_own_pictures() {
    let mut driver = TestDriver::start().await;
    driver.directory.taking_tools("claude-code");
    let first = driver.repo.root().join("first.png");
    let second = driver.repo.root().join("second.png");
    for path in [&first, &second] {
        std::fs::write(path, [0x89, b'P', b'N', b'G']).unwrap();
    }
    driver
        .agent
        .push(FakeSession::completed("Looking.").with_delay(std::time::Duration::from_millis(200)));
    driver.agent.push(FakeSession::completed("One."));
    driver.agent.push(FakeSession::completed("Two."));
    driver.submit("look at the login page").await;
    driver
        .send(with_picture("the header [Image #1]", 1, &first))
        .await;
    driver
        .send(with_picture("the footer [Image #2]", 2, &second))
        .await;
    for _ in 0..3 {
        driver.until(turn_ended).await;
    }
    let specs = driver.agent.specs();
    assert!(pictures_of(&specs[0]).is_empty());
    let found: Vec<_> = specs[1..]
        .iter()
        .map(|spec| (spec.prompt[0].text.clone(), pictures_of(spec)))
        .collect();
    let of = |words: &str| {
        found
            .iter()
            .find(|(text, _)| text.contains(words))
            .map(|(_, pictures)| pictures.clone())
            .unwrap_or_else(|| panic!("no turn took {words}: {found:?}"))
    };
    assert_eq!(
        of("the header"),
        [("[Image #1]".to_owned(), Some(first.display().to_string()))]
    );
    assert_eq!(
        of("the footer"),
        [("[Image #2]".to_owned(), Some(second.display().to_string()))]
    );
    driver.exit().await;
}