@yemi33/minions 0.1.2447 → 0.1.2449

package/engine/quarantine-refs.js

@@ -1,103 +0,0 @@
-const shared = require('./shared');
-
-const QUARANTINE_REF_RETENTION_MS = 10 * 24 * 60 * 60 * 1000;
-const DELETE_CONCURRENCY = 8;
-
-function quarantineRefCreatedAtMs(ref, fallbackCreatedAt) {
-  const timestamp = String(ref || '').split('/').pop();
-  const fromRef = Number(timestamp);
-  if (Number.isFinite(fromRef) && fromRef > 0) return fromRef;
-  const fallback = Date.parse(fallbackCreatedAt || '');
-  return Number.isFinite(fallback) ? fallback : null;
-}
-
-async function _readProjectQuarantineRefs(project) {
-  const output = await shared.shellSafeGit([
-    'for-each-ref',
-    '--format=%(refname)|%(objectname)|%(creatordate:iso-strict)',
-    'refs/minions/quarantine/',
-    'refs/minions/quarantine-wip/',
-  ], { cwd: project.localPath, timeout: 15000 });
-  const seenRefs = new Set();
-  return String(output || '').split(/\r?\n/).filter(Boolean).map(line => {
-    const [ref, sha, fallbackCreatedAt] = line.split('|');
-    if (!ref || seenRefs.has(ref)) return null;
-    seenRefs.add(ref);
-    const createdAtMs = quarantineRefCreatedAtMs(ref, fallbackCreatedAt);
-    return { ref, sha, fallbackCreatedAt, createdAtMs };
-  }).filter(Boolean);
-}
-
-async function listQuarantineRefs(projects) {
-  const candidates = (Array.isArray(projects) ? projects : []).filter(project => project?.localPath);
-  const results = await Promise.allSettled(candidates.map(async project => {
-    const refs = await _readProjectQuarantineRefs(project);
-    return refs.map(({ ref, sha, fallbackCreatedAt, createdAtMs }) => {
-      return {
-        project: project.name || '',
-        ref,
-        sha,
-        createdAt: createdAtMs ? new Date(createdAtMs).toISOString() : (fallbackCreatedAt || ''),
-        kind: ref.startsWith('refs/minions/quarantine-wip/') ? 'wip' : 'commits',
-      };
-    });
-  }));
-  const items = [];
-  for (let i = 0; i < results.length; i++) {
-    const result = results[i];
-    if (result.status === 'fulfilled') items.push(...result.value);
-    else items.push({ project: candidates[i].name || '', error: result.reason?.message || String(result.reason) });
-  }
-  return items.sort((a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || '')));
-}
-
-async function _mapWithConcurrency(items, limit, worker) {
-  let next = 0;
-  const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (next < items.length) {
-      const item = items[next++];
-      await worker(item);
-    }
-  });
-  await Promise.all(runners);
-}
-
-async function pruneExpiredQuarantineRefs(projects, {
-  now = Date.now(),
-  retentionMs = QUARANTINE_REF_RETENTION_MS,
-} = {}) {
-  const candidates = (Array.isArray(projects) ? projects : []).filter(project => project?.localPath);
-  const results = await Promise.allSettled(candidates.map(async project => {
-    const refs = await _readProjectQuarantineRefs(project);
-    const expired = refs.filter(item => item.createdAtMs !== null && now - item.createdAtMs >= retentionMs);
-
-    let removed = 0;
-    await _mapWithConcurrency(expired, DELETE_CONCURRENCY, async item => {
-      await shared.shellSafeGit(['update-ref', '-d', item.ref, item.sha], {
-        cwd: project.localPath,
-        timeout: 15000,
-      });
-      removed++;
-    });
-    return removed;
-  }));
-
-  let removed = 0;
-  const errors = [];
-  for (let i = 0; i < results.length; i++) {
-    const result = results[i];
-    if (result.status === 'fulfilled') removed += result.value;
-    else errors.push({
-      project: candidates[i]?.name || '',
-      error: result.reason?.message || String(result.reason),
-    });
-  }
-  return { removed, errors };
-}
-
-module.exports = {
-  QUARANTINE_REF_RETENTION_MS,
-  quarantineRefCreatedAtMs,
-  listQuarantineRefs,
-  pruneExpiredQuarantineRefs,
-};

package/engine/state-operations.js

