1. 1//! vak-store: SQLite FTS5 rebuildable index over JSONL session ledgers.
2. 2//!
3. 3//! JSONL files remain the source of truth. This crate builds a persistent
4. 4//! query index (FTS5 for full-text search, normalized table for structured
5. 5//! queries) that can be fully reconstructed from the JSONL at any time.
6. 6//!
7. 7//! Design: `docs/design/23-memory.md` — rebuildable index layer.
8. 8
9. 9use std::path::{Path, PathBuf};
10. 10use std::sync::{Arc, Mutex};
11. 11
12. 12use rusqlite::Connection;
13. 13use serde::{Deserialize, Serialize};
14. 14
15. 15pub mod index;
16. 16pub mod presentation;
17. 17pub mod query;
18. 18
19. 19/// The database file name within the sessions home directory.
20. 20pub const DB_NAME: &str = "store.db";
21. 21
22. 22/// Version tag stored in the `meta` table; bump when the schema changes.
23. 23const SCHEMA_VERSION: u32 = 1;
24. 24
25. 25// ---------------------------------------------------------------------------
26. 26// Entry metadata (written to the `entries` table alongside FTS rows)
27. 27// ---------------------------------------------------------------------------
28. 28
29. 29#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
30. 30pub enum EntryKind {
31. 31 Header,
32. 32 Message,
33. 33 Compaction,
34. 34 Receipt,
35. 35 Goal,
36. 36 Activity,
37. 37 Work,
38. 38 Intent,
39. 39}
40. 40
41. 41impl EntryKind {
42. 42 pub fn as_str(&self) -> &'static str {
43. 43 match self {
44. 44 Self::Header => "header",
45. 45 Self::Message => "message",
46. 46 Self::Compaction => "compaction",
47. 47 Self::Receipt => "receipt",
48. 48 Self::Goal => "goal",
49. 49 Self::Activity => "activity",
50. 50 Self::Work => "work",
51. 51 Self::Intent => "intent",
52. 52 }
53. 53 }
54. 54
55. 55 pub fn parse_str(s: &str) -> Option<Self> {
56. 56 match s {
57. 57 "header" => Some(Self::Header),
58. 58 "message" => Some(Self::Message),
59. 59 "compaction" => Some(Self::Compaction),
60. 60 "receipt" => Some(Self::Receipt),
61. 61 "goal" => Some(Self::Goal),
62. 62 "activity" => Some(Self::Activity),
63. 63 "intent" => Some(Self::Intent),
64. 64 "work" => Some(Self::Work),
65. 65 _ => None,
66. 66 }
67. 67 }
68. 68}
69. 69
70. 70#[derive(Debug, Clone, Serialize, Deserialize)]
71. 71pub struct IndexedEntry {
72. 72 pub entry_id: String,
73. 73 pub session_id: String,
74. 74 pub project_hash: String,
75. 75 pub parent_id: Option<String>,
76. 76 pub ts: String,
77. 77 pub kind: EntryKind,
78. 78 pub role: Option<String>,
79. 79 pub provider: Option<String>,
80. 80 pub model: Option<String>,
81. 81 pub tool_name: Option<String>,
82. 82 pub content_text: String,
83. 83 pub is_error: bool,
84. 84}
85. 85
86. 86#[derive(Debug, thiserror::Error)]
87. 87pub enum StoreError {
88. 88 #[error("database error: {0}")]
89. 89 Db(#[from] rusqlite::Error),
90. 90 #[error("io error: {0}")]
91. 91 Io(#[from] std::io::Error),
92. 92 #[error("json error: {0}")]
93. 93 Json(#[from] serde_json::Error),
94. 94 #[error("schema mismatch: expected {expected}, found {found}")]
95. 95 SchemaMismatch { expected: u32, found: u32 },
96. 96}
97. 97
98. 98// ---------------------------------------------------------------------------
99. 99// Store handle (thread-safe, cheap to clone)
100. 100// ---------------------------------------------------------------------------
101. 101
102. 102#[derive(Clone)]
103. 103pub struct Store {
104. 104 inner: Arc<StoreInner>,
105. 105}
106. 106
107. 107struct StoreInner {
108. 108 db_path: PathBuf,
109. 109 conn: Mutex<Connection>,
110. 110}
111. 111
112. 112impl Store {
113. 113 /// Open or create the FTS5 index at `<sessions_home>/store.db`.
114. 114 /// WAL mode is enabled automatically. Idempotent.
115. 115 pub fn open(sessions_home: &Path) -> Result<Self, StoreError> {
116. 116 std::fs::create_dir_all(sessions_home)?;
117. 117 let db_path = sessions_home.join(DB_NAME);
118. 118 let conn = Connection::open(&db_path)?;
119. 119 conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;")?;
120. 120 Self::ensure_schema(&conn)?;
121. 121 Ok(Store {
122. 122 inner: Arc::new(StoreInner {
123. 123 db_path,
124. 124 conn: Mutex::new(conn),
125. 125 }),
126. 126 })
127. 127 }
128. 128
129. 129 /// Path to the database file.
130. 130 pub fn db_path(&self) -> &Path {
131. 131 &self.inner.db_path
132. 132 }
133. 133
134. 134 /// Rebuild the entire index from JSONL files under `sessions_home`.
135. 135 /// This drops all existing data and re-imports — safe because the
136. 136 /// index is fully derivable from JSONL.
137. 137 pub fn rebuild(&self, sessions_home: &Path) -> Result<RebuildStats, StoreError> {
138. 138 let conn = self.inner.conn.lock().unwrap_or_else(|p| p.into_inner());
139. 139 conn.execute_batch("DELETE FROM entries; DELETE FROM entries_fts;")?;
140. 140 let stats = self.import_all(&conn, sessions_home)?;
141. 141 conn.execute(
142. 142 "INSERT OR REPLACE INTO meta(key, value) VALUES ('version', ?1)",
143. 143 [SCHEMA_VERSION.to_string()],
144. 144 )?;
145. 145 Ok(stats)
146. 146 }
147. 147
148. 148 /// Import a single JSONL file into the index. Idempotent (skips
149. 149 /// already-indexed entry IDs).
150. 150 pub fn import_session(
151. 151 &self,
152. 152 sessions_home: &Path,
153. 153 jsonl_path: &Path,
154. 154 ) -> Result<ImportStats, StoreError> {
155. 155 let conn = self.inner.conn.lock().unwrap_or_else(|p| p.into_inner());
156. 156 self.import_file(&conn, sessions_home, jsonl_path)
157. 157 }
158. 158
159. 159 /// Append a single entry (real-time update path). Called from
160. 160 /// `SessionLog::append` when the store is wired in.
161. 161 pub fn append_entry(
162. 162 &self,
163. 163 session_id: &str,
164. 164 entry: &vak_session::Entry,
165. 165 ) -> Result<(), StoreError> {
166. 166 let conn = self.inner.conn.lock().unwrap_or_else(|p| p.into_inner());
167. 167 if let Some(meta) = self.extract_meta(session_id, entry) {
168. 168 Self::insert_meta(&conn, &meta)?;
169. 169 }
170. 170 Ok(())
171. 171 }
172. 172
173. 173 fn conn(&self) -> std::sync::MutexGuard<'_, Connection> {
174. 174 self.inner.conn.lock().unwrap_or_else(|p| p.into_inner())
175. 175 }
176. 176}
177. 177
178. 178#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
179. 179pub struct RebuildStats {
180. 180 pub files_scanned: usize,
181. 181 pub entries_indexed: usize,
182. 182 pub fts_rows: usize,
183. 183}
184. 184
185. 185#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
186. 186pub struct ImportStats {
187. 187 pub entries_indexed: usize,
188. 188 pub fts_rows: usize,
189. 189 pub skipped: usize,
190. 190}
191. 191
192. 192// ---------------------------------------------------------------------------
193. 193// Schema
194. 194// ---------------------------------------------------------------------------
195. 195
196. 196impl Store {
197. 197 fn ensure_schema(conn: &Connection) -> Result<(), StoreError> {
198. 198 conn.execute_batch(
199. 199 "CREATE TABLE IF NOT EXISTS meta (
200. 200 key TEXT PRIMARY KEY,
201. 201 value TEXT NOT NULL
202. 202 );
203. 203
204. 204 CREATE TABLE IF NOT EXISTS entries (
205. 205 entry_id TEXT PRIMARY KEY,
206. 206 session_id TEXT NOT NULL,
207. 207 project_hash TEXT NOT NULL,
208. 208 parent_id TEXT,
209. 209 ts TEXT NOT NULL,
210. 210 kind TEXT NOT NULL,
211. 211 role TEXT,
212. 212 provider TEXT,
213. 213 model TEXT,
214. 214 tool_name TEXT,
215. 215 content_text TEXT NOT NULL DEFAULT '',
216. 216 is_error INTEGER NOT NULL DEFAULT 0
217. 217 );
218. 218
219. 219 CREATE INDEX IF NOT EXISTS idx_entries_session
220. 220 ON entries(session_id);
221. 221 CREATE INDEX IF NOT EXISTS idx_entries_project
222. 222 ON entries(project_hash);
223. 223 CREATE INDEX IF NOT EXISTS idx_entries_kind
224. 224 ON entries(kind);
225. 225 CREATE INDEX IF NOT EXISTS idx_entries_ts
226. 226 ON entries(ts);
227. 227 CREATE INDEX IF NOT EXISTS idx_entries_role
228. 228 ON entries(role);
229. 229
230. 230 CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(
231. 231 entry_id UNINDEXED,
232. 232 session_id UNINDEXED,
233. 233 project_hash UNINDEXED,
234. 234 ts UNINDEXED,
235. 235 kind UNINDEXED,
236. 236 role UNINDEXED,
237. 237 content,
238. 238 tokenize='porter unicode61'
239. 239 );",
240. 240 )?;
241. 241 Ok(())
242. 242 }
243. 243}
244. 244
245. 245// ---------------------------------------------------------------------------
246. 246// Extraction logic: JSONL Entry → IndexedEntry
247. 247// ---------------------------------------------------------------------------
248. 248
249. 249impl Store {
250. 250 /// Extract search metadata from a single JSONL entry.
251. 251 fn extract_meta(&self, session_id: &str, entry: &vak_session::Entry) -> Option<IndexedEntry> {
252. 252 use vak_session::EntryPayload;
253. 253
254. 254 let kind = match &entry.payload {
255. 255 EntryPayload::Header(_) => EntryKind::Header,
256. 256 EntryPayload::Message(_) => EntryKind::Message,
257. 257 EntryPayload::Compaction(_) => EntryKind::Compaction,
258. 258 EntryPayload::Receipt(_) => EntryKind::Receipt,
259. 259 EntryPayload::Goal(_) => EntryKind::Goal,
260. 260 EntryPayload::GoalUpdate(_) => EntryKind::Goal,
261. 261 EntryPayload::Activity(_) => EntryKind::Activity,
262. 262 EntryPayload::Work(_) => EntryKind::Work,
263. 263 EntryPayload::Intent(_) => EntryKind::Intent,
264. 264 // A Presentation entry is display-channel/model-history
265. 265 // data (docs/design/68-context-engine.md §10), not free text to
266. 266 // full-text index today; its own TurnIndex/recall search
267. 267 // (design §3) is separate future work. A TurnCard is derived,
268. 268 // never-model-visible audit data with its own in-memory BM25
269. 269 // index (`TurnIndex::search`) — not this store's concern either.
270. 270 // An evidence body repeats a tool result the Message entry
271. 271 // already indexes the window of; `recall` reaches the rest.
272. 272 EntryPayload::TurnCapabilitiesBound(_)
273. 273 | EntryPayload::TurnCapabilitiesRef(_)
274. 274 | EntryPayload::ChildRun { .. }
275. 275 | EntryPayload::Presentation(_)
276. 276 | EntryPayload::TurnCard(_)
277. 277 | EntryPayload::EvidenceBody(_) => return None,
278. 278 };
279. 279
280. 280 match &entry.payload {
281. 281 EntryPayload::Message(record) => {
282. 282 // A runtime-authored nudge is indexed under its own role so
283. 283 // it is never returned as something the user said.
284. 284 let role = match record.message.role {
285. 285 _ if record.control_kind().is_some() => "control",
286. 286 vak_llm::Role::User => "user",
287. 287 vak_llm::Role::Assistant => "assistant",
288. 288 };
289. 289 let (text, tool_name, is_error) = extract_message_text(&record.message.content);
290. 290 let model = record.meta.as_ref().and_then(|m| m.model.clone());
291. 291 Some(IndexedEntry {
292. 292 entry_id: entry.id.clone(),
293. 293 session_id: session_id.to_string(),
294. 294 project_hash: String::new(),
295. 295 parent_id: entry.parent_id.clone(),
296. 296 ts: entry.ts.to_rfc3339(),
297. 297 kind,
298. 298 role: Some(role.to_string()),
299. 299 provider: None,
300. 300 model,
301. 301 tool_name,
302. 302 content_text: text,
303. 303 is_error,
304. 304 })
305. 305 }
306. 306 EntryPayload::Header(header) => Some(IndexedEntry {
307. 307 entry_id: entry.id.clone(),
308. 308 session_id: session_id.to_string(),
309. 309 project_hash: String::new(),
310. 310 parent_id: entry.parent_id.clone(),
311. 311 ts: entry.ts.to_rfc3339(),
312. 312 kind,
313. 313 role: None,
314. 314 provider: Some(header.contract.provider.clone()),
315. 315 model: Some(header.contract.model.clone()),
316. 316 tool_name: None,
317. 317 content_text: String::new(),
318. 318 is_error: false,
319. 319 }),
320. 320 EntryPayload::Compaction(c) => Some(IndexedEntry {
321. 321 entry_id: entry.id.clone(),
322. 322 session_id: session_id.to_string(),
323. 323 project_hash: String::new(),
324. 324 parent_id: entry.parent_id.clone(),
325. 325 ts: entry.ts.to_rfc3339(),
326. 326 kind,
327. 327 role: None,
328. 328 provider: None,
329. 329 model: None,
330. 330 tool_name: None,
331. 331 content_text: c.summary.clone(),
332. 332 is_error: false,
333. 333 }),
334. 334 EntryPayload::Receipt(r) => Some(IndexedEntry {
335. 335 entry_id: entry.id.clone(),
336. 336 session_id: session_id.to_string(),
337. 337 project_hash: String::new(),
338. 338 parent_id: entry.parent_id.clone(),
339. 339 ts: entry.ts.to_rfc3339(),
340. 340 kind,
341. 341 role: None,
342. 342 provider: Some(r.provider.clone()),
343. 343 model: Some(r.model.clone()),
344. 344 tool_name: None,
345. 345 content_text: String::new(),
346. 346 is_error: false,
347. 347 }),
348. 348 EntryPayload::Goal(g) => Some(IndexedEntry {
349. 349 entry_id: entry.id.clone(),
350. 350 session_id: session_id.to_string(),
351. 351 project_hash: String::new(),
352. 352 parent_id: entry.parent_id.clone(),
353. 353 ts: entry.ts.to_rfc3339(),
354. 354 kind,
355. 355 role: None,
356. 356 provider: None,
357. 357 model: None,
358. 358 tool_name: None,
359. 359 content_text: format!("{} {}", g.objective, g.criteria.join(" ")),
360. 360 is_error: false,
361. 361 }),
362. 362 EntryPayload::GoalUpdate(update) => Some(IndexedEntry {
363. 363 entry_id: entry.id.clone(),
364. 364 session_id: session_id.to_string(),
365. 365 project_hash: String::new(),
366. 366 parent_id: entry.parent_id.clone(),
367. 367 ts: entry.ts.to_rfc3339(),
368. 368 kind,
369. 369 role: Some("system".into()),
370. 370 provider: None,
371. 371 model: None,
372. 372 tool_name: None,
373. 373 content_text: format!("{:?} {}", update.relation, update.request),
374. 374 is_error: false,
375. 375 }),
376. 376 EntryPayload::Activity(activity) => Some(IndexedEntry {
377. 377 entry_id: entry.id.clone(),
378. 378 session_id: session_id.to_string(),
379. 379 project_hash: String::new(),
380. 380 parent_id: entry.parent_id.clone(),
381. 381 ts: entry.ts.to_rfc3339(),
382. 382 kind,
383. 383 role: Some("system".into()),
384. 384 provider: None,
385. 385 model: None,
386. 386 tool_name: activity.data.get("tool").cloned(),
387. 387 content_text: format!(
388. 388 "{} {}",
389. 389 activity.label,
390. 390 activity.detail.as_deref().unwrap_or_default()
391. 391 ),
392. 392 is_error: matches!(
393. 393 activity.status,
394. 394 vak_session::ActivityStatus::Failed | vak_session::ActivityStatus::Denied
395. 395 ),
396. 396 }),
397. 397 EntryPayload::Work(work) => Some(IndexedEntry {
398. 398 entry_id: entry.id.clone(),
399. 399 session_id: session_id.to_string(),
400. 400 project_hash: String::new(),
401. 401 parent_id: entry.parent_id.clone(),
402. 402 ts: entry.ts.to_rfc3339(),
403. 403 kind,
404. 404 role: Some("system".into()),
405. 405 provider: None,
406. 406 model: None,
407. 407 tool_name: None,
408. 408 content_text: serde_json::to_string(&work.kind).unwrap_or_default(),
409. 409 is_error: false,
410. 410 }),
411. 411 // Indexed on the reading rather than the note, so "every
412. 412 // irreversible thing this agent did in March" is a search rather
413. 413 // than a ledger crawl. That query is the whole point of recording
414. 414 // the axes next to the decision.
415. 415 EntryPayload::Intent(record) => Some(IndexedEntry {
416. 416 entry_id: entry.id.clone(),
417. 417 session_id: session_id.to_string(),
418. 418 project_hash: String::new(),
419. 419 parent_id: entry.parent_id.clone(),
420. 420 ts: entry.ts.to_rfc3339(),
421. 421 kind,
422. 422 role: Some("system".into()),
423. 423 provider: None,
424. 424 model: record.provenance.model.clone(),
425. 425 tool_name: None,
426. 426 content_text: format!(
427. 427 "{} {} {} {} {} {} {}",
428. 428 record.reading.act.as_str(),
429. 429 record.reading.horizon.as_str(),
430. 430 record.reading.stakes.as_str(),
431. 431 record.reading.evidence.as_str(),
432. 432 record.reading.attendance.as_str(),
433. 433 record.provenance.tier.as_str(),
434. 434 record.model_visible.as_deref().unwrap_or_default()
435. 435 ),
436. 436 is_error: false,
437. 437 }),
438. 438 EntryPayload::TurnCapabilitiesBound(_)
439. 439 | EntryPayload::TurnCapabilitiesRef(_)
440. 440 | EntryPayload::ChildRun { .. }
441. 441 | EntryPayload::Presentation(_)
442. 442 | EntryPayload::TurnCard(_)
443. 443 | EntryPayload::EvidenceBody(_) => None,
444. 444 }
445. 445 }
446. 446
447. 447 fn insert_meta(conn: &Connection, meta: &IndexedEntry) -> Result<(), StoreError> {
448. 448 conn.execute(
449. 449 "INSERT OR IGNORE INTO entries
450. 450 (entry_id, session_id, project_hash, parent_id, ts, kind, role,
451. 451 provider, model, tool_name, content_text, is_error)
452. 452 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)",
453. 453 rusqlite::params![
454. 454 meta.entry_id,
455. 455 meta.session_id,
456. 456 meta.project_hash,
457. 457 meta.parent_id,
458. 458 meta.ts,
459. 459 meta.kind.as_str(),
460. 460 meta.role,
461. 461 meta.provider,
462. 462 meta.model,
463. 463 meta.tool_name,
464. 464 meta.content_text,
465. 465 meta.is_error as i32,
466. 466 ],
467. 467 )?;
468. 468 // FTS row — only if there is searchable content.
469. 469 if !meta.content_text.trim().is_empty() {
470. 470 conn.execute(
471. 471 "INSERT INTO entries_fts(entry_id, session_id, project_hash, ts, kind, role, content)
472. 472 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
473. 473 rusqlite::params![
474. 474 meta.entry_id,
475. 475 meta.session_id,
476. 476 meta.project_hash,
477. 477 meta.ts,
478. 478 meta.kind.as_str(),
479. 479 meta.role.as_deref().unwrap_or(""),
480. 480 meta.content_text,
481. 481 ],
482. 482 )?;
483. 483 }
484. 484 Ok(())
485. 485 }
486. 486}
487. 487
488. 488/// Extract searchable text and metadata from message content blocks.
489. 489/// Returns (text, tool_name, is_error).
490. 490fn extract_message_text(
491. 491 content: &[vak_llm::types::ContentBlock],
492. 492) -> (String, Option<String>, bool) {
493. 493 use vak_llm::types::ContentBlock;
494. 494
495. 495 let mut text_parts = Vec::new();
496. 496 let mut tool_name: Option<String> = None;
497. 497 let mut is_error = false;
498. 498
499. 499 for block in content {
500. 500 match block {
501. 501 ContentBlock::Text { text } => {
502. 502 text_parts.push(text.clone());
503. 503 }
504. 504 ContentBlock::Thinking { text, .. } => {
505. 505 text_parts.push(format!("[thinking] {text}"));
506. 506 }
507. 507 ContentBlock::ToolUse { name, input, .. } => {
508. 508 tool_name = Some(name.clone());
509. 509 if let Some(cmd) = input.get("command").and_then(|v| v.as_str()) {
510. 510 text_parts.push(format!("[tool:{name}] {cmd}"));
511. 511 } else {
512. 512 text_parts.push(format!("[tool:{name}]"));
513. 513 }
514. 514 }
515. 515 ContentBlock::ToolResult {
516. 516 content,
517. 517 is_error: err,
518. 518 ..
519. 519 } => {
520. 520 is_error = *err;
521. 521 if !content.trim().is_empty() {
522. 522 text_parts.push(format!("[result] {content}"));
523. 523 }
524. 524 }
525. 525 ContentBlock::Image { .. } => {}
526. 526 ContentBlock::Provider { .. } => {}
527. 527 }
528. 528 }
529. 529 (text_parts.join("\n"), tool_name, is_error)
530. 530}
531. 531
532. 532// ---------------------------------------------------------------------------
533. 533// Tests
534. 534// ---------------------------------------------------------------------------
535. 535
536. 536#[cfg(test)]
537. 537mod tests {
538. 538 #![allow(clippy::unwrap_used, clippy::expect_used)]
539. 539
540. 540 use super::*;
541. 541 use std::io::Write;
542. 542 use vak_llm::types::{ContentBlock, Message};
543. 543 use vak_session::log::SessionPath;
544. 544 use vak_session::types::{Entry, EntryPayload, FrozenContract, MessageRecord, SessionHeader};
545. 545
546. 546 fn test_header(id: &str) -> SessionHeader {
547. 547 SessionHeader {
548. 548 agent: None,
549. 549 session_id: id.to_string(),
550. 550 created_at: chrono::Utc::now(),
551. 551 cwd: std::env::current_dir().unwrap(),
552. 552 parent_session_id: None,
553. 553 contract_id: None,
554. 554 work_item_id: None,
555. 555 conversation: None,
556. 556 contract: FrozenContract {
557. 557 app_version: "test".into(),
558. 558 provider: "openai".into(),
559. 559 model: "gpt-4o".into(),
560. 560 route_ladder: vec![],
561. 561 route_objective: String::new(),
562. 562 route_annotations: vec![],
563. 563 system_prompt: String::new(),
564. 564 permission_mode: "workspace-write".into(),
565. 565 capabilities: Vec::new(),
566. 566 prompt_layers: Vec::new(),
567. 567 },
568. 568 }
569. 569 }
570. 570
571. 571 fn user_msg(text: &str) -> MessageRecord {
572. 572 MessageRecord {
573. 573 message: Message {
574. 574 role: vak_llm::Role::User,
575. 575 content: vec![ContentBlock::text(text)],
576. 576 },
577. 577 meta: None,
578. 578 }
579. 579 }
580. 580
581. 581 fn assistant_msg(text: &str) -> MessageRecord {
582. 582 MessageRecord {
583. 583 message: Message {
584. 584 role: vak_llm::Role::Assistant,
585. 585 content: vec![ContentBlock::text(text)],
586. 586 },
587. 587 meta: None,
588. 588 }
589. 589 }
590. 590
591. 591 fn write_session(home: &Path, cwd: &Path, id: &str, msgs: &[MessageRecord]) {
592. 592 let path = SessionPath::new_session_file(home, cwd, id);
593. 593 std::fs::create_dir_all(path.parent().unwrap()).unwrap();
594. 594 let file = std::fs::File::create(&path).unwrap();
595. 595 let mut w = std::io::BufWriter::new(file);
596. 596 let header = Entry::new(None, EntryPayload::Header(test_header(id)));
597. 597 serde_json::to_writer(&mut w, &header).unwrap();
598. 598 w.write_all(b"\n").unwrap();
599. 599 let mut parent = Some(header.id.clone());
600. 600 for m in msgs {
601. 601 let entry = Entry {
602. 602 prev_hash: None,
603. 603 id: uuid::Uuid::now_v7().to_string(),
604. 604 parent_id: parent.clone(),
605. 605 ts: chrono::Utc::now(),
606. 606 payload: EntryPayload::Message(m.clone()),
607. 607 };
608. 608 parent = Some(entry.id.clone());
609. 609 serde_json::to_writer(&mut w, &entry).unwrap();
610. 610 w.write_all(b"\n").unwrap();
611. 611 }
612. 612 w.flush().unwrap();
613. 613 }
614. 614
615. 615 #[test]
616. 616 fn open_creates_db_and_schema() {
617. 617 let dir = tempfile::tempdir().unwrap();
618. 618 let store = Store::open(dir.path()).unwrap();
619. 619 assert!(store.db_path().exists());
620. 620 // Second open is idempotent.
621. 621 let store2 = Store::open(dir.path()).unwrap();
622. 622 assert_eq!(store.db_path(), store2.db_path());
623. 623 }
624. 624
625. 625 #[test]
626. 626 fn rebuild_indexes_entries_and_fts() {
627. 627 let dir = tempfile::tempdir().unwrap();
628. 628 let home = dir.path();
629. 629 let cwd = dir.path();
630. 630 write_session(
631. 631 home,
632. 632 cwd,
633. 633 "sess-001",
634. 634 &[
635. 635 user_msg("the deploy pipeline handles rollbacks gracefully"),
636. 636 assistant_msg("confirmed — rollback windows pause before deploy"),
637. 637 ],
638. 638 );
639. 639 write_session(
640. 640 home,
641. 641 cwd,
642. 642 "sess-002",
643. 643 &[user_msg("pizza toppings are irrelevant to this query")],
644. 644 );
645. 645
646. 646 let store = Store::open(home).unwrap();
647. 647 let stats = store.rebuild(home).unwrap();
648. 648 assert_eq!(stats.files_scanned, 2);
649. 649 // sess-001: 1 header + 2 msgs, sess-002: 1 header + 1 msg = 5 entries
650. 650 assert_eq!(stats.entries_indexed, 5);
651. 651 // 3 messages with text → 3 FTS rows
652. 652 assert_eq!(stats.fts_rows, 3);
653. 653 }
654. 654
655. 655 #[test]
656. 656 fn import_skips_already_indexed() {
657. 657 let dir = tempfile::tempdir().unwrap();
658. 658 let home = dir.path();
659. 659 let cwd = dir.path();
660. 660 write_session(
661. 661 home,
662. 662 cwd,
663. 663 "sess-aaa",
664. 664 &[user_msg("unique search term zanzibar")],
665. 665 );
666. 666
667. 667 let store = Store::open(home).unwrap();
668. 668 let s1 = store
669. 669 .import_session(home, &SessionPath::new_session_file(home, cwd, "sess-aaa"))
670. 670 .unwrap();
671. 671 assert_eq!(s1.entries_indexed, 2); // header + message
672. 672 let s2 = store
673. 673 .import_session(home, &SessionPath::new_session_file(home, cwd, "sess-aaa"))
674. 674 .unwrap();
675. 675 assert_eq!(s2.skipped, 2, "second import skips all");
676. 676 }
677. 677
678. 678 #[test]
679. 679 fn extract_message_text_captures_tools() {
680. 680 use vak_llm::types::ContentBlock;
681. 681
682. 682 let blocks = vec![
683. 683 ContentBlock::text("look at this"),
684. 684 ContentBlock::ToolUse {
685. 685 id: "tc-1".into(),
686. 686 name: "bash".into(),
687. 687 input: serde_json::json!({"command": "cargo test"}),
688. 688 },
689. 689 ContentBlock::ToolResult {
690. 690 tool_use_id: "tc-1".into(),
691. 691 content: "2 passed".into(),
692. 692 is_error: false,
693. 693 },
694. 694 ];
695. 695 let (text, tool, is_err) = extract_message_text(&blocks);
696. 696 assert!(text.contains("look at this"));
697. 697 assert!(text.contains("[tool:bash] cargo test"));
698. 698 assert!(text.contains("[result] 2 passed"));
699. 699 assert_eq!(tool.as_deref(), Some("bash"));
700. 700 assert!(!is_err);
701. 701 }
702. 702}
703. 703