pyre-cli 9.5.1 → 10.0.0

package/src/doctor.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import os from 'node:os';
 import chalk from 'chalk';
 import { run } from './monitors/run.js';
 import { readConfig, CONFIG_FILE } from './state/config.js';
@@ -10,6 +12,13 @@ export interface DoctorCheck {
 }
 
 export async function runDoctor(): Promise<DoctorCheck[]> {
+  const platform = process.platform;
+  if (platform === 'linux') return runLinuxDoctor();
+  if (platform === 'win32') return runWindowsDoctor();
+  return runMacDoctor();
+}
+
+async function runMacDoctor(): Promise<DoctorCheck[]> {
   const checks: DoctorCheck[] = [];
 
   // 1. Sudo / Powermetrics Access
@@ -163,27 +172,246 @@ export async function runDoctor(): Promise<DoctorCheck[]> {
   }
 
   // 7. Config file integrity
+  checks.push(checkConfigIntegrity());
+
+  return checks;
+}
+
+async function runLinuxDoctor(): Promise<DoctorCheck[]> {
+  const checks: DoctorCheck[] = [];
+
+  // 1. Process Visibility
+  try {
+    const psCheck = await run('ps -eo pid,user,comm', '');
+    if (psCheck.length > 0) {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'ok',
+        message: 'Full process table access available.',
+      });
+    } else {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'warn',
+        message: 'Restricted process table access.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Process Visibility',
+      status: 'error',
+      message: 'Unable to query process list.',
+    });
+  }
+
+  // 2. /proc and /sys Telemetry Access
+  try {
+    const statExists = fs.existsSync('/proc/stat');
+    const memExists = fs.existsSync('/proc/meminfo');
+    if (statExists && memExists) {
+      checks.push({
+        name: 'Kernel Telemetry (/proc)',
+        status: 'ok',
+        message: 'Kernel telemetry interfaces readable.',
+      });
+    } else {
+      checks.push({
+        name: 'Kernel Telemetry (/proc)',
+        status: 'error',
+        message: 'Core pseudo-filesystems (/proc) unavailable or restricted.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Kernel Telemetry (/proc)',
+      status: 'warn',
+      message: 'Could not check /proc readability.',
+    });
+  }
+
+  // 3. Thermal & Hardware Sensors
+  try {
+    const thermZones = fs.existsSync('/sys/class/thermal');
+    const hwmon = fs.existsSync('/sys/class/hwmon');
+    if (thermZones || hwmon) {
+      checks.push({
+        name: 'Hardware Sensors (/sys)',
+        status: 'ok',
+        message: 'Thermal and hardware monitoring sensors detected.',
+      });
+    } else {
+      checks.push({
+        name: 'Hardware Sensors (/sys)',
+        status: 'warn',
+        message: 'No hardware sensor paths detected in /sys/class.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Hardware Sensors (/sys)',
+      status: 'warn',
+      message: 'Unable to query sensor interfaces.',
+    });
+  }
+
+  // 4. Network Reachability
+  try {
+    const netCheck = await run('ip route 2>/dev/null || route -n 2>/dev/null', '');
+    if (netCheck.includes('default') || netCheck.includes('0.0.0.0')) {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'ok',
+        message: 'Active default route detected.',
+      });
+    } else {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'warn',
+        message: 'No default network gateway detected.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Network Reachability',
+      status: 'warn',
+      message: 'Could not verify network routes.',
+    });
+  }
+
+  // 5. Systemd User Service Capability
+  try {
+    const sysctlRes = await run('systemctl --user status 2>&1', '');
+    if (!sysctlRes.includes('Failed to connect to bus') && !sysctlRes.includes('not found')) {
+      checks.push({
+        name: 'Systemd User Daemon',
+        status: 'ok',
+        message: 'Systemd user session active (ready for pyre --install).',
+      });
+    } else {
+      checks.push({
+        name: 'Systemd User Daemon',
+        status: 'warn',
+        message: 'Systemd user session not available.',
+        details: 'Background services via pyre --install require an active user systemd session.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Systemd User Daemon',
+      status: 'warn',
+      message: 'Systemd check skipped.',
+    });
+  }
+
+  // 6. Config file integrity
+  checks.push(checkConfigIntegrity());
+
+  return checks;
+}
+
+async function runWindowsDoctor(): Promise<DoctorCheck[]> {
+  const checks: DoctorCheck[] = [];
+
+  // 1. Process Visibility
   try {
-    const cfg = readConfig();
+    const psCheck = await run('tasklist /nh 2>nul', '');
+    if (psCheck.length > 0) {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'ok',
+        message: 'Windows process table access available.',
+      });
+    } else {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'warn',
+        message: 'Tasklist query returned no output.',
+      });
+    }
+  } catch {
     checks.push({
+      name: 'Process Visibility',
+      status: 'error',
+      message: 'Unable to query Windows tasklist.',
+    });
+  }
+
+  // 2. PowerShell / WMI Interface
+  try {
+    const wmiCheck = await run('wmic os get Caption 2>nul || powershell -Command "(Get-CimInstance Win32_OperatingSystem).Caption"', '');
+    if (wmiCheck.toLowerCase().includes('windows')) {
+      checks.push({
+        name: 'WMI / CIM Subsystem',
+        status: 'ok',
+        message: 'WMI/CIM management queries responsive.',
+      });
+    } else {
+      checks.push({
+        name: 'WMI / CIM Subsystem',
+        status: 'warn',
+        message: 'WMI/CIM query did not return expected response.',
+        details: 'Some hardware metrics (disks, thermal) rely on WMI or PowerShell CIM.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'WMI / CIM Subsystem',
+      status: 'warn',
+      message: 'Could not execute WMI query.',
+    });
+  }
+
+  // 3. Network Reachability
+  try {
+    const netCheck = await run('netstat -rn 2>nul', '');
+    if (netCheck.includes('0.0.0.0')) {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'ok',
+        message: 'Active default IPv4 gateway detected.',
+      });
+    } else {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'warn',
+        message: 'No default route detected in routing table.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Network Reachability',
+      status: 'warn',
+      message: 'Could not verify Windows network routes.',
+    });
+  }
+
+  // 4. Config file integrity
+  checks.push(checkConfigIntegrity());
+
+  return checks;
+}
+
+function checkConfigIntegrity(): DoctorCheck {
+  try {
+    readConfig();
+    return {
       name: 'Configuration File',
       status: 'ok',
       message: `Config file valid (${CONFIG_FILE}).`,
-    });
+    };
   } catch (err: any) {
-    checks.push({
+    return {
       name: 'Configuration File',
       status: 'error',
       message: 'Failed to parse config file.',
       details: err.message,
-    });
+    };
   }
