@mtndev/cli 0.0.1

package/esm/__chunks/SJXQJ7RS.js

@@ -0,0 +1,92 @@
+// src/commands/doppler/utils/exec.js
+import { execSync } from "child_process";
+import chalk from "chalk";
+function exec(command, options = {}) {
+  const {
+    stdoutParser = "string",
+    throwOnError = true,
+    verbosity = "default",
+    stdio: userStdio,
+    ...execSyncOptions
+  } = options;
+  try {
+    if (verbosity === "verbose") {
+      console.log(chalk.gray(`   Executing: ${command}`));
+    }
+    let stdio;
+    if (userStdio) {
+      stdio = userStdio;
+    } else if (verbosity === "verbose") {
+      stdio = "inherit";
+    } else if (verbosity === "silent") {
+      stdio = "pipe";
+    } else {
+      stdio = ["pipe", "pipe", "pipe"];
+    }
+    const result = (
+      /** @type {string} */
+      execSync(command, {
+        encoding: "utf-8",
+        stdio,
+        ...execSyncOptions
+      })
+    );
+    if (stdio === "inherit") {
+      return stdoutParser === "string" ? "" : void 0;
+    }
+    if (!result || typeof result === "string" && !result.trim()) {
+      return stdoutParser === "string" ? "" : void 0;
+    }
+    switch (stdoutParser) {
+      case "json": {
+        try {
+          return JSON.parse(result);
+        } catch (parseError) {
+          if (throwOnError) {
+            throw new Error(
+              `Failed to parse JSON output: ${parseError.message}`
+            );
+          }
+          return void 0;
+        }
+      }
+      case "number": {
+        const num = parseFloat(result.trim());
+        if (isNaN(num)) {
+          if (throwOnError) {
+            throw new Error(`Failed to parse number from output: ${result}`);
+          }
+          return void 0;
+        }
+        return num;
+      }
+      case "string":
+      default:
+        return result;
+    }
+  } catch (error) {
+    if (!throwOnError) {
+      return void 0;
+    }
+    if (error.stderr) {
+      throw new Error(error.stderr.toString());
+    }
+    throw error;
+  }
+}
+function execString(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "string" });
+}
+function execJson(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "json" });
+}
+function execNumber(command, options = {}) {
+  return exec(command, { ...options, stdoutParser: "number" });
+}
+
+export {
+  exec,
+  execString,
+  execJson,
+  execNumber
+};

package/esm/__chunks/XPAQNFHZ.js

