pyre-cli 10.3.0 → 10.5.0

package/src/menu.test.ts

@@ -0,0 +1,110 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { ALL_COMMANDS, CATEGORIES, filterCommands } from './menu/commands.js';
+import { renderMenuScreen } from './menu/render.js';
+import type { MenuState } from './menu/types.js';
+
+describe('TUI Command Center & Tool Navigator', () => {
+  it('should define a comprehensive catalog of Pyre commands', () => {
+    assert.ok(ALL_COMMANDS.length >= 30, `Expected at least 30 commands, got ${ALL_COMMANDS.length}`);
+    const ids = ALL_COMMANDS.map((c) => c.id);
+    assert.ok(ids.includes('live'));
+    assert.ok(ids.includes('check'));
+    assert.ok(ids.includes('doctor'));
+    assert.ok(ids.includes('smart'));
+    assert.ok(ids.includes('anomalies'));
+    assert.ok(ids.includes('benchmark'));
+    assert.ok(ids.includes('optimize'));
+    assert.ok(ids.includes('brew'));
+    assert.ok(ids.includes('netusage'));
+    assert.ok(ids.includes('ui'));
+    assert.ok(ids.includes('web'));
+  });
+
+  it('should categorize every command into a valid category', () => {
+    const validCatIds = CATEGORIES.map((c) => c.id);
+    for (const cmd of ALL_COMMANDS) {
+      assert.ok(
+        validCatIds.includes(cmd.category),
+        `Command ${cmd.id} has invalid category: ${cmd.category}`
+      );
+      assert.ok(cmd.name.length > 0);
+      assert.ok(cmd.cli.startsWith('pyre '));
+      assert.ok(cmd.description.length > 0);
+      assert.ok(Array.isArray(cmd.tags));
+      assert.ok(cmd.tags.length > 0);
+    }
+  });
+
+  it('should filter commands by category', () => {
+    const healthCmds = filterCommands(ALL_COMMANDS, 'health', '');
+    assert.ok(healthCmds.length >= 4);
+    assert.ok(healthCmds.some((c) => c.id === 'doctor'));
+    assert.ok(healthCmds.some((c) => c.id === 'check'));
+    assert.ok(healthCmds.some((c) => c.id === 'smart'));
+    assert.ok(healthCmds.every((c) => c.category === 'health'));
+
+    const perfCmds = filterCommands(ALL_COMMANDS, 'performance', '');
+    assert.ok(perfCmds.some((c) => c.id === 'benchmark'));
+    assert.ok(perfCmds.some((c) => c.id === 'stress'));
+  });
+
+  it('should fuzzy search commands by name, tag, or description', () => {
+    // Search by exact name
+    const docResults = filterCommands(ALL_COMMANDS, 'all', 'doctor');
+    assert.strictEqual(docResults[0].id, 'doctor');
+
+    // Search by tag
+    const nvmeResults = filterCommands(ALL_COMMANDS, 'all', 'nvme');
+    assert.ok(nvmeResults.some((c) => c.id === 'smart'));
+
+    // Search by keyword in description
+    const idleResults = filterCommands(ALL_COMMANDS, 'all', 'idle');
+    assert.ok(idleResults.some((c) => c.id === 'optimize'));
+  });
+
+  it('should render menu screen without crashing', () => {
+    const state: MenuState = {
+      category: 'all',
+      categoryIndex: 0,
+      searchQuery: '',
+      selectedIndex: 0,
+      scrollOffset: 0,
+      inputMode: 'search',
+      argPromptValue: '',
+      activeCommand: null,
+      statusMessage: '',
+      termWidth: 100,
+      termHeight: 30,
+      theme: 'default',
+    };
+
+    const rendered = renderMenuScreen(state, ALL_COMMANDS);
+    assert.ok(typeof rendered === 'string');
+    assert.ok(rendered.includes('Command Center'));
+    assert.ok(rendered.includes('Search:'));
+    assert.ok(rendered.includes('pyre live'));
+  });
+
+  it('should render argument prompt modal when inputMode is prompt-args', () => {
+    const benchCmd = ALL_COMMANDS.find((c) => c.id === 'bench')!;
+    const state: MenuState = {
+      category: 'performance',
+      categoryIndex: 3,
+      searchQuery: '',
+      selectedIndex: 0,
+      scrollOffset: 0,
+      inputMode: 'prompt-args',
+      argPromptValue: 'npm test',
+      activeCommand: benchCmd,
+      statusMessage: '',
+      termWidth: 100,
+      termHeight: 30,
+      theme: 'default',
+    };
+
+    const rendered = renderMenuScreen(state, [benchCmd]);
+    assert.ok(rendered.includes('Execute:'));
+    assert.ok(rendered.includes('npm test'));
+  });
+});

