@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/playbook-2FCBV7N3.js

@@ -0,0 +1,229 @@
+(() => {
+  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 {
+  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 "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/playbook.ts
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Execute a playbook (.cantbook) by name \u2014 walks the graph until completion or HITL pause"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Playbook name (resolved as <name>.cantbook)",
+      required: true
+    },
+    context: {
+      type: "string",
+      description: `JSON object string seeding the initial run context (e.g. '{"epicId":"T999"}')`
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "playbook",
+      "run",
+      { name: args.name, context: args.context },
+      { command: "playbook" }
+    );
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Return the current state of a playbook run from playbook_runs"
+  },
+  args: {
+    runId: {
+      type: "positional",
+      description: "Playbook run identifier",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "playbook",
+      "status",
+      { runId: args.runId },
+      { command: "playbook" }
+    );
+  }
+});
+var resumeCommand = defineCommand({
+  meta: {
+    name: "resume",
+    description: "Resume a paused playbook run once its HITL approval gate is approved"
+  },
+  args: {
+    runId: {
+      type: "positional",
+      description: "Playbook run identifier to resume",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "playbook",
+      "resume",
+      { runId: args.runId },
+      { command: "playbook" }
+    );
+  }
+});
+var createCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: "Scaffold a new .cantbook playbook (invokes playbook-architect meta-agent)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: 'Playbook name (kebab-case, e.g. "feature-ship")',
+      required: true
+    },
+    description: {
+      type: "string",
+      description: "Plain-text description of what the playbook should do"
+    },
+    stages: {
+      type: "string",
+      description: "Comma-separated list of stage names to scaffold (auto-inferred if omitted)"
+    },
+    "output-dir": {
+      type: "string",
+      description: "Output directory for the .cantbook file (defaults to .cleo/cant/playbooks/)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be created without writing files",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "playbook",
+      "create",
+      {
+        name: args.name,
+        description: args.description,
+        stages: args.stages,
+        outputDir: args["output-dir"],
+        dryRun: args["dry-run"]
+      },
+      { command: "playbook" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List playbook runs (optionally filter by status: active|completed|pending|failed|cancelled)"
+  },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter runs by status (active \u2192 running, pending \u2192 paused, completed, ...)"
+    },
+    epic: {
+      type: "string",
+      description: "Filter runs by epic id"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum number of runs to return"
+    },
+    offset: {
+      type: "string",
+      description: "Skip the first N runs"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "playbook",
+      "list",
+      {
+        status: args.status,
+        epicId: args.epic,
+        limit: args.limit !== void 0 ? Number.parseInt(args.limit, 10) : void 0,
+        offset: args.offset !== void 0 ? Number.parseInt(args.offset, 10) : void 0
+      },
+      { command: "playbook" }
+    );
+  }
+});
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Parse and validate a .cantbook file \u2014 exit 0 on success, exit 70 on parse error (T1261)"
+  },
+  args: {
+    file: {
+      type: "positional",
+      description: "Path to .cantbook file OR playbook name to resolve via search path",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const isPath = args.file.includes("/") || args.file.includes("\\") || args.file.endsWith(".cantbook");
+    await dispatchFromCli(
+      "query",
+      "playbook",
+      "validate",
+      isPath ? { file: args.file } : { name: args.file },
+      { command: "playbook" }
+    );
+  }
+});
+var playbookCommand = defineCommand({
+  meta: {
+    name: "playbook",
+    description: "Playbook runtime operations (run, status, resume, list, create, validate)"
+  },
+  subCommands: {
+    run: runCommand,
+    status: statusCommand,
+    resume: resumeCommand,
+    list: listCommand,
+    create: createCommand,
+    validate: validateCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  playbookCommand
+};
+//# sourceMappingURL=playbook-2FCBV7N3.js.map

package/dist/cli/project-WDX2TGMC.js

@@ -0,0 +1,330 @@
+(() => {
+  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 {
+  NEXUS_API_URL_ARG,
+  emitNexusResult,
+  failNexus,
+  nexusApiUrlArg,
+  writeNexusWarnings
+} from "./chunk-ULN4OKQQ.js";
+import "./chunk-47JYZAMS.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import {
+  getFormatContext
+} from "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/project.ts
+import { resolve } from "node:path";
+import { ExitCode } from "@cleocode/contracts";
+import {
+  CleoError,
+  getProjectRoot,
+  moveProject,
+  projectLifecycle,
+  renameProject,
+  rerootProject
+} from "@cleocode/core";
+function formatSuccessSection(header, icon, items) {
+  const prefix = icon ? `${icon} ` : "";
+  return { kind: "section", data: { header: `${prefix}${header}`, items } };
+}
+function emitEngineFailure(error, operation) {
+  const exitCode = error.exitCode ?? ExitCode.GENERAL_ERROR;
+  cliError(
+    error.message,
+    exitCode,
+    { name: error.code, fix: error.fix, details: error.details },
+    { operation }
+  );
+  process.exitCode = exitCode;
+}
+function resolveRootOrFail(operation) {
+  try {
+    return getProjectRoot();
+  } catch (err) {
+    const code = err instanceof CleoError && typeof err.details?.["code"] === "string" ? err.details["code"] : "E_NOT_CLEO_PROJECT";
+    emitEngineFailure(
+      {
+        code,
+        message: err.message,
+        exitCode: err instanceof CleoError ? err.code : ExitCode.CONFIG_ERROR,
+        fix: err instanceof CleoError ? err.fix : void 0
+      },
+      operation
+    );
+    return null;
+  }
+}
+function planItems(plan) {
+  const r = plan.registry;
+  return [
+    `Source:      ${plan.source}`,
+    `Target:      ${plan.target}`,
+    `Rename:      ${plan.entries.join(", ") || "(nothing)"}`,
+    ...plan.excluded.map((e) => `Left:        ${e.entry} (${e.reason})`),
+    `Writes:      ${plan.writes.join(", ") || "(nothing)"}`,
+    `Registry:    ${r.livePath} live; ${r.demotedPath} ${r.demotedState}`,
+    `Checkpoint:  ${plan.checkpoint}`,
+    ...plan.blockers.map((b) => `BLOCKER:     ${b}`),
+    ...plan.deferredChecks.map((c) => `Checked at apply time: ${c}`),
+    "Nothing was changed. Run without --dry-run to apply."
+  ];
+}
+function resultItems(r) {
+  const [from, to] = "oldPath" in r ? [r.oldPath, r.newPath] : [r.oldRoot, r.newRoot];
+  return [
+    `Project ID:  ${r.projectId}`,
+    `Old root:    ${from}`,
+    `New root:    ${to}`,
+    ..."renamed" in r ? [`Renamed:     ${r.renamed.join(", ") || "(resumed)"}`] : [],
+    `Checkpoint:  ${r.checkpointPath || "(none: resumed)"}`,
+    `Registry:    ${r.reconcileStatus}`,
+    ..."notes" in r ? r.notes.map((n) => `Next:        ${n}`) : []
+  ];
+}
+function emitRelocation(data, operation) {
+  if (getFormatContext().format !== "human") {
+    cliOutput(data, { command: "project", operation });
+    return;
+  }
+  const verb = operation === "project.move" ? "move" : "reroot";
+  cliOutput(
+    data.dryRun ? formatSuccessSection(`Dry Run: project ${verb}`, void 0, [
+      `Project ID:  ${data.projectId}`,
+      ...planItems(data)
+    ]) : formatSuccessSection(
+      verb === "move" ? "Project Moved" : "Project Rerooted",
+      "\u2705",
+      resultItems(data)
+    ),
+    { command: "project", operation }
+  );
+}
+var moveSubCommand = defineCommand({
+  meta: {
+    name: "move",
+    description: "Move this project to a new path on the same device by RENAMING its root: .git, the database and everything else move together, nothing is copied and no old copy is left. The registry is rebound to the new path. Refuses a cross-device target (use a plain `mv`, then any cleo command), a target inside the project (use `cleo project reroot`), and any move while sessions are active or worktrees exist (end them first)."
+  },
+  args: {
+    newPath: {
+      type: "positional",
+      description: "New project root: absent or an empty directory, outside this project.",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print the plan (renames, blockers, registry action) and change nothing.",
+      default: false
+    },
+    json: { type: "boolean", description: "Output raw JSON envelope.", default: false }
+  },
+  async run({ args }) {
+    const operation = "project.move";
+    const root = resolveRootOrFail(operation);
+    if (root === null) return;
+    const result = await moveProject(resolve(args["newPath"]), root, {
+      dryRun: args["dry-run"] === true
+    });
+    if (!result.success) {
+      emitEngineFailure(result.error, operation);
+      return;
+    }
+    emitRelocation(result.data, operation);
+  }
+});
+var rerootSubCommand = defineCommand({
+  meta: {
+    name: "reroot",
+    description: "Make a subdirectory of this project the project root. Checkpoints, then RENAMES CLEO's own top-level entries into it (.cleo/, .worktreeinclude, and .github/ when it holds only CLEO's init templates), keeps the same project id, leaves a .cleo-moved.json tombstone at the old root and rebinds the registry. Everything else stays. Refuses while a session or worktree is active. Run `cleo project reroot .` from the child to finish an interrupted reroot."
+  },
+  args: {
+    childDir: {
+      type: "positional",
+      description: "Existing subdirectory of the current project root (`.` from the child resumes).",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print the plan and change nothing (no disk, no registry).",
+      default: false
+    },
+    json: { type: "boolean", description: "Output raw JSON envelope.", default: false }
+  },
+  async run({ args }) {
+    const operation = "project.reroot";
+    const root = resolveRootOrFail(operation);
+    if (root === null) return;
+    const result = await rerootProject(resolve(args["childDir"]), root, {
+      dryRun: args["dry-run"] === true
+    });
+    if (!result.success) {
+      emitEngineFailure(result.error, operation);
+      return;
+    }
+    emitRelocation(result.data, operation);
+  }
+});
+var renameSubCommand = defineCommand({
+  meta: {
+    name: "rename",
+    description: "Rename this project: the committed .cleo/project.json name, the registry label, and a Cleo Nexus relink hint (the id never changes)."
+  },
+  args: {
+    newName: { type: "positional", description: "New project name.", required: true },
+    "dry-run": { type: "boolean", description: "Validate without applying.", default: false },
+    json: { type: "boolean", description: "Output raw JSON envelope.", default: false }
+  },
+  async run({ args }) {
+    const newName = args["newName"];
+    const dryRun = args["dry-run"] ?? false;
+    const nameRe = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,99}$/;
+    if (!newName || !nameRe.test(newName)) {
+      emitEngineFailure(
+        {
+          code: "E_VALIDATION",
+          message: `Invalid project name: "${newName}".`,
+          exitCode: ExitCode.INVALID_INPUT,
+          fix: 'Use 1-100 characters: letters, digits, "_" or "-", starting with a letter or digit'
+        },
+        "project.rename"
+      );
+      return;
+    }
+    if (dryRun) {
+      cliOutput(
+        formatSuccessSection("Dry Run", void 0, [
+          `Would rename project to "${newName}".`,
+          "Run without --dry-run to apply."
+        ]),
+        { command: "project", operation: "project.rename" }
+      );
+      return;
+    }
+    const result = await renameProject(newName, process.cwd());
+    if (result.success) {
+      const r = result.data;
+      cliOutput(
+        formatSuccessSection("Project Renamed", "\u2705", [
+          `Project ID:   ${r.projectId}`,
+          `Old name:     ${r.oldName}`,
+          `New name:     ${r.newName}`,
+          `Project hash: ${r.newProjectHash}`,
+          ...r.recordedIn ? [`Recorded in:  .cleo/${r.recordedIn}`] : [],
+          ...r.registry ? [`Registry:     ${r.registry}`] : [],
+          ...r.nexusLabel ? [`Nexus label:  ${r.nexusLabel}`] : [],
+          ...r.hint ? [`Next:         ${r.hint}`] : []
+        ]),
+        { command: "project", operation: "project.rename" }
+      );
+    } else {
+      emitEngineFailure(result.error, "project.rename");
+    }
+  }
+});
+var reregisterSubCommand = defineCommand({
+  meta: { name: "re-register", description: "Re-register project with NEXUS." },
+  args: {
+    fix: { type: "boolean", description: "Auto-heal path_updated drift.", default: false },
+    json: { type: "boolean", description: "Output raw JSON envelope.", default: false }
+  },
+  async run() {
+    const result = await projectLifecycle.reregisterProject(process.cwd());
+    if (result.success) {
+      const r = result.data;
+      const icon = r.drifted ? "\u26A0\uFE0F" : "\u2705";
+      const items = [
+        `Project ID:  ${r.projectId}`,
+        `Project root: ${r.projectRoot}`,
+        `Hash:        ${r.projectHash}`,
+        `Status:      ${r.reconcileStatus}`
+      ];
+      if (r.drifted && r.oldPath) items.push(`Old path:    ${r.oldPath}`);
+      cliOutput(
+        formatSuccessSection(
+          r.drifted ? "Project Re-registered (Drift Detected)" : "Project Re-registered",
+          icon,
+          items
+        ),
+        { command: "project", operation: "project.re-register" }
+      );
+    } else {
+      emitEngineFailure(result.error, "project.re-register");
+    }
+  }
+});
+var linkSubCommand = defineCommand({
+  meta: {
+    name: "link",
+    description: "Register this project with Cleo Nexus under its project id (.cleo/project-id) with its name as a plaintext label (--label overrides; never a filesystem path). Idempotent: re-linking after a rename updates the label. Requires cleo login nexus."
+  },
+  args: {
+    label: {
+      type: "string",
+      description: "Name shown in Nexus, sent in plaintext (default: the project name). A name, never a path."
+    },
+    rebind: {
+      type: "boolean",
+      description: "Use only after E_NEXUS_REPLICA_COPIED: give this copy of the project a new replica id before attaching it (this machine was re-enrolled, or the store was copied). Each run mints a new id and leaves the old one on the server as stale history."
+    },
+    "api-url": NEXUS_API_URL_ARG,
+    json: { type: "boolean", description: "Output raw JSON envelope.", default: false }
+  },
+  async run({ args }) {
+    const { linkProjectToNexus } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/cloud/nexus-link.js"
+    );
+    let result;
+    try {
+      result = await linkProjectToNexus({
+        apiUrl: nexusApiUrlArg(args),
+        ...typeof args["label"] === "string" && args["label"] ? { label: args["label"] } : {},
+        ...args["rebind"] === true ? { rebind: true } : {}
+      });
+    } catch (err) {
+      failNexus(err, "project.link");
+    }
+    const { link, replica } = result;
+    const verb = result.alreadyLinked ? "Already linked" : "Linked";
+    const attached = replica ? ` This machine (device ${replica.deviceId}) holds it as replica ${replica.replicaId}${replica.reboundFrom ? ` (rebound from ${replica.reboundFrom})` : ""}${replica.presenceAt ? "; presence reported" : ""}.` : "";
+    const summary = `${verb}: project ${link.localProjectId} as "${link.label ?? ""}" on ${link.apiUrl}.${attached}`;
+    writeNexusWarnings(result.warnings);
+    emitNexusResult(result, summary, "project", "project.link");
+  }
+});
+var projectCommand = defineCommand({
+  meta: {
+    name: "project",
+    description: "Project lifecycle management (move, reroot, rename, re-register, link)."
+  },
+  subCommands: {
+    link: linkSubCommand,
+    move: moveSubCommand,
+    reroot: rerootSubCommand,
+    rename: renameSubCommand,
+    "re-register": reregisterSubCommand
+  }
+});
+export {
+  projectCommand
+};
+//# sourceMappingURL=project-WDX2TGMC.js.map

package/dist/cli/promote-YINYFBZY.js

@@ -0,0 +1,52 @@
+(() => {
+  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 {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/promote.ts
+var promoteCommand = defineCommand({
+  meta: { name: "promote", description: "Remove parent from task, making it root-level" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to promote to root level",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "reparent",
+      { taskId: args.taskId, newParentId: null },
+      { command: "promote" }
+    );
+  }
+});
+export {
+  promoteCommand
+};
+//# sourceMappingURL=promote-YINYFBZY.js.map