@geekbeer/minion 2.70.2 → 3.4.7

package/core/stores/execution-store.js

@@ -1,123 +1,98 @@
 /**
- * Execution Store
- * Persists skill execution history to local JSON file.
+ * Execution Store (SQLite)
+ * Persists skill execution history to local SQLite database.
  * Single source of truth for execution records.
  */
 
-const fs = require('fs').promises
-const path = require('path')
-
-const { config } = require('../config')
-const { DATA_DIR } = require('../lib/platform')
+const { getDb } = require('../db')
 
 // Max executions to keep (older ones are pruned)
 const MAX_EXECUTIONS = 200
 
 /**
- * Get execution file path
- * Uses DATA_DIR if available (platform-aware), otherwise home dir
- */
-function getExecutionFilePath() {
-  try {
-    require('fs').accessSync(DATA_DIR)
-    return path.join(DATA_DIR, 'executions.json')
-  } catch {
-    return path.join(config.HOME_DIR, 'executions.json')
-  }
-}
-
-const EXECUTION_FILE = getExecutionFilePath()
-
-/**
- * Load executions from local file
- * @returns {Promise<Array>} Array of execution objects
- */
-async function load() {
-  try {
-    const data = await fs.readFile(EXECUTION_FILE, 'utf-8')
-    return JSON.parse(data)
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return []
-    }
-    console.error(`[ExecutionStore] Failed to load executions: ${err.message}`)
-    return []
-  }
-}
-
-/**
- * Save executions to local file
- * @param {Array} executions - Array of execution objects
- */
-async function saveAll(executions) {
-  try {
-    await fs.writeFile(EXECUTION_FILE, JSON.stringify(executions, null, 2), 'utf-8')
-  } catch (err) {
-    console.error(`[ExecutionStore] Failed to save executions: ${err.message}`)
-    throw err
-  }
-}
-
-/**
- * Save a single execution record
- * Upserts by ID, prunes old records if over limit
+ * Save a single execution record.
+ * Upserts by ID, prunes old records if over limit.
  * @param {object} execution - Execution record
  */
