@hugeicons/migrate 0.1.0

package/dist/main.js

@@ -0,0 +1,744 @@
+#!/usr/bin/env node
+/**
+ * Hugeicons Migration Tool CLI
+ * Command-line interface for migrating icon libraries to Hugeicons
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { select, input } from '@inquirer/prompts';
+import { VERSION, TOOL_NAME } from '@hugeicons/migrate-core';
+import { scanCommand } from './commands/scan.js';
+import { planCommand } from './commands/plan.js';
+import { applyCommand } from './commands/apply.js';
+import { revertCommand } from './commands/revert.js';
+import * as fs from 'fs';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+const program = new Command();
+program
+    .name('hugeicons-migrate')
+    .description(TOOL_NAME + ' - Migrate from popular icon libraries to Hugeicons')
+    .version(VERSION);
+// Global options
+program
+    .option('-r, --root <path>', 'Project root directory', '.')
+    .option('--include <glob>', 'Include file patterns (repeatable)', collect, [])
+    .option('--exclude <glob>', 'Exclude file patterns (repeatable)', collect, [])
+    .option('-c, --config <path>', 'Path to config file')
+    .option('--report <format>', 'Report format: text, json, md', 'text')
+    .option('-o, --output <path>', 'Output file for report/patch')
+    .option('-y, --yes', 'Non-interactive mode (CI)', false)
+    .option('--strict', 'Fail on unmapped/ambiguous icons', false)
+    .option('-v, --verbose', 'Verbose output', false);
+// Scan command
+program
+    .command('scan')
+    .description('Detect icon libraries and collect usage statistics')
+    .action(async () => {
+    const opts = program.opts();
+    await scanCommand(opts);
+});
+// Plan command
+program
+    .command('plan')
+    .description('Generate migration plan with icon mappings')
+    .option('-s, --style <style>', 'Hugeicons style: stroke, solid, duotone, auto', 'stroke')
+    .option('--confidence <threshold>', 'Fuzzy match confidence threshold (0-1)', '0.9')
+    .option('-i, --interactive', 'Interactive mode for ambiguous mappings', false)
+    .action(async (cmdOpts) => {
+    const opts = { ...program.opts(), ...cmdOpts };
+    await planCommand(opts);
+});
+// Apply command
+program
+    .command('apply')
+    .description('Apply migration transformations to source files')
+    .option('-s, --style <style>', 'Hugeicons style: stroke, solid, duotone, auto', 'stroke')
+    .option('--dry-run', 'Preview changes without writing files', false)
+    .option('-w, --write', 'Actually write changes to files', false)
+    .option('--patch', 'Generate patch file', false)
+    .option('--backup', 'Create backup before writing', false)
+    .option('--no-git-check', 'Skip git clean working tree check', false)
+    .option('--format', 'Run prettier after changes', false)
+    .option('--fix-deps', 'Update package.json dependencies', false)
+    .option('--html-report', 'Generate HTML report and open in browser', false)
+    .action(async (cmdOpts) => {
+    const opts = { ...program.opts(), ...cmdOpts };
+    await applyCommand(opts);
+});
+// Revert command
+program
+    .command('revert')
+    .description('Restore files from a migration backup')
+    .option('-b, --backup <name>', 'Specific backup directory to restore from')
+    .action(async (cmdOpts) => {
+    const opts = { ...program.opts(), ...cmdOpts };
+    await revertCommand(opts);
+});
+// Helper function to collect repeatable options
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+/**
+ * Display welcome banner
+ */
+function showWelcome() {
+    console.log();
+    console.log(chalk.cyan.bold('  ╭─────────────────────────────────────────────╮'));
+    console.log(chalk.cyan.bold('  │                                             │'));
+    console.log(chalk.cyan.bold('  │') + chalk.white.bold('      Hugeicons Migration Tool ') + chalk.yellow(`v${VERSION}`) + chalk.cyan.bold('     │'));
+    console.log(chalk.cyan.bold('  │                                             │'));
+    console.log(chalk.cyan.bold('  ╰─────────────────────────────────────────────╯'));
+    console.log();
+    console.log(chalk.gray('  Migrate from popular icon libraries to Hugeicons'));
+    console.log(chalk.gray('  Supports: Lucide, Heroicons, FontAwesome, and more'));
+    console.log();
+    console.log(chalk.yellow('  ⚠ Beta: Currently only supports Lucide with React'));
+    console.log();
+}
+/**
+ * Get custom project path from user input with retry option
+ */
+async function getCustomProjectPath() {
+    while (true) {
+        const customPath = await input({
+            message: 'Enter project path:',
+        });
+        if (!customPath.trim()) {
+            const action = await select({
+                message: 'No path entered. What would you like to do?',
+                choices: [
+                    { name: 'Enter a different path', value: 'retry' },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+            });
+            if (action === 'cancel') {
+                return null;
+            }
+            continue;
+        }
+        const resolvedPath = resolve(customPath.trim());
+        if (!existsSync(resolvedPath)) {
+            console.log();
+            console.log(chalk.red('  ✗') + chalk.white(` Path does not exist: ${chalk.cyan(resolvedPath)}`));
+            console.log();
+            const action = await select({
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Enter a different path', value: 'retry' },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+            });
+            if (action === 'cancel') {
+                return null;
+            }
+            continue;
+        }
+        const hasPackageJson = existsSync(resolve(resolvedPath, 'package.json'));
+        console.log();
+        if (hasPackageJson) {
+            console.log(chalk.green('  ✓') + chalk.white(` Project found: ${chalk.cyan(resolvedPath)}`));
+        }
+        else {
+            console.log(chalk.yellow('  ⚠') + chalk.white(` No package.json at: ${chalk.cyan(resolvedPath)}`));
+            console.log(chalk.gray('    Continuing anyway...'));
+        }
+        return resolvedPath;
+    }
+}
+/**
+ * Interactive mode - shows menu when no command is provided
+ */
+async function interactiveMode() {
+    showWelcome();
+    // Check current directory for a project
+    const cwd = process.cwd();
+    let projectPath = cwd;
+    const hasPackageJson = existsSync(resolve(cwd, 'package.json'));
+    if (hasPackageJson) {
+        console.log(chalk.green('  ✓') + chalk.white(` Project detected: ${chalk.cyan(cwd)}`));
+        console.log();
+        // Ask if user wants to use detected project or enter a different path
+        const projectChoice = await select({
+            message: 'Select project:',
+            choices: [
+                {
+                    name: 'Use current project',
+                    value: 'current',
+                },
+                {
+                    name: 'Enter a different project path',
+                    value: 'custom',
+                },
+            ],
+        });
+        if (projectChoice === 'custom') {
+            const customPath = await getCustomProjectPath();
+            if (customPath === null) {
+                console.log(chalk.gray('  Cancelled.'));
+                process.exit(0);
+            }
+            projectPath = customPath;
+        }
+        console.log();
+    }
+    else {
+        console.log(chalk.yellow('  ⚠') + chalk.white(` No package.json found in current directory`));
+        console.log(chalk.gray(`    Current path: ${cwd}`));
+        console.log();
+        // Ask user to enter a path or continue anyway
+        const projectChoice = await select({
+            message: 'What would you like to do?',
+            choices: [
+                {
+                    name: 'Enter a project path',
+                    value: 'custom',
+                },
+                {
+                    name: 'Continue with current directory anyway',
+                    value: 'current',
+                },
+                {
+                    name: 'Exit',
+                    value: 'exit',
+                },
+            ],
+        });
+        if (projectChoice === 'exit') {
+            console.log(chalk.gray('  Goodbye!'));
+            process.exit(0);
+        }
+        if (projectChoice === 'custom') {
+            const customPath = await getCustomProjectPath();
+            if (customPath === null) {
+                console.log(chalk.gray('  Cancelled.'));
+                process.exit(0);
+            }
+            projectPath = customPath;
+        }
+        console.log();
+    }
+    const baseOpts = {
+        root: projectPath,
+        include: [],
+        exclude: [],
+        config: undefined,
+        report: 'text',
+        output: undefined,
+        yes: false,
+        strict: false,
+        verbose: true,
+    };
+    // Main action loop
+    while (true) {
+        // Show action menu
+        const action = await select({
+            message: 'What would you like to do?',
+            choices: [
+                {
+                    name: 'Scan - Detect icon libraries and usage statistics',
+                    value: 'scan',
+                    description: 'Analyze your project to find icon imports and usage',
+                },
+                {
+                    name: 'Plan - Generate migration plan with icon mappings',
+                    value: 'plan',
+                    description: 'Create a detailed plan showing how icons will be mapped',
+                },
+                {
+                    name: 'Apply - Apply migration transformations (dry-run)',
+                    value: 'apply-dry',
+                    description: 'Preview changes without modifying files',
+                },
+                {
+                    name: 'Apply - Apply migration and write changes',
+                    value: 'apply-write',
+                    description: 'Actually modify your source files (creates backup)',
+                },
+                {
+                    name: 'Revert - Restore files from a backup',
+                    value: 'revert',
+                    description: 'Undo migration by restoring from backup',
+                },
+                {
+                    name: 'Exit',
+                    value: 'exit',
+                },
+            ],
+        });
+        console.log();
+        let lastAction = null;
+        let lastStyle = null;
+        switch (action) {
+            case 'scan':
+                await scanCommand(baseOpts);
+                lastAction = 'scan';
+                break;
+            case 'plan': {
+                const style = await selectStyle(projectPath);
+                if (style === 'cancel') {
+                    console.log(chalk.gray('  Cancelled.'));
+                    break;
+                }
+                console.log();
+                await planCommand({ ...baseOpts, style, confidence: '0.9', interactive: false });
+                lastAction = 'plan';
+                lastStyle = style;
+                break;
+            }
+            case 'apply-dry': {
+                const style = await selectStyle(projectPath);
+                if (style === 'cancel') {
+                    console.log(chalk.gray('  Cancelled.'));
+                    break;
+                }
+                console.log();
+                await applyCommand({
+                    ...baseOpts,
+                    style,
+                    dryRun: true,
+                    write: false,
+                    patch: false,
+                    backup: false,
+                    gitCheck: true,
+                    format: false,
+                    fixDeps: false,
+                });
+                lastAction = 'apply-dry';
+                lastStyle = style;
+                break;
+            }
+            case 'apply-write': {
+                const style = await selectStyle(projectPath);
+                if (style === 'cancel') {
+                    console.log(chalk.gray('  Cancelled.'));
+                    break;
+                }
+                console.log();
+                const confirmWrite = await select({
+                    message: 'This will modify your source files. A backup will be created.',
+                    choices: [
+                        { name: 'Proceed', value: 'proceed' },
+                        { name: 'Cancel', value: 'cancel' },
+                    ],
+                });
+                if (confirmWrite === 'cancel') {
+                    console.log(chalk.gray('  Cancelled.'));
+                    break;
+                }
+                console.log();
+                await applyCommand({
+                    ...baseOpts,
+                    style,
+                    dryRun: false,
+                    write: true,
+                    patch: false,
+                    backup: true,
+                    gitCheck: true,
+                    format: false,
+                    fixDeps: false,
+                    htmlReport: true,
+                });
+                // Exit after successful write - applyCommand will show thanks message and exit
+                // This line should not be reached but just in case
+                process.exit(0);
+            }
+            case 'revert':
+                await revertCommand({
+                    root: projectPath,
+                    yes: false,
+                    verbose: true,
+                });
+                lastAction = 'revert';
+                break;
+            case 'exit':
+                console.log(chalk.gray('  Goodbye!'));
+                process.exit(0);
+        }
+        // After command execution, ask if user wants to continue with suggested next steps
+        if (lastAction) {
+            console.log();
+            const nextChoice = await promptNextStep(lastAction, lastStyle, baseOpts);
+            if (nextChoice === 'exit') {
+                console.log();
+                console.log(chalk.gray('  Goodbye!'));
+                process.exit(0);
+            }
+            // If a direct action was chosen, execute it
+            if (nextChoice === 'plan' || nextChoice === 'apply-dry' || nextChoice === 'apply-write') {
+                console.log();
+                await executeAction(nextChoice, lastStyle, baseOpts);
+            }
+            console.log();
+        }
+    }
+}
+/**
+ * Prompt for next step with suggested actions based on last command
+ */
+async function promptNextStep(lastAction, _lastStyle, _baseOpts) {
+    const choices = [];
+    // Add suggested next steps based on last action
+    switch (lastAction) {
+        case 'scan':
+            choices.push({ name: 'Plan - Generate migration plan (suggested)', value: 'plan' }, { name: 'Apply (dry-run) - Preview changes', value: 'apply-dry' });
+            break;
+        case 'plan':
+            choices.push({ name: 'Apply (dry-run) - Preview changes (suggested)', value: 'apply-dry' }, { name: 'Apply - Write changes to files', value: 'apply-write' });
+            break;
+        case 'apply-dry':
+            choices.push({ name: 'Apply - Write changes to files (suggested)', value: 'apply-write' }, { name: 'Plan - Regenerate migration plan', value: 'plan' });
+            break;
+        case 'apply-write':
+            choices.push({ name: 'Scan - Verify migration results', value: 'scan' });
+            break;
+    }
+    // Always add these options
+    choices.push({ name: 'Other commands...', value: 'continue' }, { name: 'Exit', value: 'exit' });
+    return await select({
+        message: 'What would you like to do next?',
+        choices,
+    });
+}
+/**
+ * Execute a direct action (used for suggested next steps)
+ */
+async function executeAction(action, previousStyle, baseOpts) {
+    const projectRoot = baseOpts.root;
+    // Use previous style or ask for new one
+    let style = previousStyle;
+    if (!style || action === 'plan') {
+        const selectedStyle = await selectStyle(projectRoot);
+        if (selectedStyle === 'cancel') {
+            console.log(chalk.gray('  Cancelled.'));
+            return;
+        }
+        style = selectedStyle;
+    }
+    else {
+        // Confirm using previous style
+        const styleChoice = await select({
+            message: `Use previous style (${style})?`,
+            choices: [
+                { name: `Yes, use ${style}`, value: 'yes' },
+                { name: 'No, choose different style', value: 'no' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        if (styleChoice === 'cancel') {
+            console.log(chalk.gray('  Cancelled.'));
+            return;
+        }
+        if (styleChoice === 'no') {
+            const selectedStyle = await selectStyle(projectRoot);
+            if (selectedStyle === 'cancel') {
+                console.log(chalk.gray('  Cancelled.'));
+                return;
+            }
+            style = selectedStyle;
+        }
+    }
+    console.log();
+    switch (action) {
+        case 'plan':
+            await planCommand({ ...baseOpts, style, confidence: '0.9', interactive: false });
+            break;
+        case 'apply-dry':
+            await applyCommand({
+                ...baseOpts,
+                style,
+                dryRun: true,
+                write: false,
+                patch: false,
+                backup: false,
+                gitCheck: true,
+                format: false,
+                fixDeps: false,
+            });
+            break;
+        case 'apply-write': {
+            const confirmWrite = await select({
+                message: 'This will modify your source files. A backup will be created.',
+                choices: [
+                    { name: 'Proceed', value: 'proceed' },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+            });
+            if (confirmWrite === 'cancel') {
+                console.log(chalk.gray('  Cancelled.'));
+                return;
+            }
+            console.log();
+            await applyCommand({
+                ...baseOpts,
+                style,
+                dryRun: false,
+                write: true,
+                patch: false,
+                backup: true,
+                gitCheck: true,
+                format: false,
+                fixDeps: false,
+                htmlReport: true,
+            });
+            // Exit after write - applyCommand will exit, but just in case
+            process.exit(0);
+        }
+    }
+}
+function detectPackageManager(projectRoot) {
+    // Check for lock files to determine package manager
+    if (existsSync(resolve(projectRoot, 'bun.lockb')) || existsSync(resolve(projectRoot, 'bun.lock'))) {
+        return 'bun';
+    }
+    if (existsSync(resolve(projectRoot, 'pnpm-lock.yaml'))) {
+        return 'pnpm';
+    }
+    if (existsSync(resolve(projectRoot, 'yarn.lock'))) {
+        return 'yarn';
+    }
+    // Default to npm
+    return 'npm';
+}
+/**
+ * Check if a Hugeicons Pro license is already configured
+ */
+function hasLicenseFile(projectRoot) {
+    // Check .npmrc (npm, pnpm, bun)
+    const npmrcPath = resolve(projectRoot, '.npmrc');
+    if (existsSync(npmrcPath)) {
+        const content = fs.readFileSync(npmrcPath, 'utf-8');
+        if (content.includes('@hugeicons-pro:registry') || content.includes('//npm.hugeicons.com')) {
+            return true;
+        }
+    }
+    // Check .yarnrc.yml (yarn v2+)
+    const yarnrcPath = resolve(projectRoot, '.yarnrc.yml');
+    if (existsSync(yarnrcPath)) {
+        const content = fs.readFileSync(yarnrcPath, 'utf-8');
+        if (content.includes('hugeicons-pro') && content.includes('npm.hugeicons.com')) {
+            return true;
+        }
+    }
+    // Check bunfig.toml (bun alternative)
+    const bunfigPath = resolve(projectRoot, 'bunfig.toml');
+    if (existsSync(bunfigPath)) {
+        const content = fs.readFileSync(bunfigPath, 'utf-8');
+        if (content.includes('hugeicons-pro') && content.includes('npm.hugeicons.com')) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Save license configuration for the detected package manager
+ */
+function saveLicense(projectRoot, license) {
+    const packageManager = detectPackageManager(projectRoot);
+    // For yarn v2+, check if .yarnrc.yml exists (indicates yarn berry)
+    const isYarnBerry = existsSync(resolve(projectRoot, '.yarnrc.yml')) ||
+        (packageManager === 'yarn' && existsSync(resolve(projectRoot, '.yarn')));
+    if (isYarnBerry) {
+        return saveYarnLicense(projectRoot, license);
+    }
+    // For npm, pnpm, and bun - all support .npmrc
+    return saveNpmrcLicense(projectRoot, license, packageManager);
+}
+/**
+ * Save license to .npmrc file (works for npm, pnpm, bun)
+ */
+function saveNpmrcLicense(projectRoot, license, packageManager) {
+    const npmrcPath = resolve(projectRoot, '.npmrc');
+    let content = '';
+    if (existsSync(npmrcPath)) {
+        content = fs.readFileSync(npmrcPath, 'utf-8');
+        // Remove existing hugeicons config if present
+        content = content
+            .split('\n')
+            .filter(line => !line.includes('@hugeicons-pro:registry') && !line.includes('//npm.hugeicons.com'))
+            .join('\n')
+            .trim();
+        if (content) {
+            content += '\n\n';
+        }
+    }
+    // Add hugeicons registry config
+    content += `# Hugeicons Pro License\n`;
+    content += `@hugeicons-pro:registry=https://npm.hugeicons.com/\n`;
+    content += `//npm.hugeicons.com/:_authToken=${license}\n`;
+    fs.writeFileSync(npmrcPath, content, 'utf-8');
+    return `.npmrc (${packageManager})`;
+}
+/**
+ * Save license to .yarnrc.yml file (yarn v2+/berry)
+ */
+function saveYarnLicense(projectRoot, license) {
+    const yarnrcPath = resolve(projectRoot, '.yarnrc.yml');
+    let content = '';
+    if (existsSync(yarnrcPath)) {
+        content = fs.readFileSync(yarnrcPath, 'utf-8');
+        // Remove existing hugeicons config if present
+        const lines = content.split('\n');
+        const filteredLines = [];
+        let skipSection = false;
+        for (const line of lines) {
+            // Check if we're entering the npmScopes section for hugeicons-pro
+            if (line.match(/^\s*hugeicons-pro:/)) {
+                skipSection = true;
+                continue;
+            }
+            // Check if we're exiting the section (new top-level key or npmScopes entry)
+            if (skipSection && line.match(/^[a-zA-Z]/) || line.match(/^\s{2}[a-zA-Z]/)) {
+                skipSection = false;
+            }
+            if (!skipSection) {
+                filteredLines.push(line);
+            }
+        }
+        content = filteredLines.join('\n').trim();
+        if (content) {
+            content += '\n\n';
+        }
+    }
+    // Check if npmScopes already exists
+    if (!content.includes('npmScopes:')) {
+        content += `npmScopes:\n`;
+    }
+    // Add hugeicons-pro scope
+    content += `  hugeicons-pro:\n`;
+    content += `    npmAlwaysAuth: true\n`;
+    content += `    npmAuthToken: ${license}\n`;
+    content += `    npmRegistryServer: "https://npm.hugeicons.com/"\n`;
+    fs.writeFileSync(yarnrcPath, content, 'utf-8');
+    return '.yarnrc.yml (yarn)';
+}
+/**
+ * Select Hugeicons style with license handling for Pro styles
+ */
+async function selectStyle(projectRoot) {
+    const styleChoice = await select({
+        message: 'Select Hugeicons style:',
+        choices: [
+            { name: 'Stroke Rounded (free)', value: 'stroke-rounded' },
+            { name: 'Pro styles...', value: 'pro' },
+            { name: 'Cancel', value: 'cancel' },
+        ],
+    });
+    if (styleChoice === 'cancel' || styleChoice === 'stroke-rounded') {
+        return styleChoice === 'stroke-rounded' ? 'stroke' : 'cancel';
+    }
+    // Pro style selected - show pro style options
+    const proStyle = await select({
+        message: 'Select Pro style:',
+        choices: [
+            { name: 'Rounded', value: 'rounded' },
+            { name: 'Standard', value: 'standard' },
+            { name: 'Sharp', value: 'sharp' },
+            { name: 'Back', value: 'back' },
+            { name: 'Cancel', value: 'cancel' },
+        ],
+    });
+    if (proStyle === 'cancel') {
+        return 'cancel';
+    }
+    if (proStyle === 'back') {
+        return await selectStyle(projectRoot);
+    }
+    // Select variant within the style family
+    let variantChoices = [];
+    switch (proStyle) {
+        case 'rounded':
+            variantChoices = [
+                { name: 'Solid', value: 'solid-rounded' },
+                { name: 'Duotone', value: 'duotone-rounded' },
+                { name: 'Twotone', value: 'twotone-rounded' },
+                { name: 'Bulk', value: 'bulk-rounded' },
+            ];
+            break;
+        case 'standard':
+            variantChoices = [
+                { name: 'Stroke', value: 'stroke-standard' },
+                { name: 'Solid', value: 'solid-standard' },
+                { name: 'Duotone', value: 'duotone-standard' },
+            ];
+            break;
+        case 'sharp':
+            variantChoices = [
+                { name: 'Stroke', value: 'stroke-sharp' },
+                { name: 'Solid', value: 'solid-sharp' },
+            ];
+            break;
+    }
+    variantChoices.push({ name: 'Back', value: 'back' }, { name: 'Cancel', value: 'cancel' });
+    const variant = await select({
+        message: `Select ${proStyle} variant:`,
+        choices: variantChoices,
+    });
+    if (variant === 'cancel') {
+        return 'cancel';
+    }
+    if (variant === 'back') {
+        return await selectStyle(projectRoot);
+    }
+    // Check if license exists
+    if (projectRoot && !hasLicenseFile(projectRoot)) {
+        console.log();
+        console.log(chalk.yellow('  Pro styles require a Hugeicons license.'));
+        console.log(chalk.gray('  Get your license at: https://hugeicons.com/pricing'));
+        console.log();
+        const hasLicense = await select({
+            message: 'Do you have a Hugeicons Pro license?',
+            choices: [
+                { name: 'Yes, I have a license', value: 'yes' },
+                { name: 'No, take me to pricing', value: 'no' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        if (hasLicense === 'no') {
+            console.log();
+            console.log(chalk.gray('  Visit https://hugeicons.com/pricing to get a license.'));
+            return 'cancel';
+        }
+        if (hasLicense === 'cancel') {
+            return 'cancel';
+        }
+        const license = await input({
+            message: 'Enter your license key:',
+            validate: (value) => {
+                if (!value.trim()) {
+                    return 'Please enter a license key';
+                }
+                if (value.trim().length < 10) {
+                    return 'Invalid license key format';
+                }
+                return true;
+            },
+        });
+        // Save license to appropriate config file based on package manager
+        const configFile = saveLicense(projectRoot, license.trim());
+        console.log();
+        console.log(chalk.green('  ✓') + chalk.white(` License saved to ${configFile}`));
+    }
+    return variant;
+}
+// Check if no command was provided - run interactive mode
+const args = process.argv.slice(2);
+const hasCommand = args.some(arg => ['scan', 'plan', 'apply', 'revert', 'help', '-h', '--help', '-V', '--version'].includes(arg));
+if (!hasCommand && args.length === 0) {
+    // No arguments - run interactive mode
+    interactiveMode().catch((err) => {
+        if (err.name === 'ExitPromptError') {
+            // User cancelled with Ctrl+C
+            console.log();
+            console.log(chalk.gray('  Cancelled.'));
+            process.exit(0);
+        }
+        console.error(chalk.red('Error:'), err.message);
+        process.exit(1);
+    });
+}
+else {
+    // Parse and run with commander
+    program.parse();
+}
+//# sourceMappingURL=main.js.map