@mtndev/cli 0.0.1

package/cjs/commands/doppler/utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Execute a doppler command and return the result
+ * @param {string[]} args - Command arguments
+ * @param {'string' | 'json'} parser - How to parse the output
+ * @param {boolean} silent - Suppress output
+ * @param {boolean} verbose - Show verbose output
+ * @returns {string | any}
+ */
+export function execDoppler(args: string[], parser?: "string" | "json", silent?: boolean, verbose?: boolean): string | any;
+/**
+ * Check if doppler CLI is installed and configured
+ * @param {boolean} verbose - Show verbose output
+ */
+export function checkDependencies(verbose?: boolean): void;
+/**
+ * Get list of configurations based on environment parameter
+ * @param {string} environment - Environment name ('all', 'dev', 'stg', 'prd', etc.)
+ * @param {boolean} verbose - Show verbose output
+ * @returns {string[]}
+ */
+export function getConfigs(environment: string, verbose?: boolean): string[];
+/**
+ * Normalize escape sequences in file content
+ * @param {string} content - File content
+ * @returns {string}
+ */
+export function normalizeEscapeSequences(content: string): string;
+/**
+ * Create a unified diff between two strings
+ * @param {string} oldContent - Original content
+ * @param {string} newContent - New content
+ * @returns {string[]}
+ */
+export function createDiff(oldContent: string, newContent: string): string[];
+/**
+ * Prompt user for confirmation
+ * @param {string} message - Prompt message
+ * @returns {Promise<boolean>}
+ */
+export function promptConfirmation(message: string): Promise<boolean>;
+/**
+ * Download configurations from Doppler
+ * @param {{
+ * verbose: boolean;
+ * environment: string;
+ * }} options - Options for downloading configurations
+ */
+export function downloadConfigs(options: {
+    verbose: boolean;
+    environment: string;
+}): Promise<void>;
+/**
+ * Upload configurations to Doppler
+ * @param {{
+ * environment: string;
+ * verbose: boolean;
+ * }} options - Options for uploading configurations
+ */
+export function uploadConfigs(options: {
+    environment: string;
+    verbose: boolean;
+}): Promise<void>;
+export type VerbosityLevel = import("./utils/exec.js").VerbosityLevel;
+export type ExecOptions = import("./utils/exec.js").ExecOptions;
+import { exec } from "./utils/exec.js";
+import { execString } from "./utils/exec.js";
+import { execJson } from "./utils/exec.js";
+import { execNumber } from "./utils/exec.js";
+export { exec, execString, execJson, execNumber };

package/cjs/commands/icons/handler.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _INFOPAHNcjs = require('../../__chunks/INFOPAHN.cjs');
+require('../../__chunks/4SFWHCB3.cjs');
+require('../../__chunks/J36P6UNE.cjs');
+
+
+exports.iconsCommand = _INFOPAHNcjs.iconsCommand;

package/cjs/commands/icons/handler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main icons command handler
+ * @param {unknown} options - Command options (will be validated)
+ */
+export function iconsCommand(options: unknown): Promise<void>;

