@build-astron-co/nimbus 0.2.0

package/src/commands/onboarding.ts

@@ -0,0 +1,228 @@
+/**
+ * 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 type { LLMProviderName } from '../auth/types';
+import { ui } from '../wizard/ui';
+import { select, input } from '../wizard/prompts';
+
+export interface OnboardingOptions {
+  /** Skip the wizard and exit immediately. */
+  skip?: boolean;
+}
+
+/**
+ * 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(): boolean {
+  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: OnboardingOptions = {}): Promise<void> {
+  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
+    ui.newLine();
+    ui.box({
+      title: 'Welcome to Nimbus',
+      content: [
+        'AI-Powered Cloud Engineering Agent',
+        '',
+        "Let's get you set up with an LLM provider.",
+        'This takes about 30 seconds.',
+      ],
+      style: 'rounded',
+      borderColor: 'cyan',
+      titleColor: 'brightCyan',
+      padding: 1,
+    });
+    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<LLMProviderName>({
+      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: string | undefined;
+    let baseUrl: string | undefined;
+
+    if (providerInfo.requiresApiKey) {
+      ui.newLine();
+      if (providerInfo.apiKeyUrl) {
+        ui.info(`Get your API key at: ${ui.color(providerInfo.apiKeyUrl, 'cyan')}`);
+      }
+      ui.newLine();
+
+      apiKey = await input({
+        message: `Enter your ${providerInfo.displayName} API key`,
+      });
+
+      if (!apiKey) {
+        ui.newLine();
+        ui.warning('No API key entered. You can run "nimbus login" later to set up.');
+        ui.newLine();
+        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',
+      });
+    }
+
+    // Validate credentials
+    ui.newLine();
+    ui.startSpinner({ message: `Validating ${providerInfo.displayName} credentials...` });
+
+    let validation: { valid: boolean; error?: string };
+    try {
+      validation = await validateProviderApiKey(provider, apiKey, baseUrl);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ui.stopSpinnerFail(`Validation error: ${msg}`);
+      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(`Validation failed: ${validation.error}`);
+      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!`);
+
+    // 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 */
+    }
+
+    // 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,
+    });
+    ui.newLine();
+  } catch (err: unknown) {
+    // 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();
+  }
+}

package/src/commands/plan/display.ts

