@yemi33/minions 0.1.2114 → 0.1.2115

package/engine/db/migrations/010-pr-links.js

@@ -0,0 +1,61 @@
+// engine/db/migrations/010-pr-links.js
+//
+// Phase 9.1: move `engine/pr-links.json` into SQL.
+//
+// pr-links.json is the *fallback* PR → work-item linkage store. The
+// primary source is `pull_requests.prdItems[]` (managed via the
+// pull-requests-store). Stray PR IDs that aren't covered by a project
+// pull-requests record still need to be discoverable — that's what this
+// table holds.
+//
+// Shape: { [prId]: <value> } where <value> is typically an array of item IDs
+// but may also be a bare string from legacy writes. Readers normalize.
+
+const path = require('path');
+const fs = require('fs');
+
+function _resolveMinionsDir() {
+  const envHome = process.env.MINIONS_HOME || process.env.MINIONS_TEST_DIR;
+  if (envHome) return envHome;
+  try { return require('../../shared').MINIONS_DIR; } catch { return null; }
+}
+
+function _readJsonOr(filePath, fallback) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch { return fallback; }
+}
+
+module.exports = {
+  version: 10,
+  description: 'pr_links: schema + pr-links.json backfill (fallback static store)',
+  up(db) {
+    db.exec(`
+      CREATE TABLE pr_links (
+        pr_id      TEXT PRIMARY KEY,
+        data       TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+
+    const minionsDir = _resolveMinionsDir();
+    if (!minionsDir) return;
+    const now = Date.now();
+    let inserted = 0;
+
+    const raw = _readJsonOr(path.join(minionsDir, 'engine', 'pr-links.json'), null);
+    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+      const ins = db.prepare(`INSERT INTO pr_links (pr_id, data, updated_at) VALUES (?, ?, ?)`);
+      for (const [prId, value] of Object.entries(raw)) {
+        try {
+          ins.run(String(prId), JSON.stringify(value), now);
+          inserted += 1;
+        } catch { /* duplicate / corrupt — skip */ }
+      }
+    }
+
+    // eslint-disable-next-line no-console
+    console.log(`[db-migrate] v10: backfilled ${inserted} pr-links rows; pr-links.json kept as dual-write mirror`);
+  },
+};

package/engine/shared.js

@@ -532,6 +532,10 @@ function _routeJsonReadToSql(p) {
       const store = require('./small-state-store');
       return { value: store.readQaSessions() };
     }
+    if (norm.endsWith('/engine/pr-links.json')) {
+      const store = require('./small-state-store');
+      return { value: store.readPrLinks() };
+    }
     // Per-project work-items.json — match `/projects/<name>/work-items.json`.
     // When SQL has no rows for the scope AND the JSON file is absent on
     // disk, preserve the legacy "file missing → null" semantic. This guards
@@ -582,9 +586,9 @@ function _routeJsonReadToSql(p) {
  *
  * **SQL routing (Phase 9):** when the path matches a migrated state file
  * (work-items, pull-requests, dispatch, metrics, watches, schedule-runs,
- * pipeline-runs, managed-processes, worktree-pool, qa-runs, qa-sessions),
- * the read is served from SQLite via `_routeJsonReadToSql` — the JSON file
- * on disk is no longer authoritative.
+ * pipeline-runs, managed-processes, worktree-pool, qa-runs, qa-sessions,
+ * pr-links), the read is served from SQLite via `_routeJsonReadToSql` — the
+ * JSON file on disk is no longer authoritative.
  *
  * Counterpart: `safeJsonNoRestore` for terminal artifacts and "missing == gone"
  * reads (cooldowns, archived PRDs, ephemeral session state) where reviving a
@@ -4988,9 +4992,19 @@ function getPrLinks() {
       mergePrLinkItems(links, pr.id, pr.prdItems || []);
     }
   } catch { /* SQL unavailable — skip primary source */ }
-  // Fallback: static pr-links.json for entries not covered above
+  // Fallback: pr_links SQL store (was static pr-links.json file). Phase 9.1
+  // routes both reads and writes through small-state-store; the JSON file is
+  // kept as a dual-write mirror. SQL failures fall through to the JSON file.
+  let static_ = null;
   try {
-    const static_ = JSON.parse(fs.readFileSync(PR_LINKS_PATH, 'utf8'));
+    const store = require('./small-state-store');
+    static_ = store.readPrLinks();
+  } catch { static_ = null; }
+  if (!static_ || Object.keys(static_).length === 0) {
+    try { static_ = JSON.parse(fs.readFileSync(PR_LINKS_PATH, 'utf8')); }
+    catch { static_ = null; }
+  }
+  if (static_ && typeof static_ === 'object' && !Array.isArray(static_)) {
     for (const [k, v] of Object.entries(static_)) {
       const canonical = parseCanonicalPrId(k);
       let normalizedKey = canonical ? `${canonical.scope}#${canonical.prNumber}` : k;
@@ -5004,7 +5018,7 @@ function getPrLinks() {
       }
       if (!links[normalizedKey]) mergePrLinkItems(links, normalizedKey, v);
     }
-  } catch { /* missing */ }
+  }
   return links;
 }
 
