@geekbeer/minion 2.68.6 → 2.73.0

package/core/routes/memory.js

@@ -1,11 +1,11 @@
 /**
  * Memory management endpoints
  *
- * Provides CRUD for the minion's long-term memory entries.
- * Memory is stored as markdown files with YAML frontmatter in $DATA_DIR/memory/.
+ * Provides CRUD + search for the minion's long-term memory entries.
+ * Memory is stored in SQLite with FTS5 full-text search.
  *
  * Endpoints:
- *   GET    /api/memory          - List all memory entries
+ *   GET    /api/memory          - List all entries (or search with ?search=keyword)
  *   GET    /api/memory/:id      - Get a single entry
  *   POST   /api/memory          - Create a new entry
  *   PUT    /api/memory/:id      - Update an entry
@@ -21,14 +21,20 @@ const memoryStore = require('../stores/memory-store')
  */
 async function memoryRoutes(fastify) {
 
-  // GET /api/memory - List all entries
+  // GET /api/memory - List or search entries
   fastify.get('/api/memory', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
-    const entries = await memoryStore.listEntries()
+    const { search } = request.query || {}
+    if (search) {
+      const entries = memoryStore.searchEntries(search)
+      return { success: true, entries }
+    }
+
+    const entries = memoryStore.listEntries()
     return { success: true, entries }
   })
 
@@ -39,7 +45,7 @@ async function memoryRoutes(fastify) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const entry = await memoryStore.loadEntry(request.params.id)
+    const entry = memoryStore.loadEntry(request.params.id)
     if (!entry) {
       reply.code(404)
       return { success: false, error: 'Entry not found' }
@@ -61,7 +67,7 @@ async function memoryRoutes(fastify) {
       return { success: false, error: 'title and content are required' }
     }
 
-    const entry = await memoryStore.saveEntry({ title, category, content })
+    const entry = memoryStore.saveEntry({ title, category, content })
     console.log(`[Memory] Created entry: ${entry.id} (${entry.title})`)
     return { success: true, entry }
   })
@@ -73,14 +79,14 @@ async function memoryRoutes(fastify) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const existing = await memoryStore.loadEntry(request.params.id)
+    const existing = memoryStore.loadEntry(request.params.id)
     if (!existing) {
       reply.code(404)
       return { success: false, error: 'Entry not found' }
     }
 
     const { title, category, content } = request.body || {}
