@hed-hog/cli 0.0.35 → 0.0.37

package/dist/src/modules/developer/developer.service.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeveloperService = void 0;
 const common_1 = require("@nestjs/common");
 const chalk = require("chalk");
+const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const ejs_1 = require("ejs");
 const fs_1 = require("fs");
@@ -51,6 +52,1373 @@ let DeveloperService = class DeveloperService {
             process.emitWarning = originalEmitWarning;
         };
     }
+    refreshEnvironmentPath() {
+        try {
+            if (process.platform === 'win32') {
+                // On Windows, re-read PATH from system environment registry
+                const pathCmd = `powershell -NoProfile -Command "[System.Environment]::GetEnvironmentVariable('Path', 'Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path', 'User')"`;
+                const newPath = (0, child_process_1.execSync)(pathCmd, { encoding: 'utf8' }).trim();
+                if (newPath) {
+                    process.env.PATH = newPath;
+                }
+            }
+            else if (process.platform === 'darwin') {
+                // On macOS, try to refresh PATH
+                try {
+                    const newPath = (0, child_process_1.execSync)('eval "$(launchctl getenv PATH)" && echo $PATH', {
+                        encoding: 'utf8',
+                        shell: '/bin/bash',
+                    }).trim();
+                    if (newPath) {
+                        process.env.PATH = newPath;
+                    }
+                }
+                catch {
+                    // Silent fail - macOS might not have launchctl env
+                }
+            }
+            else {
+                // On Linux, source bashrc and get PATH
+                try {
+                    const newPath = (0, child_process_1.execSync)('bash -ic "echo $PATH"', {
+                        encoding: 'utf8',
+                    }).trim();
+                    if (newPath) {
+                        process.env.PATH = newPath;
+                    }
+                }
+                catch {
+                    // Silent fail
+                }
+            }
+        }
+        catch (error) {
+            // Silent fail - if refresh doesn't work, tools check will handle it
+            this.log('Environment refresh attempt completed');
+        }
+    }
+    async deployConfig(path, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
+        this.verbose = verbose;
+        path = await this.getRootPath(path);
+        const spinner = ora('Checking deployment configuration...').start();
+        try {
+            spinner.text = 'Checking required tools...';
+            // Check all required tools
+            const toolsStatus = await this.checkRequiredTools();
+            spinner.stop();
+            // Display tools status
+            console.log(chalk.blue.bold('\n🔧 Required Tools Status:\n'));
+            const missingTools = [];
+            for (const [tool, status] of Object.entries(toolsStatus)) {
+                if (status.installed) {
+                    console.log(chalk.green(`  ✓ ${tool.padEnd(15)} ${status.version || 'installed'}`));
+                }
+                else {
+                    console.log(chalk.red(`  ✗ ${tool.padEnd(15)} not installed`));
+                    missingTools.push(tool);
+                }
+            }
+            // Handle missing tools
+            if (missingTools.length > 0) {
+                console.log(chalk.yellow('\n⚠️  Some required tools are missing.\n'));
+                const { installMissing } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'installMissing',
+                        message: 'Would you like help installing and configuring the missing tools?',
+                        default: true,
+                    },
+                ]);
+                if (installMissing) {
+                    await this.helpInstallTools(missingTools);
+                    // Refresh environment variables to pick up newly installed tools
+                    this.refreshEnvironmentPath();
+                    // Re-check tools after installation
+                    console.log(chalk.blue('\n🔄 Re-checking tools...\n'));
+                    const newToolsStatus = await this.checkRequiredTools();
+                    const stillMissing = Object.entries(newToolsStatus)
+                        .filter(([_, status]) => !status.installed)
+                        .map(([tool]) => tool);
+                    if (stillMissing.length > 0) {
+                        console.log(chalk.red('\n❌ The following tools are still not available:'));
+                        stillMissing.forEach((tool) => console.log(chalk.red(`  • ${tool}`)));
+                        console.log(chalk.yellow('\nPlease install them manually and run this command again.\n'));
+                        return;
+                    }
+                }
+                else {
+                    console.log(chalk.yellow('\n⚠️  Cannot proceed without required tools.'));
+                    console.log(chalk.blue('\nPlease install the following tools:\n'));
+                    missingTools.forEach((tool) => {
+                        console.log(chalk.white(`  ${tool}:`));
+                        this.printInstallInstructions(tool);
+                        console.log('');
+                    });
+                    return;
+                }
+            }
+            console.log(chalk.green('\n✓ All required tools are available!\n'));
+            // Start deployment configuration wizard
+            const config = await this.runDeploymentWizard();
+            if (!config) {
+                console.log(chalk.yellow('\nDeployment configuration cancelled.\n'));
+                return;
+            }
+            // Generate deployment files
+            spinner.start('Generating deployment configuration files...');
+            await this.generateDeploymentFiles(path, config);
+            spinner.succeed(chalk.green('Deployment configuration completed successfully!'));
+            // Display summary
+            this.displayDeploymentSummary(config);
+        }
+        catch (error) {
+            spinner.fail('Failed to configure deployment.');
+            console.error(chalk.red('Error configuring deployment:'), error);
+            throw error;
+        }
+        finally {
+            restoreWarnings();
+            spinner.stop();
+        }
+    }
+    async checkRequiredTools() {
+        const tools = {
+            kubectl: this.checkKubectl.bind(this),
+            doctl: this.checkDoctl.bind(this),
+            'gh cli': this.checkGhCli.bind(this),
+            helm: this.checkHelm.bind(this),
+        };
+        const results = {};
+        for (const [name, checkFn] of Object.entries(tools)) {
+            try {
+                const version = await checkFn();
+                results[name] = { installed: true, version };
+            }
+            catch {
+                results[name] = { installed: false };
+            }
+        }
+        return results;
+    }
+    async checkKubectl() {
+        const result = await this.runner.executeCommand(runner_service_1.ProgramName.KUBECTL, ['version', '--client'], {}, true);
+        // Extract version from output (works for both old and new kubectl versions)
+        const match = result.stdout.match(/Client Version: (v[\d.]+)|GitVersion:"(v[\d.]+)"/);
+        return match ? match[1] || match[2] : result.stdout.split('\n')[0].trim();
+    }
+    async checkDoctl() {
+        const result = await this.runner.executeCommand(runner_service_1.ProgramName.DOCTL, ['version'], {}, true);
+        return result.stdout.trim();
+    }
+    async checkGhCli() {
+        const result = await this.runner.executeCommand(runner_service_1.ProgramName.GH, ['--version'], {}, true);
+        const versionLine = result.stdout.split('\n')[0];
+        return versionLine.trim();
+    }
+    async checkHelm() {
+        const result = await this.runner.executeCommand(runner_service_1.ProgramName.HELM, ['version', '--short'], {}, true);
+        // Extract version (handles both --short and regular output)
+        const versionMatch = result.stdout.match(/v[\d.]+/);
+        return versionMatch ? versionMatch[0] : result.stdout.trim();
+    }
+    async checkPackageManager(manager) {
+        try {
+            if (manager === 'choco') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', 'choco --version'], {}, true);
+                return true;
+            }
+            else if (manager === 'winget') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', 'winget --version'], {}, true);
+                return true;
+            }
+            else if (manager === 'scoop') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', 'scoop --version'], {}, true);
+                return true;
+            }
+            else if (manager === 'brew') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.BREW, ['--version'], {}, true);
+                return true;
+            }
+            else if (manager === 'apt') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', 'apt --version'], {}, true);
+                return true;
+            }
+            else if (manager === 'snap') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', 'snap --version'], {}, true);
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getAvailablePackageManager() {
+        const platform = process.platform;
+        if (platform === 'win32') {
+            // Check for Chocolatey first (more reliable for dev tools)
+            if (await this.checkPackageManager('choco')) {
+                return 'choco';
+            }
+            // Then check for Scoop (developer-friendly, no admin required)
+            if (await this.checkPackageManager('scoop')) {
+                return 'scoop';
+            }
+            // Finally check for winget
+            if (await this.checkPackageManager('winget')) {
+                return 'winget';
+            }
+            return null;
+        }
+        else if (platform === 'darwin') {
+            if (await this.checkPackageManager('brew')) {
+                return 'brew';
+            }
+            return null;
+        }
+        else if (platform === 'linux') {
+            // Check for apt first (most common on Ubuntu/Debian)
+            if (await this.checkPackageManager('apt')) {
+                return 'apt';
+            }
+            // Then check for snap (universal package manager)
+            if (await this.checkPackageManager('snap')) {
+                return 'snap';
+            }
+            return null;
+        }
+        return null;
+    }
+    async installChocolatey() {
+        console.log(chalk.blue('\n📦 Installing Chocolatey...\n'));
+        try {
+            // Install Chocolatey using the official installation script
+            await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, [
+                '-NoProfile',
+                '-ExecutionPolicy',
+                'Bypass',
+                '-Command',
+                "Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))",
+            ], {}, false);
+            console.log(chalk.green('\n✓ Chocolatey installed successfully!\n'));
+            return true;
+        }
+        catch (error) {
+            console.log(chalk.red('\n✗ Failed to install Chocolatey.\n'));
+            console.log(chalk.yellow('Please install it manually from: https://chocolatey.org/install\n'));
+            return false;
+        }
+    }
+    async helpInstallTools(missingTools) {
+        console.log(chalk.blue('\n📦 Installing and configuring tools...\n'));
+        // Check for available package manager
+        let packageManager = await this.getAvailablePackageManager();
+        // If on Windows and no package manager found, offer to install Chocolatey
+        if (process.platform === 'win32' && !packageManager) {
+            console.log(chalk.yellow('⚠️  No package manager detected (Chocolatey or winget).\n'));
+            const { installChoco } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'installChoco',
+                    message: 'Would you like to install Chocolatey to manage package installations?',
+                    default: true,
+                },
+            ]);
+            if (installChoco) {
+                const success = await this.installChocolatey();
+                if (success) {
+                    packageManager = 'choco';
+                }
+                else {
+                    console.log(chalk.yellow('\nCannot proceed with automatic installation without a package manager.\n'));
+                    console.log(chalk.blue('Please install tools manually:\n'));
+                    for (const tool of missingTools) {
+                        console.log(chalk.white(`  ${tool}:`));
+                        this.printInstallInstructions(tool);
+                        console.log('');
+                    }
+                    return;
+                }
+            }
+            else {
+                console.log(chalk.yellow('\nCannot proceed with automatic installation without a package manager.\n'));
+                console.log(chalk.blue('Please install tools manually:\n'));
+                for (const tool of missingTools) {
+                    console.log(chalk.white(`  ${tool}:`));
+                    this.printInstallInstructions(tool);
+                    console.log('');
+                }
+                return;
+            }
+        }
+        if (packageManager) {
+            console.log(chalk.gray(`Using package manager: ${chalk.cyan(packageManager)}\n`));
+        }
+        for (const tool of missingTools) {
+            const { installNow } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'installNow',
+                    message: `Install ${tool} now?`,
+                    default: true,
+                },
+            ]);
+            if (installNow) {
+                try {
+                    await this.installTool(tool, packageManager);
+                    console.log(chalk.green(`\n✓ ${tool} installed successfully!\n`));
+                }
+                catch (error) {
+                    console.log(chalk.yellow(`\n⚠️  Could not install ${tool} automatically.`));
+                    console.log(chalk.blue('\nPlease install it manually:\n'));
+                    this.printInstallInstructions(tool);
+                    console.log('');
+                }
+            }
+            else {
+                console.log(chalk.blue(`\nTo install ${tool} manually:\n`));
+                this.printInstallInstructions(tool);
+                console.log('');
+            }
+        }
+    }
+    async installTool(tool, packageManager) {
+        const platform = process.platform;
+        // Package names mapping for different package managers
+        const packageNames = {
+            kubectl: {
+                choco: 'kubernetes-cli',
+                winget: 'Kubernetes.kubectl',
+                scoop: 'kubectl',
+                brew: 'kubectl',
+                apt: 'kubectl',
+                snap: 'kubectl',
+            },
+            doctl: {
+                choco: 'doctl',
+                winget: 'DigitalOcean.Doctl',
+                scoop: 'doctl',
+                brew: 'doctl',
+                apt: 'doctl',
+                snap: 'doctl',
+            },
+            'gh cli': {
+                choco: 'gh',
+                winget: 'GitHub.cli',
+                scoop: 'gh',
+                brew: 'gh',
+                apt: 'gh',
+                snap: 'gh',
+            },
+            helm: {
+                choco: 'kubernetes-helm',
+                winget: 'Helm.Helm',
+                scoop: 'helm',
+                brew: 'helm',
+                apt: 'helm',
+                snap: 'helm',
+            },
+        };
+        const packageName = packageNames[tool]?.[packageManager];
+        if (!packageName) {
+            throw new Error(`Unknown tool: ${tool} for package manager: ${packageManager}`);
+        }
+        if (platform === 'win32') {
+            if (packageManager === 'choco') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', `choco install ${packageName} -y`], {}, false);
+            }
+            else if (packageManager === 'winget') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, [
+                    '-Command',
+                    `winget install --id ${packageName} --silent --accept-package-agreements --accept-source-agreements`,
+                ], {}, false);
+            }
+            else if (packageManager === 'scoop') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', `scoop install ${packageName}`], {}, false);
+            }
+            else {
+                throw new Error(`Unsupported package manager: ${packageManager}`);
+            }
+        }
+        else if (platform === 'darwin') {
+            if (packageManager === 'brew') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.BREW, ['install', packageName], {}, false);
+            }
+            else {
+                throw new Error(`Unsupported package manager for macOS: ${packageManager}`);
+            }
+        }
+        else if (platform === 'linux') {
+            if (packageManager === 'apt') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', `sudo apt update && sudo apt install -y ${packageName}`], {}, false);
+            }
+            else if (packageManager === 'snap') {
+                await this.runner.executeCommand(runner_service_1.ProgramName.POWERSHELL, ['-Command', `sudo snap install ${packageName} --classic`], {}, false);
+            }
+            else {
+                throw new Error(`Unsupported package manager for Linux: ${packageManager}`);
+            }
+        }
+        else {
+            throw new Error('Automatic installation not supported on this platform');
+        }
+    }
+    printInstallInstructions(tool) {
+        const platform = process.platform;
+        switch (tool) {
+            case 'kubectl':
+                console.log(chalk.gray('  Windows (Chocolatey): choco install kubernetes-cli'));
+                console.log(chalk.gray('  Windows (Scoop):      scoop install kubectl'));
+                console.log(chalk.gray('  Windows (winget):     winget install Kubernetes.kubectl'));
+                console.log(chalk.gray('  macOS (Homebrew):     brew install kubectl'));
+                console.log(chalk.gray('  Linux (apt):          sudo apt install kubectl'));
+                console.log(chalk.gray('  Linux (snap):         sudo snap install kubectl --classic'));
+                break;
+            case 'doctl':
+                console.log(chalk.gray('  Windows (Chocolatey): choco install doctl'));
+                console.log(chalk.gray('  Windows (Scoop):      scoop install doctl'));
+                console.log(chalk.gray('  Windows (winget):     winget install DigitalOcean.Doctl'));
+                console.log(chalk.gray('  macOS (Homebrew):     brew install doctl'));
+                console.log(chalk.gray('  Linux (snap):         sudo snap install doctl'));
+                console.log(chalk.gray('  Linux (manual):       https://docs.digitalocean.com/reference/doctl/how-to/install/'));
+                break;
+            case 'gh cli':
+                console.log(chalk.gray('  Windows (Chocolatey): choco install gh'));
+                console.log(chalk.gray('  Windows (Scoop):      scoop install gh'));
+                console.log(chalk.gray('  Windows (winget):     winget install GitHub.cli'));
+                console.log(chalk.gray('  macOS (Homebrew):     brew install gh'));
+                console.log(chalk.gray('  Linux (apt):          sudo apt install gh'));
+                console.log(chalk.gray('  Linux (snap):         sudo snap install gh'));
+                break;
+            case 'helm':
+                console.log(chalk.gray('  Windows (Chocolatey): choco install kubernetes-helm'));
+                console.log(chalk.gray('  Windows (Scoop):      scoop install helm'));
+                console.log(chalk.gray('  Windows (winget):     winget install Helm.Helm'));
+                console.log(chalk.gray('  macOS (Homebrew):     brew install helm'));
+                console.log(chalk.gray('  Linux (snap):         sudo snap install helm --classic'));
+                console.log(chalk.gray('  Linux (manual):       https://helm.sh/docs/intro/install/'));
+                break;
+        }
+    }
+    async getGitRepoName(path) {
+        try {
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['config', '--get', 'remote.origin.url'], { cwd: path }, true);
+            const url = result.stdout.trim();
+            // Extract repo name from git URL
+            const match = url.match(/\/([^\/]+?)(\.git)?$/);
+            return match ? match[1] : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getCurrentKubeContext() {
+        try {
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.KUBECTL, ['config', 'current-context'], {}, true);
+            return result.stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    async getKubeNamespaces() {
+        try {
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.KUBECTL, ['get', 'namespaces', '-o', 'jsonpath={.items[*].metadata.name}'], {}, true);
+            return result.stdout
+                .trim()
+                .split(/\s+/)
+                .filter((n) => n.length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    async getKubeClusters() {
+        try {
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.KUBECTL, ['config', 'get-clusters'], {}, true);
+            return result.stdout
+                .trim()
+                .split('\n')
+                .slice(1) // Skip header
+                .filter((c) => c.length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    async runDeploymentWizard() {
+        console.log(chalk.blue.bold('\n🚀 Deployment Configuration Wizard\n'));
+        console.log(chalk.gray('This wizard will help you set up CI/CD for your project.\n'));
+        // Gather context information
+        const spinner = ora('Gathering environment information...').start();
+        const gitRepoName = await this.getGitRepoName(process.cwd());
+        const currentDir = pathModule.basename(process.cwd());
+        const defaultAppName = gitRepoName || currentDir;
+        const currentContext = await this.getCurrentKubeContext();
+        const availableNamespaces = await this.getKubeNamespaces();
+        const availableClusters = await this.getKubeClusters();
+        spinner.stop();
+        if (currentContext) {
+            console.log(chalk.gray(`Current kubectl context: ${chalk.cyan(currentContext)}\n`));
+        }
+        if (availableNamespaces.length > 0) {
+            console.log(chalk.gray(`Available namespaces: ${chalk.cyan(availableNamespaces.join(', '))}\n`));
+        }
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'provider',
+                message: 'Select your Kubernetes provider:',
+                choices: [
+                    { name: 'Digital Ocean Kubernetes', value: 'digitalocean' },
+                    { name: 'Other (Coming soon)', value: 'other', disabled: true },
+                ],
+                default: 'digitalocean',
+            },
+            {
+                type: 'list',
+                name: 'cicd',
+                message: 'Select your CI/CD platform:',
+                choices: [
+                    { name: 'GitHub Actions', value: 'github-actions' },
+                    { name: 'Other (Coming soon)', value: 'other', disabled: true },
+                ],
+                default: 'github-actions',
+            },
+            {
+                type: 'list',
+                name: 'clusterSelection',
+                message: 'How would you like to specify your cluster?',
+                choices: availableClusters.length > 0
+                    ? [
+                        { name: 'Use current context', value: 'current' },
+                        { name: 'Select from available clusters', value: 'select' },
+                        { name: 'Enter cluster name manually', value: 'manual' },
+                    ]
+                    : [{ name: 'Enter cluster name manually', value: 'manual' }],
+                default: availableClusters.length > 0 ? 'current' : 'manual',
+                when: () => availableClusters.length > 0 || !currentContext,
+            },
+            {
+                type: 'list',
+                name: 'clusterName',
+                message: 'Select your Kubernetes cluster:',
+                choices: availableClusters,
+                when: (answers) => answers.clusterSelection === 'select',
+            },
+            {
+                type: 'input',
+                name: 'clusterName',
+                message: 'Enter your Kubernetes cluster name:',
+                validate: (input) => input.length > 0 || 'Cluster name is required',
+                when: (answers) => answers.clusterSelection === 'manual',
+            },
+            {
+                type: 'list',
+                name: 'namespaceSelection',
+                message: 'How would you like to configure the namespace?',
+                choices: availableNamespaces.length > 0
+                    ? [
+                        { name: 'Use existing namespace', value: 'existing' },
+                        { name: 'Create new namespace', value: 'new' },
+                    ]
+                    : [{ name: 'Create new namespace', value: 'new' }],
+                default: availableNamespaces.length > 0 ? 'existing' : 'new',
+            },
+            {
+                type: 'list',
+                name: 'namespace',
+                message: 'Select an existing namespace:',
+                choices: availableNamespaces,
+                default: availableNamespaces.includes('production')
+                    ? 'production'
+                    : availableNamespaces[0],
+                when: (answers) => answers.namespaceSelection === 'existing' &&
+                    availableNamespaces.length > 0,
+            },
+            {
+                type: 'input',
+                name: 'namespace',
+                message: 'Enter the new namespace name:',
+                default: 'production',
+                validate: (input) => {
+                    if (input.length === 0)
+                        return 'Namespace name is required';
+                    if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(input)) {
+                        return 'Namespace must be lowercase alphanumeric and may contain hyphens';
+                    }
+                    return true;
+                },
+                when: (answers) => answers.namespaceSelection === 'new',
+            },
+            {
+                type: 'input',
+                name: 'appName',
+                message: 'Enter your application name:',
+                default: defaultAppName,
+                validate: (input) => {
+                    if (input.length === 0)
+                        return 'Application name is required';
+                    if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(input)) {
+                        return 'Application name must be lowercase alphanumeric and may contain hyphens';
+                    }
+                    return true;
+                },
+            },
+            {
+                type: 'input',
+                name: 'containerRegistry',
+                message: 'Enter your container registry:',
+                default: (answers) => `registry.digitalocean.com/${answers.appName}`,
+                validate: (input) => input.length > 0 || 'Container registry is required',
+            },
+            {
+                type: 'input',
+                name: 'domain',
+                message: 'Enter your domain (optional, press Enter to skip):',
+            },
+            {
+                type: 'checkbox',
+                name: 'apps',
+                message: 'Select which apps to deploy:',
+                choices: [
+                    { name: 'API (Backend)', value: 'api', checked: true },
+                    { name: 'Admin (Frontend)', value: 'admin', checked: true },
+                ],
+            },
+            {
+                type: 'confirm',
+                name: 'setupIngress',
+                message: 'Would you like to set up Ingress for external access?',
+                default: true,
+                when: (answers) => answers.domain && answers.domain.length > 0,
+            },
+            {
+                type: 'confirm',
+                name: 'setupSSL',
+                message: 'Would you like to set up SSL/TLS with cert-manager?',
+                default: true,
+                when: (answers) => answers.setupIngress,
+            },
+            {
+                type: 'input',
+                name: 'email',
+                message: 'Enter your email for SSL certificate notifications:',
+                validate: (input) => {
+                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                    return emailRegex.test(input) || 'Please enter a valid email address';
+                },
+                when: (answers) => answers.setupSSL,
+            },
+            {
+                type: 'confirm',
+                name: 'confirmGeneration',
+                message: 'Generate deployment configuration files now?',
+                default: true,
+            },
+        ]);
+        if (!answers.confirmGeneration) {
+            return null;
+        }
+        // Set cluster name from current context if using current
+        if (answers.clusterSelection === 'current' && currentContext) {
+            // Extract cluster name from context (format may vary)
+            answers.clusterName = currentContext;
+        }
+        // Store if namespace needs to be created
+        const createNamespace = answers.namespaceSelection === 'new';
+        return {
+            ...answers,
+            createNamespace,
+        };
+    }
+    async generateDeploymentFiles(path, config) {
+        // Create .github/workflows directory
+        const workflowsDir = pathModule.join(path, '.github', 'workflows');
+        await (0, promises_1.mkdir)(workflowsDir, { recursive: true });
+        // Create k8s directory
+        const k8sDir = pathModule.join(path, 'k8s');
+        await (0, promises_1.mkdir)(k8sDir, { recursive: true });
+        // Generate Dockerfiles and .dockerignore for each app
+        for (const app of config.apps) {
+            await this.generateDockerfile(path, app, config);
+        }
+        // Generate .dockerignore in root
+        await this.generateDockerignore(path);
+        // Generate GitHub Actions workflow
+        await this.generateGitHubActionsWorkflow(workflowsDir, config);
+        // Generate Kubernetes manifests for each app
+        for (const app of config.apps) {
+            await this.generateKubernetesManifests(k8sDir, app, config);
+        }
+        // Generate Ingress if requested
+        if (config.setupIngress) {
+            await this.generateIngressManifest(k8sDir, config);
+        }
+        // Generate cert-manager ClusterIssuer if SSL is requested
+        if (config.setupSSL) {
+            await this.generateCertManagerIssuer(k8sDir, config);
+        }
+        // Generate Helm chart configuration (optional)
+        await this.generateHelmChart(path, config);
+        // Generate README with deployment instructions
+        await this.generateDeploymentReadme(path, config);
+    }
+    async generateDockerfile(path, app, config) {
+        const templatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', `${app}.Dockerfile.ejs`);
+        const dockerfilePath = pathModule.join(path, 'apps', app, 'Dockerfile');
+        // Check if Dockerfile already exists
+        if ((0, fs_1.existsSync)(dockerfilePath)) {
+            this.log(chalk.yellow(`Dockerfile already exists for ${app}, skipping...`));
+            return;
+        }
+        try {
+            const templateContent = await (0, promises_1.readFile)(templatePath, 'utf8');
+            const renderedContent = await (0, ejs_1.render)(templateContent, { config, app });
+            await (0, promises_1.writeFile)(dockerfilePath, renderedContent, 'utf8');
+            this.log(chalk.green(`Created Dockerfile for ${app}`));
+        }
+        catch (error) {
+            this.log(chalk.yellow(`Could not create Dockerfile from template for ${app}, creating basic version...`));
+            // Create a basic Dockerfile if template doesn't exist
+            const basicDockerfile = this.generateBasicDockerfile(app);
+            await (0, promises_1.writeFile)(dockerfilePath, basicDockerfile, 'utf8');
+            this.log(chalk.green(`Created basic Dockerfile for ${app}`));
+        }
+    }
+    generateBasicDockerfile(app) {
+        if (app === 'api') {
+            return `# Dockerfile for API
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package.json pnpm-lock.yaml ./
+COPY apps/api/package.json ./apps/api/
+RUN npm install -g pnpm
+RUN pnpm install --frozen-lockfile
+COPY . .
+RUN pnpm --filter api build
+
+FROM node:18-alpine
+WORKDIR /app
+COPY package.json pnpm-lock.yaml ./
+COPY apps/api/package.json ./apps/api/
+RUN npm install -g pnpm
+RUN pnpm install --frozen-lockfile --prod
+COPY --from=builder /app/apps/api/dist ./apps/api/dist
+ENV NODE_ENV=production
+ENV PORT=3000
+EXPOSE 3000
+CMD ["node", "apps/api/dist/main.js"]
+`;
+        }
+        else if (app === 'admin') {
+            return `# Dockerfile for Admin
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package.json pnpm-lock.yaml ./
+COPY apps/admin/package.json ./apps/admin/
+RUN npm install -g pnpm
+RUN pnpm install --frozen-lockfile
+COPY . .
+RUN pnpm --filter admin build
+
+FROM node:18-alpine
+WORKDIR /app
+RUN npm install -g pnpm
+COPY --from=builder /app/apps/admin/.next ./apps/admin/.next
+COPY --from=builder /app/apps/admin/public ./apps/admin/public
+COPY --from=builder /app/apps/admin/package.json ./apps/admin/
+COPY --from=builder /app/apps/admin/node_modules ./apps/admin/node_modules
+ENV NODE_ENV=production
+ENV PORT=80
+EXPOSE 80
+WORKDIR /app/apps/admin
+CMD ["pnpm", "start"]
+`;
+        }
+        return `# Dockerfile for ${app}
+FROM node:18-alpine
+WORKDIR /app
+COPY . .
+RUN npm install -g pnpm
+RUN pnpm install --frozen-lockfile
+RUN pnpm build
+EXPOSE 3000
+CMD ["pnpm", "start"]
+`;
+    }
+    async generateDockerignore(path) {
+        const dockerignorePath = pathModule.join(path, '.dockerignore');
+        // Check if .dockerignore already exists
+        if ((0, fs_1.existsSync)(dockerignorePath)) {
+            this.log(chalk.yellow('.dockerignore already exists, skipping...'));
+            return;
+        }
+        const templatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', '.dockerignore.ejs');
+        try {
+            const templateContent = await (0, promises_1.readFile)(templatePath, 'utf8');
+            await (0, promises_1.writeFile)(dockerignorePath, templateContent, 'utf8');
+            this.log(chalk.green('Created .dockerignore'));
+        }
+        catch (error) {
+            // Create basic .dockerignore if template doesn't exist
+            const basicDockerignore = `node_modules
+dist
+build
+.next
+.env
+.env.local
+.git
+.github
+k8s
+helm
+*.md
+test
+tests
+coverage
+.vscode
+.idea
+*.log
+tmp
+temp
+`;
+            await (0, promises_1.writeFile)(dockerignorePath, basicDockerignore, 'utf8');
+            this.log(chalk.green('Created basic .dockerignore'));
+        }
+    }
+    async generateGitHubActionsWorkflow(dir, config) {
+        const workflowContent = `name: Deploy to Kubernetes
+
+onon:
+  push:
+    branches:
+      - main
+      - production
+  workflow_dispatch:
+
+env:
+  REGISTRY: ${config.containerRegistry}
+  CLUSTER_NAME: ${config.clusterName}
+  NAMESPACE: ${config.namespace}
+
+jobs:
+${config.apps
+            .map((app) => `  deploy-${app}:
+    name: Deploy ${app.toUpperCase()}
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      
+      - name: Install doctl
+        uses: digitalocean/action-doctl@v2
+        with:
+          token: \${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}
+      
+      - name: Log in to Container Registry
+        run: doctl registry login
+      
+      - name: Build and push Docker image
+        run: |
+          docker build -t \${{ env.REGISTRY }}/${config.appName}-${app}:\${{ github.sha }} \\
+            -f apps/${app}/Dockerfile .
+          docker push \${{ env.REGISTRY }}/${config.appName}-${app}:\${{ github.sha }}
+          docker tag \${{ env.REGISTRY }}/${config.appName}-${app}:\${{ github.sha }} \\
+            \${{ env.REGISTRY }}/${config.appName}-${app}:latest
+          docker push \${{ env.REGISTRY }}/${config.appName}-${app}:latest
+      
+      - name: Save DigitalOcean kubeconfig
+        run: doctl kubernetes cluster kubeconfig save \${{ env.CLUSTER_NAME }}
+      
+      - name: Deploy to Kubernetes
+        run: |
+          kubectl set image deployment/${config.appName}-${app} \\
+            ${config.appName}-${app}=\${{ env.REGISTRY }}/${config.appName}-${app}:\${{ github.sha }} \\
+            -n \${{ env.NAMESPACE }}
+          kubectl rollout status deployment/${config.appName}-${app} -n \${{ env.NAMESPACE }}
+`)
+            .join('\n')}
+`;
+        const workflowPath = pathModule.join(dir, 'deploy.yml');
+        await (0, promises_1.writeFile)(workflowPath, workflowContent, 'utf8');
+        this.log(chalk.green(`Created GitHub Actions workflow: ${workflowPath}`));
+    }
+    async generateKubernetesManifests(dir, app, config) {
+        const appDir = pathModule.join(dir, app);
+        await (0, promises_1.mkdir)(appDir, { recursive: true });
+        // Generate Deployment
+        const deploymentContent = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${config.appName}-${app}
+  namespace: ${config.namespace}
+  labels:
+    app: ${config.appName}-${app}
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: ${config.appName}-${app}
+  template:
+    metadata:
+      labels:
+        app: ${config.appName}-${app}
+    spec:
+      containers:
+        - name: ${config.appName}-${app}
+          image: ${config.containerRegistry}/${config.appName}-${app}:latest
+          ports:
+            - containerPort: ${app === 'api' ? '3000' : '80'}
+          env:
+            - name: NODE_ENV
+              value: "production"
+          resources:
+            requests:
+              memory: "256Mi"
+              cpu: "100m"
+            limits:
+              memory: "512Mi"
+              cpu: "500m"
+          livenessProbe:
+            httpGet:
+              path: ${app === 'api' ? '/health' : '/'}
+              port: ${app === 'api' ? '3000' : '80'}
+            initialDelaySeconds: 30
+            periodSeconds: 10
+          readinessProbe:
+            httpGet:
+              path: ${app === 'api' ? '/health' : '/'}
+              port: ${app === 'api' ? '3000' : '80'}
+            initialDelaySeconds: 10
+            periodSeconds: 5
+`;
+        await (0, promises_1.writeFile)(pathModule.join(appDir, 'deployment.yaml'), deploymentContent, 'utf8');
+        // Generate Service
+        const serviceContent = `apiVersion: v1
+kind: Service
+metadata:
+  name: ${config.appName}-${app}
+  namespace: ${config.namespace}
+  labels:
+    app: ${config.appName}-${app}
+spec:
+  type: ClusterIP
+  ports:
+    - port: ${app === 'api' ? '3000' : '80'}
+      targetPort: ${app === 'api' ? '3000' : '80'}
+      protocol: TCP
+      name: http
+  selector:
+    app: ${config.appName}-${app}
+`;
+        await (0, promises_1.writeFile)(pathModule.join(appDir, 'service.yaml'), serviceContent, 'utf8');
+        this.log(chalk.green(`Created Kubernetes manifests for ${app}`));
+    }
+    async generateIngressManifest(dir, config) {
+        const ingressContent = `apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: ${config.appName}-ingress
+  namespace: ${config.namespace}
+  annotations:
+    kubernetes.io/ingress.class: "nginx"
+${config.setupSSL ? `    cert-manager.io/cluster-issuer: "letsencrypt-prod"` : ''}
+spec:
+${config.setupSSL
+            ? `  tls:
+    - hosts:
+        - ${config.domain}
+${config.apps.includes('api') ? `        - api.${config.domain}` : ''}
+      secretName: ${config.appName}-tls
+`
+            : ''}  rules:
+${config.apps.includes('admin')
+            ? `    - host: ${config.domain}
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: ${config.appName}-admin
+                port:
+                  number: 80
+`
+            : ''}${config.apps.includes('api')
+            ? `    - host: api.${config.domain}
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: ${config.appName}-api
+                port:
+                  number: 3000
+`
+            : ''}`;
+        await (0, promises_1.writeFile)(pathModule.join(dir, 'ingress.yaml'), ingressContent, 'utf8');
+        this.log(chalk.green('Created Ingress manifest'));
+    }
+    async generateCertManagerIssuer(dir, config) {
+        const issuerContent = `apiVersion: cert-manager.io/v1
+kind: ClusterIssuer
+metadata:
+  name: letsencrypt-prod
+spec:
+  acme:
+    server: https://acme-v02.api.letsencrypt.org/directory
+    email: ${config.email}
+    privateKeySecretRef:
+      name: letsencrypt-prod
+    solvers:
+      - http01:
+          ingress:
+            class: nginx
+`;
+        await (0, promises_1.writeFile)(pathModule.join(dir, 'cert-manager-issuer.yaml'), issuerContent, 'utf8');
+        this.log(chalk.green('Created cert-manager ClusterIssuer'));
+    }
+    async generateHelmChart(path, config) {
+        const helmDir = pathModule.join(path, 'helm', config.appName);
+        await (0, promises_1.mkdir)(helmDir, { recursive: true });
+        // Generate Chart.yaml
+        const chartContent = `apiVersion: v2
+name: ${config.appName}
+description: Helm chart for ${config.appName}
+type: application
+version: 1.0.0
+appVersion: "1.0.0"
+`;
+        await (0, promises_1.writeFile)(pathModule.join(helmDir, 'Chart.yaml'), chartContent, 'utf8');
+        // Generate values.yaml
+        const valuesContent = `# Default values for ${config.appName}
+namespace: ${config.namespace}
+
+registry: ${config.containerRegistry}
+
+apps:
+${config.apps
+            .map((app) => `  ${app}:
+    enabled: true
+    replicas: 2
+    image:
+      repository: \${{ .Values.registry }}/${config.appName}-${app}
+      tag: latest
+      pullPolicy: Always
+    service:
+      type: ClusterIP
+      port: ${app === 'api' ? '3000' : '80'}
+    resources:
+      requests:
+        memory: "256Mi"
+        cpu: "100m"
+      limits:
+        memory: "512Mi"
+        cpu: "500m"
+`)
+            .join('')}
+${config.setupIngress
+            ? `ingress:
+  enabled: true
+  className: nginx
+  annotations:
+${config.setupSSL ? `    cert-manager.io/cluster-issuer: letsencrypt-prod` : ''}
+  hosts:
+${config.apps.includes('admin')
+                ? `    - host: ${config.domain}
+      paths:
+        - path: /
+          pathType: Prefix
+          backend:
+            service:
+              name: ${config.appName}-admin
+              port:
+                number: 80
+`
+                : ''}${config.apps.includes('api')
+                ? `    - host: api.${config.domain}
+      paths:
+        - path: /
+          pathType: Prefix
+          backend:
+            service:
+              name: ${config.appName}-api
+              port:
+                number: 3000
+`
+                : ''}${config.setupSSL
+                ? `  tls:
+    - secretName: ${config.appName}-tls
+      hosts:
+        - ${config.domain}
+${config.apps.includes('api') ? `        - api.${config.domain}` : ''}`
+                : ''}`
+            : ''}
+`;
+        await (0, promises_1.writeFile)(pathModule.join(helmDir, 'values.yaml'), valuesContent, 'utf8');
+        this.log(chalk.green('Created Helm chart'));
+    }
+    async generateDeploymentReadme(path, config) {
+        const readmeContent = `# Deployment Guide
+
+This project is configured for deployment to **${config.provider === 'digitalocean' ? 'Digital Ocean Kubernetes' : config.provider}** using **${config.cicd === 'github-actions' ? 'GitHub Actions' : config.cicd}**.
+
+## Prerequisites
+
+Make sure you have the following tools installed:
+
+- \`kubectl\` - Kubernetes CLI
+- \`doctl\` - Digital Ocean CLI
+- \`gh\` - GitHub CLI
+- \`helm\` - Kubernetes package manager
+
+## Initial Setup
+
+### 1. Configure Digital Ocean
+
+\`\`\`bash
+# Authenticate with Digital Ocean
+doctl auth init
+
+# Get your cluster kubeconfig
+doctl kubernetes cluster kubeconfig save ${config.clusterName}
+\`\`\`
+
+${config.createNamespace
+            ? `### 2. Create Kubernetes Namespace
+
+\`\`\`bash
+kubectl create namespace ${config.namespace}
+\`\`\`
+
+`
+            : `### 2. Verify Namespace
+
+\`\`\`bash
+# Verify the namespace exists
+kubectl get namespace ${config.namespace}
+\`\`\`
+
+`}### 3. Configure GitHub Secrets
+
+Add the following secrets to your GitHub repository:
+
+1. \`DIGITALOCEAN_ACCESS_TOKEN\` - Your Digital Ocean API token
+
+\`\`\`bash
+# Get your DO token and add it to GitHub
+gh secret set DIGITALOCEAN_ACCESS_TOKEN
+\`\`\`
+
+${config.setupSSL
+            ? `### 4. Install cert-manager
+
+\`\`\`bash
+# Install cert-manager for SSL certificates
+kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.13.0/cert-manager.yaml
+
+# Wait for cert-manager to be ready
+kubectl wait --for=condition=ready pod -l app.kubernetes.io/instance=cert-manager -n cert-manager --timeout=300s
+
+# Apply the ClusterIssuer
+kubectl apply -f k8s/cert-manager-issuer.yaml
+\`\`\`
+`
+            : ''}${config.setupIngress
+            ? `### ${config.setupSSL ? '5' : '4'}. Install NGINX Ingress Controller
+
+\`\`\`bash
+# Install NGINX Ingress Controller
+helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
+helm repo update
+
+helm install nginx-ingress ingress-nginx/ingress-nginx \\
+  --namespace ingress-nginx \\
+  --create-namespace \\
+  --set controller.publishService.enabled=true
+
+# Wait for the load balancer IP
+kubectl get service nginx-ingress-ingress-nginx-controller -n ingress-nginx --watch
+\`\`\`
+
+**Important:** After the LoadBalancer gets an external IP, configure your DNS:
+
+${config.domain
+                ? `- Point \`${config.domain}\` to the LoadBalancer IP
+${config.apps.includes('api')
+                    ? `- Point \`api.${config.domain}\` to the LoadBalancer IP
+`
+                    : ''}`
+                : ''}
+`
+            : ''}
+## Deployment
+
+### Using GitHub Actions (Automatic)
+
+Push to the \`main\` or \`production\` branch:
+
+\`\`\`bash
+git add .
+git commit -m "Deploy to production"
+git push origin main
+\`\`\`
+
+The GitHub Actions workflow will automatically:
+1. Build Docker images
+2. Push to container registry
+3. Deploy to Kubernetes cluster
+
+### Manual Deployment
+
+#### Option 1: Using kubectl
+
+\`\`\`bash
+# Apply all manifests
+${config.apps.map((app) => `kubectl apply -f k8s/${app}/`).join('\n')}
+${config.setupIngress ? `kubectl apply -f k8s/ingress.yaml` : ''}
+\`\`\`
+
+#### Option 2: Using Helm
+
+\`\`\`bash
+# Install or upgrade the release
+helm upgrade --install ${config.appName} ./helm/${config.appName} \\
+  --namespace ${config.namespace} \\
+  --create-namespace
+\`\`\`
+
+## Monitoring
+
+### Check Deployment Status
+
+\`\`\`bash
+# Check pods
+kubectl get pods -n ${config.namespace}
+
+# Check deployments
+kubectl get deployments -n ${config.namespace}
+
+# Check services
+kubectl get services -n ${config.namespace}
+
+${config.setupIngress
+            ? `# Check ingress
+kubectl get ingress -n ${config.namespace}
+`
+            : ''}
+# View logs
+${config.apps.map((app) => `kubectl logs -f deployment/${config.appName}-${app} -n ${config.namespace}`).join('\n')}
+\`\`\`
+
+### Scaling
+
+\`\`\`bash
+# Scale a deployment
+${config.apps.map((app) => `kubectl scale deployment/${config.appName}-${app} --replicas=3 -n ${config.namespace}`).join('\n')}
+\`\`\`
+
+## Rollback
+
+\`\`\`bash
+# View rollout history
+${config.apps.map((app) => `kubectl rollout history deployment/${config.appName}-${app} -n ${config.namespace}`).join('\n')}
+
+# Rollback to previous version
+${config.apps.map((app) => `kubectl rollout undo deployment/${config.appName}-${app} -n ${config.namespace}`).join('\n')}
+\`\`\`
+
+## Troubleshooting
+
+### View Pod Events
+
+\`\`\`bash
+kubectl describe pod <pod-name> -n ${config.namespace}
+\`\`\`
+
+### View Cluster Events
+
+\`\`\`bash
+kubectl get events -n ${config.namespace} --sort-by='.lastTimestamp'
+\`\`\`
+
+### Access Pod Shell
+
+\`\`\`bash
+${config.apps.map((app) => `kubectl exec -it deployment/${config.appName}-${app} -n ${config.namespace} -- /bin/sh`).join('\n')}
+\`\`\`
+
+## URLs
+
+${config.domain
+            ? `- **Admin Panel:** https://${config.domain}
+${config.apps.includes('api')
+                ? `- **API:** https://api.${config.domain}
+`
+                : ''}`
+            : '- Configure your domain and update DNS records as described above\n'}
+
+## Further Reading
+
+- [Digital Ocean Kubernetes Documentation](https://docs.digitalocean.com/products/kubernetes/)
+- [GitHub Actions Documentation](https://docs.github.com/en/actions)
+- [Kubernetes Documentation](https://kubernetes.io/docs/home/)
+- [Helm Documentation](https://helm.sh/docs/)
+${config.setupSSL
+            ? `- [cert-manager Documentation](https://cert-manager.io/docs/)
+`
+            : ''}
+`;
+        await (0, promises_1.writeFile)(pathModule.join(path, 'DEPLOYMENT.md'), readmeContent, 'utf8');
+        this.log(chalk.green('Created DEPLOYMENT.md'));
+    }
+    displayDeploymentSummary(config) {
+        console.log(chalk.blue.bold('\n📋 Deployment Configuration Summary\n'));
+        console.log(chalk.white('Provider:          ') + chalk.cyan(config.provider));
+        console.log(chalk.white('CI/CD:             ') + chalk.cyan(config.cicd));
+        console.log(chalk.white('Cluster:           ') + chalk.cyan(config.clusterName));
+        console.log(chalk.white('Namespace:         ') +
+            chalk.cyan(config.namespace) +
+            chalk.gray(config.createNamespace ? ' (will be created)' : ' (existing)'));
+        console.log(chalk.white('App Name:          ') + chalk.cyan(config.appName));
+        console.log(chalk.white('Registry:          ') + chalk.cyan(config.containerRegistry));
+        if (config.domain) {
+            console.log(chalk.white('Domain:            ') + chalk.cyan(config.domain));
+        }
+        console.log(chalk.white('Apps:              ') + chalk.cyan(config.apps.join(', ')));
+        console.log(chalk.white('Ingress:           ') +
+            chalk.cyan(config.setupIngress ? 'Yes' : 'No'));
+        console.log(chalk.white('SSL/TLS:           ') +
+            chalk.cyan(config.setupSSL ? 'Yes' : 'No'));
+        console.log(chalk.green.bold('\n✓ Generated Files:\n'));
+        console.log(chalk.gray('  .dockerignore'));
+        config.apps.forEach((app) => {
+            console.log(chalk.gray(`  apps/${app}/Dockerfile`));
+        });
+        console.log(chalk.gray('  .github/workflows/deploy.yml'));
+        config.apps.forEach((app) => {
+            console.log(chalk.gray(`  k8s/${app}/deployment.yaml`));
+            console.log(chalk.gray(`  k8s/${app}/service.yaml`));
+        });
+        if (config.setupIngress) {
+            console.log(chalk.gray('  k8s/ingress.yaml'));
+        }
+        if (config.setupSSL) {
+            console.log(chalk.gray('  k8s/cert-manager-issuer.yaml'));
+        }
+        console.log(chalk.gray(`  helm/${config.appName}/Chart.yaml`));
+        console.log(chalk.gray(`  helm/${config.appName}/values.yaml`));
+        console.log(chalk.gray('  DEPLOYMENT.md'));
+        console.log(chalk.blue.bold('\n📖 Next Steps:\n'));
+        console.log(chalk.white('1. Review the generated files in your project'));
+        console.log(chalk.white('2. Read DEPLOYMENT.md for setup instructions'));
+        console.log(chalk.white('3. Configure GitHub secrets (see DEPLOYMENT.md)'));
+        console.log(chalk.white('4. Push to main branch to trigger deployment'));
+        console.log('');
+    }
     async syncPublish(path, verbose = false) {
         const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;