@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/questionnaire.js

@@ -0,0 +1,1021 @@
+/**
+ * Questionnaire Command
+ *
+ * Interactive questionnaire flow for generating infrastructure code
+ *
+ * Usage:
+ *   nimbus questionnaire terraform
+ *   nimbus questionnaire kubernetes
+ *   nimbus questionnaire helm
+ *   nimbus generate terraform --interactive
+ */
+import { logger } from '../utils';
+import { ui } from '../wizard/ui';
+import { select, input, confirm, multiSelect } from '../wizard/prompts';
+/**
+ * Run questionnaire command
+ */
+export async function questionnaireCommand(options) {
+    logger.info('Starting questionnaire', { type: options.type });
+    ui.newLine();
+    ui.header(`${capitalize(options.type)} Configuration Wizard`);
+    await runLocal(options);
+}
+/**
+ * Run questionnaire locally
+ */
+async function runLocal(options) {
+    ui.info('Starting local questionnaire...');
+    ui.newLine();
+    const answers = {};
+    // Get questionnaire steps based on type
+    const steps = getLocalQuestionnaireSteps(options.type);
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        // Check step condition
+        if (step.condition && !step.condition(answers)) {
+            continue;
+        }
+        // Display step header
+        ui.print(ui.bold(`Step ${i + 1}/${steps.length}: ${step.title}`));
+        if (step.description) {
+            ui.print(ui.dim(step.description));
+        }
+        ui.newLine();
+        // Process questions
+        for (const question of step.questions) {
+            // Check question dependency
+            if (question.dependsOn) {
+                const depValue = answers[question.dependsOn.questionId];
+                if (depValue !== question.dependsOn.value) {
+                    continue;
+                }
+            }
+            const answer = await askQuestion(question, answers);
+            answers[question.id] = answer;
+        }
+        // Show progress
+        displayProgress({
+            current: i + 1,
+            total: steps.length,
+            percentage: Math.round(((i + 1) / steps.length) * 100),
+        });
+    }
+    ui.newLine();
+    ui.success('Questionnaire completed!');
+    if (!options.dryRun) {
+        // Generate code from answers
+        await generateFromAnswers(answers, options.type, options);
+    }
+    else {
+        ui.newLine();
+        ui.print(ui.bold('Collected answers:'));
+        ui.print(JSON.stringify(answers, null, 2));
+    }
+}
+/**
+ * Ask a single question and return the answer
+ */
+async function askQuestion(question, currentAnswers) {
+    // Substitute variables in label and description
+    const label = substituteVariables(question.label, currentAnswers);
+    const _description = question.description
+        ? substituteVariables(question.description, currentAnswers)
+        : undefined;
+    switch (question.type) {
+        case 'select':
+            return select({
+                message: label,
+                options: question.options || [],
+            });
+        case 'multiselect':
+            return multiSelect({
+                message: label,
+                options: question.options || [],
+            });
+        case 'text':
+            return input({
+                message: label,
+                defaultValue: question.default,
+            });
+        case 'number': {
+            const numStr = await input({
+                message: label,
+                defaultValue: String(question.default ?? ''),
+            });
+            return parseInt(numStr, 10);
+        }
+        case 'confirm':
+            return confirm({
+                message: label,
+                defaultValue: question.default,
+            });
+        default:
+            return input({
+                message: label,
+                defaultValue: question.default,
+            });
+    }
+}
+/**
+ * Substitute variables in text ({{variable}} format)
+ */
+function substituteVariables(text, answers) {
+    return text.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+        const value = answers[key];
+        return value !== undefined ? String(value) : `{{${key}}}`;
+    });
+}
+/**
+ * Display progress bar
+ */
+function displayProgress(progress) {
+    const barWidth = 30;
+    const filled = Math.round((progress.current / progress.total) * barWidth);
+    const empty = barWidth - filled;
+    const bar = ui.color('█'.repeat(filled), 'green') + ui.dim('░'.repeat(empty));
+    ui.newLine();
+    ui.print(`  Progress: ${bar} ${progress.percentage}%`);
+}
+/**
+ * Generate code from answers
+ */
+async function generateFromAnswers(answers, type, options) {
+    ui.newLine();
+    ui.startSpinner({ message: 'Generating code...' });
+    try {
+        const outputDir = options.outputDir || `./${type}`;
+        const fs = await import('fs/promises');
+        const path = await import('path');
+        // Ensure output directory exists
+        await fs.mkdir(outputDir, { recursive: true });
+        // Generate code based on type
+        let files = [];
+        if (type === 'terraform') {
+            files = await generateTerraformCode(answers, outputDir, fs, path);
+        }
+        else if (type === 'kubernetes') {
+            files = await generateKubernetesCode(answers, outputDir, fs, path);
+        }
+        else if (type === 'helm') {
+            files = await generateHelmCode(answers, outputDir, fs, path);
+        }
+        ui.stopSpinnerSuccess('Code generated successfully');
+        // Display generated files
+        ui.newLine();
+        ui.print(ui.bold('Generated files:'));
+        for (const file of files) {
+            ui.print(`  ${ui.color('●', 'green')} ${file}`);
+        }
+        ui.newLine();
+        ui.print(`Output directory: ${outputDir}`);
+        // Run post-generation validation for Terraform
+        if (type === 'terraform') {
+            await runPostGenerationValidation(outputDir);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Code generation failed');
+        ui.error(error.message);
+    }
+}
+/**
+ * Generate Terraform code from answers
+ */
+async function generateTerraformCode(answers, outputDir, fs, path) {
+    const files = [];
+    // Generate main.tf
+    const mainContent = generateTerraformMain(answers);
+    const mainPath = path.join(outputDir, 'main.tf');
+    await fs.writeFile(mainPath, mainContent);
+    files.push('main.tf');
+    // Generate variables.tf
+    const varsContent = generateTerraformVariables(answers);
+    const varsPath = path.join(outputDir, 'variables.tf');
+    await fs.writeFile(varsPath, varsContent);
+    files.push('variables.tf');
+    // Generate outputs.tf
+    const outputsContent = generateTerraformOutputs(answers);
+    const outputsPath = path.join(outputDir, 'outputs.tf');
+    await fs.writeFile(outputsPath, outputsContent);
+    files.push('outputs.tf');
+    // Generate environment directories if environments were selected
+    const environments = answers.environments;
+    if (environments && environments.length > 0) {
+        const envFiles = await generateEnvironmentDirs(answers, outputDir, fs, path);
+        files.push(...envFiles);
+    }
+    return files;
+}
+/**
+ * Generate Terraform main.tf content
+ */
+function generateTerraformMain(answers) {
+    const provider = answers.provider || 'aws';
+    const _region = answers.region || 'us-east-1';
+    let content = `# Generated by Nimbus CLI
+
+terraform {
+  required_version = ">= 1.0.0"
+
+  required_providers {
+    ${provider} = {
+      source  = "hashicorp/${provider}"
+      version = "~> 5.0"
+    }
+  }
+}
+
+provider "${provider}" {
+  region = var.region
+}
+`;
+    // Add VPC if selected
+    const components = answers.components || [];
+    if (components.includes('vpc')) {
+        const vpcCidr = answers.vpc_cidr || '10.0.0.0/16';
+        content += `
+# VPC
+module "vpc" {
+  source  = "terraform-aws-modules/vpc/aws"
+  version = "~> 5.0"
+
+  name = var.project_name
+  cidr = "${vpcCidr}"
+
+  azs             = var.availability_zones
+  private_subnets = var.private_subnets
+  public_subnets  = var.public_subnets
+
+  enable_nat_gateway = true
+  single_nat_gateway = true
+
+  tags = var.tags
+}
+`;
+    }
+    return content;
+}
+/**
+ * Generate Terraform variables.tf content
+ */
+function generateTerraformVariables(answers) {
+    const projectName = answers.project_name || 'my-project';
+    return `# Generated by Nimbus CLI
+
+variable "region" {
+  description = "AWS region"
+  type        = string
+  default     = "us-east-1"
+}
+
+variable "project_name" {
+  description = "Project name"
+  type        = string
+  default     = "${projectName}"
+}
+
+variable "environment" {
+  description = "Environment (dev, staging, prod)"
+  type        = string
+  default     = "dev"
+}
+
+variable "availability_zones" {
+  description = "List of availability zones"
+  type        = list(string)
+  default     = ["us-east-1a", "us-east-1b", "us-east-1c"]
+}
+
+variable "private_subnets" {
+  description = "Private subnet CIDRs"
+  type        = list(string)
+  default     = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
+}
+
+variable "public_subnets" {
+  description = "Public subnet CIDRs"
+  type        = list(string)
+  default     = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]
+}
+
+variable "tags" {
+  description = "Tags to apply to resources"
+  type        = map(string)
+  default     = {}
+}
+`;
+}
+/**
+ * Generate Terraform outputs.tf content
+ */
+function generateTerraformOutputs(answers) {
+    const components = answers.components || [];
+    let content = `# Generated by Nimbus CLI
+`;
+    if (components.includes('vpc')) {
+        content += `
+output "vpc_id" {
+  description = "VPC ID"
+  value       = module.vpc.vpc_id
+}
+
+output "private_subnets" {
+  description = "Private subnet IDs"
+  value       = module.vpc.private_subnets
+}
+
+output "public_subnets" {
+  description = "Public subnet IDs"
+  value       = module.vpc.public_subnets
+}
+`;
+    }
+    return content;
+}
+/**
+ * Generate Kubernetes code from answers
+ */
+async function generateKubernetesCode(answers, outputDir, fs, path) {
+    const files = [];
+    const appName = answers.app_name || 'my-app';
+    // Generate deployment.yaml
+    const deploymentContent = `# Generated by Nimbus CLI
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${appName}
+  labels:
+    app: ${appName}
+spec:
+  replicas: ${answers.replicas || 2}
+  selector:
+    matchLabels:
+      app: ${appName}
+  template:
+    metadata:
+      labels:
+        app: ${appName}
+    spec:
+      containers:
+        - name: ${appName}
+          image: ${answers.image || 'nginx:latest'}
+          ports:
+            - containerPort: ${answers.port || 80}
+          resources:
+            requests:
+              cpu: ${answers.cpu_request || '100m'}
+              memory: ${answers.memory_request || '128Mi'}
+            limits:
+              cpu: ${answers.cpu_limit || '500m'}
+              memory: ${answers.memory_limit || '512Mi'}
+`;
+    const deploymentPath = path.join(outputDir, 'deployment.yaml');
+    await fs.writeFile(deploymentPath, deploymentContent);
+    files.push('deployment.yaml');
+    // Generate service.yaml if enabled
+    if (answers.create_service !== false) {
+        const serviceContent = `# Generated by Nimbus CLI
+apiVersion: v1
+kind: Service
+metadata:
+  name: ${appName}
+spec:
+  selector:
+    app: ${appName}
+  ports:
+    - protocol: TCP
+      port: ${answers.service_port || 80}
+      targetPort: ${answers.port || 80}
+  type: ${answers.service_type || 'ClusterIP'}
+`;
+        const servicePath = path.join(outputDir, 'service.yaml');
+        await fs.writeFile(servicePath, serviceContent);
+        files.push('service.yaml');
+    }
+    return files;
+}
+/**
+ * Generate Helm chart code from answers
+ */
+async function generateHelmCode(answers, outputDir, fs, path) {
+    const files = [];
+    const chartName = answers.chart_name || 'my-chart';
+    // Create templates directory
+    const templatesDir = path.join(outputDir, 'templates');
+    await fs.mkdir(templatesDir, { recursive: true });
+    // Generate Chart.yaml
+    const chartContent = `# Generated by Nimbus CLI
+apiVersion: v2
+name: ${chartName}
+description: ${answers.description || 'A Helm chart for Kubernetes'}
+type: application
+version: ${answers.version || '0.1.0'}
+appVersion: "${answers.app_version || '1.0.0'}"
+`;
+    const chartPath = path.join(outputDir, 'Chart.yaml');
+    await fs.writeFile(chartPath, chartContent);
+    files.push('Chart.yaml');
+    // Generate values.yaml
+    const valuesContent = `# Generated by Nimbus CLI
+# Default values for ${chartName}
+
+replicaCount: ${answers.replicas || 1}
+
+image:
+  repository: ${answers.image_repository || 'nginx'}
+  tag: ${answers.image_tag || 'latest'}
+  pullPolicy: IfNotPresent
+
+service:
+  type: ${answers.service_type || 'ClusterIP'}
+  port: ${answers.service_port || 80}
+
+resources:
+  requests:
+    cpu: ${answers.cpu_request || '100m'}
+    memory: ${answers.memory_request || '128Mi'}
+  limits:
+    cpu: ${answers.cpu_limit || '500m'}
+    memory: ${answers.memory_limit || '512Mi'}
+`;
+    const valuesPath = path.join(outputDir, 'values.yaml');
+    await fs.writeFile(valuesPath, valuesContent);
+    files.push('values.yaml');
+    return files;
+}
+/**
+ * Generate per-environment directories with module references
+ */
+async function generateEnvironmentDirs(answers, outputDir, fs, path) {
+    const environments = answers.environments;
+    const projectName = answers.project_name || 'my-project';
+    const _provider = answers.cloud || answers.provider || 'aws';
+    const region = answers.region || 'us-east-1';
+    const useRemoteState = answers.use_remote_state;
+    const files = [];
+    const envsDir = path.join(outputDir, 'environments');
+    await fs.mkdir(envsDir, { recursive: true });
+    for (const env of environments) {
+        const envDir = path.join(envsDir, env);
+        await fs.mkdir(envDir, { recursive: true });
+        // main.tf — module source pointing to root
+        const mainContent = `# ${env.charAt(0).toUpperCase() + env.slice(1)} Environment
+# Generated by Nimbus CLI
+
+module "infrastructure" {
+  source = "../../"
+
+  project_name = "${projectName}"
+  environment  = "${env}"
+  region       = var.region
+
+  tags = merge(var.tags, {
+    Environment = "${env}"
+  })
+}
+`;
+        await fs.writeFile(path.join(envDir, 'main.tf'), mainContent);
+        files.push(`environments/${env}/main.tf`);
+        // terraform.tfvars
+        const _instanceSize = env === 'prod' ? 't3.large' : env === 'staging' ? 't3.medium' : 't3.small';
+        const tfvarsContent = `# ${env.charAt(0).toUpperCase() + env.slice(1)} environment variables
+# Generated by Nimbus CLI
+
+region       = "${region}"
+
+tags = {
+  Environment = "${env}"
+  Project     = "${projectName}"
+  ManagedBy   = "terraform"
+}
+`;
+        await fs.writeFile(path.join(envDir, 'terraform.tfvars'), tfvarsContent);
+        files.push(`environments/${env}/terraform.tfvars`);
+        // backend.tf — remote state if selected
+        if (useRemoteState) {
+            const backendContent = `# Remote state configuration for ${env}
+# Generated by Nimbus CLI
+
+terraform {
+  backend "s3" {
+    bucket         = "${projectName}-tfstate"
+    key            = "${env}/terraform.tfstate"
+    region         = "${region}"
+    encrypt        = true
+    dynamodb_table = "${projectName}-tflock"
+  }
+}
+`;
+            await fs.writeFile(path.join(envDir, 'backend.tf'), backendContent);
+            files.push(`environments/${env}/backend.tf`);
+        }
+    }
+    return files;
+}
+/**
+ * Run post-generation validation on Terraform files
+ */
+async function runPostGenerationValidation(outputDir) {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    ui.newLine();
+    ui.section('Post-Generation Validation');
+    // Check if terraform CLI is available
+    let _hasTerraform = false;
+    try {
+        await execFileAsync('terraform', ['version'], { timeout: 5000 });
+        _hasTerraform = true;
+    }
+    catch {
+        ui.info('Terraform CLI not found - skipping validation');
+        ui.print(ui.dim('  Install terraform for automatic validation'));
+        return;
+    }
+    // Run terraform fmt -check
+    try {
+        ui.startSpinner({ message: 'Running terraform fmt...' });
+        await execFileAsync('terraform', ['fmt', '-check', '-diff'], {
+            cwd: outputDir,
+            timeout: 15000,
+        });
+        ui.stopSpinnerSuccess('Code formatting valid');
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Formatting issues found');
+        // Try to auto-fix
+        try {
+            await execFileAsync('terraform', ['fmt'], { cwd: outputDir, timeout: 15000 });
+            ui.success('Auto-formatted Terraform files');
+        }
+        catch {
+            ui.warning('Could not auto-format files');
+        }
+    }
+    // Run terraform init -backend=false for validation
+    try {
+        ui.startSpinner({ message: 'Running terraform validate...' });
+        await execFileAsync('terraform', ['init', '-backend=false', '-no-color'], {
+            cwd: outputDir,
+            timeout: 30000,
+        });
+        const { stdout } = await execFileAsync('terraform', ['validate', '-no-color'], {
+            cwd: outputDir,
+            timeout: 15000,
+        });
+        ui.stopSpinnerSuccess('Terraform validation passed');
+        if (stdout.includes('Success')) {
+            ui.print(ui.dim(`  ${stdout.trim()}`));
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Terraform validation failed');
+        const output = error.stdout || error.stderr || error.message;
+        ui.print(ui.dim(`  ${output}`));
+    }
+    // Check if tflint is available
+    try {
+        await execFileAsync('tflint', ['--version'], { timeout: 5000 });
+        ui.startSpinner({ message: 'Running tflint...' });
+        const { stdout } = await execFileAsync('tflint', ['--no-color'], {
+            cwd: outputDir,
+            timeout: 15000,
+        });
+        ui.stopSpinnerSuccess('tflint check passed');
+        if (stdout) {
+            ui.print(ui.dim(`  ${stdout.trim()}`));
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            ui.info('tflint not found - skipping lint check');
+            ui.print(ui.dim('  Install tflint for additional validation'));
+        }
+        else {
+            ui.warning('tflint found issues');
+            const output = error.stdout || error.stderr || error.message;
+            ui.print(ui.dim(`  ${output}`));
+        }
+    }
+    // Check if checkov is available for security scanning
+    try {
+        await execFileAsync('checkov', ['--version'], { timeout: 5000 });
+        ui.startSpinner({ message: 'Running checkov security scan...' });
+        const { stdout } = await execFileAsync('checkov', ['-d', outputDir, '--framework', 'terraform', '--compact', '--quiet'], { timeout: 60000 });
+        ui.stopSpinnerSuccess('checkov security scan passed');
+        // Parse passed/failed from output
+        const passedMatch = stdout.match(/Passed checks: (\d+)/);
+        const failedMatch = stdout.match(/Failed checks: (\d+)/);
+        if (passedMatch || failedMatch) {
+            const passed = passedMatch ? passedMatch[1] : '0';
+            const failed = failedMatch ? failedMatch[1] : '0';
+            ui.print(ui.dim(`  Passed: ${passed}, Failed: ${failed}`));
+        }
+        else if (stdout.trim()) {
+            ui.print(ui.dim(`  ${stdout.trim()}`));
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            ui.info('Security scanning available with checkov. Install: pip install checkov');
+        }
+        else {
+            ui.warning('checkov found security issues');
+            const output = error.stdout || error.stderr || error.message;
+            // Parse passed/failed from output even on non-zero exit
+            const passedMatch = output.match(/Passed checks: (\d+)/);
+            const failedMatch = output.match(/Failed checks: (\d+)/);
+            if (passedMatch || failedMatch) {
+                const passed = passedMatch ? passedMatch[1] : '0';
+                const failed = failedMatch ? failedMatch[1] : '0';
+                ui.print(ui.dim(`  Passed: ${passed}, Failed: ${failed}`));
+            }
+            else {
+                ui.print(ui.dim(`  ${output}`));
+            }
+        }
+    }
+}
+/**
+ * Get local questionnaire steps based on type
+ */
+function getLocalQuestionnaireSteps(type) {
+    switch (type) {
+        case 'terraform':
+            return getTerraformSteps();
+        case 'kubernetes':
+            return getKubernetesSteps();
+        case 'helm':
+            return getHelmSteps();
+        default:
+            return [];
+    }
+}
+/**
+ * Terraform questionnaire steps (local fallback)
+ */
+function getTerraformSteps() {
+    return [
+        {
+            id: 'provider',
+            title: 'Cloud Provider',
+            description: 'Select your cloud provider and region',
+            questions: [
+                {
+                    id: 'cloud',
+                    type: 'select',
+                    label: 'Which cloud provider?',
+                    options: [
+                        { value: 'aws', label: 'AWS', description: 'Amazon Web Services' },
+                        { value: 'gcp', label: 'GCP', description: 'Google Cloud Platform' },
+                        { value: 'azure', label: 'Azure', description: 'Microsoft Azure' },
+                    ],
+                    default: 'aws',
+                },
+                {
+                    id: 'region',
+                    type: 'select',
+                    label: 'Which region?',
+                    options: [
+                        { value: 'us-east-1', label: 'US East (N. Virginia)' },
+                        { value: 'us-west-2', label: 'US West (Oregon)' },
+                        { value: 'eu-west-1', label: 'EU (Ireland)' },
+                        { value: 'ap-southeast-1', label: 'Asia Pacific (Singapore)' },
+                    ],
+                    default: 'us-east-1',
+                    dependsOn: { questionId: 'cloud', value: 'aws' },
+                },
+                {
+                    id: 'project_name',
+                    type: 'text',
+                    label: 'Project name',
+                    default: 'my-project',
+                },
+                {
+                    id: 'environment',
+                    type: 'select',
+                    label: 'Environment',
+                    options: [
+                        { value: 'dev', label: 'Development' },
+                        { value: 'staging', label: 'Staging' },
+                        { value: 'prod', label: 'Production' },
+                    ],
+                    default: 'dev',
+                },
+            ],
+        },
+        {
+            id: 'components',
+            title: 'Infrastructure Components',
+            description: 'Select the components you need',
+            questions: [
+                {
+                    id: 'components',
+                    type: 'multiselect',
+                    label: 'What components do you need?',
+                    options: [
+                        { value: 'vpc', label: 'VPC / Network' },
+                        { value: 'eks', label: 'Kubernetes (EKS)' },
+                        { value: 'rds', label: 'Database (RDS)' },
+                        { value: 's3', label: 'Object Storage (S3)' },
+                        { value: 'ecs', label: 'Container Service (ECS)' },
+                    ],
+                    default: ['vpc'],
+                },
+            ],
+        },
+        {
+            id: 'environments',
+            title: 'Environment Separation',
+            description: 'Configure environment-specific deployments',
+            questions: [
+                {
+                    id: 'environments',
+                    type: 'multiselect',
+                    label: 'Which environments do you need?',
+                    options: [
+                        { value: 'dev', label: 'Development' },
+                        { value: 'staging', label: 'Staging' },
+                        { value: 'prod', label: 'Production' },
+                    ],
+                    default: ['dev'],
+                },
+                {
+                    id: 'use_remote_state',
+                    type: 'confirm',
+                    label: 'Use remote state backend (S3)?',
+                    default: true,
+                },
+            ],
+        },
+        {
+            id: 'vpc_config',
+            title: 'VPC Configuration',
+            condition: (answers) => {
+                const components = answers.components;
+                return components && components.includes('vpc');
+            },
+            questions: [
+                {
+                    id: 'vpc_cidr',
+                    type: 'text',
+                    label: 'VPC CIDR block',
+                    default: '10.0.0.0/16',
+                },
+                {
+                    id: 'availability_zones',
+                    type: 'number',
+                    label: 'Number of availability zones',
+                    default: 3,
+                },
+                {
+                    id: 'nat_gateway',
+                    type: 'select',
+                    label: 'NAT Gateway configuration',
+                    options: [
+                        { value: 'single', label: 'Single NAT (~$32/month)' },
+                        { value: 'ha', label: 'HA NAT (one per AZ)' },
+                        { value: 'none', label: 'No NAT Gateway' },
+                    ],
+                    default: 'single',
+                },
+            ],
+        },
+    ];
+}
+/**
+ * Kubernetes questionnaire steps (local fallback)
+ */
+function getKubernetesSteps() {
+    return [
+        {
+            id: 'workload',
+            title: 'Workload Type',
+            description: 'Configure your Kubernetes workload',
+            questions: [
+                {
+                    id: 'workload_type',
+                    type: 'select',
+                    label: 'What type of workload?',
+                    options: [
+                        {
+                            value: 'deployment',
+                            label: 'Deployment',
+                            description: 'Standard stateless workload',
+                        },
+                        {
+                            value: 'statefulset',
+                            label: 'StatefulSet',
+                            description: 'Stateful workload with persistent storage',
+                        },
+                        { value: 'daemonset', label: 'DaemonSet', description: 'Run on every node' },
+                        { value: 'cronjob', label: 'CronJob', description: 'Scheduled job' },
+                    ],
+                    default: 'deployment',
+                },
+                {
+                    id: 'name',
+                    type: 'text',
+                    label: 'Workload name',
+                    default: 'my-app',
+                },
+                {
+                    id: 'namespace',
+                    type: 'text',
+                    label: 'Namespace',
+                    default: 'default',
+                },
+            ],
+        },
+        {
+            id: 'container',
+            title: 'Container Configuration',
+            questions: [
+                {
+                    id: 'image',
+                    type: 'text',
+                    label: 'Container image',
+                    default: 'nginx:latest',
+                },
+                {
+                    id: 'replicas',
+                    type: 'number',
+                    label: 'Number of replicas',
+                    default: 3,
+                },
+                {
+                    id: 'port',
+                    type: 'number',
+                    label: 'Container port',
+                    default: 80,
+                },
+            ],
+        },
+        {
+            id: 'service',
+            title: 'Service Configuration',
+            questions: [
+                {
+                    id: 'service_type',
+                    type: 'select',
+                    label: 'Service type',
+                    options: [
+                        { value: 'ClusterIP', label: 'ClusterIP', description: 'Internal only' },
+                        { value: 'NodePort', label: 'NodePort', description: 'External via node port' },
+                        { value: 'LoadBalancer', label: 'LoadBalancer', description: 'External load balancer' },
+                    ],
+                    default: 'ClusterIP',
+                },
+                {
+                    id: 'create_ingress',
+                    type: 'confirm',
+                    label: 'Create Ingress?',
+                    default: false,
+                },
+            ],
+        },
+        {
+            id: 'resources',
+            title: 'Resource Limits',
+            questions: [
+                {
+                    id: 'cpu_request',
+                    type: 'text',
+                    label: 'CPU request',
+                    default: '100m',
+                },
+                {
+                    id: 'cpu_limit',
+                    type: 'text',
+                    label: 'CPU limit',
+                    default: '500m',
+                },
+                {
+                    id: 'memory_request',
+                    type: 'text',
+                    label: 'Memory request',
+                    default: '128Mi',
+                },
+                {
+                    id: 'memory_limit',
+                    type: 'text',
+                    label: 'Memory limit',
+                    default: '512Mi',
+                },
+            ],
+        },
+    ];
+}
+/**
+ * Helm questionnaire steps (local fallback)
+ */
+function getHelmSteps() {
+    return [
+        {
+            id: 'chart',
+            title: 'Chart Information',
+            description: 'Basic Helm chart configuration',
+            questions: [
+                {
+                    id: 'chart_name',
+                    type: 'text',
+                    label: 'Chart name',
+                    default: 'my-chart',
+                },
+                {
+                    id: 'chart_version',
+                    type: 'text',
+                    label: 'Chart version',
+                    default: '0.1.0',
+                },
+                {
+                    id: 'app_version',
+                    type: 'text',
+                    label: 'Application version',
+                    default: '1.0.0',
+                },
+                {
+                    id: 'description',
+                    type: 'text',
+                    label: 'Chart description',
+                    default: 'A Helm chart for my application',
+                },
+            ],
+        },
+        {
+            id: 'deployment',
+            title: 'Deployment Configuration',
+            questions: [
+                {
+                    id: 'image_repository',
+                    type: 'text',
+                    label: 'Image repository',
+                    default: 'nginx',
+                },
+                {
+                    id: 'image_tag',
+                    type: 'text',
+                    label: 'Image tag',
+                    default: 'latest',
+                },
+                {
+                    id: 'replica_count',
+                    type: 'number',
+                    label: 'Replica count',
+                    default: 1,
+                },
+            ],
+        },
+        {
+            id: 'service',
+            title: 'Service Configuration',
+            questions: [
+                {
+                    id: 'service_type',
+                    type: 'select',
+                    label: 'Service type',
+                    options: [
+                        { value: 'ClusterIP', label: 'ClusterIP' },
+                        { value: 'NodePort', label: 'NodePort' },
+                        { value: 'LoadBalancer', label: 'LoadBalancer' },
+                    ],
+                    default: 'ClusterIP',
+                },
+                {
+                    id: 'service_port',
+                    type: 'number',
+                    label: 'Service port',
+                    default: 80,
+                },
+            ],
+        },
+        {
+            id: 'ingress',
+            title: 'Ingress Configuration',
+            questions: [
+                {
+                    id: 'ingress_enabled',
+                    type: 'confirm',
+                    label: 'Enable Ingress?',
+                    default: false,
+                },
+                {
+                    id: 'ingress_host',
+                    type: 'text',
+                    label: 'Ingress hostname',
+                    default: 'chart.local',
+                    dependsOn: { questionId: 'ingress_enabled', value: true },
+                },
+            ],
+        },
+    ];
+}
+/**
+ * Capitalize first letter
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+// Export as default
+export default questionnaireCommand;