pyre-cli 4.17.0 → 5.1.0

package/src/live/render.ts

@@ -6,11 +6,28 @@
  * alert checker.  All state variables are imported from
  * `state.ts`.
  */
+import { execFile } from 'node:child_process';
 import chalk from 'chalk';
 import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel } from '../formatters/index.js';
+import { detectAnomalies } from '../anomalies.js';
 import { state, setStatus, SIGNAL_OPTIONS, getToggleKey } from './state.js';
 import type { StatsData } from '../monitors/index.js';
 
+function formatTempForUnit(c: number): string {
+  if (state.tempUnit === 'f') {
+    const f = c * (9 / 5) + 32;
+    return `${f.toFixed(1)}°F`;
+  }
+  return `${c.toFixed(1)}°C`;
+}
+
+function applyTempUnit(text: string): string {
+  if (state.tempUnit === 'f') {
+    return text.replace(/([\d.]+)°C \/ ([\d.]+)°F/g, '$2°F');
+  }
+  return text.replace(/([\d.]+)°C \/ ([\d.]+)°F/g, '$1°C');
+}
+
 // --- render caching -----------------------------------------------------------
 
 let _cachedTable = '';
@@ -103,28 +120,33 @@ function renderCustomizerOverlay(): string {
      chalk.bgCyan.black.bold(' UI CUSTOMIZER (Use ↑/↓ or J/K to navigate, Enter/Space to toggle, Esc to exit) '),
    ];
 