@@ -0,0 +1,279 @@
+/**
+ * Plan Display Utilities
+ *
+ * Format and display plan output for different infrastructure types
+ */
+
+import { ui } from '../../wizard';
+
+/**
+ * Resource change in plan
+ */
+export interface ResourceChange {
+  action: string;
+  resource: string;
+  address: string;
+  before?: Record<string, unknown>;
+  after?: Record<string, unknown>;
+}
+
+/**
+ * Plan result structure
+ */
+export interface PlanResult {
+  type: 'terraform' | 'k8s' | 'helm';
+  success: boolean;
+  error?: string;
+  changes?: {
+    add: number;
+    change: number;
+    destroy: number;
+  };
+  resources?: ResourceChange[];
+  raw?: string;
+}
+
+/**
+ * Action symbols for display
+ */
+const ACTION_SYMBOLS: Record<
+  string,
+  { symbol: string; color: 'green' | 'yellow' | 'red' | 'blue' | 'cyan' }
+> = {
+  create: { symbol: '+', color: 'green' },
+  add: { symbol: '+', color: 'green' },
+  apply: { symbol: '~', color: 'cyan' },
+  update: { symbol: '~', color: 'yellow' },
+  change: { symbol: '~', color: 'yellow' },
+  delete: { symbol: '-', color: 'red' },
+  destroy: { symbol: '-', color: 'red' },
+  read: { symbol: '<=', color: 'blue' },
+  'no-op': { symbol: ' ', color: 'blue' },
+};
+
+/**
+ * Format action for display
+ */
+function formatAction(action: string): string {
+  const config = ACTION_SYMBOLS[action.toLowerCase()] || { symbol: '?', color: 'yellow' as const };
+  return ui.color(config.symbol, config.color);
+}
+
+/**
+ * Format resource for display
+ */
+function formatResource(resource: string): string {
+  return resource;
+}
+
+/**
+ * Display plan summary
+ */
+function displaySummary(changes: { add: number; change: number; destroy: number }): void {
+  ui.print('Plan Summary:');
+  ui.newLine();
+
+  const { add, change, destroy } = changes;
+  const total = add + change + destroy;
+
+  if (total === 0) {
+    ui.print('  No changes. Infrastructure is up to date.');
+    return;
+  }
+
+  if (add > 0) {
+    ui.print(`  ${ui.color(`+ ${add} to add`, 'green')}`);
+  }
+  if (change > 0) {
+    ui.print(`  ${ui.color(`~ ${change} to change`, 'yellow')}`);
+  }
+  if (destroy > 0) {
+    ui.print(`  ${ui.color(`- ${destroy} to destroy`, 'red')}`);
+  }
+
+  ui.newLine();
+  ui.print(`  Total: ${total} resource(s)`);
+}
+
+/**
+ * Display resource changes
+ */
+function displayResources(resources: ResourceChange[]): void {
+  if (!resources || resources.length === 0) {
+    return;
+  }
+
+  ui.newLine();
+  ui.print('Resource Changes:');
+  ui.newLine();
+
+  // Group by action
+  const grouped: Record<string, ResourceChange[]> = {};
+
+  for (const resource of resources) {
+    const action = resource.action.toLowerCase();
+    if (!grouped[action]) {
+      grouped[action] = [];
+    }
+    grouped[action].push(resource);
+  }
+
+  // Display in order: create, update, delete, other
+  const order = ['create', 'add', 'update', 'change', 'apply', 'delete', 'destroy', 'read'];
+
+  for (const action of order) {
+    const items = grouped[action];
+    if (!items || items.length === 0) {
+      continue;
+    }
+
+    for (const item of items) {
+      const symbol = formatAction(item.action);
+      const resource = formatResource(item.resource);
+      ui.print(`  ${symbol} ${resource}`);
+
+      // Show address if different from resource name
+      if (item.address && item.address !== item.resource) {
+        ui.print(`      ${ui.dim(item.address)}`);
+      }
+    }
+  }
+
+  // Display any remaining actions not in order
+  for (const [action, items] of Object.entries(grouped)) {
+    if (order.includes(action)) {
+      continue;
+    }
+
+    for (const item of items) {
+      const symbol = formatAction(item.action);
+      const resource = formatResource(item.resource);
+      ui.print(`  ${symbol} ${resource}`);
+    }
+  }
+}
+
+/**
+ * Display raw plan output (detailed mode)
+ */
+function displayRawPlan(raw: string): void {
+  ui.newLine();
+  ui.print('Detailed Plan:');
+  ui.newLine();
+
+  // Limit output length
+  const maxLength = 5000;
+  if (raw.length > maxLength) {
+    ui.print(raw.slice(0, maxLength));
+    ui.newLine();
+    ui.print(ui.dim(`... (output truncated, ${raw.length - maxLength} more characters)`));
+  } else {
+    ui.print(raw);
+  }
+}
+
+/**
+ * Display Terraform-specific plan
+ */
+function displayTerraformPlan(plan: PlanResult, detailed: boolean): void {
+  if (plan.changes) {
+    displaySummary(plan.changes);
+  }
+
+  if (plan.resources && plan.resources.length > 0) {
+    displayResources(plan.resources);
+  }
+
+  if (detailed && plan.raw) {
+    displayRawPlan(plan.raw);
+  }
+
+  // Show next steps
+  ui.newLine();
+  ui.print('Next steps:');
+  ui.print('  - Review the changes above');
+  ui.print('  - Run "nimbus apply terraform" to apply');
+  ui.print('  - Or run "nimbus tf apply" for more options');
+}
+
+/**
+ * Display Kubernetes-specific plan
+ */
+function displayK8sPlan(plan: PlanResult, detailed: boolean): void {
+  if (plan.changes) {
+    ui.print('Plan Summary:');
+    ui.newLine();
+    ui.print(`  ${ui.color(`${plan.changes.add} resource(s) to apply`, 'cyan')}`);
+    if (plan.changes.change > 0) {
+      ui.print(`  ${ui.color(`${plan.changes.change} resource(s) will be updated`, 'yellow')}`);
+    }
+    ui.newLine();
+    ui.info("Note: Kubernetes apply is idempotent - unchanged resources won't be modified");
+  }
+
+  if (plan.resources && plan.resources.length > 0) {
+    displayResources(plan.resources);
+  }
+
+  if (detailed && plan.raw) {
+    displayRawPlan(plan.raw);
+  }
+
+  // Show next steps
+  ui.newLine();
+  ui.print('Next steps:');
+  ui.print('  - Review the resources above');
+  ui.print('  - Run "nimbus apply k8s" to apply');
+  ui.print('  - Or run "nimbus k8s apply" for more options');
+}
+
+/**
+ * Display Helm-specific plan
+ */
+function displayHelmPlan(plan: PlanResult, detailed: boolean): void {
+  if (plan.changes) {
+    ui.print('Plan Summary:');
+    ui.newLine();
+    if (plan.changes.add > 0) {
+      ui.print(`  ${ui.color(`+ ${plan.changes.add} resource(s) to create`, 'green')}`);
+    }
+    if (plan.changes.change > 0) {
+      ui.print(`  ${ui.color(`~ ${plan.changes.change} resource(s) to update`, 'yellow')}`);
+    }
+    if (plan.changes.destroy > 0) {
+      ui.print(`  ${ui.color(`- ${plan.changes.destroy} resource(s) to remove`, 'red')}`);
+    }
+  }
+
+  if (plan.resources && plan.resources.length > 0) {
+    displayResources(plan.resources);
+  }
+
+  if (detailed && plan.raw) {
+    displayRawPlan(plan.raw);
+  }
+
+  // Show next steps
+  ui.newLine();
+  ui.print('Next steps:');
+  ui.print('  - Review the changes above');
+  ui.print('  - Run "nimbus apply helm" to install/upgrade');
+  ui.print('  - Or run "nimbus helm install/upgrade" for more options');
+}
+
+/**
+ * Display plan result
+ */
+export function displayPlan(plan: PlanResult, detailed = false): void {
+  switch (plan.type) {
+    case 'terraform':
+      displayTerraformPlan(plan, detailed);
+      break;
+    case 'k8s':
+      displayK8sPlan(plan, detailed);
+      break;
+    case 'helm':
+      displayHelmPlan(plan, detailed);
+      break;
+  }
+}