package/src/monitors/blender.ts

@@ -1,13 +1,17 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { run } from './run.js';
 import type { BlenderRenderData } from './types.js';
+import { collectWindowsProcesses } from './platform/windows.js';
 
-const RENDER_LOG_DIR = '/tmp/blender_render_logs';
+const RENDER_LOG_DIR = path.join(os.tmpdir(), 'blender_render_logs');
 
 function blendFileFromArgs(args: string[]): string {
   const nonFlag = args.filter(a => !a.startsWith('-'));
   for (const a of nonFlag) {
     if (a.endsWith('.blend') || a.includes('.blend')) {
-      return a.split('/').pop() || a;
+      return a.split(/[/\\]/).pop() || a;
     }
   }
   return 'unknown.blend';
@@ -25,15 +29,17 @@ function outputPathFromArgs(args: string[]): string {
   const oIdx = args.indexOf('-o');
   if (oIdx !== -1 && args[oIdx + 1]) {
     let p = args[oIdx + 1];
-    if (p.endsWith('/')) p = p.slice(0, -1);
-    return p.split('/').slice(0, -1).join('/') || '/tmp';
+    if (p.endsWith('/') || p.endsWith('\\')) p = p.slice(0, -1);
+    const parts = p.split(/[/\\]/);
+    return parts.slice(0, -1).join('/') || os.tmpdir();
   }
   const fFlag = args.find(a => a.startsWith('-o='));
   if (fFlag) {
     const p = fFlag.slice(3);
-    return p.endsWith('/') ? p.slice(0, -1).split('/').slice(0, -1).join('/') || '/tmp' : p.split('/').slice(0, -1).join('/') || '/tmp';
+    const parts = p.split(/[/\\]/);
+    return parts.slice(0, -1).join('/') || os.tmpdir();
   }
-  return '/tmp';
+  return os.tmpdir();
 }
 
 function frameRangeFromArgs(args: string[]): { start: number; end: number } {
@@ -57,11 +63,17 @@ function frameRangeFromArgs(args: string[]): { start: number; end: number } {
 async function parseRenderLog(blendName: string): Promise<{ framesRendered: number; totalFrames: number; startTime: number; samples?: number } | null> {
   const baseName = blendName.replace(/\.blend$/i, '');
   try {
-    const entries = (await run(`ls -t "${RENDER_LOG_DIR}" 2>/dev/null | grep "^${baseName}_" | head -5`, '')).trim().split('\n').filter(Boolean);
+    if (!fs.existsSync(RENDER_LOG_DIR)) return null;
+    const entries = fs.readdirSync(RENDER_LOG_DIR)
+      .filter(f => f.startsWith(`${baseName}_`))
+      .map(f => ({ name: f, time: fs.statSync(path.join(RENDER_LOG_DIR, f)).mtimeMs }))
+      .sort((a, b) => b.time - a.time)
+      .slice(0, 5);
+
     for (const entry of entries) {
-      const logPath = `${RENDER_LOG_DIR}/${entry}`;
+      const logPath = path.join(RENDER_LOG_DIR, entry.name);
       try {
-        const content = await run(`cat "${logPath}" 2>/dev/null`, '', 500);
+        const content = fs.readFileSync(logPath, 'utf-8');
         if (!content) continue;
         const lines = content.split('\n');
         const rendered = lines.filter(l => /Fra:(\d+)/i.test(l)).length;
@@ -86,21 +98,39 @@ async function parseRenderLog(blendName: string): Promise<{ framesRendered: numb
 export async function collectBlenderRenders(): Promise<BlenderRenderData[]> {
   const renders: BlenderRenderData[] = [];
   try {
-    const psRaw = await run("ps -eo pid,pcpu,pmem,state,command 2>/dev/null | grep -iE '[b]lender'", '', 2000);
-    if (!psRaw) return renders;
+    interface BlenderProc {
+      pid: number;
+      cpuPct: number;
+      command: string;
+    }
+    const procList: BlenderProc[] = [];
 
-    const lines = psRaw.split('\n');
-    for (const line of lines) {
-      const parts = line.trim().match(/\s*(\d+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+(.+)/);
-      if (!parts) continue;
+    if (process.platform === 'win32') {
+      const procs = await collectWindowsProcesses();
+      for (const p of procs) {
+        if (/blender/i.test(p.command)) {
+          procList.push({ pid: p.pid, cpuPct: p.cpu, command: p.command });
+        }
+      }
+    } else {
+      const psRaw = await run("ps -eo pid,pcpu,pmem,state,command 2>/dev/null | grep -iE '[b]lender'", '', 2000);
+      if (psRaw) {
+        const lines = psRaw.split('\n');
+        for (const line of lines) {
+          const parts = line.trim().match(/\s*(\d+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+(.+)/);
+          if (parts) {
+            procList.push({ pid: parseInt(parts[1], 10), cpuPct: parseFloat(parts[2]), command: parts[5] });
+          }
+        }
+      }
+    }
 
-      const pid = parseInt(parts[1], 10);
-      const cpuPct = parseFloat(parts[2]);
-      const command = parts[5];
+    for (const p of procList) {
+      const { pid, cpuPct, command } = p;
       const args = command.split(/\s+/);
 
       const isRender = /-b|--background|-f\s/.test(command) || /render/i.test(command);
-      if (!isRender && !command.includes('blender')) continue;
+      if (!isRender && !command.toLowerCase().includes('blender')) continue;
 
       const blendFile = blendFileFromArgs(args);
       const engine = engineFromArgs(args);

package/src/monitors/buildTracker.ts

@@ -1,14 +1,15 @@
 /**
  * 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.
+ * Scans active processes for compiler invocations (xcodebuild, msbuild, cargo, rustc,
+ * clang, cl.exe, make, ninja, bazel, cmake, go build), tracking compiler
+ * parallelism, CPU/RAM usage, and estimated elapsed time across macOS, Linux, and Windows.
  */
 import { run } from './run.js';
+import { collectWindowsProcesses } from './platform/windows.js';
 
 export interface ActiveBuild {
-  tool: 'xcodebuild' | 'cargo' | 'swift' | 'make' | 'ninja' | 'bazel' | 'go' | 'clang' | 'compiler';
+  tool: 'xcodebuild' | 'cargo' | 'swift' | 'make' | 'ninja' | 'bazel' | 'go' | 'clang' | 'compiler' | 'msbuild' | 'cmake';
   rootPid: number;
   command: string;
   compilerProcesses: number;
@@ -20,52 +21,79 @@ export interface ActiveBuild {
 
 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: 'msbuild', match: /\b(msbuild|devenv)\b/i },
       { name: 'xcodebuild', match: /xcodebuild/i },
-      { name: 'cargo', match: /\bcargo\s+(build|check|test|run)\b/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: 'make', match: /\b(make|nmake)\b/i },
       { name: 'ninja', match: /\bninja\b/i },
+      { name: 'cmake', match: /\bcmake\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;
+    const compilerMatch = /(clang|swift-frontend|rustc|go tool compile|gcc|g\+\+|ghc|cl\.exe|csc\.exe|link\.exe)/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;
+    interface ProcEntry {
+      pid: number;
+      cpu: number;
+      mem: number;
+      elapsedSec: number;
+      cmd: string;
+    }
 
-      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(' ');
+    const procList: ProcEntry[] = [];
 
-      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];
+    if (process.platform === 'win32') {
+      const winProcs = await collectWindowsProcesses();
+      for (const p of winProcs) {
+        procList.push({
+          pid: p.pid,
+          cpu: p.cpu,
+          mem: p.mem,
+          elapsedSec: p.runtime || 0,
+          cmd: p.command,
+        });
+      }
+    } else {
+      const raw = await run('ps -eo pid,ppid,pcpu,pmem,etime,command -r 2>/dev/null', '');
+      if (!raw) return [];
+      const lines = raw.split('\n').slice(1);
+      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(' ');
+
+        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];
 
+        procList.push({ pid, cpu, mem, elapsedSec, cmd });
+      }
+    }
+
+    // First pass: identify build roots
+    for (const p of procList) {
+      for (const pattern of buildToolPatterns) {
+        if (pattern.match.test(p.cmd)) {
           builds.set(pattern.name, {
             tool: pattern.name,
-            rootPid: pid,
-            command: cmd.slice(0, 80),
+            rootPid: p.pid,
+            command: p.cmd.slice(0, 80),
             compilerProcesses: 1,
-            totalCpu: cpu,
-            totalMem: mem,
-            elapsedSec,
-            target: cmd.split(' ').slice(1, 4).join(' '),
+            totalCpu: p.cpu,
+            totalMem: p.mem,
+            elapsedSec: p.elapsedSec,
+            target: p.cmd.split(' ').slice(1, 4).join(' '),
           });
           break;
         }
@@ -73,41 +101,31 @@ export async function collectBuilds(): Promise<ActiveBuild[]> {
     }
 
     // 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
+    for (const p of procList) {
+      if (compilerMatch.test(p.cmd)) {
         if (builds.size > 0) {
           const firstBuild = builds.values().next().value;
           if (firstBuild) {
             firstBuild.compilerProcesses += 1;
-            firstBuild.totalCpu += cpu;
-            firstBuild.totalMem += mem;
+            firstBuild.totalCpu += p.cpu;
+            firstBuild.totalMem += p.mem;
           }
         } else {
-          // Standalone compiler invocation
           const key = 'compiler';
           const existing = builds.get(key);
           if (existing) {
             existing.compilerProcesses += 1;
-            existing.totalCpu += cpu;
-            existing.totalMem += mem;
+            existing.totalCpu += p.cpu;
+            existing.totalMem += p.mem;
           } else {
             builds.set(key, {
               tool: 'compiler',
-              rootPid: parseInt(parts[0], 10),
-              command: cmd.slice(0, 80),
+              rootPid: p.pid,
+              command: p.cmd.slice(0, 80),
               compilerProcesses: 1,
-              totalCpu: cpu,
-              totalMem: mem,
-              elapsedSec: 0,
+              totalCpu: p.cpu,
+              totalMem: p.mem,
+              elapsedSec: p.elapsedSec,
             });
           }
         }

package/src/monitors/platform/windows-ui.ps1

@@ -1,42 +1,44 @@
 <#
 .SYNOPSIS
-Launches a native Pyre UI window on Windows using WPF WebBrowser control.
+Launches a native standalone Pyre UI window on Windows.
+Prefers Microsoft Edge or Chromium in standalone desktop application mode (--app)
+for modern HTML5/ES6/Chart.js rendering without browser tabs or address bars.
 #>
 param(
     [Parameter(Mandatory=$true)]
     [int]$Port
 )
 
-$ErrorActionPreference = 'Stop'
+$ErrorActionPreference = 'SilentlyContinue'
 
-Add-Type -AssemblyName System.Windows.Forms
-Add-Type -AssemblyName System.Drawing
-Add-Type -AssemblyName PresentationFramework
+$url = "http://localhost:$Port/"
 
-$regPath = "HKCU:\Software\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION"
-if (-not (Test-Path $regPath)) {
-    New-Item -Path $regPath -Force | Out-Null
-}
-$scriptName = [System.IO.Path]::GetFileName($PSCommandPath)
-Set-ItemProperty -Path $regPath -Name $scriptName -Value 11001 -Type DWord -ErrorAction SilentlyContinue
-
-$form = New-Object System.Windows.Forms.Form
-$form.Text = "Pyre Live Dashboard"
-$form.Width = 1200
-$form.Height = 800
-$form.StartPosition = "CenterScreen"
-$form.MinimumSize = New-Object System.Drawing.Size(860, 600)
-$form.BackColor = [System.Drawing.Color]::FromArgb(10, 10, 15)
-$form.ForeColor = [System.Drawing.Color]::FromArgb(245, 245, 247)
+# 1. Search for Edge or Chrome executable paths
+$browsers = @(
+    "$env:ProgramFiles (x86)\Microsoft\Edge\Application\msedge.exe",
+    "$env:ProgramFiles\Microsoft\Edge\Application\msedge.exe",
+    "$env:LocalAppData\Microsoft\Edge\Application\msedge.exe",
+    "$env:ProgramFiles\Google\Chrome\Application\chrome.exe",
+    "$env:ProgramFiles (x86)\Google\Chrome\Application\chrome.exe",
+    "$env:LocalAppData\Google\Chrome\Application\chrome.exe",
+    "$env:ProgramFiles\BraveSoftware\Brave-Browser\Application\brave.exe"
+)
 
-$browser = New-Object System.Windows.Forms.WebBrowser
-$browser.Dock = "Fill"
-$browser.ScriptErrorsSuppressed = $true
-$browser.Navigate("http://localhost:$Port/")
-$form.Controls.Add($browser)
+$targetBrowser = $null
+foreach ($b in $browsers) {
+    if (Test-Path $b) {
+        $targetBrowser = $b
+        break
+    }
+}
 
-$form.Add_Shown({
-    $form.Activate()
-})
+if ($targetBrowser) {
+    # Launch in standalone application window mode (frameless app window)
+    $args = "--app=$url --window-size=1200,800"
+    $proc = Start-Process -FilePath $targetBrowser -ArgumentList $args -PassThru -Wait
+    exit 0
+}
 
-$form.ShowDialog()
+# 2. Fallback: Launch default system browser
+Start-Process $url
+exit 0