Publish harness and TUI open-source

initial sync from the monorepo

crates/codegen/xai-grok-hooks/src/matcher.rs

@@ -0,0 +1,196 @@
+use regex::Regex;
+use xai_grok_tools::types::{claude_names_for, grok_names_for};
+
+/// A compiled hook matcher for tool names. The pattern semantics are chosen so that
+/// `matcher` entries in hooks migrated from other agent CLIs keep firing unchanged:
+///
+/// - an empty pattern or `"*"` matches every tool;
+/// - a "simple" pattern (only `[A-Za-z0-9_|]`, i.e. a plain name or `|`-list) is an
+///   **exact** match against each name (after external→Grok alias expansion), NOT a regex;
+/// - anything else is an **unanchored** regex (also tested against the tool's external
+///   alias names, so e.g. `^Bash$` matches the Grok tool `run_terminal_command`).
+///
+/// The simple-vs-regex split is deliberate: it avoids anchoring a `|`-alternation (a
+/// naive `^a|b|c$` anchors only the first/last term and silently over-matches). Whitespace
+/// is significant (not trimmed): `"  "` is a regex that matches nothing.
+#[derive(Debug, Clone)]
+pub struct HookMatcher {
+    kind: MatcherKind,
+}
+
+#[derive(Debug, Clone)]
+enum MatcherKind {
+    All,
+    Exact(Vec<String>),
+    Regex(Regex),
+}
+
+impl HookMatcher {
+    /// Compile a matcher from a user pattern. Errors only when a regex-form pattern is
+    /// itself invalid regex (simple/empty/`*` forms never error).
+    pub fn new(pattern: &str) -> Result<Self, regex::Error> {
+        let kind = if pattern.is_empty() || pattern == "*" {
+            MatcherKind::All
+        } else if is_simple_form(pattern) {
+            MatcherKind::Exact(exact_names(pattern))
+        } else {
+            MatcherKind::Regex(Regex::new(pattern)?)
+        };
+        Ok(Self { kind })
+    }
+
+    pub fn is_match(&self, tool_name: &str) -> bool {
+        match &self.kind {
+            MatcherKind::All => true,
+            MatcherKind::Exact(names) => names.iter().any(|n| n == tool_name),
+            MatcherKind::Regex(regex) => {
+                regex.is_match(tool_name)
+                    || claude_names_for(tool_name).any(|alias| regex.is_match(alias))
+            }
+        }
+    }
+}
+
+/// A pattern is "simple" (exact/`|`-list, not regex) when it contains only
+/// ASCII alphanumerics, `_`, and `|`.
+fn is_simple_form(pattern: &str) -> bool {
+    !pattern.is_empty()
+        && pattern
+            .bytes()
+            .all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'|')
+}
+
+/// Expand a simple-form pattern into the exact set of names it matches: each `|`-term
+/// plus any Grok tool names that term aliases (so `"Bash"` also matches
+/// `run_terminal_command`), per the shared external-name to Grok registry in
+/// `xai-grok-tools`. Empty terms and duplicates are dropped.
+fn exact_names(pattern: &str) -> Vec<String> {
+    let mut names: Vec<String> = Vec::new();
+    let mut push = |name: &str| {
+        if !name.is_empty() && !names.iter().any(|n| n == name) {
+            names.push(name.to_string());
+        }
+    };
+    for term in pattern.split('|') {
+        push(term);
+        for grok_name in grok_names_for(term) {
+            push(grok_name);
+        }
+    }
+    names
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn exact_match() {
+        let m = HookMatcher::new("run_terminal_command").unwrap();
+        assert!(m.is_match("run_terminal_command"));
+        assert!(!m.is_match("run_terminal_command_v2"));
+        assert!(!m.is_match("other_tool"));
+    }
+
+    #[test]
+    fn pipe_list_is_exact_per_term() {
+        let m = HookMatcher::new("read_file|list_dir").unwrap();
+        assert!(m.is_match("read_file"));
+        assert!(m.is_match("list_dir"));
+        assert!(!m.is_match("grep"));
+        // Regression for the old `^a|b$` anchoring bug: terms must not substring-match.
+        assert!(!m.is_match("my_read_file"));
+        assert!(!m.is_match("list_dir_v2"));
+    }
+
+    #[test]
+    fn pipe_skips_empty_terms() {
+        // Leading/trailing/double pipes contribute no spurious empty-string match.
+        let m = HookMatcher::new("|read_file||grep|").unwrap();
+        assert!(m.is_match("read_file"));
+        assert!(m.is_match("grep"));
+        assert!(!m.is_match(""));
+    }
+
+    #[test]
+    fn regex_form_is_unanchored() {
+        // Contains regex metachars -> regex mode, unanchored.
+        let m = HookMatcher::new("run_.*").unwrap();
+        assert!(m.is_match("run_terminal_command"));
+        assert!(m.is_match("xrun_yyy")); // unanchored: substring match
+        assert!(!m.is_match("read_file"));
+    }
+
+    #[test]
+    fn anchored_regex_respects_user_anchors() {
+        let m = HookMatcher::new("^run_.*$").unwrap();
+        assert!(m.is_match("run_terminal_command"));
+        assert!(!m.is_match("xrun_yyy"));
+        assert!(!m.is_match("read_file"));
+    }
+
+    #[test]
+    fn invalid_regex_errors() {
+        assert!(HookMatcher::new("[invalid").is_err());
+    }
+
+    #[test]
+    fn star_and_empty_match_all() {
+        for pat in ["*", ""] {
+            let m = HookMatcher::new(pat).unwrap();
+            assert!(m.is_match("read_file"), "{pat:?} should match all");
+            assert!(m.is_match("anything_at_all"), "{pat:?} should match all");
+        }
+    }
+
+    #[test]
+    fn whitespace_matcher_matches_nothing() {
+        // Whitespace is NOT trimmed; `"   "` is a regex that matches no
+        // real tool name (NOT match-all, which would turn a deny gate into deny-all).
+        let m = HookMatcher::new("   ").unwrap();
+        assert!(!m.is_match("read_file"));
+        assert!(!m.is_match("run_terminal_command"));
+    }
+
+    // ── External tool-name aliases ────────────────────────────────
+
+    #[test]
+    fn claude_bash_matches_grok_tool() {
+        let m = HookMatcher::new("Bash").unwrap();
+        assert!(m.is_match("Bash")); // external alias name
+        assert!(m.is_match("run_terminal_command")); // Grok name
+        assert!(!m.is_match("read_file"));
+        // Bug-fix regression: exact, not prefix.
+        assert!(!m.is_match("run_terminal_command_v2"));
+    }
+
+    #[test]
+    fn claude_edit_write_matches_grok_tool_exactly() {
+        let m = HookMatcher::new("Edit|Write").unwrap();
+        assert!(m.is_match("Edit"));
+        assert!(m.is_match("Write"));
+        assert!(m.is_match("search_replace")); // Grok equivalent
+        assert!(m.is_match("hashline_edit")); // second Grok alias
+        assert!(!m.is_match("read_file"));
+        // The old anchoring bug matched these; the exact-list mode must not.
+        assert!(!m.is_match("Editorial"));
+        assert!(!m.is_match("my_search_replace"));
+    }
+
+    #[test]
+    fn claude_read_matches_grok_tool() {
+        let m = HookMatcher::new("Read").unwrap();
+        assert!(m.is_match("Read"));
+        assert!(m.is_match("read_file"));
+        assert!(m.is_match("hashline_read"));
+    }
+
+    #[test]
+    fn regex_against_claude_alias_matches_grok_tool() {
+        // A regex written against an external alias still matches the Grok tool
+        // (legacy alias-name expansion).
+        let m = HookMatcher::new("^Bash$").unwrap();
+        assert!(m.is_match("run_terminal_command"));
+        assert!(m.is_match("Bash"));
+    }
+}