1. 1//! `vak memory` (docs/design/29-personal-os.md P1): list/add/forget/
2. 2/// amend over the workspace MEMORY.md tier and the global USER.md profile
3. 3/// tier, wired straight onto `vak_core::memory`. Ids are printed so they
4. 4/// can be copied into forget/amend.
5. 5use std::path::{Path, PathBuf};
6. 6
7. 7use vak_core::Core;
8. 8use vak_core::memory::{self, NoteBlock};
9. 9
10. 10pub fn run_memory(cwd: PathBuf, action: Option<crate::cli::MemoryAction>) -> i32 {
11. 11 let core = match Core::new(cwd.clone()) {
12. 12 Ok(c) => c,
13. 13 Err(e) => {
14. 14 eprintln!("error: {e}");
15. 15 return 2;
16. 16 }
17. 17 };
18. 18 let home = core.sessions_home();
19. 19 let workspace = core.cwd().clone();
20. 20 match action.unwrap_or(crate::cli::MemoryAction::List { profile: false }) {
21. 21 crate::cli::MemoryAction::Clean { older_than_secs } => {
22. 22 let report =
23. 23 memory::cleanup_artifacts(&home, std::time::Duration::from_secs(older_than_secs));
24. 24 println!(
25. 25 "cleaned {} locks, {} temp files, {} empty workspace directories",
26. 26 report.removed_locks, report.removed_temps, report.removed_empty_dirs
27. 27 );
28. 28 0
29. 29 }
30. 30 crate::cli::MemoryAction::List { profile } => {
31. 31 list(&home, &workspace, profile);
32. 32 0
33. 33 }
34. 34 crate::cli::MemoryAction::Consolidate => match core.consolidate_memory() {
35. 35 Ok(report) => {
36. 36 println!("Memory consolidation complete:");
37. 37 println!(" Examined notes: {}", report.total_notes_examined);
38. 38 println!(
39. 39 " Promoted invariants: {}",
40. 40 report.promoted_invariants.len()
41. 41 );
42. 42 for inv in &report.promoted_invariants {
43. 43 println!(" + Invariant: \"{inv}\"");
44. 44 }
45. 45 println!(
46. 46 " Detected conflicts: {}",
47. 47 report.detected_conflicts.len()
48. 48 );
49. 49 for conf in &report.detected_conflicts {
50. 50 println!(" ! Conflict: {conf}");
51. 51 }
52. 52 println!(
53. 53 " Distilled entities: {}",
54. 54 report.distilled_entities.len()
55. 55 );
56. 56 for ent in &report.distilled_entities {
57. 57 println!(" * Entity: {ent}");
58. 58 }
59. 59 0
60. 60 }
61. 61 Err(e) => {
62. 62 eprintln!("error: {e}");
63. 63 1
64. 64 }
65. 65 },
66. 66 crate::cli::MemoryAction::Add {
67. 67 text,
68. 68 kind,
69. 69 tag,
70. 70 profile,
71. 71 } => match add(&home, &workspace, profile, &kind, &tag, &text) {
72. 72 Ok(note) => {
73. 73 println!(
74. 74 "added note {} [{}] to {}",
75. 75 note.id,
76. 76 note.kind,
77. 77 tier(profile)
78. 78 );
79. 79 0
80. 80 }
81. 81 Err(e) => {
82. 82 eprintln!("error: {e}");
83. 83 1
84. 84 }
85. 85 },
86. 86 crate::cli::MemoryAction::Forget { id, profile } => {
87. 87 match memory::forget_note(&store_path(&home, &workspace, profile), &id) {
88. 88 Ok(bytes) => {
89. 89 println!("forgot {id} ({bytes} bytes removed from {})", tier(profile));
90. 90 0
91. 91 }
92. 92 Err(e) => {
93. 93 eprintln!("error: {e}");
94. 94 1
95. 95 }
96. 96 }
97. 97 }
98. 98 crate::cli::MemoryAction::Amend { id, text, profile } => {
99. 99 match memory::amend_note(&store_path(&home, &workspace, profile), &id, &text) {
100. 100 Ok(()) => {
101. 101 println!("amended {id} in {}", tier(profile));
102. 102 0
103. 103 }
104. 104 Err(e) => {
105. 105 eprintln!("error: {e}");
106. 106 1
107. 107 }
108. 108 }
109. 109 }
110. 110 }
111. 111}
112. 112
113. 113fn tier(profile: bool) -> &'static str {
114. 114 if profile {
115. 115 "profile (USER.md)"
116. 116 } else {
117. 117 "workspace (MEMORY.md)"
118. 118 }
119. 119}
120. 120
121. 121fn store_path(home: &Path, workspace: &Path, profile: bool) -> PathBuf {
122. 122 if profile {
123. 123 memory::profile_path(home)
124. 124 } else {
125. 125 home.join("memory")
126. 126 .join(memory::hash_cwd(workspace))
127. 127 .join("MEMORY.md")
128. 128 }
129. 129}
130. 130
131. 131fn notes_for(home: &Path, workspace: &Path, profile: bool) -> Vec<NoteBlock> {
132. 132 if profile {
133. 133 memory::list_profile_notes(home)
134. 134 } else {
135. 135 memory::list_notes(home, workspace)
136. 136 }
137. 137}
138. 138
139. 139fn list(home: &Path, workspace: &Path, profile: bool) {
140. 140 let notes = notes_for(home, workspace, profile);
141. 141 if notes.is_empty() {
142. 142 println!("no memory notes in {}", tier(profile));
143. 143 return;
144. 144 }
145. 145 for n in &notes {
146. 146 println!(
147. 147 "{} {} [{}]{} session={}",
148. 148 n.id,
149. 149 n.ts.to_rfc3339(),
150. 150 n.kind,
151. 151 if n.tag.is_empty() {
152. 152 String::new()
153. 153 } else {
154. 154 format!(" tag={}", n.tag)
155. 155 },
156. 156 n.session_id
157. 157 );
158. 158 println!(" {}", n.text.replace('\n', "\n "));
159. 159 }
160. 160}
161. 161
162. 162fn add(
163. 163 home: &Path,
164. 164 workspace: &Path,
165. 165 profile: bool,
166. 166 kind: &str,
167. 167 tag: &str,
168. 168 text: &str,
169. 169) -> Result<NoteBlock, String> {
170. 170 // CLI-written notes carry a synthetic session id; provenance grammar
171. 171 // stays identical to tool-written notes.
172. 172 if profile {
173. 173 memory::append_profile_note(home, kind, tag, text, "cli")
174. 174 } else {
175. 175 memory::append_note(home, workspace, kind, tag, "cli", text)
176. 176 }
177. 177}
178. 178
179. 179#[cfg(test)]
180. 180mod tests {
181. 181 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
182. 182 use super::*;
183. 183
184. 184 #[test]
185. 185 fn store_paths_split_tiers() {
186. 186 let dir = tempfile::tempdir().unwrap();
187. 187 let home = dir.path();
188. 188 let ws = dir.path().join("ws");
189. 189 assert_eq!(
190. 190 store_path(home, &ws, true),
191. 191 home.join("memory/user/USER.md")
192. 192 );
193. 193 assert_eq!(
194. 194 store_path(home, &ws, false),
195. 195 home.join("memory")
196. 196 .join(memory::hash_cwd(&ws))
197. 197 .join("MEMORY.md")
198. 198 );
199. 199 }
200. 200
201. 201 #[test]
202. 202 fn add_list_roundtrip_both_tiers() {
203. 203 let dir = tempfile::tempdir().unwrap();
204. 204 let home = dir.path();
205. 205 let ws = dir.path().join("ws");
206. 206 std::fs::create_dir_all(&ws).unwrap();
207. 207
208. 208 let note = add(
209. 209 home,
210. 210 &ws,
211. 211 false,
212. 212 "decision",
213. 213 "deploy",
214. 214 "pause before rollbacks",
215. 215 )
216. 216 .unwrap();
217. 217 let profile_note = add(home, &ws, true, "preference", "", "vim bindings").unwrap();
218. 218
219. 219 assert!(note.id.len() == 16);
220. 220 assert_eq!(note.session_id, "cli");
221. 221 let ws_notes = notes_for(home, &ws, false);
222. 222 assert_eq!(ws_notes.len(), 1);
223. 223 assert_eq!(ws_notes[0].text, "pause before rollbacks");
224. 224 let profile_notes = notes_for(home, &ws, true);
225. 225 assert_eq!(profile_notes.len(), 1);
226. 226 assert_eq!(profile_notes[0].id, profile_note.id);
227. 227
228. 228 // forget by printed id removes exactly that block.
229. 229 let path = store_path(home, &ws, false);
230. 230 memory::forget_note(&path, &note.id).unwrap();
231. 231 assert!(notes_for(home, &ws, false).is_empty());
232. 232 }
233. 233
234. 234 #[test]
235. 235 fn empty_add_is_a_value_error() {
236. 236 let dir = tempfile::tempdir().unwrap();
237. 237 let err = add(dir.path(), dir.path(), false, "note", "", " ").unwrap_err();
238. 238 assert!(err.contains("empty"), "{err}");
239. 239 }
240. 240
241. 241 #[test]
242. 242 fn empty_listing_renders_without_panicking() {
243. 243 let dir = tempfile::tempdir().unwrap();
244. 244 let ws = dir.path().join("ws");
245. 245 list(dir.path(), &ws, false);
246. 246 list(dir.path(), &ws, true);
247. 247 }
248. 248}
249. 249