@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/commands/logs.ts

@@ -0,0 +1,167 @@
+/**
+ * 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';
+
+export interface LogsOptions {
+  namespace?: string;
+  follow?: boolean;
+  previous?: boolean;
+  tail?: number;
+  analyze?: boolean;
+  container?: string;
+  context?: string;
+  quiet?: boolean;
+}
+
+/**
+ * Build the kubectl logs argument array.
+ */
+function buildArgs(pod: string, options: LogsOptions): string[] {
+  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: string, options: LogsOptions = {}): Promise<void> {
+  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: any) {
+      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<void>((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: any) {
+    ui.error(`kubectl logs failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Parse `nimbus logs <pod> [options]` arguments.
+ */
+export function parseLogsArgs(args: string[]): { pod: string; options: LogsOptions } {
+  let pod = '';
+  const options: LogsOptions = {};
+
+  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/src/commands/onboarding.ts

@@ -79,15 +79,20 @@ export async function onboardingCommand(options: OnboardingOptions = {}): Promis
   }
 
   try {
-    // Welcome banner
+    // Welcome banner — DevOps-first identity
     ui.newLine();
     ui.box({
-      title: 'Welcome to Nimbus',
+      title: 'Welcome to Nimbus — AI-Powered DevOps Terminal',
       content: [
-        'AI-Powered Cloud Engineering Agent',
+        'Plan, apply, and manage Terraform, Kubernetes, Helm,',
+        'AWS, GCP, and Azure using natural language.',
         '',
-        "Let's get you set up with an LLM provider.",
-        'This takes about 30 seconds.',
+        "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',
@@ -96,6 +101,15 @@ export async function onboardingCommand(options: OnboardingOptions = {}): Promis
     });
     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,
@@ -129,14 +143,71 @@ export async function onboardingCommand(options: OnboardingOptions = {}): Promis
       }
       ui.newLine();
 
-      apiKey = await input({
-        message: `Enter your ${providerInfo.displayName} API key`,
-      });
+      // Retry loop: re-prompt on invalid key (up to 3 attempts)
+      const MAX_ATTEMPTS = 3;
+      let attempt = 0;
+      let validated = false;
 
-      if (!apiKey) {
-        ui.newLine();
-        ui.warning('No API key entered. You can run "nimbus login" later to set up.');
+      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: { 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}`);
+          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) {
@@ -148,34 +219,49 @@ export async function onboardingCommand(options: OnboardingOptions = {}): Promis
       });
     }
 
