1. 1//! Plain-text formatting helpers for the headless CLI's non-interactive
2. 2//! output (tool-call summaries, unified diffs, ANSI stripping).
3. 3//!
4. 4//! These are adapted from the now-removed `vak-tui` crate, keeping only the
5. 5//! plain (non-ANSI, non-interactive) code paths — no crossterm/ratatui
6. 6//! rendering, keymap, palette, editor, or event loop involved.
7. 7
8. 8use similar::{ChangeTag, TextDiff};
9. 9
10. 10/// Summarize a tool call's JSON args into a short one-line hint for the CLI's
11. 11/// progress output (e.g. `▸ bash echo hi`).
12. 12pub fn summarize_args(name: &str, args_json: &str) -> String {
13. 13 let Ok(v) = serde_json::from_str::<serde_json::Value>(args_json) else {
14. 14 return trunc_cells(args_json, 60);
15. 15 };
16. 16 let pick = |k: &str| v.get(k).and_then(|x| x.as_str()).unwrap_or("").to_string();
17. 17 let hint = match name {
18. 18 "bash" => pick("command"),
19. 19 "read" | "write" | "edit" => pick("path"),
20. 20 "glob" => pick("pattern"),
21. 21 "webfetch" => pick("url"),
22. 22 "grep" => {
23. 23 let base = v.get("path").and_then(|x| x.as_str()).unwrap_or(".");
24. 24 format!("{} in {base}", pick("pattern"))
25. 25 }
26. 26 _ => v.to_string(),
27. 27 };
28. 28 trunc_cells(&hint, 90)
29. 29}
30. 30
31. 31/// Truncate `s` to at most `max` display columns (accounting for
32. 32/// double-width characters), appending an ellipsis when truncated.
33. 33pub fn trunc_cells(s: &str, max: usize) -> String {
34. 34 let mut w = 0usize;
35. 35 for (i, c) in s.char_indices() {
36. 36 w += char_width(c);
37. 37 if w > max {
38. 38 return format!("{}…", &s[..i]);
39. 39 }
40. 40 }
41. 41 s.to_string()
42. 42}
43. 43
44. 44fn char_width(c: char) -> usize {
45. 45 let cp = u32::from(c);
46. 46 if cp < 0x20 || (0x7F..0xA0).contains(&cp) {
47. 47 return 0;
48. 48 }
49. 49 if is_zero_width(cp) {
50. 50 return 0;
51. 51 }
52. 52 if is_wide(cp) { 2 } else { 1 }
53. 53}
54. 54
55. 55fn is_zero_width(cp: u32) -> bool {
56. 56 matches!(
57. 57 cp,
58. 58 0x0300..=0x036F
59. 59 | 0x0483..=0x0489
60. 60 | 0x0591..=0x05BD
61. 61 | 0x05BF
62. 62 | 0x05C1..=0x05C2
63. 63 | 0x05C4..=0x05C5
64. 64 | 0x05C7
65. 65 | 0x0610..=0x061A
66. 66 | 0x064B..=0x065F
67. 67 | 0x0670
68. 68 | 0x06D6..=0x06DC
69. 69 | 0x06DF..=0x06E4
70. 70 | 0x06E7..=0x06E8
71. 71 | 0x06EA..=0x06ED
72. 72 | 0x0711
73. 73 | 0x0730..=0x074A
74. 74 | 0x07A6..=0x07B0
75. 75 | 0x0816..=0x0819
76. 76 | 0x081B..=0x0823
77. 77 | 0x0825..=0x0827
78. 78 | 0x0829..=0x082D
79. 79 | 0x0E31
80. 80 | 0x0E34..=0x0E3A
81. 81 | 0x0E47..=0x0E4E
82. 82 | 0x135D..=0x135F
83. 83 | 0x1AB0..=0x1AFF
84. 84 | 0x1DC0..=0x1DFF
85. 85 | 0x200B..=0x200F
86. 86 | 0x202A..=0x202E
87. 87 | 0x2060..=0x2064
88. 88 | 0x206A..=0x206F
89. 89 | 0x20D0..=0x20F0
90. 90 | 0xFE00..=0xFE0F
91. 91 | 0xFE20..=0xFE2F
92. 92 | 0xFEFF
93. 93 | 0xE0100..=0xE01EF
94. 94 )
95. 95}
96. 96
97. 97fn is_wide(cp: u32) -> bool {
98. 98 matches!(
99. 99 cp,
100. 100 0x1100..=0x115F
101. 101 | 0x2329..=0x232A
102. 102 | 0x2600..=0x27BF
103. 103 | 0x2E80..=0x303E
104. 104 | 0x3041..=0x33FF
105. 105 | 0x3400..=0x4DBF
106. 106 | 0x4E00..=0x9FFF
107. 107 | 0xA000..=0xA4CF
108. 108 | 0xA960..=0xA97F
109. 109 | 0xAC00..=0xD7A3
110. 110 | 0xF900..=0xFAFF
111. 111 | 0xFE10..=0xFE19
112. 112 | 0xFE30..=0xFE6F
113. 113 | 0xFF00..=0xFF60
114. 114 | 0xFFE0..=0xFFE6
115. 115 | 0x1B000..=0x1B2FF
116. 116 | 0x1F000..=0x1FFFD
117. 117 | 0x20000..=0x3FFFD
118. 118 )
119. 119}
120. 120
121. 121/// Render a plain (no ANSI) unified diff for the `edit` tool's args JSON.
122. 122/// Mirrors `vak_tui::app::edit_diff_text` but skips styling entirely since
123. 123/// the CLI's plain output has no use for it.
124. 124pub fn edit_diff_text(args_json: &str, max_lines: usize) -> Option<String> {
125. 125 let v: serde_json::Value = serde_json::from_str(args_json).ok()?;
126. 126 let pairs: Vec<(String, String)> =
127. 127 if let Some(edits) = v.get("edits").and_then(|e| e.as_array()) {
128. 128 edits
129. 129 .iter()
130. 130 .filter_map(|e| {
131. 131 let old = e.get("old_string").and_then(|x| x.as_str())?;
132. 132 let new = e.get("new_string").and_then(|x| x.as_str())?;
133. 133 Some((old.to_string(), new.to_string()))
134. 134 })
135. 135 .collect()
136. 136 } else {
137. 137 let old = v.get("old_string").and_then(|x| x.as_str())?;
138. 138 let new = v.get("new_string").and_then(|x| x.as_str())?;
139. 139 vec![(old.to_string(), new.to_string())]
140. 140 };
141. 141 let mut out = String::new();
142. 142 let mut any = false;
143. 143 for (old, new) in pairs {
144. 144 if old.is_empty() && new.is_empty() {
145. 145 continue;
146. 146 }
147. 147 out.push_str(&unified_diff(&old, &new, max_lines));
148. 148 out.push('\n');
149. 149 any = true;
150. 150 }
151. 151 any.then_some(out)
152. 152}
153. 153
154. 154/// Plain unified diff renderer, adapted from `vak_tui::diffview::unified`
155. 155/// with ANSI styling stripped since the caller only wants plain text.
156. 156fn unified_diff(old: &str, new: &str, max_lines: usize) -> String {
157. 157 let diff = TextDiff::from_lines(old, new);
158. 158 let mut lines: Vec<String> = Vec::new();
159. 159 for group in diff.grouped_ops(3) {
160. 160 if group.is_empty() {
161. 161 continue;
162. 162 }
163. 163 let mut old_start = usize::MAX;
164. 164 let mut old_end = 0;
165. 165 let mut new_start = usize::MAX;
166. 166 let mut new_end = 0;
167. 167 for op in &group {
168. 168 let o = op.old_range();
169. 169 let n = op.new_range();
170. 170 old_start = old_start.min(o.start);
171. 171 old_end = old_end.max(o.end);
172. 172 new_start = new_start.min(n.start);
173. 173 new_end = new_end.max(n.end);
174. 174 }
175. 175 lines.push(format!(
176. 176 "@@ -{},{} +{},{} @@",
177. 177 old_start.saturating_add(1),
178. 178 old_end - old_start,
179. 179 new_start.saturating_add(1),
180. 180 new_end - new_start
181. 181 ));
182. 182 for op in &group {
183. 183 for change in diff.iter_changes(op) {
184. 184 let body = change.value().trim_end_matches(['\n', '\r']);
185. 185 lines.push(match change.tag() {
186. 186 ChangeTag::Equal => body.to_string(),
187. 187 ChangeTag::Delete => format!("- {body}"),
188. 188 ChangeTag::Insert => format!("+ {body}"),
189. 189 });
190. 190 }
191. 191 }
192. 192 }
193. 193 render_capped(&lines, max_lines)
194. 194}
195. 195
196. 196fn render_capped(lines: &[String], max_lines: usize) -> String {
197. 197 let mut out = String::new();
198. 198 let keep = if lines.len() > max_lines {
199. 199 max_lines.saturating_sub(1)
200. 200 } else {
201. 201 lines.len()
202. 202 };
203. 203 for line in &lines[..keep] {
204. 204 out.push_str(line);
205. 205 out.push('\n');
206. 206 }
207. 207 if lines.len() > keep {
208. 208 out.push_str(&format!("… (+{} more)", lines.len() - keep));
209. 209 } else if !out.is_empty() {
210. 210 out.truncate(out.len() - 1);
211. 211 }
212. 212 out
213. 213}
214. 214
215. 215/// Strip ANSI escape sequences from a string (used when a tool's captured
216. 216/// output includes color codes that plain CLI output should not show).
217. 217pub fn strip_ansi(s: &str) -> String {
218. 218 let mut out = String::with_capacity(s.len());
219. 219 let mut chars = s.chars().peekable();
220. 220 while let Some(c) = chars.next() {
221. 221 if c == '\x1b' && chars.peek() == Some(&'[') {
222. 222 chars.next();
223. 223 for c in chars.by_ref() {
224. 224 if c.is_ascii_alphabetic() {
225. 225 break;
226. 226 }
227. 227 }
228. 228 } else {
229. 229 out.push(c);
230. 230 }
231. 231 }
232. 232 out
233. 233}
234. 234