bosun 0.41.2 → 0.41.3

package/workflow/workflow-templates.mjs

@@ -32,9 +32,10 @@
 
 import { createHash, randomUUID } from "node:crypto";
 import { detectProjectStack, getCommandPresets } from "./project-detection.mjs";
+import { normalizeTemplateLayoutInPlace } from "../workflow-templates/_helpers.mjs";
 
 // ── Re-export helpers for external consumers ────────────────────────────────
-export { node, edge, resetLayout } from "../workflow-templates/_helpers.mjs";
+export { node, edge, resetLayout, normalizeTemplateLayoutInPlace } from "../workflow-templates/_helpers.mjs";
 
 // ── Import templates from category modules ──────────────────────────────────
 
@@ -252,7 +253,7 @@ export const TEMPLATE_CATEGORIES = Object.freeze({
   custom:      { label: "Custom",       icon: ":settings:", order: 13 },
 });
 
-export const WORKFLOW_TEMPLATES = Object.freeze([
+const BUILTIN_WORKFLOW_TEMPLATES = [
   // ── GitHub ──
   PR_MERGE_STRATEGY_TEMPLATE,
   PR_TRIAGE_TEMPLATE,
@@ -332,248 +333,347 @@ export const WORKFLOW_TEMPLATES = Object.freeze([
   INLINE_WORKFLOW_COMPOSITION_TEMPLATE,
   MCP_TO_BOSUN_BRIDGE_TEMPLATE,
   GIT_HEALTH_PIPELINE_TEMPLATE,
-]);
+];
+
+for (const template of BUILTIN_WORKFLOW_TEMPLATES) {
+  normalizeTemplateLayoutInPlace(template);
+}
+
+export const WORKFLOW_TEMPLATES = Object.freeze(BUILTIN_WORKFLOW_TEMPLATES);
 
 const _TEMPLATE_BY_ID = new Map(
   WORKFLOW_TEMPLATES.map((template) => [template.id, template]),
 );
-const TEMPLATE_STATE_VERSION = 1;
+function createWorkflowTemplateState({ getTemplate, cloneTemplateDefinition }) {
+  const templateStateVersion = 1;
+
+  function toFingerprintNode(node = {}) {
+    if (!node || typeof node !== "object") return node;
+    const next = JSON.parse(JSON.stringify(node));
+    delete next.position;
+    delete next.inputPorts;
+    delete next.outputPorts;
+    delete next.width;
+    delete next.height;
+    return next;
+  }
 
-function stableNormalize(value) {
-  if (Array.isArray(value)) {
-    return value.map((entry) => stableNormalize(entry));
+  function toFingerprintEdge(edgeDef = {}) {
+    if (!edgeDef || typeof edgeDef !== "object") return edgeDef;
+    const next = JSON.parse(JSON.stringify(edgeDef));
+    next.sourcePort = String(next.sourcePort || "default").trim() || "default";
+    next.targetPort = String(next.targetPort || "default").trim() || "default";
+    delete next.sourcePortType;
+    delete next.targetPortType;
+    return next;
   }
-  if (value && typeof value === "object") {
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-      normalized[key] = stableNormalize(value[key]);
+
+  function stableNormalize(value) {
+    if (Array.isArray(value)) {
+      return value.map((entry) => stableNormalize(entry));
     }
-    return normalized;
+    if (value && typeof value === "object") {
+      const normalized = {};
+      for (const key of Object.keys(value).sort()) {
+        normalized[key] = stableNormalize(value[key]);
+      }
+      return normalized;
+    }
+    return value;
   }
-  return value;
-}
 
-function stableStringify(value) {
-  return JSON.stringify(stableNormalize(value));
-}
+  function stableStringify(value) {
+    return JSON.stringify(stableNormalize(value));
+  }
 
-function hashContent(value) {
-  return createHash("sha256").update(stableStringify(value)).digest("hex");
-}
+  function hashContent(value) {
+    return createHash("sha256").update(stableStringify(value)).digest("hex");
+  }
 
-function toWorkflowFingerprintPayload(def = {}) {
-  return {
-    name: def.name || "",
-    description: def.description || "",
-    category: def.category || "custom",
-    trigger: def.trigger || "",
-    variables: def.variables || {},
-    nodes: def.nodes || [],
-    edges: def.edges || [],
-  };
-}
+  function toWorkflowFingerprintPayload(def = {}) {
+    return {
+      name: def.name || "",
+      description: def.description || "",
+      category: def.category || "custom",
+      trigger: def.trigger || "",
+      variables: def.variables || {},
+      nodes: Array.isArray(def.nodes) ? def.nodes.map((node) => toFingerprintNode(node)) : [],
+      edges: Array.isArray(def.edges) ? def.edges.map((edgeDef) => toFingerprintEdge(edgeDef)) : [],
+    };
+  }
 
-export function computeWorkflowFingerprint(def = {}) {
-  return hashContent(toWorkflowFingerprintPayload(def));
-}
+  function computeWorkflowFingerprint(def = {}) {
+    return hashContent(toWorkflowFingerprintPayload(def));
+  }
 
-function cloneTemplateDefinition(template) {
-  return JSON.parse(JSON.stringify(template));
-}
+  function deriveTemplateState(def, template) {
+    const nowIso = new Date().toISOString();
+    const currentFingerprint = computeWorkflowFingerprint(def);
+    const templateFingerprint = computeWorkflowFingerprint(template);
+    const previousState = def?.metadata?.templateState || {};
 
-function getTemplateVersion(templateId) {
-  const template = getTemplate(templateId);
-  if (!template) return null;
-  return computeWorkflowFingerprint(template).slice(0, 12);
-}
+    const installedTemplateFingerprint = typeof previousState.installedTemplateFingerprint === "string"
+      ? previousState.installedTemplateFingerprint
+      : (currentFingerprint === templateFingerprint ? templateFingerprint : null);
+
+    const installedFingerprint = typeof previousState.installedFingerprint === "string"
+      ? previousState.installedFingerprint
+      : currentFingerprint;
+
+    const isCustomized = currentFingerprint !== installedFingerprint;
+    const updateAvailable = installedTemplateFingerprint
+      ? installedTemplateFingerprint !== templateFingerprint
+      : false;
+
+    return {
+      stateVersion: templateStateVersion,
+      templateId: template.id,
+      templateName: template.name,
+      templateVersion: templateFingerprint.slice(0, 12),
+      templateFingerprint,
+      installedTemplateFingerprint,
+      installedTemplateVersion: installedTemplateFingerprint
+        ? installedTemplateFingerprint.slice(0, 12)
+        : null,
+      installedFingerprint,
+      currentFingerprint,
+      isCustomized,
+      updateAvailable,
+      refreshedAt: nowIso,
+    };
+  }
+
+  function applyWorkflowTemplateState(def = {}) {
+    if (!def || typeof def !== "object") return def;
+    const templateId = String(def?.metadata?.installedFrom || "").trim();
+    if (!templateId) return def;
+    const template = getTemplate(templateId);
+    if (!template) return def;
+    if (!def.metadata || typeof def.metadata !== "object") def.metadata = {};
+    def.metadata.templateState = deriveTemplateState(def, template);
+    return def;
+  }
+
+  function makeUpdatedWorkflowFromTemplate(existing, template, mode = "replace") {
+    const templateClone = cloneTemplateDefinition(template);
+    const nowIso = new Date().toISOString();
+    const mergedVariables = {
+      ...(templateClone.variables || {}),
+      ...(existing.variables || {}),
+    };
+    const next = {
+      ...templateClone,
+      id: mode === "copy" ? randomUUID() : existing.id,
+      name: mode === "copy" ? `${existing.name} (Updated)` : existing.name,
+      enabled: existing.enabled !== false,
+      variables: mergedVariables,
+      metadata: {
+        ...(existing.metadata || {}),
+        ...(templateClone.metadata || {}),
+        installedFrom: template.id,
+        templateUpdatedAt: nowIso,
+      },
+    };
+    delete next.metadata.templateState;
+    if (mode === "copy") {
+      next.metadata.createdAt = nowIso;
+      next.metadata.updatedAt = nowIso;
+    }
+    return applyWorkflowTemplateState(next);
+  }
+
+  function updateWorkflowFromTemplate(engine, workflowId, opts = {}) {
+    const mode = String(opts.mode || "replace").toLowerCase();
+    if (!["replace", "copy"].includes(mode)) {
+      throw new Error(`Unsupported template update mode "${mode}"`);
+    }
 
-function deriveTemplateState(def, template) {
-  const nowIso = new Date().toISOString();
-  const currentFingerprint = computeWorkflowFingerprint(def);
-  const templateFingerprint = computeWorkflowFingerprint(template);
-  const previousState = def?.metadata?.templateState || {};
+    const existing = engine.get(workflowId);
+    if (!existing) throw new Error(`Workflow "${workflowId}" not found`);
+    const templateId = String(existing?.metadata?.installedFrom || "").trim();
+    if (!templateId) throw new Error(`Workflow "${workflowId}" is not template-backed`);
+    const template = getTemplate(templateId);
+    if (!template) throw new Error(`Template "${templateId}" not found`);
+
+    const hydrated = applyWorkflowTemplateState(existing);
+    if (mode === "replace" && hydrated?.metadata?.templateState?.isCustomized && opts.force !== true) {
+      throw new Error("Workflow has custom changes; pass force=true to replace it");
+    }
 
-  const installedTemplateFingerprint = typeof previousState.installedTemplateFingerprint === "string"
-    ? previousState.installedTemplateFingerprint
-    : (currentFingerprint === templateFingerprint ? templateFingerprint : null);
+    const next = makeUpdatedWorkflowFromTemplate(hydrated, template, mode);
+    return engine.save(next);
+  }
 
-  const installedFingerprint = typeof previousState.installedFingerprint === "string"
-    ? previousState.installedFingerprint
-    : currentFingerprint;
+  function reconcileInstalledTemplates(engine, opts = {}) {
+    const autoUpdateUnmodified = opts.autoUpdateUnmodified !== false;
+    const forceUpdateTemplateIds = new Set(
+      (Array.isArray(opts.forceUpdateTemplateIds)
+        ? opts.forceUpdateTemplateIds
+        : [opts.forceUpdateTemplateIds])
+        .map((value) => String(value || "").trim())
+        .filter(Boolean),
+    );
+    const workflows = engine.list();
+    const result = {
+      scanned: 0,
+      metadataUpdated: 0,
+      autoUpdated: 0,
+      forceUpdated: [],
+      updateAvailable: [],
+      customized: [],
+      updatedWorkflowIds: [],
+      errors: [],
+    };
 
-  const isCustomized = currentFingerprint !== installedFingerprint;
-  const updateAvailable = installedTemplateFingerprint
-    ? installedTemplateFingerprint !== templateFingerprint
-    : false;
+    for (const summary of workflows) {
+      const wfId = summary?.id;
+      if (!wfId) continue;
+      const def = engine.get(wfId);
+      if (!def?.metadata?.installedFrom) continue;
+      result.scanned += 1;
+
+      try {
+        const previousState = def.metadata?.templateState || null;
+        const before = stableStringify(previousState);
+        applyWorkflowTemplateState(def);
+        const state = def.metadata?.templateState || null;
+        const after = stableStringify(state);
+        if (before !== after) {
+          engine.save(def);
+          result.metadataUpdated += 1;
+        }
+
+        if (!state) continue;
+        if (state.isCustomized) {
+          result.customized.push({
+            workflowId: def.id,
+            name: def.name,
+            templateId: state.templateId,
+            updateAvailable: state.updateAvailable === true,
+          });
+        }
+        if (state.updateAvailable === true) {
+          result.updateAvailable.push({
+            workflowId: def.id,
+            name: def.name,
+            templateId: state.templateId,
+            isCustomized: state.isCustomized === true,
+          });
+        }
+
+        const templateId = String(state.templateId || "").trim();
+        const shouldForceUpdate = templateId && forceUpdateTemplateIds.has(templateId);
+        if (shouldForceUpdate) {
+          const saved = updateWorkflowFromTemplate(engine, def.id, { mode: "replace", force: true });
+          result.autoUpdated += 1;
+          result.updatedWorkflowIds.push(saved.id);
+          result.forceUpdated.push(saved.id);
+          continue;
+        }
+
+        const wasCustomized = previousState?.isCustomized === true;
+        if (autoUpdateUnmodified && state.updateAvailable === true && !wasCustomized) {
+          const saved = updateWorkflowFromTemplate(engine, def.id, { mode: "replace", force: true });
+          result.autoUpdated += 1;
+          result.updatedWorkflowIds.push(saved.id);
+        }
+      } catch (err) {
+        result.errors.push({
+          workflowId: wfId,
+          error: err.message,
+        });
+      }
+    }
+
+    return result;
+  }
 
   return {
-    stateVersion: TEMPLATE_STATE_VERSION,
-    templateId: template.id,
-    templateName: template.name,
-    templateVersion: templateFingerprint.slice(0, 12),
-    templateFingerprint,
-    installedTemplateFingerprint,
-    installedTemplateVersion: installedTemplateFingerprint
-      ? installedTemplateFingerprint.slice(0, 12)
-      : null,
-    installedFingerprint,
-    currentFingerprint,
-    isCustomized,
-    updateAvailable,
-    refreshedAt: nowIso,
+    applyWorkflowTemplateState,
+    computeWorkflowFingerprint,
+    reconcileInstalledTemplates,
+    updateWorkflowFromTemplate,
   };
 }
 
-export function applyWorkflowTemplateState(def = {}) {
+
+function cloneTemplateDefinition(template) {
+  return JSON.parse(JSON.stringify(template));
+}
+
+function relayoutWorkflowDefinition(def = {}) {
   if (!def || typeof def !== "object") return def;
-  const templateId = String(def?.metadata?.installedFrom || "").trim();
-  if (!templateId) return def;
-  const template = getTemplate(templateId);
-  if (!template) return def;
-  if (!def.metadata || typeof def.metadata !== "object") def.metadata = {};
-  def.metadata.templateState = deriveTemplateState(def, template);
+  normalizeTemplateLayoutInPlace(def);
+  applyWorkflowTemplateState(def);
   return def;
 }
 
-function makeUpdatedWorkflowFromTemplate(existing, template, mode = "replace") {
-  const templateClone = cloneTemplateDefinition(template);
-  const nowIso = new Date().toISOString();
-  const mergedVariables = {
-    ...(templateClone.variables || {}),
-    ...(existing.variables || {}),
-  };
-  const next = {
-    ...templateClone,
-    id: mode === "copy" ? randomUUID() : existing.id,
-    name: mode === "copy" ? `${existing.name} (Updated)` : existing.name,
-    enabled: existing.enabled !== false,
-    variables: mergedVariables,
-    metadata: {
-      ...(existing.metadata || {}),
-      ...(templateClone.metadata || {}),
-      installedFrom: template.id,
-      templateUpdatedAt: nowIso,
-    },
-  };
-  delete next.metadata.templateState;
-  if (mode === "copy") {
-    next.metadata.createdAt = nowIso;
-    next.metadata.updatedAt = nowIso;
+function normalizeRelayoutWorkflowIdInput(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry || "").trim()).filter(Boolean);
   }
-  return applyWorkflowTemplateState(next);
+  const id = String(value || "").trim();
+  return id ? [id] : [];
 }
 
-export function updateWorkflowFromTemplate(engine, workflowId, opts = {}) {
-  const mode = String(opts.mode || "replace").toLowerCase();
-  if (!["replace", "copy"].includes(mode)) {
-    throw new Error(`Unsupported template update mode "${mode}"`);
+function resolveRelayoutWorkflowTargets(engine, requestedIds = []) {
+  const targets = new Set();
+  for (const requestedId of requestedIds) {
+    const normalizedId = String(requestedId || "").trim();
+    if (!normalizedId) continue;
+    const resolved = engine.get(normalizedId);
+    if (resolved?.id) {
+      targets.add(String(resolved.id).trim());
+      continue;
+    }
+    targets.add(normalizedId);
   }
-  const existing = engine.get(workflowId);
-  if (!existing) throw new Error(`Workflow "${workflowId}" not found`);
-  const templateId = String(existing?.metadata?.installedFrom || "").trim();
-  if (!templateId) throw new Error(`Workflow "${workflowId}" is not template-backed`);
-  const template = getTemplate(templateId);
-  if (!template) throw new Error(`Template "${templateId}" not found`);
+  return targets;
+}
 
-  const hydrated = applyWorkflowTemplateState(existing);
-  if (mode === "replace" && hydrated?.metadata?.templateState?.isCustomized && opts.force !== true) {
-    throw new Error("Workflow has custom changes; pass force=true to replace it");
+export function relayoutInstalledTemplateWorkflows(engine, opts = {}) {
+  if (!engine || typeof engine.list !== "function" || typeof engine.get !== "function" || typeof engine.save !== "function") {
+    throw new Error("A workflow engine with list/get/save is required");
   }
 
-  const next = makeUpdatedWorkflowFromTemplate(hydrated, template, mode);
-  return engine.save(next);
-}
-
-export function reconcileInstalledTemplates(engine, opts = {}) {
-  const autoUpdateUnmodified = opts.autoUpdateUnmodified !== false;
-  const forceUpdateTemplateIds = new Set(
-    (Array.isArray(opts.forceUpdateTemplateIds)
-      ? opts.forceUpdateTemplateIds
-      : [opts.forceUpdateTemplateIds])
-      .map((value) => String(value || "").trim())
-      .filter(Boolean),
+  const targetWorkflowIds = resolveRelayoutWorkflowTargets(
+    engine,
+    normalizeRelayoutWorkflowIdInput(opts.workflowIds || opts.workflowId),
   );
-  const workflows = engine.list();
   const result = {
     scanned: 0,
-    metadataUpdated: 0,
-    autoUpdated: 0,
-    forceUpdated: [],
-    updateAvailable: [],
-    customized: [],
+    updated: 0,
+    skipped: 0,
     updatedWorkflowIds: [],
+    skippedWorkflowIds: [],
     errors: [],
   };
 
-  for (const summary of workflows) {
-    const wfId = summary?.id;
-    if (!wfId) continue;
-    const def = engine.get(wfId);
-    if (!def?.metadata?.installedFrom) continue;
+  for (const summary of engine.list()) {
+    const workflowId = String(summary?.id || "").trim();
+    if (!workflowId) continue;
+    if (targetWorkflowIds.size > 0 && !targetWorkflowIds.has(workflowId)) continue;
     result.scanned += 1;
 
     try {
-      const previousState = def.metadata?.templateState || null;
-      const before = stableStringify(previousState);
-      applyWorkflowTemplateState(def);
-      const state = def.metadata?.templateState || null;
-      const after = stableStringify(state);
-      if (before !== after) {
-        engine.save(def);
-        result.metadataUpdated += 1;
-      }
-
-      if (!state) continue;
-      if (state.isCustomized) {
-        result.customized.push({
-          workflowId: def.id,
-          name: def.name,
-          templateId: state.templateId,
-          updateAvailable: state.updateAvailable === true,
-        });
-      }
-      if (state.updateAvailable === true) {
-        result.updateAvailable.push({
-          workflowId: def.id,
-          name: def.name,
-          templateId: state.templateId,
-          isCustomized: state.isCustomized === true,
-        });
-      }
-
-      const templateId = String(state.templateId || "").trim();
-      const shouldForceUpdate = templateId && forceUpdateTemplateIds.has(templateId);
-      if (shouldForceUpdate) {
-        const saved = updateWorkflowFromTemplate(engine, def.id, { mode: "replace", force: true });
-        result.autoUpdated += 1;
-        result.updatedWorkflowIds.push(saved.id);
-        result.forceUpdated.push(saved.id);
+      const def = engine.get(workflowId);
+      if (!def?.metadata?.installedFrom) {
+        result.skipped += 1;
+        result.skippedWorkflowIds.push(workflowId);
         continue;
       }
-
-      const wasCustomized = previousState?.isCustomized === true;
-      if (autoUpdateUnmodified && state.updateAvailable === true && !wasCustomized) {
-        const saved = updateWorkflowFromTemplate(engine, def.id, { mode: "replace", force: true });
-        result.autoUpdated += 1;
-        result.updatedWorkflowIds.push(saved.id);
-      }
+      relayoutWorkflowDefinition(def);
+      engine.save(def);
+      result.updated += 1;
+      result.updatedWorkflowIds.push(workflowId);
     } catch (err) {
-      result.errors.push({
-        workflowId: wfId,
-        error: err.message,
-      });
+      result.errors.push({ workflowId, error: err.message });
     }
   }
 
   return result;
 }
 
-/**
- * Setup workflow profiles used by `bosun --setup`.
- * - `manual`: human-driven dispatch with reliability safety nets.
- * - `balanced`: recommended default for most teams.
- * - `autonomous`: higher automation with planning + maintenance workflows.
- */
 export const WORKFLOW_SETUP_PROFILES = Object.freeze({
   manual: Object.freeze({
     id: "manual",
@@ -788,6 +888,21 @@ export function getTemplate(id) {
   return _TEMPLATE_BY_ID.get(id) || null;
 }
 
+const {
+  applyWorkflowTemplateState,
+  computeWorkflowFingerprint,
+  reconcileInstalledTemplates,
+  updateWorkflowFromTemplate,
+} = createWorkflowTemplateState({ getTemplate, cloneTemplateDefinition });
+
+export {
+  applyWorkflowTemplateState,
+  computeWorkflowFingerprint,
+  reconcileInstalledTemplates,
+  updateWorkflowFromTemplate,
+};
+
+
 // ── Grouped Flows ──────────────────────────────────────────────────────────
 // Templates that use action.execute_workflow to chain into other templates
 // declare metadata.requiredTemplates. When one template in a group is
@@ -1275,3 +1390,10 @@ export function installRecommendedTemplates(engine, overridesById = {}) {
     .map((template) => template.id);
   return installTemplateSet(engine, recommendedIds, overridesById);
 }
+
+
+
+
+
+
+