atomwrite 0.1.14

Atomic file operations CLI for LLM agents — read, write, edit, search, replace with NDJSON output
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

// SPDX-License-Identifier: MIT OR Apache-2.0

//! Integration tests for the `outline` subcommand (v14 Tier 3, v0.1.12).
//!
//! Covers high-level structure extraction via tree-sitter:
//! functions, classes, structs, enums, traits.

mod common;

fn write_rust(dir: &std::path::Path) -> std::path::PathBuf {
    let p = dir.join("lib.rs");
    std::fs::write(
        &p,
        "pub fn hello() -> i32 { 42 }\n\
         pub struct Point { x: i32, y: i32 }\n\
         pub enum Color { Red, Green, Blue }\n\
         pub trait Greet { fn greet(&self); }\n",
    )
    .expect("write");
    p
}

fn write_python(dir: &std::path::Path) -> std::path::PathBuf {
    let p = dir.join("sample.py");
    std::fs::write(
        &p,
        "def hello():\n    return 42\n\
         \n\
         class Greeter:\n    def __init__(self, name):\n        self.name = name\n",
    )
    .expect("write");
    p
}

#[test]
fn outline_rust_extracts_all_structural_items() {
    let dir = tempfile::tempdir().expect("tempdir");
    let workspace = dir.path().to_str().unwrap();
    let f = write_rust(dir.path());

    let output = common::atomwrite()
        .args(["--workspace", workspace, "outline", f.to_str().unwrap()])
        .output()
        .expect("outline");

    assert!(
        output.status.success(),
        "outline failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("function"), "missing function: {stdout}");
    assert!(stdout.contains("struct"), "missing struct: {stdout}");
    assert!(stdout.contains("enum"), "missing enum: {stdout}");
    assert!(stdout.contains("trait"), "missing trait: {stdout}");
}

#[test]
fn outline_python_extracts_function_and_class() {
    let dir = tempfile::tempdir().expect("tempdir");
    let workspace = dir.path().to_str().unwrap();
    let f = write_python(dir.path());

    let output = common::atomwrite()
        .args(["--workspace", workspace, "outline", f.to_str().unwrap()])
        .output()
        .expect("outline");

    assert!(
        output.status.success(),
        "outline failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("function"), "missing function: {stdout}");
    assert!(stdout.contains("class"), "missing class: {stdout}");
}

#[test]
fn outline_kind_filter_narrows_results() {
    let dir = tempfile::tempdir().expect("tempdir");
    let workspace = dir.path().to_str().unwrap();
    let f = write_rust(dir.path());

    let output = common::atomwrite()
        .args([
            "--workspace",
            workspace,
            "outline",
            f.to_str().unwrap(),
            "--kind",
            "function_item",
        ])
        .output()
        .expect("outline");

    assert!(
        output.status.success(),
        "outline failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("function_item"),
        "missing function_item: {stdout}"
    );
    assert!(
        !stdout.contains("struct_item"),
        "struct_item should be filtered: {stdout}"
    );
}

#[test]
fn outline_missing_file_fails() {
    let dir = tempfile::tempdir().expect("tempdir");
    let workspace = dir.path().to_str().unwrap();
    let f = dir.path().join("missing.rs");

    let output = common::atomwrite()
        .args(["--workspace", workspace, "outline", f.to_str().unwrap()])
        .output()
        .expect("outline");

    assert!(
        !output.status.success(),
        "outline on missing file should fail"
    );
}

#[test]
fn outline_emits_ndjson_envelope() {
    let dir = tempfile::tempdir().expect("tempdir");
    let workspace = dir.path().to_str().unwrap();
    let f = write_rust(dir.path());

    let output = common::atomwrite()
        .args(["--workspace", workspace, "outline", f.to_str().unwrap()])
        .output()
        .expect("outline");

    assert!(
        output.status.success(),
        "outline failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    let events = common::parse_ndjson(&output.stdout);
    let item_count = events
        .iter()
        .filter(|e| e.get("type").and_then(|v| v.as_str()) == Some("outline_item"))
        .count();
    assert!(
        item_count >= 4,
        "expected at least 4 outline items, got {item_count}: {events:?}"
    );
    let summary = events
        .iter()
        .find(|e| e.get("type").and_then(|v| v.as_str()) == Some("outline_summary"));
    assert!(summary.is_some(), "expected outline_summary event");
}