container-superposition 0.1.1 → 0.1.3

package/dist/scripts/init.js

@@ -8,8 +8,15 @@ import boxen from 'boxen';
 import ora from 'ora';
 import { select, checkbox, input } from '@inquirer/prompts';
 import yaml from 'js-yaml';
-import { composeDevContainer } from '../tool/questionnaire/composer.js';
+import { composeDevContainer, generateManifestOnly } from '../tool/questionnaire/composer.js';
 import { loadOverlaysConfig } from '../tool/schema/overlay-loader.js';
+import { listCommand } from '../tool/commands/list.js';
+import { explainCommand } from '../tool/commands/explain.js';
+import { planCommand } from '../tool/commands/plan.js';
+import { doctorCommand } from '../tool/commands/doctor.js';
+import { getIncompatibleOverlays, DEPLOYMENT_TARGETS } from '../tool/schema/deployment-targets.js';
+import { migrateManifest, needsMigration, detectManifestVersion, isVersionSupported, CURRENT_MANIFEST_VERSION, SUPPORTED_MANIFEST_VERSIONS, } from '../tool/schema/manifest-migrations.js';
+import { getToolVersion } from '../tool/utils/version.js';
 // Get __dirname equivalent in ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -32,8 +39,8 @@ const OVERLAYS_CONFIG_CANDIDATES = [
 const OVERLAYS_CONFIG_PATH = OVERLAYS_CONFIG_CANDIDATES.find((candidate) => fs.existsSync(candidate)) ??
     OVERLAYS_CONFIG_CANDIDATES[0];
 const PRESETS_DIR_CANDIDATES = [
-    path.join(__dirname, '..', 'overlays', 'presets'),
-    path.join(__dirname, '..', '..', 'overlays', 'presets'),
+    path.join(__dirname, '..', 'overlays', '.presets'),
+    path.join(__dirname, '..', '..', 'overlays', '.presets'),
 ];
 const PRESETS_DIR = PRESETS_DIR_CANDIDATES.find((candidate) => fs.existsSync(candidate)) ??
     PRESETS_DIR_CANDIDATES[0];
