@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/caamp-MFQVN6VU.js

@@ -0,0 +1,181 @@
+(() => {
+  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
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput,
+  humanLine
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/caamp.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var dedupeCommand = defineCommand({
+  meta: {
+    name: "dedupe",
+    description: "Remove duplicate CAAMP injection blocks from AGENTS.md files"
+  },
+  args: {
+    file: {
+      type: "string",
+      description: "Path to a specific AGENTS.md file to deduplicate (default: all standard locations)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be changed without writing",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const { dedupeFiles } = await import("@cleocode/caamp");
+    let filePaths;
+    if (args.file) {
+      filePaths = [args.file];
+    } else {
+      const home = homedir();
+      filePaths = [
+        join(home, ".agents", "AGENTS.md"),
+        // project-level AGENTS.md in cwd
+        join(process.cwd(), "AGENTS.md")
+      ];
+    }
+    if (args["dry-run"]) {
+      const { parseCaampBlocks } = await import("@cleocode/caamp");
+      const { existsSync } = await import("node:fs");
+      const { readFile } = await import("node:fs/promises");
+      const dryResults = [];
+      for (const filePath of filePaths) {
+        if (!existsSync(filePath)) {
+          dryResults.push({ filePath, exists: false, blockCount: 0, wouldRemove: 0 });
+          continue;
+        }
+        const content = await readFile(filePath, "utf-8");
+        const blocks = parseCaampBlocks(content);
+        const uniqueContents = new Set(blocks.map((b) => b.content));
+        const wouldRemove = blocks.length - uniqueContents.size;
+        dryResults.push({ filePath, exists: true, blockCount: blocks.length, wouldRemove });
+      }
+      cliOutput(
+        { dryRun: true, files: dryResults },
+        { command: "caamp", operation: "caamp.dedupe" }
+      );
+      return;
+    }
+    const results = await dedupeFiles(filePaths);
+    const totalRemoved = results.reduce((n, r) => n + r.removed, 0);
+    const filesModified = results.filter((r) => r.modified).length;
+    cliOutput(
+      {
+        dryRun: false,
+        filesProcessed: results.length,
+        filesModified,
+        totalRemoved,
+        files: results
+      },
+      { command: "caamp", operation: "caamp.dedupe" }
+    );
+  }
+});
+var repairCommand = defineCommand({
+  meta: {
+    name: "repair",
+    description: "Heal damaged CAAMP markers and remove duplicate blocks across all instruction files"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Report what would change without writing",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const { getInstalledProviders, instructionFileCascade, normalizeMarkers, parseBlocks } = await import("@cleocode/caamp");
+    const { existsSync } = await import("node:fs");
+    const { readFile } = await import("node:fs/promises");
+    const providers = getInstalledProviders();
+    const paths = instructionFileCascade(process.cwd(), providers).filter((p) => existsSync(p));
+    if (args["dry-run"]) {
+      const preview = [];
+      for (const filePath of paths) {
+        const raw = await readFile(filePath, "utf-8");
+        const { content, repaired } = normalizeMarkers(raw);
+        const blocks = parseBlocks(content);
+        const distinct = new Set(blocks.map((b) => b.content)).size;
+        preview.push({
+          filePath,
+          blocks: blocks.length,
+          damagedMarkers: repaired,
+          duplicateBlocks: blocks.length - distinct
+        });
+      }
+      cliOutput(
+        {
+          dryRun: true,
+          filesScanned: preview.length,
+          needsRepair: preview.filter((p) => p.damagedMarkers > 0 || p.duplicateBlocks > 0).length,
+          files: preview
+        },
+        { command: "caamp", operation: "caamp.repair" }
+      );
+      return;
+    }
+    const { repairInstructionFiles } = await import("@cleocode/caamp");
+    const result = await repairInstructionFiles(process.cwd(), providers);
+    cliOutput(
+      {
+        dryRun: false,
+        filesScanned: result.files.length,
+        filesModified: result.filesModified,
+        markersHealed: result.repaired,
+        duplicatesRemoved: result.removed,
+        files: result.files
+      },
+      { command: "caamp", operation: "caamp.repair" }
+    );
+  }
+});
+var caampCommand = defineCommand({
+  meta: {
+    name: "caamp",
+    description: "CAAMP injection management: repair markers, deduplicate blocks"
+  },
+  subCommands: {
+    dedupe: dedupeCommand,
+    repair: repairCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    humanLine("Usage: cleo caamp <subcommand>");
+    humanLine("");
+    humanLine("Subcommands:");
+    humanLine("  repair   Heal damaged CAAMP markers and remove duplicate blocks");
+    humanLine("  dedupe   Remove duplicate CAAMP injection blocks from AGENTS.md files");
+  }
+});
+export {
+  caampCommand
+};
+//# sourceMappingURL=caamp-MFQVN6VU.js.map

package/dist/cli/cancel-SCMJTXZB.js

@@ -0,0 +1,84 @@
+(() => {
+  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/cancel.ts
+var cancelCommand = defineCommand({
+  meta: {
+    name: "cancel",
+    description: "Cancel a task (soft terminal state; reversible via restore)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to cancel",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Reason for cancellation"
+    },
+    children: {
+      type: "string",
+      description: "Child handling mode: block (default), cascade (cancel subtree), or reparent (move children under --to)",
+      default: "block"
+    },
+    to: {
+      type: "string",
+      description: "Target parent ID for --children reparent (T11811): children move under this epic"
+    },
+    force: {
+      type: "boolean",
+      description: "Required waiver for cascade cancellation above the subtree threshold",
+      default: false
+    },
+    cascadeThreshold: {
+      type: "string",
+      description: "Maximum descendant count allowed for cascade without --force (default: 10)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "cancel",
+      {
+        taskId: args.taskId,
+        reason: args.reason,
+        children: args.children,
+        reparentTo: typeof args.to === "string" && args.to.length > 0 ? args.to : void 0,
+        force: args.force === true,
+        cascadeThreshold: typeof args.cascadeThreshold === "string" && args.cascadeThreshold.length > 0 ? Number.parseInt(args.cascadeThreshold, 10) : void 0
+      },
+      { command: "cancel", operation: "tasks.cancel" }
+    );
+  }
+});
+export {
+  cancelCommand
+};
+//# sourceMappingURL=cancel-SCMJTXZB.js.map

package/dist/cli/canon-NPF5RODM.js

@@ -0,0 +1,142 @@
+(() => {
+  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);
+  };
+})();
+
+// packages/cleo/src/dispatch/domains/check/canon.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var FORBIDDEN_PHRASES = [
+  "Four Great Systems",
+  "Four systems",
+  "Circle of Ten",
+  "exactly 10 domains",
+  "exactly ten domains"
+];
+var EXCLUDED_FILENAMES = [
+  "CLEO-CANT.md",
+  "CLEO-AWAKENING-STORY.md",
+  "CLEO-FOUNDING-STORY.md",
+  "CLEO-MANIFESTO.md"
+];
+function readLines(filePath) {
+  try {
+    return readFileSync(filePath, "utf8").split("\n");
+  } catch {
+    return [];
+  }
+}
+function scanForbiddenPhrases(filePath, lines) {
+  const results = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const phrase of FORBIDDEN_PHRASES) {
+      if (line.includes(phrase)) {
+        results.push({ file: filePath, line: i + 1, phrase });
+      }
+    }
+  }
+  return results;
+}
+function countCanonicalDomains(typesFilePath) {
+  const lines = readLines(typesFilePath);
+  let inArray = false;
+  let count = 0;
+  for (const line of lines) {
+    if (!inArray) {
+      if (line.includes("CANONICAL_DOMAINS") && line.includes("[")) {
+        inArray = true;
+      }
+      continue;
+    }
+    if (line.includes("] as const")) {
+      break;
+    }
+    const trimmed = line.trim();
+    if (trimmed.startsWith("'") && trimmed.includes("'")) {
+      count++;
+    }
+  }
+  return count;
+}
+function countOperations(registryFilePath) {
+  const lines = readLines(registryFilePath);
+  let count = 0;
+  for (const line of lines) {
+    if (/^\s*gateway:/.test(line)) {
+      count++;
+    }
+  }
+  return count;
+}
+function runCanonCheck(params) {
+  const { projectRoot } = params;
+  const typesFile = join(projectRoot, "packages/cleo/src/dispatch/types.ts");
+  const registryFile = join(projectRoot, "packages/cleo/src/dispatch/registry.ts");
+  const archGuide = join(projectRoot, "docs/concepts/CLEO-ARCHITECTURE-GUIDE.md");
+  const visionDoc = join(projectRoot, "docs/concepts/CLEO-VISION.md");
+  const constitution = join(projectRoot, "docs/specs/CLEO-OPERATION-CONSTITUTION.md");
+  const domainsInCode = countCanonicalDomains(typesFile);
+  const operationsInCode = countOperations(registryFile);
+  const excludedSet = new Set(EXCLUDED_FILENAMES);
+  const auditedDocs = [archGuide, visionDoc, constitution].filter((f) => {
+    const basename = f.split("/").pop() ?? "";
+    return !excludedSet.has(basename);
+  });
+  const allViolations = [];
+  for (const docPath of auditedDocs) {
+    const lines = readLines(docPath);
+    allViolations.push(...scanForbiddenPhrases(docPath, lines));
+  }
+  const assertions = [];
+  const archLines = readLines(archGuide);
+  const archText = archLines.join("\n");
+  assertions.push({
+    file: archGuide,
+    assertion: 'Contains "Six Great Systems"',
+    passed: archText.includes("Six Great Systems")
+  });
+  assertions.push({
+    file: archGuide,
+    assertion: 'Contains "Circle of Eleven"',
+    passed: archText.includes("Circle of Eleven")
+  });
+  const visionLines = readLines(visionDoc);
+  const visionText = visionLines.join("\n");
+  assertions.push({
+    file: visionDoc,
+    assertion: "Contains reference to six systems",
+    passed: visionText.includes("six systems") || visionText.includes("Six systems") || visionText.includes("6 systems") || visionText.includes("six canonical systems")
+  });
+  const constLines = readLines(constitution);
+  const constText = constLines.join("\n");
+  assertions.push({
+    file: constitution,
+    assertion: 'Contains "11 canonical domains"',
+    passed: constText.includes("11 canonical domains") || constText.includes("eleven canonical domains")
+  });
+  const allAssertionsPassed = assertions.every((a) => a.passed);
+  const passed = allViolations.length === 0 && allAssertionsPassed;
+  return {
+    domainsInCode,
+    operationsInCode,
+    violations: allViolations,
+    assertions,
+    passed
+  };
+}
+export {
+  runCanonCheck
+};
+//# sourceMappingURL=canon-NPF5RODM.js.map

