malvin 0.2.7

Non-interactive research and coding agent
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

use super::{RequestKind, classify_top_level_requests};
use std::ffi::OsString;

fn os(args: &[&str]) -> Vec<OsString> {
    args.iter().map(OsString::from).collect()
}

#[test]
fn each_do_tags_only_the_next_request() {
    let tagged = classify_top_level_requests(&os(&[
        "malvin",
        "Write",
        "--do",
        "What time",
        "Find bug",
        "--do",
        "Summarize",
    ]))
    .expect("classify");
    assert_eq!(
        tagged
            .iter()
            .map(|t| (t.text.as_str(), t.kind, t.creative))
            .collect::<Vec<_>>(),
        vec![
            ("Write", RequestKind::Router, None),
            ("What time", RequestKind::Do, None),
            ("Find bug", RequestKind::Router, None),
            ("Summarize", RequestKind::Do, None),
        ]
    );
}

#[test]
fn each_creative_tags_only_the_next_request() {
    let tagged = classify_top_level_requests(&os(&[
        "malvin",
        "Write",
        "--creative",
        "Explore",
        "Find bug",
        "--creative=0.4",
        "Summarize",
    ]))
    .expect("classify");
    assert_eq!(
        tagged
            .iter()
            .map(|t| (t.text.as_str(), t.kind, t.creative))
            .collect::<Vec<_>>(),
        vec![
            ("Write", RequestKind::Router, None),
            ("Explore", RequestKind::Router, Some(1.0)),
            ("Find bug", RequestKind::Router, None),
            ("Summarize", RequestKind::Router, Some(0.4)),
        ]
    );
}

#[test]
fn creative_survives_intervening_global_flags() {
    let tagged = classify_top_level_requests(&os(&[
        "malvin",
        "--creative=0.7",
        "--max-loops",
        "3",
        "task",
    ]))
    .expect("classify");
    assert_eq!(tagged.len(), 1);
    assert_eq!(tagged[0].creative, Some(0.7));
    assert_eq!(tagged[0].kind, RequestKind::Router);
}

#[test]
fn creative_then_do_without_request_errors() {
    let err = classify_top_level_requests(&os(&["malvin", "--creative", "--do", "x"])).unwrap_err();
    assert!(err.contains("--creative"), "{err}");
}

#[test]
fn do_then_creative_without_request_errors() {
    let err = classify_top_level_requests(&os(&["malvin", "--do", "--creative", "x"])).unwrap_err();
    assert!(err.contains("--do"), "{err}");
}

#[test]
fn do_then_trailing_request_is_router() {
    let tagged =
        classify_top_level_requests(&os(&["malvin", "--do", "Hello", "Research"])).expect("ok");
    assert_eq!(tagged[0].kind, RequestKind::Do);
    assert_eq!(tagged[1].kind, RequestKind::Router);
    assert!(tagged[0].creative.is_none());
    assert!(tagged[1].creative.is_none());
}

#[test]
fn bare_do_without_request_is_ok_when_empty() {
    let tagged = classify_top_level_requests(&os(&["malvin", "--do"])).expect("ok");
    assert!(tagged.is_empty());
}

#[test]
fn bare_creative_without_request_is_ok_when_empty() {
    let tagged = classify_top_level_requests(&os(&["malvin", "--creative"])).expect("ok");
    assert!(tagged.is_empty());
}

#[test]
fn do_without_request_after_other_requests_errors() {
    let err = classify_top_level_requests(&os(&["malvin", "A", "--do"])).unwrap_err();
    assert!(err.contains("--do"));
}

#[test]
fn creative_without_request_after_other_requests_errors() {
    let err = classify_top_level_requests(&os(&["malvin", "A", "--creative"])).unwrap_err();
    assert!(err.contains("--creative"));
}

#[test]
fn do_then_creative_on_next_router_request() {
    let tagged = classify_top_level_requests(&os(&[
        "malvin",
        "--do",
        "shot",
        "--creative=0.5",
        "route me",
    ]))
    .expect("ok");
    assert_eq!(tagged[0].kind, RequestKind::Do);
    assert!(tagged[0].creative.is_none());
    assert_eq!(tagged[1].kind, RequestKind::Router);
    assert_eq!(tagged[1].creative, Some(0.5));
}