@geekbeer/minion 2.70.2 → 2.73.0

package/core/stores/chat-store.js

@@ -1,113 +1,175 @@
 /**
- * Chat Session Store
- * Persists the active chat session (session_id + messages) to local JSON file.
- * One active session per minion. Claude CLI manages conversation context via --resume.
+ * Chat Session Store (SQLite)
+ * Persists chat sessions and messages.
+ * Supports multiple sessions: one active + archived past sessions.
+ * Claude CLI manages conversation context via --resume.
  */
 
-const fs = require('fs').promises
-const path = require('path')
-
-const { config } = require('../config')
-const { DATA_DIR } = require('../lib/platform')
+const { getDb } = require('../db')
 
 const MAX_MESSAGES = 100
 
 /**
- * Get chat session file path
- * Uses DATA_DIR if available (platform-aware), otherwise home dir
+ * Load the active (most recent) chat session
+ * @returns {object|null} Session object or null if none exists
  */
-function getFilePath() {
-  try {
-    require('fs').accessSync(DATA_DIR)
-    return path.join(DATA_DIR, 'chat-session.json')
-  } catch {
-    return path.join(config.HOME_DIR, 'chat-session.json')
+function load() {
+  const db = getDb()
+  const session = db.prepare(
+    'SELECT * FROM chat_sessions ORDER BY updated_at DESC LIMIT 1'
+  ).get()
+  if (!session) return null
+
+  const messages = db.prepare(
+    'SELECT role, content, timestamp FROM chat_messages WHERE session_id = ? ORDER BY id'
+  ).all(session.session_id)
+
+  return {
+    session_id: session.session_id,
+    messages,
+    turn_count: session.turn_count,
+    created_at: session.created_at,
+    updated_at: session.updated_at,
   }
 }
 
-const SESSION_FILE = getFilePath()
-
 /**
- * Load the active chat session
- * @returns {Promise<object|null>} Session object or null if none exists
+ * Load a specific session by ID
+ * @param {string} sessionId
+ * @returns {object|null}
  */
-async function load() {
-  try {
-    const data = await fs.readFile(SESSION_FILE, 'utf-8')
-    return JSON.parse(data)
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return null
-    }
-    console.error(`[ChatStore] Failed to load session: ${err.message}`)
-    return null
+function loadById(sessionId) {
+  const db = getDb()
+  const session = db.prepare('SELECT * FROM chat_sessions WHERE session_id = ?').get(sessionId)
+  if (!session) return null
+
+  const messages = db.prepare(
+    'SELECT role, content, timestamp FROM chat_messages WHERE session_id = ? ORDER BY id'
+  ).all(session.session_id)
+
+  return {
+    session_id: session.session_id,
+    messages,
+    turn_count: session.turn_count,
+    created_at: session.created_at,
+    updated_at: session.updated_at,
   }
 }
 
 /**
- * Save the active chat session
+ * List all sessions (metadata only, no messages)
+ * @param {number} limit
+ * @returns {Array<{ session_id, turn_count, message_count, created_at, updated_at }>}
+ */
+function listSessions(limit = 50) {
+  const db = getDb()
+  return db.prepare(`
+    SELECT
+      s.session_id,
+      s.turn_count,
+      s.created_at,
+      s.updated_at,
+      (SELECT COUNT(*) FROM chat_messages WHERE session_id = s.session_id) as message_count
+    FROM chat_sessions s
+    ORDER BY s.updated_at DESC
+    LIMIT ?
+  `).all(limit)
+}
+
+/**
+ * Save the active chat session (full replace of this session only)
  * @param {object} session - Session object
  */
-async function save(session) {
-  try {
-    await fs.writeFile(SESSION_FILE, JSON.stringify(session, null, 2), 'utf-8')
-  } catch (err) {
-    console.error(`[ChatStore] Failed to save session: ${err.message}`)
-  }
+function save(session) {
+  const db = getDb()
+  const tx = db.transaction(() => {
+    // Remove only this session (preserve others)
+    db.prepare('DELETE FROM chat_sessions WHERE session_id = ?').run(session.session_id)
+
+    // Insert session
+    db.prepare(
+      'INSERT INTO chat_sessions (session_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?)'
+    ).run(session.session_id, session.turn_count || 0, session.created_at, session.updated_at)
+
+    // Insert messages
+    const insertMsg = db.prepare(
+      'INSERT INTO chat_messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)'
+    )
+    for (const msg of (session.messages || [])) {
+      insertMsg.run(session.session_id, msg.role, msg.content, msg.timestamp)
+    }
+  })
+  tx()
 }
 
 /**
- * Add a message to the active session
- * Creates a new session if none exists
+ * Add a message to the active session.
+ * Creates a new session if none exists or session_id changed.
+ * Past sessions are preserved (not deleted).
  * @param {string} sessionId - Claude CLI session ID
  * @param {{ role: string, content: string }} msg - Message to add
- * @param {number} [turnCount] - Optional turn count to update session with
+ * @param {number} [turnCount] - Optional turn count to add
  */
-async function addMessage(sessionId, msg, turnCount) {
-  let session = await load()
-
-  // If session_id changed, start a new session
-  if (!session || session.session_id !== sessionId) {
-    session = {
-      session_id: sessionId,
-      messages: [],
-      turn_count: 0,
-      created_at: Date.now(),
-      updated_at: Date.now(),
-    }
+function addMessage(sessionId, msg, turnCount) {
+  const db = getDb()
+  const existing = db.prepare('SELECT * FROM chat_sessions WHERE session_id = ?').get(sessionId)
+
+  // If session doesn't exist, create a new one (past sessions remain in DB)
+  if (!existing) {
+    const now = Date.now()
+    db.prepare(
+      'INSERT INTO chat_sessions (session_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?)'
+    ).run(sessionId, 0, now, now)
   }
 
-  session.messages.push({
-    role: msg.role,
-    content: msg.content,
-    timestamp: Date.now(),
-  })
-  session.updated_at = Date.now()
+  // Insert message
+  db.prepare(
+    'INSERT INTO chat_messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)'
+  ).run(sessionId, msg.role, msg.content, Date.now())
 
-  // Update turn count if provided
-  if (typeof turnCount === 'number' && turnCount > 0) {
-    session.turn_count = (session.turn_count || 0) + turnCount
-  }
+  // Update session metadata
+  const newTurnCount = (turnCount && turnCount > 0) ? turnCount : 0
+  db.prepare(`
+    UPDATE chat_sessions
+    SET updated_at = ?,
+        turn_count = turn_count + ?
+    WHERE session_id = ?
+  `).run(Date.now(), newTurnCount, sessionId)
 
-  // Prune old messages
-  if (session.messages.length > MAX_MESSAGES) {
-    session.messages = session.messages.slice(-MAX_MESSAGES)
+  // Prune old messages for this session (keep only MAX_MESSAGES most recent)
+  const count = db.prepare('SELECT COUNT(*) as cnt FROM chat_messages WHERE session_id = ?').get(sessionId).cnt
+  if (count > MAX_MESSAGES) {
+    db.prepare(`
+      DELETE FROM chat_messages WHERE id IN (
+        SELECT id FROM chat_messages WHERE session_id = ?
+        ORDER BY id ASC LIMIT ?
+      )
+    `).run(sessionId, count - MAX_MESSAGES)
   }
-
-  await save(session)
 }
 
 /**
- * Clear the active session
+ * Clear the active session (remove from DB).
+ * This deletes only the most recent session.
+ * For reset flows, use clearActive() which preserves the session in history.
  */
-async function clear() {
-  try {
-    await fs.unlink(SESSION_FILE)
-  } catch (err) {
-    if (err.code !== 'ENOENT') {
-      console.error(`[ChatStore] Failed to clear session: ${err.message}`)
-    }
+function clear() {
+  const db = getDb()
+  const active = db.prepare('SELECT session_id FROM chat_sessions ORDER BY updated_at DESC LIMIT 1').get()
+  if (active) {
+    db.prepare('DELETE FROM chat_sessions WHERE session_id = ?').run(active.session_id)
   }
 }
 
-module.exports = { load, save, addMessage, clear }
+/**
+ * Delete a specific session by ID
+ * @param {string} sessionId
+ * @returns {boolean}
+ */
+function deleteSession(sessionId) {
+  const db = getDb()
+  const result = db.prepare('DELETE FROM chat_sessions WHERE session_id = ?').run(sessionId)
+  return result.changes > 0
+}
+
+module.exports = { load, loadById, listSessions, save, addMessage, clear, deleteSession }

package/core/stores/daily-log-store.js

@@ -1,38 +1,11 @@
 /**
- * Daily Log Store
- * Stores daily conversation summaries as markdown files.
- * One file per day: $DATA_DIR/daily-logs/YYYY-MM-DD.md
- *
- * These logs serve as short-term memory (recent days),
- * bridging working memory (chat session) and long-term memory (memory-store).
+ * Daily Log Store (SQLite)
+ * Stores daily conversation summaries.
+ * One entry per day, keyed by YYYY-MM-DD date string.
+ * Supports full-text search via FTS5.
  */
 
-const fs = require('fs').promises
-const path = require('path')
-
-const { config } = require('../config')
-const { DATA_DIR } = require('../lib/platform')
-
-/**
- * Resolve daily logs directory path
- */
-function getLogsDir() {
-  try {
-    require('fs').accessSync(DATA_DIR)
-    return path.join(DATA_DIR, 'daily-logs')
-  } catch {
-    return path.join(config.HOME_DIR, 'daily-logs')
-  }
-}
-
-const LOGS_DIR = getLogsDir()
-
-/**
- * Ensure the daily-logs directory exists
- */
-async function ensureDir() {
-  await fs.mkdir(LOGS_DIR, { recursive: true })
-}
+const { getDb } = require('../db')
 
 /**
  * Validate date string format (YYYY-MM-DD)
@@ -42,114 +15,122 @@ function isValidDate(date) {
 }
 
 /**
- * List all daily logs with date, file size, and timestamps.
- * @returns {Promise<Array<{ date: string, size: number, created_at: string, updated_at: string }>>} Sorted descending by date
+ * List all daily logs with date, content size, and timestamps.
+ * @returns {Array<{ date, size, created_at, updated_at }>} Sorted descending by date
  */
-async function listLogs() {
-  await ensureDir()
-  let files
-  try {
-    files = await fs.readdir(LOGS_DIR)
-  } catch {
-    return []
-  }
-
-  const logs = []
-  for (const file of files) {
-    if (!file.endsWith('.md')) continue
-    const date = file.replace('.md', '')
-    if (!isValidDate(date)) continue
-    try {
-      const stat = await fs.stat(path.join(LOGS_DIR, file))
-      logs.push({
-        date,
-        size: stat.size,
-        created_at: stat.birthtime.toISOString(),
-        updated_at: stat.mtime.toISOString(),
-      })
-    } catch {
-      // Skip unreadable
-    }
-  }
-
-  // Sort by date descending (most recent first)
-  logs.sort((a, b) => b.date.localeCompare(a.date))
-  return logs
+function listLogs() {
+  const db = getDb()
+  const rows = db.prepare(`
+    SELECT date, length(content) as size, created_at, updated_at
+    FROM daily_logs
+    ORDER BY date DESC
+  `).all()
+  return rows
 }
 
 /**
  * Load a specific day's log.
  * @param {string} date - YYYY-MM-DD format
- * @returns {Promise<string|null>} Log content or null
+ * @returns {string|null} Log content or null
  */
-async function loadLog(date) {
+function loadLog(date) {
   if (!isValidDate(date)) return null
-  try {
-    return await fs.readFile(path.join(LOGS_DIR, `${date}.md`), 'utf-8')
-  } catch (err) {
-    if (err.code === 'ENOENT') return null
-    console.error(`[DailyLogStore] Failed to load log ${date}: ${err.message}`)
-    return null
-  }
+  const db = getDb()
+  const row = db.prepare('SELECT content FROM daily_logs WHERE date = ?').get(date)
+  return row ? row.content : null
 }
 
 /**
- * Save a daily log. Overwrites existing log for the same date.
+ * Save a daily log. Upserts (overwrites existing log for the same date).
  * @param {string} date - YYYY-MM-DD format
  * @param {string} content - Markdown content
  */
-async function saveLog(date, content) {
+function saveLog(date, content) {
   if (!isValidDate(date)) {
     throw new Error(`Invalid date format: ${date}. Expected YYYY-MM-DD.`)
   }
-  await ensureDir()
-  await fs.writeFile(path.join(LOGS_DIR, `${date}.md`), content, 'utf-8')
+  const db = getDb()
+  const now = new Date().toISOString()
+  const existing = db.prepare('SELECT date FROM daily_logs WHERE date = ?').get(date)
+
+  if (existing) {
+    db.prepare('UPDATE daily_logs SET content = ?, updated_at = ? WHERE date = ?').run(content, now, date)
+  } else {
+    db.prepare('INSERT INTO daily_logs (date, content, created_at, updated_at) VALUES (?, ?, ?, ?)').run(
+      date, content, now, now
+    )
+  }
 }
 
 /**
  * Delete a daily log.
  * @param {string} date - YYYY-MM-DD format
- * @returns {Promise<boolean>}
+ * @returns {boolean}
  */
-async function deleteLog(date) {
+function deleteLog(date) {
   if (!isValidDate(date)) return false
-  try {
-    await fs.unlink(path.join(LOGS_DIR, `${date}.md`))
-    return true
-  } catch (err) {
-    if (err.code === 'ENOENT') return false
-    console.error(`[DailyLogStore] Failed to delete log ${date}: ${err.message}`)
-    return false
-  }
+  const db = getDb()
+  const result = db.prepare('DELETE FROM daily_logs WHERE date = ?').run(date)
+  return result.changes > 0
 }
 
 /**
  * Get the most recent N days of logs.
  * @param {number} days - Number of recent days to fetch
- * @returns {Promise<Array<{ date: string, content: string }>>}
+ * @returns {Array<{ date, content }>}
  */
-async function getRecentLogs(days = 3) {
-  const all = await listLogs()
-  const recent = all.slice(0, days)
-
-  const results = []
-  for (const { date } of recent) {
-    const content = await loadLog(date)
-    if (content) {
-      results.push({ date, content })
-    }
+function getRecentLogs(days = 3) {
+  const db = getDb()
+  const rows = db.prepare('SELECT date, content FROM daily_logs ORDER BY date DESC LIMIT ?').all(days)
+  return rows
+}
+
+/**
+ * Search daily logs using FTS5 full-text search (trigram tokenizer).
+ * Falls back to LIKE for queries shorter than 3 characters (trigram minimum).
+ * @param {string} query - Search query
+ * @param {number} limit - Max results
+ * @returns {Array<{ date, content, created_at, updated_at }>}
+ */
+function searchLogs(query, limit = 20) {
+  const db = getDb()
+  const terms = query.split(/\s+/).filter(Boolean)
+  if (terms.length === 0) return []
+
+  const hasShortTerm = terms.some(t => [...t].length < 3)
+
+  if (hasShortTerm) {
+    const conditions = terms.map(() => 'content LIKE ?').join(' AND ')
+    const params = terms.map(t => `%${t}%`)
+    params.push(limit)
+    return db.prepare(`
+      SELECT date, content, created_at, updated_at
+      FROM daily_logs
+      WHERE ${conditions}
+      ORDER BY date DESC
+      LIMIT ?
+    `).all(...params)
   }
-  return results
+
+  const sanitized = terms.map(t => `"${t.replace(/"/g, '')}"`).join(' ')
+  return db.prepare(`
+    SELECT d.date, d.content, d.created_at, d.updated_at
+    FROM daily_logs d
+    JOIN daily_logs_fts f ON d.rowid = f.rowid
+    WHERE daily_logs_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?
+  `).all(sanitized, limit)
 }
 
 /**
  * Get a context snippet of recent daily logs for chat injection.
  * @param {number} days - Number of days to include
  * @param {number} maxChars - Maximum total characters
- * @returns {Promise<string>}
+ * @returns {string}
  */
-async function getContextSnippet(days = 3, maxChars = 1500) {
-  const logs = await getRecentLogs(days)
+function getContextSnippet(days = 3, maxChars = 1500) {
+  const logs = getRecentLogs(days)
   if (logs.length === 0) return ''
 
   const parts = []
@@ -161,7 +142,6 @@ async function getContextSnippet(days = 3, maxChars = 1500) {
     const section = `${header}\n${content}`
 
     if (totalLen + section.length > maxChars) {
-      // Add truncated version
       const remaining = maxChars - totalLen
       if (remaining > 50) {
         parts.push(section.substring(0, remaining) + '...')
@@ -176,12 +156,11 @@ async function getContextSnippet(days = 3, maxChars = 1500) {
 }
 
 module.exports = {
-  ensureDir,
   listLogs,
   loadLog,
   saveLog,
   deleteLog,
   getRecentLogs,
+  searchLogs,
   getContextSnippet,
-  LOGS_DIR,
 }