rippy-cli 0.2.0

A shell command safety hook for AI coding tools (Claude Code, Cursor, Gemini CLI) — Rust rewrite of Dippy
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

use super::{Classification, Handler, HandlerContext, has_flag};

pub static FIND_HANDLER: FindHandler = FindHandler;

pub struct FindHandler;

impl Handler for FindHandler {
    fn commands(&self) -> &[&str] {
        &["find"]
    }

    fn classify(&self, ctx: &HandlerContext) -> Classification {
        if has_flag(ctx.args, &["-delete"]) {
            return Classification::Ask("find -delete".into());
        }

        if has_flag(ctx.args, &["-ok", "-okdir"]) {
            return Classification::Ask("find -ok (interactive)".into());
        }

        // -exec / -execdir: extract inner command and delegate
        for (i, arg) in ctx.args.iter().enumerate() {
            if arg == "-exec" || arg == "-execdir" {
                let inner_args: Vec<&str> = ctx.args[i + 1..]
                    .iter()
                    .take_while(|a| a.as_str() != ";" && a.as_str() != "+")
                    .map(String::as_str)
                    .collect();
                if !inner_args.is_empty() {
                    return Classification::Recurse(inner_args.join(" "));
                }
                return Classification::Ask(format!("find {arg}"));
            }
        }

        Classification::Allow("find (search only)".into())
    }
}

#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
    use std::path::Path;

    use super::*;

    fn ctx<'a>(args: &'a [String], cmd: &'a str) -> HandlerContext<'a> {
        HandlerContext {
            command_name: cmd,
            args,
            working_directory: Path::new("/tmp"),
            remote: false,
            receives_piped_input: false,
            cd_allowed_dirs: &[],
        }
    }

    #[test]
    fn find_search_only_allows() {
        let args: Vec<String> = vec![".".into(), "-name".into(), "*.rs".into()];
        let result = FIND_HANDLER.classify(&ctx(&args, "find"));
        assert!(matches!(result, Classification::Allow(_)));
    }

    #[test]
    fn find_delete_asks() {
        let args: Vec<String> = vec![".".into(), "-name".into(), "*.tmp".into(), "-delete".into()];
        let result = FIND_HANDLER.classify(&ctx(&args, "find"));
        assert!(matches!(result, Classification::Ask(reason) if reason.contains("delete")));
    }

    #[test]
    fn find_exec_recurses() {
        let args: Vec<String> = vec![
            ".".into(),
            "-name".into(),
            "*.rs".into(),
            "-exec".into(),
            "wc".into(),
            "-l".into(),
            "{}".into(),
            ";".into(),
        ];
        let result = FIND_HANDLER.classify(&ctx(&args, "find"));
        assert!(matches!(result, Classification::Recurse(cmd) if cmd == "wc -l {}"));
    }

    #[test]
    fn find_ok_asks() {
        let args: Vec<String> = vec![
            ".".into(),
            "-ok".into(),
            "rm".into(),
            "{}".into(),
            ";".into(),
        ];
        let result = FIND_HANDLER.classify(&ctx(&args, "find"));
        assert!(matches!(result, Classification::Ask(reason) if reason.contains("ok")));
    }
}