microclaw_engine/tools/
glob.rs1use 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 mut matches = if include_ignored || pattern.starts_with('/') {
86 None
87 } else {
88 match workspace_matches(&resolved_base, pattern) {
89 Ok(found) => Some(found),
90 Err(e) => return ToolResult::error(format!("Invalid glob pattern: {e}")),
91 }
92 };
93 if matches.as_ref().is_none_or(|found| found.is_empty()) {
97 matches = match literal_matches(&resolved_base, pattern) {
98 Ok(found) => Some(found),
99 Err(e) => return ToolResult::error(format!("Invalid glob pattern: {e}")),
100 };
101 }
102 let mut matches =
103 crate::internal::tool_runtime::path_guard::filter_paths(matches.unwrap_or_default());
104 matches.sort();
105 matches.dedup();
106
107 if matches.is_empty() {
108 ToolResult::success("No files found matching pattern.".into())
109 } else {
110 let count = matches.len();
111 if count > 500 {
112 matches.truncate(500);
113 matches.push(format!("... and {} more files", count - 500));
114 }
115 ToolResult::success(matches.join("\n"))
116 }
117 }
118}
119
120fn workspace_matches(base: &Path, pattern: &str) -> Result<Vec<String>, glob::PatternError> {
121 let compiled = glob::Pattern::new(pattern)?;
122 let options = glob::MatchOptions {
123 case_sensitive: true,
124 require_literal_separator: true,
125 require_literal_leading_dot: false,
126 };
127 let walk_options = super::workspace_walk::WalkOptions {
128 include_ignored: false,
129 include_dirs: true,
130 };
131 Ok(super::workspace_walk::walk(base, walk_options)
132 .into_iter()
133 .filter(|path| {
134 path.strip_prefix(base)
135 .map(|relative| compiled.matches_path_with(relative, options))
136 .unwrap_or(false)
137 })
138 .map(|path| path.display().to_string())
139 .collect())
140}
141
142fn literal_matches(base: &Path, pattern: &str) -> Result<Vec<String>, glob::PatternError> {
143 let full_pattern = if pattern.starts_with('/') {
144 pattern.to_string()
145 } else {
146 format!("{}/{}", base.display(), pattern)
147 };
148 Ok(glob::glob(&full_pattern)?
149 .filter_map(|p| p.ok())
150 .map(|p| p.display().to_string())
151 .collect())
152}
153
154#[cfg(test)]
155mod tests {
156 use super::*;
157 use serde_json::json;
158
159 #[tokio::test]
160 async fn test_glob_finds_files() {
161 let dir = std::env::temp_dir().join(format!("microclaw_glob_{}", uuid::Uuid::new_v4()));
162 std::fs::create_dir_all(&dir).unwrap();
163 std::fs::write(dir.join("a.txt"), "").unwrap();
164 std::fs::write(dir.join("b.txt"), "").unwrap();
165 std::fs::write(dir.join("c.rs"), "").unwrap();
166
167 let tool = GlobTool::new(".");
168 let result = tool
169 .execute(json!({"pattern": "*.txt", "path": dir.to_str().unwrap()}))
170 .await;
171 assert!(!result.is_error);
172 assert!(result.content.contains("a.txt"));
173 assert!(result.content.contains("b.txt"));
174 assert!(!result.content.contains("c.rs"));
175
176 let _ = std::fs::remove_dir_all(&dir);
177 }
178
179 #[tokio::test]
180 async fn test_glob_no_matches() {
181 let dir = std::env::temp_dir().join(format!("microclaw_glob2_{}", uuid::Uuid::new_v4()));
182 std::fs::create_dir_all(&dir).unwrap();
183
184 let tool = GlobTool::new(".");
185 let result = tool
186 .execute(json!({"pattern": "*.xyz", "path": dir.to_str().unwrap()}))
187 .await;
188 assert!(!result.is_error);
189 assert!(result.content.contains("No files found"));
190
191 let _ = std::fs::remove_dir_all(&dir);
192 }
193
194 #[tokio::test]
195 async fn test_glob_missing_pattern() {
196 let tool = GlobTool::new(".");
197 let result = tool.execute(json!({})).await;
198 assert!(result.is_error);
199 assert!(result.content.contains("Missing 'pattern'"));
200 }
201
202 #[tokio::test]
203 async fn test_glob_defaults_to_working_dir() {
204 let root = std::env::temp_dir().join(format!("microclaw_glob3_{}", uuid::Uuid::new_v4()));
205 let work = root.join("workspace");
206 let shared = work.join("shared");
207 std::fs::create_dir_all(&shared).unwrap();
208 std::fs::write(shared.join("x.txt"), "").unwrap();
209
210 let tool = GlobTool::new(work.to_str().unwrap());
211 let result = tool.execute(json!({"pattern":"*.txt"})).await;
212 assert!(!result.is_error);
213 assert!(result.content.contains("x.txt"));
214
215 let _ = std::fs::remove_dir_all(&root);
216 }
217
218 #[tokio::test]
219 async fn test_glob_respects_gitignore_with_literal_fallback() {
220 let dir = tempfile::tempdir().unwrap();
221 let root = dir.path();
222 std::fs::write(root.join(".gitignore"), "dist/\n").unwrap();
223 std::fs::create_dir_all(root.join("dist")).unwrap();
224 std::fs::create_dir_all(root.join("src/nested")).unwrap();
225 std::fs::write(root.join("dist/app.js"), "").unwrap();
226 std::fs::write(root.join("src/main.js"), "").unwrap();
227 std::fs::write(root.join("src/nested/util.js"), "").unwrap();
228
229 let tool = GlobTool::new(".");
230 let result = tool
231 .execute(json!({"pattern": "**/*.js", "path": root.to_str().unwrap()}))
232 .await;
233 assert!(result.content.contains("main.js"));
234 assert!(result.content.contains("util.js"));
235 assert!(!result.content.contains("app.js"));
236
237 let top_level = tool
238 .execute(json!({"pattern": "*.js", "path": root.join("src").to_str().unwrap()}))
239 .await;
240 assert!(top_level.content.contains("main.js"));
241 assert!(!top_level.content.contains("util.js"));
242
243 let explicit = tool
244 .execute(json!({"pattern": "dist/*.js", "path": root.to_str().unwrap()}))
245 .await;
246 assert!(explicit.content.contains("app.js"));
247 }
248}