-    const entry = await memoryStore.saveEntry({
+    const entry = memoryStore.saveEntry({
       id: request.params.id,
       title: title || existing.title,
       category: category || existing.category,
@@ -98,7 +104,7 @@ async function memoryRoutes(fastify) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const deleted = await memoryStore.deleteEntry(request.params.id)
+    const deleted = memoryStore.deleteEntry(request.params.id)
     if (!deleted) {
       reply.code(404)
       return { success: false, error: 'Entry not found' }

package/core/routes/{help-threads.js → threads.js}

@@ -2,13 +2,13 @@
  * Project thread routes (local API on minion)
  *
  * Endpoints:
- * - GET  /api/help-threads         - List open threads in minion's projects
- * - POST /api/help-threads         - Create a new thread (proxied to HQ)
- * - GET  /api/help-threads/:id     - Get thread detail with messages
- * - POST /api/help-threads/:id/messages  - Post a message to a thread
- * - POST /api/help-threads/:id/resolve   - Resolve a thread
- * - POST /api/help-threads/:id/cancel    - Cancel a thread
- * - DELETE /api/help-threads/:id   - Permanently delete a thread (PM only)
+ * - GET  /api/threads         - List open threads in minion's projects
+ * - POST /api/threads         - Create a new thread (proxied to HQ)
+ * - GET  /api/threads/:id     - Get thread detail with messages
+ * - POST /api/threads/:id/messages  - Post a message to a thread
+ * - POST /api/threads/:id/resolve   - Resolve a thread
+ * - POST /api/threads/:id/cancel    - Cancel a thread
+ * - DELETE /api/threads/:id   - Permanently delete a thread (PM only)
  * - GET  /api/project-memories     - Search project memories
  * - POST /api/project-memories     - Create a project memory
  */
@@ -19,77 +19,77 @@ const api = require('../api')
 /**
  * @param {import('fastify').FastifyInstance} fastify
  */
-async function helpThreadRoutes(fastify) {
+async function threadRoutes(fastify) {
   // List open threads
-  fastify.get('/api/help-threads', async (request, reply) => {
+  fastify.get('/api/threads', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
     try {
-      const data = await api.getOpenHelpThreads()
+      const data = await api.getOpenThreads()
       return { success: true, threads: data.threads || [] }
     } catch (error) {
-      console.error(`[HelpThreads] List error: ${error.message}`)
+      console.error(`[Threads] List error: ${error.message}`)
       reply.code(500)
       return { success: false, error: error.message }
     }
   })
 
   // Create thread
-  fastify.post('/api/help-threads', async (request, reply) => {
+  fastify.post('/api/threads', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
     try {
-      const data = await api.createHelpThread(request.body)
+      const data = await api.createThread(request.body)
       return { success: true, thread: data.thread }
     } catch (error) {
-      console.error(`[HelpThreads] Create error: ${error.message}`)
+      console.error(`[Threads] Create error: ${error.message}`)
       reply.code(error.statusCode || 500)
       return { success: false, error: error.message }
     }
   })
 
   // Get thread detail
-  fastify.get('/api/help-threads/:id', async (request, reply) => {
+  fastify.get('/api/threads/:id', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
     try {
-      const data = await api.getHelpThread(request.params.id)
+      const data = await api.getThread(request.params.id)
       return { success: true, thread: data.thread, messages: data.messages }
     } catch (error) {
-      console.error(`[HelpThreads] Get error: ${error.message}`)
+      console.error(`[Threads] Get error: ${error.message}`)
       reply.code(error.statusCode || 500)
       return { success: false, error: error.message }
     }
   })
 
   // Post message
-  fastify.post('/api/help-threads/:id/messages', async (request, reply) => {
+  fastify.post('/api/threads/:id/messages', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
     try {
-      const data = await api.postHelpMessage(request.params.id, request.body)
+      const data = await api.postThreadMessage(request.params.id, request.body)
       return { success: true, message: data.message }
     } catch (error) {
-      console.error(`[HelpThreads] Message error: ${error.message}`)
+      console.error(`[Threads] Message error: ${error.message}`)
       reply.code(error.statusCode || 500)
       return { success: false, error: error.message }
     }
   })
 
   // Resolve thread
-  fastify.post('/api/help-threads/:id/resolve', async (request, reply) => {
+  fastify.post('/api/threads/:id/resolve', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
@@ -97,34 +97,34 @@ async function helpThreadRoutes(fastify) {
 
     try {
       const { resolution } = request.body || {}
-      const data = await api.resolveHelpThread(request.params.id, resolution)
+      const data = await api.resolveThread(request.params.id, resolution)
       return { success: true, thread: data.thread }
     } catch (error) {
-      console.error(`[HelpThreads] Resolve error: ${error.message}`)
+      console.error(`[Threads] Resolve error: ${error.message}`)
       reply.code(error.statusCode || 500)
       return { success: false, error: error.message }
     }
   })
 
   // Permanently delete thread (PM only)
-  fastify.delete('/api/help-threads/:id', async (request, reply) => {
+  fastify.delete('/api/threads/:id', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
     try {
-      const data = await api.deleteHelpThread(request.params.id)
+      const data = await api.deleteThread(request.params.id)
       return { success: true, deleted: data.deleted }
     } catch (error) {
-      console.error(`[HelpThreads] Delete error: ${error.message}`)
+      console.error(`[Threads] Delete error: ${error.message}`)
       reply.code(error.statusCode || 500)
       return { success: false, error: error.message }
     }
   })
 
   // Cancel thread
-  fastify.post('/api/help-threads/:id/cancel', async (request, reply) => {
+  fastify.post('/api/threads/:id/cancel', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
@@ -132,10 +132,10 @@ async function helpThreadRoutes(fastify) {
 
     try {
       const { reason } = request.body || {}
-      const data = await api.cancelHelpThread(request.params.id, reason)
+      const data = await api.cancelThread(request.params.id, reason)
       return { success: true, thread: data.thread }
     } catch (error) {
-      console.error(`[HelpThreads] Cancel error: ${error.message}`)
+      console.error(`[Threads] Cancel error: ${error.message}`)
       reply.code(error.statusCode || 500)
       return { success: false, error: error.message }
     }
@@ -186,4 +186,4 @@ async function helpThreadRoutes(fastify) {
   })
 }
 
-module.exports = { helpThreadRoutes }
+module.exports = { threadRoutes }

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 }