package/dist/cli/canon-docs-2GTOLF7Y.js

@@ -0,0 +1,26 @@
+(() => {
+  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 {
+  CanonDocsDiffError,
+  loadCanonRegistry,
+  runCanonDocsCheck
+} from "./chunk-SXXOC6KZ.js";
+export {
+  CanonDocsDiffError,
+  loadCanonRegistry,
+  runCanonDocsCheck
+};
+//# sourceMappingURL=canon-docs-2GTOLF7Y.js.map

package/dist/cli/cant-46XCUP4P.js

@@ -0,0 +1,239 @@
+(() => {
+  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,
+  humanWarn
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/cant.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+function resolveFilePath(file) {
+  return isAbsolute(file) ? file : resolve(process.cwd(), file);
+}
+function ensureExists(filePath, operation) {
+  if (existsSync(filePath)) return true;
+  cliError(`File not found: ${filePath}`, "E_FILE_READ");
+  process.exitCode = 3;
+  if (process.env["CLEO_DEBUG"]) humanWarn(`(operation: ${operation})`);
+  return false;
+}
+function emitFailure(operation, code, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  cliError(`${operation} failed: ${message}`, code);
+  process.exitCode = process.exitCode ?? 1;
+}
+async function loadCantDocument() {
+  const paths = ["@cleocode/cant", "../../../../cant/dist/index", "../../../../cant/src/index"];
+  for (const p of paths) {
+    try {
+      const mod = await import(p);
+      if (typeof mod["parseDocument"] === "function" && typeof mod["validateDocument"] === "function" && typeof mod["listSections"] === "function" && typeof mod["executePipeline"] === "function") {
+        return mod;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Cannot load CANT document API. Ensure @cleocode/cant is installed.");
+}
+async function loadMigrateEngine() {
+  const paths = ["@cleocode/cant", "../../../../cant/dist/index", "../../../../cant/src/index"];
+  for (const p of paths) {
+    try {
+      const mod = await import(p);
+      if (typeof mod["migrateMarkdown"] === "function" && typeof mod["showDiff"] === "function") {
+        return mod;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Cannot load CANT migration engine. Ensure @cleocode/cant is installed.");
+}
+var cantParseCommand = defineCommand({
+  meta: { name: "parse", description: "Parse a .cant file and emit the AST" },
+  args: { file: { type: "positional", description: ".cant file to parse", required: true } },
+  async run({ args }) {
+    const filePath = resolveFilePath(args.file);
+    if (!ensureExists(filePath, "cant.parse")) return;
+    try {
+      const mod = await loadCantDocument();
+      const result = await mod.parseDocument(filePath);
+      cliOutput(result, { command: "cant", operation: "cant.parse" });
+    } catch (err) {
+      emitFailure("cant.parse", "E_PARSE_FAILED", err);
+    }
+  }
+});
+var cantValidateCommand = defineCommand({
+  meta: { name: "validate", description: "Run the 42-rule validation suite on a .cant file" },
+  args: { file: { type: "positional", description: ".cant file to validate", required: true } },
+  async run({ args }) {
+    const filePath = resolveFilePath(args.file);
+    if (!ensureExists(filePath, "cant.validate")) return;
+    try {
+      const mod = await loadCantDocument();
+      const result = await mod.validateDocument(filePath);
+      cliOutput(result, { command: "cant", operation: "cant.validate" });
+    } catch (err) {
+      emitFailure("cant.validate", "E_VALIDATE_FAILED", err);
+    }
+  }
+});
+var cantListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List agents, workflows, or pipelines in a .cant file"
+  },
+  args: {
+    file: { type: "positional", description: ".cant file to inspect", required: true },
+    kind: {
+      type: "string",
+      description: "One of: agent | workflow | pipeline (default: agent)",
+      default: "agent"
+    }
+  },
+  async run({ args }) {
+    const filePath = resolveFilePath(args.file);
+    if (!ensureExists(filePath, "cant.list")) return;
+    const kind = (args.kind ?? "agent").toLowerCase();
+    if (kind !== "agent" && kind !== "pipeline" && kind !== "workflow") {
+      cliError(`Invalid --kind '${kind}'. Use one of: agent, pipeline, workflow.`, "E_BAD_KIND");
+      process.exitCode = 2;
+      return;
+    }
+    try {
+      const mod = await loadCantDocument();
+      const result = await mod.listSections(filePath, kind);
+      cliOutput(result, { command: "cant", operation: `cant.list-${kind}s` });
+    } catch (err) {
+      emitFailure(`cant.list-${kind}s`, "E_LIST_FAILED", err);
+    }
+  }
+});
+var cantExecuteCommand = defineCommand({
+  meta: {
+    name: "execute",
+    description: "Execute a deterministic pipeline from a .cant file. LLM-dependent workflow constructs run via the cant-bridge."
+  },
+  args: {
+    file: { type: "positional", description: ".cant file to execute", required: true },
+    pipeline: { type: "string", description: "Pipeline name to execute", required: true }
+  },
+  async run({ args }) {
+    const filePath = resolveFilePath(args.file);
+    if (!ensureExists(filePath, "cant.execute")) return;
+    const pipelineName = args.pipeline;
+    try {
+      const mod = await loadCantDocument();
+      const result = await mod.executePipeline(filePath, pipelineName);
+      cliOutput(result, { command: "cant", operation: "cant.execute" });
+      if (!result.success) process.exitCode = 1;
+    } catch (err) {
+      emitFailure("cant.execute", "E_PIPELINE_RUNTIME", err);
+      process.exitCode = 1;
+    }
+  }
+});
+var cantMigrateCommand = defineCommand({
+  meta: { name: "migrate", description: "Convert markdown instruction files to .cant format" },
+  args: {
+    file: { type: "positional", description: "Markdown file to migrate", required: true },
+    write: { type: "boolean", description: "Write .cant files to disk (default: dry-run preview)" },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview conversion without writing files (default behavior)"
+    },
+    "output-dir": {
+      type: "string",
+      description: "Output directory for .cant files (default: .cleo/agents/)"
+    },
+    verbose: { type: "boolean", description: "Show detailed conversion log" }
+  },
+  async run({ args }) {
+    const isWrite = !!args.write && !args["dry-run"];
+    const isVerbose = !!args.verbose;
+    const filePath = resolveFilePath(args.file);
+    if (!ensureExists(filePath, "cant.migrate")) return;
+    try {
+      const mod = await loadMigrateEngine();
+      const content = readFileSync(filePath, "utf-8");
+      const result = mod.migrateMarkdown(content, filePath, {
+        write: isWrite,
+        verbose: isVerbose,
+        outputDir: args["output-dir"]
+      });
+      if (isWrite) {
+        const projectRoot = process.cwd();
+        let written = 0;
+        for (const outputFile of result.outputFiles) {
+          const outputPath = isAbsolute(outputFile.path) ? outputFile.path : join(projectRoot, outputFile.path);
+          mkdirSync(dirname(outputPath), { recursive: true });
+          writeFileSync(outputPath, outputFile.content, "utf-8");
+          written++;
+        }
+        cliOutput(
+          {
+            inputFile: result.inputFile,
+            filesWritten: written,
+            outputFiles: result.outputFiles.map((f) => ({ path: f.path, kind: f.kind })),
+            unconverted: result.unconverted,
+            summary: result.summary
+          },
+          { command: "cant-migrate", operation: "cant.migrate" }
+        );
+      } else {
+        cliOutput(
+          {
+            inputFile: result.inputFile,
+            dryRun: true,
+            outputFiles: result.outputFiles.map((f) => ({ path: f.path, kind: f.kind })),
+            unconverted: result.unconverted,
+            summary: result.summary
+          },
+          { command: "cant-migrate", operation: "cant.migrate" }
+        );
+      }
+    } catch (err) {
+      emitFailure("cant.migrate", "E_MIGRATION_FAILED", err);
+      process.exitCode = 1;
+    }
+  }
+});
+var cantCommand = defineCommand({
+  meta: { name: "cant", description: "CANT DSL tooling" },
+  subCommands: {
+    parse: cantParseCommand,
+    validate: cantValidateCommand,
+    list: cantListCommand,
+    execute: cantExecuteCommand,
+    migrate: cantMigrateCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  cantCommand
+};
+//# sourceMappingURL=cant-46XCUP4P.js.map