@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/scripts/migrate-prefs.mjs

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+// migrate-prefs.mjs — migrates multi-agent-preferences.json v2.0.0 → v2.1.0
+//
+// Usage:
+//   node migrate-prefs.mjs [--dry-run] [--file <path>]
+//
+// - Idempotent: safe to run multiple times. v2.1.0 files pass through unchanged.
+// - Atomic: writes to a .tmp file and rename()s. No partial writes.
+// - Non-destructive: renames gitIdentities → identities, preserves everything else.
+// - Fills defaults for new v2.1.0 fields.
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const DEFAULT_FILE = path.join(os.homedir(), ".claude", "multi-agent-preferences.json");
+
+function parseArgs(argv) {
+  const args = { file: DEFAULT_FILE, dryRun: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--dry-run") args.dryRun = true;
+    else if (a === "--file") args.file = argv[++i];
+    else if (a === "--help" || a === "-h") {
+      console.log("Usage: migrate-prefs.mjs [--dry-run] [--file <path>]");
+      process.exit(0);
+    }
+  }
+  return args;
+}
+
+function defaultSettings() {
+  return {
+    branchTtlDays: 15,
+    pushRetryMax: 5,
+    buildRetryMax: 3,
+    serviceStatusCacheSeconds: 300,
+    repoScanDays: 90,
+    identityRoutingEnabled: false,
+    multiRepoEnabled: false,
+    pushMustSucceed: true,
+  };
+}
+
+function defaultKeychainMapping() {
+  return {
+    jira: null,
+    bitbucket_token: null,
+    bitbucket_user: null,
+    github: null,
+    confluence: null,
+    figma: null,
+    figma_mcp: null,
+    fortify: null,
+    firebase: null, // unified — project_id is parsed from the decoded SA JSON; no separate firebase_project
+    jenkins: null,
+  };
+}
+
+// v2.1.0 sub-migration — always runs (even on already-v2.1.0 files) to consolidate
+// early-v2.1.0 drift: firebase_sa+firebase_project → firebase.
+function consolidateFirebase(out, changes) {
+  const km = out?.global?.keychainMapping;
+  if (km && typeof km === "object") {
+    if ("firebase_sa" in km) {
+      if ((km.firebase == null || km.firebase === undefined) && km.firebase_sa != null) {
+        km.firebase = km.firebase_sa;
+      } else if (!("firebase" in km)) {
+        km.firebase = null;
+      }
+      delete km.firebase_sa;
+      changes.push("keychainMapping: firebase_sa → firebase");
+    } else if (!("firebase" in km)) {
+      km.firebase = null;
+      changes.push("keychainMapping: added firebase: null");
+    }
+    if ("firebase_project" in km) {
+      delete km.firebase_project;
+      changes.push("keychainMapping: removed firebase_project (redundant — project_id lives inside the SA JSON)");
+    }
+  }
+  if (Array.isArray(out?.global?.identities)) {
+    for (const id of out.global.identities) {
+      const spm = id?.servicePatMap;
+      if (!spm || typeof spm !== "object") continue;
+      if ("firebase_sa" in spm) {
+        if ((spm.firebase == null || spm.firebase === undefined) && spm.firebase_sa != null) {
+          spm.firebase = spm.firebase_sa;
+        }
+        delete spm.firebase_sa;
+        changes.push(`identities[${id.name || "?"}].servicePatMap: firebase_sa → firebase`);
+      }
+      if ("firebase_project" in spm) {
+        delete spm.firebase_project;
+        changes.push(`identities[${id.name || "?"}].servicePatMap: removed firebase_project`);
+      }
+    }
+  }
+}
+
+// v2.1.0 sub-migration — consolidate figma_pat → figma, remove figma_user.
+function consolidateFigma(out, changes) {
+  const km = out?.global?.keychainMapping;
+  if (km && typeof km === "object") {
+    if ("figma_pat" in km) {
+      if ((km.figma == null || km.figma === undefined) && km.figma_pat != null) {
+        km.figma = km.figma_pat;
+      }
+      delete km.figma_pat;
+      changes.push("keychainMapping: figma_pat → figma");
+    }
+    if ("figma_user" in km) {
+      delete km.figma_user;
+      changes.push("keychainMapping: removed figma_user (unused)");
+    }
+  }
+  if (Array.isArray(out?.global?.identities)) {
+    for (const id of out.global.identities) {
+      const spm = id?.servicePatMap;
+      if (!spm || typeof spm !== "object") continue;
+      if ("figma_pat" in spm) {
+        if ((spm.figma == null || spm.figma === undefined) && spm.figma_pat != null) {
+          spm.figma = spm.figma_pat;
+        }
+        delete spm.figma_pat;
+        changes.push(`identities[${id.name || "?"}].servicePatMap: figma_pat → figma`);
+      }
+    }
+  }
+}
+
+function defaultTriageCrossCheck() {
+  return { enabled: false, samplePct: 10, model: "sonnet", blockOnDisagreement: false };
+}
+
+function migrate(prefs) {
+  const changes = [];
+  const out = JSON.parse(JSON.stringify(prefs)); // deep clone
+
+  // 1. schemaVersion — detect whether a v2.0.0 → 2.1.0 → 2.2.0 → 2.3.0 bump chain is needed.
+  // Sub-migrations run regardless (they're idempotent), so early-return is avoided.
+  // v2.3.0 is the v7.4.0 target — adds optional `accounts[]` (per-account host
+  // overrides) and `recentAccounts[]` (LRU for autopilot account picker).
+  // Both default to empty arrays; old prefs continue to validate without them.
+  const TARGET = "2.3.0";
+  if (out.schemaVersion === TARGET) {
+    // already on target — skip version bump, but still run sub-migrations below
+  } else if (out.schemaVersion === "2.2.0") {
+    out.schemaVersion = TARGET;
+    changes.push(`schemaVersion: 2.2.0 → ${TARGET}`);
+  } else if (out.schemaVersion === "2.1.0") {
+    out.schemaVersion = TARGET;
+    changes.push(`schemaVersion: 2.1.0 → ${TARGET}`);
+  } else if (!out.schemaVersion) {
+    out.schemaVersion = TARGET;
+    changes.push(`added schemaVersion: ${TARGET}`);
+  } else if (out.schemaVersion === "2.0.0") {
+    out.schemaVersion = TARGET;
+    changes.push(`schemaVersion: 2.0.0 → ${TARGET}`);
+  } else {
+    throw new Error(`unknown schemaVersion: ${out.schemaVersion}`);
+  }
+
+  // 2. Ensure global object
+  if (!out.global || typeof out.global !== "object") {
+    out.global = {};
+    changes.push("created empty global object");
+  }
+
+  // 3. Rename gitIdentities → identities (if present, and identities not already set)
+  if (Array.isArray(out.global.gitIdentities)) {
+    if (!Array.isArray(out.global.identities)) {
+      out.global.identities = out.global.gitIdentities;
+      changes.push(`renamed gitIdentities → identities (${out.global.identities.length} entries)`);
+    } else {
+      changes.push("gitIdentities present but identities also exists — keeping identities, dropping gitIdentities");
+    }
+    delete out.global.gitIdentities;
+  } else if (!Array.isArray(out.global.identities)) {
+    out.global.identities = [];
+    changes.push("initialized empty identities array");
+  }
+
+  // 4. keychainMapping — expand to 12 services
+  const km = out.global.keychainMapping || {};
+  const kmDefaults = defaultKeychainMapping();
+  let kmChanged = false;
+  for (const [k, v] of Object.entries(kmDefaults)) {
+    if (!(k in km)) {
+      km[k] = v;
+      kmChanged = true;
+    }
+  }
+  out.global.keychainMapping = km;
+  if (kmChanged) changes.push("expanded keychainMapping with missing services (existing values preserved)");
+
+  // 5. New v2.1.0 fields with defaults
+  if (!out.global.platformIdentityRouting) {
+    out.global.platformIdentityRouting = {};
+    changes.push("added empty platformIdentityRouting");
+  }
+  if (!Array.isArray(out.global.recentProjects)) {
+    out.global.recentProjects = [];
+    changes.push("initialized empty recentProjects");
+  }
+  if (!out.global.recentBranches) {
+    out.global.recentBranches = {};
+    changes.push("added empty recentBranches");
+  }
+  if (!Array.isArray(out.global.recentGroups)) {
+    out.global.recentGroups = [];
+    changes.push("added empty recentGroups");
+  }
+  // v7.4.0: account picker LRU + per-account host overrides.
+  // Both optional — installer initializes to empty arrays so the schema
+  // validator sees them, but downstream code treats undefined as empty too.
+  if (!Array.isArray(out.global.recentAccounts)) {
+    out.global.recentAccounts = [];
+    changes.push("added empty recentAccounts (v7.4.0)");
+  }
+  if (!Array.isArray(out.global.accounts)) {
+    out.global.accounts = [];
+    changes.push("added empty accounts (v7.4.0 per-account host overrides)");
+  }
+  if (!out.global.serviceStatus) {
+    out.global.serviceStatus = {};
+    changes.push("added empty serviceStatus");
+  }
+  if (!out.global.settings) {
+    out.global.settings = defaultSettings();
+    changes.push("added settings with defaults");
+  } else {
+    const s = out.global.settings;
+    const sd = defaultSettings();
+    let sChanged = false;
+    for (const [k, v] of Object.entries(sd)) {
+      if (!(k in s)) {
+        s[k] = v;
+        sChanged = true;
+      }
+    }
+    if (sChanged) changes.push("filled missing settings keys");
+  }
+
+  // 6. triageCrossCheck default if missing
+  if (!out.global.triageCrossCheck) {
+    out.global.triageCrossCheck = defaultTriageCrossCheck();
+    changes.push("added triageCrossCheck defaults");
+  }
+
+  // 7. promptLanguage default if missing
+  if (!out.global.promptLanguage) {
+    out.global.promptLanguage = "en";
+    changes.push("added promptLanguage: en");
+  }
+
+  // 8. Prune obsolete fields (v2.0.0 template artifacts)
+  if ("defaultPriority" in out.global) {
+    delete out.global.defaultPriority;
+    changes.push("removed obsolete defaultPriority");
+  }
+  if ("defaultIssueType" in out.global) {
+    delete out.global.defaultIssueType;
+    changes.push("removed obsolete defaultIssueType");
+  }
+
+  // 9. Ensure projects object
+  if (!out.projects || typeof out.projects !== "object") {
+    out.projects = {};
+    changes.push("initialized empty projects object");
+  }
+
+  // 10. v2.1.0 sub-migration: consolidate Firebase keys (always runs, idempotent).
+  consolidateFirebase(out, changes);
+
+  // 11. v2.1.0 sub-migration: figma_pat → figma, remove figma_user (always runs, idempotent).
+  consolidateFigma(out, changes);
+
+  // 12. v5.7+ sub-migration: promote legacy channel defaults to the new reportChannels /
+  // reportContent / wikiScope structure. Idempotent — safe to re-run.
+  migrateReportChannels(out, changes);
+
+  return { out, changes, alreadyMigrated: changes.length === 0 };
+}
+
+// v5.7+ sub-migration: legacy jiraCommentDefault / confluenceDefault / wikiDefault booleans
+// → new reportChannels {pr,jira,confluence,wiki} object + wikiScope array. Also initializes
+// reportContent + autopilotReportTimeoutSeconds with schema defaults. Old fields are removed
+// after a successful migration. Runs every load; no-op when fields already normalized.
+function migrateReportChannels(out, changes) {
+  const g = out.global;
+  if (!g || typeof g !== "object") return;
+
+  // --- reportChannels ---
+  if (!g.reportChannels || typeof g.reportChannels !== "object") {
+    const channels = {
+      pr:         true,  // schema default
+      jira:       typeof g.jiraCommentDefault === "boolean" ? g.jiraCommentDefault : true,
+      confluence: typeof g.confluenceDefault === "boolean" ? g.confluenceDefault : false,
+      wiki:       typeof g.wikiDefault === "boolean" ? g.wikiDefault : false,
+    };
+    g.reportChannels = channels;
+    changes.push("added reportChannels {pr,jira,confluence,wiki} (migrated from jiraCommentDefault/confluenceDefault/wikiDefault if present)");
+  }
+
+  // --- reportContent ---
+  if (!g.reportContent || typeof g.reportContent !== "object") {
+    g.reportContent = {
+      normalAnalysis:    true,
+      technicalAnalysis: false,
+      testScenarios:     true,
+      autoDiff:          false,
+      manualNote:        false,
+    };
+    changes.push("added reportContent defaults {normalAnalysis,technicalAnalysis,testScenarios,autoDiff,manualNote}");
+  } else if (!("technicalAnalysis" in g.reportContent)) {
+    // v5.7.3+ — backfill technicalAnalysis onto already-initialized reportContent
+    g.reportContent.technicalAnalysis = false;
+    changes.push("added reportContent.technicalAnalysis: false (v5.7.3 backfill)");
+  }
+
+  // --- wikiScope ---
+  if (!Array.isArray(g.wikiScope)) {
+    if (g.wikiDefault === false) {
+      g.wikiScope = [];
+      changes.push("added wikiScope: [] (legacy wikiDefault=false — opt out of all wiki artifacts)");
+    } else {
+      g.wikiScope = ["main", "ios", "screenshots", "index"];
+      changes.push("added wikiScope: [main,ios,screenshots,index] (legacy wikiDefault=true or unset)");
+    }
+  }
+
+  // --- autopilotReportTimeoutSeconds ---
+  if (typeof g.autopilotReportTimeoutSeconds !== "number") {
+    g.autopilotReportTimeoutSeconds = 1800;
+    changes.push("added autopilotReportTimeoutSeconds: 1800 (30 min) — Phase 7 always-pause timeout");
+  }
+
+  // --- prune deprecated booleans ---
+  for (const key of ["jiraCommentDefault", "confluenceDefault", "wikiDefault"]) {
+    if (key in g) {
+      delete g[key];
+      changes.push(`removed deprecated ${key} (superseded by reportChannels${key === "wikiDefault" ? " + wikiScope" : ""})`);
+    }
+  }
+}
+
+function atomicWrite(filePath, data) {
+  const tmp = filePath + ".tmp." + process.pid;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+  fs.renameSync(tmp, filePath);
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (!fs.existsSync(args.file)) {
+    console.error(`ERROR: preferences file not found: ${args.file}`);
+    process.exit(2);
+  }
+
+  const raw = fs.readFileSync(args.file, "utf8");
+  let prefs;
+  try {
+    prefs = JSON.parse(raw);
+  } catch (e) {
+    console.error(`ERROR: invalid JSON in ${args.file}: ${e.message}`);
+    process.exit(2);
+  }
+
+  const { out, changes, alreadyMigrated } = migrate(prefs);
+
+  if (alreadyMigrated) {
+    console.log(`✓ already v2.1.0 — no changes: ${args.file}`);
+    process.exit(0);
+  }
+
+  console.log(`migrating ${args.file} (${changes.length} change(s)):`);
+  for (const c of changes) console.log(`  • ${c}`);
+
+  if (args.dryRun) {
+    console.log("--- DRY RUN — no write ---");
+    process.exit(0);
+  }
+
+  atomicWrite(args.file, out);
+  console.log(`✓ wrote migrated prefs to ${args.file}`);
+}
+
+main();