-
-  return checks;
 }
 
 export function printDoctorReport(checks: DoctorCheck[]): void {
-  console.log(chalk.bold('\n  pyre doctor — System Diagnostics\n'));
+  const osLabel = process.platform === 'darwin' ? 'macOS' : (process.platform === 'win32' ? 'Windows' : 'Linux');
+  console.log(chalk.bold(`\n  pyre doctor — System Diagnostics (${osLabel})\n`));
 
   for (const check of checks) {
     let icon = chalk.green('✔');

package/src/easy_features.test.ts

@@ -1,5 +1,10 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import path from 'node:path';
+import fs from 'node:fs';
+
+process.env.PYRE_CONFIG_DIR = path.join(process.cwd(), 'node_modules', '.test-pyre-config');
+
 import { parseSystemExtensionsOutput } from './extensions.js';
 import { saveProfile, loadProfile, listProfiles } from './state/config.js';
 import { sparkline } from './sparkline.js';
@@ -41,3 +46,38 @@ describe('Plain text sparkline (Feature F3)', () => {
     assert.strictEqual(res, '[10.0 -> 30.0 (Δ:+20.0)]');
   });
 });
+
+describe('Cross-Platform Support', () => {
+  it('should generate valid PowerShell completions script', async () => {
+    const { generatePowerShellCompletions } = await import('./completions.js');
+    const ps = generatePowerShellCompletions();
+    assert.ok(ps.includes('Register-ArgumentCompleter'));
+    assert.ok(ps.includes('CommandName pyre'));
+    assert.ok(ps.includes('live'));
+    assert.ok(ps.includes('--json'));
+  });
+
+  it('should run doctor diagnostics without crashing on any platform', async () => {
+    const { runDoctor } = await import('./doctor.js');
+    const checks = await runDoctor();
+    assert.ok(Array.isArray(checks));
+    assert.ok(checks.length > 0);
+    for (const c of checks) {
+      assert.ok(['ok', 'warn', 'error'].includes(c.status));
+      assert.ok(typeof c.name === 'string');
+      assert.ok(typeof c.message === 'string');
+    }
+  });
+
+  it('should collect telemetry across subsystems without crashing', async () => {
+    const { collectAll } = await import('./monitors/index.js');
+    const data = await collectAll();
+    assert.ok(data.header.hostname.length > 0);
+    assert.ok(data.header.os.length > 0);
+    assert.ok(data.cpu.cores >= 1);
+    assert.ok(data.memory.total > 0);
+    assert.ok(Array.isArray(data.disk));
+    assert.ok(typeof data.network.interface === 'string');
+  });
+});
+