package/cjs/commands/icons/index.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../../__chunks/B2KFW7T7.cjs');
+
+
+var _INFOPAHNcjs = require('../../__chunks/INFOPAHN.cjs');
+
+
+
+
+
+var _4SFWHCB3cjs = require('../../__chunks/4SFWHCB3.cjs');
+
+
+
+
+
+
+
+var _J36P6UNEcjs = require('../../__chunks/J36P6UNE.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CHANNELS = _J36P6UNEcjs.CHANNELS; exports.CHANNEL_TEXT_MAP = _J36P6UNEcjs.CHANNEL_TEXT_MAP; exports.ICON_SIZE_MAP = _J36P6UNEcjs.ICON_SIZE_MAP; exports.ICON_TYPES = _J36P6UNEcjs.ICON_TYPES; exports.checkDependencies = _4SFWHCB3cjs.checkDependencies; exports.generateAllIcons = _4SFWHCB3cjs.generateAllIcons; exports.generateIcon = _4SFWHCB3cjs.generateIcon; exports.iconsCommand = _INFOPAHNcjs.iconsCommand; exports.iconsCommandMetadata = _J36P6UNEcjs.iconsCommandMetadata; exports.iconsCommandOptionsSchema = _J36P6UNEcjs.iconsCommandOptionsSchema; exports.validateBaseIcons = _4SFWHCB3cjs.validateBaseIcons;

package/cjs/commands/icons/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./handler.js";
+export * from "./schema.js";
+export * from "./utils.js";

package/cjs/commands/icons/schema.cjs

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var _J36P6UNEcjs = require('../../__chunks/J36P6UNE.cjs');
+
+
+
+
+
+
+
+exports.CHANNELS = _J36P6UNEcjs.CHANNELS; exports.CHANNEL_TEXT_MAP = _J36P6UNEcjs.CHANNEL_TEXT_MAP; exports.ICON_SIZE_MAP = _J36P6UNEcjs.ICON_SIZE_MAP; exports.ICON_TYPES = _J36P6UNEcjs.ICON_TYPES; exports.iconsCommandMetadata = _J36P6UNEcjs.iconsCommandMetadata; exports.iconsCommandOptionsSchema = _J36P6UNEcjs.iconsCommandOptionsSchema;

package/cjs/commands/icons/schema.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Available channels for icon generation
+ */
+export const CHANNELS: string[];
+/**
+ * Available icon types
+ */
+export const ICON_TYPES: string[];
+export namespace CHANNEL_TEXT_MAP {
+    let dev: string;
+    let local: string;
+    let staging: string;
+    let test: string;
+}
+/**
+ * Icon type to point size mapping
+ */
+export const ICON_SIZE_MAP: {
+    "adaptive-icon": number;
+    icon: number;
+};
+/**
+ * Zod schema for icons command options
+ */
+export const iconsCommandOptionsSchema: z.ZodObject<{
+    input: z.ZodString;
+    channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["dev", "local", "staging", "test"]>, "many">>>;
+    iconTypes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["icon", "adaptive-icon"]>, "many">>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    help: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    verbose: boolean;
+    help: boolean;
+    input: string;
+    channels: ("dev" | "staging" | "test" | "local")[];
+    iconTypes: ("icon" | "adaptive-icon")[];
+}, {
+    input: string;
+    verbose?: boolean | undefined;
+    help?: boolean | undefined;
+    channels?: ("dev" | "staging" | "test" | "local")[] | undefined;
+    iconTypes?: ("icon" | "adaptive-icon")[] | undefined;
+}>;
+export namespace iconsCommandMetadata {
+    let name: string;
+    let description: string;
+    namespace options {
+        namespace input {
+            let description_1: string | undefined;
+            export { description_1 as description };
+            export let required: boolean;
+        }
+        namespace channels {
+            let description_2: string | undefined;
+            export { description_2 as description };
+            let _default: string;
+            export { _default as default };
+            export let alias: string;
+        }
+        namespace iconTypes {
+            let description_3: string | undefined;
+            export { description_3 as description };
+            let _default_1: string;
+            export { _default_1 as default };
+            let alias_1: string;
+            export { alias_1 as alias };
+        }
+        namespace verbose {
+            let description_4: string | undefined;
+            export { description_4 as description };
+            let _default_2: boolean;
+            export { _default_2 as default };
+            let alias_2: string;
+            export { alias_2 as alias };
+        }
+        namespace help {
+            let description_5: string | undefined;
+            export { description_5 as description };
+            let _default_3: boolean;
+            export { _default_3 as default };
+            let alias_3: string;
+            export { alias_3 as alias };
+        }
+    }
+}
+import { z } from "zod";

package/cjs/commands/icons/utils.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _4SFWHCB3cjs = require('../../__chunks/4SFWHCB3.cjs');
+require('../../__chunks/J36P6UNE.cjs');
+
+
+
+
+
+exports.checkDependencies = _4SFWHCB3cjs.checkDependencies; exports.generateAllIcons = _4SFWHCB3cjs.generateAllIcons; exports.generateIcon = _4SFWHCB3cjs.generateIcon; exports.validateBaseIcons = _4SFWHCB3cjs.validateBaseIcons;

package/cjs/commands/icons/utils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Check if ImageMagick is installed
+ * @param {boolean} verbose - Show verbose output
+ * @throws {Error} If ImageMagick is not installed
+ */
+export function checkDependencies(verbose?: boolean): void;
+/**
+ * Validate that required base icons exist
+ * @param {string} baseDir - Base directory containing icons
+ * @param {string[]} iconTypes - Icon types to validate
+ * @param {boolean} verbose - Show verbose output
+ * @throws {Error} If required icons are missing
+ */
+export function validateBaseIcons(baseDir: string, iconTypes: string[], verbose?: boolean): void;
+/**
+ * Generate a single icon with channel overlay
+ * @param {{
+ *   baseDir: string;
+ *   channel: string;
+ *   iconType: string;
+ *   verbose: boolean;
+ * }} options - Generation options
+ * @returns {string} Path to generated icon
+ */
+export function generateIcon(options: {
+    baseDir: string;
+    channel: string;
+    iconType: string;
+    verbose: boolean;
+}): string;
+/**
+ * Generate all icons for specified channels and types
+ * @param {{
+ *   baseDir: string;
+ *   channels: string[];
+ *   iconTypes: string[];
+ *   verbose: boolean;
+ * }} options - Generation options
+ * @returns {{ success: string[]; failed: { icon: string; error: string }[] }}
+ */
+export function generateAllIcons(options: {
+    baseDir: string;
+    channels: string[];
+    iconTypes: string[];
+    verbose: boolean;
+}): {
+    success: string[];
+    failed: {
+        icon: string;
+        error: string;
+    }[];
+};

package/cjs/commands/index.cjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+"use strict"; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _LQMP4ZKYcjs = require('../__chunks/LQMP4ZKY.cjs');
+require('../__chunks/B2KFW7T7.cjs');
+
+
+var _INFOPAHNcjs = require('../__chunks/INFOPAHN.cjs');
+require('../__chunks/4SFWHCB3.cjs');
+
+
+var _J36P6UNEcjs = require('../__chunks/J36P6UNE.cjs');
+require('../__chunks/WNJ3ZYLI.cjs');
+
+
+var _YCCIX4ZQcjs = require('../__chunks/YCCIX4ZQ.cjs');
+require('../__chunks/EMMC33QA.cjs');
+require('../__chunks/NIMXXHJQ.cjs');
+
+
+var _FEZT3HUTcjs = require('../__chunks/FEZT3HUT.cjs');
+
+// src/commands/index.js
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _commander = require('commander');
+function displayWelcomeMessage() {
+  console.log(_chalk2.default.bold.blue("\n\u{1F680} @mtndev/cli"));
+  console.log(_chalk2.default.gray(`   ${_LQMP4ZKYcjs.globalCommandsMetadata.description}
+`));
+}
+displayWelcomeMessage();
+_commander.program.name(_LQMP4ZKYcjs.globalCommandsMetadata.name).description(_LQMP4ZKYcjs.globalCommandsMetadata.description).version(_LQMP4ZKYcjs.globalCommandsMetadata.version).option(
+  `-${_LQMP4ZKYcjs.globalCommandsMetadata.options.verbose.alias}, --verbose`,
+  _LQMP4ZKYcjs.globalCommandsMetadata.options.verbose.description,
+  _LQMP4ZKYcjs.globalCommandsMetadata.options.verbose.default
+);
+_commander.program.command("doppler <action>").description(_FEZT3HUTcjs.dopplerCommandMetadata.description).option(
+  `-${_FEZT3HUTcjs.dopplerCommandMetadata.options.environment.alias}, --environment <env>`,
+  _FEZT3HUTcjs.dopplerCommandMetadata.options.environment.description,
+  _FEZT3HUTcjs.dopplerCommandMetadata.options.environment.default
+).option(
+  `-${_FEZT3HUTcjs.dopplerCommandMetadata.options.help.alias}, --help`,
+  _FEZT3HUTcjs.dopplerCommandMetadata.options.help.description,
+  _FEZT3HUTcjs.dopplerCommandMetadata.options.help.default
+).action(async (action, options, cmd) => {
+  const globalOptions = _optionalChain([cmd, 'access', _ => _.parent, 'optionalAccess', _2 => _2.opts, 'call', _3 => _3()]) || {};
+  await _YCCIX4ZQcjs.dopplerCommand.call(void 0, {
+    action,
+    environment: options.environment,
+    verbose: globalOptions.verbose,
+    help: options.help
+  });
+});
+_commander.program.command("icons <input>").description(_J36P6UNEcjs.iconsCommandMetadata.description).option(
+  `-${_J36P6UNEcjs.iconsCommandMetadata.options.channels.alias}, --channels <channels>`,
+  _J36P6UNEcjs.iconsCommandMetadata.options.channels.description,
+  _J36P6UNEcjs.iconsCommandMetadata.options.channels.default
+).option(
+  `-${_J36P6UNEcjs.iconsCommandMetadata.options.iconTypes.alias}, --icon-types <types>`,
+  _J36P6UNEcjs.iconsCommandMetadata.options.iconTypes.description,
+  _J36P6UNEcjs.iconsCommandMetadata.options.iconTypes.default
+).option(
+  `-${_J36P6UNEcjs.iconsCommandMetadata.options.help.alias}, --help`,
+  _J36P6UNEcjs.iconsCommandMetadata.options.help.description,
+  _J36P6UNEcjs.iconsCommandMetadata.options.help.default
+).action(async (input, options, cmd) => {
+  const globalOptions = _optionalChain([cmd, 'access', _4 => _4.parent, 'optionalAccess', _5 => _5.opts, 'call', _6 => _6()]) || {};
+  const channels = typeof options.channels === "string" ? options.channels.split(",").map((c) => c.trim()) : options.channels;
+  const iconTypes = typeof options.iconTypes === "string" ? options.iconTypes.split(",").map((t) => t.trim()) : options.iconTypes;
+  await _INFOPAHNcjs.iconsCommand.call(void 0, {
+    input,
+    channels,
+    iconTypes,
+    verbose: globalOptions.verbose,
+    help: options.help
+  });
+});
+_commander.program.on("command:*", () => {
+  _commander.program.help();
+});
+if (process.argv.length <= 2) {
+  _commander.program.help();
+}
+_commander.program.parse();

package/cjs/commands/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/cjs/commands/schema.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _LQMP4ZKYcjs = require('../__chunks/LQMP4ZKY.cjs');
+
+
+
+exports.globalCommandsMetadata = _LQMP4ZKYcjs.globalCommandsMetadata; exports.globalOptionsSchema = _LQMP4ZKYcjs.globalOptionsSchema;

package/cjs/commands/schema.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Zod schema for global command options
+ * These options are available across all commands
+ */
+export const globalOptionsSchema: z.ZodObject<{
+    verbose: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    verbose?: boolean | undefined;
+}, {
+    verbose?: boolean | undefined;
+}>;
+export namespace globalCommandsMetadata {
+    let name: string;
+    let version: string;
+    let description: string;
+    namespace options {
+        namespace verbose {
+            let description_1: string | undefined;
+            export { description_1 as description };
+            let _default: boolean;
+            export { _default as default };
+            export let alias: string;
+        }
+    }
+}
+import { z } from "zod";

package/cjs/index.cjs

@@ -0,0 +1,5 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/index.js
+var src_default = void 0;
+
+
+exports.default = src_default;

package/cjs/index.d.ts

@@ -0,0 +1,2 @@
+declare const undefined: undefined;
+export default undefined;

package/esm/__chunks/6G4PXXKF.js

@@ -0,0 +1,75 @@
+// src/commands/icons/schema.js
+import { z } from "zod";
+var CHANNELS = ["dev", "staging", "test"];
+var ICON_TYPES = ["icon", "adaptive-icon"];
+var CHANNEL_TEXT_MAP = {
+  dev: "DEV",
+  local: "LOC",
+  staging: "STG",
+  test: "TST"
+};
+var ICON_SIZE_MAP = {
+  "adaptive-icon": 250,
+  icon: 378
+};
+var iconsCommandOptionsSchema = z.object({
+  input: z.string().describe(
+    "Path to the input image directory containing icon.png and adaptive-icon.png"
+  ),
+  channels: z.array(z.enum(["dev", "local", "staging", "test"])).optional().default(["dev", "local", "staging", "test"]).describe("Channels to generate icons for"),
+  iconTypes: z.array(z.enum(["icon", "adaptive-icon"])).optional().default(["icon", "adaptive-icon"]).describe("Icon types to generate"),
+  verbose: z.boolean().optional().default(false).describe("Enable verbose logging for detailed error information"),
+  help: z.boolean().optional().default(false).describe("Display help for command")
+});
+var iconsCommandMetadata = {
+  name: "icons",
+  description: `Generate app channel version icons with overlay text
+
+This command generates icon variants for different app channels (dev, local, staging, test)
+by overlaying text on base icon images using ImageMagick.
+
+Requirements:
+  \u2022 ImageMagick must be installed (brew install imagemagick)
+  \u2022 Base icons (icon.png, adaptive-icon.png) must exist in the input directory
+
+Examples:
+  $ mtn icons ./apps/my-app/assets          # Generate all channel icons
+  $ mtn icons ./assets -c dev,staging       # Generate only dev and staging icons
+  $ mtn icons ./assets -t icon              # Generate only standard icons
+  $ mtn icons ./assets -v                   # Verbose output`,
+  options: {
+    input: {
+      description: iconsCommandOptionsSchema.shape.input.description,
+      required: true
+    },
+    channels: {
+      description: iconsCommandOptionsSchema.shape.channels.description,
+      default: "dev,local,staging,test",
+      alias: "c"
+    },
+    iconTypes: {
+      description: iconsCommandOptionsSchema.shape.iconTypes.description,
+      default: "icon,adaptive-icon",
+      alias: "t"
+    },
+    verbose: {
+      description: iconsCommandOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    },
+    help: {
+      description: iconsCommandOptionsSchema.shape.help.description,
+      default: false,
+      alias: "h"
+    }
+  }
+};
+
+export {
+  CHANNELS,
+  ICON_TYPES,
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP,
+  iconsCommandOptionsSchema,
+  iconsCommandMetadata
+};

package/esm/__chunks/FL7AILGH.js

@@ -0,0 +1,133 @@
+import {
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP
+} from "./6G4PXXKF.js";
+
+// src/commands/icons/utils.js
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import chalk from "chalk";
+function checkDependencies(verbose = false) {
+  if (verbose) {
+    console.log(chalk.blue("\n\u{1F50D} Checking dependencies..."));
+  }
+  try {
+    execSync("which magick", { stdio: "pipe" });
+    if (verbose) {
+      console.log(chalk.green("   \u2713 ImageMagick is installed"));
+    }
+  } catch {
+    throw new Error(
+      "ImageMagick is not installed. Please install it (brew install imagemagick) and try again."
+    );
+  }
+}
+function validateBaseIcons(baseDir, iconTypes, verbose = false) {
+  if (verbose) {
+    console.log(chalk.blue("\n\u{1F4C1} Validating base icons..."));
+  }
+  const resolvedDir = resolve(baseDir);
+  if (!existsSync(resolvedDir)) {
+    throw new Error(`Input directory does not exist: ${resolvedDir}`);
+  }
+  const missingIcons = [];
+  for (const iconType of iconTypes) {
+    const iconPath = join(resolvedDir, `${iconType}.png`);
+    if (!existsSync(iconPath)) {
+      missingIcons.push(`${iconType}.png`);
+    } else if (verbose) {
+      console.log(chalk.green(`   \u2713 Found: ${iconType}.png`));
+    }
+  }
+  if (missingIcons.length > 0) {
+    throw new Error(
+      `Missing base icons in ${resolvedDir}: ${missingIcons.join(", ")}`
+    );
+  }
+}
+function generateIcon(options) {
+  const { baseDir, channel, iconType, verbose } = options;
+  const resolvedDir = resolve(baseDir);
+  const inputFile = join(resolvedDir, `${iconType}.png`);
+  const outputFile = join(resolvedDir, `${iconType}-${channel}.png`);
+  const size = ICON_SIZE_MAP[
+    /** @type {keyof typeof ICON_SIZE_MAP} */
+    iconType
+  ] || 378;
+  const text = CHANNEL_TEXT_MAP[
+    /** @type {keyof typeof CHANNEL_TEXT_MAP} */
+    channel
+  ] || channel.toUpperCase().slice(0, 3);
+  const command = [
+    "magick",
+    `"${inputFile}"`,
+    `-pointsize ${size}`,
+    "-fill white",
+    "-gravity center",
+    "-font Arial-Black",
+    "-stroke black",
+    "-strokewidth 5",
+    `-draw "rotate -45 text 0,0 '${text}'"`,
+    `"${outputFile}"`
+  ].join(" ");
+  if (verbose) {
+    console.log(chalk.gray(`   Command: ${command}`));
+  }
+  try {
+    execSync(command, { stdio: verbose ? "inherit" : "pipe" });
+    return outputFile;
+  } catch (error) {
+    throw new Error(
+      `Failed to generate ${iconType}-${channel}.png: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function generateAllIcons(options) {
+  const { baseDir, channels, iconTypes, verbose } = options;
+  const success = [];
+  const failed = [];
+  const totalIcons = channels.length * iconTypes.length;
+  let current = 0;
+  if (verbose) {
+    console.log(chalk.blue(`
+\u{1F3A8} Generating ${totalIcons} icon(s)...`));
+  }
+  for (const channel of channels) {
+    for (const iconType of iconTypes) {
+      current++;
+      const iconName = `${iconType}-${channel}.png`;
+      if (verbose) {
+        console.log(
+          chalk.blue(`
+[${current}/${totalIcons}] Generating ${iconName}...`)
+        );
+      }
+      try {
+        const outputPath = generateIcon({
+          baseDir,
+          channel,
+          iconType,
+          verbose
+        });
+        success.push(outputPath);
+        console.log(chalk.green(`   \u2713 Generated: ${iconName}`));
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        failed.push({ icon: iconName, error: errorMessage });
+        console.log(chalk.red(`   \u2717 Failed: ${iconName}`));
+        if (verbose) {
+          console.log(chalk.red(`     ${errorMessage}`));
+        }
+      }
+    }
+  }
+  return { success, failed };
+}
+
+export {
+  checkDependencies,
+  validateBaseIcons,
+  generateIcon,
+  generateAllIcons
+};