@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/release-4ZJTMUUT.js

@@ -0,0 +1,524 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/release.ts
+import { release as release2 } from "@cleocode/core";
+
+// packages/cleo/src/cli/commands/release/ship-e2e-smoke.ts
+import { release } from "@cleocode/core";
+var shipE2eSmokeCommand = defineCommand({
+  meta: {
+    name: "ship-e2e-smoke",
+    description: "One-shot end-to-end release smoke: plan \u2192 open \u2192 wait-for-PR \u2192 wait-for-tag \u2192 verify-npm-published. Dry-run by default; pass --execute to perform real mutations (T10103)."
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Candidate release version (e.g. v2026.6.0 or 2026.6.0)",
+      required: true
+    },
+    epic: {
+      type: "string",
+      description: "Epic task ID (forwarded to release plan)",
+      required: true
+    },
+    execute: {
+      type: "boolean",
+      description: "Actually perform mutations (default: dry-run preview only)"
+    },
+    "poll-interval-ms": {
+      type: "string",
+      description: "Polling interval for wait-* steps (default 5000)"
+    },
+    "total-timeout-ms": {
+      type: "string",
+      description: "Wall-clock budget across all polling waits (default 1800000 = 30 min)"
+    }
+  },
+  async run({ args }) {
+    const pollIntervalMs = args["poll-interval-ms"] ? Number.parseInt(args["poll-interval-ms"], 10) : void 0;
+    const totalTimeoutMs = args["total-timeout-ms"] ? Number.parseInt(args["total-timeout-ms"], 10) : void 0;
+    const params = {
+      version: args.version,
+      epicId: args.epic,
+      execute: args.execute === true,
+      ...pollIntervalMs !== void 0 ? { pollIntervalMs } : {},
+      ...totalTimeoutMs !== void 0 ? { totalTimeoutMs } : {}
+    };
+    const env = release.createDefaultSmokeEnvironment();
+    const result = await release.runShipE2eSmoke(params, env);
+    if (result.success) {
+      cliOutput(result, { command: "release", operation: "release.ship-e2e-smoke" });
+      return;
+    }
+    const failed = result.steps.find((s) => s.status === "failed");
+    cliError(
+      `ship-e2e-smoke step "${failed?.name ?? "unknown"}" failed: ${failed?.error ?? "see envelope"}`,
+      "E_SHIP_E2E_SMOKE_FAILED",
+      { name: "E_SHIP_E2E_SMOKE_FAILED", details: result },
+      { operation: "release.ship-e2e-smoke" }
+    );
+    process.exit(1);
+  }
+});
+
+// packages/cleo/src/cli/commands/release.ts
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all releases" },
+  async run() {
+    await dispatchFromCli("query", "pipeline", "release.list", {}, { command: "release" });
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show release details" },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version to show",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "release.show",
+      { version: args.version },
+      { command: "release" }
+    );
+  }
+});
+var cancelCommand = defineCommand({
+  meta: {
+    name: "cancel",
+    description: "Cancel and remove a release in draft or prepared state"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version to cancel",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "release.cancel",
+      { version: args.version },
+      { command: "release" }
+    );
+  }
+});
+var rollbackCommand = defineCommand({
+  meta: {
+    name: "rollback",
+    description: "Roll back a shipped release (marks it as rolled-back in CLEO records)"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version to roll back",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Reason for rollback"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "release.rollback",
+      {
+        version: args.version,
+        reason: args.reason
+      },
+      { command: "release" }
+    );
+  }
+});
+var rollbackFullCommand = defineCommand({
+  meta: {
+    name: "rollback-full",
+    description: "Full rollback: delete git tag, revert commit, remove release record"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version to fully roll back (e.g. 2026.4.77)",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Reason for rollback"
+    },
+    force: {
+      type: "boolean",
+      description: "Continue even if some git operations fail"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "release.rollback.full",
+      {
+        version: args.version,
+        reason: args.reason,
+        force: args.force
+      },
+      { command: "release" }
+    );
+  }
+});
+var prStatusCommand = defineCommand({
+  meta: {
+    name: "pr-status",
+    description: "Poll CI check status for an in-progress release PR (T9095)"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version (e.g. 2026.5.43)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "release.pr-status",
+      { version: args.version },
+      { command: "release" }
+    );
+  }
+});
+var channelCommand = defineCommand({
+  meta: {
+    name: "channel",
+    description: "Show the current release channel based on git branch (latest/beta/alpha)"
+  },
+  async run() {
+    await dispatchFromCli("query", "pipeline", "release.channel.show", {}, { command: "release" });
+  }
+});
+var validateChangelogCommand = defineCommand({
+  meta: {
+    name: "validate-changelog",
+    description: "Validate that CHANGELOG.md contains the canonical `## [VERSION]` header (T9937)"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version (accepts v2026.5.94 or 2026.5.94)",
+      required: true
+    },
+    path: {
+      type: "string",
+      description: "Override the CHANGELOG file path (default: <projectRoot>/CHANGELOG.md)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "release",
+      "validate-changelog",
+      {
+        version: args.version,
+        ...typeof args.path === "string" && args.path.length > 0 ? { changelogPath: args.path } : {}
+      },
+      { command: "release" }
+    );
+  }
+});
+var READINESS_GATE_EXIT_CODE = 6;
+var planCommand = defineCommand({
+  meta: {
+    name: "plan",
+    description: "Build the canonical Release Plan envelope and persist status=planned (T9525)"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Candidate release version (e.g. v2026.6.0 or 2026.6.0)",
+      required: true
+    },
+    epic: {
+      type: "string",
+      description: "Epic task ID \u2014 children (or leaf Epic itself per ADR-073) are candidates",
+      required: false
+    },
+    saga: {
+      type: "string",
+      description: "Saga task ID \u2014 walks task_relations type=groups to aggregate member Epics (ADR-073). Mutually exclusive with --epic/--tasks. (T9838)",
+      required: false
+    },
+    tasks: {
+      type: "string",
+      description: "Explicit task-list release scope (comma- or space-separated, e.g. --tasks T9961,T9962 or --tasks T9961 --tasks T9962). Mutually exclusive with --epic/--saga. (T10088)",
+      required: false
+    },
+    scheme: {
+      type: "string",
+      description: "Versioning scheme: calver | semver | calver-suffix"
+    },
+    channel: {
+      type: "string",
+      description: "Release channel: latest | beta | alpha | rc"
+    },
+    hotfix: {
+      type: "boolean",
+      description: "Mark plan as release_kind=hotfix"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Compute plan + envelope without writing the plan file or DB row"
+    },
+    "no-changelog": {
+      type: "boolean",
+      description: "Skip CHANGELOG.md auto-write (default: write/replace the ## [<version>] section). (T9838)"
+    },
+    "skip-readiness": {
+      type: "boolean",
+      description: "Skip the release-readiness preflight check (default: run check). Use only in emergency. (T10459)"
+    }
+  },
+  async run({ args }) {
+    if (args["skip-readiness"] !== true) {
+      const { runSpawnReadinessHygieneCli } = await import("@cleocode/core/hygiene/validate-spawn-readiness.js");
+      const readiness = await runSpawnReadinessHygieneCli();
+      if (readiness.hasBlockingFailure) {
+        const failed = readiness.gates.filter((g) => !g.passed && g.severity === "error");
+        const timedOut = failed.filter((g) => g.reason === "timeout").map((g) => g.name);
+        cliError(
+          `Release readiness failed: ${readiness.blockingGates.join(", ")}. No plan was written.`,
+          READINESS_GATE_EXIT_CODE,
+          {
+            name: "E_READINESS_GATE_FAILED",
+            // gh#1367: a gate that timed out found nothing wrong — telling the
+            // operator to go repair the artifact would send them after a defect
+            // that does not exist.
+            fix: timedOut.length > 0 ? `${timedOut.join(", ")} timed out rather than finding a problem \u2014 re-run, raise the gate timeout, or pass --skip-readiness.` : "Fix the gates listed above, or pass --skip-readiness to bypass the preflight (emergency use only).",
+            details: {
+              gates: failed.map((g) => ({
+                name: g.name,
+                reason: g.reason ?? "validation",
+                message: g.message
+              })),
+              checkedAt: readiness.checkedAt
+            }
+          },
+          { operation: "release.plan" }
+        );
+        process.exit(READINESS_GATE_EXIT_CODE);
+      }
+    }
+    await dispatchFromCli(
+      "mutate",
+      "release",
+      "plan",
+      {
+        version: args.version,
+        epicId: args.epic,
+        sagaId: args.saga,
+        taskIds: parseTaskScopeArg(args.tasks),
+        scheme: args.scheme,
+        channel: args.channel,
+        hotfix: args.hotfix === true,
+        dryRun: args["dry-run"] === true,
+        writeChangelog: !negatedFlag(args, "changelog")
+      },
+      { command: "release" }
+    );
+  }
+});
+function parseTaskScopeArg(value) {
+  const raw = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  const taskIds = raw.flatMap(
+    (part) => String(part).split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  return taskIds.length > 0 ? taskIds : void 0;
+}
+var openCommand = defineCommand({
+  meta: {
+    name: "open",
+    description: "Dispatch release-prepare workflow + transition releases.status to pr-opened"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version (e.g. v2026.6.0)",
+      required: true
+    },
+    workflow: {
+      type: "string",
+      description: "Workflow file to dispatch (default: release-prepare.yml)"
+    },
+    watch: {
+      type: "boolean",
+      description: "Poll gh run watch until the run reaches a terminal state"
+    },
+    "commit-plan": {
+      type: "boolean",
+      description: "Commit the plan file to the active branch before dispatching (DEFAULT). The workflow cannot regenerate a task- or epic-scoped plan on the runner \u2014 the task store is untracked \u2014 so the committed plan is the only path that can succeed (T12309). After a release-plan PR has merged, pass --no-commit-plan: the plan on the default branch is verified (read from there when this checkout lacks it) and dispatched by its sha256 (T13050). Either way the dispatch carries the verified preflight skips (T13140).",
+      default: true
+    },
+    // T12089: the workflow regenerates the plan when no committed plan is
+    // supplied, and `cleo release plan` requires a scope — so one of these must
+    // ride along or the dispatched run dies at "Prepare bump-PR".
+    epic: {
+      type: "string",
+      description: "Epic task ID forwarded as the plan scope (e.g. T9999)"
+    },
+    tasks: {
+      type: "string",
+      description: "Comma-separated task IDs forwarded as the plan scope (task-scoped release)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "release",
+      "open",
+      {
+        version: args.version,
+        workflow: args.workflow,
+        watch: args.watch === true,
+        // citty synthesises `--no-commit-plan` for a boolean with `default: true`
+        // and delivers it as `commit-plan: false`, so the negation needs no arg
+        // of its own — declaring one listed it twice in `--help`.
+        commitPlan: args["commit-plan"] !== false,
+        epic: args.epic,
+        tasks: args.tasks
+      },
+      { command: "release" }
+    );
+  }
+});
+var reconcileCommand = defineCommand({
+  meta: {
+    name: "reconcile",
+    description: "Reconcile a published release: backfill the 11 provenance tables"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Version string (e.g. v2026.6.0)",
+      required: true
+    },
+    "from-workflow": {
+      type: "boolean",
+      description: "Indicates invocation from release-publish.yml (affects logging only)"
+    },
+    rollback: {
+      type: "boolean",
+      description: "Reconcile a rollback rather than a publish (deferred to T9528)"
+    },
+    /**
+     * T11977 / DHQ-080: tag-driven path dry-run.
+     *
+     * When the release plan file is absent (tag-driven publish with no prior
+     * `cleo release plan`), `--dry-run` synthesises the minimal plan from the
+     * git tag + CHANGELOG.md + merged-PR history and prints the derivation
+     * WITHOUT writing to the DB. Safe to run against the live project — produces
+     * no side effects.
+     */
+    "dry-run": {
+      type: "boolean",
+      description: "On tag-driven path (no plan file): synthesise and print the plan derivation without writing to DB"
+    },
+    json: { type: "boolean", description: "Emit LAFS envelope" }
+  },
+  async run({ args }) {
+    const result = await release2.releaseReconcileV2(args.version, {
+      fromWorkflow: args["from-workflow"] === true,
+      rollback: args.rollback === true,
+      dryRun: args["dry-run"] === true
+    });
+    if (result.success) {
+      cliOutput(result.data, { command: "release", operation: "release.reconcile" });
+      return;
+    }
+    cliError(
+      result.error.message,
+      result.error.code,
+      {
+        name: result.error.code,
+        ...result.error.details ? { details: result.error.details } : {},
+        ...result.error.fix ? { fix: result.error.fix } : {}
+      },
+      { operation: "release.reconcile" }
+    );
+    process.exit(1);
+  }
+});
+var releaseCommand = defineCommand({
+  meta: {
+    name: "release",
+    description: "Release lifecycle management \u2014 4-verb pipeline: plan \u2192 open \u2192 reconcile / rollback. Use `ship-e2e-smoke` for end-to-end validation (dry-run by default)."
+  },
+  subCommands: {
+    // Canonical SPEC-T9345 4-verb pipeline — list these first so `--help`
+    // surfaces them as the documented default.
+    plan: planCommand,
+    open: openCommand,
+    reconcile: reconcileCommand,
+    rollback: rollbackCommand,
+    // End-to-end smoke walker — see docs/release/verb-matrix.md.
+    "ship-e2e-smoke": shipE2eSmokeCommand,
+    // Read-only helpers — not deprecated.
+    list: listCommand,
+    show: showCommand,
+    cancel: cancelCommand,
+    "pr-status": prStatusCommand,
+    channel: channelCommand,
+    "rollback-full": rollbackFullCommand,
+    // T9937 — canonical CHANGELOG.md header validator (Saga T9862).
+    "validate-changelog": validateChangelogCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  releaseCommand
+};
+//# sourceMappingURL=release-4ZJTMUUT.js.map