rho-coding-agent 2.19.0

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

use pretty_assertions::assert_eq;

use crate::agent::CursorTool;
use crate::permission::PermissionMode;

use super::*;

fn request(model: Option<&str>) -> CursorSpawnRequest {
    CursorSpawnRequest {
        model: model.map(str::to_string),
        cwd: PathBuf::from("/tmp/project"),
    }
}

// Covers: ACP argv carries identity only, with `acp` last; permission flags
// are ignored under `acp` (spike) and must not imply a fence.
// Owner: cursor spawn argv
#[test]
fn builds_identity_only_acp_args() {
    for (model, expected) in [
        (
            Some("composer-2.5"),
            vec!["--trust", "--model", "composer-2.5", "acp"],
        ),
        (None, vec!["--trust", "acp"]),
    ] {
        let plan = build_spawn_plan(&request(model));
        assert_eq!(plan.args, expected);
        assert_eq!(plan.cwd, PathBuf::from("/tmp/project"));
    }
}

// Covers: Plan keeps only read-only tools, Bypass keeps every declared tool,
// and Auto/Allow edits/Supervised refuse before spawn.
// Owner: cursor permission gate
#[test]
fn rho_permission_modes_gate_and_narrow_tools() {
    let mixed = [CursorTool::Read, CursorTool::Edit, CursorTool::Shell];
    let writes = [CursorTool::Edit, CursorTool::Shell];
    let reads = [CursorTool::Read, CursorTool::Grep];

    for (mode, tools, expected) in [
        (
            PermissionMode::Plan,
            mixed.as_slice(),
            Ok(vec![CursorTool::Read]),
        ),
        (PermissionMode::Bypass, mixed.as_slice(), Ok(mixed.to_vec())),
        (PermissionMode::Plan, reads.as_slice(), Ok(reads.to_vec())),
        (
            PermissionMode::Plan,
            writes.as_slice(),
            Err(CursorSpawnError::NoToolsAllowed),
        ),
        (
            PermissionMode::Bypass,
            &[][..],
            Err(CursorSpawnError::NoToolsAllowed),
        ),
        (
            PermissionMode::Auto,
            mixed.as_slice(),
            Err(CursorSpawnError::ApprovalUnsupported(PermissionMode::Auto)),
        ),
        (
            PermissionMode::AllowEdits,
            mixed.as_slice(),
            Err(CursorSpawnError::ApprovalUnsupported(
                PermissionMode::AllowEdits,
            )),
        ),
        (
            PermissionMode::Supervised,
            mixed.as_slice(),
            Err(CursorSpawnError::ApprovalUnsupported(
                PermissionMode::Supervised,
            )),
        ),
    ] {
        let got = map_permission_mode(mode, tools).map(|allowed| allowed.tools().to_vec());
        assert_eq!(got, expected);
    }
}

// Covers: frozen workflow argv (including pre-ACP `-p` plans) may keep only
// --model; `acp` stays the last argument.
// Owner: cursor spawn frozen identity
#[test]
fn frozen_identity_keeps_model_and_acp_last() {
    let frozen: Vec<String> = [
        "-p",
        "--model",
        "frozen-model",
        "--mode",
        "plan",
        "--allowed-tools",
        "shell_tool_call",
        "--force",
    ]
    .map(String::from)
    .to_vec();
    for (model, expected) in [
        (
            Some("composer-2.5"),
            vec!["--trust", "--model", "frozen-model", "acp"],
        ),
        (None, vec!["--trust", "--model", "frozen-model", "acp"]),
    ] {
        let plan = apply_frozen_identity_args(build_spawn_plan(&request(model)), &frozen);
        assert_eq!(plan.args, expected);
    }
}