pyre-cli 9.5.2 → 10.1.0

package/src/monitors/batteryPredictor.ts

@@ -0,0 +1,143 @@
+/**
+ * Smart Battery Predictor.
+ *
+ * Predicts multi-scenario battery longevity by synthesizing:
+ * 1. Current instantaneous discharge rate and state of charge.
+ * 2. Historical discharge profiles parsed from local CSV log exports.
+ * 3. Machine load heuristics (idle vs. current compute vs. sustained high-power).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import type { BatteryData, PowerData } from './types.js';
+
+export interface BatteryPredictionScenario {
+  label: string;
+  ratePerHour: number;
+  timeRemaining: string;
+  hours: number;
+}
+
+export interface SmartBatteryPrediction {
+  currentLevel: number;
+  healthPercentage?: number;
+  cycleCount?: number;
+  powerWatts?: number;
+  scenarios: {
+    idle: BatteryPredictionScenario;
+    current: BatteryPredictionScenario;
+    heavy: BatteryPredictionScenario;
+  };
+  recommendation: string;
+  confidence: 'low' | 'medium' | 'high';
+}
+
+function formatHours(h: number): string {
+  if (!isFinite(h) || h <= 0) return 'calculating';
+  const hours = Math.floor(h);
+  const mins = Math.round((h - hours) * 60);
+  if (hours === 0 && mins === 0) return '< 1m';
+  if (hours === 0) return `${mins}m`;
+  return `${hours}h ${mins}m`;
+}
+
+export function computeSmartBatteryPrediction(
+  battery: BatteryData | null,
+  power: PowerData | null,
+  logDir: string = './pyre-exports'
+): SmartBatteryPrediction | null {
+  if (!battery) return null;
+
+  const level = battery.level;
+  const isCharging = battery.state.toLowerCase().includes('charg');
+
+  // Baseline assumption for typical MacBook battery Wh capacity
+  const assumedCapacityWh = 58;
+
+  // 1. Current discharge rate in %/hour
+  let currentRate = battery.dischargeRatePerHour || 12; // default fallback 12%/h
+  if (battery.dischargeRatePerHour === undefined && power && power.combinedWatts) {
+    currentRate = (power.combinedWatts / assumedCapacityWh) * 100;
+  }
+  currentRate = Math.max(2, Math.min(60, currentRate));
+
+  // 2. Scan historical logs for typical average discharge rate if available
+  let historicalSamples: number[] = [];
+  try {
+    if (fs.existsSync(logDir)) {
+      const files = fs.readdirSync(logDir).filter(f => f.startsWith('pyre-') && f.endsWith('.csv')).slice(-3);
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(logDir, file), 'utf-8');
+        const lines = content.split('\n').slice(1);
+        for (const line of lines) {
+          const parts = line.split(',');
+          if (parts.length >= 4) {
+            const cpu = parseFloat(parts[1]);
+            if (!isNaN(cpu)) {
+              // Estimate power based on CPU history
+              const estRate = 5 + (cpu / 100) * 20;
+              historicalSamples.push(estRate);
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // fallback
+  }
+
+  const confidence: 'low' | 'medium' | 'high' = isCharging
+    ? 'low'
+    : historicalSamples.length > 50
+    ? 'high'
+    : battery.dischargeRatePerHour ? 'medium' : 'low';
+
+  // Compute scenarios
+  // Idle load scenario (light browser/reading, ~5-7% per hour)
+  const idleRate = 6.0;
+  const idleHours = level / idleRate;
+
+  // Current load scenario
+  const currentHours = level / currentRate;
+
+  // Heavy load scenario (compiling, 3D render, gaming: ~25-35% per hour)
+  const heavyRate = Math.max(28.0, currentRate * 1.5);
+  const heavyHours = level / heavyRate;
+
+  let recommendation = 'Power consumption is normal.';
+  if (isCharging) {
+    recommendation = `Device is currently ${battery.state}. Full capacity health: ${battery.health || 'Good'}.`;
+  } else if (currentRate > 25) {
+    recommendation = 'High power drain detected. Reducing display brightness and closing heavy background processes can extend battery significantly.';
+  } else if (currentRate < 10) {
+    recommendation = 'Excellent power efficiency. Machine is running under low-drain conditions.';
+  }
+
+  return {
+    currentLevel: level,
+    healthPercentage: battery.maxCapacityPercent,
+    cycleCount: battery.cycles,
+    powerWatts: battery.powerWatts || power?.combinedWatts,
+    scenarios: {
+      idle: {
+        label: 'Light / Reading Load',
+        ratePerHour: idleRate,
+        timeRemaining: formatHours(idleHours),
+        hours: idleHours,
+      },
+      current: {
+        label: 'Current Activity',
+        ratePerHour: Math.round(currentRate * 10) / 10,
+        timeRemaining: isCharging ? 'Charging' : formatHours(currentHours),
+        hours: currentHours,
+      },
+      heavy: {
+        label: 'Sustained Heavy Compute',
+        ratePerHour: Math.round(heavyRate * 10) / 10,
+        timeRemaining: formatHours(heavyHours),
+        hours: heavyHours,
+      },
+    },
+    recommendation,
+    confidence,
+  };
+}

package/src/monitors/buildTracker.ts

@@ -0,0 +1,121 @@
+/**
+ * Build System Tracker.
+ *
+ * Scans active processes for compiler invocations (xcodebuild, cargo, rustc,
+ * clang, swift-frontend, make, ninja, bazel, go build), tracking compiler
+ * parallelism, CPU/RAM usage, and estimated elapsed time.
+ */
+import { run } from './run.js';
+
+export interface ActiveBuild {
+  tool: 'xcodebuild' | 'cargo' | 'swift' | 'make' | 'ninja' | 'bazel' | 'go' | 'clang' | 'compiler';
+  rootPid: number;
+  command: string;
+  compilerProcesses: number;
+  totalCpu: number;
+  totalMem: number;
+  elapsedSec: number;
+  target?: string;
+}
+
+export async function collectBuilds(): Promise<ActiveBuild[]> {
+  try {
+    const raw = await run('ps -eo pid,ppid,pcpu,pmem,etime,command -r', '');
+    if (!raw) return [];
+
+    const lines = raw.split('\n').slice(1);
+    const builds: Map<string, ActiveBuild> = new Map();
+
+    const buildToolPatterns: { name: ActiveBuild['tool']; match: RegExp }[] = [
+      { name: 'xcodebuild', match: /xcodebuild/i },
+      { name: 'cargo', match: /\bcargo\s+(build|check|test|run)\b/i },
+      { name: 'swift', match: /\bswift\s+(build|test)\b/i },
+      { name: 'make', match: /\bmake\b/i },
+      { name: 'ninja', match: /\bninja\b/i },
+      { name: 'bazel', match: /\bbazel\b/i },
+      { name: 'go', match: /\bgo\s+(build|test|run)\b/i },
+    ];
+
+    const compilerMatch = /(clang|swift-frontend|rustc|go tool compile|gcc|g\+\+|ghc)/i;
+
+    // First pass: identify build roots
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 6) continue;
+
+      const pid = parseInt(parts[0], 10);
+      const cpu = parseFloat(parts[2]) || 0;
+      const mem = parseFloat(parts[3]) || 0;
+      const etimeStr = parts[4];
+      const cmd = parts.slice(5).join(' ');
+
+      for (const pattern of buildToolPatterns) {
+        if (pattern.match.test(cmd)) {
+          let elapsedSec = 0;
+          const etimeParts = etimeStr.split(':').map(Number);
+          if (etimeParts.length === 2) elapsedSec = etimeParts[0] * 60 + etimeParts[1];
+          else if (etimeParts.length === 3) elapsedSec = etimeParts[0] * 3600 + etimeParts[1] * 60 + etimeParts[2];
+
+          builds.set(pattern.name, {
+            tool: pattern.name,
+            rootPid: pid,
+            command: cmd.slice(0, 80),
+            compilerProcesses: 1,
+            totalCpu: cpu,
+            totalMem: mem,
+            elapsedSec,
+            target: cmd.split(' ').slice(1, 4).join(' '),
+          });
+          break;
+        }
+      }
+    }
+
+    // Second pass: associate child compiler processes
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 6) continue;
+
+      const cpu = parseFloat(parts[2]) || 0;
+      const mem = parseFloat(parts[3]) || 0;
+      const cmd = parts.slice(5).join(' ');
+
+      if (compilerMatch.test(cmd)) {
+        // If an active build was found, associate this compiler worker
+        if (builds.size > 0) {
+          const firstBuild = builds.values().next().value;
+          if (firstBuild) {
+            firstBuild.compilerProcesses += 1;
+            firstBuild.totalCpu += cpu;
+            firstBuild.totalMem += mem;
+          }
+        } else {
+          // Standalone compiler invocation
+          const key = 'compiler';
+          const existing = builds.get(key);
+          if (existing) {
+            existing.compilerProcesses += 1;
+            existing.totalCpu += cpu;
+            existing.totalMem += mem;
+          } else {
+            builds.set(key, {
+              tool: 'compiler',
+              rootPid: parseInt(parts[0], 10),
+              command: cmd.slice(0, 80),
+              compilerProcesses: 1,
+              totalCpu: cpu,
+              totalMem: mem,
+              elapsedSec: 0,
+            });
+          }
+        }
+      }
+    }
+
+    return Array.from(builds.values());
+  } catch {
+    return [];
+  }
+}