matrixcode-core 0.4.43

MatrixCode Agent Core - Pure logic, no UI
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

use matrixcode_core::tools::Tool;
use matrixcode_core::tools::edit::EditTool;
use serde_json::json;
use std::io::Write;
use tempfile::NamedTempFile;

#[tokio::test]
async fn test_edit_replaces_string() {
    let mut tmp = NamedTempFile::new().unwrap();
    write!(tmp, "hello world").unwrap();

    let tool = EditTool;
    let result = tool
        .execute(json!({
            "path": tmp.path().to_str().unwrap(),
            "old_string": "world",
            "new_string": "rust"
        }))
        .await
        .unwrap();

    assert!(result.contains("Successfully edited"));
    assert_eq!(std::fs::read_to_string(tmp.path()).unwrap(), "hello rust");
}

#[tokio::test]
async fn test_edit_old_string_not_found() {
    let mut tmp = NamedTempFile::new().unwrap();
    write!(tmp, "hello world").unwrap();

    let tool = EditTool;
    let result = tool
        .execute(json!({
            "path": tmp.path().to_str().unwrap(),
            "old_string": "nonexistent",
            "new_string": "replacement"
        }))
        .await;

    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("not found"));
}

#[tokio::test]
async fn test_edit_multiple_matches_fails() {
    let mut tmp = NamedTempFile::new().unwrap();
    write!(tmp, "aaa bbb aaa").unwrap();

    let tool = EditTool;
    let result = tool
        .execute(json!({
            "path": tmp.path().to_str().unwrap(),
            "old_string": "aaa",
            "new_string": "ccc"
        }))
        .await;

    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("2 times"));
}

#[tokio::test]
async fn test_edit_missing_params() {
    let tool = EditTool;
    assert!(tool.execute(json!({})).await.is_err());
    assert!(
        tool.execute(json!({"path": "/tmp/x", "old_string": "a"}))
            .await
            .is_err()
    );
}

#[tokio::test]
async fn test_edit_definition() {
    let tool = EditTool;
    let def = tool.definition();
    assert_eq!(def.name, "edit");
    let required = def.parameters["required"].as_array().unwrap();
    assert!(required.contains(&json!("path")));
    assert!(required.contains(&json!("old_string")));
    assert!(required.contains(&json!("new_string")));
}

#[tokio::test]
async fn test_edit_crlf_file_with_lf_search() {
    // Test: file uses CRLF, but old_string uses LF (common AI input case)
    let mut tmp = NamedTempFile::new().unwrap();
    // Write file with CRLF line endings (Windows style)
    write!(tmp, "line1\r\nline2\r\nline3\r\n").unwrap();

    let tool = EditTool;
    // AI sends LF-style old_string
    let result = tool
        .execute(json!({
            "path": tmp.path().to_str().unwrap(),
            "old_string": "line1\nline2",  // LF only
            "new_string": "new1\nnew2"      // LF only
        }))
        .await
        .unwrap();

    assert!(result.contains("Successfully edited"));
    // File should still have CRLF after edit
    let content = std::fs::read_to_string(tmp.path()).unwrap();
    assert!(content.contains("\r\n"), "File should retain CRLF line endings");
    assert!(content.contains("new1"));
    assert!(content.contains("new2"));
}

#[tokio::test]
async fn test_edit_lf_file_with_crlf_search() {
    // Test: file uses LF, but old_string uses CRLF
    let mut tmp = NamedTempFile::new().unwrap();
    // Write file with LF line endings (Unix style)
    write!(tmp, "line1\nline2\nline3\n").unwrap();

    let tool = EditTool;
    // User sends CRLF-style old_string
    let result = tool
        .execute(json!({
            "path": tmp.path().to_str().unwrap(),
            "old_string": "line1\r\nline2",  // CRLF
            "new_string": "new1\r\nnew2"      // CRLF
        }))
        .await
        .unwrap();

    assert!(result.contains("Successfully edited"));
    // File should still have LF after edit
    let content = std::fs::read_to_string(tmp.path()).unwrap();
    assert!(!content.contains("\r\n"), "File should retain LF line endings");
    assert!(content.contains("new1"));
    assert!(content.contains("new2"));
}