@hed-hog/cli 0.0.49 → 0.0.50

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

@@ -23,6 +23,7 @@ const promises_1 = require("fs/promises");
 const inquirer_1 = require("inquirer");
 const ora = require("ora");
 const pathModule = require("path");
+const yaml_1 = require("yaml");
 const to_pascal_case_1 = require("../../functions/to-pascal-case");
 const database_service_1 = require("../database/database.service");
 const hedhog_service_1 = require("../hedhog/hedhog.service");
@@ -160,7 +161,7 @@ let DeveloperService = class DeveloperService {
             }
             console.log(chalk.green('\n✓ All required tools are available!\n'));
             // Start deployment configuration wizard
-            const config = await this.runDeploymentWizard();
+            const config = await this.runDeploymentWizard(path);
             if (!config) {
                 console.log(chalk.yellow('\nDeployment configuration cancelled.\n'));
                 return;
@@ -547,17 +548,307 @@ let DeveloperService = class DeveloperService {
             return [];
         }
     }
-    async runDeploymentWizard() {
+    extractContainerPort(ports) {
+        for (const portEntry of ports || []) {
+            if (typeof portEntry === 'number' && portEntry > 0) {
+                return portEntry;
+            }
+            if (typeof portEntry === 'string') {
+                const segment = portEntry.includes(':')
+                    ? portEntry.split(':').pop() || ''
+                    : portEntry;
+                const normalized = segment.split('/')[0];
+                const parsed = Number.parseInt(normalized, 10);
+                if (Number.isInteger(parsed) && parsed > 0) {
+                    return parsed;
+                }
+            }
+            if (portEntry && typeof portEntry === 'object') {
+                const target = Number.parseInt(String(portEntry.target ?? ''), 10);
+                if (Number.isInteger(target) && target > 0) {
+                    return target;
+                }
+            }
+        }
+        return undefined;
+    }
+    getDefaultAppPort(app) {
+        if (app === 'api')
+            return 3000;
+        if (app === 'admin')
+            return 80;
+        return 80;
+    }
+    extractDockerfileExposedPort(dockerfileContent) {
+        const exposeRegex = /^\s*EXPOSE\s+([^\r\n#]+)$/gim;
+        let match;
+        while ((match = exposeRegex.exec(dockerfileContent)) !== null) {
+            const declaration = (match[1] || '').trim();
+            if (!declaration)
+                continue;
+            const tokens = declaration.split(/\s+/);
+            for (const token of tokens) {
+                const normalized = token.split('/')[0];
+                const parsed = Number.parseInt(normalized, 10);
+                if (Number.isInteger(parsed) && parsed > 0) {
+                    return parsed;
+                }
+            }
+        }
+        return undefined;
+    }
+    async getAppPortsFromDockerfiles(projectPath, apps) {
+        const appPorts = {};
+        for (const app of apps) {
+            const dockerfilePath = pathModule.join(projectPath, 'apps', app, 'Dockerfile');
+            if (!(0, fs_1.existsSync)(dockerfilePath)) {
+                appPorts[app] = this.getDefaultAppPort(app);
+                continue;
+            }
+            try {
+                const dockerfileContent = await (0, promises_1.readFile)(dockerfilePath, 'utf8');
+                appPorts[app] =
+                    this.extractDockerfileExposedPort(dockerfileContent) ||
+                        this.getDefaultAppPort(app);
+            }
+            catch {
+                appPorts[app] = this.getDefaultAppPort(app);
+            }
+        }
+        return appPorts;
+    }
+    async getDockerComposeServices(projectPath) {
+        const candidates = ['docker-compose.yaml', 'docker-compose.yml'];
+        for (const fileName of candidates) {
+            const filePath = pathModule.join(projectPath, fileName);
+            if (!(0, fs_1.existsSync)(filePath)) {
+                continue;
+            }
+            try {
+                const content = await (0, promises_1.readFile)(filePath, 'utf8');
+                const parsed = (0, yaml_1.parse)(content);
+                const servicesObject = parsed?.services;
+                if (!servicesObject || typeof servicesObject !== 'object') {
+                    return { fileName, services: [] };
+                }
+                const services = Object.entries(servicesObject)
+                    .map(([name, serviceConfig]) => {
+                    const image = typeof serviceConfig?.image === 'string'
+                        ? serviceConfig.image.trim()
+                        : '';
+                    if (!image) {
+                        return null;
+                    }
+                    const containerPort = this.extractContainerPort(Array.isArray(serviceConfig?.ports) ? serviceConfig.ports : []);
+                    return {
+                        name,
+                        image,
+                        containerPort,
+                    };
+                })
+                    .filter((service) => service != null);
+                return { fileName, services };
+            }
+            catch (error) {
+                this.log(chalk.yellow(`Could not parse ${fileName}. Skipping compose services detection.`));
+                return null;
+            }
+        }
+        return null;
+    }
+    async getAvailableApps(projectPath) {
+        const appsDir = pathModule.join(projectPath, 'apps');
+        const fallbackApps = ['api', 'admin'];
+        if (!(0, fs_1.existsSync)(appsDir)) {
+            return fallbackApps;
+        }
+        try {
+            const entries = await (0, promises_1.readdir)(appsDir, { withFileTypes: true });
+            const detectedApps = entries
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name)
+                .filter((name) => /^[a-z0-9][a-z0-9-]*$/i.test(name));
+            if (detectedApps.length === 0) {
+                return fallbackApps;
+            }
+            const preferred = ['api', 'admin'];
+            return [
+                ...preferred.filter((app) => detectedApps.includes(app)),
+                ...detectedApps
+                    .filter((app) => !preferred.includes(app))
+                    .sort((a, b) => a.localeCompare(b)),
+            ];
+        }
+        catch {
+            return fallbackApps;
+        }
+    }
+    async detectAppFramework(projectPath, app) {
+        const packageJsonPath = pathModule.join(projectPath, 'apps', app, 'package.json');
+        try {
+            if (!(0, fs_1.existsSync)(packageJsonPath)) {
+                if (app === 'api')
+                    return 'nestjs';
+                if (app === 'admin')
+                    return 'nextjs';
+                return 'node';
+            }
+            const content = await (0, promises_1.readFile)(packageJsonPath, 'utf8');
+            const pkg = JSON.parse(content);
+            const deps = {
+                ...(pkg?.dependencies || {}),
+                ...(pkg?.devDependencies || {}),
+            };
+            const scripts = pkg?.scripts || {};
+            const scriptText = Object.values(scripts).join(' ').toLowerCase();
+            if (deps.next)
+                return 'nextjs';
+            if (deps['@nestjs/core'] || deps['@nestjs/common'])
+                return 'nestjs';
+            if (deps['@angular/core'])
+                return 'angular';
+            if (deps.vite || scriptText.includes(' vite'))
+                return 'vitejs';
+            if (deps.vue)
+                return 'vue';
+            if (app === 'api')
+                return 'nestjs';
+            if (app === 'admin')
+                return 'nextjs';
+            return 'node';
+        }
+        catch {
+            if (app === 'api')
+                return 'nestjs';
+            if (app === 'admin')
+                return 'nextjs';
+            return 'node';
+        }
+    }
+    getInstallCommand() {
+        return [
+            'if [ -f pnpm-lock.yaml ]; then pnpm install --frozen-lockfile; ',
+            'elif [ -f yarn.lock ]; then yarn install --frozen-lockfile; ',
+            'elif [ -f package-lock.json ]; then npm ci; ',
+            'else npm install; fi',
+        ].join('');
+    }
+    getBuildCommand(app) {
+        return [
+            `if [ -f pnpm-lock.yaml ]; then pnpm --filter ${app} build; `,
+            `elif [ -f yarn.lock ]; then yarn workspace ${app} build; `,
+            `else npm run build --workspace=${app}; fi`,
+        ].join('');
+    }
+    getStartCommand(app) {
+        return [
+            `if [ -f pnpm-lock.yaml ]; then pnpm --filter ${app} start; `,
+            `elif [ -f yarn.lock ]; then yarn workspace ${app} start; `,
+            `else npm run start --workspace=${app}; fi`,
+        ].join('');
+    }
+    generateBasicAppDockerfile(app, framework) {
+        const installCmd = this.getInstallCommand();
+        const buildCmd = this.getBuildCommand(app);
+        const startCmd = this.getStartCommand(app);
+        if (framework === 'nestjs') {
+            return `FROM node:20-alpine AS builder
+WORKDIR /app
+RUN corepack enable
+COPY . .
+RUN ${installCmd}
+RUN ${buildCmd}
+
+FROM node:20-alpine
+WORKDIR /app
+RUN corepack enable
+COPY . .
+RUN ${installCmd}
+COPY --from=builder /app/apps/${app}/dist ./apps/${app}/dist
+ENV NODE_ENV=production
+ENV PORT=3000
+EXPOSE 3000
+CMD ["sh", "-c", "${startCmd}"]
+`;
+        }
+        if (framework === 'nextjs') {
+            return `FROM node:20-alpine AS builder
+WORKDIR /app
+RUN corepack enable
+COPY . .
+RUN ${installCmd}
+RUN ${buildCmd}
+
+FROM node:20-alpine
+WORKDIR /app
+RUN corepack enable
+COPY . .
+RUN ${installCmd}
+ENV NODE_ENV=production
+ENV PORT=3000
+EXPOSE 3000
+CMD ["sh", "-c", "${startCmd}"]
+`;
+        }
+        if (framework === 'vitejs' ||
+            framework === 'angular' ||
+            framework === 'vue') {
+            return `FROM node:20-alpine AS builder
+WORKDIR /app
+RUN corepack enable
+COPY . .
+RUN ${installCmd}
+RUN ${buildCmd}
+
+FROM node:20-alpine
+WORKDIR /app
+RUN npm install -g serve
+COPY --from=builder /app/apps/${app} ./apps/${app}
+COPY --from=builder /app/dist ./dist
+ENV NODE_ENV=production
+EXPOSE 80
+CMD ["sh", "-c", "DIR=apps/${app}/dist; [ -d dist/${app}/browser ] && DIR=dist/${app}/browser; [ -d dist/${app} ] && DIR=dist/${app}; serve -s $DIR -l 80"]
+`;
+        }
+        return `FROM node:20-alpine
+WORKDIR /app
+RUN corepack enable
+COPY . .
+RUN ${installCmd}
+RUN ${buildCmd}
+ENV NODE_ENV=production
+EXPOSE 3000
+CMD ["sh", "-c", "${startCmd}"]
+`;
+    }
+    async ensureAppDockerfiles(projectPath, apps) {
+        const createdFiles = [];
+        for (const app of apps) {
+            const dockerfilePath = pathModule.join(projectPath, 'apps', app, 'Dockerfile');
+            if ((0, fs_1.existsSync)(dockerfilePath)) {
+                continue;
+            }
+            const framework = await this.detectAppFramework(projectPath, app);
+            const dockerfile = this.generateBasicAppDockerfile(app, framework);
+            await (0, promises_1.writeFile)(dockerfilePath, dockerfile, 'utf8');
+            createdFiles.push(pathModule.join('apps', app, 'Dockerfile'));
+            this.log(chalk.green(`Created basic Dockerfile for app ${app} (detected: ${framework})`));
+        }
+        return createdFiles;
+    }
+    async runDeploymentWizard(path) {
         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 gitRepoName = await this.getGitRepoName(path);
+        const currentDir = pathModule.basename(path);
         const defaultAppName = gitRepoName || currentDir;
         const currentContext = await this.getCurrentKubeContext();
         const availableNamespaces = await this.getKubeNamespaces();
         const availableClusters = await this.getKubeClusters();
+        const composeData = await this.getDockerComposeServices(path);
+        const availableApps = await this.getAvailableApps(path);
         spinner.stop();
         if (currentContext) {
             console.log(chalk.gray(`Current kubectl context: ${chalk.cyan(currentContext)}\n`));
@@ -565,6 +856,14 @@ let DeveloperService = class DeveloperService {
         if (availableNamespaces.length > 0) {
             console.log(chalk.gray(`Available namespaces: ${chalk.cyan(availableNamespaces.join(', '))}\n`));
         }
+        if (composeData) {
+            if (composeData.services.length > 0) {
+                console.log(chalk.gray(`Detected services in ${composeData.fileName}: ${chalk.cyan(composeData.services.map((s) => s.name).join(', '))}\n`));
+            }
+            else {
+                console.log(chalk.gray(`Detected ${composeData.fileName}, but no image-based services were found.\n`));
+            }
+        }
         const answers = await inquirer_1.default.prompt([
             {
                 type: 'list',
@@ -586,6 +885,23 @@ let DeveloperService = class DeveloperService {
                 ],
                 default: 'github-actions',
             },
+            {
+                type: 'input',
+                name: 'deployBranch',
+                message: 'Which branch should trigger automatic deployment?',
+                default: 'production',
+                validate: (input) => {
+                    const branch = String(input || '').trim();
+                    if (!branch) {
+                        return 'Branch name is required';
+                    }
+                    if (/\s/.test(branch)) {
+                        return 'Branch name cannot contain spaces';
+                    }
+                    return true;
+                },
+                when: (answers) => answers.cicd === 'github-actions',
+            },
             {
                 type: 'list',
                 name: 'clusterSelection',
@@ -682,10 +998,27 @@ let DeveloperService = class DeveloperService {
                 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 },
-                ],
+                choices: availableApps.map((app) => ({
+                    name: app === 'api'
+                        ? 'API (Backend)'
+                        : app === 'admin'
+                            ? 'Admin (Frontend)'
+                            : `${app} (Detected app)`,
+                    value: app,
+                    checked: app === 'api' || app === 'admin',
+                })),
+                validate: (selected) => (selected || []).length > 0 || 'Select at least one app',
+            },
+            {
+                type: 'checkbox',
+                name: 'selectedInfraServices',
+                message: 'Select additional docker-compose services to provision via Helm charts:',
+                choices: (composeData?.services || []).map((service) => ({
+                    name: `${service.name} (${service.image})`,
+                    value: service.name,
+                    checked: true,
+                })),
+                when: () => (composeData?.services || []).length > 0,
             },
             {
                 type: 'confirm',
@@ -728,9 +1061,41 @@ let DeveloperService = class DeveloperService {
         }
         // Store if namespace needs to be created
         const createNamespace = answers.namespaceSelection === 'new';
+        const parseReplicaCount = (value) => {
+            const parsed = Number.parseInt(String(value), 10);
+            return Number.isInteger(parsed) && parsed > 0 ? parsed : 2;
+        };
+        const replicaAnswers = await inquirer_1.default.prompt((answers.apps || []).map((app) => ({
+            type: 'input',
+            name: `replicas_${app}`,
+            message: app === 'api'
+                ? 'How many replicas should API (Backend) have?'
+                : app === 'admin'
+                    ? 'How many replicas should Admin (Frontend) have?'
+                    : `How many replicas should ${app} have?`,
+            default: 2,
+            validate: (input) => {
+                const value = Number.parseInt(String(input), 10);
+                if (!Number.isInteger(value) || value < 1) {
+                    return 'Please enter a whole number greater than or equal to 1';
+                }
+                return true;
+            },
+        })));
+        const appReplicas = {};
+        (answers.apps || []).forEach((app) => {
+            appReplicas[app] = parseReplicaCount(replicaAnswers[`replicas_${app}`]);
+        });
+        const selectedInfraServices = new Set((answers.selectedInfraServices || []));
+        const infraServices = (composeData?.services || []).filter((service) => selectedInfraServices.has(service.name));
+        const appPorts = await this.getAppPortsFromDockerfiles(path, answers.apps || []);
         return {
             ...answers,
             createNamespace,
+            appReplicas,
+            appPorts,
+            infraServices,
+            composeFileName: composeData?.fileName,
         };
     }
     async generateDeploymentFiles(path, config) {
@@ -740,12 +1105,14 @@ let DeveloperService = class DeveloperService {
         // 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);
+        // Create basic app Dockerfiles when missing
+        const createdDockerfiles = await this.ensureAppDockerfiles(path, config.apps || []);
+        if (createdDockerfiles.length > 0) {
+            config.createdDockerfiles = createdDockerfiles;
+            config.appPorts = await this.getAppPortsFromDockerfiles(path, config.apps || []);
+        }
         // Generate GitHub Actions workflow
         await this.generateGitHubActionsWorkflow(workflowsDir, config);
         // Generate Kubernetes manifests for each app
@@ -760,93 +1127,62 @@ let DeveloperService = class DeveloperService {
         if (config.setupSSL) {
             await this.generateCertManagerIssuer(k8sDir, config);
         }
-        // Generate Helm chart configuration (optional)
-        await this.generateHelmChart(path, config);
+        // Generate optional Helm charts for detected docker-compose services
+        await this.generateComposeServiceHelmCharts(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;
-        }
+    getDefaultServicePort(serviceName) {
+        const name = serviceName.toLowerCase();
+        if (name.includes('postgres'))
+            return 5432;
+        if (name.includes('mysql'))
+            return 3306;
+        if (name.includes('redis'))
+            return 6379;
+        if (name.includes('rabbitmq'))
+            return 5672;
+        return 80;
+    }
+    normalizeYamlContent(content, fileLabel) {
         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}`));
+            const parsed = (0, yaml_1.parse)(content);
+            return (0, yaml_1.stringify)(parsed, { lineWidth: 0 });
         }
-        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}`));
+        catch {
+            this.log(chalk.yellow(`Could not normalize YAML for ${fileLabel}; using rendered content as-is.`));
+            return content;
         }
     }
-    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"]
-`;
+    async generateComposeServiceHelmCharts(path, config) {
+        const infraServices = (config.infraServices || []);
+        if (infraServices.length === 0) {
+            return;
         }
-        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"]
-`;
+        const servicesRoot = pathModule.join(path, 'helm', 'services');
+        await (0, promises_1.mkdir)(servicesRoot, { recursive: true });
+        for (const service of infraServices) {
+            const chartDir = pathModule.join(servicesRoot, service.name);
+            const templatesDir = pathModule.join(chartDir, 'templates');
+            await (0, promises_1.mkdir)(templatesDir, { recursive: true });
+            const servicePort = service.containerPort || this.getDefaultServicePort(service.name);
+            const chartTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'helm.service.chart.yaml.ejs');
+            const valuesTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'helm.service.values.yaml.ejs');
+            const deploymentTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'helm.service.deployment.yaml.ejs');
+            const serviceTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'helm.service.service.yaml.ejs');
+            const chartYaml = await (0, ejs_1.render)(await (0, promises_1.readFile)(chartTemplatePath, 'utf8'), {
+                config,
+                service,
+                servicePort,
+            });
+            const valuesYaml = await (0, ejs_1.render)(await (0, promises_1.readFile)(valuesTemplatePath, 'utf8'), { config, service, servicePort });
+            const deploymentTemplate = await (0, ejs_1.render)(await (0, promises_1.readFile)(deploymentTemplatePath, 'utf8'), { config, service, servicePort });
+            const serviceTemplate = await (0, ejs_1.render)(await (0, promises_1.readFile)(serviceTemplatePath, 'utf8'), { config, service, servicePort });
+            await (0, promises_1.writeFile)(pathModule.join(chartDir, 'Chart.yaml'), this.normalizeYamlContent(chartYaml, `helm/services/${service.name}/Chart.yaml`), 'utf8');
+            await (0, promises_1.writeFile)(pathModule.join(chartDir, 'values.yaml'), this.normalizeYamlContent(valuesYaml, `helm/services/${service.name}/values.yaml`), 'utf8');
+            await (0, promises_1.writeFile)(pathModule.join(templatesDir, 'deployment.yaml'), deploymentTemplate, 'utf8');
+            await (0, promises_1.writeFile)(pathModule.join(templatesDir, 'service.yaml'), serviceTemplate, 'utf8');
         }
-        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');
@@ -888,59 +1224,9 @@ temp
         }
     }
     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 templatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'workflow.deploy.yml.ejs');
