@yemi33/minions 0.1.2072 → 0.1.2074

package/engine/small-state-store.js

@@ -0,0 +1,560 @@
+// engine/small-state-store.js — SQL-backed implementations for the
+// four Phase 7 small state files:
+//
+//   schedule-runs.json      <-> schedule_runs       (object → row-per-id)
+//   pipeline-runs.json      <-> pipeline_runs       ({id:[runs]} → row-per-run)
+//   managed-processes.json  <-> managed_processes   ({specs:[]} → row-per-name)
+//   worktree-pool.json      <-> worktree_pool       ({entries:[]} → row-per-entry)
+//
+// They share enough infrastructure (content-hash fingerprint, mirror
+// writer, withTransaction wiring) that it's clearer to keep them in one
+// module — each store is small, and the JSON-shape transformations are
+// the only per-file divergence.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function _toMs(v) {
+  if (v == null) return null;
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  const parsed = Date.parse(v);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function _fileContentHash(filePath) {
+  try {
+    const buf = fs.readFileSync(filePath);
+    return crypto.createHash('sha1').update(buf).digest('hex');
+  }
+  catch { return null; }
+}
+
+function _readJson(filePath) {
+  let raw;
+  try { raw = fs.readFileSync(filePath, 'utf8'); }
+  catch { return null; }
+  try { return JSON.parse(raw); }
+  catch (e) {
+    try {
+      // eslint-disable-next-line no-console
+      console.warn(`[small-state-store] corrupt JSON in ${filePath}: ${e.message}`);
+    } catch { /* console wrapped */ }
+    return null;
+  }
+}
+
+function _resolveFilePath(rel) {
+  const shared = require('./shared');
+  return path.join(shared.MINIONS_DIR, 'engine', rel);
+}
+
+// ─── schedule_runs ──────────────────────────────────────────────────────────
+// Shape: { [scheduleId]: { lastRun, lastWorkItemId, lastResult, lastCompletedAt } }
+// SQL:   row per scheduleId, data = the value blob.
+
+let _scheduleRunsHash = null;
+
+function _hydrateScheduleRuns(db) {
+  const fp = _resolveFilePath('schedule-runs.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM schedule_runs').run();
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO schedule_runs (schedule_id, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(schedule_id) DO NOTHING');
+  for (const [id, value] of Object.entries(raw)) {
+    ins.run(id, JSON.stringify(value), now);
+  }
+}
+
+function _resyncScheduleRunsIfDiverged(db) {
+  const fp = _resolveFilePath('schedule-runs.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_scheduleRunsHash != null && currentHash === _scheduleRunsHash) return;
+  if (_scheduleRunsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM schedule_runs LIMIT 1').get();
+    if (sqlHas) {
+      _scheduleRunsHash = currentHash;
+      return;
+    }
+  }
+  _hydrateScheduleRuns(db);
+  _scheduleRunsHash = currentHash;
+}
+
+function _readScheduleRunsFromSql(db) {
+  const rows = db.prepare('SELECT schedule_id, data FROM schedule_runs').all();
+  const out = {};
+  for (const row of rows) {
+    try { out[row.schedule_id] = JSON.parse(row.data); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readScheduleRuns() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('schedule-runs.json')) || {}; }
+  _resyncScheduleRunsIfDiverged(db);
+  const out = _readScheduleRunsFromSql(db);
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('schedule-runs.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyScheduleRunsMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncScheduleRunsIfDiverged(db);
+    const before = _readScheduleRunsFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    const afterIds = new Set(Object.keys(after));
+    const beforeIds = new Set(Object.keys(beforeSnap));
+    let wrote = false;
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO schedule_runs (schedule_id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(schedule_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM schedule_runs WHERE schedule_id = ?');
+    for (const id of afterIds) {
+      if (!beforeIds.has(id) || JSON.stringify(beforeSnap[id]) !== JSON.stringify(after[id])) {
+        upsert.run(id, JSON.stringify(after[id]), now);
+        wrote = true;
+      }
+    }
+    for (const id of beforeIds) {
+      if (!afterIds.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorScheduleRunsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readScheduleRunsFromSql(getDb());
+    const target = filePath || _resolveFilePath('schedule-runs.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _scheduleRunsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── pipeline_runs ──────────────────────────────────────────────────────────
+// Shape: { [pipelineId]: [run, run, ...] }
+// SQL:   row per (pipelineId, runId). Reconstruct on read by grouping.
+
+let _pipelineRunsHash = null;
+
+function _hydratePipelineRuns(db) {
+  const fp = _resolveFilePath('pipeline-runs.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM pipeline_runs').run();
+  const now = Date.now();
+  const ins = db.prepare(`
+    INSERT INTO pipeline_runs (pipeline_id, run_id, status, started_at, data, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(pipeline_id, run_id) DO NOTHING
+  `);
+  for (const [pipelineId, runs] of Object.entries(raw)) {
+    if (!Array.isArray(runs)) continue;
+    for (const run of runs) {
+      if (!run || !run.runId) continue;
+      ins.run(pipelineId, String(run.runId), run.status || null, _toMs(run.startedAt), JSON.stringify(run), now);
+    }
+  }
+}
+
+function _resyncPipelineRunsIfDiverged(db) {
+  const fp = _resolveFilePath('pipeline-runs.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_pipelineRunsHash != null && currentHash === _pipelineRunsHash) return;
+  if (_pipelineRunsHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM pipeline_runs LIMIT 1').get();
+    if (sqlHas) { _pipelineRunsHash = currentHash; return; }
+  }
+  _hydratePipelineRuns(db);
+  _pipelineRunsHash = currentHash;
+}
+
+function _readPipelineRunsFromSql(db) {
+  const rows = db.prepare('SELECT pipeline_id, data FROM pipeline_runs ORDER BY pipeline_id, rowid').all();
+  const out = {};
+  for (const row of rows) {
+    try {
+      const run = JSON.parse(row.data);
+      if (!out[row.pipeline_id]) out[row.pipeline_id] = [];
+      out[row.pipeline_id].push(run);
+    } catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readPipelineRuns() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('pipeline-runs.json')) || {}; }
+  _resyncPipelineRunsIfDiverged(db);
+  const out = _readPipelineRunsFromSql(db);
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('pipeline-runs.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyPipelineRunsMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncPipelineRunsIfDiverged(db);
+    const before = _readPipelineRunsFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+
+    // Index by (pipelineId, runId).
+    const flatten = (obj) => {
+      const out = new Map();
+      for (const [pid, runs] of Object.entries(obj || {})) {
+        if (!Array.isArray(runs)) continue;
+        for (const run of runs) {
+          if (!run || !run.runId) continue;
+          out.set(`${pid}|${run.runId}`, { pid, run });
+        }
+      }
+      return out;
+    };
+    const beforeMap = flatten(beforeSnap);
+    const afterMap = flatten(after);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO pipeline_runs (pipeline_id, run_id, status, started_at, data, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(pipeline_id, run_id) DO UPDATE SET
+        status = excluded.status,
+        started_at = excluded.started_at,
+        data = excluded.data,
+        updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM pipeline_runs WHERE pipeline_id = ? AND run_id = ?');
+    let wrote = false;
+    for (const [key, { pid, run }] of afterMap) {
+      const prev = beforeMap.get(key);
+      if (!prev || JSON.stringify(prev.run) !== JSON.stringify(run)) {
+        upsert.run(pid, String(run.runId), run.status || null, _toMs(run.startedAt), JSON.stringify(run), now);
+        wrote = true;
+      }
+    }
+    for (const [key, { pid, run }] of beforeMap) {
+      if (!afterMap.has(key)) { del.run(pid, String(run.runId)); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorPipelineRunsJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readPipelineRunsFromSql(getDb());
+    const target = filePath || _resolveFilePath('pipeline-runs.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _pipelineRunsHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── managed_processes ─────────────────────────────────────────────────────
+// Shape: { specs: [ {name, ...}, ... ] }
+// SQL:   row per name.
+
+let _managedProcessesHash = null;
+
+function _hydrateManagedProcesses(db) {
+  const fp = _resolveFilePath('managed-processes.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM managed_processes').run();
+  const specs = Array.isArray(raw.specs) ? raw.specs : [];
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO managed_processes (name, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(name) DO NOTHING');
+  for (const spec of specs) {
+    if (!spec || !spec.name) continue;
+    ins.run(String(spec.name), JSON.stringify(spec), now);
+  }
+}
+
+function _resyncManagedProcessesIfDiverged(db) {
+  const fp = _resolveFilePath('managed-processes.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_managedProcessesHash != null && currentHash === _managedProcessesHash) return;
+  if (_managedProcessesHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM managed_processes LIMIT 1').get();
+    if (sqlHas) { _managedProcessesHash = currentHash; return; }
+  }
+  _hydrateManagedProcesses(db);
+  _managedProcessesHash = currentHash;
+}
+
+function _readManagedProcessesFromSql(db) {
+  const rows = db.prepare('SELECT data FROM managed_processes ORDER BY rowid').all();
+  const specs = [];
+  for (const row of rows) {
+    try { specs.push(JSON.parse(row.data)); } catch { /* skip */ }
+  }
+  return { specs };
+}
+
+function readManagedProcesses() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('managed-processes.json')) || { specs: [] }; }
+  _resyncManagedProcessesIfDiverged(db);
+  const out = _readManagedProcessesFromSql(db);
+  if (out.specs.length === 0) {
+    const fallback = _readJson(_resolveFilePath('managed-processes.json'));
+    if (fallback && Array.isArray(fallback.specs) && fallback.specs.length > 0) return fallback;
+    return { specs: [] };
+  }
+  return out;
+}
+
+function applyManagedProcessesMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncManagedProcessesIfDiverged(db);
+    const before = _readManagedProcessesFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!after || !Array.isArray(after.specs)) after.specs = [];
+
+    const indexByName = (arr) => {
+      const out = new Map();
+      for (const spec of arr) {
+        if (spec && spec.name) out.set(String(spec.name), spec);
+      }
+      return out;
+    };
+    const beforeMap = indexByName(beforeSnap.specs);
+    const afterMap = indexByName(after.specs);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO managed_processes (name, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM managed_processes WHERE name = ?');
+    let wrote = false;
+    for (const [name, spec] of afterMap) {
+      const prev = beforeMap.get(name);
+      if (!prev || JSON.stringify(prev) !== JSON.stringify(spec)) {
+        upsert.run(name, JSON.stringify(spec), now);
+        wrote = true;
+      }
+    }
+    for (const [name] of beforeMap) {
+      if (!afterMap.has(name)) { del.run(name); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorManagedProcessesJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readManagedProcessesFromSql(getDb());
+    const target = filePath || _resolveFilePath('managed-processes.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _managedProcessesHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── worktree_pool ─────────────────────────────────────────────────────────
+// Shape: { entries: [ {path, ...}, ... ] }
+// SQL:   row per entry, keyed by the worktree path (unique).
+
+let _worktreePoolHash = null;
+
+function _entryKey(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  return entry.path || entry.id || null;
+}
+
+function _hydrateWorktreePool(db) {
+  const fp = _resolveFilePath('worktree-pool.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM worktree_pool').run();
+  const entries = Array.isArray(raw.entries) ? raw.entries : [];
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO worktree_pool (entry_id, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(entry_id) DO NOTHING');
+  for (const entry of entries) {
+    const id = _entryKey(entry);
+    if (!id) continue;
+    ins.run(String(id), JSON.stringify(entry), now);
+  }
+}
+
+function _resyncWorktreePoolIfDiverged(db) {
+  const fp = _resolveFilePath('worktree-pool.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_worktreePoolHash != null && currentHash === _worktreePoolHash) return;
+  if (_worktreePoolHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM worktree_pool LIMIT 1').get();
+    if (sqlHas) { _worktreePoolHash = currentHash; return; }
+  }
+  _hydrateWorktreePool(db);
+  _worktreePoolHash = currentHash;
+}
+
+function _readWorktreePoolFromSql(db) {
+  const rows = db.prepare('SELECT data FROM worktree_pool ORDER BY rowid').all();
+  const entries = [];
+  for (const row of rows) {
+    try { entries.push(JSON.parse(row.data)); } catch { /* skip */ }
+  }
+  return { entries };
+}
+
+function readWorktreePool() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('worktree-pool.json')) || { entries: [] }; }
+  _resyncWorktreePoolIfDiverged(db);
+  const out = _readWorktreePoolFromSql(db);
+  if (out.entries.length === 0) {
+    const fallback = _readJson(_resolveFilePath('worktree-pool.json'));
+    if (fallback && Array.isArray(fallback.entries) && fallback.entries.length > 0) return fallback;
+    return { entries: [] };
+  }
+  return out;
+}
+
+function applyWorktreePoolMutation(mutator) {
+  const { getDb, withTransaction } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`small-state-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    _resyncWorktreePoolIfDiverged(db);
+    const before = _readWorktreePoolFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!after || !Array.isArray(after.entries)) after.entries = [];
+
+    const indexByKey = (arr) => {
+      const out = new Map();
+      for (const e of arr) {
+        const k = _entryKey(e);
+        if (k) out.set(String(k), e);
+      }
+      return out;
+    };
+    const beforeMap = indexByKey(beforeSnap.entries);
+    const afterMap = indexByKey(after.entries);
+
+    const now = Date.now();
+    const upsert = db.prepare(`
+      INSERT INTO worktree_pool (entry_id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(entry_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM worktree_pool WHERE entry_id = ?');
+    let wrote = false;
+    for (const [id, entry] of afterMap) {
+      const prev = beforeMap.get(id);
+      if (!prev || JSON.stringify(prev) !== JSON.stringify(entry)) {
+        upsert.run(id, JSON.stringify(entry), now);
+        wrote = true;
+      }
+    }
+    for (const [id] of beforeMap) {
+      if (!afterMap.has(id)) { del.run(id); wrote = true; }
+    }
+    return { wrote, result: after };
+  });
+}
+
+function _mirrorWorktreePoolJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readWorktreePoolFromSql(getDb());
+    const target = filePath || _resolveFilePath('worktree-pool.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _worktreePoolHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
+// ─── Test seam ─────────────────────────────────────────────────────────────
+
+function _resetAllForTest() {
+  const { getDb } = require('./db');
+  try {
+    const db = getDb();
+    db.exec('DELETE FROM schedule_runs');
+    db.exec('DELETE FROM pipeline_runs');
+    db.exec('DELETE FROM managed_processes');
+    db.exec('DELETE FROM worktree_pool');
+  } catch { /* not initialized */ }
+  _scheduleRunsHash = null;
+  _pipelineRunsHash = null;
+  _managedProcessesHash = null;
+  _worktreePoolHash = null;
+}
+
+module.exports = {
+  // schedule_runs
+  readScheduleRuns,
+  applyScheduleRunsMutation,
+  _mirrorScheduleRunsJson,
+  // pipeline_runs
+  readPipelineRuns,
+  applyPipelineRunsMutation,
+  _mirrorPipelineRunsJson,
+  // managed_processes
+  readManagedProcesses,
+  applyManagedProcessesMutation,
+  _mirrorManagedProcessesJson,
+  // worktree_pool
+  readWorktreePool,
+  applyWorktreePoolMutation,
+  _mirrorWorktreePoolJson,
+  // test seam
+  _resetAllForTest,
+};