snapif 0.1.2

Snapif scores one tool call and returns Auto, Review, or Escalate.
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

#[macro_export]
macro_rules! choice {
    (
        $(#[$meta:meta])*
        $vis:vis enum $name:ident {
            $($variant:ident = $wire:literal => $criteria:literal),* $(,)?
        }
    ) => {
        $(#[$meta])*
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        $vis enum $name {
            $($variant),*
        }

        impl $crate::question::ChoiceLabels for $name {
            fn labels() -> &'static [(&'static str, &'static str)] {
                &[$(($wire, $criteria)),*]
            }

            fn from_label(s: &str) -> Option<Self> {
                match s {
                    $($wire => Some(Self::$variant),)*
                    _ => None,
                }
            }

            fn as_label(&self) -> &'static str {
                match self {
                    $(Self::$variant => $wire,)*
                }
            }
        }
    };
}

#[macro_export]
macro_rules! score {
    (
        $(#[$meta:meta])*
        $vis:vis enum $name:ident {
            $($variant:ident = $criteria:literal),* $(,)?
        }
    ) => {
        $(#[$meta])*
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        $vis enum $name {
            $($variant),*
        }

        impl $crate::question::ScoreLabels for $name {
            fn criteria() -> &'static [&'static str] {
                &[$($criteria),*]
            }

            fn from_index(i: usize) -> Option<Self> {
                let mut n = 0usize;
                $(
                    if n == i {
                        return Some(Self::$variant);
                    }
                    n += 1;
                )*
                let _ = n;
                None
            }

            fn as_index(&self) -> usize {
                let mut i = 0usize;
                $(
                    if matches!(self, Self::$variant) {
                        return i;
                    }
                    i += 1;
                )*
                i
            }
        }
    };
}