@kurotako/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,714 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigExistsError: () => ConfigExistsError,
+  ConsoleReporter: () => ConsoleReporter,
+  comparePlanToDisk: () => comparePlanToDisk,
+  renderError: () => renderError,
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cli.ts
+var import_core6 = require("@kurotako/core");
+var import_citty5 = require("citty");
+
+// src/commands/check.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_config = require("@kurotako/config");
+var import_core2 = require("@kurotako/core");
+var import_citty = require("citty");
+
+// src/args.ts
+var sharedArgs = {
+  config: {
+    type: "string",
+    description: "path to the tako config file (default: ./tako.config.ts)"
+  },
+  /** Hidden: not advertised, kept minimal. Enables `debug` reporter output. */
+  debug: {
+    type: "boolean",
+    default: false
+  }
+};
+
+// src/diff.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+function toPosix(rootDir, absPath) {
+  return import_node_path.default.relative(rootDir, absPath).split(import_node_path.default.sep).join("/");
+}
+async function comparePlanToDisk(args) {
+  const { plan, roots, ignore, rootDir } = args;
+  const plannedByPath = new Map(plan.map((f) => [import_node_path.default.resolve(f.path), f]));
+  const entries = [];
+  for (const [absPath, file] of plannedByPath) {
+    if (!(0, import_node_fs.existsSync)(absPath)) {
+      entries.push({ kind: "missing", path: toPosix(rootDir, absPath) });
+      continue;
+    }
+    const onDisk = await (0, import_promises.readFile)(absPath, "utf8");
+    if (onDisk !== file.content) {
+      entries.push({ kind: "modified", path: toPosix(rootDir, absPath) });
+    }
+  }
+  const plannedPaths = [...plannedByPath.keys()];
+  const hasPlannedUnder = (dir) => {
+    const prefix = `${dir}${import_node_path.default.sep}`;
+    return plannedPaths.some((p) => p === dir || p.startsWith(prefix));
+  };
+  const seenRoots = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const absRoot = import_node_path.default.resolve(root);
+    if (seenRoots.has(absRoot) || !(0, import_node_fs.existsSync)(absRoot)) {
+      continue;
+    }
+    seenRoots.add(absRoot);
+    await scan(absRoot);
+  }
+  async function scan(dir) {
+    if (!hasPlannedUnder(dir)) {
+      if (await hasNonIgnoredFile(dir)) {
+        entries.push({ kind: "orphan", path: `${toPosix(rootDir, dir)}/` });
+      }
+      return;
+    }
+    for (const dirent of await (0, import_promises.readdir)(dir, { withFileTypes: true })) {
+      const abs = import_node_path.default.join(dir, dirent.name);
+      if (ignore(abs)) {
+        continue;
+      }
+      if (dirent.isDirectory()) {
+        await scan(abs);
+      } else if (dirent.isFile() && !plannedByPath.has(abs)) {
+        entries.push({ kind: "orphan", path: toPosix(rootDir, abs) });
+      }
+    }
+  }
+  async function hasNonIgnoredFile(dir) {
+    for (const dirent of await (0, import_promises.readdir)(dir, { withFileTypes: true })) {
+      const abs = import_node_path.default.join(dir, dirent.name);
+      if (ignore(abs)) {
+        continue;
+      }
+      if (dirent.isFile()) {
+        return true;
+      }
+      if (dirent.isDirectory() && await hasNonIgnoredFile(abs)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  entries.sort(
+    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0
+  );
+  return entries;
+}
+function ignoreBuildArtifacts(absPath) {
+  return /(^|[/\\])(dist|node_modules)([/\\]|$)/.test(absPath);
+}
+async function hasGeneratedMarker(pkgDir) {
+  try {
+    const pkg = JSON.parse(
+      await (0, import_promises.readFile)(import_node_path.default.join(pkgDir, "package.json"), "utf8")
+    );
+    return typeof pkg["//"] === "string" && pkg["//"].startsWith("Generated by tako");
+  } catch {
+    return false;
+  }
+}
+async function markedPackageDirs(packagesDir) {
+  if (!(0, import_node_fs.existsSync)(packagesDir)) {
+    return [];
+  }
+  const out = [];
+  for (const dirent of await (0, import_promises.readdir)(packagesDir, { withFileTypes: true })) {
+    if (!dirent.isDirectory()) {
+      continue;
+    }
+    const abs = import_node_path.default.join(packagesDir, dirent.name);
+    if (await hasGeneratedMarker(abs)) {
+      out.push(abs);
+    }
+  }
+  return out.sort();
+}
+
+// src/reporter.ts
+var import_core = require("@kurotako/core");
+var ESC = String.fromCharCode(27);
+var ANSI = {
+  debug: `${ESC}[2m`,
+  // dim
+  info: `${ESC}[36m`,
+  // cyan
+  warn: `${ESC}[33m`,
+  // yellow
+  error: `${ESC}[31m`
+  // red
+};
+var ANSI_RESET = `${ESC}[0m`;
+var ConsoleReporter = class {
+  stream;
+  showDebug;
+  color;
+  constructor(options = {}) {
+    this.stream = options.stream ?? process.stderr;
+    this.showDebug = options.debug ?? Boolean(process.env.TAKO_DEBUG);
+    this.color = options.color ?? (Boolean(this.stream.isTTY) && process.env.NO_COLOR === void 0);
+  }
+  debug(msg, meta) {
+    if (this.showDebug) {
+      this.write("debug", msg, meta);
+    }
+  }
+  info(msg, meta) {
+    this.write("info", msg, meta);
+  }
+  warn(msg, meta) {
+    this.write("warn", msg, meta);
+  }
+  error(msg, meta) {
+    this.write("error", msg, meta);
+  }
+  /** A child `Logger` whose calls carry `{ scope: tag }` in `meta`. */
+  child(tag) {
+    return (0, import_core.childLogger)(this, { scope: tag });
+  }
+  write(level, msg, meta) {
+    const prefix = this.color ? `${ANSI[level]}tako${ANSI_RESET}` : "tako";
+    const detail = meta === void 0 ? "" : ` ${formatMeta(meta)}`;
+    this.stream.write(`${prefix} ${msg}${detail}
+`);
+  }
+};
+function formatMeta(meta) {
+  if (meta !== null && typeof meta === "object" && !Array.isArray(meta)) {
+    return Object.entries(meta).map(([k, v]) => `${k}=${stringify(v)}`).join(" ");
+  }
+  return stringify(meta);
+}
+function stringify(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/commands/check.ts
+var checkCommand = (0, import_citty.defineCommand)({
+  meta: {
+    name: "check",
+    description: "check the generated output on disk matches a fresh generate (drift guard)"
+  },
+  args: { ...sharedArgs },
+  run: async ({ args }) => {
+    const reporter = new ConsoleReporter({ debug: Boolean(args.debug) });
+    const cwd = process.cwd();
+    const { config } = await (0, import_config.loadConfig)({
+      cwd,
+      configPath: args.config || void 0
+    });
+    const { plan = [] } = await (0, import_core2.run)(config, { logger: reporter, plan: true });
+    const roots = [];
+    const ignores = [];
+    for (const output of config.outputs) {
+      if (output.mode === "package") {
+        ignores.push(ignoreBuildArtifacts);
+        if (output.packagesDir) {
+          roots.push(...await markedPackageDirs(output.packagesDir));
+        }
+      } else {
+        const dir = output.dir;
+        if (!dir) {
+          continue;
+        }
+        if (!(0, import_node_fs2.existsSync)(dir)) {
+          reporter.info(
+            `output directory ${(0, import_node_path2.relative)(config.rootDir, dir)} does not exist \u2014 run tako generate`
+          );
+          process.exitCode = 1;
+          return;
+        }
+        roots.push(dir);
+      }
+    }
+    const ignore = (absPath) => ignores.some((fn) => fn(absPath));
+    const drift = await comparePlanToDisk({
+      plan,
+      roots,
+      ignore,
+      rootDir: config.rootDir
+    });
+    if (drift.length === 0) {
+      reporter.info("output is in sync");
+      process.exitCode ??= 0;
+      return;
+    }
+    reporter.error(formatDrift(drift));
+    process.exitCode = 1;
+  }
+});
+function formatDrift(drift) {
+  const width = Math.max(...drift.map((entry) => entry.kind.length));
+  const lines = drift.map(
+    (entry) => `  ${entry.kind.padEnd(width)}  ${entry.path}`
+  );
+  return [
+    "drift detected",
+    "",
+    ...lines,
+    "",
+    `${drift.length} files differ from a fresh generate. Run \`tako generate\`.`
+  ].join("\n");
+}
+
+// src/commands/generate.ts
+var import_node_path4 = require("path");
+var import_config3 = require("@kurotako/config");
+var import_core5 = require("@kurotako/core");
+var import_citty2 = require("citty");
+
+// src/watch.ts
+var import_node_path3 = require("path");
+var import_config2 = require("@kurotako/config");
+var import_core4 = require("@kurotako/core");
+var import_chokidar = __toESM(require("chokidar"), 1);
+
+// src/errors.ts
+var import_core3 = require("@kurotako/core");
+var ConfigExistsError = class extends import_core3.TakoError {
+  path;
+  constructor(path2) {
+    super(
+      "config_exists",
+      `a config file already exists at '${path2}' (pass --force to overwrite)`
+    );
+    this.path = path2;
+  }
+};
+function renderError(error) {
+  const lines = [`error [${error.code}]: ${error.message}`];
+  const issues = error.issues;
+  if (Array.isArray(issues)) {
+    for (const issue of issues) {
+      const at = issue.path === void 0 || issue.path === "" ? "<root>" : issue.path;
+      lines.push(`  - ${at}: ${issue.message}`);
+    }
+  }
+  const cycle = error.cycle;
+  if (Array.isArray(cycle) && cycle.length > 0) {
+    lines.push(`  cycle: ${cycle.join(" -> ")}`);
+  }
+  const driverName = error.driverName;
+  if (typeof driverName === "string") {
+    const role = error.role;
+    const namespace = error.namespace;
+    const roleLabel = typeof role === "string" ? role : "driver";
+    const where = typeof namespace === "string" ? ` (namespace '${namespace}')` : "";
+    lines.push(`  ${roleLabel}: ${driverName}${where}`);
+  } else {
+    const generator = error.generator;
+    if (typeof generator === "string") {
+      const namespace = error.namespace;
+      const where = typeof namespace === "string" ? ` (namespace '${namespace}')` : "";
+      lines.push(`  generator: ${generator}${where}`);
+    }
+  }
+  const cause = error.cause;
+  if (cause !== void 0 && cause !== null) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const code = cause instanceof import_core3.TakoError ? ` [${cause.code}]` : "";
+    lines.push(`  cause${code}: ${message}`);
+  }
+  return lines.join("\n");
+}
+
+// src/watch.ts
+var DEBOUNCE_MS = 100;
+function chokidarWatcher() {
+  const fsw = import_chokidar.default.watch([], {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 20 }
+  });
+  return {
+    add: (paths) => fsw.add(paths),
+    unwatch: (paths) => fsw.unwatch(paths),
+    on: (handler) => {
+      fsw.on("add", (p) => handler("add", p));
+      fsw.on("change", (p) => handler("change", p));
+      fsw.on("unlink", (p) => handler("unlink", p));
+    },
+    close: () => fsw.close()
+  };
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+async function watchAndRun(opts, deps = {}) {
+  const { cwd, configPath, reporter } = opts;
+  const createWatcher = deps.createWatcher ?? chokidarWatcher;
+  const loadConfig3 = deps.loadConfig ?? import_config2.loadConfig;
+  const run3 = deps.run ?? import_core4.run;
+  const debounceMs = deps.debounceMs ?? DEBOUNCE_MS;
+  const watcher = createWatcher();
+  let watched = /* @__PURE__ */ new Set();
+  let inFlight = null;
+  let queued = false;
+  let closed = false;
+  let timer = null;
+  let reason = "initial build";
+  const guessedConfigFile = configPath ? (0, import_node_path3.resolve)(cwd, configPath) : (0, import_node_path3.resolve)(cwd, "tako.config.ts");
+  function applyWatchSet(desired) {
+    for (const path2 of desired) {
+      if (!watched.has(path2)) {
+        watcher.add(path2);
+      }
+    }
+    for (const path2 of watched) {
+      if (!desired.has(path2)) {
+        watcher.unwatch(path2);
+      }
+    }
+    watched = desired;
+  }
+  async function reconcileWatchSet(loaded) {
+    const desired = /* @__PURE__ */ new Set([loaded.configFile]);
+    for (const [namespace, source] of Object.entries(loaded.config.sources)) {
+      const paths = await source.parser.watchPaths?.({
+        namespace,
+        cwd: loaded.rootDir,
+        logger: reporter
+      }) ?? [];
+      for (const path2 of paths) {
+        desired.add((0, import_node_path3.resolve)(loaded.rootDir, path2));
+      }
+    }
+    applyWatchSet(desired);
+  }
+  async function cycle() {
+    const why = reason;
+    reporter.info(`--- rebuild (${why}) ---`);
+    const ac = new AbortController();
+    inFlight = ac;
+    try {
+      const loaded = await loadConfig3({ cwd, configPath });
+      await reconcileWatchSet(loaded);
+      const result = await run3(loaded.config, {
+        logger: reporter,
+        signal: ac.signal,
+        write: true
+      });
+      if (!ac.signal.aborted) {
+        reporter.info(`wrote ${result.files.length} files`);
+      }
+    } catch (error) {
+      if (isAbortError(error) || ac.signal.aborted) {
+      } else if (error instanceof import_core4.TakoError) {
+        reporter.error(renderError(error));
+        applyWatchSet(/* @__PURE__ */ new Set([...watched, guessedConfigFile]));
+      } else {
+        reporter.error("internal error (this is a bug):");
+        console.error(error);
+      }
+    } finally {
+      inFlight = null;
+      if (queued && !closed) {
+        queued = false;
+        await cycle();
+      }
+    }
+  }
+  function trigger() {
+    if (inFlight) {
+      queued = true;
+      inFlight.abort();
+      return;
+    }
+    void cycle();
+  }
+  function schedule(event, path2) {
+    if (closed) {
+      return;
+    }
+    reason = `${(0, import_node_path3.basename)(path2)} ${event === "unlink" ? "removed" : "changed"}`;
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      trigger();
+    }, debounceMs);
+  }
+  watcher.on(schedule);
+  applyWatchSet(/* @__PURE__ */ new Set([guessedConfigFile]));
+  await cycle();
+  reporter.info(`watching ${watched.size} paths`);
+  await new Promise((resolvePromise) => {
+    const shutdown = () => {
+      closed = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      inFlight?.abort();
+      process.off("SIGINT", shutdown);
+      process.off("SIGTERM", shutdown);
+      void watcher.close().finally(() => resolvePromise());
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+}
+
+// src/commands/generate.ts
+function outputSummaryDir(output, config) {
+  return output.mode === "package" ? output.packagesDir ?? config.rootDir : output.dir ?? config.rootDir;
+}
+async function loadAndRun(opts) {
+  const loaded = await (0, import_config3.loadConfig)({
+    cwd: opts.cwd,
+    configPath: opts.configPath
+  });
+  const result = await (0, import_core5.run)(loaded.config, {
+    logger: opts.reporter,
+    write: opts.write,
+    signal: opts.signal
+  });
+  return {
+    result,
+    config: loaded.config,
+    configFile: loaded.configFile,
+    rootDir: loaded.rootDir
+  };
+}
+var generateCommand = (0, import_citty2.defineCommand)({
+  meta: {
+    name: "generate",
+    description: "run the pipeline and write the generated code"
+  },
+  args: {
+    ...sharedArgs,
+    watch: {
+      type: "boolean",
+      description: "rebuild on every schema / config change",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "run everything but write nothing",
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    const reporter = new ConsoleReporter({ debug: Boolean(args.debug) });
+    const cwd = process.cwd();
+    const configPath = args.config || void 0;
+    if (args.watch) {
+      await watchAndRun({ cwd, configPath, reporter });
+      return;
+    }
+    const dryRun = Boolean(args["dry-run"]);
+    const { result, config } = await loadAndRun({
+      cwd,
+      configPath,
+      write: !dryRun,
+      reporter
+    });
+    if (dryRun) {
+      reporter.info(`dry run: ${result.files.length} files would be written`);
+      return;
+    }
+    const dirs = config.outputs.map((output) => (0, import_node_path4.relative)(cwd, outputSummaryDir(output, config))).join(", ");
+    reporter.info(`wrote ${result.files.length} files -> ${dirs}`);
+  }
+});
+
+// src/commands/init.ts
+var import_node_fs3 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_config4 = require("@kurotako/config");
+var import_citty3 = require("citty");
+function detectMonorepo(startDir) {
+  let dir = (0, import_node_path5.resolve)(startDir);
+  while (true) {
+    const pkgPath = (0, import_node_path5.resolve)(dir, "package.json");
+    if ((0, import_node_fs3.existsSync)(pkgPath)) {
+      if ((0, import_node_fs3.existsSync)((0, import_node_path5.resolve)(dir, "pnpm-workspace.yaml"))) {
+        return true;
+      }
+      try {
+        const pkg = JSON.parse((0, import_node_fs3.readFileSync)(pkgPath, "utf8"));
+        const ws = pkg.workspaces;
+        if (Array.isArray(ws) || typeof ws === "object" && ws !== null && Array.isArray(ws.packages)) {
+          return true;
+        }
+      } catch {
+      }
+      return false;
+    }
+    const parent = (0, import_node_path5.dirname)(dir);
+    if (parent === dir) {
+      return false;
+    }
+    dir = parent;
+  }
+}
+var initCommand = (0, import_citty3.defineCommand)({
+  meta: {
+    name: "init",
+    description: "create a tako.config.ts in the current directory"
+  },
+  args: {
+    ...sharedArgs,
+    force: {
+      type: "boolean",
+      description: "overwrite an existing config file",
+      default: false
+    },
+    monorepo: {
+      type: "boolean",
+      description: "write the monorepo config layout (auto-detected from workspaces when unset)",
+      default: void 0
+    }
+  },
+  run: async ({ args }) => {
+    const reporter = new ConsoleReporter({ debug: Boolean(args.debug) });
+    const cwd = process.cwd();
+    const target = args.config ? (0, import_node_path5.resolve)(cwd, args.config) : (0, import_node_path5.resolve)(cwd, "tako.config.ts");
+    if ((0, import_node_fs3.existsSync)(target) && !args.force) {
+      throw new ConfigExistsError(target);
+    }
+    const monorepo = typeof args.monorepo === "boolean" ? args.monorepo : detectMonorepo(cwd);
+    await (0, import_promises2.mkdir)((0, import_node_path5.dirname)(target), { recursive: true });
+    await (0, import_promises2.writeFile)(
+      target,
+      monorepo ? import_config4.CONFIG_TEMPLATE_MONOREPO : import_config4.CONFIG_TEMPLATE,
+      "utf8"
+    );
+    const name = (0, import_node_path5.relative)(cwd, target) || "tako.config.ts";
+    reporter.info(
+      monorepo ? `created ${name} (monorepo layout)` : `created ${name}`
+    );
+  }
+});
+
+// src/commands/validate.ts
+var import_citty4 = require("citty");
+var validateCommand = (0, import_citty4.defineCommand)({
+  meta: {
+    name: "validate",
+    description: "check the config and schema without writing anything"
+  },
+  args: { ...sharedArgs },
+  run: async ({ args }) => {
+    const reporter = new ConsoleReporter({ debug: Boolean(args.debug) });
+    await loadAndRun({
+      cwd: process.cwd(),
+      configPath: args.config || void 0,
+      write: false,
+      reporter
+    });
+    reporter.info("config and schema are valid");
+  }
+});
+
+// src/cli.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var subCommands = {
+  init: initCommand,
+  generate: generateCommand,
+  validate: validateCommand,
+  check: checkCommand
+};
+var main = (0, import_citty5.defineCommand)({
+  meta: {
+    name: "tako",
+    version: VERSION,
+    description: "synchronise TypeScript schemas from data model to forms"
+  },
+  subCommands
+});
+async function runCli(argv) {
+  const reporter = new ConsoleReporter({
+    debug: argv.includes("--debug") || Boolean(process.env.TAKO_DEBUG)
+  });
+  if (argv.includes("--version") || argv.includes("-v")) {
+    process.stdout.write(`${VERSION}
+`);
+    process.exitCode ??= 0;
+    return;
+  }
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    const sub = argv.find((a) => !a.startsWith("-"));
+    const isSub = sub !== void 0 && sub in subCommands;
+    const cmd = isSub ? subCommands[sub] : main;
+    process.stdout.write(
+      `${await (0, import_citty5.renderUsage)(cmd, isSub ? main : void 0)}
+`
+    );
+    process.exitCode ??= 0;
+    return;
+  }
+  try {
+    await (0, import_citty5.runCommand)(main, { rawArgs: argv });
+    process.exitCode ??= 0;
+  } catch (error) {
+    if (error instanceof import_core6.TakoError) {
+      reporter.error(renderError(error));
+      process.exitCode = 1;
+    } else if (error instanceof Error && error.name === "CLIError") {
+      reporter.error(error.message);
+      process.exitCode = 1;
+    } else {
+      reporter.error("internal error (this is a bug):");
+      console.error(error);
+      process.exitCode = 1;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigExistsError,
+  ConsoleReporter,
+  comparePlanToDisk,
+  renderError,
+  runCli
+});
+//# sourceMappingURL=index.cjs.map