@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/remote-QSONJDIK.js

@@ -0,0 +1,279 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/remote.ts
+import { ExitCode } from "@cleocode/contracts";
+import {
+  addRemote,
+  CleoError,
+  getRemoteSyncStatus as getRemoteGitStatus,
+  listRemotes,
+  pull,
+  push,
+  removeRemote
+} from "@cleocode/core/internal";
+var addRemoteCommand = defineCommand({
+  meta: { name: "add", description: "Add a git remote to .cleo/.git for shared state syncing" },
+  args: {
+    url: {
+      type: "positional",
+      description: "Remote URL to add",
+      required: true
+    },
+    name: {
+      type: "string",
+      description: "Remote name",
+      alias: "n",
+      default: "origin"
+    }
+  },
+  async run({ args }) {
+    try {
+      const name = args.name ?? "origin";
+      await addRemote(args.url, name);
+      cliOutput(
+        { added: true, name, url: args.url },
+        { command: "remote", message: `Remote '${name}' added: ${args.url}` }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      if (err instanceof Error) {
+        cliError(err.message, ExitCode.GENERAL_ERROR, { name: "E_GENERAL" });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      throw err;
+    }
+  }
+});
+var removeRemoteCommand = defineCommand({
+  meta: { name: "remove", description: "Remove a git remote from .cleo/.git" },
+  args: {
+    name: {
+      type: "positional",
+      description: "Remote name to remove",
+      required: true
+    }
+  },
+  async run({ args }) {
+    try {
+      await removeRemote(args.name);
+      cliOutput(
+        { removed: true, name: args.name },
+        { command: "remote", message: `Remote '${args.name}' removed` }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      if (err instanceof Error) {
+        cliError(err.message, ExitCode.GENERAL_ERROR, { name: "E_GENERAL" });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      throw err;
+    }
+  }
+});
+var listRemoteCommand = defineCommand({
+  meta: { name: "list", description: "List configured .cleo/.git remotes" },
+  async run() {
+    try {
+      const remotes = await listRemotes();
+      cliOutput(
+        { remotes, count: remotes.length },
+        {
+          command: "remote",
+          message: remotes.length === 0 ? "No remotes configured. Add one with: cleo remote add <url>" : `${remotes.length} remote(s) configured`
+        }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      if (err instanceof Error) {
+        cliError(err.message, ExitCode.GENERAL_ERROR, { name: "E_GENERAL" });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      throw err;
+    }
+  }
+});
+var statusRemoteCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show sync status between local .cleo/.git and remote"
+  },
+  args: {
+    remote: {
+      type: "string",
+      description: "Remote name",
+      alias: "r",
+      default: "origin"
+    }
+  },
+  async run({ args }) {
+    try {
+      const remoteName = args.remote ?? "origin";
+      const status = await getRemoteGitStatus(remoteName);
+      let message;
+      if (status.ahead === 0 && status.behind === 0) {
+        message = `Up to date with ${remoteName}/${status.branch}`;
+      } else {
+        const parts = [];
+        if (status.ahead > 0) parts.push(`${status.ahead} ahead`);
+        if (status.behind > 0) parts.push(`${status.behind} behind`);
+        message = `${parts.join(", ")} ${remoteName}/${status.branch}`;
+      }
+      cliOutput({ ...status }, { command: "remote", message });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      if (err instanceof Error) {
+        cliError(err.message, ExitCode.GENERAL_ERROR, { name: "E_GENERAL" });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      throw err;
+    }
+  }
+});
+var remoteCommand = defineCommand({
+  meta: {
+    name: "remote",
+    description: "Manage .cleo/.git remotes for multi-contributor state sharing"
+  },
+  subCommands: {
+    add: addRemoteCommand,
+    remove: removeRemoteCommand,
+    list: listRemoteCommand,
+    status: statusRemoteCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+var pushCommand = defineCommand({
+  meta: { name: "push", description: "Push .cleo/ state to remote (operates on .cleo/.git)" },
+  args: {
+    remote: {
+      type: "string",
+      description: "Remote name",
+      alias: "r",
+      default: "origin"
+    },
+    "set-upstream": {
+      type: "boolean",
+      description: "Set upstream tracking branch",
+      alias: "u"
+    },
+    force: {
+      type: "boolean",
+      description: "Force push (overwrite remote)"
+    }
+  },
+  async run({ args }) {
+    try {
+      const remoteName = args.remote ?? "origin";
+      const result = await push(remoteName, {
+        force: args.force ?? false,
+        setUpstream: args["set-upstream"] ?? false
+      });
+      if (!result.success) {
+        cliError(result.message, ExitCode.GENERAL_ERROR, { name: "E_PUSH_FAILED" });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      cliOutput(
+        { pushed: true, branch: result.branch, remote: result.remote },
+        { command: "push", message: result.message }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      if (err instanceof Error) {
+        cliError(err.message, ExitCode.GENERAL_ERROR, { name: "E_GENERAL" });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      throw err;
+    }
+  }
+});
+var pullCommand = defineCommand({
+  meta: { name: "pull", description: "Pull .cleo/ state from remote (operates on .cleo/.git)" },
+  args: {
+    remote: {
+      type: "string",
+      description: "Remote name",
+      alias: "r",
+      default: "origin"
+    }
+  },
+  async run({ args }) {
+    try {
+      const remoteName = args.remote ?? "origin";
+      const result = await pull(remoteName);
+      if (!result.success) {
+        const details = {
+          pulled: false,
+          branch: result.branch,
+          remote: result.remote
+        };
+        if (result.hasConflicts) {
+          details["conflicts"] = result.conflictFiles;
+        }
+        cliError(result.message, ExitCode.GENERAL_ERROR, { details });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      cliOutput(
+        { pulled: true, branch: result.branch, remote: result.remote },
+        { command: "pull", message: result.message }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      if (err instanceof Error) {
+        cliError(err.message, ExitCode.GENERAL_ERROR, { name: "E_GENERAL" });
+        process.exit(ExitCode.GENERAL_ERROR);
+      }
+      throw err;
+    }
+  }
+});
+export {
+  pullCommand,
+  pushCommand,
+  remoteCommand
+};
+//# sourceMappingURL=remote-QSONJDIK.js.map

package/dist/cli/renderers-64OR3IWX.js

@@ -0,0 +1,37 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput,
+  humanInfo,
+  humanLine,
+  humanProgress,
+  humanWarn,
+  isHumanOutput,
+  renderWaves
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  cliError,
+  cliOutput,
+  humanInfo,
+  humanLine,
+  humanProgress,
+  humanWarn,
+  isHumanOutput,
+  renderWaves
+};
+//# sourceMappingURL=renderers-64OR3IWX.js.map

package/dist/cli/reorder-J3DOE7ST.js

@@ -0,0 +1,86 @@
+(() => {
+  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 {
+  cliError
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/reorder.ts
+var BOTTOM_POSITION = 999999;
+var reorderCommand = defineCommand({
+  meta: { name: "reorder", description: "Change task position within sibling group" },
+  args: {
+    "task-id": {
+      type: "positional",
+      description: "Task ID to reorder",
+      required: true
+    },
+    position: {
+      type: "string",
+      description: "Move to specific zero-based position among siblings"
+    },
+    top: {
+      type: "boolean",
+      description: "Move to the top (position 0)"
+    },
+    bottom: {
+      type: "boolean",
+      description: "Move to the bottom"
+    }
+  },
+  async run({ args }) {
+    const taskId = args["task-id"];
+    let position;
+    if (args.top) {
+      position = 0;
+    } else if (args.bottom) {
+      position = BOTTOM_POSITION;
+    } else if (args.position !== void 0) {
+      position = Number.parseInt(args.position, 10);
+    }
+    if (position === void 0) {
+      cliError(
+        "Must specify --position <n>, --top, or --bottom.",
+        2,
+        { name: "E_INVALID_INPUT" },
+        { operation: "tasks.reorder" }
+      );
+      process.exitCode = 2;
+      return;
+    }
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "reorder",
+      { taskId, position },
+      { command: "reorder" }
+    );
+  }
+});
+export {
+  reorderCommand
+};
+//# sourceMappingURL=reorder-J3DOE7ST.js.map

package/dist/cli/reparent-2OUMKEZX.js

@@ -0,0 +1,58 @@
+(() => {
+  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/reparent.ts
+var reparentCommand = defineCommand({
+  meta: { name: "reparent", description: "Move task to a different parent in hierarchy" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "ID of the task to reparent",
+      required: true
+    },
+    to: {
+      type: "string",
+      description: 'Target parent task ID (or "" to make root)',
+      required: true
+    }
+  },
+  async run({ args }) {
+    const newParentId = args.to || null;
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "reparent",
+      { taskId: args.taskId, newParentId },
+      { command: "reparent" }
+    );
+  }
+});
+export {
+  reparentCommand
+};
+//# sourceMappingURL=reparent-2OUMKEZX.js.map

package/dist/cli/req-TZB7OFKO.js

@@ -0,0 +1,129 @@
+(() => {
+  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 {
+  cliError
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/req.ts
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add a typed AcceptanceGate (with REQ-ID) to a task's acceptance array"
+  },
+  args: {
+    "task-id": {
+      type: "positional",
+      description: "Task ID to add the gate to",
+      required: true
+    },
+    gate: {
+      type: "string",
+      description: 'AcceptanceGate JSON string (must match the AcceptanceGate schema; include "req" for a REQ-ID)',
+      required: true
+    }
+  },
+  async run({ args }) {
+    const taskId = args["task-id"];
+    const gate = args.gate;
+    if (!gate) {
+      cliError(
+        "--gate <json> is required.",
+        6,
+        {
+          name: "E_VALIDATION",
+          fix: `Example: cleo req add T42 --gate '{"kind":"test","command":"pnpm test","expect":"pass","description":"Tests pass","req":"TIMER-01"}'`
+        },
+        { operation: "tasks.req.add" }
+      );
+      process.exit(6);
+    }
+    await dispatchFromCli("mutate", "tasks", "req.add", { taskId, gate }, { command: "req add" });
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all REQ-ID-addressed acceptance gates on a task" },
+  args: {
+    "task-id": {
+      type: "positional",
+      description: "Task ID to list gates for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const taskId = args["task-id"];
+    await dispatchFromCli("query", "tasks", "req.list", { taskId }, { command: "req list" });
+  }
+});
+var migrateCommand = defineCommand({
+  meta: {
+    name: "migrate",
+    description: 'Heuristic migrator: propose (or apply) typed gate replacements for free-text acceptance strings. Heuristics: "tests pass" \u2192 test gate, "<file> exists" \u2192 file gate, "lint clean" \u2192 lint gate, "<cmd> returns 0" \u2192 command gate, otherwise \u2192 manual gate.'
+  },
+  args: {
+    "task-id": {
+      type: "positional",
+      description: "Task ID to migrate gates for",
+      required: true
+    },
+    apply: {
+      type: "boolean",
+      description: "Write the proposed typed gates back to the task (default: dry-run, print proposals only)"
+    }
+  },
+  async run({ args }) {
+    const taskId = args["task-id"];
+    const apply = Boolean(args.apply);
+    await dispatchFromCli(
+      apply ? "mutate" : "query",
+      "tasks",
+      apply ? "req.migrate" : "req.migrate.preview",
+      { taskId, apply },
+      { command: "req migrate" }
+    );
+  }
+});
+var reqCommand = defineCommand({
+  meta: {
+    name: "req",
+    description: "Manage REQ-ID-addressable acceptance gates on tasks (in-task gates only). For cross-task dependency edges, use `cleo update <id> --add-depends <ids>` or `cleo update <id> --add-relates <id>:blocks` (gh-394)."
+  },
+  subCommands: {
+    add: addCommand,
+    list: listCommand,
+    migrate: migrateCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  reqCommand
+};
+//# sourceMappingURL=req-TZB7OFKO.js.map