@@ -5030,7 +5044,7 @@ function addPrLink(prId, itemId, { project = null, url = '', prNumber = null } =
   const effectivePrId = canonicalPrId || prId;
   if (!effectivePrId || !itemId) return;
   const legacyPrId = String(prId || '');
-  mutateJsonFileLocked(PR_LINKS_PATH, (links) => {
+  const mutator = (links) => {
     if (!links || Array.isArray(links) || typeof links !== 'object') links = {};
     const mergedCurrent = new Set(normalizePrLinkItems(links[effectivePrId]));
     if (legacyPrId && legacyPrId !== effectivePrId && links[legacyPrId]) {
@@ -5040,7 +5054,24 @@ function addPrLink(prId, itemId, { project = null, url = '', prNumber = null } =
     if (!mergedCurrent.has(itemId)) mergedCurrent.add(itemId);
     links[effectivePrId] = [...mergedCurrent];
     return links;
-  }, { defaultValue: {} });
+  };
+  // Phase 9.1: pr-links is SQL-canonical via small-state-store; the JSON file
+  // is a dual-write mirror. SQLite failures fall through to the legacy JSON
+  // path so older installs without --experimental-sqlite still work.
+  let routedViaSql = false;
+  try {
+    const store = require('./small-state-store');
+    store.applyPrLinksMutation(mutator);
+    try { store._mirrorPrLinksJson(); } catch { /* mirror best-effort */ }
+    routedViaSql = true;
+  } catch (e) {
+    if (!e || !/SQLite unavailable|no such table|node:sqlite/.test(String(e.message))) {
+      throw e;
+    }
+  }
+  if (!routedViaSql) {
+    mutateJsonFileLocked(PR_LINKS_PATH, mutator, { defaultValue: {} });
+  }
 
   if (!project) return;
   const prPath = projectPrPath(project);

package/engine/small-state-store.js

@@ -829,6 +829,118 @@ function _mirrorQaSessionsJson(filePath) {
   } catch { /* mirror best-effort */ }
 }
 
+// ─── pr_links ───────────────────────────────────────────────────────────────
+// Shape: { [prId]: <value> } where <value> is typically array of item IDs
+// but may also be a bare string (legacy). Readers normalize.
+
+let _prLinksHash = null;
+
+function _hydratePrLinks(db) {
+  const fp = _resolveFilePath('pr-links.json');
+  const raw = _readJson(fp) || {};
+  db.prepare('DELETE FROM pr_links').run();
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return;
+  const now = Date.now();
+  const ins = db.prepare('INSERT INTO pr_links (pr_id, data, updated_at) VALUES (?, ?, ?) ON CONFLICT(pr_id) DO NOTHING');
+  for (const [prId, value] of Object.entries(raw)) {
+    ins.run(String(prId), JSON.stringify(value), now);
+  }
+}
+
+function _resyncPrLinksIfDiverged(db) {
+  const fp = _resolveFilePath('pr-links.json');
+  const currentHash = _fileContentHash(fp);
+  if (currentHash == null) return;
+  if (_prLinksHash != null && currentHash === _prLinksHash) return;
+  if (_prLinksHash == null) {
+    const sqlHas = db.prepare('SELECT 1 FROM pr_links LIMIT 1').get();
+    if (sqlHas) {
+      _prLinksHash = currentHash;
+      return;
+    }
+  }
+  _hydratePrLinks(db);
+  _prLinksHash = currentHash;
+}
+
+function _readPrLinksFromSql(db) {
+  const rows = db.prepare('SELECT pr_id, data FROM pr_links').all();
+  const out = {};
+  for (const row of rows) {
+    try { out[row.pr_id] = JSON.parse(row.data); }
+    catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+function readPrLinks() {
+  const { getDb } = require('./db');
+  let db;
+  try { db = getDb(); }
+  catch { return _readJson(_resolveFilePath('pr-links.json')) || {}; }
+  try { _resyncPrLinksIfDiverged(db); }
+  catch { /* table may be missing on a stale install — fall back to JSON */ }
+  let out;
+  try { out = _readPrLinksFromSql(db); }
+  catch { return _readJson(_resolveFilePath('pr-links.json')) || {}; }
+  if (Object.keys(out).length === 0) {
+    const fallback = _readJson(_resolveFilePath('pr-links.json'));
+    if (fallback && Object.keys(fallback).length > 0) return fallback;
+    return {};
+  }
+  return out;
+}
+
+function applyPrLinksMutation(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, () => {
+    _resyncPrLinksIfDiverged(db);
+    const before = _readPrLinksFromSql(db);
+    const beforeSnap = JSON.parse(JSON.stringify(before));
+    const next = mutator(before);
+    const after = (next === undefined || next === null) ? before : next;
+    if (!after || typeof after !== 'object' || Array.isArray(after)) {
+      return { wrote: false, result: beforeSnap };
+    }
+    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 pr_links (pr_id, data, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(pr_id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    const del = db.prepare('DELETE FROM pr_links WHERE pr_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 _mirrorPrLinksJson(filePath) {
+  try {
+    const shared = require('./shared');
+    const { getDb } = require('./db');
+    const obj = _readPrLinksFromSql(getDb());
+    const target = filePath || _resolveFilePath('pr-links.json');
+    shared.safeWrite(target, obj);
+    const h = _fileContentHash(target);
+    if (h != null) _prLinksHash = h;
+  } catch { /* mirror best-effort */ }
+}
+
 // ─── Test seam ─────────────────────────────────────────────────────────────
 
 function _resetAllForTest() {
@@ -841,6 +953,7 @@ function _resetAllForTest() {
     db.exec('DELETE FROM worktree_pool');
     try { db.exec('DELETE FROM qa_runs'); } catch { /* migration not applied */ }
     try { db.exec('DELETE FROM qa_sessions'); } catch { /* migration not applied */ }
+    try { db.exec('DELETE FROM pr_links'); } catch { /* migration not applied */ }
   } catch { /* not initialized */ }
   _scheduleRunsHash = null;
   _pipelineRunsHash = null;
@@ -848,6 +961,7 @@ function _resetAllForTest() {
   _worktreePoolHash = null;
   _qaRunsHash = null;
   _qaSessionsHash = null;
+  _prLinksHash = null;
 }
 
 module.exports = {
@@ -875,6 +989,10 @@ module.exports = {
   readQaSessions,
   applyQaSessionsMutation,
   _mirrorQaSessionsJson,
+  // pr_links
+  readPrLinks,
+  applyPrLinksMutation,
+  _mirrorPrLinksJson,
   // test seam
   _resetAllForTest,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2114",
+  "version": "0.1.2115",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"