codewhale-tui 0.9.0

Terminal UI for open-source and open-weight coding models
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

use std::path::PathBuf;
use std::process::{Command, Output};

fn codewhale_tui_binary() -> PathBuf {
    if let Some(path) = option_env!("CARGO_BIN_EXE_codewhale-tui") {
        return PathBuf::from(path);
    }
    if let Ok(path) = std::env::var("CARGO_BIN_EXE_codewhale-tui") {
        return PathBuf::from(path);
    }

    let mut path = std::env::current_exe().expect("current test executable path");
    path.pop();
    if path.ends_with("deps") {
        path.pop();
    }
    path.push(format!("codewhale-tui{}", std::env::consts::EXE_SUFFIX));
    path
}

fn assert_terminal_stream_error(output: Output, expected_fragment: &str) {
    assert!(
        !output.status.success(),
        "workflow-tool unexpectedly succeeded\nstdout:\n{}\nstderr:\n{}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8(output.stdout).expect("workflow-tool stdout is UTF-8");
    let events = stdout
        .lines()
        .filter(|line| !line.trim().is_empty())
        .map(|line| {
            serde_json::from_str::<serde_json::Value>(line)
                .unwrap_or_else(|error| panic!("invalid stream JSON {line:?}: {error}"))
        })
        .collect::<Vec<_>>();
    let terminal = events.last().expect("terminal error event");
    assert_eq!(terminal["type"], "error", "events={events:?}");
    assert!(
        terminal["error"]
            .as_str()
            .is_some_and(|error| error.contains(expected_fragment)),
        "events={events:?}"
    );
    assert!(
        events.iter().all(|event| event["type"] != "tool_use"),
        "setup failure must happen before tool_use: {events:?}"
    );
}

#[test]
fn invalid_workflow_input_is_terminal_ndjson() {
    let output = Command::new(codewhale_tui_binary())
        .args([
            "workflow-tool",
            "--approval-source",
            "explicit-workflow-command",
            "--input-json",
            "{not-json",
        ])
        .output()
        .expect("run workflow-tool");
    assert_terminal_stream_error(output, "valid Workflow tool input object");
}

#[test]
fn missing_profile_is_terminal_ndjson() {
    let dir = tempfile::tempdir().expect("tempdir");
    let config = dir.path().join("config.toml");
    std::fs::write(&config, "provider = \"vllm\"\n").expect("write config");
    let output = Command::new(codewhale_tui_binary())
        .arg("--config")
        .arg(&config)
        .args([
            "--profile",
            "missing-profile",
            "workflow-tool",
            "--approval-source",
            "explicit-workflow-command",
            "--input-json",
            r#"{"action":"run"}"#,
        ])
        .env("CODEWHALE_HOME", dir.path().join("codewhale-home"))
        .output()
        .expect("run workflow-tool with missing profile");
    assert_terminal_stream_error(output, "Profile 'missing-profile' not found");
}

#[test]
fn profile_provider_switch_accepts_source_marked_cli_key_offline() {
    let dir = tempfile::tempdir().expect("tempdir");
    let config = dir.path().join("config.toml");
    std::fs::write(
        &config,
        r#"
provider = "deepseek"

[features]
mcp = false

[profiles.anthropic]
provider = "anthropic"
"#,
    )
    .expect("write profile config");
    let output = Command::new(codewhale_tui_binary())
        .arg("--config")
        .arg(&config)
        .args([
            "--profile",
            "anthropic",
            "workflow-tool",
            "--approval-source",
            "explicit-workflow-command",
            "--input-json",
            r#"{"action":"run","script":"phase('offline'); return { ok: true };"}"#,
        ])
        .env("CODEWHALE_HOME", dir.path().join("codewhale-home"))
        .env("DEEPSEEK_API_KEY_SOURCE", "cli")
        .env("CODEWHALE_CLI_API_KEY", "profile-switch-secret")
        .output()
        .expect("run profile-switched workflow-tool");

    assert!(
        output.status.success(),
        "workflow-tool failed\nstdout:\n{}\nstderr:\n{}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8(output.stdout).expect("workflow-tool stdout is UTF-8");
    let event_types = stdout
        .lines()
        .filter(|line| !line.trim().is_empty())
        .map(|line| {
            serde_json::from_str::<serde_json::Value>(line)
                .unwrap_or_else(|error| panic!("invalid stream JSON {line:?}: {error}"))
        })
        .map(|event| event["type"].as_str().unwrap_or_default().to_string())
        .collect::<Vec<_>>();
    assert!(event_types.iter().any(|kind| kind == "tool_use"));
    assert!(event_types.iter().any(|kind| kind == "tool_result"));
    assert_eq!(event_types.last().map(String::as_str), Some("done"));
    assert!(!stdout.contains("profile-switch-secret"));
    assert!(!String::from_utf8_lossy(&output.stderr).contains("profile-switch-secret"));
}