tailwindcss-patch 8.3.0 → 8.4.1

package/README.md

@@ -59,6 +59,40 @@ cli.help()
 cli.parse()
 ```
 
+#### Custom command hooks
+
+Hosts can override per-command lifecycles by supplying `commandHandlers`. Each handler receives a context object (with the resolved `cwd`, parsed `args`, memoized `loadConfig`/`createPatcher` helpers, and the shared `logger`) plus a `next()` callback that runs the built-in action.
+
+```ts
+mountTailwindcssPatchCommands(cli, {
+  commandHandlers: {
+    install: async (ctx) => {
+      const patcher = await ctx.createPatcher()
+      await clearTailwindcssPatcherCache(ctx.cwd)
+      await patcher.patch()
+      await saveCliPatchTargetRecord({ cwd: ctx.cwd })
+    },
+    extract: async (ctx, next) => {
+      const result = await next() // run the default extract implementation
+      ctx.logger.success(`[host] wrote ${result.classList.length} classes`)
+      return result
+    },
+  },
+  commandOptions: {
+    extract: {
+      description: 'Localised extract command',
+      appendDefaultOptions: false,
+      optionDefs: [
+        { flags: '--entry <file>', description: 'Tailwind CSS entry file' },
+        { flags: '--preview', description: 'Print a preview instead of writing' },
+      ],
+    },
+  },
+})
+```
+
+Skip `next()` to fully replace a command (e.g. custom `init` or cache clearing before `install`). Calling `next()` returns the default result—`ExtractResult`, `TailwindTokenReport`, etc.—so hosts can log metadata or feed it into their own telemetry without re-implementing the commands.
+
 ### Extract options
 
 | Flag                     | Description                                                      |
@@ -73,13 +107,13 @@ The CLI loads `tailwindcss-patch.config.ts` via `@tailwindcss-mangle/config`. Le
 
 ### Token report options
 
-| Flag                     | Description                                                                 |
-| ------------------------ | --------------------------------------------------------------------------- |
-| `--cwd <dir>`            | Use a different working directory when loading configuration.               |
-| `--output <file>`        | Override the token report target file (defaults to `.tw-patch/tw-token-report.json`). |
+| Flag                                   | Description                                                                               |
+| -------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `--cwd <dir>`                          | Use a different working directory when loading configuration.                             |
+| `--output <file>`                      | Override the token report target file (defaults to `.tw-patch/tw-token-report.json`).     |
 | `--format <json\|lines\|grouped-json>` | Choose between a JSON payload (default), newline summaries, or JSON grouped by file path. |
-| `--group-key <relative\|absolute>` | Control grouped-json keys (defaults to relative paths). |
-| `--no-write`             | Skip writing to disk and only print a preview.                              |
+| `--group-key <relative\|absolute>`     | Control grouped-json keys (defaults to relative paths).                                   |
+| `--no-write`                           | Skip writing to disk and only print a preview.                                            |
 
 ## Programmatic API
 

package/dist/{chunk-SN7IO2IS.mjs → chunk-C3YPPFE6.mjs}

@@ -5,6 +5,9 @@ var logger_default = logger;
 
 // src/cache/store.ts
 import fs from "fs-extra";
+function isErrnoException(error) {
+  return error instanceof Error && typeof error.code === "string";
+}
 var CacheStore = class {
   constructor(options) {
     this.options = options;
@@ -55,6 +58,9 @@ var CacheStore = class {
         return new Set(data.filter((item) => typeof item === "string"));
       }
     } catch (error) {
+      if (isErrnoException(error) && error.code === "ENOENT") {
+        return /* @__PURE__ */ new Set();
+      }
       logger_default.warn("Unable to read Tailwind class cache, removing invalid file.", error);
       try {
         await fs.remove(this.options.path);
@@ -78,6 +84,9 @@ var CacheStore = class {
         return new Set(data.filter((item) => typeof item === "string"));
       }
     } catch (error) {
+      if (isErrnoException(error) && error.code === "ENOENT") {
+        return /* @__PURE__ */ new Set();
+      }
       logger_default.warn("Unable to read Tailwind class cache, removing invalid file.", error);
       try {
         fs.removeSync(this.options.path);
@@ -387,7 +396,7 @@ function normalizeTailwindV4Options(v4, fallbackBase) {
   const hasUserDefinedSources = Boolean(userSources?.length);
   const sources = hasUserDefinedSources ? userSources : [
     {
-      base,
+      base: fallbackBase,
       pattern: "**/*",
       negated: false
     }
@@ -516,13 +525,6 @@ async function collectClassesFromTailwindV4(options) {
     if (!v4Options.sources?.length) {
       return void 0;
     }
-    if (!v4Options.hasUserDefinedSources && !resolvedConfiguredBase) {
-      return v4Options.sources.map((source) => ({
-        base,
-        pattern: source.pattern,
-        negated: source.negated
-      }));
-    }
     return v4Options.sources.map((source) => ({
       base: source.base ?? base,
       pattern: source.pattern,
@@ -1656,156 +1658,143 @@ var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
 import cac from "cac";
 import fs8 from "fs-extra";
 import path9 from "pathe";
-var tailwindcssPatchCommands = [
-  "install",
-  "extract",
-  "tokens",
-  "init"
-];
-function createTailwindcssPatchCli(options = {}) {
-  const cli = cac(options.name ?? "tw-patch");
-  mountTailwindcssPatchCommands(cli, options.mountOptions);
-  return cli;
+var tailwindcssPatchCommands = ["install", "extract", "tokens", "init"];
+var TOKEN_FORMATS = ["json", "lines", "grouped-json"];
+var DEFAULT_TOKEN_REPORT = ".tw-patch/tw-token-report.json";
+function formatTokenLine(entry) {
+  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
 }
-function mountTailwindcssPatchCommands(cli, options = {}) {
-  const prefix = options.commandPrefix ?? "";
-  const selectedCommands = options.commands ?? tailwindcssPatchCommands;
-  const TOKEN_FORMATS = ["json", "lines", "grouped-json"];
-  const registrars = {
-    install() {
-      const { name, aliases } = resolveCommandNames("install", options, prefix);
-      const command = cli.command(name, "Apply Tailwind CSS runtime patches").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).action(async (args) => {
-        const patchOptions = await loadPatchOptions(args.cwd);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        await patcher.patch();
-        logger_default.success("Tailwind CSS runtime patched successfully.");
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    extract() {
-      const { name, aliases } = resolveCommandNames("extract", options, prefix);
-      const command = cli.command(name, "Collect generated class names into a cache file").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).option("--output <file>", "Override output file path").option("--format <format>", "Output format (json|lines)").option("--css <file>", "Tailwind CSS entry CSS when using v4").option("--no-write", "Skip writing to disk").action(async (args) => {
-        const overrides = {};
-        if (args.output || args.format) {
-          overrides.output = {
-            file: args.output,
-            format: args.format
-          };
-        }
-        if (args.css) {
-          overrides.tailwind = {
-            v4: {
-              cssEntries: [args.css]
-            }
-          };
-        }
-        const patchOptions = await loadPatchOptions(args.cwd, overrides);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        const result = await patcher.extract({ write: args.write });
-        if (result.filename) {
-          logger_default.success(`Collected ${result.classList.length} classes \u2192 ${result.filename}`);
-        } else {
-          logger_default.success(`Collected ${result.classList.length} classes.`);
-        }
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    tokens() {
-      const { name, aliases } = resolveCommandNames("tokens", options, prefix);
-      const command = cli.command(name, "Extract Tailwind tokens with file/position metadata").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).option("--output <file>", "Override output file path", { default: ".tw-patch/tw-token-report.json" }).option("--format <format>", "Output format (json|lines|grouped-json)", { default: "json" }).option("--group-key <key>", "Grouping key for grouped-json output (relative|absolute)", { default: "relative" }).option("--no-write", "Skip writing to disk").action(async (args) => {
-        const patchOptions = await loadPatchOptions(args.cwd);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        const report = await patcher.collectContentTokens();
-        const shouldWrite = args.write ?? true;
-        let format = args.format ?? "json";
-        if (!TOKEN_FORMATS.includes(format)) {
-          format = "json";
-        }
-        const targetFile = args.output ?? ".tw-patch/tw-token-report.json";
-        const groupKey = args.groupKey === "absolute" ? "absolute" : "relative";
-        const buildGrouped = () => groupTokensByFile(report, {
-          key: groupKey,
-          stripAbsolutePaths: groupKey !== "absolute"
-        });
-        const grouped = format === "grouped-json" ? buildGrouped() : null;
-        const resolveGrouped = () => grouped ?? buildGrouped();
-        if (shouldWrite) {
-          const target = path9.resolve(targetFile);
-          await fs8.ensureDir(path9.dirname(target));
-          if (format === "json") {
-            await fs8.writeJSON(target, report, { spaces: 2 });
-          } else if (format === "grouped-json") {
-            await fs8.writeJSON(target, resolveGrouped(), { spaces: 2 });
-          } else {
-            const lines = report.entries.map(formatTokenLine);
-            await fs8.writeFile(target, `${lines.join("\n")}
-`, "utf8");
-          }
-          logger_default.success(
-            `Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process5.cwd(), ".")}`
-          );
-        } else {
-          logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
-          if (format === "lines") {
-            const preview = report.entries.slice(0, 5).map(formatTokenLine).join("\n");
-            if (preview) {
-              logger_default.log("");
-              logger_default.info(preview);
-              if (report.entries.length > 5) {
-                logger_default.info(`\u2026and ${report.entries.length - 5} more.`);
-              }
-            }
-          } else if (format === "grouped-json") {
-            const map = resolveGrouped();
-            const { preview, moreFiles } = formatGroupedPreview(map);
-            if (preview) {
-              logger_default.log("");
-              logger_default.info(preview);
-              if (moreFiles > 0) {
-                logger_default.info(`\u2026and ${moreFiles} more files.`);
-              }
-            }
-          } else {
-            const previewEntries = report.entries.slice(0, 3);
-            if (previewEntries.length) {
-              logger_default.log("");
-              logger_default.info(JSON.stringify(previewEntries, null, 2));
-            }
-          }
-        }
-        if (report.skippedFiles.length) {
-          logger_default.warn("Skipped files:");
-          for (const skipped of report.skippedFiles) {
-            logger_default.warn(`  \u2022 ${skipped.file} (${skipped.reason})`);
-          }
-        }
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    init() {
-      const { name, aliases } = resolveCommandNames("init", options, prefix);
-      const command = cli.command(name, "Generate a tailwindcss-patch config file").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).action(async (args) => {
-        await initConfig(args.cwd);
-        logger_default.success(`\u2728 ${CONFIG_NAME}.config.ts initialized!`);
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    }
+function formatGroupedPreview(map, limit = 3) {
+  const files = Object.keys(map);
+  if (!files.length) {
+    return { preview: "", moreFiles: 0 };
+  }
+  const lines = files.slice(0, limit).map((file) => {
+    const tokens = map[file];
+    const sample = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
+    const suffix = tokens.length > 3 ? ", \u2026" : "";
+    return `${file}: ${tokens.length} tokens (${sample}${suffix})`;
+  });
+  return {
+    preview: lines.join("\n"),
+    moreFiles: Math.max(0, files.length - limit)
   };
-  for (const name of selectedCommands) {
-    const register = registrars[name];
-    if (register) {
-      register();
-    }
+}
+function resolveCwd(rawCwd) {
+  if (!rawCwd) {
+    return process5.cwd();
   }
-  return cli;
+  return path9.resolve(rawCwd);
+}
+function createDefaultRunner(factory) {
+  let promise;
+  return () => {
+    if (!promise) {
+      promise = factory();
+    }
+    return promise;
+  };
 }
-async function loadPatchOptions(cwd, overrides) {
+async function loadPatchOptionsForCwd(cwd, overrides) {
   const { config } = await getConfig(cwd);
   const legacyConfig = config;
   const base = config?.registry ? fromUnifiedConfig(config.registry) : legacyConfig?.patch ? fromLegacyOptions({ patch: legacyConfig.patch }) : {};
   const merged = defu(overrides ?? {}, base);
   return merged;
 }
+function createCommandContext(cli, command, commandName, args, cwd) {
+  let cachedOptions;
+  let cachedPatcher;
+  let cachedConfig;
+  const loadPatchOptionsForContext = (overrides) => {
+    if (overrides) {
+      return loadPatchOptionsForCwd(cwd, overrides);
+    }
+    if (!cachedOptions) {
+      cachedOptions = loadPatchOptionsForCwd(cwd);
+    }
+    return cachedOptions;
+  };
+  const createPatcherForContext = async (overrides) => {
+    if (overrides) {
+      const patchOptions = await loadPatchOptionsForCwd(cwd, overrides);
+      return new TailwindcssPatcher(patchOptions);
+    }
+    if (!cachedPatcher) {
+      cachedPatcher = loadPatchOptionsForContext().then((options) => new TailwindcssPatcher(options));
+    }
+    return cachedPatcher;
+  };
+  return {
+    cli,
+    command,
+    commandName,
+    args,
+    cwd,
+    logger: logger_default,
+    loadConfig: () => {
+      if (!cachedConfig) {
+        cachedConfig = getConfig(cwd);
+      }
+      return cachedConfig;
+    },
+    loadPatchOptions: loadPatchOptionsForContext,
+    createPatcher: createPatcherForContext
+  };
+}
+function createCwdOptionDefinition(description = "Working directory") {
+  return {
+    flags: "--cwd <dir>",
+    description,
+    config: { default: process5.cwd() }
+  };
+}
+function buildDefaultCommandDefinitions() {
+  return {
+    install: {
+      description: "Apply Tailwind CSS runtime patches",
+      optionDefs: [createCwdOptionDefinition()]
+    },
+    extract: {
+      description: "Collect generated class names into a cache file",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path" },
+        { flags: "--format <format>", description: "Output format (json|lines)" },
+        { flags: "--css <file>", description: "Tailwind CSS entry CSS when using v4" },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    tokens: {
+      description: "Extract Tailwind tokens with file/position metadata",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path", config: { default: DEFAULT_TOKEN_REPORT } },
+        {
+          flags: "--format <format>",
+          description: "Output format (json|lines|grouped-json)",
+          config: { default: "json" }
+        },
+        {
+          flags: "--group-key <key>",
+          description: "Grouping key for grouped-json output (relative|absolute)",
+          config: { default: "relative" }
+        },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    init: {
+      description: "Generate a tailwindcss-patch config file",
+      optionDefs: [createCwdOptionDefinition()]
+    }
+  };
+}
+function addPrefixIfMissing(value, prefix) {
+  if (!prefix || value.startsWith(prefix)) {
+    return value;
+  }
+  return `${prefix}${value}`;
+}
 function resolveCommandNames(command, mountOptions, prefix) {
   const override = mountOptions.commandOptions?.[command];
   const baseName = override?.name ?? command;
@@ -1813,30 +1802,228 @@ function resolveCommandNames(command, mountOptions, prefix) {
   const aliases = (override?.aliases ?? []).map((alias) => addPrefixIfMissing(alias, prefix));
   return { name, aliases };
 }
-function addPrefixIfMissing(value, prefix) {
-  if (!prefix || value.startsWith(prefix)) {
-    return value;
+function resolveOptionDefinitions(defaults, override) {
+  if (!override) {
+    return defaults;
   }
-  return `${prefix}${value}`;
+  const appendDefaults = override.appendDefaultOptions ?? true;
+  const customDefs = override.optionDefs ?? [];
+  if (!appendDefaults) {
+    return customDefs;
+  }
+  if (customDefs.length === 0) {
+    return defaults;
+  }
+  return [...defaults, ...customDefs];
 }
-function formatTokenLine(entry) {
-  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
+function applyCommandOptions(command, optionDefs) {
+  for (const option of optionDefs) {
+    command.option(option.flags, option.description ?? "", option.config);
+  }
 }
-function formatGroupedPreview(map, limit = 3) {
-  const files = Object.keys(map);
-  if (!files.length) {
-    return { preview: "", moreFiles: 0 };
+function runWithCommandHandler(cli, command, commandName, args, handler, defaultHandler) {
+  const cwd = resolveCwd(args.cwd);
+  const context = createCommandContext(cli, command, commandName, args, cwd);
+  const runDefault = createDefaultRunner(() => defaultHandler(context));
+  if (!handler) {
+    return runDefault();
+  }
+  return handler(context, runDefault);
+}
+function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
+  const names = resolveCommandNames(command, mountOptions, prefix);
+  const definition = defaults[command];
+  const override = mountOptions.commandOptions?.[command];
+  const description = override?.description ?? definition.description;
+  const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
+  return { ...names, description, optionDefs };
+}
+async function installCommandDefaultHandler(ctx) {
+  const patcher = await ctx.createPatcher();
+  await patcher.patch();
+  logger_default.success("Tailwind CSS runtime patched successfully.");
+}
+async function extractCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const overrides = {};
+  let hasOverrides = false;
+  if (args.output || args.format) {
+    overrides.output = {
+      file: args.output,
+      format: args.format
+    };
+    hasOverrides = true;
   }
-  const lines = files.slice(0, limit).map((file) => {
-    const tokens = map[file];
-    const sample = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
-    const suffix = tokens.length > 3 ? ", \u2026" : "";
-    return `${file}: ${tokens.length} tokens (${sample}${suffix})`;
+  if (args.css) {
+    overrides.tailwind = {
+      v4: {
+        cssEntries: [args.css]
+      }
+    };
+    hasOverrides = true;
+  }
+  const patcher = await ctx.createPatcher(hasOverrides ? overrides : void 0);
+  const result = await patcher.extract({ write: args.write });
+  if (result.filename) {
+    logger_default.success(`Collected ${result.classList.length} classes \u2192 ${result.filename}`);
+  } else {
+    logger_default.success(`Collected ${result.classList.length} classes.`);
+  }
+  return result;
+}
+async function tokensCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const patcher = await ctx.createPatcher();
+  const report = await patcher.collectContentTokens();
+  const shouldWrite = args.write ?? true;
+  let format = args.format ?? "json";
+  if (!TOKEN_FORMATS.includes(format)) {
+    format = "json";
+  }
+  const targetFile = args.output ?? DEFAULT_TOKEN_REPORT;
+  const groupKey = args.groupKey === "absolute" ? "absolute" : "relative";
+  const buildGrouped = () => groupTokensByFile(report, {
+    key: groupKey,
+    stripAbsolutePaths: groupKey !== "absolute"
   });
-  return {
-    preview: lines.join("\n"),
-    moreFiles: Math.max(0, files.length - limit)
+  const grouped = format === "grouped-json" ? buildGrouped() : null;
+  const resolveGrouped = () => grouped ?? buildGrouped();
+  if (shouldWrite) {
+    const target = path9.resolve(targetFile);
+    await fs8.ensureDir(path9.dirname(target));
+    if (format === "json") {
+      await fs8.writeJSON(target, report, { spaces: 2 });
+    } else if (format === "grouped-json") {
+      await fs8.writeJSON(target, resolveGrouped(), { spaces: 2 });
+    } else {
+      const lines = report.entries.map(formatTokenLine);
+      await fs8.writeFile(target, `${lines.join("\n")}
+`, "utf8");
+    }
+    logger_default.success(`Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process5.cwd(), ".")}`);
+  } else {
+    logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
+    if (format === "lines") {
+      const preview = report.entries.slice(0, 5).map(formatTokenLine).join("\n");
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (report.entries.length > 5) {
+          logger_default.info(`\u2026and ${report.entries.length - 5} more.`);
+        }
+      }
+    } else if (format === "grouped-json") {
+      const map = resolveGrouped();
+      const { preview, moreFiles } = formatGroupedPreview(map);
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (moreFiles > 0) {
+          logger_default.info(`\u2026and ${moreFiles} more files.`);
+        }
+      }
+    } else {
+      const previewEntries = report.entries.slice(0, 3);
+      if (previewEntries.length) {
+        logger_default.log("");
+        logger_default.info(JSON.stringify(previewEntries, null, 2));
+      }
+    }
+  }
+  if (report.skippedFiles.length) {
+    logger_default.warn("Skipped files:");
+    for (const skipped of report.skippedFiles) {
+      logger_default.warn(`  \u2022 ${skipped.file} (${skipped.reason})`);
+    }
+  }
+  return report;
+}
+async function initCommandDefaultHandler(ctx) {
+  await initConfig(ctx.cwd);
+  logger_default.success(`\u2728 ${CONFIG_NAME}.config.ts initialized!`);
+}
+function mountTailwindcssPatchCommands(cli, options = {}) {
+  const prefix = options.commandPrefix ?? "";
+  const selectedCommands = options.commands ?? tailwindcssPatchCommands;
+  const defaultDefinitions = buildDefaultCommandDefinitions();
+  const registrars = {
+    install: () => {
+      const metadata = resolveCommandMetadata("install", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "install",
+          args,
+          options.commandHandlers?.install,
+          installCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    extract: () => {
+      const metadata = resolveCommandMetadata("extract", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "extract",
+          args,
+          options.commandHandlers?.extract,
+          extractCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    tokens: () => {
+      const metadata = resolveCommandMetadata("tokens", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "tokens",
+          args,
+          options.commandHandlers?.tokens,
+          tokensCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    init: () => {
+      const metadata = resolveCommandMetadata("init", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "init",
+          args,
+          options.commandHandlers?.init,
+          initCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    }
   };
+  for (const name of selectedCommands) {
+    const register = registrars[name];
+    if (register) {
+      register();
+    }
+  }
+  return cli;
+}
+function createTailwindcssPatchCli(options = {}) {
+  const cli = cac(options.name ?? "tw-patch");
+  mountTailwindcssPatchCommands(cli, options.mountOptions);
+  return cli;
 }
 
 export {
@@ -1854,6 +2041,6 @@ export {
   runTailwindBuild,
   TailwindcssPatcher,
   tailwindcssPatchCommands,
-  createTailwindcssPatchCli,
-  mountTailwindcssPatchCommands
+  mountTailwindcssPatchCommands,
+  createTailwindcssPatchCli
 };