malvin 0.2.5

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
136
137
138
139
140
141
142
143
144
145
146
147

use crate::acp::{AgentIoOptions, CoderPromptOptions};
use crate::cursor_sdk::CursorSdkClient;

pub(super) fn bug_mock_io_forced() -> AgentIoOptions {
    AgentIoOptions {
        force: true,
        no_tee: true,
        raw_output: true,
        show_thoughts_on_stdout: false,
        emit_stdout_markdown: false,
        log_full_outgoing_prompts: false,
    }
}

pub(super) fn bug_mock_io_noforce() -> AgentIoOptions {
    AgentIoOptions {
        force: false,
        no_tee: true,
        raw_output: true,
        show_thoughts_on_stdout: false,
        emit_stdout_markdown: false,
        log_full_outgoing_prompts: false,
    }
}

pub(super) fn bug_install_env(mock: &std::path::Path) {
    unsafe {
        std::env::set_var("MALVIN_CURSOR_SDK_BRIDGE", mock);
        std::env::set_var("CURSOR_API_KEY", "test-key");
        std::env::set_var(crate::acp::MALVIN_TEST_NO_REAL_AGENT_ENV, "1");
    }
}

pub(super) fn bug_set_progress_env(period_ms: u64, count: u64) {
    unsafe {
        std::env::set_var("MOCK_BRIDGE_PROGRESS_MS", period_ms.to_string());
        std::env::set_var("MOCK_BRIDGE_PROGRESS_COUNT", count.to_string());
    }
}

pub(super) fn bug_clear_progress_env() {
    unsafe {
        std::env::remove_var("MOCK_BRIDGE_PROGRESS_MS");
        std::env::remove_var("MOCK_BRIDGE_PROGRESS_COUNT");
    }
}

pub(super) fn bug_set_tool_turn_env(period_ms: u64, pulses: u64) {
    unsafe {
        std::env::set_var("MOCK_BRIDGE_TOOL_PERIOD_MS", period_ms.to_string());
        std::env::set_var("MOCK_BRIDGE_TOOL_PULSES", pulses.to_string());
    }
}

pub(super) fn bug_clear_tool_turn_env() {
    unsafe {
        std::env::remove_var("MOCK_BRIDGE_TOOL_PERIOD_MS");
        std::env::remove_var("MOCK_BRIDGE_TOOL_PULSES");
    }
}

pub(super) fn bug_clear_env() {
    unsafe {
        std::env::remove_var("MALVIN_CURSOR_SDK_BRIDGE");
        std::env::remove_var("MALVIN_SDK_DRAIN_IDLE_TIMEOUT_MS");
        std::env::remove_var("MOCK_BRIDGE_HANG_CREATE");
    }
    bug_clear_progress_env();
    bug_clear_tool_turn_env();
}

pub(super) fn bug_set_drain_idle_timeout_ms(ms: u64) {
    unsafe {
        std::env::set_var("MALVIN_SDK_DRAIN_IDLE_TIMEOUT_MS", ms.to_string());
    }
}

pub(super) fn bug_bridge_js() -> std::path::PathBuf {
    std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/cursor_sdk/mock_bridge.js")
}

pub(super) fn bug_client(run_dir: &std::path::Path, retries: u32) -> CursorSdkClient {
    let mut client =
        crate::cursor_sdk::cursor_sdk_client_from_raw("cursor:auto", bug_mock_io_forced(), retries);
    client.prompts_log_run_dir = Some(run_dir.to_path_buf());
    client
}

pub(super) fn bug_client_noforce(run_dir: &std::path::Path) -> CursorSdkClient {
    let mut client =
        crate::cursor_sdk::cursor_sdk_client_from_raw("cursor:auto", bug_mock_io_noforce(), 1);
    client.prompts_log_run_dir = Some(run_dir.to_path_buf());
    client
}

pub(super) fn bug_prepare() -> tempfile::TempDir {
    crate::test_utils::enable_test_fast_teardown();
    bug_install_env(&bug_bridge_js());
    let tmp = tempfile::tempdir().expect("tmp");
    crate::malvin_sandbox::clear_active_sandbox_session();
    tmp
}

pub(super) fn assert_err_has(err: &crate::acp::AgentError, needles: &[&str]) {
    assert!(
        needles.iter().any(|n| err.message.contains(n)),
        "unexpected: {}",
        err.message
    );
}

pub(super) async fn expect_prompt_err(
    client: &mut CursorSdkClient,
    prompt: &str,
    log: &std::path::Path,
) -> crate::acp::AgentError {
    client
        .run_coder_prompt(
            prompt,
            log,
            "coder",
            CoderPromptOptions {
                single_attempt: true,
                llm_phase: Some(crate::run_timing::TimingPhase::Implement),
                ..CoderPromptOptions::default()
            },
        )
        .await
        .expect_err("expected failure")
}

#[test]
fn kiss_cov_sdk_bug_helpers() {
    let _ = bug_mock_io_forced;
    let _ = bug_mock_io_noforce;
    let _ = bug_install_env;
    let _ = bug_clear_env;
    let _ = bug_set_drain_idle_timeout_ms;
    let _ = bug_set_progress_env;
    let _ = bug_clear_progress_env;
    let _ = bug_bridge_js;
    let _ = bug_client;
    let _ = bug_client_noforce;
    let _ = bug_prepare;
    let _ = assert_err_has;
    let _ = expect_prompt_err;
}