Add glob tool for ergonomic file matching (Phase 7)

Supports standard glob patterns (**/*.rs, src/**/*.tsx) with * and ? wildcards.
Respects .gitignore via ignore crate. Sorted by modification time.
Handles nested directory matching. Complements find_files (regex-based).

Author: Yogthos

Cargo.lock

@@ -65,6 +65,7 @@ base64 = "0.22"
 streaming-iterator = { version = "0.1", optional = true }
 janetrs = { version = "0.8", optional = true }
 html2text = "0.17"
+glob = "0.3.3"
 
 [profile.release]
 opt-level = "z"

Cargo.toml

@@ -159,6 +159,7 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
                 ask_tx.clone(),
                 cache.clone(),
             )),
+            Box::new(tools::GlobTool::new(permission.clone(), ask_tx.clone())),
             Box::new(tools::ListDirTool::with_cache(
                 permission.clone(),
                 ask_tx.clone(),

src/agent/builder.rs

@@ -0,0 +1,220 @@
+use ignore::WalkBuilder;
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use serde::Deserialize;
+use std::path::Path;
+
+use crate::agent::tools::{AskSender, PermCheck, ToolError, check_perm};
+use crate::agent::tools::{MAX_FIND_RESULTS, is_skip_dir};
+
+pub struct GlobTool {
+    pub permission: Option<PermCheck>,
+    pub ask_tx: Option<AskSender>,
+}
+
+impl GlobTool {
+    pub fn new(permission: Option<PermCheck>, ask_tx: Option<AskSender>) -> Self {
+        Self {
+            permission,
+            ask_tx,
+        }
+    }
+}
+
+#[derive(Deserialize)]
+pub struct GlobArgs {
+    pub pattern: String,
+    pub path: Option<String>,
+}
+
+fn glob_to_regex(pattern: &str) -> Result<regex::Regex, String> {
+    let mut regex_str = String::from("^");
+    let chars: Vec<char> = pattern.chars().collect();
+    let mut i = 0;
+    while i < chars.len() {
+        if i + 1 < chars.len() && chars[i] == '*' && chars[i + 1] == '*' {
+            // ** — match any depth
+            if i + 2 < chars.len() && chars[i + 2] == '/' {
+                regex_str.push_str("(?:.*/)?");
+                i += 3;
+                continue;
+            } else {
+                regex_str.push_str(".*");
+                i += 2;
+                continue;
+            }
+        } else if chars[i] == '*' {
+            regex_str.push_str("[^/]*");
+        } else if chars[i] == '?' {
+            regex_str.push_str("[^/]");
+        } else {
+            let c = chars[i];
+            if ".+()[]{}^$|\\".contains(c) {
+                regex_str.push('\\');
+            }
+            regex_str.push(c);
+        }
+        i += 1;
+    }
+    regex_str.push('$');
+    regex::Regex::new(&regex_str).map_err(|e| format!("invalid glob pattern: {}", e))
+}
+
+impl Tool for GlobTool {
+    const NAME: &'static str = "glob";
+
+    type Error = ToolError;
+    type Args = GlobArgs;
+    type Output = String;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: "glob".to_string(),
+            description: "Find files matching a glob pattern (e.g., '**/*.rs', 'src/**/*.tsx'). Respects .gitignore. Returns matching file paths sorted by modification time. Use this for natural path pattern matching instead of regex-based find_files."
+                .to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "Glob pattern to match file paths (e.g. '**/*.rs', 'src/agent/**/*.rs')"
+                    },
+                    "path": {
+                        "type": "string",
+                        "description": "Root directory to search in (default: current working directory)"
+                    }
+                },
+                "required": ["pattern"]
+            }),
+        }
+    }
+
+    async fn call(&self, args: GlobArgs) -> Result<String, ToolError> {
+        check_perm(
+            &self.permission,
+            &self.ask_tx,
+            "glob",
+            &format!("pattern:{}", args.pattern),
+        )
+        .await?;
+
+        let re = glob_to_regex(&args.pattern)
+            .map_err(|e| ToolError::Msg(e))?;
+
+        let root = args
+            .path
+            .as_deref()
+            .map(Path::new)
+            .filter(|p| p.is_dir())
+            .unwrap_or_else(|| Path::new("."));
+
+        let mut matches: Vec<String> = Vec::new();
+
+        let walker = WalkBuilder::new(root)
+            .hidden(false)
+            .git_global(false)
+            .git_ignore(true)
+            .git_exclude(true)
+            .build();
+
+        for entry in walker {
+            let entry = entry.map_err(|e| ToolError::Msg(e.to_string()))?;
+            if !entry.file_type().map_or(false, |ft| ft.is_file()) {
+                continue;
+            }
+
+            let path = entry.path();
+            let relative = path
+                .strip_prefix(root)
+                .unwrap_or(path)
+                .to_string_lossy()
+                .into_owned();
+
+            // Skip ignored dirs
+            if let Some(parent) = path.parent() {
+                if parent
+                    .file_name()
+                    .map_or(false, |n| is_skip_dir(&n.to_string_lossy()))
+                {
+                    continue;
+                }
+            }
+
+            if re.is_match(&relative) {
+                matches.push(relative);
+            }
+
+            if matches.len() >= MAX_FIND_RESULTS {
+                break;
+            }
+        }
+
+        // Sort by modification time (newest first), fall back to alphabetical
+        matches.sort_by(|a, b| {
+            let ma = std::fs::metadata(a)
+                .ok()
+                .and_then(|m| m.modified().ok());
+            let mb = std::fs::metadata(b)
+                .ok()
+                .and_then(|m| m.modified().ok());
+            match (ma, mb) {
+                (Some(a), Some(b)) => b.cmp(&a),
+                _ => a.cmp(b),
+            }
+        });
+
+        if matches.is_empty() {
+            Ok("no files matched".to_string())
+        } else {
+            Ok(matches.join("\n"))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_glob_to_regex_basic() {
+        let re = glob_to_regex("*.rs").unwrap();
+        assert!(re.is_match("main.rs"));
+        assert!(re.is_match("lib.rs"));
+        assert!(!re.is_match("main.py"));
+        assert!(!re.is_match("src/main.rs"));
+    }
+
+    #[test]
+    fn test_glob_to_regex_recursive() {
+        let re = glob_to_regex("**/*.rs").unwrap();
+        assert!(re.is_match("main.rs"));
+        assert!(re.is_match("src/main.rs"));
+        assert!(re.is_match("src/agent/tools/foo.rs"));
+        assert!(!re.is_match("main.py"));
+    }
+
+    #[test]
+    fn test_glob_to_regex_nested_dir() {
+        let re = glob_to_regex("src/**/*.rs").unwrap();
+        assert!(!re.is_match("main.rs"));
+        assert!(re.is_match("src/main.rs"));
+        assert!(re.is_match("src/agent/tools/foo.rs"));
+        assert!(!re.is_match("lib/main.rs"));
+    }
+
+    #[test]
+    fn test_glob_to_regex_question_mark() {
+        let re = glob_to_regex("file.??").unwrap();
+        assert!(re.is_match("file.rs"));
+        assert!(re.is_match("file.py"));
+        assert!(!re.is_match("file.cpp"));
+        assert!(!re.is_match("file.r"));
+    }
+
+    #[tokio::test]
+    async fn test_definition_has_correct_name() {
+        let tool = GlobTool::new(None, None);
+        let def = tool.definition(String::new()).await;
+        assert_eq!(def.name, "glob");
+    }
+}

src/agent/tools/glob.rs

@@ -4,6 +4,7 @@ mod bash;
 pub(crate) mod cache;
 pub(crate) mod edit;
 mod find_files;
+mod glob;
 mod grep;
 mod list_dir;
 mod memory;
@@ -25,6 +26,7 @@ pub use bash::BashTool;
 pub use cache::ToolCache;
 pub use edit::EditTool;
 pub use find_files::FindFilesTool;
+pub use glob::GlobTool;
 pub use grep::GrepTool;
 pub use list_dir::ListDirTool;
 pub use memory::MemoryTool;

src/agent/tools/mod.rs

@@ -73,7 +73,7 @@ fn format_tool_call_summary(name: &str, args: &serde_json::Value) -> String {
     let primary_keys: &[&str] = match name {
         "read" | "write" | "edit" | "list_dir" => &["path"],
         "grep" => &["pattern", "path"],
-        "find_files" => &["pattern"],
+        "find_files" | "glob" => &["pattern"],
         "bash" => &["command"],
         "question" => &["questions"],
         "task" | "task_status" => &["prompt", "task_id"],