@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/templates-7O77TKPV.js

@@ -0,0 +1,611 @@
+(() => {
+  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 "./chunk-C3B7C43W.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/templates/diff.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
+import { ExitCode } from "@cleocode/contracts";
+import { getTemplateById } from "@cleocode/core/templates/registry";
+
+// packages/cleo/src/cli/commands/templates/lib.ts
+import { readFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { getProjectRoot } from "@cleocode/core";
+import { resolveSourcePathAbsolute } from "@cleocode/core/templates/registry";
+function resolveProjectRoot(raw) {
+  if (typeof raw === "string" && raw.length > 0) {
+    return isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
+  }
+  return getProjectRoot();
+}
+function readTemplateSource(entry) {
+  const sourceAbsolute = resolveSourcePathAbsolute(entry);
+  return readFileSync(sourceAbsolute, "utf8");
+}
+function applySubstitution(entry, source) {
+  if (entry.substitution === "static") {
+    return { rendered: source, substituted: false };
+  }
+  return { rendered: source, substituted: false };
+}
+
+// packages/cleo/src/cli/commands/templates/diff.ts
+var templatesDiffCommand = defineCommand({
+  meta: {
+    name: "diff",
+    description: "Diff a template against its installed copy (exit 0 same, 1 different)"
+  },
+  args: {
+    id: {
+      type: "positional",
+      required: true,
+      description: "Template id (kebab-case)"
+    },
+    project: {
+      type: "string",
+      description: "Project root to diff against (default: detected project root)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const id = String(args["id"] ?? "").trim();
+    if (id.length === 0) {
+      cliError(`templates diff failed: <id> is required`, ExitCode.INVALID_INPUT, {
+        name: "E_TEMPLATES_DIFF_FAILED"
+      });
+      process.exit(ExitCode.INVALID_INPUT);
+      return;
+    }
+    const entry = getTemplateById(id);
+    if (entry === void 0) {
+      cliError(`templates diff failed: id "${id}" not found`, ExitCode.NOT_FOUND, {
+        name: "E_NOT_FOUND",
+        details: { id }
+      });
+      process.exit(ExitCode.NOT_FOUND);
+      return;
+    }
+    let projectRoot;
+    let installPath;
+    let rendered;
+    try {
+      projectRoot = resolveProjectRoot(args["project"]);
+      installPath = join(projectRoot, entry.installPath);
+      const source = readTemplateSource(entry);
+      rendered = applySubstitution(entry, source).rendered;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`templates diff failed: ${message}`, ExitCode.GENERAL_ERROR, {
+        name: "E_TEMPLATES_DIFF_FAILED"
+      });
+      process.exit(ExitCode.GENERAL_ERROR);
+      return;
+    }
+    if (!existsSync(installPath)) {
+      const missingResult = {
+        id,
+        installPath,
+        same: false,
+        missing: true,
+        diff: `--- (missing) ${installPath}
++++ (rendered) ${id}
+${unifiedDiff("", rendered)}`
+      };
+      cliOutput(missingResult, {
+        command: "templates-diff",
+        operation: "templates.diff"
+      });
+      process.exit(ExitCode.GENERAL_ERROR);
+      return;
+    }
+    const current = readFileSync2(installPath, "utf8");
+    const same = current === rendered;
+    const result = {
+      id,
+      installPath,
+      same,
+      missing: false,
+      diff: same ? "" : unifiedDiff(current, rendered)
+    };
+    cliOutput(result, {
+      command: "templates-diff",
+      operation: "templates.diff"
+    });
+    if (!same) {
+      process.exit(ExitCode.GENERAL_ERROR);
+    }
+  }
+});
+function unifiedDiff(a, b) {
+  const aLines = a.length === 0 ? [] : a.split("\n");
+  const bLines = b.length === 0 ? [] : b.split("\n");
+  const out = [];
+  const max = Math.max(aLines.length, bLines.length);
+  for (let i = 0; i < max; i += 1) {
+    const av = aLines[i];
+    const bv = bLines[i];
+    if (av === bv) {
+      if (av !== void 0) out.push(` ${av}`);
+      continue;
+    }
+    if (av !== void 0) out.push(`-${av}`);
+    if (bv !== void 0) out.push(`+${bv}`);
+  }
+  return out.join("\n");
+}
+
+// packages/cleo/src/cli/commands/templates/install.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { ExitCode as ExitCode2 } from "@cleocode/contracts";
+import { getTemplateById as getTemplateById2 } from "@cleocode/core/templates/registry";
+var templatesInstallCommand = defineCommand({
+  meta: {
+    name: "install",
+    description: "Install a template into a project root (default: current project), idempotent"
+  },
+  args: {
+    id: {
+      type: "positional",
+      required: true,
+      description: "Template id (kebab-case)"
+    },
+    project: {
+      type: "string",
+      description: "Project root to install into (default: detected project root)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const id = String(args["id"] ?? "").trim();
+    if (id.length === 0) {
+      cliError(`templates install failed: <id> is required`, ExitCode2.INVALID_INPUT, {
+        name: "E_TEMPLATES_INSTALL_FAILED"
+      });
+      process.exit(ExitCode2.INVALID_INPUT);
+      return;
+    }
+    const entry = getTemplateById2(id);
+    if (entry === void 0) {
+      cliError(`templates install failed: id "${id}" not found`, ExitCode2.NOT_FOUND, {
+        name: "E_NOT_FOUND",
+        details: { id }
+      });
+      process.exit(ExitCode2.NOT_FOUND);
+      return;
+    }
+    let projectRoot;
+    let installPath;
+    let rendered;
+    let substituted;
+    try {
+      projectRoot = resolveProjectRoot(args["project"]);
+      installPath = join2(projectRoot, entry.installPath);
+      const source = readTemplateSource(entry);
+      const sub = applySubstitution(entry, source);
+      rendered = sub.rendered;
+      substituted = sub.substituted;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`templates install failed: ${message}`, ExitCode2.GENERAL_ERROR, {
+        name: "E_TEMPLATES_INSTALL_FAILED"
+      });
+      process.exit(ExitCode2.GENERAL_ERROR);
+      return;
+    }
+    if (existsSync2(installPath)) {
+      const current = readFileSync3(installPath, "utf8");
+      if (current === rendered) {
+        const noopResult = {
+          id,
+          installPath,
+          installed: false,
+          noop: true,
+          substituted
+        };
+        cliOutput(noopResult, {
+          command: "templates-install",
+          operation: "templates.install"
+        });
+        return;
+      }
+    }
+    try {
+      mkdirSync(dirname(installPath), { recursive: true });
+      writeFileSync(installPath, rendered, "utf8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`templates install failed: ${message}`, ExitCode2.GENERAL_ERROR, {
+        name: "E_TEMPLATES_INSTALL_FAILED"
+      });
+      process.exit(ExitCode2.GENERAL_ERROR);
+      return;
+    }
+    const result = {
+      id,
+      installPath,
+      installed: true,
+      noop: false,
+      substituted
+    };
+    cliOutput(result, {
+      command: "templates-install",
+      operation: "templates.install"
+    });
+  }
+});
+
+// packages/cleo/src/cli/commands/templates/list.ts
+import {
+  ExitCode as ExitCode3,
+  TEMPLATE_KINDS
+} from "@cleocode/contracts";
+import { getTemplateManifest, getTemplatesByKind } from "@cleocode/core/templates/registry";
+var templatesListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List every template the registry knows about (optionally filtered by --kind)"
+  },
+  args: {
+    kind: {
+      type: "string",
+      description: `Optional kind filter: ${TEMPLATE_KINDS.join(" | ")}`
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const rawKind = args["kind"];
+    const kind = parseTemplateKind(typeof rawKind === "string" ? rawKind : void 0);
+    if (kind === null && rawKind !== void 0 && rawKind !== "") {
+      cliError(
+        `templates list failed: invalid --kind (must be ${TEMPLATE_KINDS.join("|")})`,
+        ExitCode3.INVALID_INPUT,
+        { name: "E_TEMPLATES_LIST_FAILED" }
+      );
+      process.exit(ExitCode3.INVALID_INPUT);
+      return;
+    }
+    const entries = kind === null ? getTemplateManifest() : getTemplatesByKind(kind);
+    const result = { kind, entries };
+    cliOutput(result, {
+      command: "templates-list",
+      operation: "templates.list"
+    });
+  }
+});
+function parseTemplateKind(raw) {
+  if (raw === void 0 || raw === "") return null;
+  return TEMPLATE_KINDS.includes(raw) ? raw : null;
+}
+
+// packages/cleo/src/cli/commands/templates/show.ts
+import { ExitCode as ExitCode4 } from "@cleocode/contracts";
+import { getTemplateById as getTemplateById3 } from "@cleocode/core/templates/registry";
+var templatesShowCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Print a single template manifest entry by id"
+  },
+  args: {
+    id: {
+      type: "positional",
+      required: true,
+      description: "Template id (kebab-case)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const id = String(args["id"] ?? "").trim();
+    if (id.length === 0) {
+      cliError(`templates show failed: <id> is required`, ExitCode4.INVALID_INPUT, {
+        name: "E_TEMPLATES_SHOW_FAILED"
+      });
+      process.exit(ExitCode4.INVALID_INPUT);
+      return;
+    }
+    const entry = getTemplateById3(id);
+    if (entry === void 0) {
+      cliError(`templates show failed: id "${id}" not found`, ExitCode4.NOT_FOUND, {
+        name: "E_NOT_FOUND",
+        details: { id }
+      });
+      process.exit(ExitCode4.NOT_FOUND);
+      return;
+    }
+    const result = { id, entry };
+    cliOutput(result, {
+      command: "templates-show",
+      operation: "templates.show"
+    });
+  }
+});
+
+// packages/cleo/src/cli/commands/templates/upgrade.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { ExitCode as ExitCode5 } from "@cleocode/contracts";
+import { getTemplateById as getTemplateById4 } from "@cleocode/core/templates/registry";
+var templatesUpgradeCommand = defineCommand({
+  meta: {
+    name: "upgrade",
+    description: "Re-install a template respecting its updateStrategy (overwrite | diff-prompt | immutable | manifest-merge)"
+  },
+  args: {
+    id: {
+      type: "positional",
+      required: true,
+      description: "Template id (kebab-case)"
+    },
+    project: {
+      type: "string",
+      description: "Project root to upgrade against (default: detected project root)"
+    },
+    diff: {
+      type: "boolean",
+      description: "Preview-only \u2014 print the diff without writing"
+    },
+    accept: {
+      type: "boolean",
+      description: "Apply when strategy is diff-prompt (no-op otherwise)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const id = String(args["id"] ?? "").trim();
+    if (id.length === 0) {
+      cliError(`templates upgrade failed: <id> is required`, ExitCode5.INVALID_INPUT, {
+        name: "E_TEMPLATES_UPGRADE_FAILED"
+      });
+      process.exit(ExitCode5.INVALID_INPUT);
+      return;
+    }
+    const entry = getTemplateById4(id);
+    if (entry === void 0) {
+      cliError(`templates upgrade failed: id "${id}" not found`, ExitCode5.NOT_FOUND, {
+        name: "E_NOT_FOUND",
+        details: { id }
+      });
+      process.exit(ExitCode5.NOT_FOUND);
+      return;
+    }
+    let projectRoot;
+    let installPath;
+    let rendered;
+    try {
+      projectRoot = resolveProjectRoot(args["project"]);
+      installPath = join3(projectRoot, entry.installPath);
+      const source = readTemplateSource(entry);
+      rendered = applySubstitution(entry, source).rendered;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`templates upgrade failed: ${message}`, ExitCode5.GENERAL_ERROR, {
+        name: "E_TEMPLATES_UPGRADE_FAILED"
+      });
+      process.exit(ExitCode5.GENERAL_ERROR);
+      return;
+    }
+    const previewOnly = args["diff"] === true;
+    const accept = args["accept"] === true;
+    const current = existsSync3(installPath) ? readFileSync4(installPath, "utf8") : null;
+    const diffBody = current === null ? "" : current === rendered ? "" : unifiedDiff(current, rendered);
+    let outcome;
+    let reason;
+    let shouldWrite = false;
+    if (entry.updateStrategy === "manifest-merge") {
+      outcome = "not-supported";
+      reason = "manifest-merge upgrade is not yet supported (T9886-followup)";
+    } else if (entry.updateStrategy === "immutable") {
+      outcome = "skipped";
+      reason = current === null ? "immutable: not installed yet \u2014 use `install`" : "immutable: skipped per strategy";
+    } else if (current !== null && current === rendered) {
+      outcome = "noop";
+      reason = "already current";
+    } else if (entry.updateStrategy === "overwrite-on-bump") {
+      if (previewOnly) {
+        outcome = "skipped";
+        reason = "preview-only (--diff)";
+      } else {
+        outcome = "overwritten";
+        reason = current === null ? "fresh install" : "overwrite-on-bump";
+        shouldWrite = true;
+      }
+    } else {
+      if (previewOnly || !accept) {
+        outcome = "skipped";
+        reason = previewOnly ? "preview-only (--diff)" : "diff-prompt: pass --accept to apply";
+      } else {
+        outcome = "overwritten";
+        reason = "diff-prompt: accepted";
+        shouldWrite = true;
+      }
+    }
+    if (shouldWrite) {
+      try {
+        mkdirSync2(dirname2(installPath), { recursive: true });
+        writeFileSync2(installPath, rendered, "utf8");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        cliError(`templates upgrade failed: ${message}`, ExitCode5.GENERAL_ERROR, {
+          name: "E_TEMPLATES_UPGRADE_FAILED"
+        });
+        process.exit(ExitCode5.GENERAL_ERROR);
+        return;
+      }
+    }
+    const result = {
+      id,
+      installPath,
+      updateStrategy: entry.updateStrategy,
+      outcome,
+      reason,
+      diff: diffBody
+    };
+    cliOutput(result, {
+      command: "templates-upgrade",
+      operation: "templates.upgrade"
+    });
+  }
+});
+
+// packages/cleo/src/cli/commands/templates/validate.ts
+import { ExitCode as ExitCode6 } from "@cleocode/contracts";
+import {
+  getInstalledStatus,
+  getTemplateById as getTemplateById5,
+  getTemplateManifest as getTemplateManifest2,
+  resolveSourcePathAbsolute as resolveSourcePathAbsolute2
+} from "@cleocode/core/templates/registry";
+var templatesValidateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate every registry entry (or one --id) against the live filesystem"
+  },
+  args: {
+    id: {
+      type: "string",
+      description: "Validate a single entry by id (default: walk every entry)"
+    },
+    project: {
+      type: "string",
+      description: "Project root to probe install status against (default: detected)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    let projectRoot;
+    try {
+      projectRoot = resolveProjectRoot(args["project"]);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`templates validate failed: ${message}`, ExitCode6.GENERAL_ERROR, {
+        name: "E_TEMPLATES_VALIDATE_FAILED"
+      });
+      process.exit(ExitCode6.GENERAL_ERROR);
+      return;
+    }
+    const idFilter = typeof args["id"] === "string" && args["id"].length > 0 ? args["id"] : null;
+    let targets;
+    if (idFilter === null) {
+      targets = getTemplateManifest2();
+    } else {
+      const entry = getTemplateById5(idFilter);
+      if (entry === void 0) {
+        cliError(`templates validate failed: id "${idFilter}" not found`, ExitCode6.NOT_FOUND, {
+          name: "E_NOT_FOUND",
+          details: { id: idFilter }
+        });
+        process.exit(ExitCode6.NOT_FOUND);
+        return;
+      }
+      targets = [entry];
+    }
+    const entries = targets.map((entry) => {
+      const issues = [];
+      let sourcePath = null;
+      let sourceExists = false;
+      try {
+        sourcePath = resolveSourcePathAbsolute2(entry);
+        sourceExists = true;
+      } catch (err) {
+        issues.push(`source: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      let installed = false;
+      let installPath = null;
+      try {
+        const status = getInstalledStatus(entry.id, projectRoot);
+        installed = status.installed;
+        installPath = status.path;
+      } catch (err) {
+        issues.push(`install: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      return {
+        id: entry.id,
+        kind: entry.kind,
+        sourceExists,
+        sourcePath,
+        installed,
+        installPath,
+        issues
+      };
+    });
+    const ok = entries.every((e) => e.issues.length === 0);
+    const result = {
+      ok,
+      count: entries.length,
+      entries
+    };
+    cliOutput(result, {
+      command: "templates-validate",
+      operation: "templates.validate"
+    });
+    if (!ok) {
+      process.exit(ExitCode6.VALIDATION_ERROR);
+    }
+  }
+});
+
+// packages/cleo/src/cli/commands/templates.ts
+var templatesCommand = defineCommand({
+  meta: {
+    name: "templates",
+    description: "TemplateManifest SSoT registry surface (list, show, install, upgrade, diff, validate)"
+  },
+  subCommands: {
+    list: templatesListCommand,
+    show: templatesShowCommand,
+    install: templatesInstallCommand,
+    upgrade: templatesUpgradeCommand,
+    diff: templatesDiffCommand,
+    validate: templatesValidateCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  templatesCommand
+};
+//# sourceMappingURL=templates-7O77TKPV.js.map