@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/logs.js

@@ -0,0 +1,160 @@
+/**
+ * Logs Command — H1
+ *
+ * Shorthand for streaming Kubernetes pod logs directly.
+ *
+ * Usage:
+ *   nimbus logs <pod> [-n namespace] [-f] [--previous] [--tail N] [--analyze]
+ */
+import { execFileSync, spawn } from 'node:child_process';
+import { ui } from '../wizard/ui';
+/**
+ * Build the kubectl logs argument array.
+ */
+function buildArgs(pod, options) {
+    const args = ['logs', pod];
+    if (options.namespace)
+        args.push('-n', options.namespace);
+    if (options.follow)
+        args.push('--follow');
+    if (options.previous)
+        args.push('--previous');
+    if (options.tail !== undefined)
+        args.push('--tail', String(options.tail));
+    if (options.container)
+        args.push('-c', options.container);
+    if (options.context)
+        args.push('--context', options.context);
+    return args;
+}
+/**
+ * Stream or fetch Kubernetes pod logs.
+ */
+export async function logsCommand(pod, options = {}) {
+    if (!pod) {
+        ui.error('Usage: nimbus logs <pod> [-n namespace] [-f] [--tail N]');
+        process.exit(1);
+    }
+    const args = buildArgs(pod, options);
+    // --analyze: capture output and pass to agent for analysis
+    if (options.analyze) {
+        if (!options.quiet) {
+            ui.startSpinner({ message: `Fetching logs for ${pod}...` });
+        }
+        try {
+            const output = execFileSync('kubectl', args, {
+                encoding: 'utf-8',
+                timeout: 30_000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            if (!options.quiet) {
+                ui.stopSpinnerSuccess('Logs fetched');
+            }
+            // Lazy-import agent loop to avoid circular deps at startup
+            const { runAgentLoop } = await import('../agent/loop');
+            const { getAppContext } = await import('../app');
+            const { defaultToolRegistry } = await import('../tools/schemas/types');
+            const { standardTools } = await import('../tools/schemas/standard');
+            const ctx = getAppContext();
+            if (!ctx) {
+                ui.error('App not initialized. Run `nimbus login` first.');
+                process.exit(1);
+            }
+            // Ensure tools are registered for the agent loop
+            if (defaultToolRegistry.size === 0) {
+                for (const tool of standardTools) {
+                    try {
+                        defaultToolRegistry.register(tool);
+                    }
+                    catch { /* skip duplicates */ }
+                }
+            }
+            if (!options.quiet) {
+                ui.info('Analyzing logs...');
+            }
+            await runAgentLoop(`Analyze these Kubernetes logs for pod "${pod}". Identify errors, anomalies, and crash patterns:\n\n${output}`, [], {
+                router: ctx.router,
+                toolRegistry: defaultToolRegistry,
+                mode: 'plan',
+                maxTurns: 5,
+                onText: text => { process.stdout.write(text); },
+            });
+            console.log('');
+        }
+        catch (error) {
+            if (!options.quiet) {
+                ui.stopSpinnerFail('Failed to fetch logs');
+            }
+            ui.error(error.message);
+            process.exit(1);
+        }
+        return;
+    }
+    // --follow: stream via spawn
+    if (options.follow) {
+        const child = spawn('kubectl', args, {
+            stdio: ['ignore', 'inherit', 'inherit'],
+        });
+        await new Promise((resolve, reject) => {
+            child.on('close', code => {
+                if (code !== 0)
+                    reject(new Error(`kubectl logs exited with code ${code}`));
+                else
+                    resolve();
+            });
+            child.on('error', reject);
+        });
+        return;
+    }
+    // Non-follow: capture and print
+    try {
+        const output = execFileSync('kubectl', args, {
+            encoding: 'utf-8',
+            timeout: 60_000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        process.stdout.write(output);
+    }
+    catch (error) {
+        ui.error(`kubectl logs failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Parse `nimbus logs <pod> [options]` arguments.
+ */
+export function parseLogsArgs(args) {
+    let pod = '';
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-n' || arg === '--namespace') {
+            options.namespace = args[++i];
+        }
+        else if (arg === '-f' || arg === '--follow') {
+            options.follow = true;
+        }
+        else if (arg === '-p' || arg === '--previous') {
+            options.previous = true;
+        }
+        else if (arg === '--tail') {
+            options.tail = parseInt(args[++i] ?? '100', 10);
+        }
+        else if (arg === '--analyze') {
+            options.analyze = true;
+        }
+        else if (arg === '-c' || arg === '--container') {
+            options.container = args[++i];
+        }
+        else if (arg === '--context') {
+            options.context = args[++i];
+        }
+        else if (arg === '-q' || arg === '--quiet') {
+            options.quiet = true;
+        }
+        else if (!arg.startsWith('-') && !pod) {
+            pod = arg;
+        }
+    }
+    return { pod, options };
+}

package/dist/src/commands/onboarding.js

@@ -0,0 +1,382 @@
+/**
+ * Onboarding Command
+ *
+ * First-run wizard that detects missing LLM credentials and guides
+ * the user through initial setup. Runs before full app init so it
+ * only depends on the auth store and wizard prompts.
+ */
+import { AuthStore } from '../auth/store';
+import { PROVIDER_REGISTRY, getDefaultModel, validateProviderApiKey } from '../auth/providers';
+import { ui } from '../wizard/ui';
+import { select, input } from '../wizard/prompts';
+/**
+ * Check whether onboarding is needed.
+ *
+ * Returns `true` if no LLM credentials are found in the auth store
+ * and no provider API key environment variables are set.
+ */
+export function needsOnboarding() {
+    const store = new AuthStore();
+    if (store.exists()) {
+        return false;
+    }
+    const hasEnvKey = !!(process.env.ANTHROPIC_API_KEY ||
+        process.env.OPENAI_API_KEY ||
+        process.env.GOOGLE_API_KEY ||
+        process.env.OPENROUTER_API_KEY ||
+        process.env.GROQ_API_KEY ||
+        process.env.TOGETHER_API_KEY ||
+        process.env.DEEPSEEK_API_KEY ||
+        process.env.FIREWORKS_API_KEY ||
+        process.env.PERPLEXITY_API_KEY ||
+        process.env.AWS_ACCESS_KEY_ID);
+    return !hasEnvKey;
+}
+/**
+ * Run the first-run onboarding wizard.
+ */
+export async function onboardingCommand(options = {}) {
+    if (options.skip) {
+        return;
+    }
+    const store = new AuthStore();
+    // Double-check — if credentials exist, skip silently
+    if (store.exists()) {
+        return;
+    }
+    // Non-TTY detection: if stdin is not a TTY (piped input, CI, etc.),
+    // skip the interactive wizard and show setup instructions instead.
+    if (!process.stdin.isTTY) {
+        ui.newLine();
+        ui.info('No LLM provider configured. Set an API key via environment variable:');
+        ui.newLine();
+        ui.print('  export ANTHROPIC_API_KEY=sk-ant-...');
+        ui.print('  export OPENAI_API_KEY=sk-...');
+        ui.print('  export GOOGLE_API_KEY=...');
+        ui.print('  export OPENROUTER_API_KEY=sk-or-...');
+        ui.print('  export GROQ_API_KEY=gsk_...');
+        ui.print('  export DEEPSEEK_API_KEY=sk-...');
+        ui.newLine();
+        ui.info('Or run "nimbus login" in an interactive terminal.');
+        ui.newLine();
+        return;
+    }
+    try {
+        // Welcome banner — DevOps-first identity
+        ui.newLine();
+        ui.box({
+            title: 'Welcome to Nimbus — AI-Powered DevOps Terminal',
+            content: [
+                'Plan, apply, and manage Terraform, Kubernetes, Helm,',
+                'AWS, GCP, and Azure using natural language.',
+                '',
+                "Let's get you set up. This takes about 30 seconds.",
+                '',
+                'After setup you can:',
+                '  nimbus                          Open interactive DevOps terminal',
+                '  nimbus run "tf plan --explain"  Run agent non-interactively',
+                '  nimbus status                   Live infra health dashboard',
+            ],
+            style: 'rounded',
+            borderColor: 'cyan',
+            titleColor: 'brightCyan',
+            padding: 1,
+        });
+        ui.newLine();
+        // Gap 12: Show env var shortcut for power users before the wizard
+        ui.print(ui.dim('─────────────────────────────────────────────────────'));
+        ui.print(ui.dim('  Quick setup: export an API key and restart nimbus.'));
+        ui.print(ui.dim('  export ANTHROPIC_API_KEY=sk-ant-...'));
+        ui.print(ui.dim('  export OPENAI_API_KEY=sk-...'));
+        ui.print(ui.dim('  export GOOGLE_API_KEY=...'));
+        ui.print(ui.dim('─────────────────────────────────────────────────────'));
+        ui.newLine();
+        // Provider selection
+        const providerOptions = Object.values(PROVIDER_REGISTRY).map(p => ({
+            label: p.displayName,
+            value: p.name,
+            description: p.description,
+        }));
+        const provider = await select({
+            message: 'Which LLM provider would you like to use?',
+            options: providerOptions,
+            required: true,
+        });
+        if (!provider) {
+            ui.newLine();
+            ui.info('No provider selected. You can run "nimbus login" later to set up.');
+            ui.newLine();
+            return;
+        }
+        const providerInfo = PROVIDER_REGISTRY[provider];
+        // API key input (skip for Ollama)
+        let apiKey;
+        let baseUrl;
+        if (providerInfo.requiresApiKey) {
+            ui.newLine();
+            if (providerInfo.apiKeyUrl) {
+                ui.info(`Get your API key at: ${ui.color(providerInfo.apiKeyUrl, 'cyan')}`);
+            }
+            ui.newLine();
+            // Retry loop: re-prompt on invalid key (up to 3 attempts)
+            const MAX_ATTEMPTS = 3;
+            let attempt = 0;
+            let validated = false;
+            while (attempt < MAX_ATTEMPTS) {
+                attempt++;
+                apiKey = await input({
+                    message: attempt === 1
+                        ? `Enter your ${providerInfo.displayName} API key`
+                        : `Enter your ${providerInfo.displayName} API key (attempt ${attempt}/${MAX_ATTEMPTS})`,
+                });
+                if (!apiKey) {
+                    ui.newLine();
+                    ui.warning('No API key entered. You can run "nimbus login" later to set up.');
+                    ui.newLine();
+                    return;
+                }
+                // Validate credentials
+                ui.newLine();
+                ui.startSpinner({ message: `Validating ${providerInfo.displayName} credentials...` });
+                let validation;
+                try {
+                    validation = await validateProviderApiKey(provider, apiKey, baseUrl);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    ui.stopSpinnerFail(`Validation error: ${msg}`);
+                    if (attempt < MAX_ATTEMPTS) {
+                        ui.warning('Please check your key and try again.');
+                        ui.newLine();
+                        continue;
+                    }
+                    ui.newLine();
+                    ui.info('You can retry with "nimbus login" or set the API key via environment variable.');
+                    ui.newLine();
+                    return;
+                }
+                if (!validation.valid) {
+                    ui.stopSpinnerFail(`Invalid key: ${validation.error}`);
+                    if (attempt < MAX_ATTEMPTS) {
+                        ui.warning('Please check your key and try again.');
+                        ui.newLine();
+                        continue;
+                    }
+                    ui.newLine();
+                    ui.info('You can retry with "nimbus login" or set the API key via environment variable:');
+                    if (providerInfo.envVarName) {
+                        ui.info(`  export ${providerInfo.envVarName}=your-key`);
+                    }
+                    ui.newLine();
+                    return;
+                }
+                ui.stopSpinnerSuccess(`${providerInfo.displayName} credentials verified!`);
+                validated = true;
+                break;
+            }
+            if (!validated) {
+                return;
+            }
+        }
+        else if (providerInfo.supportsBaseUrl) {
+            // Ollama — ask for base URL
+            ui.newLine();
+            baseUrl = await input({
+                message: 'Ollama server URL',
+                defaultValue: providerInfo.defaultBaseUrl || 'http://localhost:11434',
+            });
+        }
+        // Detect live infra stack from current directory (Terraform, K8s, Helm, etc.)
+        let detectedInfraStack = [];
+        try {
+            const { existsSync, readdirSync } = await import('node:fs');
+            const cwd = process.cwd();
+            const files = readdirSync(cwd);
+            if (files.some(f => f.endsWith('.tf') || f === 'terraform'))
+                detectedInfraStack.push('terraform');
+            if (files.some(f => f === 'Chart.yaml' || f === 'helmfile.yaml'))
+                detectedInfraStack.push('helm');
+            if (files.some(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
+                // Check if any yaml looks like K8s
+                const yamls = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml')).slice(0, 5);
+                for (const y of yamls) {
+                    try {
+                        const txt = require('node:fs').readFileSync(require('node:path').join(cwd, y), 'utf-8');
+                        if (txt.includes('apiVersion:') && txt.includes('kind:')) {
+                            detectedInfraStack.push('kubernetes');
+                            break;
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            if (existsSync(require('node:path').join(cwd, 'docker-compose.yaml')) || existsSync(require('node:path').join(cwd, 'docker-compose.yml')) || existsSync(require('node:path').join(cwd, 'Dockerfile'))) {
+                detectedInfraStack.push('docker');
+            }
+        }
+        catch { /* non-critical */ }
+        if (detectedInfraStack.length > 0) {
+            ui.newLine();
+            ui.print(ui.color(`Detected infrastructure: ${detectedInfraStack.join(', ')}`, 'green'));
+            ui.print(ui.dim('Nimbus will use this context to give better DevOps assistance.'));
+        }
+        // C5: Cloud provider selection step
+        let primaryClouds = [];
+        try {
+            const cloudInput = await input({
+                message: 'Which cloud providers do you primarily use? (comma-separated: aws, gcp, azure, or none)',
+                defaultValue: 'none',
+            });
+            if (cloudInput && cloudInput.trim().toLowerCase() !== 'none') {
+                primaryClouds = cloudInput
+                    .split(',')
+                    .map((s) => s.trim().toLowerCase())
+                    .filter((s) => ['aws', 'gcp', 'azure'].includes(s));
+            }
+        }
+        catch { /* non-critical — prompt may fail in non-interactive environments */ }
+        // Save credentials
+        const defaultModel = getDefaultModel(provider);
+        store.setProvider(provider, {
+            apiKey,
+            baseUrl,
+            model: defaultModel,
+            isDefault: true,
+            validatedAt: new Date().toISOString(),
+        });
+        // Create default config.yaml if it doesn't exist
+        try {
+            const { configManager } = await import('../config/manager');
+            if (!configManager.exists()) {
+                configManager.save();
+            }
+        }
+        catch {
+            /* non-critical */
+        }
+        // C5: Save primaryClouds to ~/.nimbus/config.json
+        if (primaryClouds.length > 0) {
+            try {
+                const { existsSync, readFileSync, writeFileSync, mkdirSync } = await import('node:fs');
+                const { join } = await import('node:path');
+                const { homedir } = await import('node:os');
+                const configJsonPath = join(homedir(), '.nimbus', 'config.json');
+                mkdirSync(join(homedir(), '.nimbus'), { recursive: true });
+                let configData = {};
+                if (existsSync(configJsonPath)) {
+                    try {
+                        configData = JSON.parse(readFileSync(configJsonPath, 'utf-8'));
+                    }
+                    catch { /* start fresh */ }
+                }
+                configData.primaryClouds = primaryClouds;
+                writeFileSync(configJsonPath, JSON.stringify(configData, null, 2), 'utf-8');
+            }
+            catch { /* non-critical */ }
+        }
+        // Success message
+        ui.newLine();
+        ui.box({
+            title: 'Setup Complete',
+            content: [
+                `Provider: ${providerInfo.displayName}`,
+                `Model:    ${defaultModel}`,
+                '',
+                "You're ready to go! Starting interactive chat...",
+            ],
+            style: 'rounded',
+            borderColor: 'green',
+            titleColor: 'brightGreen',
+            padding: 1,
+        });
+        // G3: DevOps context wizard — offer to run nimbus init after LLM setup
+        try {
+            const devopsSetup = await select({
+                message: 'Would you like to set up your DevOps context now? (recommended)',
+                options: [
+                    { label: 'Yes, detect my infrastructure', value: 'yes' },
+                    { label: 'No, I\'ll run nimbus init later', value: 'no' },
+                ],
+            });
+            if (devopsSetup === 'yes') {
+                ui.newLine();
+                ui.startSpinner({ message: 'Detecting infrastructure context...' });
+                try {
+                    const { runInit } = await import('../cli/init');
+                    await runInit({ cwd: process.cwd(), quiet: false });
+                    ui.stopSpinnerSuccess('NIMBUS.md generated — your infra context is ready');
+                }
+                catch (initErr) {
+                    ui.stopSpinnerFail('Could not generate NIMBUS.md (run `nimbus init` manually)');
+                }
+            }
+        }
+        catch { /* non-critical — prompt may fail in non-interactive environments */ }
+        // GAP-4: Offer to install shell completions with clear success/failure feedback
+        try {
+            ui.newLine();
+            const installCompletions = await select({
+                message: 'Install shell completions for nimbus? (adds tab completion)',
+                options: [
+                    { label: 'Yes, install completions', value: 'yes' },
+                    { label: 'No, skip', value: 'no' },
+                ],
+            });
+            if (installCompletions === 'yes') {
+                try {
+                    const { completionsCommand } = await import('./completions');
+                    await completionsCommand('install');
+                    ui.success('Shell completions installed successfully!');
+                    // Write marker file so nimbus can detect first-run tip
+                    try {
+                        const { mkdirSync, writeFileSync } = await import('node:fs');
+                        const { join } = await import('node:path');
+                        const { homedir } = await import('node:os');
+                        mkdirSync(join(homedir(), '.nimbus'), { recursive: true });
+                        writeFileSync(join(homedir(), '.nimbus', 'completions-installed'), '1', 'utf-8');
+                    }
+                    catch { /* non-critical */ }
+                }
+                catch (completionErr) {
+                    const shell = process.env.SHELL ?? '';
+                    ui.warning(`Could not auto-install completions: ${completionErr instanceof Error ? completionErr.message : String(completionErr)}`);
+                    if (/zsh/.test(shell)) {
+                        ui.print(ui.dim('  Manual install: nimbus completions install'));
+                        ui.print(ui.dim('  Then add to ~/.zshrc: fpath=(~/.zsh/completions $fpath) && autoload -U compinit && compinit'));
+                    }
+                    else if (/bash/.test(shell)) {
+                        ui.print(ui.dim('  Manual install: nimbus completions install'));
+                    }
+                    else {
+                        ui.print(ui.dim('  Manual install: nimbus completions install'));
+                    }
+                }
+            }
+        }
+        catch { /* non-critical — prompt may fail in non-interactive environments */ }
+        // C3/H1: Optional CI/CD and monitoring env vars
+        ui.newLine();
+        ui.print(ui.dim('Optional: Set these env vars for full DevOps integration:'));
+        ui.print(ui.dim('  GITLAB_TOKEN=<token>          # GitLab CI pipeline access'));
+        ui.print(ui.dim('  CIRCLECI_TOKEN=<token>        # CircleCI pipeline access'));
+        ui.print(ui.dim('  PROMETHEUS_URL=<url>          # Prometheus metrics queries'));
+        ui.print(ui.dim('  GRAFANA_URL=<url>             # Grafana dashboard access'));
+        ui.print(ui.dim('  GRAFANA_TOKEN=<token>         # Grafana API token'));
+        ui.print(ui.dim('  DD_API_KEY=<key>              # Datadog metrics/alerts'));
+        ui.print(ui.dim('  PD_API_KEY=<key>              # PagerDuty incident management (Gap 5)'));
+        ui.print(ui.dim('  OPSGENIE_API_KEY=<key>        # Opsgenie alert management (Gap 5)'));
+        ui.print(ui.dim('  BRAVE_API_KEY=<key>           # Enhanced web search'));
+        ui.newLine();
+    }
+    catch (err) {
+        // Catch-all for prompt failures (stdin closed, terminal not supported, etc.)
+        const msg = err instanceof Error ? err.message : String(err);
+        ui.newLine();
+        ui.warning(`Onboarding wizard failed: ${msg}`);
+        ui.newLine();
+        ui.info('Set up manually with "nimbus login" or via environment variables:');
+        ui.print('  export ANTHROPIC_API_KEY=sk-ant-...');
+        ui.print('  export OPENAI_API_KEY=sk-...');
+        ui.newLine();
+    }
+}