-    // Validate credentials
-    ui.newLine();
-    ui.startSpinner({ message: `Validating ${providerInfo.displayName} credentials...` });
-
-    let validation: { valid: boolean; error?: string };
+    // Detect live infra stack from current directory (Terraform, K8s, Helm, etc.)
+    let detectedInfraStack: 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`);
+      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();
-      return;
+      ui.print(ui.color(`Detected infrastructure: ${detectedInfraStack.join(', ')}`, 'green'));
+      ui.print(ui.dim('Nimbus will use this context to give better DevOps assistance.'));
     }
 
-    ui.stopSpinnerSuccess(`${providerInfo.displayName} credentials verified!`);
+    // C5: Cloud provider selection step
+    let primaryClouds: string[] = [];
+    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: string) => s.trim().toLowerCase())
+          .filter((s: string) => ['aws', 'gcp', 'azure'].includes(s));
+      }
+    } catch { /* non-critical — prompt may fail in non-interactive environments */ }
 
     // Save credentials
     const defaultModel = getDefaultModel(provider);
@@ -198,6 +284,25 @@ export async function onboardingCommand(options: OnboardingOptions = {}): Promis
       /* 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: Record<string, unknown> = {};
+        if (existsSync(configJsonPath)) {
+          try {
+            configData = JSON.parse(readFileSync(configJsonPath, 'utf-8')) as Record<string, unknown>;
+          } catch { /* start fresh */ }
+        }
+        configData.primaryClouds = primaryClouds;
+        writeFileSync(configJsonPath, JSON.stringify(configData, null, 2), 'utf-8');
+      } catch { /* non-critical */ }
+    }
+
     // Success message
     ui.newLine();
     ui.box({
@@ -213,6 +318,78 @@ export async function onboardingCommand(options: OnboardingOptions = {}): Promis
       titleColor: 'brightGreen',
       padding: 1,
     });
+    // G3: DevOps context wizard — offer to run nimbus init after LLM setup
+    try {
+      const devopsSetup = await select<string>({
+        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<string>({
+        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: unknown) {
     // Catch-all for prompt failures (stdin closed, terminal not supported, etc.)

package/src/commands/pipeline.ts

@@ -0,0 +1,186 @@
+/**
+ * Pipeline Command — H2
+ *
+ * View CI/CD pipeline status from GitHub Actions, GitLab CI, or CircleCI.
+ *
+ * Usage:
+ *   nimbus pipeline status [run-id]
+ *   nimbus pipeline status --provider github --limit 10
+ */
+
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ui } from '../wizard/ui';
+
+export interface PipelineOptions {
+  provider?: 'github' | 'gitlab' | 'circleci' | 'auto';
+  format?: 'table' | 'json';
+  limit?: number;
+}
+
+/**
+ * Auto-detect the CI/CD provider by scanning the cwd for config files.
+ */
+export function detectProvider(cwd: string = process.cwd()): 'github' | 'gitlab' | 'circleci' | null {
+  if (fs.existsSync(path.join(cwd, '.github', 'workflows'))) return 'github';
+  if (fs.existsSync(path.join(cwd, '.gitlab-ci.yml'))) return 'gitlab';
+  if (fs.existsSync(path.join(cwd, '.circleci', 'config.yml'))) return 'circleci';
+  return null;
+}
+
+interface PipelineRun {
+  id: string;
+  workflow: string;
+  status: string;
+  result: string;
+  started: string;
+  url?: string;
+}
+
+function fetchGitHubRuns(limit: number, runId?: string): PipelineRun[] {
+  if (runId) {
+    const raw = execFileSync(
+      'gh',
+      ['run', 'view', runId, '--json', 'status,conclusion,name,createdAt,url,databaseId'],
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    const r = JSON.parse(raw);
+    return [{
+      id: String(r.databaseId ?? runId),
+      workflow: r.name ?? '',
+      status: r.status ?? '',
+      result: r.conclusion ?? '-',
+      started: r.createdAt ?? '',
+      url: r.url,
+    }];
+  }
+  const raw = execFileSync(
+    'gh',
+    ['run', 'list', '--limit', String(limit), '--json', 'status,conclusion,name,createdAt,databaseId'],
+    { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+  const runs = JSON.parse(raw) as Array<Record<string, unknown>>;
+  return runs.map(r => ({
+    id: String(r['databaseId'] ?? ''),
+    workflow: String(r['name'] ?? ''),
+    status: String(r['status'] ?? ''),
+    result: String(r['conclusion'] ?? '-'),
+    started: String(r['createdAt'] ?? ''),
+  }));
+}
+
+function fetchGitLabRuns(limit: number): PipelineRun[] {
+  const raw = execFileSync(
+    'glab',
+    ['ci', 'list', '--format', 'json'],
+    { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+  const pipelines = JSON.parse(raw) as Array<Record<string, unknown>>;
+  return pipelines.slice(0, limit).map(p => ({
+    id: String(p['id'] ?? ''),
+    workflow: String(p['ref'] ?? ''),
+    status: String(p['status'] ?? ''),
+    result: String(p['status'] ?? '-'),
+    started: String(p['created_at'] ?? ''),
+    url: String(p['web_url'] ?? ''),
+  }));
+}
+
+function fetchCircleCIRuns(): PipelineRun[] {
+  const raw = execFileSync(
+    'circleci',
+    ['pipeline', 'list'],
+    { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+  // CircleCI CLI output is not always JSON; do best-effort parse
+  try {
+    const pipelines = JSON.parse(raw) as Array<Record<string, unknown>>;
+    return pipelines.map(p => ({
+      id: String(p['id'] ?? ''),
+      workflow: String(p['vcs'] ?? ''),
+      status: String(p['state'] ?? ''),
+      result: String(p['state'] ?? '-'),
+      started: String(p['created_at'] ?? ''),
+    }));
+  } catch {
+    return [{ id: '-', workflow: '-', status: raw.trim().slice(0, 40), result: '-', started: '-' }];
+  }
+}
+
+function printTable(runs: PipelineRun[]): void {
+  const COL = { id: 12, workflow: 30, status: 12, result: 12, started: 22 };
+  const pad = (s: string, n: number) => s.slice(0, n).padEnd(n);
+  const divider = `${'-'.repeat(COL.id + 2)}+${'-'.repeat(COL.workflow + 2)}+${'-'.repeat(COL.status + 2)}+${'-'.repeat(COL.result + 2)}+${'-'.repeat(COL.started + 2)}`;
+  console.log(divider);
+  console.log(`| ${pad('ID', COL.id)} | ${pad('Workflow', COL.workflow)} | ${pad('Status', COL.status)} | ${pad('Result', COL.result)} | ${pad('Started', COL.started)} |`);
+  console.log(divider);
+  for (const r of runs) {
+    console.log(`| ${pad(r.id, COL.id)} | ${pad(r.workflow, COL.workflow)} | ${pad(r.status, COL.status)} | ${pad(r.result, COL.result)} | ${pad(r.started, COL.started)} |`);
+  }
+  console.log(divider);
+}
+
+/**
+ * Main pipeline command dispatcher.
+ */
+export async function pipelineCommand(subcommand: string, args: string[]): Promise<void> {
+  const options: PipelineOptions = { format: 'table', limit: 10 };
+  let runId: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--provider' && args[i + 1]) {
+      options.provider = args[++i] as PipelineOptions['provider'];
+    } else if (arg === '--format' && args[i + 1]) {
+      options.format = args[++i] as 'table' | 'json';
+    } else if (arg === '--limit' && args[i + 1]) {
+      options.limit = parseInt(args[++i], 10);
+    } else if (arg === '--json') {
+      options.format = 'json';
+    } else if (!arg.startsWith('-') && !runId && subcommand === 'status') {
+      runId = arg;
+    }
+  }
+
+  const provider =
+    options.provider === 'auto' || !options.provider
+      ? detectProvider()
+      : options.provider;
+
+  if (!provider) {
+    ui.error('Could not detect CI/CD provider. Use --provider github|gitlab|circleci or run in a repo with CI config.');
+    process.exit(1);
+  }
+
+  let runs: PipelineRun[];
+  try {
+    if (provider === 'github') {
+      runs = fetchGitHubRuns(options.limit ?? 10, runId);
+    } else if (provider === 'gitlab') {
+      runs = fetchGitLabRuns(options.limit ?? 10);
+    } else {
+      runs = fetchCircleCIRuns();
+    }
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      const installHints: Record<string, string> = {
+        github: 'Install GitHub CLI: https://cli.github.com',
+        gitlab: 'Install GitLab CLI: https://gitlab.com/gitlab-org/cli',
+        circleci: 'Install CircleCI CLI: https://circleci.com/docs/local-cli/',
+      };
+      ui.error(`CLI not found for provider "${provider}". ${installHints[provider] ?? ''}`);
+    } else {
+      ui.error(`Failed to fetch pipeline status: ${error.message}`);
+    }
+    process.exit(1);
+  }
+
+  if (options.format === 'json') {
+    console.log(JSON.stringify(runs, null, 2));
+    return;
+  }
+
+  ui.header(`Pipeline Status (${provider})`);
+  printTable(runs);
+}