@@ -0,0 +1,52 @@
+// src/commands/doppler/schema.js
+import { z } from "zod";
+var dopplerCommandOptionsSchema = z.object({
+  action: z.enum(["download", "upload"], {
+    errorMap: () => ({
+      message: "Action must be either 'download' or 'upload'"
+    })
+  }).describe("Action to perform: download or upload configurations"),
+  environment: z.string().optional().default("dev").describe(
+    'Environment configuration to process (e.g., dev, stg, prd, or "all" for all configs)'
+  ),
+  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 dopplerCommandMetadata = {
+  name: "doppler",
+  description: `Manage Doppler configurations
+
+Subcommands:
+  download  Download configurations from Doppler to local .env files
+  upload    Upload local .env files to Doppler (with confirmation prompt)
+
+Examples:
+  $ @mtndev/cli doppler download              # Download dev config to .env.dev
+  $ @mtndev/cli doppler download -e all       # Download all configs
+  $ @mtndev/cli doppler download -e stg       # Download staging config
+  $ @mtndev/cli doppler upload                # Upload .env.dev to Doppler
+  $ @mtndev/cli doppler upload -e prd         # Upload production config`,
+  options: {
+    environment: {
+      description: dopplerCommandOptionsSchema.shape.environment.description,
+      default: "dev",
+      alias: "e"
+    },
+    // Global options are included here for help display
+    verbose: {
+      description: dopplerCommandOptionsSchema.shape.verbose.description,
+      default: false,
+      alias: "v"
+    },
+    help: {
+      description: dopplerCommandOptionsSchema.shape.help.description,
+      default: false,
+      alias: "h"
+    }
+  }
+};
+
+export {
+  dopplerCommandOptionsSchema,
+  dopplerCommandMetadata
+};

package/esm/commands/doppler/handler.d.ts

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

package/esm/commands/doppler/handler.js

@@ -0,0 +1,9 @@
+import {
+  dopplerCommand
+} from "../../__chunks/QSRTFPAA.js";
+import "../../__chunks/O262GK4B.js";
+import "../../__chunks/SJXQJ7RS.js";
+import "../../__chunks/XPAQNFHZ.js";
+export {
+  dopplerCommand
+};

package/esm/commands/doppler/index.d.ts

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

package/esm/commands/doppler/index.js

@@ -0,0 +1,41 @@
+import "../../__chunks/46HGXFME.js";
+import {
+  dopplerCommand
+} from "../../__chunks/QSRTFPAA.js";
+import {
+  checkDependencies,
+  createDiff,
+  downloadConfigs,
+  execDoppler,
+  getConfigs,
+  normalizeEscapeSequences,
+  promptConfirmation,
+  uploadConfigs
+} from "../../__chunks/O262GK4B.js";
+import {
+  exec,
+  execJson,
+  execNumber,
+  execString
+} from "../../__chunks/SJXQJ7RS.js";
+import {
+  dopplerCommandMetadata,
+  dopplerCommandOptionsSchema
+} from "../../__chunks/XPAQNFHZ.js";
+export {
+  checkDependencies,
+  createDiff,
+  dopplerCommand,
+  dopplerCommandMetadata,
+  dopplerCommandOptionsSchema,
+  downloadConfigs,
+  exec,
+  execDoppler,
+  execJson,
+  execNumber,
+  execString,
+  getConfigs,
+  normalizeEscapeSequences,
+  promptConfirmation,
+  uploadConfigs
+};

package/esm/commands/doppler/schema.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Zod schema for doppler command-specific options
+ * Global options (verbose, help) are inherited from globalOptionsSchema
+ */
+export const dopplerCommandOptionsSchema: z.ZodObject<{
+    action: z.ZodEnum<["download", "upload"]>;
+    environment: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    help: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    action: "download" | "upload";
+    environment: string;
+    verbose: boolean;
+    help: boolean;
+}, {
+    action: "download" | "upload";
+    environment?: string | undefined;
+    verbose?: boolean | undefined;
+    help?: boolean | undefined;
+}>;
+export namespace dopplerCommandMetadata {
+    let name: string;
+    let description: string;
+    namespace options {
+        namespace environment {
+            let description_1: string | undefined;
+            export { description_1 as description };
+            let _default: string;
+            export { _default as default };
+            export let alias: string;
+        }
+        namespace verbose {
+            let description_2: string | undefined;
+            export { description_2 as description };
+            let _default_1: boolean;
+            export { _default_1 as default };
+            let alias_1: string;
+            export { alias_1 as alias };
+        }
+        namespace help {
+            let description_3: string | undefined;
+            export { description_3 as description };
+            let _default_2: boolean;
+            export { _default_2 as default };
+            let alias_2: string;
+            export { alias_2 as alias };
+        }
+    }
+}
+import { z } from "zod";

package/esm/commands/doppler/schema.js

@@ -0,0 +1,8 @@
+import {
+  dopplerCommandMetadata,
+  dopplerCommandOptionsSchema
+} from "../../__chunks/XPAQNFHZ.js";
+export {
+  dopplerCommandMetadata,
+  dopplerCommandOptionsSchema
+};

package/esm/commands/doppler/utils/exec.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @typedef {'silent' | 'verbose' | 'default'} VerbosityLevel
+ */
+/**
+ * @typedef {Object} ExecOptions
+ * @property {'string' | 'number' | 'json'} [stdoutParser='string'] - How to parse stdout
+ * @property {boolean} [throwOnError=true] - Whether to throw on error
+ * @property {VerbosityLevel} [verbosity='default'] - Output verbosity level
+ */
+/**
+ * Execute a command and parse the output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options={}] - Execution options (inherits all execSync options + custom options)
+ * @returns {string | number | any} - Parsed output based on stdoutParser
+ */
+export function exec(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): string | number | any;
+/**
+ * Execute a command with string output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+ * @returns {string}
+ */
+export function execString(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): string;
+/**
+ * Execute a command with JSON output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+ * @returns {any}
+ */
+export function execJson(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): any;
+/**
+ * Execute a command with number output
+ * @param {string} command - Command to execute
+ * @param {import('child_process').ExecSyncOptions & ExecOptions} [options] - Execution options
+ * @returns {number}
+ */
+export function execNumber(command: string, options?: import("child_process").ExecSyncOptions & ExecOptions): number;
+export type VerbosityLevel = "silent" | "verbose" | "default";
+export type ExecOptions = {
+    /**
+     * - How to parse stdout
+     */
+    stdoutParser?: "string" | "number" | "json" | undefined;
+    /**
+     * - Whether to throw on error
+     */
+    throwOnError?: boolean | undefined;
+    /**
+     * - Output verbosity level
+     */
+    verbosity?: VerbosityLevel | undefined;
+};

package/esm/commands/doppler/utils/exec.js

@@ -0,0 +1,12 @@
+import {
+  exec,
+  execJson,
+  execNumber,
+  execString
+} from "../../../__chunks/SJXQJ7RS.js";
+export {
+  exec,
+  execJson,
+  execNumber,
+  execString
+};

package/esm/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/esm/commands/doppler/utils.js

@@ -0,0 +1,30 @@
+import {
+  checkDependencies,
+  createDiff,
+  downloadConfigs,
+  execDoppler,
+  getConfigs,
+  normalizeEscapeSequences,
+  promptConfirmation,
+  uploadConfigs
+} from "../../__chunks/O262GK4B.js";
+import {
+  exec,
+  execJson,
+  execNumber,
+  execString
+} from "../../__chunks/SJXQJ7RS.js";
+export {
+  checkDependencies,
+  createDiff,
+  downloadConfigs,
+  exec,
+  execDoppler,
+  execJson,
+  execNumber,
+  execString,
+  getConfigs,
+  normalizeEscapeSequences,
+  promptConfirmation,
+  uploadConfigs
+};

package/esm/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/esm/commands/icons/handler.js

@@ -0,0 +1,8 @@
+import {
+  iconsCommand
+} from "../../__chunks/HJSXC6HP.js";
+import "../../__chunks/FL7AILGH.js";
+import "../../__chunks/6G4PXXKF.js";
+export {
+  iconsCommand
+};

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

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

package/esm/commands/icons/index.js

@@ -0,0 +1,31 @@
+import "../../__chunks/SNCKIAOR.js";
+import {
+  iconsCommand
+} from "../../__chunks/HJSXC6HP.js";
+import {
+  checkDependencies,
+  generateAllIcons,
+  generateIcon,
+  validateBaseIcons
+} from "../../__chunks/FL7AILGH.js";
+import {
+  CHANNELS,
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP,
+  ICON_TYPES,
+  iconsCommandMetadata,
+  iconsCommandOptionsSchema
+} from "../../__chunks/6G4PXXKF.js";
+export {
+  CHANNELS,
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP,
+  ICON_TYPES,
+  checkDependencies,
+  generateAllIcons,
+  generateIcon,
+  iconsCommand,
+  iconsCommandMetadata,
+  iconsCommandOptionsSchema,
+  validateBaseIcons
+};

package/esm/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/esm/commands/icons/schema.js

@@ -0,0 +1,16 @@
+import {
+  CHANNELS,
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP,
+  ICON_TYPES,
+  iconsCommandMetadata,
+  iconsCommandOptionsSchema
+} from "../../__chunks/6G4PXXKF.js";
+export {
+  CHANNELS,
+  CHANNEL_TEXT_MAP,
+  ICON_SIZE_MAP,
+  ICON_TYPES,
+  iconsCommandMetadata,
+  iconsCommandOptionsSchema
+};

package/esm/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/esm/commands/icons/utils.js

@@ -0,0 +1,13 @@
+import {
+  checkDependencies,
+  generateAllIcons,
+  generateIcon,
+  validateBaseIcons
+} from "../../__chunks/FL7AILGH.js";
+import "../../__chunks/6G4PXXKF.js";
+export {
+  checkDependencies,
+  generateAllIcons,
+  generateIcon,
+  validateBaseIcons
+};

package/esm/commands/index.d.ts

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