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(¬e);
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
146fn 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
171const MAX_LITERAL_ENTRIES: usize = 50_000;
175
176fn has_glob_meta(component: &str) -> bool {
177 component.contains(['*', '?', '['])
178}
179
180fn 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 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}