Skip to main content

microclaw_engine/tools/
glob.rs

1use async_trait::async_trait;
2use serde_json::json;
3use std::path::{Path, PathBuf};
4use tracing::info;
5
6use crate::config::WorkingDirIsolation;
7use microclaw_core::llm_types::ToolDefinition;
8
9use super::{schema_object, Tool, ToolResult};
10
11pub struct GlobTool {
12    working_dir: PathBuf,
13    working_dir_isolation: WorkingDirIsolation,
14}
15
16impl GlobTool {
17    pub fn new(working_dir: &str) -> Self {
18        Self::new_with_isolation(working_dir, WorkingDirIsolation::Shared)
19    }
20
21    pub fn new_with_isolation(
22        working_dir: &str,
23        working_dir_isolation: WorkingDirIsolation,
24    ) -> Self {
25        Self {
26            working_dir: PathBuf::from(working_dir),
27            working_dir_isolation,
28        }
29    }
30}
31
32#[async_trait]
33impl Tool for GlobTool {
34    fn name(&self) -> &str {
35        "glob"
36    }
37
38    fn definition(&self) -> ToolDefinition {
39        ToolDefinition {
40            name: "glob".into(),
41            description: "Find files matching a glob pattern. Returns matching file paths. Relative patterns respect .gitignore/.ignore files and skip hidden, node_modules and target directories; set include_ignored (or target a hidden/ignored path explicitly) to match everything.".into(),
42            input_schema: schema_object(
43                json!({
44                    "pattern": {
45                        "type": "string",
46                        "description": "The glob pattern to match (e.g., '**/*.rs', 'src/**/*.ts')"
47                    },
48                    "path": {
49                        "type": "string",
50                        "description": "Base directory to search from (default: current directory)"
51                    },
52                    "include_ignored": {
53                        "type": "boolean",
54                        "description": "Also match hidden files and files excluded by .gitignore/.ignore (default: false)"
55                    }
56                }),
57                &["pattern"],
58            ),
59        }
60    }
61
62    async fn execute(&self, input: serde_json::Value) -> ToolResult {
63        let pattern = match input.get("pattern").and_then(|v| v.as_str()) {
64            Some(p) => p,
65            None => return ToolResult::error("Missing 'pattern' parameter".into()),
66        };
67        let base = input.get("path").and_then(|v| v.as_str()).unwrap_or(".");
68        let working_dir =
69            super::resolve_tool_working_dir(&self.working_dir, self.working_dir_isolation, &input);
70        let resolved_base = super::resolve_tool_path(&working_dir, base);
71        let resolved_base_str = resolved_base.to_string_lossy().to_string();
72
73        if let Err(msg) = crate::internal::tool_runtime::path_guard::check_path(&resolved_base_str)
74        {
75            return ToolResult::error(msg);
76        }
77
78        info!("Glob: {} in {}", pattern, resolved_base.display());
79
80        let include_ignored = input
81            .get("include_ignored")
82            .and_then(|v| v.as_bool())
83            .unwrap_or(false);
84
85        let pattern = pattern.to_string();
86        let search = tokio::task::spawn_blocking(move || {
87            find_matches(&resolved_base, &pattern, include_ignored)
88        })
89        .await;
90        let (mut matches, truncated) = match search {
91            Ok(Ok(found)) => found,
92            Ok(Err(e)) => return ToolResult::error(format!("Invalid glob pattern: {e}")),
93            Err(e) => return ToolResult::error(format!("Glob search failed: {e}")),
94        };
95        matches.sort();
96        matches.dedup();
97        let stopped = truncated.then(|| {
98            format!(
99                "Search stopped after visiting {MAX_LITERAL_ENTRIES} entries; narrow `path` or the pattern."
100            )
101        });
102
103        if matches.is_empty() {
104            let mut text = "No files found matching pattern.".to_string();
105            if let Some(note) = stopped {
106                text.push(' ');
107                text.push_str(&note);
108            }
109            ToolResult::success(text)
110        } else {
111            let count = matches.len();
112            if count > 500 {
113                matches.truncate(500);
114                matches.push(format!("... and {} more files", count - 500));
115            }
116            if let Some(note) = stopped {
117                matches.push(note);
118            }
119            ToolResult::success(matches.join("\n"))
120        }
121    }
122}
123
124fn workspace_matches(base: &Path, pattern: &str) -> Result<Vec<String>, glob::PatternError> {
125    let compiled = glob::Pattern::new(pattern)?;
126    let options = glob::MatchOptions {
127        case_sensitive: true,
128        require_literal_separator: true,
129        require_literal_leading_dot: false,
130    };
131    let walk_options = super::workspace_walk::WalkOptions {
132        include_ignored: false,
133        include_dirs: true,
134    };
135    Ok(super::workspace_walk::walk(base, walk_options)
136        .into_iter()
137        .filter(|path| {
138            path.strip_prefix(base)
139                .map(|relative| compiled.matches_path_with(relative, options))
140                .unwrap_or(false)
141        })
142        .map(|path| path.display().to_string())
143        .collect())
144}
145
146/// Visible matches first; when nothing visible matches, a literal walk so
147/// explicitly targeted hidden or ignored paths (".github/**", "dist/*") and
148/// absolute patterns keep working. Returns the path-guard filtered matches
149/// and whether the literal walk stopped early.
150fn find_matches(
151    base: &Path,
152    pattern: &str,
153    include_ignored: bool,
154) -> Result<(Vec<String>, bool), glob::PatternError> {
155    if !include_ignored && !pattern.starts_with('/') {
156        let found = workspace_matches(base, pattern)?;
157        if !found.is_empty() {
158            return Ok((
159                crate::internal::tool_runtime::path_guard::filter_paths(found),
160                false,
161            ));
162        }
163    }
164    let (found, truncated) = literal_matches(base, pattern, MAX_LITERAL_ENTRIES)?;
165    Ok((
166        crate::internal::tool_runtime::path_guard::filter_paths(found),
167        truncated,
168    ))
169}
170
171/// Upper bound on entries (files and directories) one literal walk visits,
172/// so a broad pattern over a large tree (`**/x` from a home directory)
173/// answers in about a second instead of scanning the disk.
174const MAX_LITERAL_ENTRIES: usize = 50_000;
175
176fn has_glob_meta(component: &str) -> bool {
177    component.contains(['*', '?', '['])
178}
179
180/// Walk from the literal prefix of `pattern` (everything before the first
181/// component with a wildcard) and match full paths. Hidden and ignored
182/// entries are included; the walk stops after `limit` visited entries.
183fn literal_matches(
184    base: &Path,
185    pattern: &str,
186    limit: usize,
187) -> Result<(Vec<String>, bool), glob::PatternError> {
188    let (mut root, rest) = if pattern.starts_with('/') {
189        (PathBuf::from("/"), pattern.trim_start_matches('/'))
190    } else {
191        (base.to_path_buf(), pattern.trim_start_matches("./"))
192    };
193    let mut wild: Vec<&str> = Vec::new();
194    for component in rest.split('/').filter(|c| !c.is_empty() && *c != ".") {
195        if wild.is_empty() && !has_glob_meta(component) {
196            root.push(component);
197        } else {
198            wild.push(component);
199        }
200    }
201    if wild.is_empty() {
202        // No wildcard at all: the pattern names one path.
203        return Ok((
204            if root.exists() {
205                vec![root.display().to_string()]
206            } else {
207                Vec::new()
208            },
209            false,
210        ));
211    }
212    let compiled = glob::Pattern::new(&format!(
213        "{}/{}",
214        glob::Pattern::escape(&root.to_string_lossy()).trim_end_matches('/'),
215        wild.join("/")
216    ))?;
217    let options = glob::MatchOptions {
218        case_sensitive: true,
219        require_literal_separator: true,
220        require_literal_leading_dot: false,
221    };
222    let mut builder = ignore::WalkBuilder::new(&root);
223    builder.standard_filters(false).follow_links(false);
224    if !wild.contains(&"**") {
225        builder.max_depth(Some(wild.len()));
226    }
227    let mut out = Vec::new();
228    let mut visited = 0usize;
229    for entry in builder.build().flatten() {
230        if entry.depth() == 0 {
231            continue;
232        }
233        visited += 1;
234        if visited > limit {
235            return Ok((out, true));
236        }
237        if compiled.matches_path_with(entry.path(), options) {
238            out.push(entry.path().display().to_string());
239        }
240    }
241    Ok((out, false))
242}
243
244#[cfg(test)]
245mod tests {
246    use super::*;
247    use serde_json::json;
248
249    #[tokio::test]
250    async fn test_glob_finds_files() {
251        let dir = std::env::temp_dir().join(format!("microclaw_glob_{}", uuid::Uuid::new_v4()));
252        std::fs::create_dir_all(&dir).unwrap();
253        std::fs::write(dir.join("a.txt"), "").unwrap();
254        std::fs::write(dir.join("b.txt"), "").unwrap();
255        std::fs::write(dir.join("c.rs"), "").unwrap();
256
257        let tool = GlobTool::new(".");
258        let result = tool
259            .execute(json!({"pattern": "*.txt", "path": dir.to_str().unwrap()}))
260            .await;
261        assert!(!result.is_error);
262        assert!(result.content.contains("a.txt"));
263        assert!(result.content.contains("b.txt"));
264        assert!(!result.content.contains("c.rs"));
265
266        let _ = std::fs::remove_dir_all(&dir);
267    }
268
269    #[tokio::test]
270    async fn test_glob_no_matches() {
271        let dir = std::env::temp_dir().join(format!("microclaw_glob2_{}", uuid::Uuid::new_v4()));
272        std::fs::create_dir_all(&dir).unwrap();
273
274        let tool = GlobTool::new(".");
275        let result = tool
276            .execute(json!({"pattern": "*.xyz", "path": dir.to_str().unwrap()}))
277            .await;
278        assert!(!result.is_error);
279        assert!(result.content.contains("No files found"));
280
281        let _ = std::fs::remove_dir_all(&dir);
282    }
283
284    #[tokio::test]
285    async fn test_glob_missing_pattern() {
286        let tool = GlobTool::new(".");
287        let result = tool.execute(json!({})).await;
288        assert!(result.is_error);
289        assert!(result.content.contains("Missing 'pattern'"));
290    }
291
292    #[tokio::test]
293    async fn test_glob_defaults_to_working_dir() {
294        let root = std::env::temp_dir().join(format!("microclaw_glob3_{}", uuid::Uuid::new_v4()));
295        let work = root.join("workspace");
296        let shared = work.join("shared");
297        std::fs::create_dir_all(&shared).unwrap();
298        std::fs::write(shared.join("x.txt"), "").unwrap();
299
300        let tool = GlobTool::new(work.to_str().unwrap());
301        let result = tool.execute(json!({"pattern":"*.txt"})).await;
302        assert!(!result.is_error);
303        assert!(result.content.contains("x.txt"));
304
305        let _ = std::fs::remove_dir_all(&root);
306    }
307
308    #[tokio::test]
309    async fn test_glob_respects_gitignore_with_literal_fallback() {
310        let dir = tempfile::tempdir().unwrap();
311        let root = dir.path();
312        std::fs::write(root.join(".gitignore"), "dist/\n").unwrap();
313        std::fs::create_dir_all(root.join("dist")).unwrap();
314        std::fs::create_dir_all(root.join("src/nested")).unwrap();
315        std::fs::write(root.join("dist/app.js"), "").unwrap();
316        std::fs::write(root.join("src/main.js"), "").unwrap();
317        std::fs::write(root.join("src/nested/util.js"), "").unwrap();
318
319        let tool = GlobTool::new(".");
320        let result = tool
321            .execute(json!({"pattern": "**/*.js", "path": root.to_str().unwrap()}))
322            .await;
323        assert!(result.content.contains("main.js"));
324        assert!(result.content.contains("util.js"));
325        assert!(!result.content.contains("app.js"));
326
327        let top_level = tool
328            .execute(json!({"pattern": "*.js", "path": root.join("src").to_str().unwrap()}))
329            .await;
330        assert!(top_level.content.contains("main.js"));
331        assert!(!top_level.content.contains("util.js"));
332
333        let explicit = tool
334            .execute(json!({"pattern": "dist/*.js", "path": root.to_str().unwrap()}))
335            .await;
336        assert!(explicit.content.contains("app.js"));
337    }
338
339    #[tokio::test]
340    async fn literal_fallback_finds_hidden_and_absolute_paths() {
341        let dir = tempfile::tempdir().unwrap();
342        let root = dir.path();
343        std::fs::create_dir_all(root.join(".github/workflows")).unwrap();
344        std::fs::write(root.join(".github/workflows/ci.yml"), "").unwrap();
345        std::fs::write(root.join("README.md"), "").unwrap();
346
347        let tool = GlobTool::new(".");
348        let hidden = tool
349            .execute(json!({"pattern": ".github/workflows/*.yml", "path": root.to_str().unwrap()}))
350            .await;
351        assert!(hidden.content.contains("ci.yml"), "{}", hidden.content);
352
353        let absolute = format!("{}/**/*.yml", root.display());
354        let found = tool.execute(json!({"pattern": absolute})).await;
355        assert!(found.content.contains("ci.yml"), "{}", found.content);
356        assert!(!found.content.contains("README.md"));
357
358        let exact = tool
359            .execute(json!({"pattern": "README.md", "path": root.to_str().unwrap(), "include_ignored": true}))
360            .await;
361        assert!(exact.content.contains("README.md"), "{}", exact.content);
362    }
363
364    #[test]
365    fn literal_walk_stops_after_the_entry_limit() {
366        let dir = tempfile::tempdir().unwrap();
367        for i in 0..30 {
368            std::fs::create_dir_all(dir.path().join(format!("d{i}/inner"))).unwrap();
369        }
370        let (found, truncated) = literal_matches(dir.path(), "**/missing*", 20).unwrap();
371        assert!(found.is_empty());
372        assert!(truncated);
373        let (_, truncated) = literal_matches(dir.path(), "**/missing*", 1_000).unwrap();
374        assert!(!truncated);
375    }
376}