rab-agent 0.1.0

rab is a lightweight, extensible, Rust-based coding agent.
Documentation 
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use rab::agent::extension::{Cancel, Extension};
use rab::builtin::edit::EditExtension;

fn tmp_dir() -> std::path::PathBuf {
    let d = std::env::temp_dir().join(format!("rab-test-{}", uuid::Uuid::new_v4()));
    std::fs::create_dir_all(&d).unwrap();
    d
}

async fn exec_ok(tool: &dyn rab::agent::extension::AgentTool, args: serde_json::Value) -> String {
    tool.execute("id".into(), args, Cancel::new(), None)
        .await
        .unwrap()
        .content
}

async fn exec_err(tool: &dyn rab::agent::extension::AgentTool, args: serde_json::Value) -> String {
    tool.execute("id".into(), args, Cancel::new(), None)
        .await
        .unwrap_err()
        .to_string()
}

#[tokio::test]
async fn single_edit_replaces_text() {
    let tmp = tmp_dir();
    let path = tmp.join("file.txt");
    std::fs::write(&path, "hello world\nfoo bar\n").unwrap();

    let ext = EditExtension::new(tmp.clone());
    let tools = ext.tools();
    let tool = &tools[0];

    exec_ok(
        tool.as_ref(),
        serde_json::json!({
            "path": path.to_str().unwrap(),
            "edits": [{"oldText": "foo bar", "newText": "baz qux"}]
        }),
    )
    .await;

    assert_eq!(
        std::fs::read_to_string(&path).unwrap(),
        "hello world\nbaz qux\n"
    );
}

#[tokio::test]
async fn multiple_edits_replaces_all() {
    let tmp = tmp_dir();
    let path = tmp.join("file.txt");
    std::fs::write(&path, "aaa\nbbb\nccc\n").unwrap();

    let ext = EditExtension::new(tmp.clone());
    let tools = ext.tools();
    let tool = &tools[0];

    exec_ok(
        tool.as_ref(),
        serde_json::json!({
            "path": path.to_str().unwrap(),
            "edits": [
                {"oldText": "aaa", "newText": "111"},
                {"oldText": "ccc", "newText": "333"}
            ]
        }),
    )
    .await;

    assert_eq!(std::fs::read_to_string(&path).unwrap(), "111\nbbb\n333\n");
}

#[tokio::test]
async fn non_unique_oldtext_errors() {
    let tmp = tmp_dir();
    let path = tmp.join("file.txt");
    std::fs::write(&path, "dup\ndup\n").unwrap();

    let ext = EditExtension::new(tmp.clone());
    let tools = ext.tools();
    let tool = &tools[0];

    let err = exec_err(
        tool.as_ref(),
        serde_json::json!({
            "path": path.to_str().unwrap(),
            "edits": [{"oldText": "dup", "newText": "x"}]
        }),
    )
    .await;
    assert!(err.contains("occurrences") || err.contains("unique"));
}

#[tokio::test]
async fn missing_oldtext_errors() {
    let tmp = tmp_dir();
    let path = tmp.join("file.txt");
    std::fs::write(&path, "content\n").unwrap();

    let ext = EditExtension::new(tmp.clone());
    let tools = ext.tools();
    let tool = &tools[0];

    let result = tool
        .execute(
            "id".into(),
            serde_json::json!({
                "path": path.to_str().unwrap(),
                "edits": [{"oldText": "not found", "newText": "x"}]
            }),
            Cancel::new(),
            None,
        )
        .await;
    assert!(result.is_err());
}

#[tokio::test]
async fn overlapping_edits_error() {
    let tmp = tmp_dir();
    let path = tmp.join("file.txt");
    std::fs::write(&path, "abcdef\n").unwrap();

    let ext = EditExtension::new(tmp.clone());
    let tools = ext.tools();
    let tool = &tools[0];

    let result = tool
        .execute(
            "id".into(),
            serde_json::json!({
                "path": path.to_str().unwrap(),
                "edits": [
                    {"oldText": "abc", "newText": "1"},
                    {"oldText": "bcd", "newText": "2"}
                ]
            }),
            Cancel::new(),
            None,
        )
        .await;
    assert!(result.is_err());
}

#[tokio::test]
async fn empty_edits_errors() {
    let tmp = tmp_dir();
    let path = tmp.join("file.txt");
    std::fs::write(&path, "content\n").unwrap();

    let ext = EditExtension::new(tmp.clone());
    let tools = ext.tools();
    let tool = &tools[0];

    let result = tool
        .execute(
            "id".into(),
            serde_json::json!({"path": path.to_str().unwrap(), "edits": []}),
            Cancel::new(),
            None,
        )
        .await;
    assert!(result.is_err());
}