@@ -111,10 +118,29 @@ function findManifestFile(manifestPath) {
 function loadManifest(manifestPath) {
     try {
         const content = fs.readFileSync(manifestPath, 'utf-8');
-        const manifest = JSON.parse(content);
+        const rawManifest = JSON.parse(content);
+        // Detect manifest version
+        const detectedVersion = detectManifestVersion(rawManifest);
+        // Check if version is supported
+        if (!isVersionSupported(detectedVersion)) {
+            console.error(chalk.red(`✗ Manifest version ${detectedVersion} is not supported.\n` +
+                `  This tool supports versions: ${SUPPORTED_MANIFEST_VERSIONS.join(', ')}\n` +
+                `  Please upgrade your tool or regenerate the manifest.`));
+            return null;
+        }
+        // Migrate if needed
+        let manifest;
+        if (needsMigration(rawManifest)) {
+            const oldVersion = rawManifest.manifestVersion || rawManifest.version || 'legacy';
+            console.log(chalk.cyan(`ℹ️  Migrating manifest from version ${oldVersion} to ${CURRENT_MANIFEST_VERSION}...`));
+            manifest = migrateManifest(rawManifest);
+        }
+        else {
+            manifest = rawManifest;
+        }
         // Basic validation
-        if (!manifest.version || !manifest.baseTemplate) {
-            console.error(chalk.red('✗ Invalid manifest format: missing required fields (version, baseTemplate)'));
+        if (!manifest.baseTemplate) {
+            console.error(chalk.red('✗ Invalid manifest format: missing required field "baseTemplate"'));
             return null;
         }
         if (!Array.isArray(manifest.overlays)) {
@@ -125,10 +151,6 @@ function loadManifest(manifestPath) {
             console.error(chalk.red('✗ Invalid manifest format: all "overlays" entries must be strings'));
             return null;
         }
-        // Version check (warn if different, but continue)
-        if (manifest.version !== '0.1.0') {
-            console.warn(chalk.yellow(`⚠️  Manifest version ${manifest.version} may not be fully compatible with this tool`));
-        }
         return manifest;
     }
     catch (error) {
@@ -603,6 +625,73 @@ async function runQuestionnaire(manifest, manifestDir) {
         const devTools = selectedOverlays.filter((o) => overlayMap.get(o)?.category === 'dev');
         const database = selectedOverlays.filter((o) => overlayMap.get(o)?.category === 'database');
         const playwright = selectedOverlays.includes('playwright');
+        // Check for deployment target compatibility
+        let target;
+        // Check if any incompatible overlays selected
+        const incompatibleOverlays = getIncompatibleOverlays(selectedOverlays, undefined);
+        if (incompatibleOverlays.length > 0) {
+            console.log(chalk.yellow('\n⚠️  Deployment Target Compatibility Check:\n'));
+            console.log(chalk.gray('Some selected overlays may not work in all environments.'));
+            console.log();
+            // Show incompatibilities
+            for (const { overlay, alternatives } of incompatibleOverlays) {
+                const overlayMeta = allOverlaysMap.get(overlay);
+                console.log(chalk.yellow(`   • ${overlayMeta?.name || overlay}`));
+                console.log(chalk.gray(`     Not compatible with: ${DEPLOYMENT_TARGETS.codespaces.name}, ${DEPLOYMENT_TARGETS.gitpod.name}`));
+                if (alternatives.length > 0) {
+                    const altNames = alternatives
+                        .map((id) => allOverlaysMap.get(id)?.name || id)
+                        .join(', ');
+                    console.log(chalk.cyan(`     Alternatives: ${altNames}`));
+                }
+                console.log();
+            }
+            const targetChoice = (await select({
+                message: 'Which environment are you targeting?',
+                choices: [
+                    {
+                        name: '🖥️  Local Development (Docker Desktop)',
+                        value: 'local',
+                        description: 'Running on your local machine - supports all overlays',
+                    },
+                    {
+                        name: '☁️  GitHub Codespaces',
+                        value: 'codespaces',
+                        description: 'Cloud development - may require docker-in-docker',
+                    },
+                    {
+                        name: '🌐 Gitpod',
+                        value: 'gitpod',
+                        description: 'Cloud development - may require docker-in-docker',
+                    },
+                    {
+                        name: '📦 DevPod',
+                        value: 'devpod',
+                        description: 'Client-only dev environments',
+                    },
+                ],
+                default: 'local',
+            }));
+            target = targetChoice;
+            // Show specific incompatibilities for selected target
+            if (target !== 'local') {
+                const targetIncompatible = getIncompatibleOverlays(selectedOverlays, target);
+                if (targetIncompatible.length > 0) {
+                    console.log(chalk.yellow(`\n⚠️  Warning: Some overlays won't work in ${DEPLOYMENT_TARGETS[target].name}:\n`));
+                    for (const { overlay, alternatives } of targetIncompatible) {
+                        const overlayMeta = allOverlaysMap.get(overlay);
+                        console.log(chalk.red(`   ✗ ${overlayMeta?.name || overlay}`));
+                        if (alternatives.length > 0) {
+                            const altNames = alternatives
+                                .map((id) => allOverlaysMap.get(id)?.name || id)
+                                .join(', ');
+                            console.log(chalk.cyan(`     → Recommended: ${altNames}`));
+                        }
+                    }
+                    console.log();
+                }
+            }
+        }
         return {
             stack,
             baseImage,
@@ -620,6 +709,7 @@ async function runQuestionnaire(manifest, manifestDir) {
             observability,
             outputPath,
             portOffset,
+            target,
         };
     }
     catch (error) {
@@ -724,6 +814,12 @@ function buildAnswersFromCliArgs(config) {
         answers.preset = config.preset;
     if (config.presetChoices)
         answers.presetChoices = config.presetChoices;
+    if (config.target)
+        answers.target = config.target;
+    if (config.minimal !== undefined)
+        answers.minimal = config.minimal;
+    if (config.editor)
+        answers.editor = config.editor;
     return answers;
 }
 /**
@@ -768,157 +864,6 @@ function mergeAnswers(...partials) {
     }
     return merged;
 }
-/**
- * List available overlays command
- */
-async function listOverlays(options) {
-    try {
-        const overlaysConfig = loadOverlaysConfigWrapper();
-        const category = options.category?.toLowerCase();
-        console.log('\n' +
-            boxen(chalk.bold('Available Overlays'), {
-                padding: 0.5,
-                borderColor: 'cyan',
-                borderStyle: 'round',
-            }));
-        const categories = [
-            { name: 'language', title: '📚 Language & Framework' },
-            { name: 'database', title: '🗄️  Database & Messaging' },
-            { name: 'observability', title: '📊 Observability' },
-            { name: 'cloud', title: '☁️  Cloud Tools' },
-            { name: 'dev', title: '🔧 Dev Tools' },
-            { name: 'preset', title: '🎯 Presets' },
-        ];
-        for (const cat of categories) {
-            if (category && cat.name !== category)
-                continue;
-            const overlays = overlaysConfig.overlays.filter((o) => o.category === cat.name);
-            if (overlays.length === 0)
-                continue;
-            console.log(`\n${chalk.bold(cat.title)}`);
-            for (const overlay of overlays) {
-                console.log(`  ${chalk.cyan(overlay.id.padEnd(20))} ${chalk.gray(overlay.description)}`);
-            }
-        }
-        console.log(chalk.dim(`\n💡 Use "container-superposition init --language nodejs,python --database postgres" to compose overlays\n`));
-        process.exit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('✗ Error listing overlays:'), error);
-        process.exit(1);
-    }
-}
-/**
- * Doctor command - check environment and validate configuration
- */
-async function runDoctor(options) {
-    try {
-        const outputPath = options.output || './.devcontainer';
-        console.log('\n' +
-            boxen(chalk.bold('Environment Check'), {
-                padding: 0.5,
-                borderColor: 'cyan',
-                borderStyle: 'round',
-            }));
-        const checks = [];
-        // Helper function for semantic version comparison
-        const isVersionAtLeast = (current, required) => {
-            const parse = (v) => {
-                const parts = v.split('.');
-                const major = parseInt(parts[0] ?? '0', 10) || 0;
-                const minor = parseInt(parts[1] ?? '0', 10) || 0;
-                const patch = parseInt(parts[2] ?? '0', 10) || 0;
-                return [major, minor, patch];
-            };
-            const [cMajor, cMinor, cPatch] = parse(current);
-            const [rMajor, rMinor, rPatch] = parse(required);
-            if (cMajor !== rMajor) {
-                return cMajor > rMajor;
-            }
-            if (cMinor !== rMinor) {
-                return cMinor > rMinor;
-            }
-            return cPatch >= rPatch;
-        };
-        // Check Node.js version
-        const nodeVersion = process.version;
-        const requiredVersion = '20.0.0';
-        const versionMatch = nodeVersion.match(/^v(\d+\.\d+\.\d+)/);
-        const currentVersion = versionMatch ? versionMatch[1] : '0.0.0';
-        const nodeOk = isVersionAtLeast(currentVersion, requiredVersion);
-        checks.push({
-            name: 'Node.js version',
-            status: nodeOk,
-            message: nodeOk
-                ? `${nodeVersion} ✓`
-                : `${nodeVersion} (requires >= ${requiredVersion})`,
-        });
-        // Check if Docker is available
-        let dockerOk = false;
-        try {
-            const { execSync } = await import('child_process');
-            execSync('docker --version', { stdio: 'ignore' });
-            dockerOk = true;
-        }
-        catch {
-            dockerOk = false;
-        }
-        checks.push({
-            name: 'Docker',
-            status: dockerOk,
-            message: dockerOk ? 'Available ✓' : 'Not found (required for devcontainers)',
-        });
-        // Check if devcontainer exists
-        const devcontainerExists = fs.existsSync(outputPath);
-        checks.push({
-            name: 'Devcontainer path',
-            status: devcontainerExists,
-            message: devcontainerExists
-                ? `${outputPath} exists ✓`
-                : `${outputPath} not found (run init first)`,
-        });
-        // Check if manifest exists
-        if (devcontainerExists) {
-            const manifestPath = path.join(outputPath, 'superposition.json');
-            const manifestExists = fs.existsSync(manifestPath);
-            checks.push({
-                name: 'Manifest',
-                status: manifestExists,
-                message: manifestExists
-                    ? 'superposition.json found ✓'
-                    : 'superposition.json missing (manual edit or old version)',
-            });
-            // Check devcontainer.json
-            const devcontainerJsonPath = path.join(outputPath, 'devcontainer.json');
-            const devcontainerJsonExists = fs.existsSync(devcontainerJsonPath);
-            checks.push({
-                name: 'DevContainer config',
-                status: devcontainerJsonExists,
-                message: devcontainerJsonExists
-                    ? 'devcontainer.json found ✓'
-                    : 'devcontainer.json missing',
-            });
-        }
-        console.log('');
-        for (const check of checks) {
-            const icon = check.status ? chalk.green('✓') : chalk.red('✗');
-            console.log(`  ${icon} ${chalk.white(check.name)}: ${chalk.gray(check.message)}`);
-        }
-        const allPassed = checks.every((c) => c.status);
-        if (allPassed) {
-            console.log(chalk.green('\n✓ All checks passed!\n'));
-            process.exit(0);
-        }
-        else {
-            console.log(chalk.yellow('\n⚠ Some checks failed. See above for details.\n'));
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        console.error(chalk.red('✗ Error running doctor:'), error);
-        process.exit(1);
-    }
-}
 /**
  * Parse CLI arguments
  */
@@ -929,7 +874,7 @@ async function parseCliArgs() {
     program
         .name('container-superposition')
         .description('Composable devcontainer scaffolds')
-        .version('0.1.0');
+        .version(getToolVersion());
     // Init command (default)
     program
         .command('init', { isDefault: true })
@@ -946,7 +891,11 @@ async function parseCliArgs() {
         .option('--cloud-tools <list>', 'Comma-separated: aws-cli, azure-cli, gcloud, kubectl-helm, terraform, pulumi')
         .option('--dev-tools <list>', 'Comma-separated: docker-in-docker, docker-sock, playwright, codex, git-helpers, pre-commit, commitlint, just, direnv, modern-cli-tools, ngrok')
         .option('--port-offset <number>', 'Add offset to all exposed ports (e.g., 100 makes Grafana 3100 instead of 3000)')
+        .option('--target <environment>', 'Deployment target: local, codespaces, gitpod, devpod (optimizes for environment)', 'local')
+        .option('--minimal', 'Minimal mode - exclude optional/nice-to-have features and extensions')
+        .option('--editor <profile>', 'Editor profile: vscode (default), jetbrains, none', 'vscode')
         .option('-o, --output <path>', 'Output path (default: ./.devcontainer)')
+        .option('--write-manifest-only', 'Generate only superposition.json manifest without creating .devcontainer/ files')
         .action((options) => {
         // Store options for main() to process
         initOptions = options;
@@ -958,12 +907,29 @@ async function parseCliArgs() {
         .option('-o, --output <path>', 'Output path (default: ./.devcontainer)')
         .option('--no-backup', 'Skip creating backup before regeneration')
         .option('--backup-dir <path>', 'Custom backup directory location')
+        .option('--minimal', 'Minimal mode - exclude optional/nice-to-have features and extensions')
+        .option('--editor <profile>', 'Editor profile: vscode (default), jetbrains, none', 'vscode')
         .action((options) => {
         const outputPath = options.output || './.devcontainer';
-        const manifestPath = path.join(outputPath, 'superposition.json');
-        if (!fs.existsSync(manifestPath)) {
-            console.error(chalk.red(`✗ Error: No manifest found at ${manifestPath}`));
-            console.error(chalk.gray('  Run "container-superposition init" first to create a configuration'));
+        // Look for manifest in multiple locations for team workflow:
+        // 1. Current directory (./superposition.json) - team workflow
+        // 2. Output directory (e.g., ./.devcontainer/superposition.json) - legacy
+        const manifestSearchPaths = [
+            'superposition.json',
+            path.join(outputPath, 'superposition.json'),
+        ];
+        let manifestPath = null;
+        for (const searchPath of manifestSearchPaths) {
+            if (fs.existsSync(searchPath)) {
+                manifestPath = searchPath;
+                break;
+            }
+        }
+        if (!manifestPath) {
+            console.error(chalk.red(`✗ Error: No manifest found`));
+            console.error(chalk.gray('  Searched for: ./superposition.json, ' +
+                path.join(outputPath, 'superposition.json')));
+            console.error(chalk.gray('  Run "container-superposition init --write-manifest-only" to create a manifest'));
             process.exit(1);
         }
         // Store options for main() to process
@@ -978,16 +944,47 @@ async function parseCliArgs() {
         .command('list')
         .description('List available overlays and presets')
         .option('--category <type>', 'Filter by category: language, database, observability, cloud, dev, preset')
+        .option('--tags <list>', 'Filter by tags (comma-separated)')
+        .option('--supports <stack>', 'Filter by stack support: plain, compose')
+        .option('--json', 'Output as JSON for scripting')
         .action(async (options) => {
-        await listOverlays(options);
+        const overlaysConfig = loadOverlaysConfigWrapper();
+        await listCommand(overlaysConfig, options);
+        process.exit(0);
+    });
+    // Explain command
+    program
+        .command('explain <overlay>')
+        .description('Show detailed information about an overlay')
+        .option('--json', 'Output as JSON for scripting')
+        .action(async (overlayId, options) => {
+        const overlaysConfig = loadOverlaysConfigWrapper();
+        await explainCommand(overlaysConfig, OVERLAYS_DIR, overlayId, options);
+        process.exit(0);
+    });
+    // Plan command
+    program
+        .command('plan')
+        .description('Preview what will be generated before creating devcontainer')
+        .option('--stack <type>', 'Base template: plain, compose', 'compose')
+        .option('--overlays <list>', 'Comma-separated list of overlay IDs')
+        .option('--port-offset <number>', 'Add offset to all exposed ports', (val) => parseInt(val, 10), 0)
+        .option('--json', 'Output as JSON for scripting')
+        .action(async (options) => {
+        const overlaysConfig = loadOverlaysConfigWrapper();
+        await planCommand(overlaysConfig, OVERLAYS_DIR, options);
+        process.exit(0);
     });
     // Doctor command
     program
         .command('doctor')
         .description('Check environment and validate configuration')
         .option('-o, --output <path>', 'Devcontainer path to validate (default: ./.devcontainer)')
+        .option('--fix', 'Apply automatic fixes where possible')
+        .option('--json', 'Output as JSON for scripting')
         .action(async (options) => {
-        await runDoctor(options);
+        const overlaysConfig = loadOverlaysConfigWrapper();
+        await doctorCommand(overlaysConfig, OVERLAYS_DIR, options);
     });
     await program.parseAsync(process.argv);
     // If init or regen command was run, return the options
@@ -1030,6 +1027,22 @@ async function parseCliArgs() {
     if (initOptions.portOffset) {
         config.portOffset = parseInt(initOptions.portOffset, 10);
     }
+    if (initOptions.target) {
+        config.target = initOptions.target;
+    }
+    if (initOptions.minimal) {
+        config.minimal = true;
+    }
+    if (initOptions.editor) {
+        const editorLower = initOptions.editor.toLowerCase();
+        if (['vscode', 'jetbrains', 'none'].includes(editorLower)) {
+            config.editor = editorLower;
+        }
+        else {
+            console.warn(chalk.yellow(`⚠️  Invalid editor profile: ${initOptions.editor}, using default (vscode)`));
+            config.editor = 'vscode';
+        }
+    }
     if (initOptions.output)
         config.outputPath = initOptions.output;
     return {
@@ -1038,6 +1051,7 @@ async function parseCliArgs() {
         noBackup: initOptions.backup === false, // Commander creates options.backup = false for --no-backup
         backupDir: initOptions.backupDir,
         noInteractive: initOptions.interactive === false, // Commander creates options.interactive = false for --no-interactive
+        writeManifestOnly: initOptions.writeManifestOnly === true,
     };
 }
 async function main() {
@@ -1091,8 +1105,12 @@ async function main() {
         }
         // Build answers based on mode
         let answers;
-        if (useManifestOnly && manifest) {
-            // Mode 1: Manifest-only (--from-manifest --no-interactive)
+        // Check if there are CLI overrides beyond just output path
+        const hasCliOverrides = cliArgs &&
+            Object.keys(cliArgs.config).some((key) => key !== 'outputPath' &&
+                cliArgs.config[key] !== undefined);
+        if (useManifestOnly && manifest && !hasCliOverrides) {
+            // Mode 1: Manifest-only (--from-manifest --no-interactive, no CLI overrides)
             const manifestAnswers = buildAnswersFromManifest(manifest, manifestDir);
             answers = mergeAnswers(manifestAnswers);
             console.log('\n' +
@@ -1110,8 +1128,9 @@ async function main() {
                         : '') +
                     chalk.gray(`  Output: ${answers.outputPath}`), { padding: 1, borderColor: 'cyan', borderStyle: 'round', margin: 1 }));
         }
-        else if (cliArgs && cliArgs.config.stack) {
+        else if (cliArgs && (cliArgs.config.stack || hasCliOverrides)) {
             // Mode 2: CLI-based (with optional manifest defaults)
+            // This includes regen with --minimal or --editor flags
             const cliAnswers = buildAnswersFromCliArgs(cliArgs.config);
             const manifestAnswers = manifest
                 ? buildAnswersFromManifest(manifest, manifestDir)
@@ -1119,12 +1138,26 @@ async function main() {
             answers = mergeAnswers(manifestAnswers, cliAnswers, {
                 outputPath: cliAnswers.outputPath || './.devcontainer',
             });
+            const modeLabel = useManifestOnly && hasCliOverrides
+                ? 'Regenerating from Manifest with Overrides'
+                : 'Running in CLI mode';
             console.log('\n' +
-                boxen(chalk.bold('Running in CLI mode'), {
+                boxen(chalk.bold(modeLabel), {
                     padding: 0.5,
                     borderColor: 'blue',
                     borderStyle: 'round',
                 }));
+            // Show what's being overridden
+            if (useManifestOnly && hasCliOverrides) {
+                const overrides = [];
+                if (cliAnswers.minimal)
+                    overrides.push('minimal mode');
+                if (cliAnswers.editor)
+                    overrides.push(`editor: ${cliAnswers.editor}`);
+                if (overrides.length > 0) {
+                    console.log(chalk.dim(`   Overrides: ${overrides.join(', ')}`));
+                }
+            }
         }
         else {
             // Mode 3: Interactive (with optional manifest pre-population)
@@ -1157,27 +1190,50 @@ async function main() {
                 borderStyle: 'round',
                 margin: { top: 0, bottom: 1 },
             }));
+        // Check if we're in manifest-only mode
+        const isManifestOnly = cliArgs?.writeManifestOnly === true;
         // Generate with spinner
         const spinner = ora({
-            text: chalk.cyan('Generating devcontainer configuration...'),
+            text: isManifestOnly
+                ? chalk.cyan('Generating manifest file...')
+                : chalk.cyan('Generating devcontainer configuration...'),
             color: 'cyan',
         }).start();
         try {
-            await composeDevContainer(answers);
-            spinner.succeed(chalk.green('DevContainer created successfully!'));
+            if (isManifestOnly) {
+                await generateManifestOnly(answers);
+                spinner.succeed(chalk.green('Manifest created successfully!'));
+            }
+            else {
+                await composeDevContainer(answers);
+                spinner.succeed(chalk.green('DevContainer created successfully!'));
+            }
         }
         catch (error) {
-            spinner.fail(chalk.red('Failed to create devcontainer'));
+            spinner.fail(chalk.red(isManifestOnly ? 'Failed to create manifest' : 'Failed to create devcontainer'));
             throw error;
         }
         // Success message
-        console.log('\n' +
-            boxen(chalk.bold.green('✓ Setup Complete!\n\n') +
+        const successMessage = isManifestOnly
+            ? chalk.bold.green('✓ Manifest Created!\n\n') +
+                chalk.white('Next steps:\n') +
+                chalk.gray('  1. Review the generated superposition.json file\n') +
+                chalk.gray('  2. Commit it to your repository\n') +
+                chalk.gray('  3. Team members can run "npx container-superposition regen"\n\n') +
+                chalk.dim('Team workflow: commit manifest, .gitignore .devcontainer/, customize with .devcontainer/custom/')
+            : chalk.bold.green('✓ Setup Complete!\n\n') +
                 chalk.white('Next steps:\n') +
                 chalk.gray('  1. Review the generated .devcontainer/ folder\n') +
                 chalk.gray("  2. Customize as needed (it's just normal JSON!)\n") +
                 chalk.gray('  3. Open in VS Code and rebuild container\n\n') +
-                chalk.dim('The generated configuration is fully editable and independent of this tool.'), { padding: 1, borderColor: 'green', borderStyle: 'double', margin: 1 }));
+                chalk.dim('The generated configuration is fully editable and independent of this tool.');
+        console.log('\n' +
+            boxen(successMessage, {
+                padding: 1,
+                borderColor: 'green',
+                borderStyle: 'double',
+                margin: 1,
+            }));
     }
     catch (error) {
         console.error('\n' +