-async function save(execution) {
+function save(execution) {
+  const db = getDb()
   console.log(`[ExecutionStore] save() called: id=${execution.id}, skill=${execution.skill_name}, status=${execution.status}`)
 
-  const executions = await load()
-  console.log(`[ExecutionStore] Loaded ${executions.length} existing executions`)
-
-  // Find existing by ID and update, or add new
-  const existingIndex = executions.findIndex(e => e.id === execution.id)
-  if (existingIndex >= 0) {
-    const oldStatus = executions[existingIndex].status
-    executions[existingIndex] = { ...executions[existingIndex], ...execution }
-    console.log(`[ExecutionStore] Updated existing record at index ${existingIndex}: ${oldStatus} → ${execution.status}`)
+  const existing = db.prepare('SELECT data FROM executions WHERE id = ?').get(execution.id)
+
+  if (existing) {
+    const merged = { ...JSON.parse(existing.data), ...execution }
+    db.prepare(
+      'UPDATE executions SET skill_name = ?, workflow_id = ?, status = ?, data = ? WHERE id = ?'
+    ).run(
+      merged.skill_name || null,
+      merged.workflow_id || null,
+      merged.status || null,
+      JSON.stringify(merged),
+      execution.id
+    )
+    console.log(`[ExecutionStore] Updated existing record: ${execution.status}`)
   } else {
-    executions.unshift(execution) // Add to beginning (newest first)
-    console.log(`[ExecutionStore] Added new record (now ${executions.length} total)`)
+    db.prepare(
+      'INSERT INTO executions (id, skill_name, workflow_id, status, created_at, data) VALUES (?, ?, ?, ?, ?, ?)'
+    ).run(
+      execution.id,
+      execution.skill_name || null,
+      execution.workflow_id || null,
+      execution.status || null,
+      execution.created_at || new Date().toISOString(),
+      JSON.stringify(execution)
+    )
+    console.log(`[ExecutionStore] Added new record`)
   }
 
-  // Prune old executions
-  const pruned = executions.slice(0, MAX_EXECUTIONS)
+  // Prune old executions beyond MAX_EXECUTIONS
+  const count = db.prepare('SELECT COUNT(*) as cnt FROM executions').get().cnt
+  if (count > MAX_EXECUTIONS) {
+    db.prepare(`
+      DELETE FROM executions WHERE id NOT IN (
+        SELECT id FROM executions ORDER BY created_at DESC LIMIT ?
+      )
+    `).run(MAX_EXECUTIONS)
+  }
 
-  await saveAll(pruned)
-  console.log(`[ExecutionStore] ✓ Saved to file: ${execution.id} (${execution.skill_name} → ${execution.status})`)
+  console.log(`[ExecutionStore] ✓ Saved: ${execution.id} (${execution.skill_name} → ${execution.status})`)
 }
 
 /**
  * List executions with optional limit
  * @param {number} limit - Max number of executions to return
- * @returns {Promise<Array>} Array of execution objects (newest first)
+ * @returns {Array} Array of execution objects (newest first)
  */
-async function list(limit = 50) {
-  const executions = await load()
-  return executions.slice(0, limit)
+function list(limit = 50) {
+  const db = getDb()
+  const rows = db.prepare('SELECT data FROM executions ORDER BY created_at DESC LIMIT ?').all(limit)
+  return rows.map(r => JSON.parse(r.data))
 }
 
 /**
  * Get executions for a specific workflow
  * @param {string} workflowId - Workflow UUID
  * @param {number} limit - Max number to return
- * @returns {Promise<Array>} Array of execution objects
+ * @returns {Array} Array of execution objects
  */
-async function getByWorkflow(workflowId, limit = 20) {
-  const executions = await load()
-  return executions
-    .filter(e => e.workflow_id === workflowId)
-    .slice(0, limit)
+function getByWorkflow(workflowId, limit = 20) {
+  const db = getDb()
+  const rows = db.prepare(
+    'SELECT data FROM executions WHERE workflow_id = ? ORDER BY created_at DESC LIMIT ?'
+  ).all(workflowId, limit)
+  return rows.map(r => JSON.parse(r.data))
 }
 
 /**
  * Get a single execution by ID
  * @param {string} id - Execution UUID
- * @returns {Promise<object|null>} Execution object or null
+ * @returns {object|null} Execution object or null
  */
-async function getById(id) {
-  const executions = await load()
-  return executions.find(e => e.id === id) || null
+function getById(id) {
+  const db = getDb()
+  const row = db.prepare('SELECT data FROM executions WHERE id = ?').get(id)
+  return row ? JSON.parse(row.data) : null
 }
 
 module.exports = {

package/core/stores/memory-store.js

@@ -1,160 +1,54 @@
 /**
- * Memory Store
- * Persistent long-term memory for the minion, stored as markdown files.
- * Each entry has YAML frontmatter (id, title, category, timestamps) + body.
- * An index file (MEMORY.md) provides a quick summary of all entries.
+ * Memory Store (SQLite)
+ * Persistent long-term memory for the minion.
+ * Supports full-text search via FTS5.
  *
- * Storage layout:
- *   $DATA_DIR/memory/
- *   ├── MEMORY.md          # Index (auto-generated)
- *   └── {id}.md            # Individual entries
+ * Categories: user, feedback, project, reference
  */
 
-const fs = require('fs').promises
-const path = require('path')
 const crypto = require('crypto')
-
-const { config } = require('../config')
-const { DATA_DIR } = require('../lib/platform')
+const { getDb } = require('../db')
 
 const VALID_CATEGORIES = ['user', 'feedback', 'project', 'reference']
 
 /**
- * Resolve memory directory path
- */
-function getMemoryDir() {
-  try {
-    require('fs').accessSync(DATA_DIR)
-    return path.join(DATA_DIR, 'memory')
-  } catch {
-    return path.join(config.HOME_DIR, 'memory')
-  }
-}
-
-const MEMORY_DIR = getMemoryDir()
-const INDEX_FILE = path.join(MEMORY_DIR, 'MEMORY.md')
-
-/**
- * Ensure the memory directory exists
- */
-async function ensureDir() {
-  await fs.mkdir(MEMORY_DIR, { recursive: true })
-}
-
-/**
- * Parse YAML-style frontmatter from markdown content.
- * Returns { meta: {}, body: '' }
- */
-function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/)
-  if (!match) return { meta: {}, body: content }
-
-  const meta = {}
-  for (const line of match[1].split('\n')) {
-    const idx = line.indexOf(':')
-    if (idx === -1) continue
-    const key = line.slice(0, idx).trim()
-    const value = line.slice(idx + 1).trim()
-    meta[key] = value
-  }
-  return { meta, body: match[2].trim() }
-}
-
-/**
- * Serialize entry to markdown with YAML frontmatter
+ * List all memory entries (metadata + excerpt, no full body).
+ * @returns {Array<{ id, title, category, created_at, updated_at, excerpt }>}
  */
-function serializeEntry(entry) {
-  const lines = [
-    '---',
-    `id: ${entry.id}`,
-    `title: ${entry.title}`,
-    `category: ${entry.category}`,
-    `created_at: ${entry.created_at}`,
-    `updated_at: ${entry.updated_at}`,
-    '---',
-    '',
-    entry.content || '',
-  ]
-  return lines.join('\n')
-}
-
-/**
- * List all memory entries (frontmatter only, no body).
- * @returns {Promise<Array<{ id, title, category, created_at, updated_at }>>}
- */
-async function listEntries() {
-  await ensureDir()
-  let files
-  try {
-    files = await fs.readdir(MEMORY_DIR)
-  } catch {
-    return []
-  }
-
-  const entries = []
-  for (const file of files) {
-    if (file === 'MEMORY.md' || !file.endsWith('.md')) continue
-    try {
-      const raw = await fs.readFile(path.join(MEMORY_DIR, file), 'utf-8')
-      const { meta, body } = parseFrontmatter(raw)
-      if (meta.id) {
-        entries.push({
-          id: meta.id,
-          title: meta.title || '',
-          category: meta.category || 'reference',
-          created_at: meta.created_at || '',
-          updated_at: meta.updated_at || '',
-          excerpt: body.substring(0, 200),
-        })
-      }
-    } catch {
-      // Skip unreadable files
-    }
-  }
-
-  // Sort by updated_at descending
-  entries.sort((a, b) => (b.updated_at || '').localeCompare(a.updated_at || ''))
-  return entries
+function listEntries() {
+  const db = getDb()
+  const rows = db.prepare(`
+    SELECT id, title, category, created_at, updated_at,
+           substr(content, 1, 200) as excerpt
+    FROM memories
+    ORDER BY updated_at DESC
+  `).all()
+  return rows
 }
 
 /**
  * Load a single memory entry by ID.
  * @param {string} id
- * @returns {Promise<object|null>}
+ * @returns {object|null}
  */
-async function loadEntry(id) {
-  try {
-    const raw = await fs.readFile(path.join(MEMORY_DIR, `${id}.md`), 'utf-8')
-    const { meta, body } = parseFrontmatter(raw)
-    return {
-      id: meta.id || id,
-      title: meta.title || '',
-      category: meta.category || 'reference',
-      content: body,
-      created_at: meta.created_at || '',
-      updated_at: meta.updated_at || '',
-    }
-  } catch (err) {
-    if (err.code === 'ENOENT') return null
-    console.error(`[MemoryStore] Failed to load entry ${id}: ${err.message}`)
-    return null
-  }
+function loadEntry(id) {
+  const db = getDb()
+  const row = db.prepare('SELECT * FROM memories WHERE id = ?').get(id)
+  return row || null
 }
 
 /**
  * Save (create or update) a memory entry.
  * @param {{ id?, title, category, content }} entry
- * @returns {Promise<object>} The saved entry
+ * @returns {object} The saved entry
  */
-async function saveEntry(entry) {
-  await ensureDir()
-
+function saveEntry(entry) {
+  const db = getDb()
   const now = new Date().toISOString()
   const id = entry.id || crypto.randomBytes(6).toString('hex')
   const category = VALID_CATEGORIES.includes(entry.category) ? entry.category : 'reference'
 
-  // Check if existing
-  const existing = await loadEntry(id)
+  const existing = db.prepare('SELECT created_at FROM memories WHERE id = ?').get(id)
 
   const full = {
     id,
@@ -165,11 +59,17 @@ async function saveEntry(entry) {
     updated_at: now,
   }
 
-  const md = serializeEntry(full)
-  await fs.writeFile(path.join(MEMORY_DIR, `${id}.md`), md, 'utf-8')
-
-  // Regenerate index
-  await regenerateIndex()
+  if (existing) {
+    db.prepare(`
+      UPDATE memories SET title = ?, category = ?, content = ?, updated_at = ?
+      WHERE id = ?
+    `).run(full.title, full.category, full.content, full.updated_at, full.id)
+  } else {
+    db.prepare(`
+      INSERT INTO memories (id, title, category, content, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(full.id, full.title, full.category, full.content, full.created_at, full.updated_at)
+  }
 
   return full
 }
@@ -177,59 +77,67 @@ async function saveEntry(entry) {
 /**
  * Delete a memory entry.
  * @param {string} id
- * @returns {Promise<boolean>}
+ * @returns {boolean}
  */
-async function deleteEntry(id) {
-  try {
-    await fs.unlink(path.join(MEMORY_DIR, `${id}.md`))
-    await regenerateIndex()
-    return true
-  } catch (err) {
-    if (err.code === 'ENOENT') return false
-    console.error(`[MemoryStore] Failed to delete entry ${id}: ${err.message}`)
-    return false
-  }
+function deleteEntry(id) {
+  const db = getDb()
+  const result = db.prepare('DELETE FROM memories WHERE id = ?').run(id)
+  return result.changes > 0
 }
 
 /**
- * Regenerate MEMORY.md index file from all entries.
+ * Search memory entries 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<{ id, title, category, content, created_at, updated_at }>}
  */
-async function regenerateIndex() {
-  const entries = await listEntries()
-  const lines = ['# Minion Memory', '']
-
-  if (entries.length === 0) {
-    lines.push('No memories stored yet.')
-  } else {
-    // Group by category
-    const grouped = {}
-    for (const e of entries) {
-      const cat = e.category || 'reference'
-      if (!grouped[cat]) grouped[cat] = []
-      grouped[cat].push(e)
-    }
-
-    for (const cat of VALID_CATEGORIES) {
-      if (!grouped[cat] || grouped[cat].length === 0) continue
-      lines.push(`## ${cat}`, '')
-      for (const e of grouped[cat]) {
-        lines.push(`- **${e.title}** (${e.id}) - ${e.excerpt.substring(0, 80)}`)
-      }
-      lines.push('')
-    }
+function searchEntries(query, limit = 20) {
+  const db = getDb()
+  const terms = query.split(/\s+/).filter(Boolean)
+  if (terms.length === 0) return []
+
+  // Trigram tokenizer requires 3+ character terms.
+  // If any term is shorter, use LIKE fallback for the entire query.
+  const hasShortTerm = terms.some(t => [...t].length < 3)
+
+  if (hasShortTerm) {
+    // LIKE fallback: match all terms with AND
+    const conditions = terms.map(() => '(title LIKE ? OR content LIKE ?)').join(' AND ')
+    const params = terms.flatMap(t => {
+      const like = `%${t}%`
+      return [like, like]
+    })
+    params.push(limit)
+    return db.prepare(`
+      SELECT id, title, category, content, created_at, updated_at
+      FROM memories
+      WHERE ${conditions}
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(...params)
   }
 
-  await fs.writeFile(INDEX_FILE, lines.join('\n'), 'utf-8')
+  // FTS5 trigram search: wrap each term in double quotes for exact substring match
+  const sanitized = terms.map(t => `"${t.replace(/"/g, '')}"`).join(' ')
+  return db.prepare(`
+    SELECT m.id, m.title, m.category, m.content, m.created_at, m.updated_at
+    FROM memories m
+    JOIN memories_fts f ON m.rowid = f.rowid
+    WHERE memories_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?
+  `).all(sanitized, limit)
 }
 
 /**
  * Get a context snippet suitable for chat injection.
  * Returns the most important memory entries as a formatted string.
  * @param {number} maxChars - Maximum characters to return
- * @returns {Promise<string>}
+ * @returns {string}
  */
-async function getContextSnippet(maxChars = 2000) {
-  const entries = await listEntries()
+function getContextSnippet(maxChars = 2000) {
+  const entries = listEntries()
   if (entries.length === 0) return ''
 
   const parts = []
@@ -246,11 +154,10 @@ async function getContextSnippet(maxChars = 2000) {
 }
 
 module.exports = {
-  ensureDir,
   listEntries,
   loadEntry,
   saveEntry,
   deleteEntry,
+  searchEntries,
   getContextSnippet,
-  MEMORY_DIR,
 }