-    state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
-      const isSelected = idx === state.customizerIndex;
-      const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
-
-       if (opt === 'Theme') {
-         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
-       } else if (opt === 'Graph Mode') {
-         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
-       } else if (opt === 'Splash Screen') {
-         const status = state.splashEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
-         lines.push(`${prefix}${opt}: ${status}`);
-       } else if (opt === 'Splash Color') {
-         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
-       } else if (opt === 'Splash Animation') {
-         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
-       } else {
-         const toggleKey = getToggleKey(opt);
-         const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
-         const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
-         lines.push(`${prefix}${opt}: ${status}`);
-       }
-    });
+     state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
+       const isSelected = idx === state.customizerIndex;
+       const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
+
+        if (opt === 'Theme') {
+          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
+        } else if (opt === 'Graph Mode') {
+          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
+        } else if (opt === 'Splash Screen') {
+          const status = state.splashEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
+          lines.push(`${prefix}${opt}: ${status}`);
+        } else if (opt === 'Splash Color') {
+          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
+        } else if (opt === 'Splash Animation') {
+          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
+        } else if (opt === 'Notifications') {
+          const status = state.notificationsEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
+          lines.push(`${prefix}${opt}: ${status}`);
+        } else if (opt === 'Temperature Unit') {
+          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.tempUnit.toUpperCase())} [C, F]`);
+        } else {
+          const toggleKey = getToggleKey(opt);
+          const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
+          const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
+          lines.push(`${prefix}${opt}: ${status}`);
+        }
+     });
 
    return lines.map(l => `  ${l}`).join('\n');
  }
@@ -170,26 +192,31 @@ function render() {
   const lines: string[] = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
 
-  const params = tableCacheParams();
-  const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || params !== _cachedTableParams
-    ? (() => {
-        const out = formatTable(state.lastData, {
-          width: state.termWidth,
-          sortBy: state.sortMode,
-          filter: state.processFilter || undefined,
-          processLimit: processRowBudget(),
-          theme: state.currentTheme,
-          visible: state.visiblePanels,
-          treeView: state.treeView,
-          activePanel: state.activePanel,
-        });
-        _cachedTableData = state.lastData;
-        _cachedTableParams = params;
-        _cachedTable = out;
-        _tableDataDirty = false;
-        return out;
-      })()
-    : _cachedTable;
+   const params = tableCacheParams();
+   const anomalies = detectAnomalies(state.lastData, state.history);
+   const anomalyCacheKey = anomalies.map(a => `${a.metric}:${a.zScore.toFixed(2)}`).join(',');
+   const cacheParams = params + '|' + anomalyCacheKey;
+    const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || cacheParams !== _cachedTableParams
+      ? (() => {
+          const out = formatTable(state.lastData, {
+            width: state.termWidth,
+            sortBy: state.sortMode,
+            filter: state.processFilter || undefined,
+            processLimit: processRowBudget(),
+            theme: state.currentTheme,
+            visible: state.visiblePanels,
+            treeView: state.treeView,
+            activePanel: state.activePanel,
+            anomalies,
+            tempUnit: state.tempUnit,
+          });
+          _cachedTableData = state.lastData;
+          _cachedTableParams = cacheParams;
+          _cachedTable = applyTempUnit(out);
+          _tableDataDirty = false;
+          return _cachedTable;
+        })()
+      : _cachedTable;
 
   const bodyLines: string[] = [];
   if (state.activePanel === 'p2p') {
@@ -206,8 +233,8 @@ function render() {
           const out = formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode);
           _cachedGraphsVersion = state.history.version;
           _cachedGraphsParams = graphsParams;
-          _cachedGraphs = out;
-          return out;
+          _cachedGraphs = applyTempUnit(out);
+          return _cachedGraphs;
         })()
       : _cachedGraphs;
 
@@ -254,16 +281,17 @@ function render() {
 
 function footerLine(): string {
    const row1: [string, string][] = [
-     ['q', 'quit'],
-     ['c', 'customize UI'],
-     ['←/→', 'tab'],
-     ['1-9', 'panels'],
-     ['g', state.showGraphs ? 'hide graphs' : 'show graphs'],
-     ['b', `graph:${state.graphMode}`],
-     ['t', state.treeView ? 'flat' : 'tree'],
-     ['d', state.detailed ? 'basic' : 'detailed'],
-     ['p', state.paused ? 'resume' : 'pause'],
-   ];
+      ['q', 'quit'],
+      ['c', 'customize UI'],
+      ['←/→', 'tab'],
+      ['1-9', 'panels'],
+      ['g', state.showGraphs ? 'hide graphs' : 'show graphs'],
+      ['b', `graph:${state.graphMode}`],
+      ['t', state.treeView ? 'flat' : 'tree'],
+      ['d', state.detailed ? 'basic' : 'detailed'],
+      ['T', `temp:${state.tempUnit}`],
+      ['p', state.paused ? 'resume' : 'pause'],
+    ];
    const row2: [string, string][] = [
      ['s', `sort:${state.sortMode}`],
      ['/', 'filter'],
@@ -286,20 +314,40 @@ function footerLine(): string {
    if (state.p2pServerRunning) badges.push(chalk.green.bold(`P2P ${state.p2pBind || '0.0.0.0'}:${state.p2pPort}`));
    const badgeStr = badges.join('  ');
 
-   return badgeStr ? `${str1}\n${str2}    ${badgeStr}` : `${str1}\n${str2}`;
-  }
+return badgeStr ? `${str1}\n${str2}    ${badgeStr}` : `${str1}\n${str2}`;
+   }
+
+function sendNotification(title: string, message: string) {
+  if (!state.notificationsEnabled) return;
+  execFile('osascript', ['-e', `display notification "${message}" with title "${title}"`], (err) => {
+    if (err) {
+      // Silently ignore notification failures (e.g., terminal not in focus, no notification permission)
+    }
+  });
+}
 
 function checkAlerts(data: StatsData) {
-  const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
-  const hot = data.cpu.usage >= state.CPU_ALERT_PCT || (temp !== null && temp >= state.TEMP_ALERT_C);
-  if (hot && !state.alerted) {
-    state.alerted = true;
-    process.stdout.write('\x07');
-    const reason = data.cpu.usage >= state.CPU_ALERT_PCT ? `CPU at ${data.cpu.usage}%` : `Temp at ${temp}°C`;
-    setStatus(chalk.red(`⚠ Alert: ${reason}`), 5000);
-  } else if (!hot) {
-    state.alerted = false;
+   const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+   const hot = data.cpu.usage >= state.CPU_ALERT_PCT || (temp !== null && temp >= state.TEMP_ALERT_C);
+   const anomalies = detectAnomalies(data, state.history);
+   const hasCriticalAnomaly = anomalies.some(a => a.severity === 'critical');
+   const hasWarningAnomaly = anomalies.some(a => a.severity === 'warning');
+   const anomalyTriggered = hasCriticalAnomaly || hasWarningAnomaly;
+
+   if ((hot || anomalyTriggered) && !state.alerted) {
+     state.alerted = true;
+     process.stdout.write('\x07');
+     const reasons: string[] = [];
+     if (data.cpu.usage >= state.CPU_ALERT_PCT) reasons.push(`CPU at ${data.cpu.usage}%`);
+     if (temp !== null && temp >= state.TEMP_ALERT_C) reasons.push(`Temp at ${formatTempForUnit(temp)}`);
+     for (const a of anomalies) {
+       reasons.push(`${a.metric} anomaly (σ=${a.zScore.toFixed(1)})`);
+     }
+      setStatus(chalk.red(`⚠ Alert: ${reasons.join('; ')}`), 5000);
+      sendNotification('pyre Alert', reasons.join('; '));
+    } else if (!hot && !anomalyTriggered) {
+     state.alerted = false;
+   }
   }
-}
 
 export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget, invalidateTableCache, invalidateFrame };

package/src/live/state.ts

@@ -11,6 +11,7 @@ import { History } from '../history.js';
 import type { StatsData } from '../monitors/index.js';
 import type { ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
 import type { ThemeName, VisibleItems } from '../formatters/types.js';
+import { readConfig, type PyreConfig } from '../state/config.js';
 
 export const SIGNAL_OPTIONS = ['SIGTERM', 'SIGKILL', 'SIGINT', 'SIGHUP', 'SIGSTOP', 'SIGCONT'] as const;
 
@@ -18,54 +19,61 @@ import { type SplashColorScheme, type SplashAnimation } from '../splash.js';
 
 export { type SplashColorScheme, type SplashAnimation };
 
+const config = readConfig();
+
 const state = {
    intervalHandle: null as NodeJS.Timeout | null,
    uiIntervalHandle: null as NodeJS.Timeout | null,
    running: false,
    paused: false,
-   detailed: false,
-    interval: 2,
-    showGraphs: true,
-    graphMode: 'spark' as GraphMode,
+   detailed: config.detailed,
+    interval: config.interval,
+    showGraphs: config.showGraphs,
+    graphMode: config.graphMode as GraphMode,
     exportFormat: 'json' as ExportFormat,
+    tempUnit: 'c' as 'c' | 'f',
 
-
-   exportDir: './pyre-exports',
-   currentTheme: 'default' as ThemeName,
-    visiblePanels: {
-      cpu: true,
-      mem: true,
-      gpu: true,
-      power: true,
-      battery: true,
-      thermal: true,
-      network: true,
-      packets: true,
-      tasks: true,
-      disk: true,
-      process: true,
-    } as VisibleItems,
-   logging: false,
-   logStream: null as fs.WriteStream | null,
-   statusMessage: '',
-   statusTimer: null as NodeJS.Timeout | null,
-   lastData: null as StatsData | null,
-   history: new History(40),
-   keypressHandler: null as ((str: string, key: readline.Key) => void) | null,
-   termWidth: process.stdout.columns || 80,
-   termHeight: process.stdout.rows || 24,
-   sortMode: 'cpu' as SortMode,
-   processFilter: '',
-   inputMode: null as InputMode,
-   inputBuffer: '',
-   targetPid: '',
-   selectedSignal: 'SIGTERM' as typeof SIGNAL_OPTIONS[number],
-   treeView: false,
-   SIGNAL_OPTIONS,
-   customizerIndex: 0,
+    exportDir: config.exportDir,
+    currentTheme: config.theme as ThemeName,
+     visiblePanels: {
+       cpu: config.visiblePanels.cpu,
+       mem: config.visiblePanels.mem,
+       gpu: config.visiblePanels.gpu,
+       power: config.visiblePanels.power,
+       battery: config.visiblePanels.battery,
+       thermal: config.visiblePanels.thermal,
+       network: config.visiblePanels.network,
+       packets: config.visiblePanels.packets,
+       tasks: config.visiblePanels.tasks,
+       disk: config.visiblePanels.disk,
+       process: config.visiblePanels.process,
+     } as VisibleItems,
+    logging: false,
+    logStream: null as fs.WriteStream | null,
+    statusMessage: '',
+    statusTimer: null as NodeJS.Timeout | null,
+    lastData: null as StatsData | null,
+    history: new History(40),
+    keypressHandler: null as ((str: string, key: readline.Key) => void) | null,
+    termWidth: process.stdout.columns || 80,
+    termHeight: process.stdout.rows || 24,
+    sortMode: config.sortMode as SortMode,
+    processFilter: '',
+    inputMode: null as InputMode,
+    inputBuffer: '',
+    targetPid: '',
+    selectedSignal: 'SIGTERM' as typeof SIGNAL_OPTIONS[number],
+    treeView: config.treeView,
+    SIGNAL_OPTIONS,
+     customizerIndex: 0,
      CUSTOMIZER_OPTIONS: [
        'Theme',
        'Graph Mode',
+       'Splash Screen',
+       'Splash Color',
+       'Splash Animation',
+       'Notifications',
+       'Temperature Unit',
        'Toggle CPU',
        'Toggle Memory',
        'Toggle GPU',
@@ -78,39 +86,37 @@ const state = {
        'Toggle Disk',
        'Toggle Processes',
        'Toggle Tree View',
-       'Splash Screen',
-       'Splash Color',
-       'Splash Animation',
      ],
-    CPU_ALERT_PCT: 90,
-    TEMP_ALERT_C: 95,
-    alerted: false,
-    activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p',
-     mouseEnabled: true,
-       PANEL_TABS: [
-         { id: 'cpu', label: 'CPU', key: '1' },
-         { id: 'mem', label: 'Memory', key: '2' },
-         { id: 'gpu', label: 'GPU', key: '3' },
-         { id: 'power', label: 'Power', key: '4' },
-         { id: 'battery', label: 'Battery', key: '5' },
-         { id: 'thermal', label: 'Thermal', key: '6' },
-         { id: 'network', label: 'Network', key: '7' },
-         { id: 'packets', label: 'Packets', key: '8' },
-         { id: 'tasks', label: 'Tasks', key: '9' },
-         { id: 'disk', label: 'Disk', key: '0' },
-         { id: 'process', label: 'Process', key: 'P' },
-         { id: 'p2p', label: 'P2P', key: 'R' },
-       ] as const,
-      p2pEvents: [] as { type: string; detail: string; ts: number }[],
-      p2pBind: '',
-      p2pServer: null as { stop: () => void; peerEventHistory: { type: string; detail: string; ts: number }[] } | null,
-      p2pServerRunning: false,
-      p2pPort: 9876,
-      p2pPassword: 'pyre',
-      splashEnabled: true,
-      splashColorScheme: 'fire' as SplashColorScheme,
-      splashAnimation: 'classic' as SplashAnimation,
-   };
+     CPU_ALERT_PCT: config.cpuAlertPct,
+     TEMP_ALERT_C: config.tempAlertC,
+     notificationsEnabled: config.notificationsEnabled,
+      alerted: false,
+      activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p',
+       mouseEnabled: config.mouseEnabled,
+         PANEL_TABS: [
+           { id: 'cpu', label: 'CPU', key: '1' },
+           { id: 'mem', label: 'Memory', key: '2' },
+           { id: 'gpu', label: 'GPU', key: '3' },
+           { id: 'power', label: 'Power', key: '4' },
+           { id: 'battery', label: 'Battery', key: '5' },
+           { id: 'thermal', label: 'Thermal', key: '6' },
+           { id: 'network', label: 'Network', key: '7' },
+           { id: 'packets', label: 'Packets', key: '8' },
+           { id: 'tasks', label: 'Tasks', key: '9' },
+           { id: 'disk', label: 'Disk', key: '0' },
+           { id: 'process', label: 'Process', key: 'P' },
+           { id: 'p2p', label: 'P2P', key: 'R' },
+         ] as const,
+        p2pEvents: [] as { type: string; detail: string; ts: number }[],
+        p2pBind: '',
+        p2pServer: null as { stop: () => void; peerEventHistory: { type: string; detail: string; ts: number }[] } | null,
+        p2pServerRunning: false,
+        p2pPort: config.p2pPort,
+        p2pPassword: config.p2pPassword,
+        splashEnabled: config.splashEnabled,
+        splashColorScheme: config.splashColorScheme as SplashColorScheme,
+        splashAnimation: config.splashAnimation as SplashAnimation,
+    };
 
 function setStatus(msg: string, ms = 3000) {
   state.statusMessage = msg;

package/src/live/types.ts

@@ -11,9 +11,12 @@ export interface LiveOptions {
   exportDir?: string;
   autoLog?: boolean;
   theme?: ThemeName;
+  alertCpu?: number;
+  alertTemp?: number;
+  tempUnit?: 'c' | 'f';
 }
 
-export type ExportFormat = 'json' | 'csv' | 'tsv';
+export type ExportFormat = 'json' | 'csv' | 'tsv' | 'html' | 'md';
 
 type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p';
 

package/src/monitors/collectors.ts

@@ -12,12 +12,14 @@
  * returning their best-effort values.
  */
 import chalk from 'chalk';
+import os from 'node:os';
 import { run } from './run.js';
 import { getSmcMetrics, parseSuffix } from './smc.js';
 import type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerData, DiskData, NetworkData, ProcessData, GpuData, PacketData, NetworkProcess } from './types.js';
 
 const SP_TTL_MS = 10_000;
 const NETSTAT_TTL_MS = 1000;
+let prevCpuTimes: { total: number; idle: number }[] | null = null;
 const ROUTE_TTL_MS = 5_000;
 const SYSCTL_TTL_MS = 60_000;
 
@@ -338,7 +340,27 @@ export async function collectCpu(): Promise<CpuData> {
     // ignore
   }
 
-  return { brand, cores, physicalCores, frequency, usage, loadAvg, temperature };
+  let coreUsage: number[] = [];
+  try {
+    const cpus = os.cpus();
+    const current = cpus.map(cpu => ({
+      total: cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq,
+      idle: cpu.times.idle,
+    }));
+    if (prevCpuTimes) {
+      coreUsage = prevCpuTimes.map((prev, i) => {
+        const totalDelta = current[i].total - prev.total;
+        const idleDelta = current[i].idle - prev.idle;
+        if (totalDelta === 0) return 0;
+        return Math.round(((totalDelta - idleDelta) / totalDelta) * 100);
+      });
+    }
+    prevCpuTimes = current;
+  } catch {
+    // ignore
+  }
+
+  return { brand, cores, physicalCores, frequency, usage, loadAvg, temperature, coreUsage };
 }
 
 export async function collectMemory(): Promise<MemoryData> {

package/src/monitors/types.ts

@@ -68,6 +68,7 @@ export interface CpuData {
   usage: number;
   loadAvg: number[];
   temperature?: number;
+  coreUsage?: number[];
 }
 
 export interface MemoryData {

package/src/state/config.ts

@@ -0,0 +1,130 @@
+/**
+ * pyre config file module.
+ *
+ * Reads and writes `~/.config/pyre/config.json` to persist
+ * user preferences across sessions.
+ *
+ * The config file stores theme, interval, panel visibility,
+ * sort mode, tree view, graph mode, alert thresholds, P2P
+ * defaults, export directory, and splash preferences.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'pyre');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export interface PyreConfig {
+  theme?: string;
+  interval?: number;
+  exportDir?: string;
+  detailed?: boolean;
+  sortMode?: string;
+  treeView?: boolean;
+  graphMode?: string;
+  showGraphs?: boolean;
+  autoLog?: boolean;
+   mouseEnabled?: boolean;
+  cpuAlertPct?: number;
+  tempAlertC?: number;
+  notificationsEnabled?: boolean;
+  p2pPort?: number;
+  p2pPassword?: string;
+  splashEnabled?: boolean;
+  splashColorScheme?: string;
+  splashAnimation?: string;
+  visiblePanels?: {
+    cpu?: boolean;
+    mem?: boolean;
+    gpu?: boolean;
+    power?: boolean;
+    battery?: boolean;
+    thermal?: boolean;
+    network?: boolean;
+    packets?: boolean;
+    tasks?: boolean;
+    disk?: boolean;
+    process?: boolean;
+    tree?: boolean;
+  };
+}
+
+export const DEFAULT_CONFIG: Required<PyreConfig> = {
+  theme: 'default',
+  interval: 2,
+  exportDir: './pyre-exports',
+  detailed: false,
+  sortMode: 'cpu',
+  treeView: false,
+  graphMode: 'spark',
+  showGraphs: true,
+  autoLog: false,
+  mouseEnabled: true,
+  cpuAlertPct: 90,
+  tempAlertC: 95,
+  notificationsEnabled: true,
+  p2pPort: 9876,
+  p2pPassword: 'pyre',
+  splashEnabled: true,
+  splashColorScheme: 'fire',
+  splashAnimation: 'classic',
+  visiblePanels: {
+    cpu: true,
+    mem: true,
+    gpu: true,
+    power: true,
+    battery: true,
+    thermal: true,
+    network: true,
+    packets: true,
+    tasks: true,
+    disk: true,
+    process: true,
+    tree: false,
+  },
+};
+
+export function readConfig(): Required<PyreConfig> {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const parsed = JSON.parse(raw) as Partial<PyreConfig>;
+    return deepMerge(DEFAULT_CONFIG, parsed);
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function writeConfig(config: Partial<PyreConfig>): void {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const merged = deepMerge(readConfig(), config);
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + '\n');
+  } catch {
+    // ignore write errors
+  }
+}
+
+function deepMerge(target: any, source: any): any {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] !== undefined && source[key] !== null) {
+      if (typeof source[key] === 'object' && !Array.isArray(source[key]) && typeof target[key] === 'object' && !Array.isArray(target[key])) {
+        result[key] = deepMerge(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+}
+
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}
+
+export { CONFIG_FILE };