package/src/explainCmd.ts

@@ -0,0 +1,261 @@
+/**
+ * pyre explain — AI-powered anomaly explanation.
+ *
+ * Reads anomaly spikes from pyre CSV logs and sends them to a
+ * local Ollama instance (default) or an OpenAI-compatible API
+ * to generate plain-English diagnosis and actionable advice.
+ *
+ * Backends:
+ *   - ollama (default): POST http://localhost:11434/api/generate
+ *   - openai:           POST https://api.openai.com/v1/chat/completions
+ *
+ * No new dependencies — uses Node.js 18+ built-in fetch.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import chalk from 'chalk';
+import { explainAnomaliesLocally } from './ai/models.js';
+
+export interface ExplainOptions {
+  since?: string;
+  backend?: 'builtin' | 'ollama' | 'openai';
+  model?: string;
+  apiKey?: string;
+  dir?: string;
+}
+
+interface AnomalyEvent {
+  timestamp: string;
+  metric: string;
+  value: number;
+  baseline: number;
+  zScore: number;
+}
+
+function parseAnomalies(dir: string, sinceStr: string): AnomalyEvent[] {
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter(f => f.startsWith('pyre-') && f.endsWith('.csv'));
+  if (files.length === 0) return [];
+
+  let cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+  if (sinceStr === 'yesterday' || sinceStr === '1d') cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  else if (sinceStr.endsWith('d')) {
+    const d = parseInt(sinceStr.slice(0, -1), 10);
+    if (!isNaN(d)) cutoff = Date.now() - d * 24 * 60 * 60 * 1000;
+  } else if (!isNaN(Date.parse(sinceStr))) {
+    cutoff = Date.parse(sinceStr);
+  }
+
+  interface LogRow { ts: Date; cpu: number; mem: number; temp?: number; }
+  const rows: LogRow[] = [];
+
+  for (const file of files.sort()) {
+    try {
+      const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+      for (const line of content.split('\n').slice(1)) {
+        if (!line.trim()) continue;
+        const parts = line.split(',');
+        if (parts.length < 3) continue;
+        const ts = new Date(parts[0]);
+        if (!isNaN(ts.getTime()) && ts.getTime() >= cutoff) {
+          const cpu = parseFloat(parts[1]);
+          const mem = parseFloat(parts[2]);
+          const temp = parts[3] ? parseFloat(parts[3]) : NaN;
+          if (!isNaN(cpu) && !isNaN(mem)) {
+            rows.push({ ts, cpu, mem, temp: isNaN(temp) ? undefined : temp });
+          }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  if (rows.length < 5) return [];
+
+  const mean = (arr: number[]) => arr.reduce((a, b) => a + b, 0) / arr.length;
+  const std = (arr: number[], m: number) => Math.sqrt(arr.reduce((a, b) => a + (b - m) ** 2, 0) / arr.length);
+
+  const cpuVals = rows.map(r => r.cpu);
+  const memVals = rows.map(r => r.mem);
+  const tempVals = rows.filter(r => r.temp !== undefined).map(r => r.temp!);
+
+  const cpuMean = mean(cpuVals); const cpuStd = std(cpuVals, cpuMean);
+  const memMean = mean(memVals); const memStd = std(memVals, memMean);
+  const tempMean = tempVals.length ? mean(tempVals) : 0;
+  const tempStd = tempVals.length ? std(tempVals, tempMean) : 0;
+
+  const anomalies: AnomalyEvent[] = [];
+  for (const r of rows) {
+    if (cpuStd > 0) {
+      const z = (r.cpu - cpuMean) / cpuStd;
+      if (z >= 2.5) anomalies.push({ timestamp: r.ts.toISOString(), metric: 'CPU', value: r.cpu, baseline: cpuMean, zScore: z });
+    }
+    if (memStd > 0) {
+      const z = (r.mem - memMean) / memStd;
+      if (z >= 2.5) anomalies.push({ timestamp: r.ts.toISOString(), metric: 'Memory', value: r.mem, baseline: memMean, zScore: z });
+    }
+    if (r.temp !== undefined && tempStd > 0) {
+      const z = (r.temp - tempMean) / tempStd;
+      if (z >= 2.5) anomalies.push({ timestamp: r.ts.toISOString(), metric: 'Temperature', value: r.temp, baseline: tempMean, zScore: z });
+    }
+  }
+  return anomalies;
+}
+
+function buildPrompt(anomalies: AnomalyEvent[], hostname: string, sinceStr: string): string {
+  const osLabel = process.platform === 'darwin' ? 'macOS' : (process.platform === 'win32' ? 'Windows' : 'Linux');
+  const lines = anomalies.slice(0, 10).map(a => {
+    const unit = a.metric === 'Temperature' ? '°C' : '%';
+    return `- ${a.metric} spike at ${a.timestamp}: ${a.value.toFixed(1)}${unit} (baseline ${a.baseline.toFixed(1)}${unit}, +${a.zScore.toFixed(1)}σ)`;
+  });
+  return [
+    `You are a ${osLabel} system performance expert analyzing a monitoring log from "${hostname}".`,
+    `The following statistical anomalies (z-score ≥ 2.5σ) were detected in the past ${sinceStr}:`,
+    '',
+    ...lines,
+    '',
+    'For each anomaly, provide:',
+    `1. A plain-English explanation of what likely caused it (be specific to ${osLabel})`,
+    '2. Whether it is likely harmless or worth investigating',
+    '3. One actionable recommendation the user can take right now',
+    '',
+    'Be concise (2-3 sentences per anomaly). Use bullet points. Do not use technical jargon.',
+  ].join('\n');
+}
+
+async function queryOllama(prompt: string, model: string): Promise<string> {
+  const res = await fetch('http://localhost:11434/api/generate', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ model, prompt, stream: false }),
+    signal: AbortSignal.timeout(60000),
+  });
+  if (!res.ok) throw new Error(`Ollama error: ${res.status} ${res.statusText}`);
+  const data = await res.json() as { response?: string; error?: string };
+  if (data.error) throw new Error(data.error);
+  return data.response ?? '';
+}
+
+async function queryOpenAI(prompt: string, model: string, apiKey: string): Promise<string> {
+  const res = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+    body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }], max_tokens: 800 }),
+    signal: AbortSignal.timeout(60000),
+  });
+  if (!res.ok) throw new Error(`OpenAI error: ${res.status} ${await res.text()}`);
+  const data = await res.json() as { choices?: Array<{ message: { content: string } }> };
+  return data.choices?.[0]?.message?.content ?? '';
+}
+
+export async function runExplainCommand(opts: ExplainOptions = {}): Promise<void> {
+  const {
+    since = '7d',
+    backend = 'builtin',
+    model = backend === 'openai' ? 'gpt-4o-mini' : backend === 'ollama' ? 'llama3.2' : 'expert-rules-v1',
+    apiKey = process.env['OPENAI_API_KEY'] ?? '',
+    dir = './pyre-exports',
+  } = opts;
+
+  console.log(chalk.bold('\n  🔥 pyre explain — AI Anomaly Analysis\n'));
+
+  const anomalies = parseAnomalies(dir, since);
+
+  if (anomalies.length === 0) {
+    console.log(chalk.green('  ✔ No anomalies detected in the past ' + since + '.'));
+    console.log(chalk.dim('  Run pyre live --log to build a history first.\n'));
+    return;
+  }
+
+  if (backend === 'builtin') {
+    console.log(chalk.dim(`  Analyzing ${anomalies.length} anomaly event(s) using local built-in model (${model})...\n`));
+    const alerts = anomalies.map(a => ({
+      metric: a.metric,
+      value: a.value,
+      zScore: a.zScore,
+      severity: (a.zScore >= 3.5 ? 'critical' : 'warning') as 'critical' | 'warning',
+      timestamp: new Date(a.timestamp),
+    }));
+    const analysis = explainAnomaliesLocally(alerts, model);
+    console.log(chalk.bold('  Analysis:\n'));
+    for (const line of analysis.split('\n')) {
+      if (line.startsWith('Diagnosis Engine:')) {
+        console.log(chalk.bold.magenta('  ' + line));
+      } else if (line.startsWith('Tip:')) {
+        console.log(chalk.cyan.bold('  ' + line));
+      } else if (line.startsWith('  • Recommendation:')) {
+        console.log('  ' + chalk.green(line));
+      } else if (line.startsWith('  • Cause:')) {
+        console.log('  ' + chalk.yellow(line));
+      } else if (line.startsWith('  • Verdict:')) {
+        console.log('  ' + chalk.dim(line));
+      } else {
+        console.log('  ' + chalk.dim(line));
+      }
+    }
+    console.log();
+    return;
+  }
+
+  console.log(chalk.dim(`  Found ${anomalies.length} anomaly event(s). Sending to ${backend} (${model})...\n`));
+
+  const hostname = os.hostname();
+  const prompt = buildPrompt(anomalies, hostname, since);
+  let explanation = '';
+
+  try {
+    if (backend === 'openai') {
+      if (!apiKey) {
+        console.log(chalk.yellow('  ⚠ No API key found.'));
+        console.log(chalk.dim('  Set OPENAI_API_KEY environment variable or use --api-key <key>\n'));
+        return;
+      }
+      explanation = await queryOpenAI(prompt, model, apiKey);
+    } else {
+      explanation = await queryOllama(prompt, model);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (backend === 'ollama' && (msg.includes('ECONNREFUSED') || msg.includes('fetch failed'))) {
+      console.log(chalk.yellow('  ⚠ Ollama server is not running at localhost:11434.\n'));
+      console.log(chalk.dim('  Switching to local built-in AI model (offline, zero-setup)...\n'));
+      const alerts = anomalies.map(a => ({
+        metric: a.metric,
+        value: a.value,
+        zScore: a.zScore,
+        severity: (a.zScore >= 3.5 ? 'critical' : 'warning') as 'critical' | 'warning',
+        timestamp: new Date(a.timestamp),
+      }));
+      const fallbackAnalysis = explainAnomaliesLocally(alerts, 'expert-rules-v1');
+      console.log(chalk.bold('  Analysis (Built-in Heuristic Model):\n'));
+      for (const line of fallbackAnalysis.split('\n')) {
+        console.log('  ' + line);
+      }
+      console.log();
+      return;
+    } else {
+      console.log(chalk.red(`  ✖ LLM error: ${msg}\n`));
+    }
+    return;
+  }
+
+  if (!explanation.trim()) {
+    console.log(chalk.yellow('  ⚠ LLM returned an empty response. Try a different model.\n'));
+    return;
+  }
+
+  console.log(chalk.bold('  Analysis:\n'));
+  for (const line of explanation.split('\n')) {
+    const t = line.trim();
+    if (t.startsWith('-') || t.startsWith('•')) {
+      console.log(chalk.dim('  ') + chalk.white(t));
+    } else if (t.match(/^\d+\./)) {
+      console.log(chalk.dim('  ') + chalk.cyan(t));
+    } else if (t) {
+      console.log('  ' + t);
+    } else {
+      console.log('');
+    }
+  }
+  console.log();
+}

package/src/extensions.ts

@@ -10,6 +10,10 @@ export interface SystemExtensionInfo {
 }
 
 export async function getSystemExtensions(): Promise<{ category: string; extensions: SystemExtensionInfo[] }[]> {
+  const platform = process.platform;
+  if (platform === 'linux') return getLinuxExtensions();
+  if (platform === 'win32') return getWindowsExtensions();
+
   try {
     const raw = await run('systemextensionsctl list 2>&1', '');
     return parseSystemExtensionsOutput(raw);
@@ -33,12 +37,12 @@ export function parseSystemExtensionsOutput(output: string): { category: string;
         result.push({ category: currentCategory, extensions: currentList });
         currentList = [];
       }
-      const catMatch = trimmed.match(/category\s+([\w\.-]+)/i);
+      const catMatch = trimmed.match(/category\s+([\w.-]+)/i);
       currentCategory = catMatch ? catMatch[1] : trimmed.replace(/^-+\s*/, '').replace(/\s*-+$/, '');
       continue;
     }
 
