intelli-shell 3.4.6

Like IntelliSense, but for shells
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

use crate::config::RegexWrapper;

/// Checks whether a command string is destructive based on its tags and regex patterns.
pub fn is_destructive(command: &str, tags: &[String], patterns: &[RegexWrapper]) -> bool {
    // 1. Tag-Based Detection (Always-On)
    if tags.iter().any(|t| t == "#destructive") {
        return true;
    }

    // 2. Config-Based Regex Detection
    if patterns.is_empty() {
        return false;
    }

    let segments = split_shell_segments(command);
    for pattern in patterns {
        for segment in &segments {
            let trimmed = segment.trim();
            if !trimmed.is_empty() && pattern.is_match(trimmed) {
                return true;
            }
        }
    }

    false
}

fn split_shell_segments(command: &str) -> Vec<&str> {
    let bytes = command.as_bytes();
    let mut segments = Vec::new();
    let mut start = 0;
    let mut index = 0;
    let mut quote: Option<u8> = None;
    let mut escaped = false;

    while index < bytes.len() {
        let byte = bytes[index];

        if escaped {
            escaped = false;
            index += 1;
            continue;
        }

        if let Some(active_quote) = quote {
            if byte == b'\\' && active_quote == b'"' {
                escaped = true;
            } else if byte == active_quote {
                quote = None;
            }
            index += 1;
            continue;
        }

        match byte {
            b'\\' => {
                escaped = true;
                index += 1;
            }
            b'\'' | b'"' => {
                quote = Some(byte);
                index += 1;
            }
            b';' | b'\n' => {
                segments.push(&command[start..index]);
                start = index + 1;
                index += 1;
            }
            b'&' if bytes.get(index + 1) == Some(&b'&') => {
                segments.push(&command[start..index]);
                start = index + 2;
                index += 2;
            }
            b'&' if bytes.get(index + 1) == Some(&b'>') || (index > 0 && bytes[index - 1] == b'>') => {
                index += 1;
            }
            b'&' => {
                segments.push(&command[start..index]);
                start = index + 1;
                index += 1;
            }
            b'|' if bytes.get(index + 1) == Some(&b'|') => {
                segments.push(&command[start..index]);
                start = index + 2;
                index += 2;
            }
            b'|' => {
                segments.push(&command[start..index]);
                start = index + 1;
                index += 1;
            }
            _ => index += 1,
        }
    }

    segments.push(&command[start..]);
    segments
}

#[cfg(test)]
mod tests {
    use regex::Regex;

    use super::{is_destructive, split_shell_segments};
    use crate::config::RegexWrapper;

    fn make_patterns(pats: &[&str]) -> Vec<RegexWrapper> {
        pats.iter().map(|p| RegexWrapper::new(Regex::new(p).unwrap())).collect()
    }

    #[test]
    fn test_tag_based_detection() {
        // Tag-based check is always-on and triggers if '#destructive' tag is present
        assert!(is_destructive("echo safe", &["#destructive".to_string()], &[]));
        assert!(is_destructive("rm -rf /", &["#destructive".to_string()], &[]));
        assert!(is_destructive(
            "some-command",
            &["#other".to_string(), "#destructive".to_string()],
            &[]
        ));

        // If '#destructive' is not present, it should not trigger without patterns
        assert!(!is_destructive("rm -rf /", &["#safe".to_string()], &[]));
    }

    #[test]
    fn redirection_ampersands_do_not_split_segments() {
        for command in ["rm -rf / 2>&1", "rm -rf / &>output", "rm -rf / >&output"] {
            assert_eq!(split_shell_segments(command), vec![command]);
        }
        assert_eq!(split_shell_segments("echo ok & rm -rf / 2>&1"), vec!["echo ok ", " rm -rf / 2>&1"]);
    }

    #[test]
    fn test_regex_patterns_detection() {
        let patterns = make_patterns(&["^rm\\b", "^del\\b"]);

        // Matches segment starting with rm or del
        assert!(is_destructive("rm -rf /", &[], &patterns));
        assert!(is_destructive("del file.txt", &[], &patterns));
        assert!(is_destructive("echo ok && rm -rf /", &[], &patterns));
        assert!(is_destructive("echo ok & rm -rf /", &[], &patterns));
        assert!(is_destructive("rm -rf / | echo", &[], &patterns));

        // Negative cases that should not match
        assert!(!is_destructive("echo rm file", &[], &patterns));
        assert!(!is_destructive("docker run --rm image", &[], &patterns));
        assert!(!is_destructive("rmdir_backup", &[], &patterns));
    }
}