@mtndev/cli 0.0.0-dev-20260618142325

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @mtndev/cli
+
+## 0.0.0-dev-20260618142325
+
+### Major Changes
+
+- [#9](https://github.com/High-Country-Dev/core/pull/9) [`ff9c7fb`](https://github.com/High-Country-Dev/core/commit/ff9c7fb79bfee9e7b77f99e289bbba7804cda9bb) Thanks [@StarScape](https://github.com/StarScape)! - Change -e to -t

package/cjs/__chunks/4SFWHCB3.cjs

@@ -0,0 +1,133 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+var _J36P6UNEcjs = require('./J36P6UNE.cjs');
+
+// src/commands/icons/utils.js
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _path = require('path');
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+function checkDependencies(verbose = false) {
+  if (verbose) {
+    console.log(_chalk2.default.blue("\n\u{1F50D} Checking dependencies..."));
+  }
+  try {
+    _child_process.execSync.call(void 0, "which magick", { stdio: "pipe" });
+    if (verbose) {
+      console.log(_chalk2.default.green("   \u2713 ImageMagick is installed"));
+    }
+  } catch (e) {
+    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(_chalk2.default.blue("\n\u{1F4C1} Validating base icons..."));
+  }
+  const resolvedDir = _path.resolve.call(void 0, baseDir);
+  if (!_fs.existsSync.call(void 0, resolvedDir)) {
+    throw new Error(`Input directory does not exist: ${resolvedDir}`);
+  }
+  const missingIcons = [];
+  for (const iconType of iconTypes) {
+    const iconPath = _path.join.call(void 0, resolvedDir, `${iconType}.png`);
+    if (!_fs.existsSync.call(void 0, iconPath)) {
+      missingIcons.push(`${iconType}.png`);
+    } else if (verbose) {
+      console.log(_chalk2.default.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 = _path.resolve.call(void 0, baseDir);
+  const inputFile = _path.join.call(void 0, resolvedDir, `${iconType}.png`);
+  const outputFile = _path.join.call(void 0, resolvedDir, `${iconType}-${channel}.png`);
+  const size = _J36P6UNEcjs.ICON_SIZE_MAP[
+    /** @type {keyof typeof ICON_SIZE_MAP} */
+    iconType
+  ] || 378;
+  const text = _J36P6UNEcjs.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(_chalk2.default.gray(`   Command: ${command}`));
+  }
+  try {
+    _child_process.execSync.call(void 0, 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(_chalk2.default.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(
+          _chalk2.default.blue(`
+[${current}/${totalIcons}] Generating ${iconName}...`)
+        );
+      }
+      try {
+        const outputPath = generateIcon({
+          baseDir,
+          channel,
+          iconType,
+          verbose
+        });
+        success.push(outputPath);
+        console.log(_chalk2.default.green(`   \u2713 Generated: ${iconName}`));
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        failed.push({ icon: iconName, error: errorMessage });
+        console.log(_chalk2.default.red(`   \u2717 Failed: ${iconName}`));
+        if (verbose) {
+          console.log(_chalk2.default.red(`     ${errorMessage}`));
+        }
+      }
+    }
+  }
+  return { success, failed };
+}
+
+
+
+
+
+
+exports.checkDependencies = checkDependencies; exports.validateBaseIcons = validateBaseIcons; exports.generateIcon = generateIcon; exports.generateAllIcons = generateAllIcons;

package/cjs/__chunks/B2KFW7T7.cjs

@@ -0,0 +1 @@
+"use strict";

package/cjs/__chunks/EMMC33QA.cjs

@@ -0,0 +1,401 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _NIMXXHJQcjs = require('./NIMXXHJQ.cjs');
+
+// src/commands/doppler/utils.js
+var _child_process = require('child_process');
+
+
+
+
+
+
+
+var _fs = require('fs');
+var _readline = require('readline');
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var DEFAULT_DOPPLER_ENVIRONMENT = "dev";
+function execDoppler(args, parser = "string", silent = false, verbose = false) {
+  const command = `doppler ${args.join(" ")}`;
+  let verbosity = "default";
+  if (verbose) {
+    verbosity = "verbose";
+  } else if (silent) {
+    verbosity = "silent";
+  }
+  return _NIMXXHJQcjs.exec.call(void 0, command, {
+    verbosity,
+    stdoutParser: parser,
+    throwOnError: true
+  });
+}
+function checkDependencies(verbose = false) {
+  if (verbose) {
+    console.log(_chalk2.default.blue("\n\u{1F50D} Checking Doppler dependencies..."));
+  }
+  try {
+    _child_process.execSync.call(void 0, "which doppler", { stdio: "pipe" });
+    if (verbose) {
+      console.log(_chalk2.default.green("   \u2713 Doppler CLI is installed"));
+    }
+  } catch (e) {
+    throw new Error(
+      "Doppler is not installed. Please install Doppler (brew install dopplerhq/cli/doppler), login, setup, and try again."
+    );
+  }
+  try {
+    execDoppler(["me"], "string", true, verbose);
+    if (verbose) {
+      console.log(_chalk2.default.green("   \u2713 Doppler is authenticated"));
+    }
+  } catch (e2) {
+    throw new Error(
+      "Doppler is not logged in. Please run 'doppler login' then 'doppler setup' and try again."
+    );
+  }
+  try {
+    execDoppler(["configs", "--json"], "json", true, verbose);
+    if (verbose) {
+      console.log(_chalk2.default.green("   \u2713 Doppler project is configured"));
+    }
+  } catch (e3) {
+    throw new Error(
+      "Doppler is not configured. Please run 'doppler setup' and try again."
+    );
+  }
+}
+function getConfigs(environment, verbose = false) {
+  if (verbose) {
+    console.log(
+      _chalk2.default.blue(
+        `
+\u{1F4CB} Resolving configurations for environment: ${_chalk2.default.cyan(environment)}`
+      )
+    );
+  }
+  const availableConfigs = execDoppler(
+    ["configs", "--json"],
+    "json",
+    true,
+    verbose
+  );
+  const configNames = Array.isArray(availableConfigs) ? availableConfigs.map(
+    (config) => config.name
+  ) : [];
+  if (verbose && configNames.length > 0) {
+    console.log(
+      _chalk2.default.gray(`   Available configurations: ${configNames.join(", ")}`)
+    );
+  }
+  if (environment === "all") {
+    if (configNames.length === 0) {
+      throw new Error("No configurations found in Doppler");
+    }
+    if (verbose) {
+      console.log(
+        _chalk2.default.green(`   \u2713 Using all ${configNames.length} configurations`)
+      );
+    }
+    return configNames;
+  }
+  if (configNames.length > 0 && !configNames.includes(environment)) {
+    throw new Error(
+      `Configuration "${environment}" not found. Available configurations: ${configNames.join(", ")}`
+    );
+  }
+  if (verbose) {
+    console.log(_chalk2.default.green(`   \u2713 Using configuration: ${environment}`));
+  }
+  return [environment];
+}
+function normalizeEscapeSequences(content) {
+  return content.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r");
+}
+function createDiff(oldContent, newContent) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const diff = [];
+  const maxLines = Math.max(oldLines.length, newLines.length);
+  for (let i = 0; i < maxLines; i++) {
+    const oldLine = oldLines[i] || "";
+    const newLine = newLines[i] || "";
+    if (oldLine !== newLine) {
+      if (oldLine && !newLine) {
+        diff.push(`-${oldLine}`);
+      } else if (!oldLine && newLine) {
+        diff.push(`+${newLine}`);
+      } else {
+        diff.push(`-${oldLine}`);
+        diff.push(`+${newLine}`);
+      }
+    }
+  }
+  return diff;
+}
+function promptConfirmation(message) {
+  return new Promise((resolve) => {
+    const rl = _readline.createInterface.call(void 0, {
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function downloadConfigs(options) {
+  const { environment, verbose } = options;
+  const actualEnvironment = _nullishCoalesce(environment, () => ( DEFAULT_DOPPLER_ENVIRONMENT));
+  const configs = getConfigs(actualEnvironment, verbose);
+  if (verbose) {
+    console.log(
+      _chalk2.default.blue(
+        `
+\u2B07\uFE0F  Starting download process for ${configs.length} configuration(s)...`
+      )
+    );
+  }
+  if (configs.length === 1 && environment !== "all") {
+    console.log(
+      "You can use -e all to download all configurations, or -e <env> for a specific environment."
+    );
+  }
+  for (const config of configs) {
+    const envFile = `.env.${config}`;
+    const backupFile = `${envFile}.backup`;
+    let backupMsg = "";
+    if (verbose) {
+      console.log(_chalk2.default.blue(`
+\u{1F4E6} Processing config: ${_chalk2.default.cyan(config)}`));
+    }
+    try {
+      if (_fs.existsSync.call(void 0, envFile)) {
+        if (verbose) {
+          console.log(_chalk2.default.gray(`   Creating backup: ${backupFile}`));
+        }
+        _fs.renameSync.call(void 0, envFile, backupFile);
+        backupMsg = "Backed up existing file, ";
+      }
+      if (verbose) {
+        console.log(_chalk2.default.gray(`   Downloading secrets from Doppler...`));
+      }
+      const content = execDoppler(
+        [
+          "secrets",
+          "download",
+          "--no-file",
+          "--format",
+          "env",
+          "--config",
+          config
+        ],
+        "string",
+        !verbose,
+        // Only silent if not verbose
+        verbose
+      );
+      if (typeof content === "string") {
+        _fs.writeFileSync.call(void 0, envFile, content, "utf-8");
+        if (verbose) {
+          console.log(_chalk2.default.gray(`   Written to: ${envFile}`));
+        }
+      } else {
+        throw new Error("Invalid content received from Doppler");
+      }
+      console.log(
+        `Config ${_chalk2.default.blue(config)}: ${backupMsg}downloaded successfully to ${_chalk2.default.green(envFile)}`
+      );
+      if (config === "dev" && !_fs.existsSync.call(void 0, ".env")) {
+        _fs.copyFileSync.call(void 0, envFile, ".env");
+        console.log(
+          `Copied ${_chalk2.default.green(".env.dev")} to ${_chalk2.default.green(".env")}`
+        );
+      }
+      if (_fs.existsSync.call(void 0, backupFile)) {
+        if (verbose) {
+          console.log(_chalk2.default.gray(`   Removing backup file`));
+        }
+        _fs.unlinkSync.call(void 0, backupFile);
+      }
+    } catch (error) {
+      console.error(`Failed to download ${config}: ${_optionalChain([error, 'optionalAccess', _ => _.message]) || error}`);
+      if (_fs.existsSync.call(void 0, backupFile)) {
+        _fs.renameSync.call(void 0, backupFile, envFile);
+        console.log(`Restored backup for ${envFile}`);
+      }
+    }
+  }
+}
+async function uploadConfigs(options) {
+  const { environment, verbose } = options;
+  const configs = getConfigs(environment, verbose);
+  if (verbose) {
+    console.log(
+      _chalk2.default.blue(
+        `
+\u2B06\uFE0F  Starting upload process for ${configs.length} configuration(s)...`
+      )
+    );
+  }
+  for (const config of configs) {
+    const envFile = `.env.${config}`;
+    const backupFile = `${envFile}.doppler`;
+    const normalizedFile = `${envFile}.normalized`;
+    if (verbose) {
+      console.log(_chalk2.default.blue(`
+\u{1F4E6} Processing config: ${_chalk2.default.cyan(config)}`));
+    }
+    try {
+      if (!_fs.existsSync.call(void 0, envFile)) {
+        console.log(
+          `Config ${config}: ${_chalk2.default.green(envFile)} does not exist. Skipping upload.`
+        );
+        continue;
+      }
+      if (verbose) {
+        console.log(
+          _chalk2.default.gray(`   Creating backup of current Doppler config...`)
+        );
+      }
+      try {
+        const backupContent2 = execDoppler(
+          [
+            "secrets",
+            "download",
+            "--no-file",
+            "--format",
+            "env",
+            "--config",
+            config
+          ],
+          "string",
+          !verbose,
+          // Only silent if not verbose
+          verbose
+        );
+        if (typeof backupContent2 === "string") {
+          _fs.writeFileSync.call(void 0, backupFile, backupContent2, "utf-8");
+          if (verbose) {
+            console.log(_chalk2.default.gray(`   Backup created: ${backupFile}`));
+          }
+        } else {
+          throw new Error("Invalid backup content received from Doppler");
+        }
+      } catch (e4) {
+        console.log(
+          `Config ${config}: Failed to create backup. Skipping upload.`
+        );
+        continue;
+      }
+      if (verbose) {
+        console.log(_chalk2.default.gray(`   Reading local file: ${envFile}`));
+      }
+      const localContent = _fs.readFileSync.call(void 0, envFile, "utf-8");
+      const normalizedContent = normalizeEscapeSequences(localContent);
+      _fs.writeFileSync.call(void 0, normalizedFile, normalizedContent, "utf-8");
+      if (verbose) {
+        console.log(_chalk2.default.gray(`   Comparing local changes with Doppler...`));
+      }
+      const backupContent = _fs.readFileSync.call(void 0, backupFile, "utf-8");
+      const diff = createDiff(backupContent, normalizedContent);
+      if (diff.length === 0) {
+        console.log(`Config ${config}: No differences found. Skipping upload.`);
+        _fs.unlinkSync.call(void 0, backupFile);
+        _fs.unlinkSync.call(void 0, normalizedFile);
+        continue;
+      }
+      if (verbose) {
+        console.log(_chalk2.default.yellow(`   Found ${diff.length} line changes`));
+      }
+      console.log("\nChanges to be uploaded:");
+      for (const line of diff) {
+        if (line.startsWith("-")) {
+          console.log(_chalk2.default.red(line));
+        } else if (line.startsWith("+")) {
+          console.log(_chalk2.default.green(line));
+        }
+      }
+      const confirmed = await promptConfirmation(
+        "\nDo you want to proceed with the upload? (y/n) "
+      );
+      if (!confirmed) {
+        console.log(`Upload cancelled for ${_chalk2.default.green(envFile)}`);
+        _fs.unlinkSync.call(void 0, backupFile);
+        _fs.unlinkSync.call(void 0, normalizedFile);
+        continue;
+      }
+      if (verbose) {
+        console.log(_chalk2.default.gray(`   Uploading to Doppler...`));
+      }
+      try {
+        execDoppler(
+          ["secrets", "upload", normalizedFile, "--config", config, "--silent"],
+          "string",
+          !verbose,
+          // Only silent if not verbose
+          verbose
+        );
+        if (config === "dev") {
+          console.log(
+            `Config ${_chalk2.default.blue(config)}: Successfully uploaded ${_chalk2.default.green(envFile)}`
+          );
+        } else {
+          console.log(
+            `Config ${config}: Successfully uploaded ${_chalk2.default.green(envFile)}`
+          );
+        }
+      } catch (e5) {
+        console.error(
+          `Config ${config}: Failed to upload ${_chalk2.default.green(envFile)}. Restoring previous configuration.`
+        );
+        try {
+          if (verbose) {
+            console.log(_chalk2.default.gray(`   Restoring previous configuration...`));
+          }
+          execDoppler(
+            ["secrets", "upload", backupFile, "--config", config, "--silent"],
+            "string",
+            !verbose,
+            // Only silent if not verbose
+            verbose
+          );
+          console.log(
+            `Config ${config}: Successfully restored previous configuration`
+          );
+        } catch (e6) {
+          console.error(
+            `Config ${config}: Failed to restore previous configuration`
+          );
+        }
+      }
+      if (_fs.existsSync.call(void 0, backupFile)) {
+        _fs.unlinkSync.call(void 0, backupFile);
+      }
+      if (_fs.existsSync.call(void 0, normalizedFile)) {
+        _fs.unlinkSync.call(void 0, normalizedFile);
+      }
+    } catch (error) {
+      console.error(
+        `Error processing config ${config}: ${_optionalChain([error, 'optionalAccess', _2 => _2.message]) || error}`
+      );
+      if (_fs.existsSync.call(void 0, backupFile)) {
+        _fs.unlinkSync.call(void 0, backupFile);
+      }
+      if (_fs.existsSync.call(void 0, normalizedFile)) {
+        _fs.unlinkSync.call(void 0, normalizedFile);
+      }
+    }
+  }
+}
+
+
+
+
+
+
+
+
+
+
+exports.execDoppler = execDoppler; exports.checkDependencies = checkDependencies; exports.getConfigs = getConfigs; exports.normalizeEscapeSequences = normalizeEscapeSequences; exports.createDiff = createDiff; exports.promptConfirmation = promptConfirmation; exports.downloadConfigs = downloadConfigs; exports.uploadConfigs = uploadConfigs;

package/cjs/__chunks/FFFTVBUR.cjs

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/commands/schema.js
+var _zod = require('zod');
+var globalOptionsSchema = _zod.z.object({
+  verbose: _zod.z.boolean().default(false).optional().describe("Enable verbose logging for detailed output and error traces")
+});
+var globalCommandsMetadata = {
+  name: "mtndev-cli",
+  version: "1.0.0",
+  description: "CLI tool for mtndev projects",
+  options: {
+    verbose: {
+      description: globalOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    }
+  }
+};
+
+
+
+
+exports.globalOptionsSchema = globalOptionsSchema; exports.globalCommandsMetadata = globalCommandsMetadata;

package/cjs/__chunks/HFSXD6YE.cjs

@@ -0,0 +1,100 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _EMMC33QAcjs = require('./EMMC33QA.cjs');
+
+
+
+var _QBNNK2WXcjs = require('./QBNNK2WX.cjs');
+
+// src/commands/doppler/handler.js
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _zod = require('zod');
+async function dopplerCommand(options) {
+  try {
+    const validatedOptions = _QBNNK2WXcjs.dopplerCommandOptionsSchema.parse(options);
+    if (validatedOptions.help) {
+      console.log(
+        _chalk2.default.bold(`
+Usage: @mtndev/cli doppler [options] <action>`)
+      );
+      console.log(_chalk2.default.gray(_QBNNK2WXcjs.dopplerCommandMetadata.description));
+      console.log(_chalk2.default.bold("\nOptions:"));
+      Object.entries(_QBNNK2WXcjs.dopplerCommandOptionsSchema.shape).forEach(
+        ([key, fieldSchema]) => {
+          if (key === "action") return;
+          const description = fieldSchema.description || "No description available";
+          const optionMeta = (
+            /** @type {any} */
+            _QBNNK2WXcjs.dopplerCommandMetadata.options[key]
+          );
+          const defaultValue = _nullishCoalesce(_optionalChain([optionMeta, 'optionalAccess', _ => _.default]), () => ( false));
+          const alias = _optionalChain([optionMeta, 'optionalAccess', _2 => _2.alias]) ? _chalk2.default.cyan(`, -${optionMeta.alias}`) : "";
+          console.log(
+            _chalk2.default.cyan(`  --${key}`) + alias + `  ${description} (default: ${defaultValue})`
+          );
+        }
+      );
+      console.log("");
+      return;
+    }
+    const { action, environment, verbose } = validatedOptions;
+    _EMMC33QAcjs.checkDependencies.call(void 0, verbose);
+    if (action === "download") {
+      await _EMMC33QAcjs.downloadConfigs.call(void 0, { environment, verbose });
+    } else if (action === "upload") {
+      await _EMMC33QAcjs.uploadConfigs.call(void 0, { environment, verbose });
+    }
+    console.log(_chalk2.default.green(`
+\u2705 Doppler ${action} completed successfully!`));
+  } catch (error) {
+    if (error instanceof _zod.ZodError) {
+      console.error(_chalk2.default.red(`
+\u274C Invalid command options:`));
+      error.errors.forEach((err) => {
+        console.error(_chalk2.default.red(`   ${err.path.join(".")}: ${err.message}`));
+      });
+      process.exit(1);
+    }
+    const action = (
+      /** @type {any} */
+      _optionalChain([options, 'optionalAccess', _3 => _3.action]) || "operation"
+    );
+    const verbose = (
+      /** @type {any} */
+      _optionalChain([options, 'optionalAccess', _4 => _4.verbose]) || false
+    );
+    console.error(_chalk2.default.red(`
+\u274C Doppler ${action} failed:`));
+    if (error instanceof Error) {
+      console.error(_chalk2.default.red(`   ${error.message}`));
+      if (verbose && error.stack) {
+        console.error(_chalk2.default.gray("\nStack trace:"));
+        console.error(_chalk2.default.gray(error.stack));
+      }
+    } else {
+      console.error(_chalk2.default.red(`   ${String(error)}`));
+    }
+    console.error(_chalk2.default.yellow("\n\u{1F4A1} Troubleshooting tips:"));
+    console.error(
+      _chalk2.default.yellow(
+        "   \u2022 Ensure Doppler CLI is installed (brew install dopplerhq/cli/doppler)"
+      )
+    );
+    console.error(
+      _chalk2.default.yellow("   \u2022 Make sure you're logged in (doppler login)")
+    );
+    console.error(
+      _chalk2.default.yellow("   \u2022 Verify project is configured (doppler setup)")
+    );
+    console.error(
+      _chalk2.default.yellow("   \u2022 Use --verbose for detailed error information\n")
+    );
+    process.exit(1);
+  }
+}
+
+
+
+exports.dopplerCommand = dopplerCommand;