@geekbeer/minion 2.70.2 → 3.4.7

package/core/stores/routine-store.js

@@ -1,105 +1,86 @@
 /**
- * Routine Store
- * Persists routine configurations to local JSON file.
+ * Routine Store (SQLite)
+ * Persists routine configurations to local SQLite database.
  * Allows minion to continue operating when HQ is offline.
  */
 
-const fs = require('fs').promises
-const path = require('path')
-
-const { config } = require('../config')
-const { DATA_DIR } = require('../lib/platform')
-
-// Routine file location: DATA_DIR/routines.json (platform-aware)
-// or ~/routines.json (fallback)
-function getRoutineFilePath() {
-  try {
-    require('fs').accessSync(DATA_DIR)
-    return path.join(DATA_DIR, 'routines.json')
-  } catch {
-    return path.join(config.HOME_DIR, 'routines.json')
-  }
-}
-
-const ROUTINE_FILE = getRoutineFilePath()
+const { getDb } = require('../db')
 
 /**
- * Load routines from local file
- * @returns {Promise<Array>} Array of routine objects
+ * Load all routines
+ * @returns {Array} Array of routine objects
  */
-async function load() {
-  try {
-    const data = await fs.readFile(ROUTINE_FILE, 'utf-8')
-    return JSON.parse(data)
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return []
-    }
-    console.error(`[RoutineStore] Failed to load routines: ${err.message}`)
-    return []
-  }
+function load() {
+  const db = getDb()
+  const rows = db.prepare('SELECT data FROM routines ORDER BY name').all()
+  return rows.map(r => JSON.parse(r.data))
 }
 
 /**
- * Save routines to local file
+ * Save routines (replace all)
  * @param {Array} routines - Array of routine objects
  */