-    const extMatch = trimmed.match(/^(?:\*\s*)*([A-Z0-9]{10}|\?\?\?\?\?\?\?\?\?\?)\s+([\w\.-]+)\s+\(([^)]+)\)\s+\[([^\]]+)\]/i);
+    const extMatch = trimmed.match(/^(?:\*\s*)*([A-Z0-9]{10}|\?\?\?\?\?\?\?\?\?\?)\s+([\w.-]+)\s+\(([^)]+)\)\s+\[([^\]]+)\]/i);
     if (extMatch) {
       currentList.push({
         teamId: extMatch[1],
@@ -57,8 +61,63 @@ export function parseSystemExtensionsOutput(output: string): { category: string;
   return result.filter(group => group.extensions.length > 0 || result.length === 1);
 }
 
+async function getLinuxExtensions(): Promise<{ category: string; extensions: SystemExtensionInfo[] }[]> {
+  try {
+    const raw = await run('lsmod 2>/dev/null', '');
+    const lines = raw.trim().split('\n').slice(1);
+    const extensions: SystemExtensionInfo[] = [];
+
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 3) {
+        const modName = parts[0];
+        const sizeBytes = parts[1];
+        const usedBy = parts.slice(3).join(' ') || 'none';
+        extensions.push({
+          teamId: 'KERNEL',
+          bundleId: modName,
+          version: `${sizeBytes} bytes`,
+          state: `used by: ${usedBy}`,
+          category: 'Kernel Modules',
+        });
+      }
+    }
+    return extensions.length > 0 ? [{ category: 'Linux Kernel Modules', extensions }] : [];
+  } catch {
+    return [];
+  }
+}
+
+async function getWindowsExtensions(): Promise<{ category: string; extensions: SystemExtensionInfo[] }[]> {
+  try {
+    const raw = await run('driverquery /fo csv /nh 2>nul', '', 3000);
+    const lines = raw.trim().split('\n');
+    const extensions: SystemExtensionInfo[] = [];
+
+    for (const line of lines) {
+      const parts = line.split('","').map(s => s.replace(/(^"|"$)/g, '').trim());
+      if (parts.length >= 3) {
+        const modName = parts[0];
+        const dispName = parts[1];
+        const driverType = parts[2];
+        extensions.push({
+          teamId: driverType,
+          bundleId: modName,
+          version: dispName,
+          state: 'active',
+          category: 'Device Drivers',
+        });
+      }
+    }
+    return extensions.length > 0 ? [{ category: 'Windows Device Drivers', extensions }] : [];
+  } catch {
+    return [];
+  }
+}
+
 export async function printExtensionsReport(): Promise<void> {
-  console.log(chalk.bold('\n  pyre extensions — System Extensions Inspector\n'));
+  const osLabel = process.platform === 'darwin' ? 'macOS System Extensions' : (process.platform === 'win32' ? 'Windows Drivers' : 'Linux Kernel Modules');
+  console.log(chalk.bold(`\n  pyre extensions — ${osLabel} Inspector\n`));
   const categories = await getSystemExtensions();
 
   let totalCount = 0;
@@ -69,15 +128,20 @@ export async function printExtensionsReport(): Promise<void> {
       console.log(chalk.dim('     (No extensions registered in this category)'));
       continue;
     }
-    for (const ext of cat.extensions) {
-      const stateColor = ext.state.includes('activated') || ext.state.includes('enabled') ? chalk.green : chalk.yellow;
+    // Limit display so large module/driver tables do not overwhelm the terminal
+    const maxShow = 25;
+    for (const ext of cat.extensions.slice(0, maxShow)) {
+      const stateColor = ext.state.includes('activated') || ext.state.includes('enabled') || ext.state.includes('active') ? chalk.green : chalk.yellow;
       console.log(`     • ${chalk.bold(ext.bundleId)} (${ext.version})`);
-      console.log(chalk.dim(`       Team: ${ext.teamId} | State: `) + stateColor(ext.state));
+      console.log(chalk.dim(`       Type/Team: ${ext.teamId} | State: `) + stateColor(ext.state));
+    }
+    if (cat.extensions.length > maxShow) {
+      console.log(chalk.dim(`     ... and ${cat.extensions.length - maxShow} more.`));
     }
     console.log();
   }
 
   if (totalCount === 0) {
-    console.log(chalk.dim('  No active system extensions detected on this system.\n'));
+    console.log(chalk.dim('  No active extensions/modules detected on this system.\n'));
   }
 }