eggsact 1.2.7

Deterministic MCP and in-process utility tools for coding agents
Documentation
use regex::Regex;

#[derive(Debug, Clone)]
pub struct GlobMatchResult {
    pub matches: bool,
    pub normalized_pattern: String,
    pub normalized_path: String,
    pub matched_segment: Option<String>,
    pub unmatched_segment: Option<String>,
    pub summary: String,
}

fn split_path_posix(path: &str) -> Vec<&str> {
    if path.is_empty() {
        return vec![];
    }
    path.split('/').filter(|p| !p.is_empty()).collect()
}

fn split_path_windows(path: &str) -> Vec<String> {
    let mut segments: Vec<String> = vec![];

    let chars: Vec<char> = path.chars().collect();
    if chars.len() >= 2 && chars[1] == ':' {
        segments.push(chars[..2].iter().collect());
        let rest: String = chars[2..].iter().collect();
        if !rest.is_empty() {
            let parts: Vec<&str> = rest.split(['/', '\\']).filter(|p| !p.is_empty()).collect();
            segments.extend(parts.iter().map(|p| p.to_string()));
        }
        return segments;
    }

    if path.starts_with("\\\\") {
        let parts: Vec<&str> = path.split(['/', '\\']).filter(|p| !p.is_empty()).collect();
        if parts.len() >= 2 {
            segments.push(format!("\\\\{}\\{}", parts[0], parts[1]));
            segments.extend(parts[2..].iter().map(|p| p.to_string()));
        } else if !parts.is_empty() {
            segments.push(format!("\\\\{}", parts[0]));
        }
        return segments;
    }

    let parts: Vec<&str> = path.split(['/', '\\']).filter(|p| !p.is_empty()).collect();
    parts.into_iter().map(|p| p.to_string()).collect()
}

fn casefold(s: &str) -> String {
    s.to_lowercase()
}

fn fnmatch_segment(pattern: &str, segment: &str, case_sensitive: bool) -> bool {
    let pattern = if case_sensitive {
        pattern.to_string()
    } else {
        casefold(pattern)
    };
    let segment = if case_sensitive {
        segment.to_string()
    } else {
        casefold(segment)
    };

    let regex_pattern = fnmatch_to_regex(&pattern);
    match Regex::new(&regex_pattern) {
        Ok(re) => re.is_match(&segment),
        Err(_) => false,
    }
}

fn fnmatch_to_regex(pattern: &str) -> String {
    let mut regex_parts = String::from("^");
    let chars: Vec<char> = pattern.chars().collect();
    let mut i = 0;

    while i < chars.len() {
        let char = chars[i];
        match char {
            '*' => regex_parts.push_str("[^/]*"),
            '?' => regex_parts.push_str("[^/]"),
            '[' => {
                let mut j = i + 1;
                if j < chars.len() && chars[j] == '!' {
                    j += 1;
                }
                if j < chars.len() && chars[j] == ']' {
                    j += 1;
                }
                while j < chars.len() && chars[j] != ']' {
                    j += 1;
                }
                if j >= chars.len() {
                    regex_parts.push_str("\\[");
                    i += 1;
                } else {
                    let mut char_class = String::new();
                    for c in chars.iter().take(j + 1).skip(i) {
                        char_class.push(*c);
                    }
                    if char_class.starts_with("[!") {
                        char_class = format!("[^{}", &char_class[2..]);
                    }
                    regex_parts.push_str(&char_class);
                    i = j;
                }
            }
            '/' => regex_parts.push('/'),
            '\\' | '.' | '^' | '$' | '|' | '(' | ')' | '{' | '}' | '+' => {
                regex_parts.push('\\');
                regex_parts.push(char);
            }
            _ => {
                regex_parts.push(char);
            }
        }
        i += 1;
    }

    regex_parts.push('$');
    regex_parts
}

