@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/status-46HTKNRR.js

@@ -0,0 +1,157 @@
+(() => {
+  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 {
+  BOLD,
+  CYAN,
+  DIM,
+  GREEN,
+  NC,
+  RED,
+  YELLOW
+} from "./chunk-V5GBGOGM.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import {
+  isJsonFormat
+} from "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/status.ts
+import { getCleoStatus } from "@cleocode/core/status";
+function formatEpoch(epoch) {
+  if (epoch == null) return "";
+  const d = new Date(epoch);
+  if (Number.isNaN(d.getTime())) return "";
+  return d.toISOString().replace("T", " ").slice(0, 19) + "Z";
+}
+function renderCredentialLine(c) {
+  const badges = [];
+  if (c.lastStatus === "invalid") badges.push(`${RED}${BOLD}[INVALID]${NC}`);
+  if (c.isExpired === true) badges.push(`${YELLOW}${BOLD}[EXPIRED]${NC}`);
+  const label = c.label ?? "(no label)";
+  const head = `${BOLD}${c.provider}${NC} ${DIM}${label}${NC}`;
+  const meta = [];
+  meta.push(`source=${c.source}`);
+  if (c.authType !== void 0) meta.push(`authType=${c.authType}`);
+  if (c.lastStatus !== void 0) meta.push(`lastStatus=${c.lastStatus}`);
+  if (c.expiresAt != null) meta.push(`expiresAt=${formatEpoch(c.expiresAt)}`);
+  const metaLine = `${DIM}${meta.join(" \xB7 ")}${NC}`;
+  const badgeStr = badges.length > 0 ? ` ${badges.join(" ")}` : "";
+  return `    ${head}${badgeStr}
+      ${metaLine}`;
+}
+function renderStatusHuman(status) {
+  const lines = [];
+  if (status.config.hasSecretsInProjectConfig) {
+    lines.push(`${RED}${BOLD}WARNING: Secrets detected in project config${NC}`);
+    for (const w of status.config.secretsWarnings) {
+      lines.push(`  ${RED}${w}${NC}`);
+    }
+    lines.push("");
+  }
+  lines.push(`${BOLD}Identity${NC}`);
+  lines.push(`  ${DIM}agentId:${NC}      ${status.identity.agentId ?? "(none)"}`);
+  lines.push(`  ${DIM}identityFile:${NC} ${status.identity.identityFile ?? "(none)"}`);
+  const loggedInBadge = status.identity.loggedIn ? `${GREEN}yes${NC}` : `${YELLOW}no \u2014 run \`cleo setup\`${NC}`;
+  lines.push(`  ${DIM}loggedIn:${NC}     ${loggedInBadge}`);
+  lines.push("");
+  lines.push(`${BOLD}Credentials${NC} ${DIM}(${status.credentials.length} entries)${NC}`);
+  if (status.credentials.length === 0) {
+    lines.push(`  ${DIM}(no credentials \u2014 run \`cleo auth list\` after \`cleo setup\`)${NC}`);
+  } else {
+    for (const c of status.credentials) {
+      lines.push(renderCredentialLine(c));
+    }
+  }
+  lines.push("");
+  lines.push(`${BOLD}Config${NC}`);
+  lines.push(`  ${DIM}globalConfigPath:${NC}  ${status.config.globalConfigPath}`);
+  lines.push(`  ${DIM}projectConfigPath:${NC} ${status.config.projectConfigPath ?? "(none)"}`);
+  lines.push(`  ${DIM}activeConfigPath:${NC}  ${status.config.activeConfigPath}`);
+  lines.push("");
+  lines.push(`${BOLD}Session${NC}`);
+  const sessionState = status.session.active ? `${GREEN}active${NC}` : `${DIM}inactive${NC}`;
+  lines.push(`  ${DIM}state:${NC}       ${sessionState}`);
+  lines.push(`  ${DIM}sessionId:${NC}   ${status.session.sessionId ?? "(none)"}`);
+  lines.push(`  ${DIM}focusedTask:${NC} ${status.session.focusedTask ?? "(none)"}`);
+  lines.push("");
+  lines.push(`${BOLD}Harness${NC}`);
+  lines.push(`  ${DIM}active:${NC}  ${CYAN}${status.harness.active}${NC}`);
+  lines.push(
+    `  ${DIM}healthy:${NC} ${status.harness.healthy ? `${GREEN}yes${NC}` : `${RED}no${NC}`}`
+  );
+  if (status.harness.issues.length > 0) {
+    for (const issue of status.harness.issues) {
+      lines.push(`    ${YELLOW}- ${issue}${NC}`);
+    }
+  }
+  lines.push("");
+  lines.push(`${BOLD}Daemon${NC}`);
+  const daemonState = status.daemon.running ? `${GREEN}running${NC}` : `${DIM}stopped${NC}`;
+  lines.push(`  ${DIM}state:${NC}            ${daemonState}`);
+  lines.push(`  ${DIM}pid:${NC}              ${status.daemon.pid ?? "(none)"}`);
+  lines.push(
+    `  ${DIM}lastTickAt:${NC}       ${status.daemon.lastTickAt != null ? formatEpoch(status.daemon.lastTickAt) : "(never)"}`
+  );
+  const killSwitchBadge = status.daemon.killSwitchActive ? `${RED}${BOLD}ACTIVE${NC}` : `${DIM}inactive${NC}`;
+  lines.push(`  ${DIM}killSwitchActive:${NC} ${killSwitchBadge}`);
+  lines.push("");
+  lines.push(`${BOLD}Cleo Nexus account${NC}`);
+  for (const n of status.nexusAccount) {
+    const color = n.state === "signed-in" ? GREEN : n.state === "not-signed-in" ? DIM : YELLOW;
+    lines.push(`  ${DIM}${n.apiUrl}:${NC} ${color}${n.summary}${NC}`);
+  }
+  return lines.join("\n");
+}
+function computeExitCode(status) {
+  const hasInvalid = status.credentials.some((c) => c.lastStatus === "invalid");
+  return hasInvalid ? 1 : 0;
+}
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Unified config + credential + session + harness + daemon snapshot. Use --json for the full LAFS envelope (CleoStatus interface). Exits non-zero when any credential is in invalid state."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON envelope (CleoStatus interface)"
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    const forceJson = a["json"] === true;
+    const status = await getCleoStatus();
+    if (forceJson || isJsonFormat()) {
+      cliOutput(status, {
+        command: "status",
+        operation: "status.show"
+      });
+    } else {
+      process.stdout.write(`${renderStatusHuman(status)}
+`);
+    }
+    const exitCode = computeExitCode(status);
+    if (exitCode !== 0) process.exit(exitCode);
+  }
+});
+export {
+  statusCommand
+};
+//# sourceMappingURL=status-46HTKNRR.js.map

package/dist/cli/sticky-2DUZOUGI.js

@@ -0,0 +1,338 @@
+(() => {
+  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,
+  dispatchRaw,
+  handleRawError
+} 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/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-2DUZOUGI.js.map

package/dist/cli/stop-J2QEUKHX.js

@@ -0,0 +1,42 @@
+(() => {
+  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/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-J2QEUKHX.js.map

package/dist/cli/sync-GJP2QYT5.js

@@ -0,0 +1,154 @@
+(() => {
+  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/sync.ts
+import { ExitCode } from "@cleocode/contracts";
+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-GJP2QYT5.js.map