@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/llm-cost-S7RS6BVA.js

@@ -0,0 +1,25 @@
+(() => {
+  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 {
+  costCommand
+} from "./chunk-BPEVD37G.js";
+import "./chunk-PKKZPOOP.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  costCommand
+};
+//# sourceMappingURL=llm-cost-S7RS6BVA.js.map

package/dist/cli/llm-stream-24A45NTS.js

@@ -0,0 +1,27 @@
+(() => {
+  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 {
+  runLlmStream,
+  streamCommand
+} from "./chunk-NWTATTEQ.js";
+import "./chunk-PKKZPOOP.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  runLlmStream,
+  streamCommand
+};
+//# sourceMappingURL=llm-stream-24A45NTS.js.map

package/dist/cli/log-XF6H2XSD.js

@@ -0,0 +1,75 @@
+(() => {
+  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/log.ts
+var logCommand = defineCommand({
+  meta: { name: "log", description: "View audit log entries (operations, timestamps, changes)" },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum entries to show",
+      default: "20"
+    },
+    offset: {
+      type: "string",
+      description: "Skip N entries",
+      default: "0"
+    },
+    operation: {
+      type: "string",
+      description: "Filter by operation type"
+    },
+    task: {
+      type: "string",
+      description: "Filter by task ID"
+    },
+    since: {
+      type: "string",
+      description: "Filter entries since date"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "log",
+      {
+        limit: args.limit ? Number(args.limit) : 20,
+        offset: args.offset ? Number(args.offset) : 0,
+        operation: args.operation,
+        taskId: args.task,
+        since: args.since
+      },
+      { command: "log", operation: "admin.log" }
+    );
+  }
+});
+export {
+  logCommand
+};
+//# sourceMappingURL=log-XF6H2XSD.js.map

package/dist/cli/login-LBPLGHYG.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 {
+  LOGIN_ARGS,
+  NEXUS_PICKER_LABEL,
+  emitLoginResult,
+  loginCommand,
+  loginPickerOptions,
+  makeOAuthAcquirer,
+  runLoginCommand,
+  runLoginFrontDoor
+} from "./chunk-J3ZFM3UQ.js";
+import "./chunk-GZFVDR44.js";
+import "./chunk-ULN4OKQQ.js";
+import "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import "./chunk-PKKZPOOP.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  LOGIN_ARGS,
+  NEXUS_PICKER_LABEL,
+  emitLoginResult,
+  loginCommand,
+  loginPickerOptions,
+  makeOAuthAcquirer,
+  runLoginCommand,
+  runLoginFrontDoor
+};
+//# sourceMappingURL=login-LBPLGHYG.js.map

package/dist/cli/logout-SX4JSJIV.js

@@ -0,0 +1,74 @@
+(() => {
+  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 {
+  emitLlmCredentialRemoval
+} from "./chunk-7INMKEAD.js";
+import {
+  NEXUS_API_URL_ARG,
+  runNexusDeviceLogout
+} from "./chunk-ULN4OKQQ.js";
+import "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/logout.ts
+import { NEXUS_LOGIN_TARGET } from "@cleocode/contracts";
+var logoutCommand = defineCommand({
+  meta: {
+    name: "logout",
+    description: "Sign out. cleo logout [nexus] signs this machine out of Cleo Nexus (the device keeps its id for the next login; --revoke burns it), confirmed by the server; cleo logout <provider> [label] removes an LLM credential exactly like cleo auth remove (the label may be omitted when the provider has one credential)."
+  },
+  args: {
+    target: {
+      type: "positional",
+      description: "'nexus' (default) or an LLM provider id (e.g. anthropic).",
+      required: false
+    },
+    label: {
+      type: "positional",
+      description: "LLM credential label (optional when the provider has one credential).",
+      required: false
+    },
+    "api-url": NEXUS_API_URL_ARG,
+    revoke: {
+      type: "boolean",
+      description: "Hard-revoke this device: destroys its key grant and burns the device id; the next login enrols a new device. Without it, logout signs the device out and keeps it for the next login."
+    },
+    json: { type: "boolean", description: "Output as JSON envelope" }
+  },
+  async run({ args }) {
+    const a = args;
+    const target = typeof a["target"] === "string" && a["target"] ? a["target"] : NEXUS_LOGIN_TARGET;
+    if (target !== NEXUS_LOGIN_TARGET) {
+      const label = typeof a["label"] === "string" && a["label"] ? a["label"] : void 0;
+      const { removeLlmCredential } = await import(
+        /* webpackIgnore: true */
+        "@cleocode/core/llm/credential-remove-entry.js"
+      );
+      emitLlmCredentialRemoval(await removeLlmCredential(target, label), "logout", "logout.run");
+      return;
+    }
+    await runNexusDeviceLogout(a);
+  }
+});
+export {
+  logoutCommand
+};
+//# sourceMappingURL=logout-SX4JSJIV.js.map

package/dist/cli/manifest-NMCW4PIW.js

@@ -0,0 +1,353 @@
+(() => {
+  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 {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+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/manifest.ts
+import { buildManifestEntryFromShorthand } from "@cleocode/core/memory/manifest-builder.js";
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show a manifest entry by ID"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Pipeline manifest entry ID",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "manifest.show",
+      { entryId: args.id },
+      { command: "manifest show" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List manifest entries with optional filters"
+  },
+  args: {
+    filter: {
+      type: "string",
+      description: "Filter by status: active|archived|distilled|pending"
+    },
+    task: {
+      type: "string",
+      description: "Filter by task_id"
+    },
+    epic: {
+      type: "string",
+      description: "Filter by epic_id"
+    },
+    type: {
+      type: "string",
+      description: "Filter by entry type"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum rows to return (default: 50, max: 500)"
+    },
+    offset: {
+      type: "string",
+      description: "Pagination offset (default: 0)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON array (default: table)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const limit = args.limit ? Number.parseInt(args.limit, 10) : 50;
+    const offset = args.offset ? Number.parseInt(args.offset, 10) : 0;
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "manifest.list",
+      {
+        filter: args.filter,
+        taskId: args.task,
+        epicId: args.epic,
+        type: args.type,
+        limit,
+        offset,
+        json: args.json
+      },
+      { command: "manifest list" }
+    );
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Full-text search manifest entries"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Full-text search string",
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Maximum rows to return (default: 20)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON array",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const limit = args.limit ? Number.parseInt(args.limit, 10) : 20;
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "manifest.find",
+      {
+        query: args.query,
+        limit,
+        json: args.json
+      },
+      { command: "manifest find" }
+    );
+  }
+});
+var statsCommand = defineCommand({
+  meta: {
+    name: "stats",
+    description: "Aggregate manifest statistics"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON object",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "manifest.stats",
+      {
+        json: args.json
+      },
+      { command: "manifest stats" }
+    );
+  }
+});
+var appendCommand = defineCommand({
+  meta: {
+    name: "append",
+    description: "Append a new manifest entry (pipeline_manifest table). Accepts either a full --entry JSON blob / --file / stdin, OR the shorthand --task + --type + --content flags which build a valid entry with sensible defaults for id/file/title/date/etc."
+  },
+  args: {
+    entry: {
+      type: "string",
+      description: "JSON string of entry fields (full ManifestEntry shape)"
+    },
+    task: {
+      type: "string",
+      description: "Task ID to associate \u2014 becomes linked_tasks[0] + id prefix (shorthand)"
+    },
+    type: {
+      type: "string",
+      description: "Entry type \u2014 becomes agent_type (e.g. research, implementation, decomposition) (shorthand)"
+    },
+    content: {
+      type: "string",
+      description: "One-paragraph summary \u2014 becomes key_findings[0] and title (first line) (shorthand)"
+    },
+    title: {
+      type: "string",
+      description: "Explicit title override for shorthand mode"
+    },
+    status: {
+      type: "string",
+      description: "Entry status: completed (default) | partial | blocked (shorthand)"
+    },
+    file: {
+      type: "string",
+      description: "Path to JSON file containing entry"
+    }
+  },
+  async run({ args }) {
+    let entry;
+    const hasShorthand = Boolean(args.task || args.type || args.content);
+    if (args.entry) {
+      try {
+        entry = JSON.parse(args.entry);
+      } catch (_err) {
+        cliError("--entry must be valid JSON", 1, { name: "E_VALIDATION" });
+        process.exit(1);
+      }
+    } else if (args.file) {
+      try {
+        const fs = await import("node:fs");
+        const fileContent = fs.readFileSync(args.file, "utf-8");
+        entry = JSON.parse(fileContent);
+      } catch (_err) {
+        cliError(`failed to read or parse ${args.file}`, 1, { name: "E_VALIDATION" });
+        process.exit(1);
+      }
+    } else if (hasShorthand) {
+      entry = {
+        ...buildManifestEntryFromShorthand({
+          task: args.task,
+          type: args.type,
+          content: args.content,
+          title: args.title,
+          status: args.status
+        })
+      };
+    } else {
+      const stdinData = await readStdin();
+      if (!stdinData) {
+        cliError(
+          "must provide --entry JSON, --file path, stdin, or shorthand (--task + --type + --content)",
+          1,
+          { name: "E_VALIDATION" }
+        );
+        process.exit(1);
+      }
+      try {
+        entry = JSON.parse(stdinData);
+      } catch (_err) {
+        cliError("stdin must be valid JSON", 1, { name: "E_VALIDATION" });
+        process.exit(1);
+      }
+    }
+    if ((args.entry || args.file) && hasShorthand) {
+      if (args.task) {
+        entry.linked_tasks = Array.isArray(entry.linked_tasks) ? [args.task, ...entry.linked_tasks.filter((t) => t !== args.task)] : [args.task];
+      }
+      if (args.type) {
+        entry.agent_type = args.type;
+      }
+      if (args.content && !entry.key_findings) {
+        entry.key_findings = [args.content];
+      }
+      if (args.title) {
+        entry.title = args.title;
+      }
+      if (args.status) {
+        entry.status = args.status;
+      }
+    }
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "manifest.append",
+      { entry },
+      { command: "manifest append" }
+    );
+  }
+});
+var archiveCommand = defineCommand({
+  meta: {
+    name: "archive",
+    description: "Archive manifest entries"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Entry ID to archive"
+    },
+    "before-date": {
+      type: "string",
+      description: "Archive all active entries created before ISO date (YYYY-MM-DD)"
+    }
+  },
+  async run({ args }) {
+    if (!args.id && !args["before-date"]) {
+      cliError("must provide either <id> positional argument or --before-date flag", 1, {
+        name: "E_VALIDATION"
+      });
+      process.exit(1);
+    }
+    if (args.id && args["before-date"]) {
+      cliError("--before-date is mutually exclusive with <id> positional argument", 1, {
+        name: "E_VALIDATION"
+      });
+      process.exit(1);
+    }
+    const dispatchPayload = args.id ? { id: args.id } : { beforeDate: args["before-date"] };
+    await dispatchFromCli("mutate", "pipeline", "manifest.archive", dispatchPayload, {
+      command: "manifest archive"
+    });
+  }
+});
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data.trim());
+    });
+    process.stdin.on("error", reject);
+  });
+}
+var manifestCommand = defineCommand({
+  meta: {
+    name: "manifest",
+    description: "Manifest operations (pipeline_manifest table)"
+  },
+  subCommands: {
+    show: showCommand,
+    list: listCommand,
+    find: findCommand,
+    stats: statsCommand,
+    append: appendCommand,
+    archive: archiveCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  manifestCommand
+};
+//# sourceMappingURL=manifest-NMCW4PIW.js.map

package/dist/cli/map-BU72KMGF.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/map.ts
+var mapCommand = defineCommand({
+  meta: { name: "map", description: "Analyze codebase structure and return structured mapping" },
+  args: {
+    store: {
+      type: "boolean",
+      description: "Store findings to brain.db"
+    },
+    focus: {
+      type: "string",
+      description: "Focus on one area: stack, architecture, structure, conventions, testing, integrations, concerns"
+    }
+  },
+  async run({ args }) {
+    const gateway = args.store ? "mutate" : "query";
+    const params = {};
+    if (args.focus) params.focus = args.focus;
+    await dispatchFromCli(gateway, "admin", "map", params, { command: "map" });
+  }
+});
+export {
+  mapCommand
+};
+//# sourceMappingURL=map-BU72KMGF.js.map