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 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        // Nothing visible matched: fall back to a literal filesystem glob so
94        // explicitly targeted hidden or ignored paths (".github/**", "dist/*")
95        // keep working.
96        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}