@mtndev/cli 0.0.0-dev-20260618142325

package/esm/commands/doppler/index.js

@@ -0,0 +1,41 @@
+import "../../__chunks/46HGXFME.js";
+import {
+  dopplerCommand
+} from "../../__chunks/G6WUCFLD.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/LHVSSZI7.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/LHVSSZI7.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 {};

package/esm/commands/index.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  globalCommandsMetadata
+} from "../__chunks/EC6MPHID.js";
+import "../__chunks/SNCKIAOR.js";
+import {
+  iconsCommand
+} from "../__chunks/HJSXC6HP.js";
+import "../__chunks/FL7AILGH.js";
+import {
+  iconsCommandMetadata
+} from "../__chunks/6G4PXXKF.js";
+import "../__chunks/46HGXFME.js";
+import {
+  dopplerCommand
+} from "../__chunks/G6WUCFLD.js";
+import "../__chunks/O262GK4B.js";
+import "../__chunks/SJXQJ7RS.js";
+import {
+  dopplerCommandMetadata
+} from "../__chunks/LHVSSZI7.js";
+
+// src/commands/index.js
+import chalk from "chalk";
+import { program } from "commander";
+function displayWelcomeMessage() {
+  console.log(chalk.bold.blue("\n\u{1F680} @mtndev/cli"));
+  console.log(chalk.gray(`   ${globalCommandsMetadata.description}
+`));
+}
+displayWelcomeMessage();
+program.name(globalCommandsMetadata.name).description(globalCommandsMetadata.description).version(globalCommandsMetadata.version).option(
+  `-${globalCommandsMetadata.options.verbose.alias}, --verbose`,
+  globalCommandsMetadata.options.verbose.description,
+  globalCommandsMetadata.options.verbose.default
+);
+program.command("doppler <action>").description(dopplerCommandMetadata.description).option(
+  `-${dopplerCommandMetadata.options.environment.alias}, --environment <env>`,
+  dopplerCommandMetadata.options.environment.description,
+  dopplerCommandMetadata.options.environment.default
+).option(
+  `-${dopplerCommandMetadata.options.help.alias}, --help`,
+  dopplerCommandMetadata.options.help.description,
+  dopplerCommandMetadata.options.help.default
+).action(async (action, options, cmd) => {
+  const globalOptions = cmd.parent?.opts() || {};
+  await dopplerCommand({
+    action,
+    environment: options.environment,
+    verbose: globalOptions.verbose,
+    help: options.help
+  });
+});
+program.command("icons <input>").description(iconsCommandMetadata.description).option(
+  `-${iconsCommandMetadata.options.channels.alias}, --channels <channels>`,
+  iconsCommandMetadata.options.channels.description,
+  iconsCommandMetadata.options.channels.default
+).option(
+  `-${iconsCommandMetadata.options.iconTypes.alias}, --icon-types <types>`,
+  iconsCommandMetadata.options.iconTypes.description,
+  iconsCommandMetadata.options.iconTypes.default
+).option(
+  `-${iconsCommandMetadata.options.help.alias}, --help`,
+  iconsCommandMetadata.options.help.description,
+  iconsCommandMetadata.options.help.default
+).action(async (input, options, cmd) => {
+  const globalOptions = cmd.parent?.opts() || {};
+  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 iconsCommand({
+    input,
+    channels,
+    iconTypes,
+    verbose: globalOptions.verbose,
+    help: options.help
+  });
+});
+program.on("command:*", () => {
+  program.help();
+});
+if (process.argv.length <= 2) {
+  program.help();
+}
+program.parse();

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

@@ -0,0 +1,8 @@
+import {
+  globalCommandsMetadata,
+  globalOptionsSchema
+} from "../__chunks/EC6MPHID.js";
+export {
+  globalCommandsMetadata,
+  globalOptionsSchema
+};

package/esm/index.d.ts

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

package/esm/index.js

@@ -0,0 +1,5 @@
+// src/index.js
+var src_default = void 0;
+export {
+  src_default as default
+};