+        const templateContent = await (0, promises_1.readFile)(templatePath, 'utf8');
+        const workflowContent = await (0, ejs_1.render)(templateContent, { config });
         const workflowPath = pathModule.join(dir, 'deploy.yml');
         await (0, promises_1.writeFile)(workflowPath, workflowContent, 'utf8');
         this.log(chalk.green(`Created GitHub Actions workflow: ${workflowPath}`));
@@ -948,430 +1234,34 @@ ${config.apps
     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');
+        const deploymentTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'k8s.deployment.yaml.ejs');
+        const deploymentTemplate = await (0, promises_1.readFile)(deploymentTemplatePath, 'utf8');
+        const deploymentContent = await (0, ejs_1.render)(deploymentTemplate, { config, app });
+        await (0, promises_1.writeFile)(pathModule.join(appDir, 'deployment.yaml'), this.normalizeYamlContent(deploymentContent, `k8s/${app}/deployment.yaml`), 'utf8');
+        const serviceTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'k8s.service.yaml.ejs');
+        const serviceTemplate = await (0, promises_1.readFile)(serviceTemplatePath, 'utf8');
+        const serviceContent = await (0, ejs_1.render)(serviceTemplate, { config, app });
+        await (0, promises_1.writeFile)(pathModule.join(appDir, 'service.yaml'), this.normalizeYamlContent(serviceContent, `k8s/${app}/service.yaml`), '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');
+        const templatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'k8s.ingress.yaml.ejs');
+        const templateContent = await (0, promises_1.readFile)(templatePath, 'utf8');
+        const ingressContent = await (0, ejs_1.render)(templateContent, { config });
+        await (0, promises_1.writeFile)(pathModule.join(dir, 'ingress.yaml'), this.normalizeYamlContent(ingressContent, 'k8s/ingress.yaml'), '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');
+        const templatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'k8s.cert-manager-issuer.yaml.ejs');
+        const templateContent = await (0, promises_1.readFile)(templatePath, 'utf8');
+        const issuerContent = await (0, ejs_1.render)(templateContent, { config });
+        await (0, promises_1.writeFile)(pathModule.join(dir, 'cert-manager-issuer.yaml'), this.normalizeYamlContent(issuerContent, 'k8s/cert-manager-issuer.yaml'), '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/)
-`
-            : ''}
-`;
+        const templatePath = pathModule.join(__dirname, '..', '..', 'templates', 'deployment', 'DEPLOYMENT.md.ejs');
+        const templateContent = await (0, promises_1.readFile)(templatePath, 'utf8');
+        const readmeContent = await (0, ejs_1.render)(templateContent, { config });
         await (0, promises_1.writeFile)(pathModule.join(path, 'DEPLOYMENT.md'), readmeContent, 'utf8');
         this.log(chalk.green('Created DEPLOYMENT.md'));
     }
