1. 1//! `vak inbox` (docs/design/29-personal-os.md P6): list/show/ack/count
2. 2//! over `vak_core::inbox` (`<home>/inbox.jsonl`) without the server, the way
3. 3//! `tasks`/`memory` read their stores directly. Row/footer/count rendering
4. 4//! lives in pure helpers so tests assert strings instead of captured stdout.
5. 5
6. 6use std::path::{Path, PathBuf};
7. 7
8. 8use vak_core::Core;
9. 9use vak_core::inbox::{self, Entry, Kind};
10. 10
11. 11const DEFAULT_LIMIT: usize = 50;
12. 12const TITLE_WIDTH: usize = 48;
13. 13
14. 14pub(crate) fn run_inbox(cwd: PathBuf, action: Option<crate::cli::InboxAction>) -> i32 {
15. 15 let core = match Core::new(cwd) {
16. 16 Ok(c) => c,
17. 17 Err(e) => {
18. 18 eprintln!("error: {e}");
19. 19 return 2;
20. 20 }
21. 21 };
22. 22 run_with_home(
23. 23 &core.sessions_home(),
24. 24 action.unwrap_or(crate::cli::InboxAction::List {
25. 25 all: false,
26. 26 limit: DEFAULT_LIMIT,
27. 27 }),
28. 28 )
29. 29}
30. 30
31. 31fn run_with_home(home: &Path, action: crate::cli::InboxAction) -> i32 {
32. 32 match action {
33. 33 crate::cli::InboxAction::List { all, limit } => {
34. 34 let limit = limit.clamp(1, inbox::MAX_SCAN);
35. 35 let rows = if all {
36. 36 all_rows(home, limit)
37. 37 } else {
38. 38 unread_rows(home, limit)
39. 39 };
40. 40 if rows.is_empty() {
41. 41 println!(
42. 42 "{}",
43. 43 if all {
44. 44 "no inbox entries yet"
45. 45 } else {
46. 46 "no unread inbox entries"
47. 47 }
48. 48 );
49. 49 return 0;
50. 50 }
51. 51 for row in rows {
52. 52 println!("{row}");
53. 53 }
54. 54 println!("{}", footer(home));
55. 55 0
56. 56 }
57. 57 crate::cli::InboxAction::Show { id_prefix } => match load_entry(home, &id_prefix) {
58. 58 Ok(entry) => {
59. 59 print_show(&entry);
60. 60 0
61. 61 }
62. 62 Err(e) => {
63. 63 eprintln!("error: {e}");
64. 64 1
65. 65 }
66. 66 },
67. 67 crate::cli::InboxAction::Ack { id_prefix } => match ack_prefix(home, &id_prefix) {
68. 68 Ok(true) => {
69. 69 println!("acked");
70. 70 0
71. 71 }
72. 72 Ok(false) => {
73. 73 println!("already acked");
74. 74 0
75. 75 }
76. 76 Err(e) => {
77. 77 eprintln!("error: {e}");
78. 78 1
79. 79 }
80. 80 },
81. 81 crate::cli::InboxAction::Count => {
82. 82 println!("{}", count_line(home));
83. 83 0
84. 84 }
85. 85 }
86. 86}
87. 87
88. 88fn ledger(home: &Path) -> Vec<Entry> {
89. 89 inbox::list(home, inbox::MAX_SCAN)
90. 90}
91. 91
92. 92fn all_rows(home: &Path, limit: usize) -> Vec<String> {
93. 93 ledger(home)
94. 94 .into_iter()
95. 95 .take(limit)
96. 96 .map(|e| format_row(&e))
97. 97 .collect()
98. 98}
99. 99
100. 100fn unread_rows(home: &Path, limit: usize) -> Vec<String> {
101. 101 inbox::unread(home)
102. 102 .into_iter()
103. 103 .take(limit)
104. 104 .map(|e| format_row(&e))
105. 105 .collect()
106. 106}
107. 107
108. 108fn footer(home: &Path) -> String {
109. 109 format!(
110. 110 "{} unread of {} total",
111. 111 inbox::unread_count(home),
112. 112 ledger(home).len()
113. 113 )
114. 114}
115. 115
116. 116fn count_line(home: &Path) -> String {
117. 117 format!("{} unread", inbox::unread_count(home))
118. 118}
119. 119
120. 120fn format_row(e: &Entry) -> String {
121. 121 format_row_rel(e, &rel_ts(e.ts))
122. 122}
123. 123
124. 124fn format_row_rel(e: &Entry, rel: &str) -> String {
125. 125 format!(
126. 126 "{:<8} {:<8} {:<width$} {}",
127. 127 rel,
128. 128 kind_chip(e.kind),
129. 129 truncate_title(&e.title),
130. 130 short_hex(&e.id),
131. 131 width = TITLE_WIDTH
132. 132 )
133. 133}
134. 134
135. 135fn print_show(e: &Entry) {
136. 136 println!("kind {}", kind_chip(e.kind));
137. 137 println!("when {} ({})", e.ts.to_rfc3339(), rel_ts(e.ts));
138. 138 println!("id {}", e.id);
139. 139 println!("title {}", truncate_title(&e.title));
140. 140 if !e.body.is_empty() {
141. 141 println!();
142. 142 println!("{}", e.body);
143. 143 }
144. 144 if let Some(s) = &e.session_id {
145. 145 println!("session {s}");
146. 146 }
147. 147 if let Some(t) = &e.task_id {
148. 148 println!("task {t}");
149. 149 }
150. 150}
151. 151
152. 152fn kind_chip(kind: Kind) -> &'static str {
153. 153 match kind {
154. 154 Kind::TaskSummary => "task",
155. 155 Kind::ApprovalPending => "approval",
156. 156 Kind::ApprovalDenied => "denied",
157. 157 Kind::BudgetAlert => "budget",
158. 158 Kind::Digest => "digest",
159. 159 Kind::Heartbeat => "beat",
160. 160 Kind::ProposalOpened => "proposal",
161. 161 Kind::RoutineFailed => "refused",
162. 162 }
163. 163}
164. 164
165. 165fn truncate_title(title: &str) -> String {
166. 166 let flat = title.split_whitespace().collect::<Vec<_>>().join(" ");
167. 167 if flat.chars().count() <= TITLE_WIDTH {
168. 168 return flat;
169. 169 }
170. 170 let cut: String = flat.chars().take(TITLE_WIDTH - 1).collect();
171. 171 format!("{cut}…")
172. 172}
173. 173
174. 174/// First 8 chars of a hex id — display form only; ack runs on the full id.
175. 175fn short_hex(hex: &str) -> String {
176. 176 hex.chars().take(8).collect()
177. 177}
178. 178
179. 179/// Relative age in the house recall format: now / Nm ago / Nh ago / Nd ago.
180. 180fn rel_ts(ts: chrono::DateTime<chrono::Utc>) -> String {
181. 181 let secs = (chrono::Utc::now() - ts).num_seconds().max(0) as u64;
182. 182 if secs < 60 {
183. 183 "now".to_string()
184. 184 } else if secs < 3600 {
185. 185 format!("{}m ago", secs / 60)
186. 186 } else if secs < 86_400 {
187. 187 format!("{}h ago", secs / 3600)
188. 188 } else {
189. 189 format!("{}d ago", secs / 86_400)
190. 190 }
191. 191}
192. 192
193. 193#[derive(Debug, Clone, PartialEq, Eq)]
194. 194enum MatchError {
195. 195 NotFound(String),
196. 196 Ambiguous(String),
197. 197}
198. 198
199. 199impl std::fmt::Display for MatchError {
200. 200 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
201. 201 match self {
202. 202 Self::NotFound(given) => write!(f, "no inbox entry matches '{given}'"),
203. 203 Self::Ambiguous(given) => {
204. 204 write!(
205. 205 f,
206. 206 "'{given}' matches several inbox entries — use more of the id"
207. 207 )
208. 208 }
209. 209 }
210. 210 }
211. 211}
212. 212
213. 213/// Resolve a user-supplied id (full 16-hex or unique prefix) to exactly one
214. 214/// entry. An exact full-id hit wins even if it is also another's prefix.
215. 215fn resolve<'a>(entries: &'a [Entry], given: &str) -> Result<&'a Entry, MatchError> {
216. 216 if let Some(e) = entries.iter().find(|e| e.id == given) {
217. 217 return Ok(e);
218. 218 }
219. 219 let hits: Vec<&Entry> = entries.iter().filter(|e| e.id.starts_with(given)).collect();
220. 220 match hits.as_slice() {
221. 221 [one] => Ok(one),
222. 222 [] => Err(MatchError::NotFound(given.to_string())),
223. 223 _ => Err(MatchError::Ambiguous(given.to_string())),
224. 224 }
225. 225}
226. 226
227. 227fn load_entry(home: &Path, given: &str) -> Result<Entry, MatchError> {
228. 228 let ledgered = ledger(home);
229. 229 resolve(&ledgered, given).cloned()
230. 230}
231. 231
232. 232/// Ack by prefix against the full ledger (acked entries stay resolvable).
233. 233fn ack_prefix(home: &Path, given: &str) -> Result<bool, String> {
234. 234 let id = load_entry(home, given).map_err(|e| e.to_string())?.id;
235. 235 inbox::ack(home, &id).map_err(|e| e.to_string())
236. 236}
237. 237
238. 238#[cfg(test)]
239. 239mod tests {
240. 240 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
241. 241 use super::*;
242. 242 use chrono::Utc;
243. 243
244. 244 fn entry(id: &str, kind: Kind, title: &str) -> Entry {
245. 245 Entry {
246. 246 id: id.to_string(),
247. 247 ts: Utc::now(),
248. 248 kind,
249. 249 title: title.to_string(),
250. 250 body: String::new(),
251. 251 session_id: None,
252. 252 task_id: None,
253. 253 result_id: None,
254. 254 dedupe_key: None,
255. 255 }
256. 256 }
257. 257
258. 258 #[test]
259. 259 fn prefix_resolution_exact_unique_ambiguous_notfound() {
260. 260 let entries = vec![
261. 261 entry("aaaa111111111111", Kind::Digest, "a"),
262. 262 entry("aaaa222222222222", Kind::Digest, "b"),
263. 263 entry("bbbb333333333333", Kind::Digest, "c"),
264. 264 ];
265. 265 assert_eq!(
266. 266 resolve(&entries, "aaaa111111111111").map(|e| e.id.as_str()),
267. 267 Ok("aaaa111111111111")
268. 268 );
269. 269 // Unique longer prefix disambiguates the aaaa pair.
270. 270 assert_eq!(
271. 271 resolve(&entries, "aaaa2").map(|e| e.id.as_str()),
272. 272 Ok("aaaa222222222222")
273. 273 );
274. 274 // Ambiguous prefixes are refused, never silently resolved.
275. 275 assert_eq!(
276. 276 resolve(&entries, "aaaa"),
277. 277 Err(MatchError::Ambiguous("aaaa".to_string()))
278. 278 );
279. 279 // Empty prefix matches everything, so it is ambiguous too.
280. 280 assert_eq!(
281. 281 resolve(&entries, ""),
282. 282 Err(MatchError::Ambiguous(String::new()))
283. 283 );
284. 284 assert_eq!(
285. 285 resolve(&entries, "ffff"),
286. 286 Err(MatchError::NotFound("ffff".to_string()))
287. 287 );
288. 288 }
289. 289
290. 290 #[test]
291. 291 fn kind_chips_cover_every_kind_within_column_width() {
292. 292 let chips = [
293. 293 (Kind::TaskSummary, "task"),
294. 294 (Kind::ApprovalPending, "approval"),
295. 295 (Kind::ApprovalDenied, "denied"),
296. 296 (Kind::BudgetAlert, "budget"),
297. 297 (Kind::Digest, "digest"),
298. 298 (Kind::Heartbeat, "beat"),
299. 299 (Kind::ProposalOpened, "proposal"),
300. 300 ];
301. 301 for (kind, chip) in chips {
302. 302 assert_eq!(kind_chip(kind), chip);
303. 303 assert!(chip.chars().count() <= 8, "{chip} breaks the column");
304. 304 }
305. 305 }
306. 306
307. 307 #[test]
308. 308 fn rows_truncate_multiline_titles_and_show_id8() {
309. 309 let long = entry(
310. 310 "0123456789abcdef",
311. 311 Kind::BudgetAlert,
312. 312 &format!("{} tail", "x".repeat(60)),
313. 313 );
314. 314 let row = format_row_rel(&long, "5m ago");
315. 315 let cells: Vec<&str> = row.split(" ").filter(|c| !c.is_empty()).collect();
316. 316 assert_eq!(cells[0], "5m ago");
317. 317 assert_eq!(cells[1], "budget");
318. 318 // Collapsed to one line, clipped under the column width, ellipsized.
319. 319 assert!(cells[2].ends_with('…'));
320. 320 assert!(cells[2].chars().count() <= TITLE_WIDTH);
321. 321 assert!(!cells[2].contains("tail"));
322. 322 assert_eq!(cells[3], "01234567");
323. 323
324. 324 let short = entry("fedcba9876543210", Kind::TaskSummary, "tiny\ntwo lines");
325. 325 let row = format_row_rel(&short, "now");
326. 326 assert!(row.contains("tiny two lines"), "{row}");
327. 327 assert!(!row.contains('…'), "{row}");
328. 328 assert!(row.ends_with("fedcba98"));
329. 329 }
330. 330
331. 331 #[test]
332. 332 fn unread_all_footer_and_count_math_on_seeded_store() {
333. 333 let dir = tempfile::tempdir().unwrap();
334. 334 let home = dir.path();
335. 335 let a = inbox::record(home, Kind::Digest, "alpha one", "b", None, None).unwrap();
336. 336 let b = inbox::record(home, Kind::BudgetAlert, "beta two", "b", None, None).unwrap();
337. 337 let _c = inbox::record(home, Kind::Heartbeat, "gamma three", "b", None, None).unwrap();
338. 338
339. 339 assert_eq!(count_line(home), "3 unread");
340. 340 assert_eq!(footer(home), "3 unread of 3 total");
341. 341
342. 342 assert!(inbox::ack(home, &b.id).unwrap());
343. 343 let unread = unread_rows(home, 50);
344. 344 assert_eq!(unread.len(), 2, "acked entry leaves the unread view");
345. 345 assert!(all_rows(home, 50).len() == 3, "--all keeps acked rows");
346. 346 assert_eq!(footer(home), "2 unread of 3 total");
347. 347 assert_eq!(count_line(home), "2 unread");
348. 348
349. 349 // --limit truncates rows but never the totals.
350. 350 assert_eq!(unread_rows(home, 1).len(), 1);
351. 351
352. 352 // b was already acked above; idempotent acks report false.
353. 353 assert!(inbox::ack(home, &a.id).unwrap());
354. 354 assert!(!inbox::ack(home, &b.id).unwrap());
355. 355 assert!(inbox::ack(home, &_c.id).unwrap());
356. 356 assert_eq!(footer(home), "0 unread of 3 total");
357. 357 assert_eq!(count_line(home), "0 unread");
358. 358 }
359. 359
360. 360 #[test]
361. 361 fn ack_by_prefix_idempotent_and_unknown_is_typed_error() {
362. 362 let dir = tempfile::tempdir().unwrap();
363. 363 let home = dir.path();
364. 364 let e = inbox::record(
365. 365 home,
366. 366 Kind::ApprovalPending,
367. 367 "gate",
368. 368 "body",
369. 369 Some("s1"),
370. 370 Some("t1"),
371. 371 )
372. 372 .unwrap();
373. 373
374. 374 let prefix = short_hex(&e.id);
375. 375 assert_eq!(ack_prefix(home, &prefix), Ok(true));
376. 376 assert_eq!(ack_prefix(home, &prefix), Ok(false));
377. 377
378. 378 let err = ack_prefix(home, "ffffffff").unwrap_err();
379. 379 assert!(err.contains("no inbox entry matches 'ffffffff'"), "{err}");
380. 380
381. 381 // show resolves the same prefix even after the entry was acked.
382. 382 let shown = load_entry(home, &prefix).unwrap();
383. 383 assert_eq!(shown.id, e.id);
384. 384 assert_eq!(shown.session_id.as_deref(), Some("s1"));
385. 385 assert_eq!(shown.task_id.as_deref(), Some("t1"));
386. 386 }
387. 387
388. 388 #[test]
389. 389 fn empty_stores_render_clear_messages() {
390. 390 let dir = tempfile::tempdir().unwrap();
391. 391 let home = dir.path();
392. 392 assert_eq!(count_line(home), "0 unread");
393. 393 assert!(unread_rows(home, DEFAULT_LIMIT).is_empty());
394. 394 assert!(all_rows(home, DEFAULT_LIMIT).is_empty());
395. 395 assert!(load_entry(home, "deadbeef").is_err());
396. 396 }
397. 397}
398. 398