pyre-cli 10.3.0 → 10.4.0

package/dist/{collectors-JDN5Y7EV.js → collectors-V7SCIIDH.js}

@@ -15,10 +15,12 @@ import {
   collectThermal,
   getDisplayInfo,
   getTimeMachineStatus
-} from "./chunk-23YWCI3O.js";
-import "./chunk-M73HCQD2.js";
-import "./chunk-VIACN2RU.js";
+} from "./chunk-QEH4LR6P.js";
+import "./chunk-NMGQVRCA.js";
+import "./chunk-FYCBGUTW.js";
+import "./chunk-OCL7P7N7.js";
 import "./chunk-MZO5QKUR.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   collectAll,
   collectBattery,

package/dist/{completions-ZVTNE52B.js → completions-FTPXDSR2.js}

@@ -1,3 +1,5 @@
+import "./chunk-3RG5ZIWI.js";
+
 // src/completions.ts
 function generateZshCompletions() {
   return `#compdef pyre
@@ -5,6 +7,16 @@ function generateZshCompletions() {
 _pyre() {
     local -a commands
     commands=(
+        'menu:Interactive TUI command center and tools navigator'
+        'tui:Alias for menu'
+        'launcher:Alias for menu'
+        'playbook:Execute sequenced multi-step macro recipes'
+        'flight:Forensic flight recorder black box'
+        'run:Performance budgeting runner for CI/CD gates'
+        'bench-git:Cross-branch git performance differ'
+        'statusline:Headless terminal statusline string'
+        'inspect:Process deep-dive inspector'
+        'containers:Container and micro-VM telemetry'
         'live:Start interactive live monitoring dashboard'
         'info:Display static system overview'
         'doctor:Run system permissions and diagnostic checks'
@@ -16,6 +28,7 @@ _pyre() {
         'ssh:Stream metrics over SSH'
         'bench:Benchmark command while logging system stats'
         'completions:Generate shell completion scripts'
+        'optimize:Mac optimizer (quit idle apps, memory, caches, trash, startup, dns)'
     )
 
     _arguments -s \\
@@ -58,8 +71,8 @@ _pyre_completions() {
     COMPREPLY=()
     cur="\${COMP_WORDS[COMP_CWORD]}"
     prev="\${COMP_WORDS[COMP_CWORD-1]}"
-    commands="live info doctor web ui launch config p2p ssh bench completions"
-    opts="--json --html --md --csv --tsv --detailed --theme --interval --once --out --export-dir --log --tree --sort --packets --limit --alert-cpu --alert-temp --temp-unit"
+    commands="menu tui launcher playbook flight run bench-git statusline inspect containers live info doctor web ui launch config p2p ssh bench completions optimize"
+    opts="--json --html --md --csv --tsv --detailed --theme --interval --once --out --export-dir --log --tree --sort --packets --limit --alert-cpu --alert-temp --temp-unit --idle --keep --yes --force --clean --empty --dry-run --auto-quit -m --menu -i --interactive --budget-cpu --budget-mem --budget-time --markdown --nice --format"
 
     case "${prev}" in
         --theme)
@@ -82,6 +95,22 @@ _pyre_completions() {
             COMPREPLY=( $(compgen -W "server connect" -- ${cur}) )
             return 0
             ;;
+        optimize)
+            COMPREPLY=( $(compgen -W "apps track memory caches trash startup dns protect unprotect help" -- ${cur}) )
+            return 0
+            ;;
+        playbook)
+            COMPREPLY=( $(compgen -W "run list audit clean triage bench" -- ${cur}) )
+            return 0
+            ;;
+        flight)
+            COMPREPLY=( $(compgen -W "dump status record" -- ${cur}) )
+            return 0
+            ;;
+        statusline)
+            COMPREPLY=( $(compgen -W "tmux starship json pango plain" -- ${cur}) )
+            return 0
+            ;;
     esac
 
     if [[ ${cur} == -* ]] ; then
@@ -98,6 +127,16 @@ complete -F _pyre_completions pyre
 function generateFishCompletions() {
   return `# fish completion for pyre
 
+complete -c pyre -n "__fish_use_subcommand" -a menu -d "Interactive TUI command center and tools navigator"
+complete -c pyre -n "__fish_use_subcommand" -a tui -d "Alias for menu"
+complete -c pyre -n "__fish_use_subcommand" -a launcher -d "Alias for menu"
+complete -c pyre -n "__fish_use_subcommand" -a playbook -d "Execute sequenced multi-step macro recipes"
+complete -c pyre -n "__fish_use_subcommand" -a flight -d "Forensic flight recorder black box"
+complete -c pyre -n "__fish_use_subcommand" -a run -d "Performance budgeting runner for CI/CD gates"
+complete -c pyre -n "__fish_use_subcommand" -a bench-git -d "Cross-branch git performance differ"
+complete -c pyre -n "__fish_use_subcommand" -a statusline -d "Headless terminal statusline string"
+complete -c pyre -n "__fish_use_subcommand" -a inspect -d "Process deep-dive inspector"
+complete -c pyre -n "__fish_use_subcommand" -a containers -d "Container and micro-VM telemetry"
 complete -c pyre -n "__fish_use_subcommand" -a live -d "Start interactive live monitoring dashboard"
 complete -c pyre -n "__fish_use_subcommand" -a info -d "Display static system overview"
 complete -c pyre -n "__fish_use_subcommand" -a doctor -d "Run system diagnostics"
@@ -107,6 +146,8 @@ complete -c pyre -n "__fish_use_subcommand" -a launch -d "Launch Activity Monito
 complete -c pyre -n "__fish_use_subcommand" -a config -d "Show or reset configuration options"
 complete -c pyre -n "__fish_use_subcommand" -a p2p -d "P2P streaming mode"
 complete -c pyre -n "__fish_use_subcommand" -a completions -d "Generate shell completions"
+complete -c pyre -n "__fish_use_subcommand" -a optimize -d "Mac optimizer: quit idle apps, clean caches"
+complete -c pyre -n "__fish_seen_subcommand_from optimize" -a "apps track memory caches trash startup dns protect unprotect help"
 
 complete -c pyre -l json -s j -d "Output snapshot as JSON"
 complete -c pyre -l html -d "Output snapshot as HTML"
@@ -123,7 +164,7 @@ function generatePowerShellCompletions() {
   return `# PowerShell completion for pyre
 Register-ArgumentCompleter -Native -CommandName pyre -ScriptBlock {
     param($wordToComplete, $commandAst, $cursorPosition)
-    $commands = @('live', 'check', 'pipe', 'stress', 'ui', 'launch', 'web', 'ssh', 'fleet', 'bench', 'benchmark', 'anomalies', 'doctor', 'extensions', 'brew', 'update', 'profile', 'config', 'history', 'diff', 'info', 'completions', 'p2p', 'blender', 'prometheus', 'smart', 'replay', 'explain')
+    $commands = @('menu', 'tui', 'launcher', 'playbook', 'flight', 'run', 'bench-git', 'statusline', 'inspect', 'containers', 'live', 'check', 'pipe', 'stress', 'ui', 'launch', 'web', 'ssh', 'fleet', 'bench', 'benchmark', 'anomalies', 'doctor', 'extensions', 'brew', 'update', 'profile', 'config', 'history', 'diff', 'info', 'completions', 'p2p', 'blender', 'prometheus', 'smart', 'replay', 'explain', 'optimize')
     $options = @('--json', '--html', '--md', '--csv', '--tsv', '--detailed', '--theme', '--interval', '--once', '--out', '--export-dir', '--log', '--tree', '--sort', '--packets', '--limit', '--alert-cpu', '--alert-temp', '--temp-unit', '--plain', '--help', '--version')
 
     $elements = $commandAst.CommandElements

package/dist/{config-J4YMADEF.js → config-5WW5M63G.js}

@@ -13,7 +13,8 @@ import {
   resetConfig,
   saveProfile,
   writeConfig
-} from "./chunk-QM5L43EK.js";
+} from "./chunk-LDJB5V4N.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   CONFIG_DIR,
   CONFIG_FILE,

package/dist/containersCmd-FSMYOBG2.js

@@ -0,0 +1,84 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/containersCmd.ts
+import { execSync } from "child_process";
+import chalk from "chalk";
+function detectContainerEngine() {
+  try {
+    execSync("docker --version", { stdio: "ignore" });
+    return "docker";
+  } catch {
+    try {
+      execSync("podman --version", { stdio: "ignore" });
+      return "podman";
+    } catch {
+      return null;
+    }
+  }
+}
+function collectContainerStats() {
+  const engine = detectContainerEngine();
+  if (!engine) return [];
+  try {
+    const raw = execSync(`${engine} stats --no-stream --format "{{.ID}}	{{.Name}}	{{.CPUPerc}}	{{.MemUsage}}	{{.MemPerc}}	{{.NetIO}}" 2>/dev/null`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    const lines = raw.trim().split("\n").filter(Boolean);
+    const stats = [];
+    for (const l of lines) {
+      const parts = l.split("	");
+      if (parts.length >= 6) {
+        stats.push({
+          id: parts[0]?.trim() || "",
+          name: parts[1]?.trim() || "",
+          engine,
+          cpuPct: parts[2]?.trim() || "0%",
+          memUsage: parts[3]?.trim() || "0B",
+          memPct: parts[4]?.trim() || "0%",
+          netIO: parts[5]?.trim() || "0B/0B"
+        });
+      }
+    }
+    return stats;
+  } catch {
+    return [];
+  }
+}
+async function runContainersCommand(opts) {
+  const stats = collectContainerStats();
+  const engine = detectContainerEngine();
+  if (opts?.json) {
+    console.log(JSON.stringify({ engine: engine || "none", containers: stats }, null, 2));
+    return;
+  }
+  console.log(chalk.bold("\n  \u{1F525} pyre containers \u2014 Container & Micro-VM Telemetry\n"));
+  if (!engine) {
+    console.log(chalk.yellow("  No container engine (Docker / Podman) detected in PATH."));
+    console.log(chalk.dim("  Install Docker or Podman to enable container performance telemetry.\n"));
+    return;
+  }
+  if (stats.length === 0) {
+    console.log(chalk.dim(`  Engine: ${engine} (Active, 0 running containers detected)
+`));
+    return;
+  }
+  console.log(chalk.dim(`  Engine: ${engine} (${stats.length} active containers)
+`));
+  console.log(`  ${"ID".padEnd(14)} ${"Name".padEnd(24)} ${"CPU %".padEnd(10)} ${"Memory Usage".padEnd(22)} ${"Net I/O"}`);
+  console.log(chalk.dim("  \u2500".repeat(40)));
+  for (const c of stats) {
+    const idCol = chalk.dim(c.id.padEnd(14));
+    const nameCol = chalk.bold.cyan(c.name.slice(0, 22).padEnd(24));
+    const cpuCol = chalk.yellow(c.cpuPct.padEnd(10));
+    const memCol = chalk.magenta(`${c.memUsage} (${c.memPct})`.padEnd(22));
+    const netCol = chalk.dim(c.netIO);
+    console.log(`  ${idCol} ${nameCol} ${cpuCol} ${memCol} ${netCol}`);
+  }
+  console.log();
+}
+export {
+  collectContainerStats,
+  detectContainerEngine,
+  runContainersCommand
+};

package/dist/{doctor-LHFW4UJP.js → doctor-O4DIAMHK.js}

@@ -1,9 +1,10 @@
 import {
   printDoctorReport,
   runDoctor
-} from "./chunk-KVUMOA6C.js";
+} from "./chunk-RKPGPVTO.js";
 import "./chunk-MZO5QKUR.js";
-import "./chunk-QM5L43EK.js";
+import "./chunk-LDJB5V4N.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   printDoctorReport,
   runDoctor

package/dist/{explainCmd-MF6PIMLW.js → explainCmd-7PBPA7O5.js}

@@ -1,6 +1,7 @@
 import {
   explainAnomaliesLocally
 } from "./chunk-ZLVIVFSO.js";
+import "./chunk-3RG5ZIWI.js";
 
 // src/explainCmd.ts
 import fs from "fs";

package/dist/{extensions-XJGHG7X3.js → extensions-QQEV7U3D.js}

@@ -1,6 +1,7 @@
 import {
   run
 } from "./chunk-MZO5QKUR.js";
+import "./chunk-3RG5ZIWI.js";
 
 // src/extensions.ts
 import chalk from "chalk";

package/dist/{firebaseSync-ON3RZ6KX.js → firebaseSync-LRN67UTV.js}

@@ -1,3 +1,5 @@
+import "./chunk-3RG5ZIWI.js";
+
 // src/firebaseSync.ts
 import crypto from "crypto";
 import os from "os";

package/dist/flightRecorder-GJIAQOXC.js

@@ -0,0 +1,162 @@
+import {
+  collectAll
+} from "./chunk-QEH4LR6P.js";
+import "./chunk-NMGQVRCA.js";
+import "./chunk-FYCBGUTW.js";
+import "./chunk-OCL7P7N7.js";
+import "./chunk-MZO5QKUR.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/flightRecorder.ts
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+var FlightRecorder = class {
+  buffer = [];
+  maxFrames;
+  constructor(maxFrames = 600) {
+    this.maxFrames = maxFrames;
+  }
+  push(frame) {
+    if (this.buffer.length >= this.maxFrames) {
+      this.buffer.shift();
+    }
+    this.buffer.push(frame);
+  }
+  size() {
+    return this.buffer.length;
+  }
+  getFrames() {
+    return [...this.buffer];
+  }
+  clear() {
+    this.buffer = [];
+  }
+  generateReport() {
+    const frames = this.getFrames();
+    let peakCpu = 0;
+    let peakMem = 0;
+    let peakTemp = void 0;
+    let highestCpuProc = void 0;
+    let highestMemProc = void 0;
+    for (const f of frames) {
+      if (f.cpu.usage > peakCpu) peakCpu = f.cpu.usage;
+      if (f.memory.usagePercent > peakMem) peakMem = f.memory.usagePercent;
+      if (f.cpu.temp !== void 0) {
+        if (peakTemp === void 0 || f.cpu.temp > peakTemp) peakTemp = f.cpu.temp;
+      }
+      for (const p of f.topProcesses) {
+        if (!highestCpuProc || p.cpu > highestCpuProc.cpu) {
+          highestCpuProc = { name: p.name, pid: p.pid, cpu: p.cpu };
+        }
+        if (!highestMemProc || p.mem > highestMemProc.mem) {
+          highestMemProc = { name: p.name, pid: p.pid, mem: p.mem };
+        }
+      }
+    }
+    const timeSpanSec = frames.length > 1 ? Math.round((new Date(frames[frames.length - 1].timestamp).getTime() - new Date(frames[0].timestamp).getTime()) / 1e3) : 0;
+    return {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      frameCount: frames.length,
+      timeSpanSec,
+      summary: {
+        peakCpuUsage: peakCpu,
+        peakMemUsage: peakMem,
+        peakTempC: peakTemp,
+        highestCpuProcess: highestCpuProc,
+        highestMemProcess: highestMemProc
+      },
+      frames
+    };
+  }
+  dump(outDir) {
+    const report = this.generateReport();
+    const targetDir = outDir || path.join(process.cwd(), "pyre-exports");
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    const filename = `pyre-flight-${Date.now()}.json`;
+    const fullPath = path.join(targetDir, filename);
+    fs.writeFileSync(fullPath, JSON.stringify(report, null, 2), "utf-8");
+    return fullPath;
+  }
+};
+var globalFlightRecorder = new FlightRecorder(600);
+async function captureCurrentFlightFrame() {
+  const data = await collectAll();
+  const sortedProcs = [...data.processes || []].sort((a, b) => b.cpu - a.cpu).slice(0, 5);
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    cpu: {
+      usage: data.cpu.usage,
+      temp: data.cpu.temperature,
+      loadAvg: data.cpu.loadAvg || []
+    },
+    memory: {
+      usagePercent: data.memory.usagePercent,
+      usedBytes: data.memory.used,
+      totalBytes: data.memory.total
+    },
+    network: {
+      rxPackets: data.network.rxPackets,
+      txPackets: data.network.txPackets
+    },
+    topProcesses: sortedProcs.map((p) => ({
+      pid: p.pid,
+      name: p.command,
+      cpu: p.cpu,
+      mem: p.mem
+    }))
+  };
+}
+async function runFlightCommand(subcommand = "dump", opts) {
+  if (subcommand === "status") {
+    const size = globalFlightRecorder.size();
+    console.log(chalk.bold("\n  \u{1F525} pyre Flight Recorder Status\n"));
+    console.log(`  Buffer Frames: ${chalk.green(size)} / 600`);
+    console.log(`  RAM Footprint: ~${(size * 1.5 / 1024).toFixed(2)} MB`);
+    console.log(chalk.dim("  Run `pyre flight dump` to generate a post-mortem forensic file.\n"));
+    return;
+  }
+  if (subcommand === "record") {
+    const durationSec = opts?.duration || 10;
+    console.log(chalk.bold(`
+  \u{1F525} Sampling Flight Recorder for ${durationSec}s...
+`));
+    for (let i = 0; i < durationSec; i++) {
+      const frame = await captureCurrentFlightFrame();
+      globalFlightRecorder.push(frame);
+      process.stdout.write(`\r  Sampled frame ${i + 1}/${durationSec}...`);
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+    console.log("\n");
+    const file2 = globalFlightRecorder.dump(opts?.out);
+    console.log(chalk.green(`  \u2714 Flight recording saved to: ${file2}
+`));
+    return;
+  }
+  if (globalFlightRecorder.size() === 0) {
+    const frame = await captureCurrentFlightFrame();
+    globalFlightRecorder.push(frame);
+  }
+  const file = globalFlightRecorder.dump(opts?.out);
+  const report = globalFlightRecorder.generateReport();
+  console.log(chalk.bold("\n  \u{1F525} pyre Flight Recorder \u2014 Forensic Dump\n"));
+  console.log(chalk.dim(`  Output File:  ${file}`));
+  console.log(`  Frames:       ${chalk.bold(report.frameCount)}`);
+  console.log(`  Peak CPU:     ${chalk.yellow(report.summary.peakCpuUsage.toFixed(1) + "%")}`);
+  console.log(`  Peak Memory:  ${chalk.magenta(report.summary.peakMemUsage.toFixed(1) + "%")}`);
+  if (report.summary.peakTempC !== void 0) {
+    console.log(`  Peak Temp:    ${chalk.red(report.summary.peakTempC.toFixed(1) + "\xB0C")}`);
+  }
+  if (report.summary.highestCpuProcess) {
+    console.log(`  Top CPU Proc: ${chalk.cyan(report.summary.highestCpuProcess.name)} (PID: ${report.summary.highestCpuProcess.pid}, ${report.summary.highestCpuProcess.cpu.toFixed(1)}%)`);
+  }
+  console.log();
+}
+export {
+  FlightRecorder,
+  captureCurrentFlightFrame,
+  globalFlightRecorder,
+  runFlightCommand
+};