@@ -1379,6 +1269,10 @@ ${config.setupSSL
         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));
+        if (config.cicd === 'github-actions') {
+            console.log(chalk.white('Deploy Branch:     ') +
+                chalk.cyan(config.deployBranch || 'production'));
+        }
         console.log(chalk.white('Cluster:           ') + chalk.cyan(config.clusterName));
         console.log(chalk.white('Namespace:         ') +
             chalk.cyan(config.namespace) +
@@ -1389,34 +1283,55 @@ ${config.setupSSL
             console.log(chalk.white('Domain:            ') + chalk.cyan(config.domain));
         }
         console.log(chalk.white('Apps:              ') + chalk.cyan(config.apps.join(', ')));
+        console.log(chalk.white('Replicas:          ') +
+            chalk.cyan(config.apps
+                .map((app) => `${app}: ${config.appReplicas?.[app] ?? 2}`)
+                .join(', ')));
+        console.log(chalk.white('Ports:             ') +
+            chalk.cyan(config.apps
+                .map((app) => `${app}: ${config.appPorts?.[app] ?? this.getDefaultAppPort(app)}`)
+                .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`));
         });
+        (config.createdDockerfiles || []).forEach((dockerfilePath) => {
+            console.log(chalk.gray(`  ${dockerfilePath}`));
+        });
         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`));
+        if ((config.infraServices || []).length > 0) {
+            config.infraServices.forEach((service) => {
+                console.log(chalk.gray(`  helm/services/${service.name}/Chart.yaml`));
+                console.log(chalk.gray(`  helm/services/${service.name}/values.yaml`));
+                console.log(chalk.gray(`  helm/services/${service.name}/templates/deployment.yaml`));
+                console.log(chalk.gray(`  helm/services/${service.name}/templates/service.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(chalk.white(`4. Push to ${config.deployBranch || 'production'} branch to trigger deployment`));
+        if ((config.infraServices || []).length > 0) {
+            console.log('');
+            console.log(chalk.blue.bold('ℹ Additional service charts were generated only (not applied):'));
+            config.infraServices.forEach((service) => {
+                console.log(chalk.white(`   helm upgrade --install ${service.name} ./helm/services/${service.name} --namespace ${config.namespace} --create-namespace`));
+            });
+        }
         console.log('');
     }
     async syncPublish(path, verbose = false) {