moesniper 0.7.6

Escape-proof precision file editor for LLM agents. Hex-encoded content, line-range splicing, atomic writes.
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

//! Diff generation for sniper dry-run mode.
//!
//! Generates unified diff-style output showing actual changes.

/// Generates a preview showing before/after for dry-run.
pub fn generate_preview(
    old_lines: &[String],
    new_lines: &[String],
    start: usize,
    end: usize,
) -> Vec<String> {
    let mut preview = Vec::new();

    // Show the range being edited
    preview.push(format!("--- original (lines {}-{})", start, end));
    preview.push(format!("+++ modified ({} lines)", new_lines.len()));
    preview.push(String::new());

    // Context before (up to 3 lines)
    let ctx_before = start.saturating_sub(3);
    for line in old_lines.iter().take(start - 1).skip(ctx_before) {
        preview.push(format!(
            " {} | {}",
            ctx_before + 1,
            line.trim_end_matches('\n')
        ));
    }

    // Separator
    if ctx_before < start - 1 {
        preview.push(" ...".to_string());
    }

    // Old content (marked for removal)
    let splice_start = start - 1;
    let splice_end = end.min(old_lines.len());
    for (idx, line) in old_lines
        .iter()
        .enumerate()
        .take(splice_end)
        .skip(splice_start)
    {
        preview.push(format!("-{}| {}", idx + 1, line.trim_end_matches('\n')));
    }

    // New content (marked for addition)
    for (i, line) in new_lines.iter().enumerate() {
        let trimmed = line.trim_end_matches('\n');
        preview.push(format!("+{}| {}", start + i, trimmed));
    }

    // Context after (up to 3 lines)
    if splice_end < old_lines.len() {
        let ctx_after = (splice_end + 3).min(old_lines.len());
        if splice_end < ctx_after {
            preview.push(" ...".to_string());
        }
        for line in old_lines.iter().take(ctx_after).skip(splice_end) {
            preview.push(format!(
                " {} | {}",
                splice_end + 1,
                line.trim_end_matches('\n')
            ));
        }
    }

    preview
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_lines(text: &str) -> Vec<String> {
        text.split_inclusive('\n').map(String::from).collect()
    }

    #[test]
    fn test_generate_preview_simple() {
        let old = make_lines("line1\nline2\nline3\nline4\nline5\n");
        let new = vec!["new2\n".to_string()];

        let preview = generate_preview(&old, &new, 2, 2);

        // Must start with --- and +++ headers
        assert!(
            preview[0].starts_with("--- original"),
            "Header missing: {}",
            preview[0]
        );
        assert!(
            preview[1].starts_with("+++ modified"),
            "Header missing: {}",
            preview[1]
        );
        // Must contain a removal line for line2
        assert!(
            preview
                .iter()
                .any(|l| l.starts_with("-2|") && l.contains("line2")),
            "Must show removal of line 2"
        );
        // Must contain an addition line for new2
        assert!(
            preview
                .iter()
                .any(|l| l.starts_with("+2|") && l.contains("new2")),
            "Must show addition of new2"
        );
        // Line count must be reasonable (> 5 lines for context + diff)
        assert!(
            preview.len() >= 5,
            "Preview too short: {}",
            preview.join("\n")
        );
    }
}