@build-astron-co/nimbus 0.2.0

package/src/demo/index.ts

@@ -0,0 +1,349 @@
+/**
+ * Demo Framework
+ *
+ * Orchestrates demo scenarios for presentations and tutorials
+ */
+
+import { logger } from '../utils';
+import { ui } from '../wizard/ui';
+import { confirm } from '../wizard/prompts';
+import type { DemoScenario, DemoStep, DemoOptions, StepResult, ScenarioResult } from './types';
+import { terraformVpcScenario } from './scenarios/terraform-vpc';
+import { fullJourneyScenario } from './scenarios/full-journey';
+import { gettingStartedScenario } from './scenarios/getting-started';
+import { k8sDeploymentScenario } from './scenarios/k8s-deployment';
+import { helmReleaseScenario } from './scenarios/helm-release';
+
+// All available scenarios
+const scenarios: DemoScenario[] = [
+  gettingStartedScenario,
+  terraformVpcScenario,
+  k8sDeploymentScenario,
+  helmReleaseScenario,
+  fullJourneyScenario,
+];
+
+/**
+ * Get all available demo scenarios
+ */
+export function getScenarios(): DemoScenario[] {
+  return scenarios;
+}
+
+/**
+ * Get a scenario by ID
+ */
+export function getScenario(id: string): DemoScenario | undefined {
+  return scenarios.find(s => s.id === id);
+}
+
+/**
+ * Run a demo scenario
+ */
+export async function runScenario(
+  scenario: DemoScenario,
+  options: DemoOptions = {}
+): Promise<ScenarioResult> {
+  logger.info(`Running demo scenario: ${scenario.name}`);
+
+  const startedAt = new Date();
+  const stepResults: StepResult[] = [];
+  let totalDuration = 0;
+  let success = true;
+
+  // Show scenario header
+  displayScenarioHeader(scenario);
+
+  // Check prerequisites
+  if (scenario.prerequisites && scenario.prerequisites.length > 0) {
+    ui.newLine();
+    ui.print(ui.bold('Prerequisites:'));
+    for (const prereq of scenario.prerequisites) {
+      ui.print(`  - ${prereq}`);
+    }
+    ui.newLine();
+
+    if (options.interactive) {
+      const proceed = await confirm({
+        message: 'Have you met all prerequisites?',
+        defaultValue: true,
+      });
+
+      if (!proceed) {
+        ui.warning('Demo cancelled - prerequisites not met');
+        return {
+          scenario,
+          steps: [],
+          success: false,
+          totalDuration: 0,
+          startedAt,
+          completedAt: new Date(),
+        };
+      }
+    }
+  }
+
+  // Run each step
+  for (let i = 0; i < scenario.steps.length; i++) {
+    const step = scenario.steps[i];
+
+    // Wait before step if interactive
+    if (options.interactive && i > 0) {
+      const proceed = await confirm({
+        message: 'Continue to next step?',
+        defaultValue: true,
+      });
+
+      if (!proceed) {
+        ui.info('Demo paused');
+        break;
+      }
+    }
+
+    const result = await runStep(step, options, i + 1, scenario.steps.length);
+    stepResults.push(result);
+    totalDuration += result.duration;
+
+    if (!result.success) {
+      success = false;
+      if (!options.interactive) {
+        ui.error('Step failed, stopping demo');
+        break;
+      }
+    }
+
+    // Add delay based on speed
+    const delay = getDelay(options.speed, step.delay);
+    if (delay > 0) {
+      await sleep(delay);
+    }
+  }
+
+  const completedAt = new Date();
+
+  // Show summary
+  displaySummary(scenario, stepResults, success, totalDuration);
+
+  return {
+    scenario,
+    steps: stepResults,
+    success,
+    totalDuration,
+    startedAt,
+    completedAt,
+  };
+}
+
+/**
+ * Run a single demo step
+ */
+async function runStep(
+  step: DemoStep,
+  options: DemoOptions,
+  current: number,
+  total: number
+): Promise<StepResult> {
+  const startTime = Date.now();
+
+  // Display step header
+  ui.newLine();
+  ui.print(ui.color(`Step ${current}/${total}`, 'cyan'));
+  ui.print(ui.bold(step.title));
+  if (step.description) {
+    ui.print(ui.dim(step.description));
+  }
+  ui.newLine();
+
+  // Show command
+  ui.print(`  ${ui.color('$', 'green')} ${ui.color(step.command, 'yellow')}`);
+  ui.newLine();
+
+  // Execute or mock
+  let output = '';
+  let error = '';
+  let success = true;
+
+  if (options.dryRun) {
+    // Use mock response in dry run mode
+    if (step.mockResponse) {
+      output = step.mockResponse;
+      if (step.showOutput !== false) {
+        displayOutput(output);
+      }
+    } else {
+      ui.dim('  [Dry run - command not executed]');
+    }
+  } else {
+    // Actually execute the command
+    try {
+      const result = await executeCommand(step.command);
+      output = result.stdout;
+      error = result.stderr;
+      success = result.exitCode === 0;
+
+      if (step.showOutput !== false && output) {
+        displayOutput(output);
+      }
+
+      if (error && options.verbose) {
+        ui.print(ui.color(error, 'red'));
+      }
+    } catch (e: any) {
+      success = false;
+      error = e.message;
+      ui.error(`Failed: ${error}`);
+    }
+  }
+
+  // Verify expected output
+  if (success && step.expectedOutput) {
+    const regex = new RegExp(step.expectedOutput);
+    if (!regex.test(output)) {
+      success = false;
+      error = 'Output did not match expected pattern';
+    }
+  }
+
+  const duration = Date.now() - startTime;
+
+  // Show result
+  if (success) {
+    ui.success('Step completed');
+  } else {
+    ui.error('Step failed');
+  }
+
+  return {
+    step,
+    success,
+    output,
+    error: error || undefined,
+    duration,
+  };
+}
+
+/**
+ * Execute a command and return result
+ */
+async function executeCommand(command: string): Promise<{
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}> {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      maxBuffer: 10 * 1024 * 1024, // 10MB
+    });
+    return { stdout, stderr, exitCode: 0 };
+  } catch (error: any) {
+    return {
+      stdout: error.stdout || '',
+      stderr: error.stderr || error.message,
+      exitCode: error.code || 1,
+    };
+  }
+}
+
+/**
+ * Display scenario header
+ */
+function displayScenarioHeader(scenario: DemoScenario): void {
+  ui.newLine();
+  ui.print(`╔${'═'.repeat(58)}╗`);
+  ui.print(`║${' '.repeat(58)}║`);
+  ui.print(`║${centerText(scenario.name, 58)}║`);
+  ui.print(`║${centerText(scenario.description, 58)}║`);
+  ui.print(`║${' '.repeat(58)}║`);
+  ui.print(`║${centerText(`${scenario.steps.length} steps`, 58)}║`);
+  ui.print(`╚${'═'.repeat(58)}╝`);
+  ui.newLine();
+}
+
+/**
+ * Display execution summary
+ */
+function displaySummary(
+  scenario: DemoScenario,
+  results: StepResult[],
+  success: boolean,
+  duration: number
+): void {
+  ui.newLine();
+  ui.print('─'.repeat(60));
+  ui.print(ui.bold('Demo Summary'));
+  ui.newLine();
+
+  const passed = results.filter(r => r.success).length;
+  const failed = results.filter(r => !r.success).length;
+
+  ui.print(`  Scenario: ${scenario.name}`);
+  ui.print(
+    `  Steps:    ${ui.color(`${passed} passed`, 'green')}, ${failed > 0 ? ui.color(`${failed} failed`, 'red') : '0 failed'}`
+  );
+  ui.print(`  Duration: ${(duration / 1000).toFixed(1)}s`);
+
+  ui.newLine();
+  if (success) {
+    ui.success('Demo completed successfully!');
+  } else {
+    ui.error('Demo completed with errors');
+  }
+}
+
+/**
+ * Display command output with formatting
+ */
+function displayOutput(output: string): void {
+  const lines = output.split('\n');
+  for (const line of lines) {
+    // Color terraform output
+    if (line.startsWith('+')) {
+      ui.print(`  ${ui.color(line, 'green')}`);
+    } else if (line.startsWith('-')) {
+      ui.print(`  ${ui.color(line, 'red')}`);
+    } else if (line.startsWith('~')) {
+      ui.print(`  ${ui.color(line, 'yellow')}`);
+    } else {
+      ui.print(`  ${line}`);
+    }
+  }
+}
+
+/**
+ * Get delay based on speed setting
+ */
+function getDelay(speed: string | undefined, stepDelay: number | undefined): number {
+  const baseDelay = stepDelay || 500;
+
+  switch (speed) {
+    case 'slow':
+      return baseDelay * 2;
+    case 'fast':
+      return baseDelay / 2;
+    default:
+      return baseDelay;
+  }
+}
+
+/**
+ * Center text in a given width
+ */
+function centerText(text: string, width: number): string {
+  const leftPadding = Math.max(0, Math.floor((width - text.length) / 2));
+  const rightPadding = Math.max(0, width - leftPadding - text.length);
+  return ' '.repeat(leftPadding) + text + ' '.repeat(rightPadding);
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Re-export types
+export * from './types';

package/src/demo/scenarios/full-journey.ts

@@ -0,0 +1,229 @@
+/**
+ * Full Journey Demo Scenario
+ *
+ * End-to-end demo from discovery to deployment
+ */
+
+import type { DemoScenario } from '../types';
+
+export const fullJourneyScenario: DemoScenario = {
+  id: 'full-journey',
+  name: 'Full Infrastructure Journey',
+  description: 'Complete workflow: Discovery → Generation → Preview → Deploy',
+  category: 'full-journey',
+  duration: 15,
+  prerequisites: [
+    'AWS CLI configured with credentials',
+    'Terraform installed (v1.0+)',
+    'kubectl configured (for K8s steps)',
+    'Nimbus CLI installed',
+  ],
+  tags: ['full-demo', 'aws', 'terraform', 'kubernetes'],
+  steps: [
+    {
+      id: 'init',
+      title: 'Initialize Nimbus Project',
+      description: 'Set up Nimbus in the current project',
+      command: 'nimbus init',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Nimbus Initialization
+
+Scanning project...
+
+Detected:
+  ✓ Languages: TypeScript, Python
+  ✓ Frameworks: Next.js, FastAPI
+  ✓ Package Managers: npm, pip
+  ✓ IaC: Terraform
+  ✓ CI/CD: GitHub Actions
+  ✓ Cloud: AWS
+
+Created .nimbus/project.yaml
+
+Project initialized successfully!
+      `.trim(),
+    },
+    {
+      id: 'discover-aws',
+      title: 'Discover AWS Resources',
+      description: 'Scan your AWS account for existing infrastructure',
+      command: 'nimbus aws discover --regions us-east-1',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+AWS Discovery
+
+Scanning AWS account...
+Region: us-east-1
+
+Discovery Summary:
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  EC2 Instances:    3
+  VPCs:             2
+  S3 Buckets:       5
+  RDS Instances:    1
+  Lambda Functions: 8
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Resources discovered and saved to .nimbus/inventory.yaml
+      `.trim(),
+    },
+    {
+      id: 'generate-terraform',
+      title: 'Generate Terraform from Inventory',
+      description: 'Create Terraform code from discovered resources',
+      command: 'nimbus generate terraform --from-inventory',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Generate Terraform
+
+Generating from .nimbus/inventory.yaml...
+
+Generated files:
+  ● terraform/main.tf
+  ● terraform/vpc.tf
+  ● terraform/ec2.tf
+  ● terraform/rds.tf
+  ● terraform/s3.tf
+  ● terraform/variables.tf
+  ● terraform/outputs.tf
+
+Output directory: ./terraform
+
+Generation complete!
+Run 'nimbus preview terraform' to see the plan.
+      `.trim(),
+    },
+    {
+      id: 'preview',
+      title: 'Preview Infrastructure Changes',
+      description: 'Review what will be created/modified',
+      command: 'nimbus preview terraform ./terraform',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Preview Terraform Changes
+
+Directory: ./terraform
+
+Creating execution plan...
+Plan created
+
+Plan Summary:
+
+  + 12 to add
+  ~ 0 to change
+  - 0 to destroy
+
+Resources to be created:
+  + aws_vpc.main
+  + aws_subnet.private[0-2]
+  + aws_subnet.public[0-2]
+  + aws_security_group.main
+  + aws_instance.app
+  + aws_db_instance.main
+  + aws_s3_bucket.assets
+
+  Safety Check Summary:
+
+    🟡 [MEDIUM]  This operation will modify infrastructure
+
+All safety checks passed
+      `.trim(),
+    },
+    {
+      id: 'apply',
+      title: 'Apply Infrastructure',
+      description: 'Deploy the infrastructure with safety approval',
+      command: 'nimbus apply terraform ./terraform',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Terraform Apply
+
+Creating execution plan...
+Plan created
+
+╔══════════════════════════════════════════════════════════╗
+║               APPROVAL REQUIRED                          ║
+╠══════════════════════════════════════════════════════════╣
+║  Operation: terraform apply                              ║
+╚══════════════════════════════════════════════════════════╝
+
+  Identified Risks:
+    🟡 [MEDIUM]  This operation will modify infrastructure
+
+Do you want to proceed? Yes
+
+Applying changes...
+
+Apply complete! Resources: 12 added, 0 changed, 0 destroyed.
+      `.trim(),
+    },
+    {
+      id: 'generate-k8s',
+      title: 'Generate Kubernetes Manifests',
+      description: 'Create K8s deployment for the application',
+      command: 'nimbus questionnaire kubernetes',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Kubernetes Configuration Wizard
+
+Step 1/4: Application Info
+  Name: my-app
+  Image: my-registry/my-app:latest
+
+Step 2/4: Deployment Settings
+  Replicas: 3
+  Port: 8080
+
+Step 3/4: Resource Limits
+  CPU Request: 100m
+  Memory Request: 128Mi
+
+Step 4/4: Service Configuration
+  Type: ClusterIP
+  Port: 80
+
+Generated files:
+  ● k8s/deployment.yaml
+  ● k8s/service.yaml
+
+Output directory: ./k8s
+      `.trim(),
+    },
+    {
+      id: 'deploy-k8s',
+      title: 'Deploy to Kubernetes',
+      description: 'Apply K8s manifests to the cluster',
+      command: 'nimbus apply k8s ./k8s',
+      showOutput: true,
+      waitForInput: false,
+      mockResponse: `
+Kubernetes Apply
+
+Manifests: ./k8s
+Namespace: default
+
+Found 2 manifest file(s)
+
+Resources to apply:
+  - Deployment/my-app
+  - Service/my-app
+
+Apply 2 resource(s)? Yes
+
+Applying manifests...
+Apply complete!
+
+Created:
+  + Deployment/my-app
+  + Service/my-app
+      `.trim(),
+    },
+  ],
+};

package/src/demo/scenarios/getting-started.ts

@@ -0,0 +1,127 @@
+/**
+ * Getting Started Tutorial
+ *
+ * Interactive tutorial for new Nimbus users
+ */
+
+import type { DemoScenario } from '../types';
+
+export const gettingStartedScenario: DemoScenario = {
+  id: 'getting-started',
+  name: 'Getting Started with Nimbus',
+  description: 'Learn the basics of Nimbus CLI in this interactive tutorial',
+  category: 'tutorial',
+  duration: 5,
+  prerequisites: ['Nimbus CLI installed'],
+  tags: ['tutorial', 'beginner', 'basics'],
+  steps: [
+    {
+      id: 'check-version',
+      title: 'Check Nimbus Version',
+      description: "First, let's make sure Nimbus is installed correctly",
+      command: 'nimbus --version',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: 'nimbus version 1.0.0',
+    },
+    {
+      id: 'help',
+      title: 'View Available Commands',
+      description: "Nimbus has many commands - let's see what's available",
+      command: 'nimbus --help',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Nimbus CLI - AI-powered infrastructure assistant
+
+USAGE:
+  nimbus <command> [options]
+
+COMMANDS:
+  init          Initialize Nimbus in the current project
+  chat          Start an interactive chat session
+  generate      Generate infrastructure code
+  apply         Apply infrastructure changes
+  preview       Preview changes without applying
+  aws           AWS CLI commands
+  tf            Terraform commands
+  k8s           Kubernetes commands
+  helm          Helm commands
+
+FLAGS:
+  --version     Show version
+  --help        Show help
+      `.trim(),
+    },
+    {
+      id: 'doctor',
+      title: 'Run System Check',
+      description: 'Check that all required tools are installed',
+      command: 'nimbus doctor',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Nimbus Doctor
+
+Checking system requirements...
+
+  ✓ Node.js 18.0.0
+  ✓ Bun 1.0.0
+  ✓ Git 2.40.0
+  ✓ Terraform 1.5.0
+  ✓ kubectl 1.28.0
+  ✓ Helm 3.12.0
+  ✓ AWS CLI 2.13.0
+
+All checks passed!
+      `.trim(),
+    },
+    {
+      id: 'init-demo',
+      title: 'Initialize a Project',
+      description: 'Set up Nimbus in any directory to get started',
+      command: 'nimbus init --scan-depth quick',
+      showOutput: true,
+      waitForInput: true,
+      mockResponse: `
+Nimbus Initialization
+
+Scanning project (quick mode)...
+
+Project Summary:
+  Type: unknown
+  Languages: none detected
+
+Created .nimbus/project.yaml
+Created .nimbus/config.yaml
+
+Project initialized!
+
+Next steps:
+  1. Run 'nimbus chat' to get AI assistance
+  2. Run 'nimbus generate terraform' to create infrastructure
+  3. Run 'nimbus aws discover' to scan your AWS account
+      `.trim(),
+    },
+    {
+      id: 'config-list',
+      title: 'View Configuration',
+      description: 'See your current Nimbus configuration',
+      command: 'nimbus config list',
+      showOutput: true,
+      waitForInput: false,
+      mockResponse: `
+Nimbus Configuration
+
+  Key                    Value
+  ─────────────────────────────────────────
+  llm.provider           anthropic
+  llm.model              claude-3-sonnet
+  safety.enabled         true
+  safety.costThreshold   500
+  output.format          table
+  output.colors          true
+      `.trim(),
+    },
+  ],
+};