-async function save(routines) {
-  try {
-    await fs.writeFile(ROUTINE_FILE, JSON.stringify(routines, null, 2), 'utf-8')
-    console.log(`[RoutineStore] Saved ${routines.length} routines to ${ROUTINE_FILE}`)
-  } catch (err) {
-    console.error(`[RoutineStore] Failed to save routines: ${err.message}`)
-    throw err
-  }
+function save(routines) {
+  const db = getDb()
+  const tx = db.transaction(() => {
+    db.prepare('DELETE FROM routines').run()
+    const insert = db.prepare('INSERT INTO routines (id, name, data) VALUES (?, ?, ?)')
+    for (const r of routines) {
+      insert.run(r.id, r.name, JSON.stringify(r))
+    }
+  })
+  tx()
+  console.log(`[RoutineStore] Saved ${routines.length} routines`)
 }
 
 /**
  * Update last_run for a specific routine
  * @param {string} routineId - Routine UUID
  */
-async function updateLastRun(routineId) {
-  const routines = await load()
-  const routine = routines.find(r => String(r.id) === String(routineId))
-  if (routine) {
-    routine.last_run = new Date().toISOString()
-    await save(routines)
-  }
+function updateLastRun(routineId) {
+  const db = getDb()
+  const row = db.prepare('SELECT data FROM routines WHERE id = ?').get(String(routineId))
+  if (!row) return
+
+  const routine = JSON.parse(row.data)
+  routine.last_run = new Date().toISOString()
+  db.prepare('UPDATE routines SET data = ? WHERE id = ?').run(JSON.stringify(routine), String(routineId))
 }
 
 /**
  * Find a routine by name
  * @param {string} name - Routine name
- * @returns {Promise<object|null>} Routine object or null
+ * @returns {object|null} Routine object or null
  */
-async function findByName(name) {
-  const routines = await load()
-  return routines.find(r => r.name === name) || null
+function findByName(name) {
+  const db = getDb()
+  const row = db.prepare('SELECT data FROM routines WHERE name = ?').get(name)
+  return row ? JSON.parse(row.data) : null
 }
 
 /**
  * Upsert a routine from HQ data.
  * Upserts by ID (routines come from HQ with UUIDs).
  * @param {object} routineData - { id, name, pipeline_skill_names, content, is_active, cron_expression, last_run, next_run }
- * @returns {Promise<Array>} Updated routines array
+ * @returns {Array} Updated routines array
  */
-async function upsertFromHQ(routineData) {
-  const routines = await load()
-  const index = routines.findIndex(r => String(r.id) === String(routineData.id))
+function upsertFromHQ(routineData) {
+  const db = getDb()
+  const existing = db.prepare('SELECT data FROM routines WHERE id = ?').get(String(routineData.id))
 
-  if (index >= 0) {
-    // Update from HQ (preserve local-only fields if any)
-    routines[index] = {
-      ...routines[index],
-      name: routineData.name,
-      pipeline_skill_names: routineData.pipeline_skill_names,
-      content: routineData.content || '',
-      context: routineData.context || null,
-      is_active: routineData.is_active,
-      cron_expression: routineData.cron_expression || '',
-    }
+  if (existing) {
+    const routine = JSON.parse(existing.data)
+    routine.name = routineData.name
+    routine.pipeline_skill_names = routineData.pipeline_skill_names
+    routine.content = routineData.content || ''
+    routine.context = routineData.context || null
+    routine.is_active = routineData.is_active
+    routine.cron_expression = routineData.cron_expression || ''
+    db.prepare('UPDATE routines SET name = ?, data = ? WHERE id = ?').run(
+      routine.name, JSON.stringify(routine), String(routineData.id)
+    )
   } else {
-    routines.push({
+    const routine = {
       id: routineData.id,
       name: routineData.name,
       pipeline_skill_names: routineData.pipeline_skill_names || [],
@@ -109,11 +90,13 @@ async function upsertFromHQ(routineData) {
       cron_expression: routineData.cron_expression || '',
       last_run: routineData.last_run || null,
       next_run: routineData.next_run || null,
-    })
+    }
+    db.prepare('INSERT INTO routines (id, name, data) VALUES (?, ?, ?)').run(
+      String(routine.id), routine.name, JSON.stringify(routine)
+    )
   }
 
-  await save(routines)
-  return routines
+  return load()
 }
 
 module.exports = { load, save, updateLastRun, findByName, upsertFromHQ }

package/core/stores/workflow-store.js

@@ -1,81 +1,62 @@
 /**
- * Workflow Store
- * Persists workflow configurations to local JSON file.
+ * Workflow Store (SQLite)
+ * Persists workflow configurations to local SQLite database.
  * Allows minion to continue operating when HQ is offline.
  */
 
-const fs = require('fs').promises
-const path = require('path')
-
-const { config } = require('../config')
-const { DATA_DIR } = require('../lib/platform')
-
-// Workflow file location: DATA_DIR/workflows.json (platform-aware)
-// or ~/workflows.json (fallback)
-function getWorkflowFilePath() {
-  try {
-    require('fs').accessSync(DATA_DIR)
-    return path.join(DATA_DIR, 'workflows.json')
-  } catch {
-    return path.join(config.HOME_DIR, 'workflows.json')
-  }
-}
-
-const WORKFLOW_FILE = getWorkflowFilePath()
+const crypto = require('crypto')
+const { getDb } = require('../db')
 
 /**
- * Load workflows from local file
- * @returns {Promise<Array>} Array of workflow objects
+ * Load all workflows
+ * @returns {Array} Array of workflow objects
  */
-async function load() {
-  try {
-    const data = await fs.readFile(WORKFLOW_FILE, 'utf-8')
-    return JSON.parse(data)
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      // File doesn't exist yet — normal on first run
-      return []
-    }
-    console.error(`[WorkflowStore] Failed to load workflows: ${err.message}`)
-    return []
-  }
+function load() {
+  const db = getDb()
+  const rows = db.prepare('SELECT data FROM workflows ORDER BY name').all()
+  return rows.map(r => JSON.parse(r.data))
 }
 
 /**
- * Save workflows to local file
+ * Save workflows (replace all)
  * @param {Array} workflows - Array of workflow objects
  */
-async function save(workflows) {
-  try {
-    await fs.writeFile(WORKFLOW_FILE, JSON.stringify(workflows, null, 2), 'utf-8')
-    console.log(`[WorkflowStore] Saved ${workflows.length} workflows to ${WORKFLOW_FILE}`)
-  } catch (err) {
-    console.error(`[WorkflowStore] Failed to save workflows: ${err.message}`)
-    throw err
-  }
+function save(workflows) {
+  const db = getDb()
+  const tx = db.transaction(() => {
+    db.prepare('DELETE FROM workflows').run()
+    const insert = db.prepare('INSERT INTO workflows (id, name, data) VALUES (?, ?, ?)')
+    for (const w of workflows) {
+      insert.run(w.id, w.name, JSON.stringify(w))
+    }
+  })
+  tx()
+  console.log(`[WorkflowStore] Saved ${workflows.length} workflows`)
 }
 
 /**
  * Update last_run for a specific workflow
  * @param {string} workflowId - Workflow UUID
  */
-async function updateLastRun(workflowId) {
-  const workflows = await load()
-  const workflow = workflows.find(w => w.id === workflowId)
-  if (workflow) {
-    workflow.last_run = new Date().toISOString()
-    await save(workflows)
-  }
+function updateLastRun(workflowId) {
+  const db = getDb()
+  const row = db.prepare('SELECT data FROM workflows WHERE id = ?').get(workflowId)
+  if (!row) return
+
+  const workflow = JSON.parse(row.data)
+  workflow.last_run = new Date().toISOString()
+  db.prepare('UPDATE workflows SET data = ? WHERE id = ?').run(JSON.stringify(workflow), workflowId)
 }
 
 /**
  * Find a workflow by name
  * @param {string} name - Workflow name (slug)
- * @returns {Promise<object|null>} Workflow object or null
+ * @returns {object|null} Workflow object or null
  */
-async function findByName(name) {
-  const workflows = await load()
-  return workflows.find(w => w.name === name) || null
+function findByName(name) {
+  const db = getDb()
+  const row = db.prepare('SELECT data FROM workflows WHERE name = ?').get(name)
+  return row ? JSON.parse(row.data) : null
 }
 
 /**
@@ -83,27 +64,27 @@ async function findByName(name) {
  * If exists: updates definition only (preserves schedule/local state).
  * If new: creates with inactive schedule.
  * @param {object} workflowData - { name, pipeline_skill_names, pipeline_steps, content, project_id }
- * @returns {Promise<Array>} Updated workflows array
+ * @returns {Array} Updated workflows array
  */
-async function upsertByName(workflowData) {
-  const crypto = require('crypto')
-  const workflows = await load()
-  const index = workflows.findIndex(w => w.name === workflowData.name)
+function upsertByName(workflowData) {
+  const db = getDb()
+  const existing = db.prepare('SELECT data FROM workflows WHERE name = ?').get(workflowData.name)
 
-  if (index >= 0) {
-    // Update definition only (preserve schedule/local state)
-    workflows[index].pipeline_skill_names = workflowData.pipeline_skill_names
+  if (existing) {
+    const workflow = JSON.parse(existing.data)
+    workflow.pipeline_skill_names = workflowData.pipeline_skill_names
     if (workflowData.content !== undefined) {
-      workflows[index].content = workflowData.content
+      workflow.content = workflowData.content
     }
     if (workflowData.project_id !== undefined) {
-      workflows[index].project_id = workflowData.project_id
+      workflow.project_id = workflowData.project_id
     }
     if (workflowData.pipeline_steps !== undefined) {
-      workflows[index].pipeline_steps = workflowData.pipeline_steps
+      workflow.pipeline_steps = workflowData.pipeline_steps
     }
+    db.prepare('UPDATE workflows SET data = ? WHERE id = ?').run(JSON.stringify(workflow), workflow.id)
   } else {
-    workflows.push({
+    const workflow = {
       id: crypto.randomUUID(),
       name: workflowData.name,
       pipeline_skill_names: workflowData.pipeline_skill_names,
@@ -113,11 +94,13 @@ async function upsertByName(workflowData) {
       cron_expression: '',
       is_active: false,
       last_run: null,
-    })
+    }
+    db.prepare('INSERT INTO workflows (id, name, data) VALUES (?, ?, ?)').run(
+      workflow.id, workflow.name, JSON.stringify(workflow)
+    )
   }
 
-  await save(workflows)
-  return workflows
+  return load()
 }
 
 module.exports = { load, save, updateLastRun, findByName, upsertByName }

package/docs/api-reference.md

@@ -77,12 +77,14 @@ Files are stored in `~/files/`. Max upload size: 50MB.
 
 ### Memory (Long-term Knowledge)
 
-Persistent memory entries stored as markdown files in `$DATA_DIR/memory/`.
+Persistent memory entries stored in SQLite (`$DATA_DIR/minion.db`).
 Categories: `user` (user preferences), `feedback` (feedback), `project` (project info), `reference` (references).
+Full-text search supported via FTS5.
 
 | Method | Endpoint | Description |
 |--------|----------|-------------|
 | GET | `/api/memory` | List all memory entries (id, title, category, excerpt, timestamps) |
+| GET | `/api/memory?search=keyword` | Full-text search on title and content (FTS5) |
 | GET | `/api/memory/:id` | Get full memory entry |
 | POST | `/api/memory` | Create memory entry. Body: `{title, category, content}` |
 | PUT | `/api/memory/:id` | Update memory entry. Body: `{title?, category?, content?}` |
@@ -116,12 +118,14 @@ Response (list):
 
 ### Daily Logs (Short-term Memory)
 
-Daily conversation summaries stored as `$DATA_DIR/daily-logs/YYYY-MM-DD.md`.
+Daily conversation summaries stored in SQLite (`$DATA_DIR/minion.db`).
 Generated via end-of-day processing or manual creation.
+Full-text search supported via FTS5.
 
 | Method | Endpoint | Description |
 |--------|----------|-------------|
 | GET | `/api/daily-logs` | List all logs (date + size, newest first) |
+| GET | `/api/daily-logs?search=keyword` | Full-text search on log content (FTS5) |
 | POST | `/api/daily-logs` | Create a daily log. Body: `{date, content}` |
 | GET | `/api/daily-logs/:date` | Get a specific day's log content |
 | PUT | `/api/daily-logs/:date` | Update a daily log. Body: `{content}` |