package/pipeline/scripts/migrate-state.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+/**
+ * migrate-state.mjs — apply forward migrations to agent-state.json or
+ * multi-agent-preferences.json when the on-disk schemaVersion is older
+ * than the repo's current schema.
+ *
+ * Each migration is a file in pipeline/schemas/migrations/ named
+ * `{type}-{from}-to-{to}.mjs`. Runner discovers them, topologically orders
+ * by version, and applies the chain.
+ *
+ * Usage:
+ *   node migrate-state.mjs <path>                   # auto-detect type, apply chain
+ *   node migrate-state.mjs --type=state <path>      # force state type
+ *   node migrate-state.mjs --type=prefs <path>      # force prefs type
+ *   node migrate-state.mjs --dry-run <path>         # preview, no write
+ *
+ * Exit codes:
+ *   0 — migration applied (or file already current)
+ *   1 — invalid input (unreadable file, malformed JSON, missing schemaVersion)
+ *   2 — no migration path (gap in the chain)
+ *   3 — migration failed (module error, schemaVersion not set in output)
+ */
+
+import { readFileSync, writeFileSync, readdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MIGRATIONS_DIR = join(__dirname, "..", "schemas", "migrations");
+const SCHEMAS_DIR = join(__dirname, "..", "schemas");
+
+/** Current target versions, read from the schemas themselves. */
+const TARGET_VERSIONS = {
+  state: readSchemaVersion("agent-state.schema.json"),
+  prefs: readSchemaVersion("prefs.schema.json"),
+};
+
+/**
+ * @param {string} filename
+ * @returns {string}
+ */
+function readSchemaVersion(filename) {
+  try {
+    const schema = JSON.parse(readFileSync(join(SCHEMAS_DIR, filename), "utf-8"));
+    const sv = schema?.properties?.schemaVersion;
+    const v = sv?.const ?? sv?.enum?.at(-1);
+    if (!v) throw new Error(`schemaVersion.const or .enum[-1] missing in ${filename}`);
+    return v;
+  } catch (err) {
+    console.error(`migrate-state: cannot read ${filename} — ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let type = null;
+  let dryRun = false;
+  let path = null;
+  for (const a of args) {
+    if (a.startsWith("--type=")) type = a.slice(7);
+    else if (a === "--dry-run") dryRun = true;
+    else if (a.startsWith("--")) {
+      console.error(`unknown flag: ${a}`);
+      process.exit(1);
+    } else path = a;
+  }
+  if (!path) {
+    console.error("usage: migrate-state.mjs [--type=state|prefs] [--dry-run] <path>");
+    process.exit(1);
+  }
+  return { type, dryRun, path };
+}
+
+/**
+ * Auto-detect type from filename if not forced.
+ * @param {string | null} forced
+ * @param {string} path
+ * @returns {"state" | "prefs"}
+ */
+function resolveType(forced, path) {
+  if (forced === "state" || forced === "prefs") return forced;
+  if (/agent-state\.json$/.test(path)) return "state";
+  if (/preferences\.json$/.test(path)) return "prefs";
+  console.error(
+    `migrate-state: cannot infer type from ${path} — pass --type=state or --type=prefs`,
+  );
+  process.exit(1);
+}
+
+/**
+ * Find the migration chain from `from` to `to` for a given type.
+ * Returns an array of { from, to, path } in order, or null if no path.
+ *
+ * @param {"state" | "prefs"} type
+ * @param {string} from
+ * @param {string} to
+ * @returns {Array<{from:string,to:string,path:string}> | null}
+ */
+function resolveChain(type, from, to) {
+  if (from === to) return [];
+  if (!existsSync(MIGRATIONS_DIR)) return null;
+
+  const files = readdirSync(MIGRATIONS_DIR).filter(
+    (f) => f.startsWith(`${type}-`) && f.endsWith(".mjs"),
+  );
+  /** @type {Array<{from:string,to:string,path:string}>} */
+  const edges = [];
+  for (const f of files) {
+    const m = f.match(new RegExp(`^${type}-(.+)-to-(.+)\\.mjs$`));
+    if (!m) continue;
+    edges.push({ from: m[1], to: m[2], path: join(MIGRATIONS_DIR, f) });
+  }
+
+  // Simple BFS from `from` to `to`
+  /** @type {Map<string, {prev: string | null, edge: {from:string,to:string,path:string} | null}>} */
+  const visited = new Map();
+  visited.set(from, { prev: null, edge: null });
+  const queue = [from];
+  while (queue.length) {
+    const cur = queue.shift();
+    if (cur === to) {
+      const chain = [];
+      let v = to;
+      while (visited.get(v)?.edge) {
+        chain.unshift(visited.get(v).edge);
+        v = visited.get(v).prev;
+      }
+      return chain;
+    }
+    for (const e of edges) {
+      if (e.from === cur && !visited.has(e.to)) {
+        visited.set(e.to, { prev: cur, edge: e });
+        queue.push(e.to);
+      }
+    }
+  }
+  return null;
+}
+
+async function main() {
+  const { type: forced, dryRun, path } = parseArgs();
+
+  if (!existsSync(path)) {
+    console.error(`migrate-state: file not found — ${path}`);
+    process.exit(1);
+  }
+
+  /** @type {object} */
+  let doc;
+  try {
+    doc = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    console.error(`migrate-state: invalid JSON in ${path} — ${err.message}`);
+    process.exit(1);
+  }
+
+  const type = resolveType(forced, path);
+  const from = doc.schemaVersion;
+  const to = TARGET_VERSIONS[type];
+
+  if (!from) {
+    console.error(`migrate-state: ${path} has no schemaVersion field`);
+    process.exit(1);
+  }
+
+  if (from === to) {
+    console.log(`${path} already at schemaVersion ${to} — no migration needed`);
+    process.exit(0);
+  }
+
+  const chain = resolveChain(type, from, to);
+  if (!chain) {
+    console.error(
+      `migrate-state: no migration path from ${from} to ${to} for ${type}. ` +
+        `Fill the gap in pipeline/schemas/migrations/.`,
+    );
+    process.exit(2);
+  }
+
+  let current = doc;
+  for (const step of chain) {
+    console.log(`  → applying ${type} ${step.from} → ${step.to} (${step.path.split("/").pop()})`);
+    try {
+      const mod = await import(pathToFileURL(step.path).href);
+      if (typeof mod.default !== "function") {
+        throw new Error("migration module must export default function");
+      }
+      current = mod.default(current);
+      if (current?.schemaVersion !== step.to) {
+        throw new Error(
+          `migration did not set schemaVersion to ${step.to} (got ${current?.schemaVersion})`,
+        );
+      }
+    } catch (err) {
+      console.error(`migrate-state: migration failed — ${err.message}`);
+      process.exit(3);
+    }
+  }
+
+  if (dryRun) {
+    console.log("--- dry run, not writing ---");
+    console.log(JSON.stringify(current, null, 2));
+    process.exit(0);
+  }
+
+  writeFileSync(path, JSON.stringify(current, null, 2) + "\n");
+  console.log(`✓ ${path} migrated to schemaVersion ${to}`);
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error(`migrate-state: unhandled — ${err.message}`);
+  process.exit(3);
+});