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

package/dist/cli/sticky-XZXZDCFW.js

@@ -0,0 +1,339 @@
+(() => {
+  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 {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/sticky.ts
+import { ExitCode } from "@cleocode/contracts";
+import { CleoError } from "@cleocode/core";
+var addCommand = defineCommand({
+  meta: { name: "add", description: "Create a new sticky note" },
+  args: {
+    content: {
+      type: "positional",
+      description: "Sticky note content",
+      required: true
+    },
+    tag: {
+      type: "string",
+      description: 'Comma-separated tags (e.g. "bug,urgent")'
+    },
+    color: {
+      type: "string",
+      description: "Sticky color: yellow|blue|green|red|purple",
+      default: "yellow"
+    },
+    priority: {
+      type: "string",
+      description: "Priority: low|medium|high",
+      default: "medium"
+    }
+  },
+  async run({ args }) {
+    try {
+      const rawTag = args.tag;
+      const tags = rawTag ? rawTag.split(",").map((t) => t.trim()).filter(Boolean) : [];
+      await dispatchFromCli(
+        "mutate",
+        "sticky",
+        "add",
+        {
+          content: args.content,
+          tags,
+          color: args.color,
+          priority: args.priority
+        },
+        { command: "sticky", operation: "sticky.add" }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List active sticky notes" },
+  args: {
+    tag: {
+      type: "string",
+      description: 'Filter by tags (comma-separated, e.g. "bug,urgent")'
+    },
+    color: {
+      type: "string",
+      description: "Filter by color"
+    },
+    status: {
+      type: "string",
+      description: "Filter by status: active|converted|archived",
+      default: "active"
+    },
+    limit: {
+      type: "string",
+      description: "Max results",
+      default: "50"
+    }
+  },
+  async run({ args }) {
+    try {
+      const rawTag = args.tag;
+      const tags = rawTag ? rawTag.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+      const response = await dispatchRaw("query", "sticky", "list", {
+        tags,
+        color: args.color,
+        status: args.status,
+        limit: Number.parseInt(args.limit, 10)
+      });
+      if (!response.success) {
+        handleRawError(response, { command: "sticky list", operation: "sticky.list" });
+        return;
+      }
+      const data = response.data;
+      if (!data?.stickies || data.stickies.length === 0) {
+        cliOutput(
+          { stickies: [], total: 0 },
+          { command: "sticky list", message: "No sticky notes found", operation: "sticky.list" }
+        );
+        process.exit(ExitCode.NO_DATA);
+        return;
+      }
+      cliOutput(data, { command: "sticky list", operation: "sticky.list", page: response.page });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show a specific sticky note" },
+  args: {
+    id: {
+      type: "positional",
+      description: "Sticky note ID",
+      required: true
+    }
+  },
+  async run({ args }) {
+    try {
+      const response = await dispatchRaw("query", "sticky", "show", {
+        stickyId: args.id
+      });
+      if (!response.success) {
+        handleRawError(response, { command: "sticky show", operation: "sticky.show" });
+        return;
+      }
+      const data = response.data;
+      if (!data) {
+        cliOutput(
+          { sticky: null },
+          {
+            command: "sticky show",
+            message: `Sticky note not found: ${args.id}`,
+            operation: "sticky.show"
+          }
+        );
+        process.exit(ExitCode.NO_DATA);
+        return;
+      }
+      cliOutput({ sticky: data }, { command: "sticky show", operation: "sticky.show" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var convertCommand = defineCommand({
+  meta: { name: "convert", description: "Convert sticky note to task or memory" },
+  args: {
+    id: {
+      type: "positional",
+      description: "Sticky note ID to convert",
+      required: true
+    },
+    "to-task": {
+      type: "boolean",
+      description: "Convert to a task"
+    },
+    "to-memory": {
+      type: "boolean",
+      description: "Convert to a memory observation"
+    },
+    title: {
+      type: "string",
+      description: "Title for the converted item (tasks only)"
+    },
+    type: {
+      type: "string",
+      description: "Memory type: pattern|learning|decision|observation (memory only)",
+      default: "observation"
+    },
+    epic: {
+      type: "string",
+      description: "Epic ID for the new task (e.g., epic:T###)"
+    }
+  },
+  async run({ args }) {
+    try {
+      const toTask = args["to-task"];
+      const toMemory = args["to-memory"];
+      if (!toTask && !toMemory) {
+        cliError(
+          "Must specify either --to-task or --to-memory",
+          ExitCode.INVALID_INPUT,
+          { name: "E_INVALID_INPUT" },
+          { operation: "sticky.convert" }
+        );
+        process.exit(ExitCode.INVALID_INPUT);
+        return;
+      }
+      if (toTask && toMemory) {
+        cliError(
+          "Cannot specify both --to-task and --to-memory",
+          ExitCode.INVALID_INPUT,
+          { name: "E_INVALID_INPUT" },
+          { operation: "sticky.convert" }
+        );
+        process.exit(ExitCode.INVALID_INPUT);
+        return;
+      }
+      const convertParams = {
+        stickyId: args.id,
+        targetType: toTask ? "task" : "memory"
+      };
+      if (toTask) {
+        if (args.title) convertParams["title"] = args.title;
+        if (args.epic) convertParams["epic"] = args.epic;
+      }
+      if (toMemory) {
+        convertParams["memoryType"] = args.type;
+      }
+      await dispatchFromCli("mutate", "sticky", "convert", convertParams, {
+        command: "sticky convert",
+        operation: "sticky.convert"
+      });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var archiveCommand = defineCommand({
+  meta: { name: "archive", description: "Archive a sticky note" },
+  args: {
+    id: {
+      type: "positional",
+      description: "Sticky note ID to archive",
+      required: true
+    }
+  },
+  async run({ args }) {
+    try {
+      await dispatchFromCli(
+        "mutate",
+        "sticky",
+        "archive",
+        { stickyId: args.id },
+        { command: "sticky archive", operation: "sticky.archive" }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var purgeCommand = defineCommand({
+  meta: { name: "purge", description: "Permanently delete a sticky note (cannot be undone)" },
+  args: {
+    id: {
+      type: "positional",
+      description: "Sticky note ID to purge",
+      required: true
+    }
+  },
+  async run({ args }) {
+    try {
+      await dispatchFromCli(
+        "mutate",
+        "sticky",
+        "purge",
+        { stickyId: args.id },
+        { command: "sticky purge", operation: "sticky.purge" }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var stickyCommand = defineCommand({
+  meta: {
+    name: "sticky",
+    description: "Manage sticky notes - quick project-wide ephemeral captures"
+  },
+  subCommands: {
+    add: addCommand,
+    jot: addCommand,
+    list: listCommand,
+    ls: listCommand,
+    show: showCommand,
+    convert: convertCommand,
+    archive: archiveCommand,
+    purge: purgeCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  stickyCommand
+};
+//# sourceMappingURL=sticky-XZXZDCFW.js.map

package/dist/cli/stop-VNOAFWNB.js

@@ -0,0 +1,43 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} 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/stop.ts
+var stopCommand = defineCommand({
+  meta: {
+    name: "stop",
+    description: "Stop working on the current task (clears the active task, returns {cleared: boolean, previousTask: string|null})"
+  },
+  async run() {
+    await dispatchFromCli("mutate", "tasks", "stop", {}, { command: "stop" });
+  }
+});
+export {
+  stopCommand
+};
+//# sourceMappingURL=stop-VNOAFWNB.js.map

package/dist/cli/sync-YYPARW3A.js

@@ -0,0 +1,155 @@
+(() => {
+  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 {
+  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 {
+  cliError
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/sync.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+var linksRemoveCommand = defineCommand({
+  meta: { name: "remove", description: "Remove all external task links for a provider" },
+  args: {
+    providerId: {
+      type: "positional",
+      description: "Provider ID whose links should be removed",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "sync.links.remove",
+      { providerId: args.providerId },
+      { command: "sync", operation: "tasks.sync.links.remove" }
+    );
+  }
+});
+var linksCommand = defineCommand({
+  meta: { name: "links", description: "List external task links" },
+  args: {
+    provider: {
+      type: "string",
+      description: "Filter links by provider (e.g. linear, jira, github)"
+    },
+    task: {
+      type: "string",
+      description: "Filter links by CLEO task ID"
+    }
+  },
+  subCommands: {
+    remove: linksRemoveCommand
+  },
+  async run({ args }) {
+    const providerId = args.provider;
+    const taskId = args.task;
+    if (!providerId && !taskId) {
+      cliError(
+        "at least one of --provider or --task is required for sync links list",
+        ExitCode.INVALID_INPUT,
+        { name: "E_VALIDATION" }
+      );
+      process.exit(ExitCode.INVALID_INPUT);
+    }
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "sync.links",
+      { providerId, taskId },
+      { command: "sync", operation: "tasks.sync.links" }
+    );
+  }
+});
+var reconcileCommand = defineCommand({
+  meta: {
+    name: "reconcile",
+    description: "Reconcile external tasks from a JSON file against CLEO tasks"
+  },
+  args: {
+    file: {
+      type: "positional",
+      description: "Path to JSON file containing external tasks array",
+      required: true
+    },
+    provider: {
+      type: "string",
+      description: "Provider ID (e.g. linear, jira, github)",
+      required: true
+    },
+    "conflict-policy": {
+      type: "string",
+      description: "How to resolve conflicts: keep-cleo, keep-external, or newest (default: keep-cleo)",
+      default: "keep-cleo"
+    }
+  },
+  async run({ args }) {
+    const { readFileSync } = await import("node:fs");
+    let externalTasks;
+    try {
+      externalTasks = JSON.parse(readFileSync(args.file, "utf8"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Failed to read or parse external tasks file: ${message}`, 2, {
+        name: "E_VALIDATION"
+      });
+      process.exit(2);
+    }
+    if (!Array.isArray(externalTasks)) {
+      cliError("External tasks file must contain a JSON array", 2, { name: "E_VALIDATION" });
+      process.exit(2);
+    }
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "sync.reconcile",
+      {
+        providerId: args.provider,
+        externalTasks,
+        conflictPolicy: args["conflict-policy"]
+      },
+      { command: "sync", operation: "tasks.sync.reconcile" }
+    );
+  }
+});
+var syncCommand = defineCommand({
+  meta: { name: "sync", description: "External task synchronisation management" },
+  subCommands: {
+    links: linksCommand,
+    reconcile: reconcileCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  syncCommand
+};
+//# sourceMappingURL=sync-YYPARW3A.js.map