container-superposition 0.1.6 → 0.1.8

package/dist/scripts/init.js

@@ -1,1537 +1,4 @@
 #!/usr/bin/env node
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { Command } from 'commander';
-import chalk from 'chalk';
-import boxen from 'boxen';
-import ora from 'ora';
-import { select, checkbox, input } from '@inquirer/prompts';
-import yaml from 'js-yaml';
-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 { adoptCommand } from '../tool/commands/adopt.js';
-import { hashCommand } from '../tool/commands/hash.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';
-import { printSummary } from '../tool/utils/summary.js';
-import { buildAnswersFromProjectConfig, loadProjectConfig, writeProjectConfigCustomizations, } from '../tool/schema/project-config.js';
-import { isInsideGitRepo, createBackup, ensureBackupPatternsInGitignore, } from '../tool/utils/backup.js';
-// Get __dirname equivalent in ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const OVERLAYS_DIR_CANDIDATES = [
-    // When running from TypeScript sources (e.g. ts-node), __dirname is "<root>/scripts"
-    path.join(__dirname, '..', 'overlays'),
-    // When running from compiled JS in "dist/scripts", __dirname is "<root>/dist/scripts"
-    path.join(__dirname, '..', '..', 'overlays'),
-];
-const OVERLAYS_DIR = OVERLAYS_DIR_CANDIDATES.find((candidate) => fs.existsSync(candidate)) ??
-    OVERLAYS_DIR_CANDIDATES[0];
-const OVERLAYS_CONFIG_CANDIDATES = [
-    // When running from TypeScript sources (e.g. ts-node), __dirname is "<root>/scripts"
-    // and "../overlays/index.yml" resolves to "<root>/overlays/index.yml".
-    path.join(__dirname, '..', 'overlays', 'index.yml'),
-    // When running from compiled JS in "dist/scripts", __dirname is "<root>/dist/scripts"
-    // and "../../overlays/index.yml" resolves to "<root>/overlays/index.yml".
-    path.join(__dirname, '..', '..', 'overlays', 'index.yml'),
-];
-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'),
-];
-const PRESETS_DIR = PRESETS_DIR_CANDIDATES.find((candidate) => fs.existsSync(candidate)) ??
-    PRESETS_DIR_CANDIDATES[0];
-/**
- * Load overlay metadata from individual manifests or fallback to YAML file
- */
-function loadOverlaysConfigWrapper() {
-    return loadOverlaysConfig(OVERLAYS_DIR, OVERLAYS_CONFIG_PATH);
-}
-/**
- * Load preset definition from YAML file
- */
-function loadPresetDefinition(presetId) {
-    const presetPath = path.join(PRESETS_DIR, `${presetId}.yml`);
-    if (!fs.existsSync(presetPath)) {
-        console.warn(chalk.yellow(`⚠️  Preset definition not found: ${presetPath}`));
-        return null;
-    }
-    const content = fs.readFileSync(presetPath, 'utf8');
-    return yaml.load(content);
-}
-function categorizeOverlayIds(overlayIds, config) {
-    const language = [];
-    const database = [];
-    const observability = [];
-    const cloudTools = [];
-    const devTools = [];
-    const overlayMap = new Map(config.overlays.map((o) => [o.id, o]));
-    for (const id of overlayIds) {
-        const overlay = overlayMap.get(id);
-        if (!overlay)
-            continue;
-        switch (overlay.category) {
-            case 'language':
-                language.push(id);
-                break;
-            case 'database':
-                database.push(id);
-                break;
-            case 'observability':
-                observability.push(id);
-                break;
-            case 'cloud':
-                cloudTools.push(id);
-                break;
-            case 'dev':
-                devTools.push(id);
-                break;
-        }
-    }
-    return { language, database, observability, cloudTools, devTools };
-}
-function mergeUnique(left, right) {
-    const merged = [...(left ?? []), ...(right ?? [])];
-    return merged.length > 0 ? [...new Set(merged)] : undefined;
-}
-function expandPresetWithDefaults(presetId, stack, providedChoices = {}) {
-    const preset = loadPresetDefinition(presetId);
-    if (!preset) {
-        throw new Error(`Preset definition not found for ${presetId}`);
-    }
-    const overlays = [...preset.selects.required];
-    const choices = {};
-    if (preset.selects.userChoice) {
-        for (const [key, choice] of Object.entries(preset.selects.userChoice)) {
-            const selectedOption = providedChoices[key] ?? choice.defaultOption;
-            if (!selectedOption || !choice.options.includes(selectedOption)) {
-                const valid = choice.options.join(', ');
-                throw new Error(`Preset choice '${key}' must be one of: ${valid}`);
-            }
-            overlays.push(selectedOption);
-            choices[key] = selectedOption;
-        }
-    }
-    if (preset.parameters) {
-        for (const [key, param] of Object.entries(preset.parameters)) {
-            const selectedId = providedChoices[key] ?? param.default;
-            const selectedOption = param.options.find((option) => option.id === selectedId);
-            if (!selectedOption) {
-                const valid = param.options.map((option) => option.id).join(', ');
-                throw new Error(`Preset parameter '${key}' must be one of: ${valid}`);
-            }
-            overlays.push(...selectedOption.overlays);
-            choices[key] = selectedId;
-        }
-    }
-    const uniqueOverlays = [...new Set(overlays)];
-    let resolvedGlueConfig = preset.glueConfig;
-    if (resolvedGlueConfig?.environment) {
-        const resolvedEnv = {};
-        for (const [envKey, envValue] of Object.entries(resolvedGlueConfig.environment)) {
-            resolvedEnv[envKey] = envValue.replace(/\{\{parameters\.(\w+)\.id\}\}/g, (_match, paramKey) => choices[paramKey] ?? _match);
-        }
-        resolvedGlueConfig = { ...resolvedGlueConfig, environment: resolvedEnv };
-    }
-    return { overlays: uniqueOverlays, choices, glueConfig: resolvedGlueConfig };
-}
-function applyPresetSelections(answers) {
-    if (!answers.preset) {
-        return answers;
-    }
-    const expansion = expandPresetWithDefaults(answers.preset, answers.stack ?? 'plain', answers.presetChoices ?? {});
-    const categories = categorizeOverlayIds(expansion.overlays, loadOverlaysConfigWrapper());
-    return {
-        ...answers,
-        language: mergeUnique(categories.language, answers.language),
-        database: mergeUnique(categories.database, answers.database),
-        observability: mergeUnique(categories.observability, answers.observability),
-        cloudTools: mergeUnique(categories.cloudTools, answers.cloudTools),
-        devTools: mergeUnique(categories.devTools, answers.devTools),
-        playwright: answers.playwright ?? expansion.overlays.includes('playwright'),
-        presetChoices: Object.keys(expansion.choices).length > 0 ? expansion.choices : undefined,
-        presetGlueConfig: expansion.glueConfig,
-    };
-}
-/**
- * Expand a preset into a list of overlay IDs with user choices resolved
- */
-async function expandPreset(presetId, stack, preProvidedChoices = {}) {
-    const preset = loadPresetDefinition(presetId);
-    if (!preset) {
-        return { overlays: [], choices: {} };
-    }
-    console.log(chalk.cyan(`\n📦 Expanding preset: ${preset.name}\n`));
-    const overlays = [...preset.selects.required];
-    const choices = {};
-    // Handle user choices (single overlay per option)
-    if (preset.selects.userChoice) {
-        for (const [key, choice] of Object.entries(preset.selects.userChoice)) {
-            const preProvidedValue = preProvidedChoices[key];
-            if (preProvidedValue !== undefined) {
-                // Validate the pre-provided value
-                if (!choice.options.includes(preProvidedValue)) {
-                    const valid = choice.options.join(', ');
-                    throw new Error(`Invalid value '${preProvidedValue}' for preset choice '${key}'. Valid options: ${valid}`);
-                }
-                console.log(chalk.dim(`✓ ${key}: ${preProvidedValue} (from CLI)`));
-                overlays.push(preProvidedValue);
-                choices[key] = preProvidedValue;
-            }
-            else {
-                const selectedOption = (await select({
-                    message: choice.prompt,
-                    choices: choice.options.map((opt) => ({
-                        name: opt,
-                        value: opt,
-                    })),
-                    default: choice.defaultOption,
-                }));
-                overlays.push(selectedOption);
-                choices[key] = selectedOption;
-            }
-        }
-    }
-    // Handle parameterized slots (multiple overlays per option)
-    if (preset.parameters) {
-        for (const [key, param] of Object.entries(preset.parameters)) {
-            const preProvidedValue = preProvidedChoices[key];
-            let selectedId;
-            if (preProvidedValue !== undefined) {
-                // Validate the pre-provided value
-                const validOption = param.options.find((o) => o.id === preProvidedValue);
-                if (!validOption) {
-                    const valid = param.options.map((o) => o.id).join(', ');
-                    throw new Error(`Invalid value '${preProvidedValue}' for preset parameter '${key}'. Valid options: ${valid}`);
-                }
-                console.log(chalk.dim(`✓ ${key}: ${preProvidedValue} (from CLI)`));
-                selectedId = preProvidedValue;
-            }
-            else {
-                const description = param.description || `Select ${key}`;
-                selectedId = (await select({
-                    message: description,
-                    choices: param.options.map((opt) => ({
-                        name: opt.description ? `${opt.id} - ${opt.description}` : opt.id,
-                        value: opt.id,
-                    })),
-                    default: param.default,
-                }));
-            }
-            // Add overlays for the selected option
-            const selectedOption = param.options.find((o) => o.id === selectedId);
-            if (selectedOption) {
-                overlays.push(...selectedOption.overlays);
-            }
-            choices[key] = selectedId;
-        }
-    }
-    // Deduplicate overlays
-    const uniqueOverlays = [...new Set(overlays)];
-    console.log(chalk.dim(`✓ Preset will include: ${uniqueOverlays.join(', ')}\n`));
-    // Apply template substitution to glueConfig.environment values.
-    // Replaces {{parameters.<key>.id}} with the selected choice for <key>.
-    let resolvedGlueConfig = preset.glueConfig;
-    if (resolvedGlueConfig?.environment) {
-        const resolvedEnv = {};
-        for (const [envKey, envValue] of Object.entries(resolvedGlueConfig.environment)) {
-            resolvedEnv[envKey] = envValue.replace(/\{\{parameters\.(\w+)\.id\}\}/g, (_match, paramKey) => choices[paramKey] ?? _match);
-        }
-        resolvedGlueConfig = { ...resolvedGlueConfig, environment: resolvedEnv };
-    }
-    return { overlays: uniqueOverlays, choices, glueConfig: resolvedGlueConfig };
-}
-/**
- * Search for manifest file in multiple locations
- */
-function findManifestFile(manifestPath) {
-    const searchPaths = [];
-    if (manifestPath) {
-        // If path specified, use it directly
-        searchPaths.push(manifestPath);
-    }
-    else {
-        // Search in common locations
-        searchPaths.push('superposition.json', '.devcontainer/superposition.json', '../superposition.json', path.join(process.cwd(), 'superposition.json'), path.join(process.cwd(), '.devcontainer', 'superposition.json'));
-    }
-    for (const searchPath of searchPaths) {
-        const resolvedPath = path.resolve(searchPath);
-        if (fs.existsSync(resolvedPath)) {
-            return resolvedPath;
-        }
-    }
-    return null;
-}
-function findDefaultRegenManifest(outputPath = './.devcontainer') {
-    const manifestSearchPaths = ['superposition.json', path.join(outputPath, 'superposition.json')];
-    for (const searchPath of manifestSearchPaths) {
-        const resolvedPath = path.resolve(searchPath);
-        if (fs.existsSync(resolvedPath)) {
-            return resolvedPath;
-        }
-    }
-    return null;
-}
-/**
- * Load and validate manifest file
- */
-function loadManifest(manifestPath) {
-    try {
-        const content = fs.readFileSync(manifestPath, 'utf-8');
-        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.baseTemplate) {
-            console.error(chalk.red('✗ Invalid manifest format: missing required field "baseTemplate"'));
-            return null;
-        }
-        if (!Array.isArray(manifest.overlays)) {
-            console.error(chalk.red('✗ Invalid manifest format: "overlays" must be an array'));
-            return null;
-        }
-        if (!manifest.overlays.every((overlay) => typeof overlay === 'string')) {
-            console.error(chalk.red('✗ Invalid manifest format: all "overlays" entries must be strings'));
-            return null;
-        }
-        return manifest;
-    }
-    catch (error) {
-        console.error(chalk.red(`✗ Failed to load manifest: ${error instanceof Error ? error.message : String(error)}`));
-        return null;
-    }
-}
-/**
- * Build checkbox choices for overlay selection with optional pre-selection
- */
-function buildOverlayChoices(config, stack, categoryList, preselected) {
-    const choices = [];
-    categoryList.forEach((category) => {
-        const filtered = category.overlays.filter((o) => !o.supports || o.supports.length === 0 || o.supports.includes(stack));
-        if (filtered.length > 0) {
-            // Add category separator
-            choices.push({
-                type: 'separator',
-                separator: chalk.cyan(`──── ${category.name} ────`),
-            });
-            // Add overlays in this category
-            filtered.forEach((overlay) => {
-                choices.push({
-                    name: overlay.name,
-                    value: overlay.id,
-                    description: overlay.description,
-                    checked: preselected.includes(overlay.id),
-                });
-            });
-        }
-    });
-    return choices;
-}
-/**
- * Interactive questionnaire with modern checkbox selections
- */
-async function runQuestionnaire(manifest, manifestDir, cliPresetId, cliPresetChoices, defaultAnswers) {
-    const config = loadOverlaysConfigWrapper();
-    // Pretty banner
-    console.log('\n' +
-        boxen(chalk.bold.cyan('Container Superposition') +
-            '\n' +
-            chalk.gray(manifest ? 'DevContainer Regenerator' : 'DevContainer Initializer'), {
-            padding: 1,
-            margin: 1,
-            borderStyle: 'round',
-            borderColor: 'cyan',
-            textAlignment: 'center',
-        }));
-    if (manifest) {
-        console.log(chalk.cyan('📋 Loaded from manifest:'));
-        console.log(chalk.dim(`   Template: ${manifest.baseTemplate}`));
-        console.log(chalk.dim(`   Overlays: ${manifest.overlays.join(', ')}`));
-        if (manifest.preset) {
-            console.log(chalk.dim(`   Preset: ${manifest.preset}`));
-        }
-        if (manifest.portOffset) {
-            console.log(chalk.dim(`   Port offset: ${manifest.portOffset}`));
-        }
-        console.log();
-    }
-    console.log(chalk.dim('Compose your ideal devcontainer from modular overlays.'));
-    console.log(chalk.dim('Use ') +
-        chalk.cyan('space') +
-        chalk.dim(' to select, ') +
-        chalk.cyan('enter') +
-        chalk.dim(' to confirm.\n'));
-    try {
-        // Question 0: Optional preset selection
-        let usePreset = false;
-        // CLI preset takes precedence over manifest preset
-        let selectedPresetId = cliPresetId || manifest?.preset;
-        // CLI preset choices merged with manifest choices (CLI takes precedence)
-        let presetChoices = {
-            ...(manifest?.presetChoices || {}),
-            ...(cliPresetChoices || {}),
-        };
-        let presetGlueConfig;
-        const presetOverlaysFiltered = config.overlays.filter((o) => o.category === 'preset');
-        let presetOverlays = [];
-        if (presetOverlaysFiltered.length > 0) {
-            // If a preset was pre-selected via CLI or manifest, skip the prompt
-            if (selectedPresetId) {
-                usePreset = true;
-                console.log(chalk.cyan(`\n📦 Using preset: ${selectedPresetId}\n`));
-            }
-            else {
-                const defaultPreset = 'custom';
-                const presetChoice = (await select({
-                    message: 'Start from a preset or build custom?',
-                    choices: [
-                        {
-                            name: 'Custom (select overlays manually)',
-                            value: 'custom',
-                            description: 'Choose individual overlays yourself',
-                        },
-                        ...presetOverlaysFiltered.map((p) => ({
-                            name: p.name,
-                            value: p.id,
-                            description: p.description,
-                        })),
-                    ],
-                    default: defaultPreset,
-                }));
-                if (presetChoice !== 'custom') {
-                    usePreset = true;
-                    selectedPresetId = presetChoice;
-                }
-                else {
-                    // User chose custom - discard any pre-provided preset choices so the
-                    // manifest cannot end up with presetChoices but no preset.
-                    presetChoices = {};
-                    selectedPresetId = undefined;
-                }
-            }
-        }
-        // Question 1: Base template
-        const stack = (await select({
-            message: 'Select base template:',
-            choices: config.base_templates.map((t) => ({
-                name: t.name,
-                value: t.id,
-                description: t.description,
-            })),
-            default: manifest?.baseTemplate || defaultAnswers?.stack,
-        }));
-        // If using preset, expand it now (pass pre-provided choices to skip those prompts)
-        if (usePreset && selectedPresetId) {
-            const expansion = await expandPreset(selectedPresetId, stack, presetChoices);
-            if (!expansion.overlays || expansion.overlays.length === 0) {
-                // Preset failed to expand (e.g., missing or invalid preset definition).
-                // Treat this as "no preset" so the manifest does not incorrectly record one.
-                console.log(chalk.yellow(`\n⚠️  Preset "${selectedPresetId}" could not be applied. Falling back to custom overlay selection.\n`));
-                usePreset = false;
-                selectedPresetId = undefined;
-                presetOverlays = [];
-                presetChoices = {};
-                presetGlueConfig = undefined;
-            }
-            else {
-                presetOverlays = expansion.overlays;
-                presetChoices = expansion.choices;
-                presetGlueConfig = expansion.glueConfig;
-            }
-        }
-        // Question 2: Base image selection
-        // Check if manifest has a custom image or a known base image
-        const knownBaseImageIds = config.base_images.map((img) => img.id);
-        const manifestBaseImageIsKnown = manifest?.baseImage && knownBaseImageIds.includes(manifest.baseImage);
-        const manifestDefaultBaseImage = manifestBaseImageIsKnown
-            ? manifest.baseImage
-            : manifest?.baseImage
-                ? 'custom'
-                : undefined;
-        const defaultBaseImage = manifestDefaultBaseImage ||
-            (defaultAnswers?.baseImage === 'custom' && defaultAnswers.customImage
-                ? 'custom'
-                : defaultAnswers?.baseImage);
-        const baseImage = (await select({
-            message: 'Select base image:',
-            choices: config.base_images.map((img) => ({
-                name: img.name,
-                value: img.id,
-                description: img.description,
-            })),
-            default: defaultBaseImage,
-        }));
-        // Question 2a: If custom, ask for image name
-        let customImage;
-        if (baseImage === 'custom') {
-            // If manifest has a custom image, use it as default
-            const manifestCustomImage = !manifestBaseImageIsKnown && manifest?.baseImage ? manifest.baseImage : undefined;
-            const defaultCustomImage = manifestCustomImage || defaultAnswers?.customImage;
-            customImage = await input({
-                message: 'Enter custom Docker image (e.g., ubuntu:22.04):',
-                default: defaultCustomImage,
-                validate: (value) => {
-                    if (!value || value.trim() === '') {
-                        return 'Image name is required';
-                    }
-                    return true;
-                },
-            });
-            console.log(chalk.yellow('\n⚠️  Warning: Custom images may conflict with overlays.'));
-            console.log(chalk.dim('   Test thoroughly and adjust configurations as needed.\n'));
-        }
-        // Build categorized overlays with separators
-        const categoryList = [
-            {
-                name: 'Language',
-                overlays: config.overlays.filter((o) => o.category === 'language'),
-            },
-            {
-                name: 'Database',
-                overlays: config.overlays.filter((o) => o.category === 'database'),
-            },
-            {
-                name: 'Observability',
-                overlays: config.overlays.filter((o) => o.category === 'observability'),
-            },
-            { name: 'Cloud', overlays: config.overlays.filter((o) => o.category === 'cloud') },
-            { name: 'DevTool', overlays: config.overlays.filter((o) => o.category === 'dev') },
-        ];
-        // Create a map of all overlays for dependency lookup
-        const allOverlaysMap = new Map(config.overlays.map((o) => [o.id, o]));
-        // Question 3: Categorized multi-select overlays with dependency tracking
-        let userSelection;
-        if (usePreset && presetOverlays.length > 0) {
-            // Preset mode: Ask if user wants to customize
-            console.log(chalk.cyan(`\n✓ Preset includes these overlays: ${presetOverlays.join(', ')}\n`));
-            const customizePreset = (await select({
-                message: 'Do you want to customize the overlay selection?',
-                choices: [
-                    {
-                        name: 'Use preset as-is',
-                        value: 'no',
-                        description: 'Keep the preset overlay selection',
-                    },
-                    {
-                        name: 'Customize selection',
-                        value: 'yes',
-                        description: 'Add or remove overlays from the preset',
-                    },
-                ],
-            }));
-            if (customizePreset === 'yes') {
-                // Show overlay selection with preset overlays pre-selected
-                console.log(chalk.dim('\n💡 Select overlays: Space to toggle, ↑/↓ to navigate, Enter to confirm'));
-                console.log(chalk.dim('   Preset overlays are pre-selected\n'));
-                const choices = buildOverlayChoices(config, stack, categoryList, presetOverlays);
-                userSelection = await checkbox({
-                    message: 'Select overlays to include:',
-                    choices,
-                    pageSize: 15,
-                    loop: false,
-                });
-            }
-            else {
-                // Use preset selection as-is
-                userSelection = presetOverlays;
-            }
-        }
-        else if (manifest) {
-            // Manifest mode: Pre-select overlays from manifest
-            console.log(chalk.cyan(`\n✓ Manifest includes these overlays: ${manifest.overlays.join(', ')}\n`));
-            const customizeManifest = (await select({
-                message: 'Do you want to customize the overlay selection?',
-                choices: [
-                    {
-                        name: 'Use manifest as-is',
-                        value: 'no',
-                        description: 'Keep the manifest overlay selection',
-                    },
-                    {
-                        name: 'Customize selection',
-                        value: 'yes',
-                        description: 'Add or remove overlays from the manifest',
-                    },
-                ],
-            }));
-            if (customizeManifest === 'yes') {
-                // Show overlay selection with manifest overlays pre-selected
-                console.log(chalk.dim('\n💡 Select overlays: Space to toggle, ↑/↓ to navigate, Enter to confirm'));
-                console.log(chalk.dim('   Manifest overlays are pre-selected\n'));
-                // Filter out overlays that don't exist anymore
-                const existingOverlays = manifest.overlays.filter((id) => allOverlaysMap.has(id));
-                const missingOverlays = manifest.overlays.filter((id) => !allOverlaysMap.has(id));
-                if (missingOverlays.length > 0) {
-                    console.log(chalk.yellow(`⚠️  Warning: Some overlays from manifest no longer exist: ${missingOverlays.join(', ')}\n`));
-                }
-                const choices = buildOverlayChoices(config, stack, categoryList, existingOverlays);
-                userSelection = await checkbox({
-                    message: 'Select overlays to include:',
-                    choices,
-                    pageSize: 15,
-                    loop: false,
-                });
-            }
-            else {
-                // Use manifest selection as-is (filtering out missing overlays)
-                const existingOverlays = manifest.overlays.filter((id) => allOverlaysMap.has(id));
-                const missingOverlays = manifest.overlays.filter((id) => !allOverlaysMap.has(id));
-                if (missingOverlays.length > 0) {
-                    console.log(chalk.yellow(`⚠️  Warning: Some overlays from manifest no longer exist and will be skipped: ${missingOverlays.join(', ')}\n`));
-                }
-                userSelection = existingOverlays;
-            }
-        }
-        else {
-            // Custom mode: Normal overlay selection
-            console.log(chalk.dim('\n💡 Select overlays: Space to toggle, ↑/↓ to navigate, Enter to confirm\n'));
-            const preselectedDefaults = [
-                ...(defaultAnswers?.language ?? []),
-                ...(defaultAnswers?.database ?? []),
-                ...(defaultAnswers?.observability ?? []),
-                ...(defaultAnswers?.cloudTools ?? []),
-                ...(defaultAnswers?.devTools ?? []),
-                ...(defaultAnswers?.playwright ? ['playwright'] : []),
-            ];
-            const choices = buildOverlayChoices(config, stack, categoryList, preselectedDefaults);
-            userSelection = await checkbox({
-                message: 'Select overlays to include:',
-                choices,
-                pageSize: 15,
-                loop: false,
-            });
-        }
-        // Add all required dependencies
-        const withDependencies = new Set(userSelection);
-        const toProcess = [...userSelection];
-        while (toProcess.length > 0) {
-            const current = toProcess.pop();
-            const overlay = allOverlaysMap.get(current);
-            if (overlay?.requires) {
-                overlay.requires.forEach((req) => {
-                    if (!withDependencies.has(req)) {
-                        withDependencies.add(req);
-                        toProcess.push(req);
-                    }
-                });
-            }
-        }
-        let selectedOverlays = Array.from(withDependencies);
-        // Check for conflicts and resolve
-        let hasConflicts = true;
-        while (hasConflicts) {
-            const conflicts = new Map();
-            // Find all conflicts
-            selectedOverlays.forEach((selectedId) => {
-                const overlay = allOverlaysMap.get(selectedId);
-                if (overlay?.conflicts) {
-                    overlay.conflicts.forEach((conflictId) => {
-                        if (selectedOverlays.includes(conflictId)) {
-                            if (!conflicts.has(selectedId)) {
-                                conflicts.set(selectedId, []);
-                            }
-                            conflicts.get(selectedId).push(conflictId);
-                        }
-                    });
-                }
-            });
-            if (conflicts.size === 0) {
-                hasConflicts = false;
-            }
-            else {
-                // Show conflict resolution UI
-                console.log(chalk.yellow('\n⚠️  Conflicts detected in selection:\n'));
-                const conflictChoices = [];
-                conflicts.forEach((conflictingWith, overlayId) => {
-                    const overlay = allOverlaysMap.get(overlayId);
-                    const conflictNames = conflictingWith
-                        .map((id) => allOverlaysMap.get(id)?.name)
-                        .join(', ');
-                    conflictChoices.push({
-                        name: `Remove ${overlay.name}`,
-                        value: overlayId,
-                        description: `Conflicts with: ${conflictNames}`,
-                    });
-                });
-                const toRemove = await checkbox({
-                    message: 'Select overlays to remove to resolve conflicts:',
-                    choices: conflictChoices,
-                    pageSize: 15,
-                    loop: false,
-                });
-                if (toRemove.length === 0) {
-                    console.log(chalk.red('\n❌ You must remove at least one conflicting overlay'));
-                    continue;
-                }
-                // Remove selected overlays
-                selectedOverlays = selectedOverlays.filter((id) => !toRemove.includes(id));
-            }
-        }
-        // Question 4: Container name
-        const containerName = await input({
-            message: 'Container/project name (optional):',
-            default: manifest?.containerName || defaultAnswers?.containerName || '',
-        });
-        // Question 5: Output path
-        // If manifest provided, default to its location; otherwise use ./.devcontainer
-        const defaultOutput = manifestDir || defaultAnswers?.outputPath || './.devcontainer';
-        const outputPath = await input({
-            message: 'Output path:',
-            default: defaultOutput,
-        });
-        // Question 6: Port offset (optional, for running multiple instances)
-        const portOffsetInput = await input({
-            message: 'Port offset (leave empty for default ports, e.g., 100 to avoid conflicts):',
-            default: manifest?.portOffset !== undefined
-                ? String(manifest.portOffset)
-                : defaultAnswers?.portOffset !== undefined
-                    ? String(defaultAnswers.portOffset)
-                    : '',
-        });
-        const portOffset = portOffsetInput ? parseInt(portOffsetInput, 10) : undefined;
-        // Parse selected overlays into categories
-        const overlayMap = new Map(config.overlays.map((o) => [o.id, o]));
-        const language = selectedOverlays.filter((o) => overlayMap.get(o)?.category === 'language');
-        const observability = selectedOverlays.filter((o) => overlayMap.get(o)?.category === 'observability');
-        const cloudTools = selectedOverlays.filter((o) => overlayMap.get(o)?.category === 'cloud');
-        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,
-            customImage,
-            containerName: containerName || undefined,
-            preset: selectedPresetId,
-            presetChoices: Object.keys(presetChoices).length > 0 ? presetChoices : undefined,
-            presetGlueConfig,
-            language,
-            needsDocker: stack === 'compose', // Compose template includes docker-outside-of-docker
-            database,
-            playwright,
-            cloudTools,
-            devTools,
-            observability,
-            outputPath,
-            portOffset,
-            target: target ?? defaultAnswers?.target,
-            minimal: defaultAnswers?.minimal,
-            editor: defaultAnswers?.editor,
-            customizations: defaultAnswers?.customizations,
-        };
-    }
-    catch (error) {
-        if (error.name === 'ExitPromptError') {
-            console.log('\n' + chalk.yellow('Cancelled by user'));
-            process.exit(0);
-        }
-        throw error;
-    }
-}
-/**
- * Build partial answers from manifest
- * Note: Categories are only used for UI/questionnaire grouping.
- * The composer works with overlay IDs regardless of category.
- */
-function buildAnswersFromManifest(manifest, manifestDir) {
-    const config = loadOverlaysConfigWrapper();
-    // Helper to categorize overlays by type (for QuestionnaireAnswers structure)
-    const categorizeOverlays = (overlayIds) => {
-        const language = [];
-        const database = [];
-        const observability = [];
-        const cloudTools = [];
-        const devTools = [];
-        // Build lookup map from unified overlays array
-        const overlayMap = new Map(config.overlays.map((o) => [o.id, o]));
-        // Categorize based on overlay metadata
-        for (const id of overlayIds) {
-            const overlay = overlayMap.get(id);
-            if (!overlay)
-                continue;
-            switch (overlay.category) {
-                case 'language':
-                    language.push(id);
-                    break;
-                case 'database':
-                    database.push(id);
-                    break;
-                case 'observability':
-                    observability.push(id);
-                    break;
-                case 'cloud':
-                    cloudTools.push(id);
-                    break;
-                case 'dev':
-                    devTools.push(id);
-                    break;
-            }
-        }
-        return { language, database, observability, cloudTools, devTools };
-    };
-    const categories = categorizeOverlays(manifest.overlays);
-    // Output path is always the directory containing the manifest
-    const outputPath = manifestDir || './.devcontainer';
-    // Handle baseImage - check if it's a known ID or a custom image string
-    const knownBaseImageIds = ['bookworm', 'trixie', 'alpine', 'ubuntu', 'custom'];
-    const isKnownBaseImage = knownBaseImageIds.includes(manifest.baseImage);
-    return {
-        stack: manifest.baseTemplate,
-        baseImage: isKnownBaseImage ? manifest.baseImage : 'custom',
-        customImage: isKnownBaseImage ? undefined : manifest.baseImage,
-        containerName: manifest.containerName,
-        preset: manifest.preset,
-        presetChoices: manifest.presetChoices,
-        ...categories,
-        needsDocker: manifest.baseTemplate === 'compose',
-        playwright: categories.devTools.includes('playwright'),
-        outputPath,
-        portOffset: manifest.portOffset,
-    };
-}
-/**
- * Build partial answers from CLI arguments
- */
-function buildAnswersFromCliArgs(config) {
-    const answers = {};
-    if (config.stack) {
-        answers.stack = config.stack;
-        answers.needsDocker = config.stack === 'compose';
-    }
-    if (config.baseImage)
-        answers.baseImage = config.baseImage;
-    if (config.containerName)
-        answers.containerName = config.containerName;
-    if (config.language)
-        answers.language = config.language;
-    if (config.database)
-        answers.database = config.database;
-    if (config.playwright !== undefined)
-        answers.playwright = config.playwright;
-    if (config.observability)
-        answers.observability = config.observability;
-    if (config.cloudTools)
-        answers.cloudTools = config.cloudTools;
-    if (config.devTools)
-        answers.devTools = config.devTools;
-    if (config.portOffset !== undefined)
-        answers.portOffset = config.portOffset;
-    if (config.outputPath)
-        answers.outputPath = config.outputPath;
-    if (config.preset)
-        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;
-}
-/**
- * Merge multiple partial answers with precedence: cli > interactive > manifest > defaults
- */
-function mergeAnswers(...partials) {
-    const merged = {
-        language: [],
-        database: [],
-        cloudTools: [],
-        devTools: [],
-        observability: [],
-        playwright: false,
-        outputPath: './.devcontainer',
-    };
-    // Merge in order (later overrides earlier)
-    for (const partial of partials) {
-        if (!partial)
-            continue;
-        Object.keys(partial).forEach((key) => {
-            const value = partial[key];
-            if (value !== undefined && value !== null) {
-                // For arrays, prefer non-empty values
-                if (Array.isArray(value)) {
-                    if (value.length > 0) {
-                        merged[key] = value;
-                    }
-                }
-                else {
-                    merged[key] = value;
-                }
-            }
-        });
-    }
-    // Ensure required fields have defaults
-    if (!merged.stack)
-        merged.stack = 'plain';
-    if (!merged.baseImage)
-        merged.baseImage = 'bookworm';
-    if (!merged.needsDocker && merged.stack) {
-        merged.needsDocker = merged.stack === 'compose';
-    }
-    return merged;
-}
-/**
- * Parse CLI arguments
- */
-async function parseCliArgs() {
-    const program = new Command();
-    // Store init options for access after parsing
-    let initOptions = null;
-    program
-        .name('container-superposition')
-        .description('Composable devcontainer scaffolds')
-        .version(getToolVersion());
-    // Init command (default)
-    program
-        .command('init', { isDefault: true })
-        .description('Initialize a new devcontainer configuration')
-        .option('--from-project', 'Load configuration from the repository project file')
-        .option('--project-root <path>', 'Run project-file and manifest discovery relative to a different repository root')
-        .option('--from-manifest <path>', 'Load configuration from existing superposition.json manifest')
-        .option('--no-interactive', 'Use persisted input values directly without questionnaire')
-        .option('--backup', 'Force or suppress backup; default is --no-backup inside a git repo, --backup outside')
-        .option('--backup-dir <path>', 'Custom backup directory location')
-        .option('--stack <type>', 'Base template: plain, compose')
-        .option('--language <list>', 'Comma-separated language overlays: dotnet, nodejs, python, mkdocs, java, go, rust, bun, powershell')
-        .option('--database <list>', 'Comma-separated database overlays: postgres, redis, mongodb, mysql, sqlserver, sqlite, minio, rabbitmq, redpanda, nats')
-        .option('--observability <list>', 'Comma-separated: otel-collector, jaeger, prometheus, grafana, loki')
-        .option('--playwright', 'Include Playwright browser automation')
-        .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')
-        .option('--preset <id>', 'Start from a preset (e.g., web-api, microservice)')
-        .option('--preset-param <value>', 'Set a preset parameter value (format: key=value, can be repeated)', (value, previous) => previous.concat([value]), [])
-        .action((options, command) => {
-        // Store options for main() to process
-        initOptions = {
-            ...options,
-            commandName: 'init',
-            _targetSource: command.getOptionValueSource('target'),
-            _editorSource: command.getOptionValueSource('editor'),
-        };
-    });
-    // Regen command
-    program
-        .command('regen')
-        .description('Regenerate devcontainer from a project file or existing superposition.json manifest')
-        .option('--from-project', 'Load configuration from the repository project file')
-        .option('--project-root <path>', 'Run project-file and manifest discovery relative to a different repository root')
-        .option('--from-manifest <path>', 'Load configuration from existing superposition.json manifest')
-        .option('-o, --output <path>', 'Output path (default: ./.devcontainer)')
-        .option('--backup', 'Force or suppress backup; default is --no-backup inside a git repo, --backup outside')
-        .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, command) => {
-        initOptions = {
-            ...options,
-            commandName: 'regen',
-            interactive: false,
-            _editorSource: command.getOptionValueSource('editor'),
-        };
-    });
-    // List command
-    program
-        .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) => {
-        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')
-        .option('--overlays <list>', 'Comma-separated list of overlay IDs')
-        .option('--from-manifest <path>', 'Load stack and overlays from an existing superposition.json manifest')
-        .option('--port-offset <number>', 'Add offset to all exposed ports', (val) => parseInt(val, 10), 0)
-        .option('-o, --output <path>', 'Compare against existing config at this path (default: ./.devcontainer)')
-        .option('--diff', 'Compare planned output vs existing configuration')
-        .option('--diff-format <format>', 'Diff output format: color (default), json', 'color')
-        .option('--diff-context <lines>', 'Context lines in diff output', (val) => parseInt(val, 10), 3)
-        .option('--verbose', 'Explain why each overlay was included in the resolved plan')
-        .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) => {
-        const overlaysConfig = loadOverlaysConfigWrapper();
-        await doctorCommand(overlaysConfig, OVERLAYS_DIR, options);
-    });
-    // Adopt command
-    program
-        .command('adopt')
-        .description('Analyse an existing .devcontainer/ and suggest an equivalent overlay-based configuration')
-        .option('-d, --dir <path>', 'Path to the existing .devcontainer directory (default: ./.devcontainer)')
-        .option('--dry-run', 'Print analysis and suggested command only; no files written')
-        .option('--force', 'Overwrite existing superposition.json if present')
-        .option('--backup', 'Force backup creation even when inside a git repo (default: backup only outside git repos)')
-        .option('--no-backup', 'Disable backup creation even when it would normally be performed')
-        .option('--backup-dir <path>', 'Custom backup directory location')
-        .option('--project-file', 'Also write a repository-root project config (.superposition.yml or existing project file)')
-        .option('--json', 'Output as JSON for scripting')
-        .action(async (options) => {
-        const overlaysConfig = loadOverlaysConfigWrapper();
-        await adoptCommand(overlaysConfig, OVERLAYS_DIR, options);
-        process.exit(0);
-    });
-    // Hash command
-    program
-        .command('hash')
-        .description('Compute a deterministic fingerprint for a given configuration')
-        .option('--stack <type>', 'Base template: plain, compose')
-        .option('--overlays <list>', 'Comma-separated list of overlay IDs')
-        .option('--preset <id>', 'Preset ID (optional)')
-        .option('--base <image>', 'Base image / distro variant (e.g. bookworm, alpine)')
-        .option('--manifest <path>', 'Path to superposition.json manifest')
-        .option('-o, --output <path>', 'Directory to write hash file (used with --write)')
-        .option('--write', 'Write hash to .devcontainer/superposition.hash')
-        .option('--json', 'Output as JSON for scripting')
-        .action(async (options) => {
-        const overlaysConfig = loadOverlaysConfigWrapper();
-        await hashCommand(overlaysConfig, OVERLAYS_DIR, options);
-        process.exit(0);
-    });
-    await program.parseAsync(process.argv);
-    // If init or regen command was run, return the options
-    if (!initOptions) {
-        // No init/regen command run (list or doctor ran instead)
-        return null;
-    }
-    // If no options provided to init, return null to trigger interactive mode
-    if (Object.keys(initOptions).length === 0) {
-        return null;
-    }
-    const hasSourceFlags = Number(Boolean(initOptions.fromProject)) + Number(Boolean(initOptions.fromManifest));
-    if (hasSourceFlags > 1) {
-        console.error(chalk.red('✗ Error: --from-project and --from-manifest cannot be used together'));
-        process.exit(1);
-    }
-    const sourceSelectionConflicts = [
-        'stack',
-        'language',
-        'database',
-        'observability',
-        'playwright',
-        'cloudTools',
-        'devTools',
-        'portOffset',
-        'preset',
-    ];
-    const hasPresetParams = Array.isArray(initOptions.presetParam) && initOptions.presetParam.length > 0;
-    const conflictingSelectionFlags = sourceSelectionConflicts.filter((key) => initOptions[key] !== undefined && initOptions[key] !== false);
-    if ((initOptions.fromProject || initOptions.fromManifest) &&
-        (conflictingSelectionFlags.length > 0 || hasPresetParams)) {
-        const conflicts = [...conflictingSelectionFlags.map((key) => `--${key}`)];
-        if (hasPresetParams) {
-            conflicts.push('--preset-param');
-        }
-        console.error(chalk.red(`✗ Error: Persisted input sources cannot be combined with clean-generation selection flags: ${conflicts.join(', ')}`));
-        console.error(chalk.dim('  Choose either a persisted input source (--from-project or --from-manifest) or direct selection flags for that run.'));
-        process.exit(1);
-    }
-    const config = {};
-    if (initOptions.stack)
-        config.stack = initOptions.stack;
-    if (initOptions.language) {
-        config.language = initOptions.language
-            .split(',')
-            .map((l) => l.trim());
-    }
-    if (initOptions.database) {
-        config.database = initOptions.database
-            .split(',')
-            .map((d) => d.trim());
-    }
-    if (initOptions.observability) {
-        config.observability = initOptions.observability
-            .split(',')
-            .map((t) => t.trim());
-    }
-    if (initOptions.playwright)
-        config.playwright = true;
-    if (initOptions.cloudTools) {
-        config.cloudTools = initOptions.cloudTools
-            .split(',')
-            .map((t) => t.trim());
-    }
-    if (initOptions.devTools) {
-        config.devTools = initOptions.devTools.split(',').map((t) => t.trim());
-    }
-    if (initOptions.portOffset) {
-        config.portOffset = parseInt(initOptions.portOffset, 10);
-    }
-    if (initOptions.target && initOptions._targetSource !== 'default') {
-        config.target = initOptions.target;
-    }
-    if (initOptions.minimal) {
-        config.minimal = true;
-    }
-    if (initOptions.editor && initOptions._editorSource !== 'default') {
-        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;
-    // Handle --preset flag
-    if (initOptions.preset) {
-        config.preset = initOptions.preset;
-    }
-    // Handle --preset-param flags (can be repeated)
-    if (initOptions.presetParam && initOptions.presetParam.length > 0) {
-        if (!initOptions.preset) {
-            console.warn(chalk.yellow('⚠️  Ignoring --preset-param because no --preset was provided. ' +
-                'Preset parameters only apply when a preset is selected (e.g., --preset web-api --preset-param broker=nats).'));
-        }
-        else {
-            const presetChoices = {};
-            for (const param of initOptions.presetParam) {
-                const eqIdx = param.indexOf('=');
-                if (eqIdx > 0) {
-                    const key = param.slice(0, eqIdx).trim();
-                    const value = param.slice(eqIdx + 1).trim();
-                    if (key) {
-                        presetChoices[key] = value;
-                    }
-                }
-                else {
-                    console.warn(chalk.yellow(`⚠️  Invalid --preset-param format: "${param}". Expected "key=value" (e.g., --preset-param broker=nats).`));
-                }
-            }
-            if (Object.keys(presetChoices).length > 0) {
-                config.presetChoices = presetChoices;
-            }
-        }
-    }
-    return {
-        commandName: initOptions.commandName,
-        config,
-        manifestPath: initOptions.fromManifest,
-        fromProject: initOptions.fromProject === true,
-        projectRoot: initOptions.projectRoot,
-        backupOverride: initOptions.backup, // undefined = auto-detect; true = --backup; false = --no-backup
-        backupDir: initOptions.backupDir,
-        noInteractive: initOptions.interactive === false, // Commander creates options.interactive = false for --no-interactive
-        writeManifestOnly: initOptions.writeManifestOnly === true,
-    };
-}
-async function main() {
-    try {
-        const cliArgs = await parseCliArgs();
-        const initialCwd = process.cwd();
-        if (cliArgs?.projectRoot) {
-            const resolvedProjectRoot = path.resolve(initialCwd, cliArgs.projectRoot);
-            if (!fs.existsSync(resolvedProjectRoot)) {
-                console.error(chalk.red(`✗ Project root not found: ${resolvedProjectRoot}`));
-                process.exit(1);
-            }
-            if (!fs.statSync(resolvedProjectRoot).isDirectory()) {
-                console.error(chalk.red(`✗ Project root is not a directory: ${resolvedProjectRoot}`));
-                process.exit(1);
-            }
-            process.chdir(resolvedProjectRoot);
-        }
-        let projectConfig = undefined;
-        let projectConfigAnswers;
-        if (!cliArgs?.manifestPath) {
-            projectConfig =
-                loadProjectConfig(loadOverlaysConfigWrapper(), process.cwd()) ?? undefined;
-            if (projectConfig) {
-                projectConfigAnswers = applyPresetSelections(buildAnswersFromProjectConfig(projectConfig.selection));
-            }
-        }
-        let manifest;
-        let manifestDir;
-        let backupDir;
-        let useManifestOnly = false;
-        let useProjectOnly = false;
-        if (cliArgs?.commandName === 'regen' && !cliArgs.manifestPath && !cliArgs.fromProject) {
-            if (projectConfigAnswers) {
-                useProjectOnly = true;
-            }
-            else {
-                const discoveredManifestPath = findDefaultRegenManifest(cliArgs?.config?.outputPath || './.devcontainer');
-                if (!discoveredManifestPath) {
-                    console.error(chalk.red('✗ Error: No project file or manifest found'));
-                    console.error(chalk.gray('  Looked for .superposition.yml or superposition.yml in the repository root, and superposition.json in common manifest locations.'));
-                    process.exit(1);
-                }
-                cliArgs.manifestPath = discoveredManifestPath;
-            }
-        }
-        // Handle manifest loading
-        if (cliArgs?.manifestPath) {
-            const manifestPath = findManifestFile(cliArgs.manifestPath);
-            if (!manifestPath) {
-                console.error(chalk.red('✗ Could not find manifest file'));
-                console.error(chalk.red(`  Searched for: ${cliArgs.manifestPath}`));
-                process.exit(1);
-            }
-            manifestDir = path.dirname(manifestPath);
-            const loadedManifest = loadManifest(manifestPath);
-            if (!loadedManifest) {
-                process.exit(1);
-            }
-            manifest = loadedManifest;
-            // Check for interaction options
-            if (cliArgs.backupDir) {
-                backupDir = cliArgs.backupDir;
-            }
-            if (cliArgs.noInteractive) {
-                useManifestOnly = true;
-            }
-        }
-        if (cliArgs?.fromProject) {
-            if (!projectConfigAnswers || !projectConfig) {
-                console.error(chalk.red('✗ Could not find project file'));
-                console.error(chalk.red('  Searched for: .superposition.yml, superposition.yml'));
-                process.exit(1);
-            }
-            useProjectOnly = cliArgs.noInteractive || cliArgs.commandName === 'regen';
-        }
-        // Validate --no-interactive requires a persisted input source
-        if (cliArgs?.noInteractive && !cliArgs?.manifestPath && !projectConfigAnswers) {
-            console.error(chalk.red('✗ Error: --no-interactive requires persisted input'));
-            console.error(chalk.dim('  Use --from-project, --from-manifest <path>, or run from a repository with .superposition.yml or superposition.yml'));
-            process.exit(1);
-        }
-        // Determine whether to create a backup:
-        //   --backup      → always backup
-        //   --no-backup   → never backup
-        //   (neither)     → backup only when NOT inside a git repository
-        //                   (git already tracks history, so backups are redundant)
-        const resolvedOutputPath = cliArgs?.config?.outputPath ||
-            projectConfigAnswers?.outputPath ||
-            manifestDir ||
-            './.devcontainer';
-        const backupCheckPath = path.resolve(resolvedOutputPath);
-        const inGitRepo = isInsideGitRepo(backupCheckPath);
-        let shouldBackup;
-        if (cliArgs?.backupOverride === true) {
-            shouldBackup = true;
-        }
-        else if (cliArgs?.backupOverride === false) {
-            shouldBackup = false;
-        }
-        else {
-            // Auto-detect based on git presence
-            shouldBackup = !inGitRepo;
-            if (!shouldBackup) {
-                console.log(chalk.dim('ℹ  Skipping backup — git repo detected (use --backup to force one)\n'));
-            }
-        }
-        const isReplayMode = cliArgs?.commandName === 'regen' || useManifestOnly || useProjectOnly;
-        // Create backup if needed
-        let actualBackupPath;
-        if (shouldBackup && isReplayMode) {
-            const outputPath = resolvedOutputPath;
-            const backupPath = await createBackup(outputPath, backupDir);
-            if (backupPath) {
-                actualBackupPath = backupPath;
-                console.log(chalk.green(`✓ Backup created: ${backupPath}\n`));
-                ensureBackupPatternsInGitignore(outputPath);
-            }
-        }
-        // Build answers based on mode
-        let answers;
-        // Check if there are CLI overrides beyond just output path and preset flags
-        // Preset/presetChoices alone don't constitute "CLI overrides" that bypass interactive mode
-        const hasCliOverrides = cliArgs &&
-            Object.keys(cliArgs.config).some((key) => key !== 'outputPath' &&
-                key !== 'preset' &&
-                key !== 'presetChoices' &&
-                !(key === 'target' && cliArgs.config.target === 'local') &&
-                !(key === 'editor' && cliArgs.config.editor === 'vscode') &&
-                cliArgs.config[key] !== undefined);
-        const hasAnyCliConfig = cliArgs &&
-            Object.entries(cliArgs.config).some(([key, value]) => value !== undefined &&
-                !(key === 'target' && value === 'local') &&
-                !(key === 'editor' && value === 'vscode'));
-        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' +
-                boxen(chalk.bold.cyan('Regenerating from Manifest (No Interactive)\n\n') +
-                    chalk.white('Configuration:\n') +
-                    chalk.gray(`  Template: ${manifest.baseTemplate}\n`) +
-                    chalk.gray(`  Base Image: ${manifest.baseImage}\n`) +
-                    (manifest.containerName
-                        ? chalk.gray(`  Container: ${manifest.containerName}\n`)
-                        : '') +
-                    chalk.gray(`  Overlays: ${manifest.overlays.join(', ')}\n`) +
-                    (manifest.preset ? chalk.gray(`  Preset: ${manifest.preset}\n`) : '') +
-                    (manifest.portOffset
-                        ? chalk.gray(`  Port offset: ${manifest.portOffset}\n`)
-                        : '') +
-                    chalk.gray(`  Output: ${answers.outputPath}`), { padding: 1, borderColor: 'cyan', borderStyle: 'round', margin: 1 }));
-        }
-        else if (useProjectOnly && projectConfigAnswers && !hasCliOverrides) {
-            const projectFileName = projectConfig?.file.fileName ?? '.superposition.yml';
-            answers = mergeAnswers(projectConfigAnswers, {
-                outputPath: cliArgs?.config?.outputPath ||
-                    projectConfigAnswers.outputPath ||
-                    './.devcontainer',
-                minimal: cliArgs?.config?.minimal,
-                editor: cliArgs?.config?.editor,
-            });
-            console.log('\n' +
-                boxen(chalk.bold.cyan('Regenerating from Project File (No Interactive)\n\n') +
-                    chalk.white('Configuration:\n') +
-                    chalk.gray(`  Project file: ${projectFileName}\n`) +
-                    chalk.gray(`  Output: ${answers.outputPath}`), {
-                    padding: 1,
-                    borderColor: 'cyan',
-                    borderStyle: 'round',
-                    margin: 1,
-                }));
-        }
-        else if ((cliArgs && (cliArgs.config.stack || hasCliOverrides)) ||
-            (projectConfigAnswers && (cliArgs?.noInteractive || hasAnyCliConfig))) {
-            // 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)
-                : undefined;
-            answers = mergeAnswers(projectConfigAnswers, manifestAnswers, cliAnswers, {
-                outputPath: cliAnswers.outputPath || projectConfigAnswers?.outputPath || './.devcontainer',
-            });
-            const modeLabel = useManifestOnly && hasCliOverrides
-                ? 'Regenerating from Manifest with Overrides'
-                : useProjectOnly && projectConfigAnswers
-                    ? 'Regenerating from Project File with Overrides'
-                    : projectConfigAnswers && !manifest
-                        ? 'Running from Project Config'
-                        : 'Running in CLI mode';
-            console.log('\n' +
-                boxen(chalk.bold(modeLabel), {
-                    padding: 0.5,
-                    borderColor: 'blue',
-                    borderStyle: 'round',
-                }));
-            // Show what's being overridden
-            if ((useManifestOnly || useProjectOnly) && 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 and CLI preset pre-selection)
-            const interactiveAnswers = await runQuestionnaire(manifest, manifestDir, cliArgs?.config.preset || projectConfigAnswers?.preset, cliArgs?.config.presetChoices || projectConfigAnswers?.presetChoices, projectConfigAnswers);
-            answers = mergeAnswers(projectConfigAnswers, interactiveAnswers);
-        }
-        if (!manifest && projectConfig?.selection.customizations) {
-            const materializedOutputPath = path.resolve(answers.outputPath);
-            if (!fs.existsSync(materializedOutputPath)) {
-                fs.mkdirSync(materializedOutputPath, { recursive: true });
-            }
-            writeProjectConfigCustomizations(materializedOutputPath, projectConfig.selection.customizations);
-        }
-        // Show configuration summary
-        const summaryLines = [
-            chalk.bold.white('Configuration Summary\n'),
-            chalk.cyan('Base:            ') + chalk.white(answers.stack),
-        ];
-        if (answers.language && answers.language.length > 0) {
-            summaryLines.push(chalk.cyan('Languages:       ') + chalk.white(answers.language.join(', ')));
-        }
-        if (answers.database && answers.database.length > 0) {
-            summaryLines.push(chalk.cyan('Database:        ') + chalk.white(answers.database.join(', ')));
-        }
-        summaryLines.push(chalk.cyan('Playwright:      ') + chalk.white(answers.playwright ? 'Yes' : 'No'));
-        if (answers.observability && answers.observability.length > 0) {
-            summaryLines.push(chalk.cyan('Observability:   ') + chalk.white(answers.observability.join(', ')));
-        }
-        if (answers.cloudTools && answers.cloudTools.length > 0) {
-            summaryLines.push(chalk.cyan('Cloud tools:     ') + chalk.white(answers.cloudTools.join(', ')));
-        }
-        if (projectConfig?.file && !manifest) {
-            summaryLines.push(chalk.cyan('Project config:  ') + chalk.white(projectConfig.file.fileName));
-        }
-        summaryLines.push(chalk.cyan('Output:          ') + chalk.white(answers.outputPath));
-        console.log('\n' +
-            boxen(summaryLines.join('\n'), {
-                padding: 1,
-                borderColor: 'green',
-                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: isManifestOnly
-                ? chalk.cyan('Generating manifest file...')
-                : chalk.cyan('Generating devcontainer configuration...'),
-            color: 'cyan',
-        }).start();
-        try {
-            let summary;
-            if (isManifestOnly) {
-                summary = await generateManifestOnly(answers, undefined, {
-                    isRegen: isReplayMode,
-                });
-                spinner.succeed(chalk.green('Manifest created successfully!'));
-            }
-            else {
-                summary = await composeDevContainer(answers, undefined, { isRegen: isReplayMode });
-                spinner.succeed(chalk.green('DevContainer created successfully!'));
-            }
-            // Update summary with backup path and regen status
-            if (actualBackupPath) {
-                summary.backupPath = actualBackupPath;
-            }
-            // Print comprehensive summary
-            printSummary(summary);
-        }
-        catch (error) {
-            spinner.fail(chalk.red(isManifestOnly ? 'Failed to create manifest' : 'Failed to create devcontainer'));
-            throw error;
-        }
-    }
-    catch (error) {
-        console.error('\n' +
-            boxen(chalk.bold.red('Error\n\n') +
-                chalk.white(error instanceof Error ? error.message : String(error)), { padding: 1, borderColor: 'red', borderStyle: 'round' }));
-        process.exit(1);
-    }
-}
+import { main } from '../tool/cli/run.js';
 main();
 //# sourceMappingURL=init.js.map