@deksden-com/dd-flow-cli 0.2.0 → 0.3.1

package/dist/services/protocol-lifecycle.js

@@ -0,0 +1,144 @@
+import { defaultFlowContract, flowContractForState, normalizeStage } from "../domain/flow-contract.js";
+export function normalizeProtocolLifecycle(input) {
+    const source = input.state ? "runtime_state" : input.rawStage || input.rawStatus ? "protocol_record" : "missing";
+    const contract = input.flowContract ?? (input.state ? flowContractForState(input.state) : defaultFlowContract);
+    const rawStage = nonEmpty(input.state?.stage) ?? nonEmpty(input.rawStage) ?? "unregistered";
+    const rawStatus = nonEmpty(input.state?.status) ?? nonEmpty(input.rawStatus) ?? "unknown";
+    const normalizedRawStage = safeNormalizeStage(rawStage, contract);
+    const diagnostics = [];
+    const mapped = mapLegacyLifecycle(normalizedRawStage, rawStatus, input.queueStatus ?? null, contract);
+    if (normalizedRawStage !== rawStage) {
+        diagnostics.push({
+            code: "lifecycle_legacy_alias_normalized",
+            severity: "info",
+            raw_stage: rawStage,
+            normalized_stage: normalizedRawStage
+        });
+    }
+    if (mapped.stage === "unknown") {
+        diagnostics.push({
+            code: "lifecycle_stage_unknown",
+            severity: "warning",
+            raw_stage: rawStage,
+            raw_status: rawStatus
+        });
+    }
+    if (["blocked", "waiting_for_user"].includes(normalizedRawStage) && !mapped.status_reason) {
+        diagnostics.push({
+            code: "lifecycle_return_stage_missing",
+            severity: "warning",
+            raw_stage: rawStage,
+            summary: `${normalizedRawStage} is a status-like legacy stage without explicit return_to_stage metadata.`
+        });
+    }
+    return {
+        flow: nonEmpty(input.flow) ?? "mb_sdlc",
+        stage: mapped.stage,
+        substage: mapped.substage,
+        status: mapped.status,
+        status_reason: mapped.status_reason,
+        terminal: mapped.terminal,
+        legacy_stage: mapped.legacy_stage,
+        legacy_status: mapped.legacy_status,
+        raw_stage: rawStage,
+        raw_status: rawStatus,
+        queue_status: input.queueStatus ?? null,
+        source,
+        diagnostics
+    };
+}
+export function lifecycleIsTerminalSuccess(lifecycle) {
+    return lifecycle.terminal && lifecycle.status === "done";
+}
+export function lifecycleIsTerminalFailure(lifecycle) {
+    return lifecycle.terminal && ["cancelled", "failed"].includes(lifecycle.status);
+}
+export function lifecycleLegacyStage(lifecycle) {
+    return lifecycle.legacy_stage ?? lifecycle.raw_stage;
+}
+function mapLegacyLifecycle(stage, rawStatus, queueStatus, contract) {
+    if (stage === "registered") {
+        return mapped("protocol", null, "registered", "registered", rawStatus, false);
+    }
+    if (stage === "priming" || stage === "prime") {
+        return mapped("specify", "priming", statusFromRaw(rawStatus, "in_progress"), stage, rawStatus, false);
+    }
+    if (stage === "specify") {
+        return mapped("specify", null, statusFromRaw(rawStatus, "in_progress"), null, null, false);
+    }
+    if (stage === "plan") {
+        return mapped("plan", null, statusFromRaw(rawStatus, "in_progress"), null, null, false);
+    }
+    if (stage === "implementation") {
+        return mapped("code", "implementation", statusFromRaw(rawStatus, "in_progress"), "implementation", rawStatus, false);
+    }
+    if (stage === "readiness") {
+        return mapped("code", "readiness", rawStatus === "running" ? "readiness" : statusFromRaw(rawStatus, "readiness"), "readiness", rawStatus, false);
+    }
+    if (stage === "ready_for_merge") {
+        const status = queueStatus && ["ready", "requeued"].includes(queueStatus) ? "ready_for_merge" : "ready_for_merge";
+        return mapped("code", null, status, "ready_for_merge", rawStatus, false);
+    }
+    if (stage === "queued_for_merge") {
+        return mapped("merge", null, queueStatus === "claimed" ? "claimed" : "queued", "queued_for_merge", rawStatus, false);
+    }
+    if (stage === "integration") {
+        return mapped("merge", "integration", queueStatus === "claimed" ? "in_progress" : statusFromRaw(rawStatus, "in_progress"), "integration", rawStatus, false);
+    }
+    if (stage === "blocked") {
+        return mapped("unknown", null, "blocked", "blocked", rawStatus, false);
+    }
+    if (stage === "waiting_for_user") {
+        return mapped("unknown", null, "waiting_for_user", "waiting_for_user", rawStatus, false);
+    }
+    if (stage === "closed") {
+        return mapped("closed", null, "done", "closed", rawStatus, true);
+    }
+    if (stage === "cancelled") {
+        return mapped("closed", null, "cancelled", "cancelled", rawStatus, true);
+    }
+    if (contract.stages[stage]?.terminal) {
+        return mapped(stage, null, statusFromRaw(rawStatus, "done"), stage, rawStatus, true);
+    }
+    if (contract.stages[stage]) {
+        return mapped(stage, null, statusFromRaw(rawStatus, "in_progress"), null, null, false);
+    }
+    return mapped("unknown", null, statusFromRaw(rawStatus, "unknown"), stage, rawStatus, false);
+}
+function mapped(stage, substage, status, legacyStage, legacyStatus, terminal) {
+    return {
+        stage,
+        substage,
+        status,
+        status_reason: null,
+        terminal,
+        legacy_stage: legacyStage,
+        legacy_status: legacyStatus
+    };
+}
+function statusFromRaw(rawStatus, fallback) {
+    if (rawStatus === "running")
+        return fallback;
+    if (rawStatus === "closed")
+        return "done";
+    if (rawStatus === "registered")
+        return "registered";
+    if (rawStatus === "waiting_user")
+        return "waiting_for_user";
+    if (rawStatus === "active")
+        return "in_progress";
+    if (rawStatus === "unknown")
+        return fallback;
+    return rawStatus || fallback;
+}
+function safeNormalizeStage(stage, contract) {
+    try {
+        return normalizeStage(stage, contract);
+    }
+    catch {
+        return stage;
+    }
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}