@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/add-batch-U2DLKAQC.js

@@ -0,0 +1,163 @@
+(() => {
+  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 {
+  collectMutateInput
+} from "./chunk-QA6T2LQ5.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchRaw,
+  maybeEmitDescribe
+} 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/add-batch.ts
+import { ExitCode } from "@cleocode/contracts";
+import { INPUT_CONTRACTS, validateOperationInput } from "@cleocode/core";
+var addBatchCommand = defineCommand({
+  meta: {
+    name: "add-batch",
+    description: "Create multiple tasks in a single atomic transaction from a JSON file"
+  },
+  args: {
+    params: {
+      type: "string",
+      description: 'Inline JSON object: { "tasks": [...], "defaultParent"?: "...", "dryRun"?: bool } (T9917)'
+    },
+    file: {
+      type: "string",
+      description: "Path to JSON file (array of task objects, or full payload). Use - for stdin."
+    },
+    parent: {
+      type: "string",
+      description: "Default parent for all tasks (overridden by per-task parent)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be created without making changes"
+    }
+  },
+  async run({ args }) {
+    if (maybeEmitDescribe("mutate", "tasks", "add-batch", { command: "add-batch" })) return;
+    const defaultParent = args.parent;
+    const dryRunFlag = args["dry-run"];
+    const paramsArg = args.params;
+    const fileArg = args.file;
+    const collectArgs = {};
+    if (paramsArg !== void 0) collectArgs.params = paramsArg;
+    if (fileArg !== void 0 && fileArg !== "-") collectArgs.file = fileArg;
+    let raw;
+    try {
+      raw = await collectMutateInput(
+        collectArgs,
+        process.stdin
+      );
+    } catch (err) {
+      cliError(
+        err.message,
+        ExitCode.VALIDATION_ERROR,
+        {
+          name: "E_VALIDATION_FAILED",
+          fix: "Verify the JSON syntax of your --params / --file / stdin input"
+        },
+        { operation: "tasks.add-batch" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    if (raw === void 0) {
+      cliError(
+        "No input provided. Pass --params <json>, --file <path>, or pipe JSON to stdin.",
+        ExitCode.VALIDATION_ERROR,
+        {
+          name: "E_VALIDATION_FAILED",
+          fix: "cleo add-batch --file tasks.json"
+        },
+        { operation: "tasks.add-batch" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    let payload;
+    if (Array.isArray(raw)) {
+      payload = { tasks: raw };
+    } else if (raw !== null && typeof raw === "object" && Array.isArray(raw["tasks"])) {
+      payload = { ...raw };
+    } else {
+      payload = { tasks: [raw] };
+    }
+    if (defaultParent !== void 0 && payload["defaultParent"] === void 0) {
+      payload["defaultParent"] = defaultParent;
+    }
+    if (dryRunFlag === true && payload["dryRun"] === void 0) {
+      payload["dryRun"] = true;
+    }
+    const contract = INPUT_CONTRACTS["tasks.add-batch"];
+    if (!contract) {
+      cliError(
+        "tasks.add-batch contract missing from INPUT_CONTRACTS registry",
+        ExitCode.GENERAL_ERROR,
+        { name: "E_INTERNAL", fix: "This is a CLI bug \u2014 file an issue" },
+        { operation: "tasks.add-batch" }
+      );
+      process.exitCode = ExitCode.GENERAL_ERROR;
+      return;
+    }
+    const result = validateOperationInput(contract, payload);
+    if (!result.ok) {
+      cliError(
+        "tasks.add-batch failed: validation",
+        ExitCode.VALIDATION_ERROR,
+        {
+          name: "E_VALIDATION_FAILED",
+          fix: result.errors[0]?.fix ?? "Inspect the errors[] payload and correct the input",
+          details: { errors: result.errors }
+        },
+        { operation: "tasks.add-batch" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    const response = await dispatchRaw("mutate", "tasks", "add-batch", payload);
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Batch creation failed",
+        response.error?.code ?? "E_BATCH_FAILED",
+        {
+          name: response.error?.code ?? "E_BATCH_FAILED",
+          fix: response.error?.fix ?? "Check task specs and try again"
+        },
+        { operation: "tasks.add-batch" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, { command: "add-batch", operation: "tasks.add-batch" });
+  }
+});
+export {
+  addBatchCommand
+};
+//# sourceMappingURL=add-batch-U2DLKAQC.js.map

package/dist/cli/admin-I7BQYVZD.js

@@ -0,0 +1,340 @@
+(() => {
+  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/admin.ts
+var versionCommand = defineCommand({
+  meta: { name: "version", description: "Show CLEO version" },
+  async run() {
+    await dispatchFromCli("query", "admin", "version", {}, { command: "admin" });
+  }
+});
+var healthCommand = defineCommand({
+  meta: { name: "health", description: "Run system health check" },
+  args: {
+    detailed: {
+      type: "boolean",
+      description: "Show detailed results"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "health",
+      { detailed: args.detailed },
+      { command: "admin" }
+    );
+  }
+});
+var statsCommand = defineCommand({
+  meta: { name: "stats", description: "Show project statistics" },
+  args: {
+    period: {
+      type: "string",
+      description: "Time period in days"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "stats",
+      { period: args.period ? Number(args.period) : void 0 },
+      { command: "admin" }
+    );
+  }
+});
+var runtimeCommand = defineCommand({
+  meta: { name: "runtime", description: "Show runtime diagnostics" },
+  args: {
+    detailed: {
+      type: "boolean",
+      description: "Show detailed runtime info"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "runtime",
+      { detailed: args.detailed },
+      { command: "admin" }
+    );
+  }
+});
+var smokeCommand = defineCommand({
+  meta: {
+    name: "smoke",
+    description: "Run operational smoke tests across all domains, or probe ADR-049 invariants for a named provider (--provider)"
+  },
+  args: {
+    provider: {
+      type: "string",
+      description: "Probe harness sovereignty invariants for a specific provider adapter (ADR-049)"
+    }
+  },
+  async run({ args }) {
+    const provider = args.provider;
+    if (provider) {
+      await dispatchFromCli(
+        "query",
+        "admin",
+        "smoke.provider",
+        { provider },
+        { command: "admin smoke", operation: "admin.smoke.provider" }
+      );
+    } else {
+      await dispatchFromCli("query", "admin", "smoke", {}, { command: "admin" });
+    }
+  }
+});
+var pathsCommand = defineCommand({
+  meta: {
+    name: "paths",
+    description: "Report all CleoOS paths (project + global hub) and scaffolding status"
+  },
+  async run() {
+    await dispatchFromCli("query", "admin", "paths", {}, { command: "admin" });
+  }
+});
+var scaffoldHubCommand = defineCommand({
+  meta: {
+    name: "scaffold-hub",
+    description: "Create CleoOS Hub dirs (global-recipes, pi-extensions, cant-workflows, agents) and seed starter justfile"
+  },
+  async run() {
+    await dispatchFromCli("mutate", "admin", "scaffold-hub", {}, { command: "admin" });
+  }
+});
+var cleanupCommand = defineCommand({
+  meta: { name: "cleanup", description: "Purge stale CLEO data (backups, logs, archive entries)" },
+  args: {
+    target: {
+      type: "string",
+      description: "What to clean: backups | logs | archive | sessions",
+      required: true
+    },
+    "older-than": {
+      type: "string",
+      description: "Remove entries older than this duration (e.g. 30d, 6m, 1y)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be removed without making changes"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "cleanup",
+      {
+        target: args.target,
+        olderThan: args["older-than"],
+        dryRun: args["dry-run"] === true
+      },
+      { command: "admin cleanup", operation: "admin.cleanup" }
+    );
+  }
+});
+var jobListCommand = defineCommand({
+  meta: { name: "list", description: "List all background jobs (default)" },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter by job status (pending, running, done, failed, cancelled)"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum jobs to return",
+      default: "20"
+    },
+    offset: {
+      type: "string",
+      description: "Skip N jobs",
+      default: "0"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "job",
+      {
+        action: "list",
+        status: args.status,
+        limit: args.limit ? Number(args.limit) : 20,
+        offset: args.offset ? Number(args.offset) : 0
+      },
+      { command: "admin job list", operation: "admin.job" }
+    );
+  }
+});
+var jobStatusCommand = defineCommand({
+  meta: { name: "status", description: "Show status of a specific background job" },
+  args: {
+    jobId: {
+      type: "positional",
+      description: "Job ID to inspect",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "job",
+      { action: "status", jobId: args.jobId },
+      { command: "admin job status", operation: "admin.job" }
+    );
+  }
+});
+var jobCancelCommand = defineCommand({
+  meta: { name: "cancel", description: "Cancel a running background job" },
+  args: {
+    jobId: {
+      type: "positional",
+      description: "Job ID to cancel",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "job.cancel",
+      { jobId: args.jobId },
+      { command: "admin job cancel", operation: "admin.job.cancel" }
+    );
+  }
+});
+var jobCommand = defineCommand({
+  meta: { name: "job", description: "Inspect background jobs managed by the job manager" },
+  subCommands: {
+    list: jobListCommand,
+    status: jobStatusCommand,
+    cancel: jobCancelCommand
+  },
+  async run({ rawArgs }) {
+    const hasSubCmd = rawArgs.some((a) => ["list", "status", "cancel"].includes(a));
+    if (!hasSubCmd) {
+      await dispatchFromCli(
+        "query",
+        "admin",
+        "job",
+        { action: "list", limit: 20, offset: 0 },
+        { command: "admin job list", operation: "admin.job" }
+      );
+    }
+  }
+});
+var installGlobalCommand = defineCommand({
+  meta: {
+    name: "install-global",
+    description: "Refresh global CLEO setup (provider files, configs, ~/.agents/AGENTS.md)"
+  },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "install.global",
+      {},
+      { command: "admin install-global", operation: "admin.install.global" }
+    );
+  }
+});
+var contextInjectCommand = defineCommand({
+  meta: {
+    name: "context-inject",
+    description: "Inject protocol content into session context (e.g. cleo-base, ct-orchestrator, ct-cleo)"
+  },
+  args: {
+    protocolType: {
+      type: "positional",
+      description: "Protocol type to inject",
+      required: true
+    },
+    task: {
+      type: "string",
+      description: "Scope injection to a specific task ID"
+    },
+    variant: {
+      type: "string",
+      description: "Select a named protocol variant"
+    }
+  },
+  async run({ args }) {
+    const protocolType = args.protocolType;
+    if (!protocolType || protocolType.trim() === "") {
+      cliError("missing required argument <protocolType>", 1, {
+        name: "E_VALIDATION",
+        fix: "Usage: cleo admin context-inject <protocolType> [--task <id>] [--variant <variant>]"
+      });
+      process.exit(1);
+    }
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "context.inject",
+      {
+        protocolType,
+        taskId: args.task,
+        variant: args.variant
+      },
+      { command: "admin context-inject", operation: "admin.context.inject" }
+    );
+  }
+});
+var adminCommand = defineCommand({
+  meta: { name: "admin", description: "System administration and diagnostics" },
+  subCommands: {
+    version: versionCommand,
+    health: healthCommand,
+    stats: statsCommand,
+    runtime: runtimeCommand,
+    smoke: smokeCommand,
+    paths: pathsCommand,
+    "scaffold-hub": scaffoldHubCommand,
+    cleanup: cleanupCommand,
+    job: jobCommand,
+    "install-global": installGlobalCommand,
+    "context-inject": contextInjectCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  adminCommand
+};
+//# sourceMappingURL=admin-I7BQYVZD.js.map

package/dist/cli/adr-K2THMQBS.js

@@ -0,0 +1,171 @@
+(() => {
+  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/adr.ts
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate frontmatter on all .cleo/adrs/*.md files against ADR-017 schema"
+  },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "adr.sync",
+      { validate: true },
+      { command: "adr validate", operation: "admin.adr.sync" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List ADRs from .cleo/adrs/"
+  },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter by status: proposed | accepted | superseded | deprecated"
+    },
+    since: {
+      type: "string",
+      description: "Filter to ADRs created on or after YYYY-MM-DD"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "adr.find",
+      {
+        status: args.status,
+        since: args.since
+      },
+      { command: "adr list", operation: "admin.adr.find" }
+    );
+  }
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show full details for a single ADR (e.g., cleo adr show ADR-017)"
+  },
+  args: {
+    adrId: {
+      type: "positional",
+      description: "ADR identifier (e.g., ADR-017)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "adr.show",
+      { adrId: args.adrId },
+      { command: "adr show", operation: "admin.adr.show" }
+    );
+  }
+});
+var syncCommand = defineCommand({
+  meta: {
+    name: "sync",
+    description: "Sync .cleo/adrs/ markdown files into the architecture_decisions DB table"
+  },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "adr.sync",
+      {},
+      { command: "adr sync", operation: "admin.adr.sync" }
+    );
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Fuzzy search ADRs by title, summary, keywords, and topics"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query string",
+      required: true
+    },
+    topics: {
+      type: "string",
+      description: "Filter by topics (comma-separated domain tags)"
+    },
+    keywords: {
+      type: "string",
+      description: "Filter by keywords (comma-separated tags)"
+    },
+    status: {
+      type: "string",
+      description: "Filter by status: proposed | accepted | superseded | deprecated"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "adr.find",
+      {
+        query: args.query,
+        topics: args.topics,
+        keywords: args.keywords,
+        status: args.status
+      },
+      { command: "adr find", operation: "admin.adr.find" }
+    );
+  }
+});
+var adrCommand = defineCommand({
+  meta: {
+    name: "adr",
+    description: "Manage and validate Architecture Decision Records in .cleo/adrs/"
+  },
+  subCommands: {
+    validate: validateCommand,
+    list: listCommand,
+    show: showCommand,
+    sync: syncCommand,
+    find: findCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  adrCommand
+};
+//# sourceMappingURL=adr-K2THMQBS.js.map