fn match_double_star(
    pattern_parts: &[&str],
    path_parts: &[String],
    p_idx: usize,
    mut path_idx: usize,
    case_sensitive: bool,
) -> (bool, usize, usize) {
    let next_pattern_idx = p_idx + 1;

    if next_pattern_idx >= pattern_parts.len() {
        return (true, next_pattern_idx, path_parts.len());
    }

    while path_idx <= path_parts.len() {
        let remaining_pattern = &pattern_parts[next_pattern_idx..];
        let remaining_path: Vec<&str> = if path_idx < path_parts.len() {
            path_parts[path_idx..].iter().map(|s| s.as_str()).collect()
        } else {
            vec![]
        };

        let (matched, consumed_p, consumed_path) =
            match_segments(remaining_pattern, &remaining_path, case_sensitive);

        if matched {
            return (
                true,
                next_pattern_idx + consumed_p,
                path_idx + consumed_path,
            );
        }

        if path_idx < path_parts.len() {
            path_idx += 1;
        } else {
            break;
        }
    }

    (false, p_idx, p_idx)
}

fn match_segments(
    pattern_parts: &[&str],
    path_parts: &[&str],
    case_sensitive: bool,
) -> (bool, usize, usize) {
    let mut p_idx = 0;
    let mut path_idx = 0;

    while p_idx < pattern_parts.len() && path_idx < path_parts.len() {
        let pattern_seg = pattern_parts[p_idx];

        if pattern_seg == "**" {
            let path_strs: Vec<String> = path_parts.iter().map(|s| (*s).to_string()).collect();
            let (matched, new_p_idx, new_path_idx) =
                match_double_star(pattern_parts, &path_strs, p_idx, path_idx, case_sensitive);
            if !matched {
                return (false, p_idx, path_idx);
            }
            p_idx = new_p_idx;
            path_idx = new_path_idx;
        } else if pattern_seg.contains("**") {
            return (false, p_idx, path_idx);
        } else {
            if !fnmatch_segment(pattern_seg, path_parts[path_idx], case_sensitive) {
                return (false, p_idx, path_idx);
            }
            p_idx += 1;
            path_idx += 1;
        }
    }

    while p_idx < pattern_parts.len() {
        if pattern_parts[p_idx] == "**" {
            p_idx += 1;
        } else {
            return (false, p_idx, path_idx);
        }
    }

    (p_idx == pattern_parts.len(), p_idx, path_idx)
}

pub fn glob_match(
    pattern: &str,
    path: &str,
    platform: &str,
    case_sensitive: bool,
) -> GlobMatchResult {
    let normalized_pattern = pattern.to_string();
    let normalized_path = path.to_string();

    let path_parts: Vec<String> = if platform == "windows" {
        split_path_windows(path)
    } else {
        split_path_posix(path)
            .into_iter()
            .map(|s| s.to_string())
            .collect()
    };

    let mut pattern_parts: Vec<&str> = vec![];
    let mut i = 0;

    let chars: Vec<char> = pattern.chars().collect();
    let char_to_byte: Vec<usize> = pattern
        .char_indices()
        .map(|(byte_offset, _)| byte_offset)
        .chain(std::iter::once(pattern.len()))
        .collect();

    while i < chars.len() {
        if i + 1 < chars.len() && chars[i] == '*' && chars[i + 1] == '*' {
            if i + 2 < chars.len() && chars[i + 2] == '/' {
                pattern_parts.push("**");
                i += 3;
            } else {
                pattern_parts.push("**");
                i += 2;
            }
        } else if chars[i] == '/' {
            i += 1;
        } else {
            let mut j = i;
            while j < chars.len() {
                if chars[j] == '/' {
                    break;
                }
                if j + 1 < chars.len() && chars[j] == '*' && chars[j + 1] == '*' {
                    break;
                }
                j += 1;
            }
            let byte_start = char_to_byte[i];
            let byte_end = char_to_byte[j];
            pattern_parts.push(&pattern[byte_start..byte_end]);
            i = j;
        }
    }

    let path_strs: Vec<&str> = path_parts.iter().map(|s| s.as_str()).collect();
    let (matched, _, _) = match_segments(&pattern_parts, &path_strs, case_sensitive);

    if matched {
        GlobMatchResult {
            matches: true,
            normalized_pattern,
            normalized_path,
            matched_segment: None,
            unmatched_segment: None,
            summary: "Pattern matches path".to_string(),
        }
    } else {
        GlobMatchResult {
            matches: false,
            normalized_pattern,
            normalized_path,
            matched_segment: None,
            unmatched_segment: None,
            summary: "Pattern does not match path".to_string(),
        }
    }
}