1. 1use std::path::Path;
2. 2
3. 3use async_trait::async_trait;
4. 4use globset::{Glob, GlobSetBuilder};
5. 5use regex::Regex;
6. 6use serde_json::Value;
7. 7use walkdir::WalkDir;
8. 8
9. 9use crate::{Tool, ToolContext, ToolOutput};
10. 10
11. 11const MAX_MATCH_LINES: usize = 300;
12. 12
13. 13pub struct GrepTool;
14. 14
15. 15#[async_trait]
16. 16impl Tool for GrepTool {
17. 17 fn name(&self) -> &str {
18. 18 "grep"
19. 19 }
20. 20
21. 21 fn serves(&self) -> &'static [&'static str] {
22. 22 &["filesystem"]
23. 23 }
24. 24
25. 25 fn always_loaded(&self) -> bool {
26. 26 true
27. 27 }
28. 28
29. 29 fn description(&self) -> &str {
30. 30 "Search file contents with a regular expression. Returns file:line:text matches. Use include to filter by glob (e.g. \"*.rs\")."
31. 31 }
32. 32
33. 33 fn schema(&self) -> Value {
34. 34 serde_json::json!({
35. 35 "type": "object",
36. 36 "properties": {
37. 37 "pattern": {"type": "string", "description": "Regular expression to search for"},
38. 38 "path": {"type": "string", "description": "File or directory to search (default: cwd)"},
39. 39 "include": {"type": "string", "description": "Glob filter for filenames, e.g. *.ts"}
40. 40 },
41. 41 "required": ["pattern"]
42. 42 })
43. 43 }
44. 44
45. 45 fn claims(&self, _args: &Value) -> crate::ResourceClaims {
46. 46 crate::ResourceClaims {
47. 47 exclusive: false,
48. 48 read_only: true,
49. 49 paths: Vec::new(),
50. 50 }
51. 51 }
52. 52
53. 53 async fn execute(&self, args: &Value, ctx: &ToolContext) -> ToolOutput {
54. 54 let Some(pattern) = args.get("pattern").and_then(|p| p.as_str()) else {
55. 55 return ToolOutput::error("missing required parameter: pattern");
56. 56 };
57. 57 let re = match Regex::new(pattern) {
58. 58 Ok(r) => r,
59. 59 Err(e) => return ToolOutput::error(format!("invalid regex: {e}")),
60. 60 };
61. 61 let base = match args.get("path").and_then(|p| p.as_str()) {
62. 62 Some(p) => ctx.resolve(Path::new(p)),
63. 63 None => ctx.cwd.clone(),
64. 64 };
65. 65 let include = args.get("include").and_then(|i| i.as_str());
66. 66 let include_set = match include {
67. 67 Some(glob_str) => {
68. 68 let g = match Glob::new(glob_str) {
69. 69 Ok(g) => g,
70. 70 Err(e) => return ToolOutput::error(format!("invalid include: {e}")),
71. 71 };
72. 72 match GlobSetBuilder::new().add(g).build() {
73. 73 Ok(gs) => Some(gs),
74. 74 Err(e) => return ToolOutput::error(format!("invalid include: {e}")),
75. 75 }
76. 76 }
77. 77 None => None,
78. 78 };
79. 79
80. 80 if !base.exists() {
81. 81 return ToolOutput::error(format!("path not found: {}", base.display()));
82. 82 }
83. 83
84. 84 // File IO + regex over whole trees is blocking; keep it off the
85. 85 // async workers that carry SSE and TUI delivery.
86. 86 let cwd = ctx.cwd.clone();
87. 87 let walked =
88. 88 tokio::task::spawn_blocking(move || search_tree(&base, &re, include_set, &cwd)).await;
89. 89 let out = match walked {
90. 90 Ok(out) => out,
91. 91 Err(e) => return ToolOutput::error(format!("grep task failed: {e}")),
92. 92 };
93. 93
94. 94 match out {
95. 95 SearchOutcome::Empty => ToolOutput::ok("no matches"),
96. 96 SearchOutcome::Hits(text) => ToolOutput::ok(text),
97. 97 }
98. 98 }
99. 99}
100. 100
101. 101enum SearchOutcome {
102. 102 Empty,
103. 103 Hits(String),
104. 104}
105. 105
106. 106fn search_file_bytes(path: &Path, root: &Path, re: &Regex, out: &mut String) -> usize {
107. 107 let Ok(bytes) = std::fs::read(path) else {
108. 108 return 0;
109. 109 };
110. 110 if bytes.iter().take(8192).any(|&b| b == 0) {
111. 111 return 0;
112. 112 }
113. 113 let text = String::from_utf8_lossy(&bytes);
114. 114 let mut hits = 0usize;
115. 115 for (i, line) in text.lines().enumerate() {
116. 116 if re.is_match(line) {
117. 117 out.push_str(&format!(
118. 118 "{}:{}:{line}\n",
119. 119 path.strip_prefix(root).unwrap_or(path).display(),
120. 120 i + 1
121. 121 ));
122. 122 hits += 1;
123. 123 }
124. 124 }
125. 125 hits
126. 126}
127. 127
128. 128fn search_tree(
129. 129 base: &Path,
130. 130 re: &Regex,
131. 131 include_set: Option<globset::GlobSet>,
132. 132 cwd: &Path,
133. 133) -> SearchOutcome {
134. 134 let mut out = String::new();
135. 135 let mut count = 0usize;
136. 136
137. 137 if base.is_file() {
138. 138 count = search_file_bytes(base, cwd, re, &mut out);
139. 139 return if count == 0 {
140. 140 SearchOutcome::Empty
141. 141 } else {
142. 142 SearchOutcome::Hits(out)
143. 143 };
144. 144 }
145. 145
146. 146 'outer: for entry in WalkDir::new(base)
147. 147 .follow_links(false)
148. 148 .into_iter()
149. 149 .filter_entry(|e| !crate::glob::is_ignored(e.path()))
150. 150 .flatten()
151. 151 {
152. 152 if !entry.file_type().is_file() {
153. 153 continue;
154. 154 }
155. 155 if let Some(gs) = &include_set {
156. 156 let name_ok = entry
157. 157 .file_name()
158. 158 .to_str()
159. 159 .map(|n| gs.is_match(n))
160. 160 .unwrap_or(false);
161. 161 if !name_ok {
162. 162 continue;
163. 163 }
164. 164 }
165. 165 count += search_file_bytes(entry.path(), cwd, re, &mut out);
166. 166 if count >= MAX_MATCH_LINES {
167. 167 out.push_str("\n[match limit reached]");
168. 168 break 'outer;
169. 169 }
170. 170 }
171. 171
172. 172 if count == 0 {
173. 173 SearchOutcome::Empty
174. 174 } else {
175. 175 SearchOutcome::Hits(out)
176. 176 }
177. 177}
178. 178