@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/generate-k8s.js

@@ -0,0 +1,1263 @@
+/**
+ * Generate Kubernetes Manifests Command
+ *
+ * Interactive wizard for generating K8s resources
+ *
+ * Usage: nimbus generate k8s [options]
+ */
+import { logger } from '../utils';
+import { createWizard, ui, select, multiSelect, confirm, input, pathInput, } from '../wizard';
+/**
+ * Run the generate k8s command
+ */
+export async function generateK8sCommand(options = {}) {
+    logger.info('Starting Kubernetes manifest generation wizard');
+    // Non-interactive mode
+    if (options.nonInteractive) {
+        await runNonInteractive(options);
+        return;
+    }
+    // Interactive wizard mode
+    const wizard = createWizard({
+        title: 'nimbus generate k8s',
+        description: 'Generate Kubernetes manifests for your application',
+        initialContext: {
+            workloadType: options.workloadType,
+            namespace: options.namespace,
+            name: options.name,
+            image: options.image,
+            replicas: options.replicas,
+            containerPort: options.port,
+            serviceType: options.serviceType,
+            outputPath: options.output,
+            includeIngress: options.includeIngress,
+            includeHpa: options.includeHpa,
+            includePdb: options.includePdb,
+            includeConfigMap: options.includeConfigMap,
+            includeSecret: options.includeSecret,
+            cpuRequest: options.cpuRequest,
+            cpuLimit: options.cpuLimit,
+            memoryRequest: options.memoryRequest,
+            memoryLimit: options.memoryLimit,
+        },
+        steps: createWizardSteps(),
+        onEvent: event => {
+            logger.debug('Wizard event', { type: event.type });
+        },
+    });
+    const result = await wizard.run();
+    if (result.success) {
+        ui.newLine();
+        ui.box({
+            title: 'Complete!',
+            content: [
+                'Your Kubernetes manifests have been generated.',
+                '',
+                'Generated files:',
+                ...(result.context.generatedFiles?.map(f => `  - ${f}`) || ['  - (manifests generated)']),
+                '',
+                'Next steps:',
+                `  1. Review the generated files in ${result.context.outputPath}`,
+                '  2. Customize values as needed for your environment',
+                '  3. Run "kubectl apply -f <path>" or "nimbus apply k8s <path>"',
+            ],
+            style: 'rounded',
+            borderColor: 'green',
+            padding: 1,
+        });
+    }
+    else {
+        ui.error(`Wizard failed: ${result.error?.message || 'Unknown error'}`);
+        process.exit(1);
+    }
+}
+/**
+ * Create wizard steps
+ */
+function createWizardSteps() {
+    return [
+        // Step 1: Workload Type Selection
+        {
+            id: 'workload-type',
+            title: 'Workload Type',
+            description: 'Select the type of Kubernetes workload to generate',
+            execute: workloadTypeStep,
+        },
+        // Step 2: Basic Configuration
+        {
+            id: 'basic-config',
+            title: 'Basic Configuration',
+            description: 'Configure name, namespace, and image',
+            execute: basicConfigStep,
+        },
+        // Step 3: Replica Configuration (not for DaemonSet or Job)
+        {
+            id: 'replicas',
+            title: 'Replica Configuration',
+            description: 'Configure replicas and scaling options',
+            condition: ctx => !['daemonset', 'job'].includes(ctx.workloadType || ''),
+            execute: replicaConfigStep,
+        },
+        // Step 4: Job/CronJob Configuration
+        {
+            id: 'job-config',
+            title: 'Job Configuration',
+            description: 'Configure job-specific settings',
+            condition: ctx => ['job', 'cronjob'].includes(ctx.workloadType || ''),
+            execute: jobConfigStep,
+        },
+        // Step 5: Port & Service Configuration
+        {
+            id: 'service-config',
+            title: 'Port & Service Configuration',
+            description: 'Configure container ports and service exposure',
+            execute: serviceConfigStep,
+        },
+        // Step 6: Resource Limits
+        {
+            id: 'resources',
+            title: 'Resource Limits',
+            description: 'Configure CPU and memory requests/limits',
+            execute: resourceLimitsStep,
+        },
+        // Step 7: Additional Resources
+        {
+            id: 'additional-resources',
+            title: 'Additional Resources',
+            description: 'Select additional Kubernetes resources to generate',
+            execute: additionalResourcesStep,
+        },
+        // Step 8: Health Checks
+        {
+            id: 'health-checks',
+            title: 'Health Checks',
+            description: 'Configure liveness and readiness probes',
+            condition: ctx => !['job', 'cronjob'].includes(ctx.workloadType || ''),
+            execute: healthChecksStep,
+        },
+        // Step 9: Output Configuration
+        {
+            id: 'output',
+            title: 'Output Configuration',
+            description: 'Configure where and how to save the manifests',
+            execute: outputConfigStep,
+        },
+        // Step 10: Generate
+        {
+            id: 'generate',
+            title: 'Generate Manifests',
+            description: 'Generating your Kubernetes manifests...',
+            execute: generateStep,
+        },
+    ];
+}
+/**
+ * Step 1: Workload Type Selection
+ */
+async function workloadTypeStep(ctx) {
+    const workloadType = await select({
+        message: 'Select workload type:',
+        options: [
+            {
+                value: 'deployment',
+                label: 'Deployment',
+                description: 'Stateless application with rolling updates (most common)',
+            },
+            {
+                value: 'statefulset',
+                label: 'StatefulSet',
+                description: 'Stateful application with stable network identity and storage',
+            },
+            {
+                value: 'daemonset',
+                label: 'DaemonSet',
+                description: 'Run a pod on every node (e.g., monitoring agents)',
+            },
+            {
+                value: 'job',
+                label: 'Job',
+                description: 'Run a task to completion',
+            },
+            {
+                value: 'cronjob',
+                label: 'CronJob',
+                description: 'Run a job on a schedule',
+            },
+        ],
+        defaultValue: ctx.workloadType || 'deployment',
+    });
+    if (!workloadType) {
+        return { success: false, error: 'No workload type selected' };
+    }
+    return {
+        success: true,
+        data: { workloadType },
+    };
+}
+/**
+ * Step 2: Basic Configuration
+ */
+async function basicConfigStep(ctx) {
+    // Application name
+    const name = await input({
+        message: 'Application name:',
+        defaultValue: ctx.name || 'my-app',
+        validate: value => {
+            if (!value) {
+                return 'Name is required';
+            }
+            if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(value)) {
+                return 'Name must be lowercase alphanumeric with dashes only';
+            }
+            return true;
+        },
+    });
+    if (!name) {
+        return { success: false, error: 'Name is required' };
+    }
+    // Namespace
+    ui.newLine();
+    const namespace = await input({
+        message: 'Namespace:',
+        defaultValue: ctx.namespace || 'default',
+        validate: value => {
+            if (!value) {
+                return 'Namespace is required';
+            }
+            if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(value)) {
+                return 'Namespace must be lowercase alphanumeric with dashes only';
+            }
+            return true;
+        },
+    });
+    if (!namespace) {
+        return { success: false, error: 'Namespace is required' };
+    }
+    // Container image
+    ui.newLine();
+    const image = await input({
+        message: 'Container image (e.g., nginx:latest, myregistry/myapp):',
+        defaultValue: ctx.image || '',
+        validate: value => {
+            if (!value) {
+                return 'Image is required';
+            }
+            return true;
+        },
+    });
+    if (!image) {
+        return { success: false, error: 'Image is required' };
+    }
+    // Parse image and tag
+    const imageParts = image.split(':');
+    const imageBase = imageParts[0];
+    const imageTag = imageParts[1] || 'latest';
+    return {
+        success: true,
+        data: {
+            name,
+            namespace,
+            image: imageBase,
+            imageTag,
+        },
+    };
+}
+/**
+ * Step 3: Replica Configuration
+ */
+async function replicaConfigStep(ctx) {
+    const replicas = await input({
+        message: 'Number of replicas:',
+        defaultValue: String(ctx.replicas || 2),
+        validate: value => {
+            const num = parseInt(value, 10);
+            if (isNaN(num) || num < 1) {
+                return 'Must be a positive number';
+            }
+            return true;
+        },
+    });
+    if (!replicas) {
+        return { success: false, error: 'Replicas required' };
+    }
+    // Ask about HPA
+    ui.newLine();
+    const includeHpa = ctx.includeHpa ??
+        (await confirm({
+            message: 'Include Horizontal Pod Autoscaler (HPA)?',
+            defaultValue: false,
+        }));
+    let minReplicas;
+    let maxReplicas;
+    let targetCPUUtilization;
+    if (includeHpa) {
+        ui.newLine();
+        const min = await input({
+            message: 'Minimum replicas:',
+            defaultValue: String(ctx.minReplicas || Math.max(1, parseInt(replicas, 10) - 1)),
+            validate: value => {
+                const num = parseInt(value, 10);
+                if (isNaN(num) || num < 1) {
+                    return 'Must be a positive number';
+                }
+                return true;
+            },
+        });
+        minReplicas = parseInt(min || '1', 10);
+        const max = await input({
+            message: 'Maximum replicas:',
+            defaultValue: String(ctx.maxReplicas || parseInt(replicas, 10) * 2),
+            validate: value => {
+                const num = parseInt(value, 10);
+                if (isNaN(num) || num < minReplicas) {
+                    return `Must be >= ${minReplicas}`;
+                }
+                return true;
+            },
+        });
+        maxReplicas = parseInt(max || '4', 10);
+        const cpu = await input({
+            message: 'Target CPU utilization (%):',
+            defaultValue: String(ctx.targetCPUUtilization || 70),
+            validate: value => {
+                const num = parseInt(value, 10);
+                if (isNaN(num) || num < 1 || num > 100) {
+                    return 'Must be between 1 and 100';
+                }
+                return true;
+            },
+        });
+        targetCPUUtilization = parseInt(cpu || '70', 10);
+    }
+    return {
+        success: true,
+        data: {
+            replicas: parseInt(replicas, 10),
+            includeHpa,
+            minReplicas,
+            maxReplicas,
+            targetCPUUtilization,
+        },
+    };
+}
+/**
+ * Step 4: Job/CronJob Configuration
+ */
+async function jobConfigStep(ctx) {
+    let schedule;
+    if (ctx.workloadType === 'cronjob') {
+        const scheduleInput = await input({
+            message: 'Cron schedule (e.g., "*/5 * * * *" for every 5 minutes):',
+            defaultValue: ctx.schedule || '0 * * * *',
+            validate: value => {
+                if (!value) {
+                    return 'Schedule is required for CronJob';
+                }
+                // Basic cron validation (5 fields)
+                const parts = value.trim().split(/\s+/);
+                if (parts.length !== 5) {
+                    return 'Schedule must have 5 fields (min hour day month weekday)';
+                }
+                return true;
+            },
+        });
+        schedule = scheduleInput;
+    }
+    // Backoff limit
+    ui.newLine();
+    const backoffInput = await input({
+        message: 'Backoff limit (retries on failure):',
+        defaultValue: String(ctx.backoffLimit || 6),
+        validate: value => {
+            const num = parseInt(value, 10);
+            if (isNaN(num) || num < 0) {
+                return 'Must be a non-negative number';
+            }
+            return true;
+        },
+    });
+    const backoffLimit = parseInt(backoffInput || '6', 10);
+    // Completions
+    ui.newLine();
+    const completionsInput = await input({
+        message: 'Number of completions (total successful pods):',
+        defaultValue: String(ctx.completions || 1),
+        validate: value => {
+            const num = parseInt(value, 10);
+            if (isNaN(num) || num < 1) {
+                return 'Must be a positive number';
+            }
+            return true;
+        },
+    });
+    const completions = parseInt(completionsInput || '1', 10);
+    // Parallelism
+    ui.newLine();
+    const parallelismInput = await input({
+        message: 'Parallelism (concurrent pods):',
+        defaultValue: String(ctx.parallelism || 1),
+        validate: value => {
+            const num = parseInt(value, 10);
+            if (isNaN(num) || num < 1) {
+                return 'Must be a positive number';
+            }
+            return true;
+        },
+    });
+    const parallelism = parseInt(parallelismInput || '1', 10);
+    return {
+        success: true,
+        data: {
+            schedule,
+            backoffLimit,
+            completions,
+            parallelism,
+        },
+    };
+}
+/**
+ * Step 5: Port & Service Configuration
+ */
+async function serviceConfigStep(ctx) {
+    // Container port
+    const portInput = await input({
+        message: 'Container port:',
+        defaultValue: String(ctx.containerPort || 8080),
+        validate: value => {
+            const num = parseInt(value, 10);
+            if (isNaN(num) || num < 1 || num > 65535) {
+                return 'Must be between 1 and 65535';
+            }
+            return true;
+        },
+    });
+    if (!portInput) {
+        return { success: false, error: 'Port is required' };
+    }
+    const containerPort = parseInt(portInput, 10);
+    // Service exposure (not for Jobs)
+    let includeService = false;
+    let serviceType = 'ClusterIP';
+    let servicePort = containerPort;
+    if (!['job', 'cronjob'].includes(ctx.workloadType || '')) {
+        ui.newLine();
+        includeService = await confirm({
+            message: 'Create a Service to expose this workload?',
+            defaultValue: true,
+        });
+        if (includeService) {
+            ui.newLine();
+            serviceType =
+                (await select({
+                    message: 'Service type:',
+                    options: [
+                        {
+                            value: 'ClusterIP',
+                            label: 'ClusterIP',
+                            description: 'Internal cluster access only (default)',
+                        },
+                        {
+                            value: 'NodePort',
+                            label: 'NodePort',
+                            description: "Expose on each node's IP at a static port",
+                        },
+                        {
+                            value: 'LoadBalancer',
+                            label: 'LoadBalancer',
+                            description: 'External load balancer (cloud provider)',
+                        },
+                    ],
+                    defaultValue: ctx.serviceType || 'ClusterIP',
+                })) || 'ClusterIP';
+            const servicePortInput = await input({
+                message: 'Service port:',
+                defaultValue: String(ctx.servicePort || containerPort),
+                validate: value => {
+                    const num = parseInt(value, 10);
+                    if (isNaN(num) || num < 1 || num > 65535) {
+                        return 'Must be between 1 and 65535';
+                    }
+                    return true;
+                },
+            });
+            servicePort = parseInt(servicePortInput || String(containerPort), 10);
+        }
+    }
+    return {
+        success: true,
+        data: {
+            containerPort,
+            includeService,
+            serviceType,
+            servicePort,
+        },
+    };
+}
+/**
+ * Step 6: Resource Limits
+ */
+async function resourceLimitsStep(ctx) {
+    const setLimits = await confirm({
+        message: 'Configure resource requests and limits? (recommended for production)',
+        defaultValue: true,
+    });
+    if (!setLimits) {
+        return { success: true, data: {} };
+    }
+    ui.newLine();
+    ui.info('Resource requests (guaranteed resources):');
+    const cpuRequest = await input({
+        message: 'CPU request (e.g., 100m, 0.5):',
+        defaultValue: ctx.cpuRequest || '100m',
+    });
+    const memoryRequest = await input({
+        message: 'Memory request (e.g., 128Mi, 1Gi):',
+        defaultValue: ctx.memoryRequest || '128Mi',
+    });
+    ui.newLine();
+    ui.info('Resource limits (maximum allowed):');
+    const cpuLimit = await input({
+        message: 'CPU limit (e.g., 500m, 1):',
+        defaultValue: ctx.cpuLimit || '500m',
+    });
+    const memoryLimit = await input({
+        message: 'Memory limit (e.g., 256Mi, 2Gi):',
+        defaultValue: ctx.memoryLimit || '256Mi',
+    });
+    return {
+        success: true,
+        data: {
+            cpuRequest,
+            cpuLimit,
+            memoryRequest,
+            memoryLimit,
+        },
+    };
+}
+/**
+ * Step 7: Additional Resources
+ */
+async function additionalResourcesStep(ctx) {
+    const resourceOptions = [
+        { value: 'configmap', label: 'ConfigMap', description: 'Environment configuration' },
+        { value: 'secret', label: 'Secret', description: 'Sensitive data (passwords, tokens)' },
+    ];
+    // Only show Ingress for services
+    if (ctx.includeService) {
+        resourceOptions.push({
+            value: 'ingress',
+            label: 'Ingress',
+            description: 'HTTP/HTTPS routing (requires ingress controller)',
+        });
+    }
+    // Only show PDB for Deployments/StatefulSets
+    if (['deployment', 'statefulset'].includes(ctx.workloadType || '')) {
+        resourceOptions.push({
+            value: 'pdb',
+            label: 'PodDisruptionBudget',
+            description: 'Ensure availability during disruptions',
+        });
+    }
+    const selectedResources = (await multiSelect({
+        message: 'Select additional resources to generate:',
+        options: resourceOptions,
+        required: false,
+    }));
+    const includeConfigMap = selectedResources.includes('configmap') || ctx.includeConfigMap;
+    const includeSecret = selectedResources.includes('secret') || ctx.includeSecret;
+    const includeIngress = selectedResources.includes('ingress') || ctx.includeIngress;
+    const includePdb = selectedResources.includes('pdb') || ctx.includePdb;
+    // Ingress configuration
+    let ingressHost;
+    let ingressPath;
+    let ingressTls = false;
+    if (includeIngress) {
+        ui.newLine();
+        ui.info('Ingress Configuration:');
+        ingressHost = await input({
+            message: 'Hostname (e.g., app.example.com):',
+            defaultValue: ctx.ingressHost || `${ctx.name}.example.com`,
+        });
+        ingressPath = await input({
+            message: 'Path:',
+            defaultValue: ctx.ingressPath || '/',
+        });
+        ingressTls = await confirm({
+            message: 'Enable TLS?',
+            defaultValue: ctx.ingressTls ?? true,
+        });
+    }
+    // PDB configuration
+    let minAvailable;
+    if (includePdb) {
+        ui.newLine();
+        const minAvailableInput = await input({
+            message: 'Minimum available pods (number or percentage like "50%"):',
+            defaultValue: String(ctx.minAvailable || 1),
+        });
+        minAvailable = minAvailableInput?.includes('%')
+            ? minAvailableInput
+            : parseInt(minAvailableInput || '1', 10);
+    }
+    return {
+        success: true,
+        data: {
+            includeConfigMap,
+            includeSecret,
+            includeIngress,
+            includePdb,
+            ingressHost,
+            ingressPath,
+            ingressTls,
+            minAvailable,
+        },
+    };
+}
+/**
+ * Step 8: Health Checks
+ */
+async function healthChecksStep(ctx) {
+    const includeProbes = await confirm({
+        message: 'Configure health check probes? (recommended for production)',
+        defaultValue: true,
+    });
+    if (!includeProbes) {
+        return { success: true, data: { includeProbes: false } };
+    }
+    ui.newLine();
+    const livenessPath = await input({
+        message: 'Liveness probe path (e.g., /healthz):',
+        defaultValue: ctx.livenessPath || '/healthz',
+    });
+    const readinessPath = await input({
+        message: 'Readiness probe path (e.g., /ready):',
+        defaultValue: ctx.readinessPath || '/ready',
+    });
+    return {
+        success: true,
+        data: {
+            includeProbes,
+            livenessPath,
+            readinessPath,
+        },
+    };
+}
+/**
+ * Step 9: Output Configuration
+ */
+async function outputConfigStep(ctx) {
+    const outputFormat = await select({
+        message: 'Output format:',
+        options: [
+            {
+                value: 'multiple',
+                label: 'Multiple files',
+                description: 'One file per resource (deployment.yaml, service.yaml, etc.)',
+            },
+            {
+                value: 'single',
+                label: 'Single file',
+                description: 'All resources in one file with document separators',
+            },
+            {
+                value: 'kustomize',
+                label: 'Kustomize structure',
+                description: 'Base with kustomization.yaml for overlays',
+            },
+        ],
+        defaultValue: ctx.outputFormat || 'multiple',
+    });
+    ui.newLine();
+    const outputPath = await pathInput('Output directory:', ctx.outputPath || `./${ctx.name}-k8s`);
+    if (!outputPath) {
+        return { success: false, error: 'Output path is required' };
+    }
+    return {
+        success: true,
+        data: {
+            outputFormat,
+            outputPath,
+        },
+    };
+}
+/**
+ * Step 10: Generate Manifests
+ */
+async function generateStep(ctx) {
+    ui.startSpinner({ message: 'Generating Kubernetes manifests...' });
+    try {
+        // Generate manifests locally using built-in generator
+        const files = generateManifestsLocally(ctx);
+        await writeFilesToDisk(files, ctx.outputPath);
+        ui.stopSpinnerSuccess(`Generated ${files.length} manifest(s)`);
+        return {
+            success: true,
+            data: {
+                generatedFiles: files.map(f => f.path),
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Build the generation request from context
+ */
+function buildGenerationRequest(ctx) {
+    return {
+        workloadType: ctx.workloadType,
+        name: ctx.name,
+        namespace: ctx.namespace,
+        image: ctx.image,
+        imageTag: ctx.imageTag,
+        replicas: ctx.replicas,
+        containerPort: ctx.containerPort,
+        serviceType: ctx.serviceType,
+        servicePort: ctx.servicePort,
+        cpuRequest: ctx.cpuRequest,
+        cpuLimit: ctx.cpuLimit,
+        memoryRequest: ctx.memoryRequest,
+        memoryLimit: ctx.memoryLimit,
+        includeService: ctx.includeService,
+        includeIngress: ctx.includeIngress,
+        includeHpa: ctx.includeHpa,
+        includePdb: ctx.includePdb,
+        includeConfigMap: ctx.includeConfigMap,
+        includeSecret: ctx.includeSecret,
+        includeProbes: ctx.includeProbes,
+        livenessPath: ctx.livenessPath,
+        readinessPath: ctx.readinessPath,
+        ingressHost: ctx.ingressHost,
+        ingressPath: ctx.ingressPath,
+        ingressTls: ctx.ingressTls,
+        minAvailable: ctx.minAvailable,
+        minReplicas: ctx.minReplicas,
+        maxReplicas: ctx.maxReplicas,
+        targetCPUUtilization: ctx.targetCPUUtilization,
+        schedule: ctx.schedule,
+        backoffLimit: ctx.backoffLimit,
+        completions: ctx.completions,
+        parallelism: ctx.parallelism,
+        outputFormat: ctx.outputFormat,
+        outputPath: ctx.outputPath,
+    };
+}
+/**
+ * Generate manifests locally when service is unavailable
+ */
+function generateManifestsLocally(ctx) {
+    const files = [];
+    const labels = {
+        'app.kubernetes.io/name': ctx.name || 'unnamed',
+        'app.kubernetes.io/instance': ctx.name || 'unnamed',
+        'app.kubernetes.io/managed-by': 'nimbus',
+    };
+    // Generate main workload
+    const workloadManifest = generateWorkloadManifest(ctx, labels);
+    files.push({
+        name: `${ctx.workloadType}.yaml`,
+        content: workloadManifest,
+        path: `${ctx.outputPath}/${ctx.workloadType}.yaml`,
+    });
+    // Generate Service
+    if (ctx.includeService) {
+        files.push({
+            name: 'service.yaml',
+            content: generateServiceManifest(ctx, labels),
+            path: `${ctx.outputPath}/service.yaml`,
+        });
+    }
+    // Generate Ingress
+    if (ctx.includeIngress) {
+        files.push({
+            name: 'ingress.yaml',
+            content: generateIngressManifest(ctx, labels),
+            path: `${ctx.outputPath}/ingress.yaml`,
+        });
+    }
+    // Generate HPA
+    if (ctx.includeHpa) {
+        files.push({
+            name: 'hpa.yaml',
+            content: generateHpaManifest(ctx, labels),
+            path: `${ctx.outputPath}/hpa.yaml`,
+        });
+    }
+    // Generate PDB
+    if (ctx.includePdb) {
+        files.push({
+            name: 'pdb.yaml',
+            content: generatePdbManifest(ctx, labels),
+            path: `${ctx.outputPath}/pdb.yaml`,
+        });
+    }
+    // Generate ConfigMap
+    if (ctx.includeConfigMap) {
+        files.push({
+            name: 'configmap.yaml',
+            content: generateConfigMapManifest(ctx, labels),
+            path: `${ctx.outputPath}/configmap.yaml`,
+        });
+    }
+    // Generate Secret
+    if (ctx.includeSecret) {
+        files.push({
+            name: 'secret.yaml',
+            content: generateSecretManifest(ctx, labels),
+            path: `${ctx.outputPath}/secret.yaml`,
+        });
+    }
+    return files;
+}
+/**
+ * Generate main workload manifest
+ */
+function generateWorkloadManifest(ctx, labels) {
+    const { workloadType, name, namespace, image, imageTag, replicas, containerPort } = ctx;
+    // Build container spec
+    const containerSpec = {
+        name,
+        image: `${image}:${imageTag || 'latest'}`,
+        ports: containerPort ? [{ containerPort }] : undefined,
+        resources: ctx.cpuRequest || ctx.memoryRequest
+            ? {
+                requests: {
+                    ...(ctx.cpuRequest && { cpu: ctx.cpuRequest }),
+                    ...(ctx.memoryRequest && { memory: ctx.memoryRequest }),
+                },
+                limits: {
+                    ...(ctx.cpuLimit && { cpu: ctx.cpuLimit }),
+                    ...(ctx.memoryLimit && { memory: ctx.memoryLimit }),
+                },
+            }
+            : undefined,
+    };
+    // Add probes if configured
+    if (ctx.includeProbes) {
+        containerSpec.livenessProbe = {
+            httpGet: {
+                path: ctx.livenessPath || '/healthz',
+                port: containerPort,
+            },
+            initialDelaySeconds: 10,
+            periodSeconds: 10,
+        };
+        containerSpec.readinessProbe = {
+            httpGet: {
+                path: ctx.readinessPath || '/ready',
+                port: containerPort,
+            },
+            initialDelaySeconds: 5,
+            periodSeconds: 5,
+        };
+    }
+    // Add envFrom if ConfigMap or Secret
+    const envFrom = [];
+    if (ctx.includeConfigMap) {
+        envFrom.push({ configMapRef: { name: `${name}-config` } });
+    }
+    if (ctx.includeSecret) {
+        envFrom.push({ secretRef: { name: `${name}-secret` } });
+    }
+    if (envFrom.length > 0) {
+        containerSpec.envFrom = envFrom;
+    }
+    // Clean up undefined values
+    Object.keys(containerSpec).forEach(key => {
+        if (containerSpec[key] === undefined) {
+            delete containerSpec[key];
+        }
+    });
+    const podSpec = {
+        containers: [containerSpec],
+    };
+    let manifest;
+    switch (workloadType) {
+        case 'deployment':
+            manifest = {
+                apiVersion: 'apps/v1',
+                kind: 'Deployment',
+                metadata: { name, namespace, labels },
+                spec: {
+                    replicas,
+                    selector: { matchLabels: { 'app.kubernetes.io/name': name } },
+                    template: {
+                        metadata: { labels },
+                        spec: podSpec,
+                    },
+                },
+            };
+            break;
+        case 'statefulset':
+            manifest = {
+                apiVersion: 'apps/v1',
+                kind: 'StatefulSet',
+                metadata: { name, namespace, labels },
+                spec: {
+                    replicas,
+                    serviceName: name,
+                    selector: { matchLabels: { 'app.kubernetes.io/name': name } },
+                    template: {
+                        metadata: { labels },
+                        spec: podSpec,
+                    },
+                },
+            };
+            break;
+        case 'daemonset':
+            manifest = {
+                apiVersion: 'apps/v1',
+                kind: 'DaemonSet',
+                metadata: { name, namespace, labels },
+                spec: {
+                    selector: { matchLabels: { 'app.kubernetes.io/name': name } },
+                    template: {
+                        metadata: { labels },
+                        spec: podSpec,
+                    },
+                },
+            };
+            break;
+        case 'job':
+            manifest = {
+                apiVersion: 'batch/v1',
+                kind: 'Job',
+                metadata: { name, namespace, labels },
+                spec: {
+                    backoffLimit: ctx.backoffLimit,
+                    completions: ctx.completions,
+                    parallelism: ctx.parallelism,
+                    template: {
+                        metadata: { labels },
+                        spec: {
+                            ...podSpec,
+                            restartPolicy: 'Never',
+                        },
+                    },
+                },
+            };
+            break;
+        case 'cronjob':
+            manifest = {
+                apiVersion: 'batch/v1',
+                kind: 'CronJob',
+                metadata: { name, namespace, labels },
+                spec: {
+                    schedule: ctx.schedule,
+                    jobTemplate: {
+                        spec: {
+                            backoffLimit: ctx.backoffLimit,
+                            template: {
+                                metadata: { labels },
+                                spec: {
+                                    ...podSpec,
+                                    restartPolicy: 'Never',
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            break;
+        default:
+            manifest = {};
+    }
+    return toYaml(manifest);
+}
+/**
+ * Generate Service manifest
+ */
+function generateServiceManifest(ctx, labels) {
+    const manifest = {
+        apiVersion: 'v1',
+        kind: 'Service',
+        metadata: {
+            name: ctx.name,
+            namespace: ctx.namespace,
+            labels,
+        },
+        spec: {
+            type: ctx.serviceType,
+            selector: { 'app.kubernetes.io/name': ctx.name },
+            ports: [
+                {
+                    port: ctx.servicePort,
+                    targetPort: ctx.containerPort,
+                    protocol: 'TCP',
+                },
+            ],
+        },
+    };
+    return toYaml(manifest);
+}
+/**
+ * Generate Ingress manifest
+ */
+function generateIngressManifest(ctx, labels) {
+    const manifest = {
+        apiVersion: 'networking.k8s.io/v1',
+        kind: 'Ingress',
+        metadata: {
+            name: ctx.name,
+            namespace: ctx.namespace,
+            labels,
+            annotations: {
+                'kubernetes.io/ingress.class': 'nginx',
+            },
+        },
+        spec: {
+            rules: [
+                {
+                    host: ctx.ingressHost,
+                    http: {
+                        paths: [
+                            {
+                                path: ctx.ingressPath || '/',
+                                pathType: 'Prefix',
+                                backend: {
+                                    service: {
+                                        name: ctx.name,
+                                        port: { number: ctx.servicePort },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            ],
+        },
+    };
+    if (ctx.ingressTls) {
+        manifest.spec.tls = [
+            {
+                hosts: [ctx.ingressHost],
+                secretName: `${ctx.name}-tls`,
+            },
+        ];
+    }
+    return toYaml(manifest);
+}
+/**
+ * Generate HPA manifest
+ */
+function generateHpaManifest(ctx, labels) {
+    const manifest = {
+        apiVersion: 'autoscaling/v2',
+        kind: 'HorizontalPodAutoscaler',
+        metadata: {
+            name: ctx.name,
+            namespace: ctx.namespace,
+            labels,
+        },
+        spec: {
+            scaleTargetRef: {
+                apiVersion: 'apps/v1',
+                kind: ctx.workloadType === 'statefulset' ? 'StatefulSet' : 'Deployment',
+                name: ctx.name,
+            },
+            minReplicas: ctx.minReplicas,
+            maxReplicas: ctx.maxReplicas,
+            metrics: [
+                {
+                    type: 'Resource',
+                    resource: {
+                        name: 'cpu',
+                        target: {
+                            type: 'Utilization',
+                            averageUtilization: ctx.targetCPUUtilization,
+                        },
+                    },
+                },
+            ],
+        },
+    };
+    return toYaml(manifest);
+}
+/**
+ * Generate PDB manifest
+ */
+function generatePdbManifest(ctx, labels) {
+    const manifest = {
+        apiVersion: 'policy/v1',
+        kind: 'PodDisruptionBudget',
+        metadata: {
+            name: ctx.name,
+            namespace: ctx.namespace,
+            labels,
+        },
+        spec: {
+            minAvailable: ctx.minAvailable,
+            selector: { matchLabels: { 'app.kubernetes.io/name': ctx.name } },
+        },
+    };
+    return toYaml(manifest);
+}
+/**
+ * Generate ConfigMap manifest
+ */
+function generateConfigMapManifest(ctx, labels) {
+    const manifest = {
+        apiVersion: 'v1',
+        kind: 'ConfigMap',
+        metadata: {
+            name: `${ctx.name}-config`,
+            namespace: ctx.namespace,
+            labels,
+        },
+        data: {
+            // Placeholder values - user should customize
+            APP_ENV: 'production',
+            LOG_LEVEL: 'info',
+        },
+    };
+    return toYaml(manifest);
+}
+/**
+ * Generate Secret manifest
+ */
+function generateSecretManifest(ctx, labels) {
+    const manifest = {
+        apiVersion: 'v1',
+        kind: 'Secret',
+        metadata: {
+            name: `${ctx.name}-secret`,
+            namespace: ctx.namespace,
+            labels,
+        },
+        type: 'Opaque',
+        stringData: {
+            // Placeholder values - user should customize
+            'example-key': 'example-value',
+        },
+    };
+    return toYaml(manifest);
+}
+/**
+ * Convert object to YAML string
+ */
+function toYaml(obj, indent = 0) {
+    const lines = [];
+    const spaces = '  '.repeat(indent);
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                continue;
+            }
+            lines.push(`${spaces}${key}:`);
+            for (const item of value) {
+                if (typeof item === 'object' && item !== null) {
+                    const itemYaml = toYaml(item, indent + 1);
+                    const itemLines = itemYaml.split('\n').filter(l => l.trim());
+                    lines.push(`${spaces}- ${itemLines[0].trim()}`);
+                    for (let i = 1; i < itemLines.length; i++) {
+                        lines.push(`${spaces}  ${itemLines[i].trim()}`);
+                    }
+                }
+                else {
+                    lines.push(`${spaces}- ${item}`);
+                }
+            }
+        }
+        else if (typeof value === 'object') {
+            lines.push(`${spaces}${key}:`);
+            lines.push(toYaml(value, indent + 1));
+        }
+        else if (typeof value === 'string' &&
+            (value.includes(':') || value.includes('#') || value.includes('\n'))) {
+            lines.push(`${spaces}${key}: "${value}"`);
+        }
+        else {
+            lines.push(`${spaces}${key}: ${value}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Write files to disk
+ */
+async function writeFilesToDisk(files, outputPath) {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    // Create output directory
+    await fs.mkdir(outputPath, { recursive: true });
+    // Write each file
+    for (const file of files) {
+        const filePath = path.join(outputPath, file.name);
+        await fs.writeFile(filePath, file.content, 'utf-8');
+    }
+}
+/**
+ * Run in non-interactive mode
+ */
+async function runNonInteractive(options) {
+    ui.header('nimbus generate k8s', 'Non-interactive mode');
+    // Validate required options
+    if (!options.name) {
+        ui.error('Name is required in non-interactive mode (--name)');
+        process.exit(1);
+    }
+    if (!options.image) {
+        ui.error('Image is required in non-interactive mode (--image)');
+        process.exit(1);
+    }
+    ui.info(`Workload type: ${options.workloadType || 'deployment'}`);
+    ui.info(`Name: ${options.name}`);
+    ui.info(`Namespace: ${options.namespace || 'default'}`);
+    ui.info(`Image: ${options.image}`);
+    ui.info(`Output: ${options.output || `./${options.name}-k8s`}`);
+    // Build context from options
+    const ctx = {
+        workloadType: options.workloadType || 'deployment',
+        name: options.name,
+        namespace: options.namespace || 'default',
+        image: options.image.split(':')[0],
+        imageTag: options.image.split(':')[1] || 'latest',
+        replicas: options.replicas ?? 2,
+        containerPort: options.port ?? 8080,
+        serviceType: options.serviceType || 'ClusterIP',
+        includeService: true,
+        includeIngress: options.includeIngress ?? false,
+        includeHpa: options.includeHpa ?? false,
+        includePdb: options.includePdb ?? false,
+        includeConfigMap: options.includeConfigMap ?? false,
+        includeSecret: options.includeSecret ?? false,
+        cpuRequest: options.cpuRequest,
+        cpuLimit: options.cpuLimit,
+        memoryRequest: options.memoryRequest,
+        memoryLimit: options.memoryLimit,
+        outputPath: options.output || `./${options.name}-k8s`,
+        outputFormat: 'multiple',
+    };
+    ui.newLine();
+    ui.startSpinner({ message: 'Generating manifests...' });
+    try {
+        const files = generateManifestsLocally(ctx);
+        await writeFilesToDisk(files, ctx.outputPath);
+        ui.stopSpinnerSuccess(`Generated ${files.length} manifest(s)`);
+        ui.newLine();
+        ui.box({
+            title: 'Complete!',
+            content: [
+                `Generated ${files.length} manifest(s) in ${ctx.outputPath}:`,
+                ...files.map(f => `  - ${f.name}`),
+            ],
+            style: 'rounded',
+            borderColor: 'green',
+            padding: 1,
+        });
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Generation failed');
+        ui.error(error.message);
+        process.exit(1);
+    }
+}
+// Export as default command
+export default generateK8sCommand;