pyre-cli 9.5.1 → 10.0.0

package/src/anomalies.ts

@@ -18,84 +18,138 @@ export interface AnomalyAlert {
 
 const ZSCORE_THRESHOLD = 2.5;
 const CRITICAL_ZSCORE = 3.5;
-const MIN_SAMPLES = 5;
+const MIN_SAMPLES = 10;
+
+// Minimum absolute deviation from the mean required to trigger an anomaly
+const MIN_DEV_CPU = 10; // 10%
+const MIN_DEV_MEM = 5; // 5%
+const MIN_DEV_TEMP = 5; // 5 degrees
+const MIN_DEV_NET = 500_000; // 500 KB
+const MIN_DEV_POWER = 5; // 5 Watts
+const MIN_DEV_GPU = 10; // 10%
 
 export function detectAnomalies(data: StatsData, history: History): AnomalyAlert[] {
   const alerts: AnomalyAlert[] = [];
 
-  const cpuZ = History.zScore(data.cpu.usage, history.cpuUsage);
-  if (Math.abs(cpuZ) > ZSCORE_THRESHOLD && history.cpuUsage.length >= MIN_SAMPLES) {
-    alerts.push({
-      metric: 'CPU',
-      value: data.cpu.usage,
-      zScore: cpuZ,
-      severity: Math.abs(cpuZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
-    });
+  if (history.cpuUsage.length >= MIN_SAMPLES) {
+    const cpuMean = History.mean(history.cpuUsage);
+    if (Math.abs(data.cpu.usage - cpuMean) > MIN_DEV_CPU) {
+      const cpuZ = History.zScore(data.cpu.usage, history.cpuUsage);
+      if (Math.abs(cpuZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'CPU',
+          value: data.cpu.usage,
+          zScore: cpuZ,
+          severity: Math.abs(cpuZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
+    }
+  }
+
+  if (history.memUsage.length >= MIN_SAMPLES) {
+    const memMean = History.mean(history.memUsage);
+    if (Math.abs(data.memory.usagePercent - memMean) > MIN_DEV_MEM) {
+      const memZ = History.zScore(data.memory.usagePercent, history.memUsage);
+      if (Math.abs(memZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'Memory',
+          value: data.memory.usagePercent,
+          zScore: memZ,
+          severity: Math.abs(memZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
+    }
   }
 
-  const memZ = History.zScore(data.memory.usagePercent, history.memUsage);
-  if (Math.abs(memZ) > ZSCORE_THRESHOLD && history.memUsage.length >= MIN_SAMPLES) {
-    alerts.push({
-      metric: 'Memory',
-      value: data.memory.usagePercent,
-      zScore: memZ,
-      severity: Math.abs(memZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
-    });
+  if (data.cpu.temperature !== undefined && history.temp.length >= MIN_SAMPLES) {
+    const tempMean = History.mean(history.temp);
+    if (Math.abs(data.cpu.temperature - tempMean) > MIN_DEV_TEMP) {
+      const tempZ = History.zScore(data.cpu.temperature, history.temp);
+      if (Math.abs(tempZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'Temp',
+          value: data.cpu.temperature,
+          zScore: tempZ,
+          severity: Math.abs(tempZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
+    }
   }
 
-  if (data.cpu.temperature !== undefined) {
-    const tempZ = History.zScore(data.cpu.temperature, history.temp);
-    if (Math.abs(tempZ) > ZSCORE_THRESHOLD && history.temp.length >= MIN_SAMPLES) {
-      alerts.push({
-        metric: 'Temp',
-        value: data.cpu.temperature,
-        zScore: tempZ,
-        severity: Math.abs(tempZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
-      });
+  if (history.netRxRate.length >= MIN_SAMPLES) {
+    const currentRxRate = history.netRxRate[history.netRxRate.length - 1];
+    const netRxMean = History.mean(history.netRxRate);
+    if (Math.abs(currentRxRate - netRxMean) > MIN_DEV_NET) {
+      const netRxZ = History.zScore(currentRxRate, history.netRxRate);
+      if (Math.abs(netRxZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'Net RX',
+          value: currentRxRate,
+          zScore: netRxZ,
+          severity: Math.abs(netRxZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
     }
   }
 
-  const netRxZ = History.zScore(data.network.rxBytes, history.netRxRate);
-  if (Math.abs(netRxZ) > ZSCORE_THRESHOLD && history.netRxRate.length >= MIN_SAMPLES) {
-    alerts.push({
-      metric: 'Net RX',
-      value: data.network.rxBytes,
-      zScore: netRxZ,
-      severity: Math.abs(netRxZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
-    });
+  if (history.netTxRate.length >= MIN_SAMPLES) {
+    const currentTxRate = history.netTxRate[history.netTxRate.length - 1];
+    const netTxMean = History.mean(history.netTxRate);
+    if (Math.abs(currentTxRate - netTxMean) > MIN_DEV_NET) {
+      const netTxZ = History.zScore(currentTxRate, history.netTxRate);
+      if (Math.abs(netTxZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'Net TX',
+          value: currentTxRate,
+          zScore: netTxZ,
+          severity: Math.abs(netTxZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
+    }
   }
 
-  const netTxZ = History.zScore(data.network.txBytes, history.netTxRate);
-  if (Math.abs(netTxZ) > ZSCORE_THRESHOLD && history.netTxRate.length >= MIN_SAMPLES) {
-    alerts.push({
-      metric: 'Net TX',
-      value: data.network.txBytes,
-      zScore: netTxZ,
-      severity: Math.abs(netTxZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
-    });
+  if (data.power?.combinedWatts !== undefined && history.powerWatts.length >= MIN_SAMPLES) {
+    const powerMean = History.mean(history.powerWatts);
+    if (Math.abs(data.power.combinedWatts - powerMean) > MIN_DEV_POWER) {
+      const powerZ = History.zScore(data.power.combinedWatts, history.powerWatts);
+      if (Math.abs(powerZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'Power',
+          value: data.power.combinedWatts,
+          zScore: powerZ,
+          severity: Math.abs(powerZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
+    }
   }
 
-  if (data.power?.combinedWatts !== undefined) {
-    const powerZ = History.zScore(data.power.combinedWatts, history.powerWatts);
-    if (Math.abs(powerZ) > ZSCORE_THRESHOLD && history.powerWatts.length >= MIN_SAMPLES) {
-      alerts.push({
-        metric: 'Power',
-        value: data.power.combinedWatts,
-        zScore: powerZ,
-        severity: Math.abs(powerZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
-      });
+  if (history.connections.length >= MIN_SAMPLES) {
+    const connMean = History.mean(history.connections);
+    if (Math.abs((data.packets?.connections || data.network.connections || 0) - connMean) > 5) {
+      const connZ = History.zScore(data.packets?.connections || data.network.connections || 0, history.connections);
+      if (Math.abs(connZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'Connections',
+          value: data.packets?.connections || data.network.connections || 0,
+          zScore: connZ,
+          severity: Math.abs(connZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
     }
   }
 
-  if (data.gpu) {
-    const gpuZ = History.zScore(data.gpu.utilization, history.gpuUtil);
-    if (Math.abs(gpuZ) > ZSCORE_THRESHOLD && history.gpuUtil.length >= MIN_SAMPLES) {
-      alerts.push({
-        metric: 'GPU',
-        value: data.gpu.utilization,
-        zScore: gpuZ,
-        severity: Math.abs(gpuZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
-      });
+  if (data.gpu && history.gpuUtil.length >= MIN_SAMPLES) {
+    const gpuMean = History.mean(history.gpuUtil);
+    if (Math.abs(data.gpu.utilization - gpuMean) > MIN_DEV_GPU) {
+      const gpuZ = History.zScore(data.gpu.utilization, history.gpuUtil);
+      if (Math.abs(gpuZ) > ZSCORE_THRESHOLD) {
+        alerts.push({
+          metric: 'GPU',
+          value: data.gpu.utilization,
+          zScore: gpuZ,
+          severity: Math.abs(gpuZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+        });
+      }
     }
   }
 

package/src/brewHealth.ts

@@ -7,76 +7,193 @@ export interface BrewHealthInfo {
   cellarSize: string;
   doctorWarnings: string[];
   brewAvailable: boolean;
+  managerName: string;
 }
 
 export async function getBrewHealth(): Promise<BrewHealthInfo> {
+  const isWindows = process.platform === 'win32';
+
+  // 1. Try Homebrew (macOS or Linuxbrew)
   try {
-    const brewPath = await run('which brew 2>&1', '');
-    if (!brewPath.trim() || brewPath.includes('not found')) {
-      return { installedCount: 0, outdatedCount: 0, cellarSize: 'N/A', doctorWarnings: [], brewAvailable: false };
+    const brewPath = await run(isWindows ? 'where brew 2>nul' : 'which brew 2>&1', '');
+    if (brewPath.trim() && !brewPath.includes('not found') && !brewPath.includes('Could not find')) {
+      const outdatedRaw = await run('brew outdated --quiet 2>&1', '');
+      const outdatedLines = outdatedRaw.trim().split('\n').filter(l => l.length > 0 && !l.startsWith('Homebrew') && !l.startsWith('==>'));
+
+      const listRaw = await run('brew list --formula -1 2>&1', '');
+      const listLines = listRaw.trim().split('\n').filter(l => l.length > 0);
+
+      let cellarSize = 'N/A';
+      try {
+        const cellarPath = await run('brew --cellar 2>&1', '');
+        if (cellarPath.trim()) {
+          const duRaw = await run(`du -sh "${cellarPath.trim()}" 2>&1`, '');
+          const duMatch = duRaw.match(/^([0-9.,]+[KMGTP]?i?B?)/i);
+          if (duMatch) cellarSize = duMatch[1];
+        }
+      } catch {
+        cellarSize = 'N/A';
+      }
+
+      const doctorRaw = await run('brew doctor 2>&1', '');
+      const doctorWarnings: string[] = [];
+      const docLines = doctorRaw.split('\n');
+      for (const line of docLines) {
+        if (line.startsWith('Warning:')) {
+          doctorWarnings.push(line.replace(/^Warning:\s*/, '').trim());
+        }
+      }
+
+      return {
+        installedCount: listLines.length,
+        outdatedCount: outdatedLines.length,
+        cellarSize,
+        doctorWarnings,
+        brewAvailable: true,
+        managerName: 'Homebrew',
+      };
     }
+  } catch {
+    // continue to alternative managers
+  }
 
-    // Outdated count without triggering brew update
-    const outdatedRaw = await run('brew outdated --quiet 2>&1', '');
-    const outdatedLines = outdatedRaw.trim().split('\n').filter(l => l.length > 0 && !l.startsWith('Homebrew') && !l.startsWith('==>'));
+  // 2. Linux Package Managers (APT, DNF, Pacman)
+  if (process.platform === 'linux') {
+    // Try APT
+    try {
+      const whichApt = (await run('which apt-get 2>/dev/null', '')).trim();
+      if (whichApt) {
+        const listRaw = (await run('dpkg-query -l 2>/dev/null', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(l => l.startsWith('ii')).length : 0;
+        const upgradeRaw = (await run('apt list --upgradable 2>/dev/null', '')).trim();
+        const outdated = upgradeRaw ? upgradeRaw.split('\n').filter(l => l.includes('/') && !l.startsWith('Listing')).length : 0;
+        return {
+          installedCount: installed,
+          outdatedCount: outdated,
+          cellarSize: '/var/cache/apt',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'APT (Debian/Ubuntu)',
+        };
+      }
+    } catch {
+      // ignore
+    }
 
-    // Installed list count
-    const listRaw = await run('brew list --formula -1 2>&1', '');
-    const listLines = listRaw.trim().split('\n').filter(l => l.length > 0);
+    // Try Pacman
+    try {
+      const whichPacman = (await run('which pacman 2>/dev/null', '')).trim();
+      if (whichPacman) {
+        const listRaw = (await run('pacman -Q 2>/dev/null', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length : 0;
+        const upgradeRaw = (await run('checkupdates 2>/dev/null || pacman -Qu 2>/dev/null', '')).trim();
+        const outdated = upgradeRaw ? upgradeRaw.split('\n').filter(Boolean).length : 0;
+        return {
+          installedCount: installed,
+          outdatedCount: outdated,
+          cellarSize: '/var/cache/pacman',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'Pacman (Arch)',
+        };
+      }
+    } catch {
+      // ignore
+    }
 
-    // Disk usage of cellar
-    let cellarSize = 'N/A';
+    // Try DNF
     try {
-      const cellarPath = await run('brew --cellar 2>&1', '');
-      if (cellarPath.trim()) {
-        const duRaw = await run(`du -sh "${cellarPath.trim()}" 2>&1`, '');
-        const duMatch = duRaw.match(/^([0-9\.\,]+[KMGTP]?i?B?)/i);
-        if (duMatch) cellarSize = duMatch[1];
+      const whichDnf = (await run('which dnf 2>/dev/null', '')).trim();
+      if (whichDnf) {
+        const listRaw = (await run('dnf list installed 2>/dev/null', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length - 1 : 0;
+        return {
+          installedCount: Math.max(0, installed),
+          outdatedCount: 0,
+          cellarSize: '/var/cache/dnf',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'DNF (Fedora/RHEL)',
+        };
       }
     } catch {
-      cellarSize = 'N/A';
+      // ignore
     }
+  }
 
-    // Doctor warnings
-    const doctorRaw = await run('brew doctor 2>&1', '');
-    const doctorWarnings: string[] = [];
-    const docLines = doctorRaw.split('\n');
-    for (const line of docLines) {
-      if (line.startsWith('Warning:')) {
-        doctorWarnings.push(line.replace(/^Warning:\s*/, '').trim());
+  // 3. Windows Package Managers (winget, choco, scoop)
+  if (isWindows) {
+    // Try winget
+    try {
+      const whichWinget = (await run('where winget 2>nul', '')).trim();
+      if (whichWinget) {
+        const listRaw = (await run('winget list 2>nul', '', 4000)).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length - 2 : 0;
+        return {
+          installedCount: Math.max(0, installed),
+          outdatedCount: 0,
+          cellarSize: 'N/A',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'Windows Package Manager (winget)',
+        };
       }
+    } catch {
+      // ignore
     }
 
-    return {
-      installedCount: listLines.length,
-      outdatedCount: outdatedLines.length,
-      cellarSize,
-      doctorWarnings,
-      brewAvailable: true,
-    };
-  } catch (err) {
-    return { installedCount: 0, outdatedCount: 0, cellarSize: 'N/A', doctorWarnings: [], brewAvailable: false };
+    // Try scoop
+    try {
+      const whichScoop = (await run('where scoop 2>nul', '')).trim();
+      if (whichScoop) {
+        const listRaw = (await run('scoop list 2>nul', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length - 4 : 0;
+        return {
+          installedCount: Math.max(0, installed),
+          outdatedCount: 0,
+          cellarSize: 'N/A',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'Scoop',
+        };
+      }
+    } catch {
+      // ignore
+    }
   }
+
+  return {
+    installedCount: 0,
+    outdatedCount: 0,
+    cellarSize: 'N/A',
+    doctorWarnings: [],
+    brewAvailable: false,
+    managerName: 'None',
+  };
 }
 
 export async function printBrewHealthReport(): Promise<void> {
-  console.log(chalk.bold('\n  pyre brew — Homebrew Health Summary\n'));
   const health = await getBrewHealth();
+  const label = health.brewAvailable ? health.managerName : 'Package Manager';
+  console.log(chalk.bold(`\n  pyre brew — ${label} Health Summary\n`));
 
   if (!health.brewAvailable) {
-    console.log(chalk.yellow('  ⚠ Homebrew is not installed or not available on PATH.\n'));
+    console.log(chalk.yellow('  ⚠ No supported package manager detected on PATH.\n'));
     return;
   }
 
-  console.log(`  📦 Installed Formulae: ${chalk.bold(health.installedCount)}`);
-  console.log(`  ⏳ Outdated Packages:   ${health.outdatedCount > 0 ? chalk.yellow.bold(health.outdatedCount) : chalk.green('0 (Up to date)')}`);
-  console.log(`  💾 Cellar Disk Usage:  ${chalk.bold(health.cellarSize)}`);
+  console.log(`  📦 Package Manager:    ${chalk.cyan.bold(health.managerName)}`);
+  console.log(`  📦 Installed Packages: ${chalk.bold(health.installedCount)}`);
+  console.log(`  ⏳ Outdated Packages:  ${health.outdatedCount > 0 ? chalk.yellow.bold(health.outdatedCount) : chalk.green('0 (Up to date)')}`);
+  if (health.cellarSize !== 'N/A') {
+    console.log(`  💾 Cache / Cellar:     ${chalk.bold(health.cellarSize)}`);
+  }
 
   console.log();
   if (health.doctorWarnings.length === 0) {
-    console.log(chalk.green('  ✔ brew doctor: No warnings detected system-wide.'));
+    console.log(chalk.green(`  ✔ ${health.managerName}: Ready and healthy.`));
   } else {
-    console.log(chalk.yellow(`  ⚠ brew doctor warnings (${health.doctorWarnings.length}):`));
+    console.log(chalk.yellow(`  ⚠ Diagnostics warnings (${health.doctorWarnings.length}):`));
     for (const warn of health.doctorWarnings.slice(0, 5)) {
       console.log(chalk.dim(`     • ${warn}`));
     }

package/src/buildCmd.ts

@@ -0,0 +1,48 @@
+/**
+ * pyre build — Active Build System Tracker.
+ *
+ * Discovers running compilation and build tools (xcodebuild, cargo, swift,
+ * make, ninja, bazel, go), displaying real-time compiler workers, parallelism,
+ * and CPU/RAM footprints.
+ */
+import chalk from 'chalk';
+import { collectBuilds } from './monitors/buildTracker.js';
+
+export interface BuildOptions {
+  watch?: boolean;
+  json?: boolean;
+}
+
+export async function runBuildCommand(opts: BuildOptions = {}): Promise<void> {
+  const builds = await collectBuilds();
+
+  if (opts.json) {
+    console.log(JSON.stringify({ activeBuilds: builds }, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold('\n  🔥 pyre build — Active Build System Tracker\n'));
+
+  if (builds.length === 0) {
+    console.log(chalk.dim('  No active build or compilation processes detected.'));
+    console.log(chalk.dim('  (Supports: xcodebuild, cargo, swift build, make, ninja, bazel, go build)\n'));
+    return;
+  }
+
+  for (const b of builds) {
+    const elapsedMins = Math.floor(b.elapsedSec / 60);
+    const elapsedSecs = b.elapsedSec % 60;
+    const timeStr = elapsedMins > 0 ? `${elapsedMins}m ${elapsedSecs}s` : `${elapsedSecs}s`;
+
+    console.log(`  ${chalk.bgCyan.black.bold(` ${b.tool.toUpperCase()} `)}  ${chalk.bold(`PID ${b.rootPid}`)}`);
+    console.log(`    Command:          ${chalk.white(b.command)}`);
+    if (b.target) {
+      console.log(`    Target:           ${chalk.cyan(b.target)}`);
+    }
+    console.log(`    Compiler Workers: ${chalk.green.bold(String(b.compilerProcesses))} active thread/processes`);
+    console.log(`    Combined CPU:     ${chalk.yellow.bold(b.totalCpu.toFixed(1) + '%')}`);
+    console.log(`    Combined RAM:     ${chalk.magenta(b.totalMem.toFixed(1) + '%')}`);
+    console.log(`    Elapsed Time:     ${chalk.dim(timeStr)}`);
+    console.log();
+  }
+}

package/src/checkCmd.ts

@@ -15,7 +15,7 @@ export async function runCheckCommand(opts: CheckOptions = {}): Promise<void> {
   const cpuUsage = data.cpu.usage;
   const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
   const memUsage = data.memory.usagePercent;
-  const disk = data.disk.mainVolume;
+  const disk = data.disk && data.disk.length > 0 ? data.disk[0] : null;
 
   const sentences: string[] = [];
   let isWarning = false;
@@ -61,10 +61,10 @@ export async function runCheckCommand(opts: CheckOptions = {}): Promise<void> {
 
   // Disk sentence
   if (disk) {
-    const freeBytes = disk.free;
-    const freeStr = formatBytes(freeBytes);
-    sentences.push(`${freeStr} free on ${disk.mount}.`);
-    if (disk.usePercent >= 90) {
+    const freeStr = disk.available;
+    sentences.push(`${freeStr} free on ${disk.mountpoint}.`);
+    const cap = parseInt(disk.capacity, 10);
+    if (!isNaN(cap) && cap >= 90) {
       isWarning = true;
     }
   }

package/src/completions.ts

@@ -116,3 +116,38 @@ complete -c pyre -l sort -x -a "cpu mem pid user command state threads runtime"
 complete -c pyre -l temp-unit -x -a "c f" -d "Temperature unit"
 `;
 }
+
+export function generatePowerShellCompletions(): string {
+  return `# PowerShell completion for pyre
+Register-ArgumentCompleter -Native -CommandName pyre -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+    $commands = @('live', 'check', 'pipe', 'stress', 'ui', 'web', 'ssh', 'fleet', 'bench', 'benchmark', 'anomalies', 'doctor', 'extensions', 'brew', 'update', 'profile', 'config', 'history', 'diff', 'info', 'completions', 'p2p', 'blender', 'prometheus', 'smart', 'replay', 'explain')
+    $options = @('--json', '--html', '--md', '--csv', '--tsv', '--detailed', '--theme', '--interval', '--once', '--out', '--export-dir', '--log', '--tree', '--sort', '--packets', '--limit', '--alert-cpu', '--alert-temp', '--temp-unit', '--plain', '--help', '--version')
+
+    $elements = $commandAst.CommandElements
+    if ($elements.Count -le 2) {
+        $commands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+    }
+    $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+    }
+}
+`;
+}
+
+export function printCompletions(shell: string): void {
+  const s = (shell || '').toLowerCase();
+  if (s === 'bash') {
+    console.log(generateBashCompletions());
+  } else if (s === 'fish') {
+    console.log(generateFishCompletions());
+  } else if (s === 'powershell' || s === 'pwsh') {
+    console.log(generatePowerShellCompletions());
+  } else {
+    console.log(generateZshCompletions());
+  }
+}
+
+