@@ -1,178 +0,0 @@
-// Explicit operational tooling for the SQL-only runtime state store.
-
-const fs = require('fs');
-const path = require('path');
-const { getDb } = require('./db');
-
-function _quoteSqlString(value) {
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-
-function checkState() {
-  const db = getDb();
-  const schemaVersion = Number(db.prepare('SELECT COALESCE(MAX(version), 0) AS version FROM schema_version').get().version) || 0;
-  const quickCheck = db.prepare('PRAGMA quick_check').all().map(row => Object.values(row)[0]);
-  const foreignKeyViolations = db.prepare('PRAGMA foreign_key_check').all();
-  const invariants = {
-    orphanPrdItems: Number(db.prepare('SELECT COUNT(*) AS n FROM prd_items pi LEFT JOIN prds p ON p.id=pi.prd_id WHERE p.id IS NULL').get().n) || 0,
-    orphanVerifyPrs: Number(db.prepare('SELECT COUNT(*) AS n FROM prd_verify_prs vp LEFT JOIN prds p ON p.id=vp.prd_id WHERE p.id IS NULL').get().n) || 0,
-    brokenWorkItemPrdLinks: Number(db.prepare('SELECT COUNT(*) AS n FROM work_items wi LEFT JOIN prd_items pi ON pi.id=wi.prd_item_id WHERE wi.prd_item_id IS NOT NULL AND pi.id IS NULL').get().n) || 0,
-  };
-  const ok = quickCheck.length === 1
-    && quickCheck[0] === 'ok'
-    && foreignKeyViolations.length === 0
-    && Object.values(invariants).every(count => count === 0);
-  return { ok, schemaVersion, quickCheck, foreignKeyViolations, invariants };
-}
-
-function backupState(targetPath) {
-  if (!targetPath) throw new Error('state backup requires an output path');
-  const resolved = path.resolve(targetPath);
-  fs.mkdirSync(path.dirname(resolved), { recursive: true });
-  if (fs.existsSync(resolved)) throw new Error(`backup target already exists: ${resolved}`);
-  const db = getDb();
-  db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-  db.exec(`VACUUM INTO ${_quoteSqlString(resolved)}`);
-  return { ok: true, path: resolved, bytes: fs.statSync(resolved).size };
-}
-
-function exportState(targetPath) {
-  if (!targetPath) throw new Error('state export requires an output path');
-  const resolved = path.resolve(targetPath);
-  fs.mkdirSync(path.dirname(resolved), { recursive: true });
-  const db = getDb();
-  const tables = db.prepare(`
-    SELECT name FROM sqlite_master
-    WHERE type='table' AND name NOT LIKE 'sqlite_%'
-    ORDER BY name
-  `).all().map(row => row.name);
-  const data = {
-    format: 'minions-sql-diagnostic-export-v1',
-    exportedAt: new Date().toISOString(),
-    integrity: checkState(),
-    tables: {},
-  };
-  for (const table of tables) {
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table)) throw new Error(`unsafe table name: ${table}`);
-    data.tables[table] = db.prepare(`SELECT * FROM "${table}"`).all();
-  }
-  const tmp = `${resolved}.tmp.${process.pid}`;
-  fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
-  fs.renameSync(tmp, resolved);
-  return { ok: true, path: resolved, tables: tables.length, bytes: fs.statSync(resolved).size };
-}
-
-function _readJson(filePath, expected) {
-  if (!fs.existsSync(filePath)) return null;
-  const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  if (expected === 'array' && !Array.isArray(value)) throw new Error(`expected array in ${filePath}`);
-  if (expected === 'object' && (!value || typeof value !== 'object' || Array.isArray(value))) {
-    throw new Error(`expected object in ${filePath}`);
-  }
-  return value;
-}
-
-function importLegacyJson(sourceRoot) {
-  if (!sourceRoot) throw new Error('state import-legacy-json requires a source directory');
-  const root = path.resolve(sourceRoot);
-  if (!fs.statSync(root).isDirectory()) throw new Error(`legacy source is not a directory: ${root}`);
-  const imported = {};
-  const replace = (modulePath, fn, value) => {
-    if (value == null) return;
-    require(modulePath)[fn](() => value);
-    imported[fn] = (imported[fn] || 0) + 1;
-  };
-
-  replace(
-    './small-state-store',
-    'applyEngineStateMutation',
-    _readJson(path.join(root, 'engine', 'state.json'), 'object'),
-  );
-  replace('./dispatch-store', 'applyDispatchMutation', _readJson(path.join(root, 'engine', 'dispatch.json'), 'object'));
-  replace('./metrics-store', 'applyMetricsMutation', _readJson(path.join(root, 'engine', 'metrics.json'), 'object'));
-  replace('./watches-store', 'applyWatchesMutation', _readJson(path.join(root, 'engine', 'watches.json'), 'array'));
-
-  const small = [
-    ['schedule-runs.json', 'applyScheduleRunsMutation', 'object'],
-    ['pipeline-runs.json', 'applyPipelineRunsMutation', 'object'],
-    ['managed-processes.json', 'applyManagedProcessesMutation', 'object'],
-    ['worktree-pool.json', 'applyWorktreePoolMutation', 'object'],
-    ['qa-runs.json', 'applyQaRunsMutation', 'array'],
-    ['qa-sessions.json', 'applyQaSessionsMutation', 'array'],
-    ['pr-links.json', 'applyPrLinksMutation', 'object'],
-    ['cooldowns.json', 'applyCooldownsMutation', 'object'],
-    ['pending-rebases.json', 'applyPendingRebasesMutation', 'array'],
-    ['cc-sessions.json', 'applyCcSessionsMutation', 'array'],
-    ['doc-sessions.json', 'applyDocSessionsMutation', 'object'],
-  ];
-  for (const [filename, fn, shape] of small) {
-    replace('./small-state-store', fn, _readJson(path.join(root, 'engine', filename), shape));
-  }
-  replace(
-    './small-state-store',
-    'applyCcGlobalSessionMutation',
-    _readJson(path.join(root, 'engine', 'cc-session.json'), 'object'),
-  );
-
-  const workItemsStore = require('./work-items-store');
-  const pullRequestsStore = require('./pull-requests-store');
-  const importScope = (scope, dir) => {
-    const workItems = _readJson(path.join(dir, 'work-items.json'), 'array');
-    if (workItems) {
-      workItemsStore.applyWorkItemsMutation(scope, () => workItems);
-      imported.workItemScopes = (imported.workItemScopes || 0) + 1;
-    }
-    const archivedWorkItems = _readJson(path.join(dir, 'work-items-archive.json'), 'array');
-    if (archivedWorkItems) {
-      workItemsStore.replaceArchivedWorkItems(scope, archivedWorkItems);
-      imported.archivedWorkItemScopes = (imported.archivedWorkItemScopes || 0) + 1;
-    }
-    const pullRequests = _readJson(path.join(dir, 'pull-requests.json'), 'array');
-    if (pullRequests) {
-      pullRequestsStore.applyPullRequestsMutation(scope, () => pullRequests);
-      imported.pullRequestScopes = (imported.pullRequestScopes || 0) + 1;
-    }
-  };
-  importScope('central', root);
-  try {
-    for (const entry of fs.readdirSync(path.join(root, 'projects'), { withFileTypes: true })) {
-      if (entry.isDirectory() && entry.name !== '.archived') {
-        importScope(entry.name, path.join(root, 'projects', entry.name));
-      }
-    }
-  } catch { /* projects are optional */ }
-
-  const prdStore = require('./prd-store');
-  for (const [dir, archived] of [[path.join(root, 'prd'), false], [path.join(root, 'prd', 'archive'), true]]) {
-    let files = [];
-    try { files = fs.readdirSync(dir).filter(name => name.endsWith('.json')); } catch { continue; }
-    for (const filename of files) {
-      const prd = _readJson(path.join(dir, filename), 'object');
-      prdStore.writePrd(filename, prd, { archived });
-      imported.prds = (imported.prds || 0) + 1;
-    }
-  }
-
-  const logs = _readJson(path.join(root, 'engine', 'log.json'), 'array');
-  if (logs) {
-    const db = getDb();
-    const { withTransaction } = require('./db');
-    withTransaction(db, () => {
-      db.exec('DELETE FROM logs');
-      const insert = db.prepare('INSERT INTO logs (ts_ms, level, message, meta) VALUES (?, ?, ?, ?)');
-      for (const entry of logs) {
-        const timestamp = Date.parse(entry.timestamp);
-        const meta = { ...entry };
-        delete meta.timestamp;
-        delete meta.level;
-        delete meta.message;
-        const { level, message } = entry;
-        insert.run(Number.isFinite(timestamp) ? timestamp : Date.now(), level || 'info', String(message || ''), Object.keys(meta).length ? JSON.stringify(meta) : null);
-      }
-    });
-    imported.logs = logs.length;
-  }
-  return { ok: true, source: root, imported, integrity: checkState() };
-}
-
-module.exports = { checkState, backupState, exportState, importLegacyJson };