@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/relates-6FWUFUS2.js

@@ -0,0 +1,260 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/relates.ts
+import { readFile } from "node:fs/promises";
+var suggestCommand = defineCommand({
+  meta: { name: "suggest", description: "Suggest related tasks based on shared attributes" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to find suggestions for",
+      required: true
+    },
+    threshold: {
+      type: "string",
+      description: "Minimum similarity threshold (0-100)",
+      default: "50"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "relates",
+      {
+        taskId: args.taskId,
+        mode: "suggest",
+        threshold: Number(args.threshold)
+      },
+      { command: "relates" }
+    );
+  }
+});
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add a relates entry to a task. Valid types: blocks|related|duplicates|absorbs|fixes|extends|supersedes"
+  },
+  args: {
+    from: {
+      type: "positional",
+      description: "Source task ID",
+      required: true
+    },
+    to: {
+      type: "positional",
+      description: "Target task ID",
+      required: true
+    },
+    type: {
+      type: "positional",
+      description: "Relationship type (blocks|related|duplicates|absorbs|fixes|extends|supersedes)",
+      required: true
+    },
+    reason: {
+      type: "positional",
+      description: "Reason for the relationship",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "relates.add",
+      { taskId: args.from, relatedId: args.to, type: args.type, reason: args.reason },
+      { command: "relates" }
+    );
+  }
+});
+var addBatchCommand = defineCommand({
+  meta: {
+    name: "add-batch",
+    description: "Add multiple advisory relation edges from JSON. Accepts {relations:[...]} or {edges:[...]}; use --dry-run to preview."
+  },
+  args: {
+    file: {
+      type: "string",
+      description: "JSON file path, or - for stdin",
+      required: true
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Validate and print what would be created without writing",
+      required: false
+    },
+    reasonWaiver: {
+      type: "string",
+      description: "Explicit audit waiver text for edges without per-edge reasons",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const input = args.file === "-" ? await new Promise((resolve, reject) => {
+      let data = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => resolve(data));
+      process.stdin.on("error", reject);
+    }) : await readFile(args.file, "utf8");
+    const parsed = JSON.parse(input);
+    const payload = Array.isArray(parsed) ? { relations: parsed } : parsed;
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "relates.add-batch",
+      { ...payload, dryRun: args.dryRun, reasonWaiver: args.reasonWaiver },
+      { command: "relates" }
+    );
+  }
+});
+var discoverCommand = defineCommand({
+  meta: { name: "discover", description: "Discover related tasks using various methods" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to discover relations for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "relates",
+      {
+        taskId: args.taskId,
+        mode: "discover"
+      },
+      { command: "relates" }
+    );
+  }
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Remove a relates entry between two tasks"
+  },
+  args: {
+    from: {
+      type: "positional",
+      description: "Source task ID",
+      required: true
+    },
+    to: {
+      type: "positional",
+      description: "Target task ID",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Relation type to remove (omit to remove any type)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "relates.remove",
+      { taskId: args.from, relatedId: args.to, type: args.type },
+      { command: "relates" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "Show existing relates entries for a task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to list relations for",
+      required: true
+    },
+    type: {
+      type: "string",
+      description: "Filter by relation type (or depends/depends_on)",
+      required: false
+    },
+    direction: {
+      type: "string",
+      description: "Filter direction: out|in|both (default: both)",
+      default: "both",
+      required: false
+    },
+    noDepends: {
+      type: "boolean",
+      description: "Hide scheduler dependency edges from relation list output",
+      required: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "relates",
+      {
+        taskId: args.taskId,
+        type: args.type,
+        direction: args.direction,
+        includeDependencies: !negatedFlag(args, "depends")
+      },
+      { command: "relates" }
+    );
+  }
+});
+var relatesCommand = defineCommand({
+  meta: {
+    name: "relates",
+    description: "Semantic relationship discovery and management between tasks"
+  },
+  subCommands: {
+    suggest: suggestCommand,
+    add: addCommand,
+    "add-batch": addBatchCommand,
+    remove: removeCommand,
+    discover: discoverCommand,
+    list: listCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  relatesCommand
+};
+//# sourceMappingURL=relates-6FWUFUS2.js.map

package/dist/cli/release-G2DPSG5M.js

@@ -0,0 +1,347 @@
+(() => {
+  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 {
+  errorResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/release.ts
+import { getLogger, getProjectRoot, resolveWorktreeRouting } from "@cleocode/core/internal";
+import {
+  releaseGateCheck,
+  releaseIvtrAutoSuggest,
+  releaseOpen,
+  releasePlan,
+  releaseReconcileV2,
+  validateChangelog
+} from "@cleocode/runtime/gateway";
+var log = getLogger("domain:release");
+async function releaseGateOp(params) {
+  return releaseGateCheck(params.epicId, params.force ?? false, getProjectRoot());
+}
+async function releaseIvtrSuggestOp(params) {
+  return releaseIvtrAutoSuggest(params.taskId, getProjectRoot());
+}
+var coreOps = {
+  gate: releaseGateOp,
+  "ivtr-suggest": releaseIvtrSuggestOp
+};
+var ReleaseHandler = class {
+  // -----------------------------------------------------------------------
+  // query — read-only
+  // -----------------------------------------------------------------------
+  /**
+   * Handle read-only release queries.
+   *
+   * Supported operations:
+   * - `gate`         — check IVTR phase state for all tasks in a release epic
+   * - `ivtr-suggest` — check if all epic tasks are released and suggest `cleo release plan` + `cleo release open`
+   *
+   * The legacy `verify` query (run gates + audit child tasks) was removed
+   * in T9540 — use `cleo verify <task> --gate X --evidence …` per
+   * SPEC-T9345 §12 R-422 / ADR-051.
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        // release.gate — IVTR gate check (RELEASE-03)
+        case "gate": {
+          const epicId = typeof params?.epicId === "string" ? params.epicId : void 0;
+          if (!epicId)
+            return errorResult(
+              "query",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const force = typeof params?.force === "boolean" ? params.force : false;
+          const typed = { epicId, force };
+          return wrapResult(await coreOps.gate(typed), "query", "release", operation, startTime);
+        }
+        // release.ivtr-suggest — IVTR auto-suggest (RELEASE-07)
+        case "ivtr-suggest": {
+          const taskId = typeof params?.taskId === "string" ? params.taskId : void 0;
+          if (!taskId)
+            return errorResult(
+              "query",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          const typed = { taskId };
+          return wrapResult(
+            await coreOps["ivtr-suggest"](typed),
+            "query",
+            "release",
+            operation,
+            startTime
+          );
+        }
+        // release.validate-changelog — canonical CHANGELOG.md header validator
+        // (T9937 / Saga T9862). Replaces the brittle `grep -qF "## [VERSION]"`
+        // step in .github/workflows/release.yml. Read-only.
+        //
+        // The core verb returns a plain `ValidateChangelogResult` envelope
+        // (NOT an EngineResult discriminated union) so direct SDK consumers
+        // can branch on `result.valid`. At the dispatch boundary we translate
+        // `valid=false` into `E_CHANGELOG_MISSING_SECTION` so the CLI emits a
+        // non-zero exit code — exactly the behaviour CI workflows depend on
+        // (the legacy `grep -qF "## [VERSION]" || exit 1` had the same
+        // contract).
+        case "validate-changelog": {
+          const version = typeof params?.version === "string" ? params.version : void 0;
+          if (!version)
+            return errorResult(
+              "query",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "version is required",
+              startTime
+            );
+          const typed = {
+            version,
+            projectRoot: getProjectRoot(),
+            ...typeof params?.changelogPath === "string" ? { changelogPath: params.changelogPath } : {}
+          };
+          const validation = await validateChangelog(typed);
+          if (validation.valid) {
+            return wrapResult(
+              { success: true, data: validation },
+              "query",
+              "release",
+              operation,
+              startTime
+            );
+          }
+          return wrapResult(
+            {
+              success: false,
+              error: {
+                code: "E_CHANGELOG_MISSING_SECTION",
+                message: validation.reason ?? `CHANGELOG.md missing canonical header for v${validation.normalizedVersion}`,
+                details: {
+                  version: validation.version,
+                  normalizedVersion: validation.normalizedVersion,
+                  changelogPath: validation.changelogPath,
+                  headerFound: validation.headerFound
+                },
+                fix: `Run \`cleo release plan v${validation.normalizedVersion}\` locally to write the section, then re-push.`,
+                exitCode: 1
+              }
+            },
+            "query",
+            "release",
+            operation,
+            startTime
+          );
+        }
+        default:
+          return unsupportedOp("query", "release", operation, startTime);
+      }
+    } catch (err) {
+      log.error({ err, operation }, "ReleaseHandler query error");
+      return handleErrorResult("query", "release", operation, err, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // mutate — state-modifying
+  // -----------------------------------------------------------------------
+  /**
+   * Handle state-modifying release mutations.
+   *
+   * Note: `release.gate` and `release.ivtr-suggest` do not write any state.
+   * They are exposed in the `mutate` gateway to allow automated pipelines
+   * (e.g. playbook action blocks) to call them without changing gateway.
+   *
+   * Supported operations:
+   * - `gate`         — same IVTR gate check as query.gate (no DB writes)
+   * - `ivtr-suggest` — same auto-suggest as query.ivtr-suggest (no DB writes)
+   * - `plan`         — SPEC-T9345 §4.2 (T9525): build canonical Release Plan envelope
+   * - `open`         — SPEC-T9345 §4.3 (T9530): dispatch release-prepare workflow
+   * - `reconcile`    — SPEC-T9345 §4.4 (T9526 v2): backfill 11 provenance tables
+   *
+   * The legacy `start` / `publish` mutations (and the legacy v1
+   * `reconcile`) were removed in T9540 — their backing functions in
+   * `packages/core/src/release/pipeline.ts` were deleted as part of
+   * Phase 6 of T9499.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        // release.gate — IVTR gate check (RELEASE-03, no DB writes)
+        case "gate": {
+          const epicId = typeof params?.epicId === "string" ? params.epicId : void 0;
+          if (!epicId)
+            return errorResult(
+              "mutate",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "epicId is required",
+              startTime
+            );
+          const force = typeof params?.force === "boolean" ? params.force : false;
+          const typed = { epicId, force };
+          return wrapResult(await coreOps.gate(typed), "mutate", "release", operation, startTime);
+        }
+        // release.ivtr-suggest — IVTR auto-suggest (RELEASE-07, no DB writes)
+        case "ivtr-suggest": {
+          const taskId = typeof params?.taskId === "string" ? params.taskId : void 0;
+          if (!taskId)
+            return errorResult(
+              "mutate",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          const typed = { taskId };
+          return wrapResult(
+            await coreOps["ivtr-suggest"](typed),
+            "mutate",
+            "release",
+            operation,
+            startTime
+          );
+        }
+        // release.plan — SPEC-T9345 §4.2 (T9525): build canonical Release Plan envelope
+        // T9838/T10088: --saga/--tasks and --no-changelog flags forwarded; epicId no longer
+        // required at the dispatch layer — the core verb validates that
+        // exactly one scope selector is set.
+        case "plan": {
+          const version = typeof params?.version === "string" ? params.version : void 0;
+          const epicId = typeof params?.epicId === "string" ? params.epicId : void 0;
+          const sagaId = typeof params?.sagaId === "string" ? params.sagaId : void 0;
+          const taskIds = Array.isArray(params?.taskIds) ? params.taskIds.filter((id) => typeof id === "string" && id.length > 0) : void 0;
+          if (!version) {
+            return errorResult(
+              "mutate",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "version is required",
+              startTime
+            );
+          }
+          if (!epicId && !sagaId && !taskIds?.length) {
+            return errorResult(
+              "mutate",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "--saga, --epic, or --tasks is required",
+              startTime
+            );
+          }
+          const typed = {
+            version,
+            ...epicId ? { epicId } : {},
+            ...sagaId ? { sagaId } : {},
+            ...taskIds?.length ? { taskIds } : {},
+            scheme: typeof params?.scheme === "string" ? params.scheme : void 0,
+            channel: typeof params?.channel === "string" ? params.channel : void 0,
+            hotfix: typeof params?.hotfix === "boolean" ? params.hotfix : false,
+            dryRun: typeof params?.dryRun === "boolean" ? params.dryRun : false,
+            writeChangelog: typeof params?.writeChangelog === "boolean" ? params.writeChangelog : true,
+            // T10079: release plan side effects are project-level. When invoked
+            // from an XDG secondary worktree/subdir, route .changeset/,
+            // CHANGELOG.md, and plan.json writes to the primary worktree.
+            projectRoot: resolveWorktreeRouting().canonicalRoot
+          };
+          return wrapResult(await releasePlan(typed), "mutate", "release", operation, startTime);
+        }
+        // release.open — SPEC-T9345 §4.3 (T9530): dispatch release-prepare workflow
+        case "open": {
+          const version = typeof params?.version === "string" ? params.version : void 0;
+          if (!version) {
+            return errorResult(
+              "mutate",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "version is required",
+              startTime
+            );
+          }
+          const typed = {
+            version,
+            workflow: typeof params?.workflow === "string" ? params.workflow : void 0,
+            watch: typeof params?.watch === "boolean" ? params.watch : false,
+            commitPlan: typeof params?.commitPlan === "boolean" ? params.commitPlan : false,
+            // T12089: forward the plan scope. This mapping is explicit, so a
+            // param the CLI accepts but this block omits is silently dropped —
+            // `--tasks` reached the CLI, never reached `releaseOpen`, and the
+            // dispatched workflow then had no scope to plan with. Adding an
+            // option in core + the CLI is not enough; the dispatch layer is a
+            // second chokepoint that must carry it too.
+            epic: typeof params?.epic === "string" ? params.epic : void 0,
+            tasks: typeof params?.tasks === "string" ? params.tasks : void 0,
+            projectRoot: getProjectRoot()
+          };
+          return wrapResult(await releaseOpen(typed), "mutate", "release", operation, startTime);
+        }
+        // release.reconcile — v2 reconcile verb (T9526 / SPEC-T9345 §4.4)
+        case "reconcile": {
+          const version = typeof params?.version === "string" ? params.version : void 0;
+          if (!version)
+            return errorResult(
+              "mutate",
+              "release",
+              operation,
+              "E_INVALID_INPUT",
+              "version is required",
+              startTime
+            );
+          const result = await releaseReconcileV2(version, {
+            projectRoot: getProjectRoot(),
+            fromWorkflow: typeof params?.fromWorkflow === "boolean" ? params.fromWorkflow : false,
+            rollback: typeof params?.rollback === "boolean" ? params.rollback : false
+          });
+          return wrapResult(result, "mutate", "release", operation, startTime);
+        }
+        default:
+          return unsupportedOp("mutate", "release", operation, startTime);
+      }
+    } catch (err) {
+      log.error({ err, operation }, "ReleaseHandler mutate error");
+      return handleErrorResult("mutate", "release", operation, err, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // getSupportedOperations
+  // -----------------------------------------------------------------------
+  /** Return declared operations for introspection and registry validation. */
+  getSupportedOperations() {
+    return {
+      query: ["gate", "ivtr-suggest", "validate-changelog"],
+      mutate: ["gate", "ivtr-suggest", "reconcile", "plan", "open"]
+    };
+  }
+};
+export {
+  ReleaseHandler
+};
+//# sourceMappingURL=release-G2DPSG5M.js.map