pyre-cli 7.1.0 → 8.0.0

package/src/sparkline.ts

@@ -8,8 +8,15 @@ const BLOCKS = ' ▂▃▄▅▆▇█';
  * Unicode block characters to represent the range, making
  * it suitable for inline terminal graphs.
  */
-export function sparkline(values: number[], opts: { min?: number; max?: number } = {}): string {
+export function sparkline(values: number[], opts: { min?: number; max?: number; plainText?: boolean } = {}): string {
   if (!values.length) return '';
+  if (opts.plainText) {
+    const first = values[0];
+    const last = values[values.length - 1];
+    const diff = last - first;
+    const sign = diff >= 0 ? '+' : '';
+    return `[${first.toFixed(1)} -> ${last.toFixed(1)} (Δ:${sign}${diff.toFixed(1)})]`;
+  }
   let min = opts.min ?? Infinity;
   let max = opts.max ?? -Infinity;
   if (opts.min === undefined || opts.max === undefined) {
@@ -29,6 +36,60 @@ export function sparkline(values: number[], opts: { min?: number; max?: number }
     .join('');
 }
 
+/**
+ * Render a multi-row unicode sparkline area graph.
+ * Returns an array of strings representing each row from top to bottom.
+ */
+export function multiRowBrailleGraph(
+  values: number[],
+  height: number,
+  opts: { min?: number; max?: number } = {}
+): string[] {
+  if (!values.length || height <= 0) return Array(height).fill('');
+  let min = opts.min ?? Infinity;
+  let max = opts.max ?? -Infinity;
+  if (opts.min === undefined || opts.max === undefined) {
+    for (const v of values) {
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  const range = max - min || 1;
+  const levels = height * 4;
+
+  const dotsCol0 = [0x40, 0x04, 0x02, 0x01]; // bottom to top
+  const dotsCol1 = [0x80, 0x20, 0x10, 0x08]; // bottom to top
+
+  const rows: string[][] = Array.from({ length: height }, () => []);
+
+  for (let i = 0; i < values.length; i += 2) {
+    const v0 = values[i];
+    const v1 = i + 1 < values.length ? values[i + 1] : v0;
+
+    const rawSteps0 = Math.round(((v0 - min) / range) * levels);
+    const totalSteps0 = Math.min(levels, Math.max(0, rawSteps0));
+
+    const rawSteps1 = Math.round(((v1 - min) / range) * levels);
+    const totalSteps1 = Math.min(levels, Math.max(0, rawSteps1));
+
+    for (let r = 0; r < height; r++) {
+      const rowFromBottom = height - 1 - r;
+      const minForThisRow = rowFromBottom * 4;
+
+      const stepsInThisRow0 = Math.min(4, Math.max(0, totalSteps0 - minForThisRow));
+      const stepsInThisRow1 = Math.min(4, Math.max(0, totalSteps1 - minForThisRow));
+
+      let code = 0x2800;
+      for (let d = 0; d < stepsInThisRow0; d++) code |= dotsCol0[d];
+      for (let d = 0; d < stepsInThisRow1; d++) code |= dotsCol1[d];
+
+      rows[r].push(String.fromCharCode(code));
+    }
+  }
+
+  return rows.map(r => r.join(''));
+}
+
 /**
  * Render a multi-row unicode sparkline area graph.
  * Returns an array of strings representing each row from top to bottom.
@@ -64,7 +125,7 @@ export function multiRowSparkline(
       if (stepsInThisRow === 0) {
         rows[r].push(' ');
       } else {
-        rows[r].push(BLOCKS[stepsInThisRow]);
+        rows[r].push(BLOCKS[Math.min(7, stepsInThisRow)]);
       }
     }
   }

package/src/state/config.ts

@@ -26,14 +26,16 @@ export interface PyreConfig {
   graphMode?: string;
   showGraphs?: boolean;
   autoLog?: boolean;
-   mouseEnabled?: boolean;
+  mouseEnabled?: boolean;
   cpuAlertPct?: number;
   tempAlertC?: number;
+  electricityRateKwH?: number;
   notificationsEnabled?: boolean;
   p2pPort?: number;
   p2pPassword?: string;
   splashEnabled?: boolean;
   splashColorScheme?: string;
+  splashAnimation?: string;
   watchdogProcess?: string;
   watchdogCpu?: number;
   watchdogMem?: number;
@@ -69,6 +71,7 @@ export const DEFAULT_CONFIG: Required<PyreConfig> = {
   mouseEnabled: true,
   cpuAlertPct: 90,
   tempAlertC: 95,
+  electricityRateKwH: 0.15,
   watchdogProcess: '',
   watchdogCpu: 80,
   watchdogMem: 80,
@@ -120,6 +123,37 @@ export function writeConfig(config: Partial<PyreConfig>): void {
   }
 }
 
+const PROFILES_DIR = path.join(CONFIG_DIR, 'profiles');
+
+export function saveProfile(name: string): void {
+  if (!name || name.includes('/') || name.includes('\\')) {
+    throw new Error('Invalid profile name.');
+  }
+  if (!fs.existsSync(PROFILES_DIR)) {
+    fs.mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+  const currentConfig = readConfig();
+  const profileFile = path.join(PROFILES_DIR, `${name}.json`);
+  fs.writeFileSync(profileFile, JSON.stringify(currentConfig, null, 2) + '\n');
+}
+
+export function loadProfile(name: string): void {
+  const profileFile = path.join(PROFILES_DIR, `${name}.json`);
+  if (!fs.existsSync(profileFile)) {
+    throw new Error(`Profile '${name}' does not exist.`);
+  }
+  const raw = fs.readFileSync(profileFile, 'utf-8');
+  const parsed = JSON.parse(raw);
+  // Atomic write to main config
+  writeConfig(parsed);
+}
+
+export function listProfiles(): string[] {
+  if (!fs.existsSync(PROFILES_DIR)) return [];
+  const files = fs.readdirSync(PROFILES_DIR);
+  return files.filter(f => f.endsWith('.json')).map(f => f.replace(/\.json$/, ''));
+}
+
 function deepMerge(target: any, source: any): any {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -138,4 +172,4 @@ export function getConfigPath(): string {
   return CONFIG_FILE;
 }
 
-export { CONFIG_FILE };
+export { CONFIG_FILE, PROFILES_DIR };

package/src/updateCheck.ts

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import https from 'node:https';
+import chalk from 'chalk';
+
+const UPDATE_CACHE_FILE = path.join(os.homedir(), '.config', 'pyre', 'update-check.json');
+
+export interface UpdateCheckResult {
+  currentVersion: string;
+  latestVersion: string;
+  hasUpdate: boolean;
+}
+
+export function checkForUpdates(currentVersion: string): Promise<UpdateCheckResult | null> {
+  return new Promise((resolve) => {
+    try {
+      if (fs.existsSync(UPDATE_CACHE_FILE)) {
+        const raw = fs.readFileSync(UPDATE_CACHE_FILE, 'utf-8');
+        const cached = JSON.parse(raw);
+        // Check once every 24 hours
+        if (Date.now() - (cached.lastChecked || 0) < 24 * 60 * 60 * 1000) {
+          return resolve({
+            currentVersion,
+            latestVersion: cached.latestVersion || currentVersion,
+            hasUpdate: isNewerVersion(currentVersion, cached.latestVersion),
+          });
+        }
+      }
+    } catch {
+      // ignore cache errors
+    }
+
+    const req = https.get('https://registry.npmjs.org/pyre-cli/latest', { timeout: 2000 }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          if (res.statusCode === 200) {
+            const data = JSON.parse(body);
+            const latestVersion = data.version || currentVersion;
+            fs.mkdirSync(path.dirname(UPDATE_CACHE_FILE), { recursive: true });
+            fs.writeFileSync(UPDATE_CACHE_FILE, JSON.stringify({ lastChecked: Date.now(), latestVersion }));
+            return resolve({
+              currentVersion,
+              latestVersion,
+              hasUpdate: isNewerVersion(currentVersion, latestVersion),
+            });
+          }
+        } catch {
+          // ignore parse errors
+        }
+        resolve(null);
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+function isNewerVersion(current: string, latest?: string): boolean {
+  if (!latest) return false;
+  const cParts = current.split('.').map(n => parseInt(n, 10));
+  const lParts = latest.split('.').map(n => parseInt(n, 10));
+  for (let i = 0; i < Math.max(cParts.length, lParts.length); i++) {
+    const c = cParts[i] || 0;
+    const l = lParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+}
+
+export async function printUpdateReport(currentVersion: string): Promise<void> {
+  console.log(chalk.bold('\n  pyre update — Version Check\n'));
+  console.log(`  Current Version: ${chalk.bold(currentVersion)}`);
+  
+  const result = await checkForUpdates(currentVersion);
+  if (!result) {
+    console.log(chalk.yellow('  ⚠ Unable to reach npm registry for update check.\n'));
+    return;
+  }
+
+  if (result.hasUpdate) {
+    console.log(chalk.green.bold(`  🚀 A new version of pyre is available: v${result.latestVersion}`));
+    console.log(chalk.dim(`  Run "npm install -g pyre-cli" to update.\n`));
+  } else {
+    console.log(chalk.green(`  ✔ You are running the latest version of pyre (v${currentVersion}).\n`));
+  }
+}