@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/context/context-db.js

@@ -0,0 +1,138 @@
+/**
+ * Context Database
+ *
+ * Lightweight SQLite wrapper for .nimbus/context.db that stores:
+ * - Recent commands and their results
+ * - File change tracking for project context
+ * - AI conversation context across sessions
+ */
+import { Database } from '../compat/sqlite';
+import * as path from 'path';
+import * as fs from 'fs';
+const CONTEXT_DB_NAME = 'context.db';
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS command_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+    command TEXT NOT NULL,
+    args TEXT,
+    status TEXT NOT NULL DEFAULT 'success',
+    duration_ms INTEGER,
+    output_summary TEXT
+);
+
+CREATE TABLE IF NOT EXISTS file_changes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+    file_path TEXT NOT NULL,
+    change_type TEXT NOT NULL,
+    content_hash TEXT,
+    metadata TEXT
+);
+
+CREATE TABLE IF NOT EXISTS conversation_context (
+    id TEXT PRIMARY KEY,
+    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+    title TEXT,
+    messages TEXT NOT NULL,
+    model TEXT,
+    token_count INTEGER,
+    metadata TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_cmd_history_ts ON command_history(timestamp);
+CREATE INDEX IF NOT EXISTS idx_file_changes_path ON file_changes(file_path);
+CREATE INDEX IF NOT EXISTS idx_file_changes_ts ON file_changes(timestamp);
+CREATE INDEX IF NOT EXISTS idx_conversation_ts ON conversation_context(timestamp);
+`;
+export class ContextDatabase {
+    db;
+    dbPath;
+    constructor(projectDir) {
+        const nimbusDir = path.join(projectDir, '.nimbus');
+        this.dbPath = path.join(nimbusDir, CONTEXT_DB_NAME);
+        if (!fs.existsSync(nimbusDir)) {
+            fs.mkdirSync(nimbusDir, { recursive: true });
+        }
+        this.db = new Database(this.dbPath);
+        this.db.exec(SCHEMA);
+    }
+    recordCommand(command, args, status = 'success', durationMs, outputSummary) {
+        const stmt = this.db.prepare(`
+      INSERT INTO command_history (command, args, status, duration_ms, output_summary)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(command, args || null, status, durationMs || null, outputSummary || null);
+    }
+    getRecentCommands(limit = 20) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM command_history ORDER BY timestamp DESC LIMIT ?
+    `);
+        return stmt.all(limit).map(row => ({
+            id: row.id,
+            timestamp: row.timestamp,
+            command: row.command,
+            args: row.args,
+            status: row.status,
+            durationMs: row.duration_ms,
+        }));
+    }
+    trackFileChange(filePath, changeType, contentHash, metadata) {
+        const stmt = this.db.prepare(`
+      INSERT INTO file_changes (file_path, change_type, content_hash, metadata)
+      VALUES (?, ?, ?, ?)
+    `);
+        stmt.run(filePath, changeType, contentHash || null, metadata ? JSON.stringify(metadata) : null);
+    }
+    getRecentFileChanges(limit = 50) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM file_changes ORDER BY timestamp DESC LIMIT ?
+    `);
+        return stmt.all(limit).map(row => ({
+            filePath: row.file_path,
+            changeType: row.change_type,
+            timestamp: row.timestamp,
+        }));
+    }
+    saveConversation(id, title, messages, model, tokenCount, metadata) {
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO conversation_context (id, title, messages, model, token_count, metadata)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, title, JSON.stringify(messages), model || null, tokenCount || null, metadata ? JSON.stringify(metadata) : null);
+    }
+    getConversation(id) {
+        const stmt = this.db.prepare('SELECT * FROM conversation_context WHERE id = ?');
+        const row = stmt.get(id);
+        if (!row) {
+            return null;
+        }
+        return {
+            id: row.id,
+            title: row.title,
+            messages: JSON.parse(row.messages),
+            model: row.model,
+            tokenCount: row.token_count,
+        };
+    }
+    listConversations(limit = 20) {
+        const stmt = this.db.prepare(`
+      SELECT id, title, timestamp, model FROM conversation_context ORDER BY timestamp DESC LIMIT ?
+    `);
+        return stmt.all(limit).map(row => ({
+            id: row.id,
+            title: row.title,
+            timestamp: row.timestamp,
+            model: row.model,
+        }));
+    }
+    close() {
+        this.db.close();
+    }
+    getPath() {
+        return this.dbPath;
+    }
+}
+export function initContextDatabase(projectDir) {
+    return new ContextDatabase(projectDir);
+}

package/dist/src/demo/index.js

@@ -0,0 +1,295 @@
+/**
+ * Demo Framework
+ *
+ * Orchestrates demo scenarios for presentations and tutorials
+ */
+import { logger } from '../utils';
+import { ui } from '../wizard/ui';
+import { confirm } from '../wizard/prompts';
+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 = [
+    gettingStartedScenario,
+    terraformVpcScenario,
+    k8sDeploymentScenario,
+    helmReleaseScenario,
+    fullJourneyScenario,
+];
+/**
+ * Get all available demo scenarios
+ */
+export function getScenarios() {
+    return scenarios;
+}
+/**
+ * Get a scenario by ID
+ */
+export function getScenario(id) {
+    return scenarios.find(s => s.id === id);
+}
+/**
+ * Run a demo scenario
+ */
+export async function runScenario(scenario, options = {}) {
+    logger.info(`Running demo scenario: ${scenario.name}`);
+    const startedAt = new Date();
+    const stepResults = [];
+    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, options, current, total) {
+    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) {
+            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) {
+    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) {
+        return {
+            stdout: error.stdout || '',
+            stderr: error.stderr || error.message,
+            exitCode: error.code || 1,
+        };
+    }
+}
+/**
+ * Display scenario header
+ */
+function displayScenarioHeader(scenario) {
+    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, results, success, duration) {
+    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) {
+    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, stepDelay) {
+    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, width) {
+    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) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// Re-export types
+export * from './types';

package/dist/src/demo/scenarios/full-journey.js

@@ -0,0 +1,226 @@
+/**
+ * Full Journey Demo Scenario
+ *
+ * End-to-end demo from discovery to deployment
+ */
+export const fullJourneyScenario = {
+    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(),
+        },
+    ],
+};