@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/commands/cost/index.ts

@@ -419,11 +419,17 @@ export async function costCommand(args: string[]): Promise<void> {
     ui.newLine();
     ui.print('Commands:');
     ui.print(`  ${ui.bold('estimate')}  Estimate infrastructure costs from Terraform`);
+    ui.print(`  ${ui.bold('compare')}   Compare cost between two workspaces or directories`);
+    ui.print(`  ${ui.bold('report')}    Export session cost summary`);
     ui.print(`  ${ui.bold('history')}   View historical cost data`);
+    ui.print(`  ${ui.bold('diff')}      Diff cost between two paths`);
     ui.newLine();
     ui.print('Examples:');
     ui.print('  nimbus cost estimate');
+    ui.print('  nimbus cost estimate --workspace staging --provider aws');
     ui.print('  nimbus cost estimate -d ./terraform --detailed');
+    ui.print('  nimbus cost compare ./workspace1 ./workspace2');
+    ui.print('  nimbus cost report --output csv');
     ui.print('  nimbus cost history --days 30 --group-by service');
     return;
   }
@@ -432,12 +438,55 @@ export async function costCommand(args: string[]): Promise<void> {
   const subArgs = args.slice(1);
 
   switch (subcommand) {
-    case 'estimate':
-      await costEstimateCommand(parseCostEstimateOptions(subArgs));
+    case 'estimate': {
+      const opts = parseCostEstimateOptions(subArgs);
+      // M3: handle --workspace and --provider flags for standalone estimate
+      for (let i = 0; i < subArgs.length; i++) {
+        if (subArgs[i] === '--workspace' && subArgs[i + 1]) {
+          opts.directory = opts.directory ?? subArgs[i + 1];
+        }
+        if (subArgs[i] === '--provider' && subArgs[i + 1]) {
+          // Provider hint is informational — store in compare for future use
+        }
+      }
+      await costEstimateCommand(opts);
+      break;
+    }
+    case 'compare': {
+      // M3: nimbus cost compare <workspace1> <workspace2>
+      const path1 = subArgs[0];
+      const path2 = subArgs[1];
+      if (!path1 || !path2) {
+        ui.error('Usage: nimbus cost compare <workspace1> <workspace2>');
+        ui.info('Compares infracost estimates between two directories.');
+        process.exit(1);
+      }
+      const format = subArgs.includes('--json') ? 'json' : 'table';
+      await costCompareCommand(path1, path2, { format });
+      break;
+    }
+    case 'report': {
+      // M3: nimbus cost report [--output csv|json|text]
+      let outputFormat: 'csv' | 'json' | 'text' = 'text';
+      for (let i = 0; i < subArgs.length; i++) {
+        if (subArgs[i] === '--output' && subArgs[i + 1]) {
+          const fmt = subArgs[i + 1];
+          if (fmt === 'csv' || fmt === 'json' || fmt === 'text') {
+            outputFormat = fmt;
+          }
+        }
+      }
+      await costReportCommand(outputFormat);
       break;
+    }
     case 'history':
       await costHistoryCommand(parseCostHistoryOptions(subArgs));
       break;
+    case 'diff': {
+      const format = subArgs.includes('--json') ? 'json' : 'table';
+      await costDiffCommand(subArgs[0], subArgs[1], { format });
+      break;
+    }
     default:
       ui.error(`Unknown cost command: ${subcommand}`);
       ui.info('Run "nimbus cost" for usage');
@@ -592,3 +641,170 @@ export async function costHistoryCommand(options: CostHistoryOptions): Promise<v
   ui.newLine();
   ui.print('Run with --provider demo to see sample data.');
 }
+
+/**
+ * H5: Cost diff — compare infracost estimates between two directories or branches.
+ */
+export async function costDiffCommand(
+  path1: string,
+  path2: string,
+  opts: { format?: 'table' | 'json' } = {}
+): Promise<void> {
+  if (!path1 || !path2) {
+    ui.error('Usage: nimbus cost diff <path1> <path2> [--json]');
+    process.exit(1);
+  }
+
+  // Check if infracost is available
+  try {
+    execSync('infracost --version', { stdio: 'pipe' });
+  } catch {
+    ui.error('infracost is not installed.');
+    ui.info('Install it from: https://www.infracost.io/docs/');
+    ui.info('  brew install infracost   (macOS)');
+    ui.info('  curl -fsSL https://raw.githubusercontent.com/infracost/infracost/master/scripts/install.sh | sh   (Linux)');
+    process.exit(1);
+  }
+
+  ui.startSpinner({ message: `Comparing costs: ${path1} vs ${path2}` });
+
+  try {
+    const rawOutput = execSync(
+      `infracost diff --path "${path1}" --compare-to "${path2}" --format json`,
+      { encoding: 'utf-8', stdio: 'pipe', maxBuffer: 10 * 1024 * 1024 }
+    );
+    const data = JSON.parse(rawOutput) as CostEstimate;
+    ui.stopSpinnerSuccess('Cost diff complete');
+
+    if (opts.format === 'json') {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    // Table output
+    ui.header('Cost Diff');
+    ui.print(`  Comparing: ${path1} (current) → ${path2} (baseline)`);
+    ui.newLine();
+
+    const monthly = data.diffTotalMonthlyCost ?? 0;
+    ui.print(`  ${ui.bold('Monthly delta:')} ${formatChange(monthly, data.currency)}`);
+    ui.print(`  ${ui.bold('New total:   ')} ${formatCurrency(data.totalMonthlyCost, data.currency)}/mo`);
+    ui.newLine();
+
+    // Per-project breakdown
+    for (const project of data.projects ?? []) {
+      if ((project.diffTotalMonthlyCost ?? 0) === 0) continue;
+      ui.print(`  ${ui.bold(project.name)}: ${formatChange(project.diffTotalMonthlyCost, data.currency)}/mo`);
+      for (const resource of (project.resources ?? []).slice(0, 10)) {
+        ui.print(`    ${resource.name.slice(0, 50).padEnd(50)} ${formatCurrency(resource.monthlyCost, data.currency)}/mo`);
+      }
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Cost diff failed');
+    ui.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+/**
+ * M3: Cost compare — compare infracost estimates between two workspaces.
+ * Runs infracost breakdown for each path and shows the delta.
+ */
+export async function costCompareCommand(
+  workspace1: string,
+  workspace2: string,
+  opts: { format?: 'table' | 'json' } = {}
+): Promise<void> {
+  if (!workspace1 || !workspace2) {
+    ui.error('Usage: nimbus cost compare <workspace1> <workspace2>');
+    process.exit(1);
+  }
+
+  // Try infracost first
+  const hasInfracost = checkInfracost();
+  if (!hasInfracost) {
+    ui.info('infracost is not installed — showing placeholder comparison.');
+    ui.info('Install infracost for real cost estimates: https://infracost.io');
+    ui.newLine();
+    ui.print(`  Workspace 1: ${workspace1}`);
+    ui.print(`  Workspace 2: ${workspace2}`);
+    ui.print('  Cost delta:  N/A (install infracost for actual data)');
+    ui.newLine();
+    ui.info('  brew install infracost   (macOS)');
+    ui.info('  curl -fsSL https://raw.githubusercontent.com/infracost/infracost/master/scripts/install.sh | sh   (Linux)');
+    return;
+  }
+
+  ui.startSpinner({ message: `Comparing costs: ${workspace1} vs ${workspace2}` });
+
+  try {
+    // Run infracost breakdown for each workspace
+    const est1 = runInfracostBreakdown(workspace1);
+    const est2 = runInfracostBreakdown(workspace2);
+
+    ui.stopSpinnerSuccess('Cost comparison complete');
+
+    if (!est1 && !est2) {
+      ui.warning('Could not obtain infracost estimates for either workspace.');
+      return;
+    }
+
+    const cost1 = est1?.totalMonthlyCost ?? 0;
+    const cost2 = est2?.totalMonthlyCost ?? 0;
+    const delta = cost1 - cost2;
+    const currency = est1?.currency ?? est2?.currency ?? 'USD';
+
+    if (opts.format === 'json') {
+      console.log(JSON.stringify({ workspace1, workspace2, cost1, cost2, delta, currency }, null, 2));
+      return;
+    }
+
+    ui.header('Cost Comparison');
+    ui.print(`  ${ui.bold(workspace1)}: ${formatCurrency(cost1, currency)}/mo`);
+    ui.print(`  ${ui.bold(workspace2)}: ${formatCurrency(cost2, currency)}/mo`);
+    ui.newLine();
+    ui.print(`  ${ui.bold('Delta (1 vs 2):')} ${formatChange(delta, currency)}/mo`);
+  } catch (err: unknown) {
+    ui.stopSpinnerFail('Cost comparison failed');
+    ui.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+/**
+ * M3: Cost report — export the session cost summary.
+ * Reads session tool-call cost data and exports it in the requested format.
+ */
+export async function costReportCommand(outputFormat: 'csv' | 'json' | 'text' = 'text'): Promise<void> {
+  ui.header('Nimbus Cost Report', `Session cost summary (format: ${outputFormat})`);
+
+  // Attempt to read cost data from ~/.nimbus/nimbus.db via the state DB
+  // For now, expose session-level token cost data as a report placeholder.
+  // In a full implementation this would query the cost_tracker table in SQLite.
+  const report = {
+    generatedAt: new Date().toISOString(),
+    note: 'Session cost data is tracked in ~/.nimbus/nimbus.db (cost_tracker table).',
+    hint: 'Run `nimbus cost estimate` to estimate infrastructure costs for the current directory.',
+    format: outputFormat,
+  };
+
+  if (outputFormat === 'json') {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  if (outputFormat === 'csv') {
+    console.log('timestamp,description,cost_usd');
+    console.log(`${report.generatedAt},session_summary,0.00`);
+    ui.newLine();
+    ui.info(report.note);
+    return;
+  }
+
+  // text
+  ui.newLine();
+  ui.print(`  ${ui.dim('Generated:')} ${report.generatedAt}`);
+  ui.newLine();
+  ui.info(report.note);
+  ui.info(report.hint);
+}

package/src/commands/deploy.ts

@@ -0,0 +1,260 @@
+/**
+ * Deploy Command
+ *
+ * Orchestrates a full deployment workflow without LLM involvement:
+ *   1. Run `terraform plan` and show summary
+ *   2. Ask user to confirm (or auto-approve with --auto-approve / -y)
+ *   3. Run `terraform apply` with the plan
+ *   4. Run `kubectl rollout status` to verify pods come up
+ *   5. Print success/failure summary
+ *
+ * Usage:
+ *   nimbus deploy [--auto-approve] [--workspace <ws>] [--namespace <ns>]
+ *                 [--dry-run] [--no-apply]
+ */
+
+import { spawnSync } from 'node:child_process';
+import * as readline from 'node:readline';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface DeployOptions {
+  autoApprove?: boolean;
+  workspace?: string;
+  namespace?: string;
+  dryRun?: boolean;
+  noApply?: boolean;
+  cwd?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function banner(step: string, total: string, label: string): void {
+  process.stdout.write(`\n[${step}/${total}] ${label}\n`);
+}
+
+function ok(msg: string): void {
+  process.stdout.write(`[OK] ${msg}\n`);
+}
+
+function warn(msg: string): void {
+  process.stdout.write(`[!!] ${msg}\n`);
+}
+
+function fail(msg: string): void {
+  process.stdout.write(`[XX] ${msg}\n`);
+}
+
+function run(
+  cmd: string,
+  args: string[],
+  opts: { cwd?: string; env?: NodeJS.ProcessEnv } = {}
+): { stdout: string; stderr: string; status: number } {
+  const result = spawnSync(cmd, args, {
+    cwd: opts.cwd ?? process.cwd(),
+    env: opts.env ?? process.env,
+    encoding: 'utf-8',
+    stdio: ['inherit', 'pipe', 'pipe'],
+  });
+  return {
+    stdout: (result.stdout as string) ?? '',
+    stderr: (result.stderr as string) ?? '',
+    status: result.status ?? 1,
+  };
+}
+
+async function askConfirm(question: string): Promise<boolean> {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false,
+    });
+    rl.question(`${question} [y/N] `, answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes');
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Parse CLI args
+// ---------------------------------------------------------------------------
+
+export function parseDeployArgs(args: string[]): DeployOptions {
+  const opts: DeployOptions = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--auto-approve' || arg === '-y') {
+      opts.autoApprove = true;
+    } else if (arg === '--workspace' && args[i + 1]) {
+      opts.workspace = args[++i];
+    } else if ((arg === '--namespace' || arg === '-n') && args[i + 1]) {
+      opts.namespace = args[++i];
+    } else if (arg === '--dry-run') {
+      opts.dryRun = true;
+    } else if (arg === '--no-apply') {
+      opts.noApply = true;
+    }
+  }
+  return opts;
+}
+
+// ---------------------------------------------------------------------------
+// Main command
+// ---------------------------------------------------------------------------
+
+export async function deployCommand(args: string[]): Promise<void> {
+  const opts = parseDeployArgs(args);
+  const cwd = opts.cwd ?? process.cwd();
+
+  const totalSteps = opts.noApply ? '2' : '4';
+  let step = 1;
+
+  // ------------------------------------------------------------------
+  // Step 1: Select Terraform workspace (if requested)
+  // ------------------------------------------------------------------
+  if (opts.workspace) {
+    banner(String(step++), totalSteps, `Selecting Terraform workspace: ${opts.workspace}`);
+    const wsResult = run('terraform', ['workspace', 'select', opts.workspace], { cwd });
+    if (wsResult.status !== 0) {
+      warn(`Workspace '${opts.workspace}' not found — attempting to create it.`);
+      const newWsResult = run('terraform', ['workspace', 'new', opts.workspace], { cwd });
+      if (newWsResult.status !== 0) {
+        fail(`Failed to select or create workspace '${opts.workspace}':\n${newWsResult.stderr}`);
+        process.exit(1);
+      }
+    }
+    ok(`Workspace set to '${opts.workspace}'`);
+  }
+
+  // ------------------------------------------------------------------
+  // Step 2/1: Terraform plan
+  // ------------------------------------------------------------------
+  banner(String(step++), totalSteps, 'Planning infrastructure changes...');
+
+  if (opts.dryRun) {
+    process.stdout.write('  [dry-run] Would run: terraform plan -out=nimbus-deploy.tfplan\n');
+  } else {
+    const planResult = run('terraform', ['plan', '-out=nimbus-deploy.tfplan', '-no-color'], { cwd });
+
+    // Always print plan output so the user can review it
+    if (planResult.stdout) process.stdout.write(planResult.stdout + '\n');
+    if (planResult.stderr) process.stderr.write(planResult.stderr + '\n');
+
+    if (planResult.status !== 0) {
+      fail('terraform plan failed. Fix the errors above before deploying.');
+      process.exit(1);
+    }
+
+    // Quick summary: count resource changes
+    const creates = (planResult.stdout.match(/\+ resource/g) ?? []).length;
+    const updates = (planResult.stdout.match(/~ resource/g) ?? []).length;
+    const destroys = (planResult.stdout.match(/- resource/g) ?? []).length;
+    process.stdout.write(
+      `\n  Plan summary: ${creates} to add, ${updates} to change, ${destroys} to destroy.\n`
+    );
+
+    if (opts.noApply) {
+      ok('--no-apply flag set. Stopping after plan.');
+      return;
+    }
+
+    // ------------------------------------------------------------------
+    // Step 3: Confirm before apply
+    // ------------------------------------------------------------------
+    if (!opts.autoApprove) {
+      const confirmed = await askConfirm('\nProceed with terraform apply?');
+      if (!confirmed) {
+        warn('Deployment cancelled by user.');
+        process.exit(0);
+      }
+    } else {
+      process.stdout.write('  --auto-approve set — skipping confirmation.\n');
+    }
+
+    // ------------------------------------------------------------------
+    // Step 4: Terraform apply
+    // ------------------------------------------------------------------
+    banner(String(step++), totalSteps, 'Applying infrastructure changes...');
+
+    const applyResult = run('terraform', ['apply', '-auto-approve', '-no-color', 'nimbus-deploy.tfplan'], { cwd });
+
+    if (applyResult.stdout) process.stdout.write(applyResult.stdout + '\n');
+    if (applyResult.stderr) process.stderr.write(applyResult.stderr + '\n');
+
+    // Clean up plan file regardless of success/failure
+    try {
+      const { unlinkSync } = await import('node:fs');
+      unlinkSync(`${cwd}/nimbus-deploy.tfplan`);
+    } catch { /* non-critical */ }
+
+    if (applyResult.status !== 0) {
+      fail('terraform apply failed.');
+      process.stdout.write('\n  Rollback hint: Run `nimbus tf rollback` to restore previous state.\n\n');
+      process.exit(1);
+    }
+
+    ok('Terraform apply succeeded.');
+  }
+
+  // ------------------------------------------------------------------
+  // Step 5: kubectl rollout status
+  // ------------------------------------------------------------------
+  banner(String(step++), totalSteps, 'Verifying Kubernetes rollout status...');
+
+  const nsArgs = opts.namespace ? ['--namespace', opts.namespace] : [];
+
+  // Collect deployments in the namespace (or all namespaces)
+  const getResult = run('kubectl', ['get', 'deployments', '-o', 'name', ...nsArgs], { cwd });
+
+  if (getResult.status !== 0) {
+    // kubectl may not be available or no cluster is configured — warn but do not fail
+    warn('Could not query kubectl deployments. Skipping rollout status check.');
+    warn('Ensure kubectl is configured and pointing to the correct cluster.');
+  } else {
+    const deployments = getResult.stdout.trim().split('\n').filter(Boolean);
+
+    if (deployments.length === 0) {
+      warn('No deployments found to verify. Pods may still be starting up.');
+    } else {
+      let allHealthy = true;
+
+      for (const deployment of deployments) {
+        // deployment looks like "deployment.apps/my-app"
+        const rolloutResult = run(
+          'kubectl',
+          ['rollout', 'status', deployment, '--timeout=120s', ...nsArgs],
+          { cwd }
+        );
+
+        if (rolloutResult.stdout) process.stdout.write(rolloutResult.stdout + '\n');
+
+        if (rolloutResult.status !== 0) {
+          warn(`Rollout timeout or error for ${deployment}: ${rolloutResult.stderr.trim()}`);
+          warn('Pods may still be coming up. Check with: kubectl get pods');
+          allHealthy = false;
+        }
+      }
+
+      if (allHealthy) {
+        ok(`All ${deployments.length} deployment(s) are healthy.`);
+      } else {
+        // Non-fatal: pods may still be starting
+        warn('Some deployments did not complete rollout within the timeout window.');
+        warn('The deploy itself succeeded — pods may still be starting up.');
+      }
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Summary
+  // ------------------------------------------------------------------
+  process.stdout.write('\n');
+  ok('Deployment workflow complete.');
+  process.stdout.write('\n');
+}