@pi-unipi/unipi 2.2.7 → 2.4.0

package/packages/info-screen/config.ts

@@ -5,11 +5,11 @@
  * under the "unipi.info" key.
  */
 
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
 import { homedir } from "node:os";
-import type { InfoScreenSettings, GroupSettings } from "./types.js";
-import { DEFAULT_SETTINGS } from "./types.js";
+import type { InfoScreenSettings, GroupSettings, BootMode } from "./types.js";
+import { DEFAULT_SETTINGS, BOOT_MODES } from "./types.js";
 
 /** Settings path */
 const SETTINGS_PATH = join(homedir(), ".pi", "agent", "settings.json");
@@ -44,9 +44,11 @@ function readSettingsFile(): Record<string, unknown> {
  * Write the full settings file.
  */
 function writeSettingsFile(data: Record<string, unknown>): void {
-  const dir = require("node:path").dirname(SETTINGS_PATH);
+  // These were require() calls in an ESM module, which throws under Node's
+  // module-format detection as soon as the directory is missing.
+  const dir = dirname(SETTINGS_PATH);
   if (!existsSync(dir)) {
-    require("node:fs").mkdirSync(dir, { recursive: true });
+    mkdirSync(dir, { recursive: true });
   }
   writeFileSync(SETTINGS_PATH, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
@@ -68,7 +70,7 @@ export function getInfoSettings(): InfoScreenSettings {
   const info = unipi.info as Record<string, unknown>;
 
   cachedSettings = {
-    showOnBoot: typeof info.showOnBoot === "boolean" ? info.showOnBoot : DEFAULT_SETTINGS.showOnBoot,
+    bootMode: parseBootMode(info),
     bootTimeoutMs: typeof info.bootTimeoutMs === "number" ? info.bootTimeoutMs : DEFAULT_SETTINGS.bootTimeoutMs,
     groups: isRecord(info.groups) ? parseGroupSettings(info.groups) : {},
   };
@@ -76,6 +78,24 @@ export function getInfoSettings(): InfoScreenSettings {
   return cachedSettings;
 }
 
+/**
+ * Resolve the boot mode, migrating the legacy `showOnBoot` boolean.
+ *
+ * `showOnBoot: false` maps to "off". `showOnBoot: true` maps to "on" rather
+ * than the new "auto-close" default, so an existing config keeps behaving the
+ * way its owner configured it.
+ */
+function parseBootMode(info: Record<string, unknown>): BootMode {
+  const raw = info.bootMode;
+  if (typeof raw === "string" && (BOOT_MODES as string[]).includes(raw)) {
+    return raw as BootMode;
+  }
+  if (typeof info.showOnBoot === "boolean") {
+    return info.showOnBoot ? "on" : "off";
+  }
+  return DEFAULT_SETTINGS.bootMode;
+}
+
 /**
  * Parse group settings from raw object.
  */
@@ -118,7 +138,7 @@ export function saveInfoSettings(settings: InfoScreenSettings): void {
   }
 
   (file[SETTINGS_KEY] as Record<string, unknown>).info = {
-    showOnBoot: settings.showOnBoot,
+    bootMode: settings.bootMode,
     bootTimeoutMs: settings.bootTimeoutMs,
     groups: settings.groups,
   };

package/packages/info-screen/core-groups.ts

@@ -9,8 +9,9 @@ import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getPiVersion } from "@pi-unipi/core";
 import { infoRegistry } from "./registry.js";
-import { parseUsageStats, formatTokens, formatCost } from "./usage-parser.js";
+import { parseUsageStatsAsync, formatTokens, formatCost } from "./usage-parser.js";
 import type { InfoGroup } from "./types.js";
 
 /**
@@ -27,43 +28,6 @@ function getPackageVersion(packageDir: string): string {
   }
 }
 
-/**
- * Get pi version from its package.json.
- */
-function getPiVersion(): string {
-  // Try to find pi's package.json in various locations
-  const possiblePaths = [
-    // Global npm install
-    join(homedir(), ".local", "share", "mise", "installs", "node", "24.14.1", "lib", "node_modules", "@earendil-works", "pi-coding-agent", "package.json"),
-    // Alternative locations
-    join(homedir(), ".local", "share", "mise", "installs", "node", "lib", "node_modules", "@earendil-works", "pi-coding-agent", "package.json"),
-  ];
-
-  for (const pkgPath of possiblePaths) {
-    try {
-      if (existsSync(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        return pkg?.version ?? "unknown";
-      }
-    } catch {
-      // Continue to next path
-    }
-  }
-
-  // Fallback: try to run pi --version
-  try {
-    const { execSync } = require("node:child_process");
-    const version = execSync("pi --version 2>/dev/null", { encoding: "utf-8" }).trim();
-    // Extract version number from output like "pi v0.42.4"
-    const match = version.match(/v([\d.]+)/);
-    if (match) return match[1];
-  } catch {
-    // Ignore
-  }
-
-  return "unknown";
-}
-
 /**
  * Discover loaded extensions by scanning filesystem.
  */
@@ -433,7 +397,9 @@ export function registerCoreGroups(): void {
       ],
     },
     dataProvider: async () => {
-      const stats = parseUsageStats();
+      // Async variant yields to the event loop between files, so a cold parse
+      // cannot block keystrokes or the initial paint.
+      const stats = await parseUsageStatsAsync();
 
       // Find top model for each period
       const findTopModel = (modelStats: Record<string, { tokens: number; cost: number; sessions: number }> | undefined) => {

package/packages/info-screen/index.ts

@@ -34,6 +34,10 @@ export default function (pi: ExtensionAPI) {
   // Start load tracking
   startLoadTracking();
 
+  // Whether an info overlay is currently on screen. Module announcements only
+  // trigger a re-fetch when something is actually displaying the result.
+  let overlayVisible = false;
+
   // Debounced MODULE_READY handling — batch module announcements
   // to prevent layout shift from rapid per-module cache invalidation.
   let moduleReadyBatch: Array<{ name: string; version: string; tools?: string[]; loadTimeMs?: number }> = [];
@@ -60,14 +64,18 @@ export default function (pi: ExtensionAPI) {
       }
     }
 
-    // Single cache invalidation for all modules
+    // Single cache invalidation for all modules.
+    //
+    // Only re-fetch while an overlay is actually on screen. Otherwise this
+    // ran every module announcement even with the dashboard disabled,
+    // doing work nobody would see.
     infoRegistry.invalidateCache("overview");
-    infoRegistry.getGroupData("overview");
+    if (hasTools) infoRegistry.invalidateCache("tools");
 
-    if (hasTools) {
-      infoRegistry.invalidateCache("tools");
-      infoRegistry.getGroupData("tools");
-    }
+    if (!overlayVisible) return;
+
+    infoRegistry.getGroupData("overview");
+    if (hasTools) infoRegistry.getGroupData("tools");
   }
 
   // Listen for module announcements — track and trigger reactive updates
@@ -107,16 +115,22 @@ export default function (pi: ExtensionAPI) {
    * Cache-first: opens with whatever data is cached (even empty).
    * Background: each group fetches independently, overlay re-renders reactively.
    */
-  function showOverlay(ctx: ExtensionContext): void {
+  function showOverlay(ctx: ExtensionContext, autoCloseMs?: number): void {
     ctx.ui.custom<void>(
       (tui, theme, _keybindings, done) => {
         const overlay = new InfoOverlay();
         overlay.setTheme(theme);
+        overlayVisible = true;
         overlay.onClose = () => {
+          overlayVisible = false;
           overlay.destroy();
           done();
         };
         overlay.requestRender = () => tui.requestRender();
+        // Boot dashboard dismisses itself; any keypress cancels the timer.
+        if (autoCloseMs && autoCloseMs > 0) {
+          overlay.startBootTimer(autoCloseMs);
+        }
         return {
           render: (w: number) => overlay.render(w),
           invalidate: () => overlay.invalidate(),
@@ -142,9 +156,10 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_start", async (event, ctx) => {
     const settings = getInfoSettings();
 
-    if (settings.showOnBoot && event.reason === "startup") {
-      // Open immediately — cache-first, no waiting
-      showOverlay(ctx);
+    if (settings.bootMode !== "off" && event.reason === "startup") {
+      // Open immediately — cache-first, no waiting. In "auto-close" mode the
+      // overlay dismisses itself after bootTimeoutMs; any keypress cancels it.
+      showOverlay(ctx, settings.bootMode === "auto-close" ? settings.bootTimeoutMs : 0);
     }
 
     finishLoadTracking();

package/packages/info-screen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
   "type": "module",
   "main": "index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.2.0"
+    "@pi-unipi/core": "2.4.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/info-screen/tui/info-overlay.ts

@@ -15,6 +15,14 @@ import { getInfoSettings } from "../config.js";
 import type { InfoGroup, GroupData } from "../types.js";
 import { boxInnerWidth } from "@pi-unipi/core";
 
+/**
+ * How long to wait before warming the non-visible tabs.
+ *
+ * Long enough that startup and the first paint finish first, short enough that
+ * a tab switch a second later is already warm.
+ */
+const PREFETCH_DELAY_MS = 1500;
+
 /** Tab color palette */
 const TAB_FG: Array<"accent" | "success" | "warning" | "error"> = [
   "accent",
@@ -48,6 +56,10 @@ export class InfoOverlay implements Component {
   private lastGlobalUpdate = 0;
   private unsubscribers: Array<() => void> = [];
   private _destroyed = false;
+  /** Groups whose fetch has already been kicked off (lazy-load bookkeeping). */
+  private fetched = new Set<string>();
+  private prefetchTimer: ReturnType<typeof setTimeout> | null = null;
+  private bootTimer: ReturnType<typeof setTimeout> | null = null;
 
   onClose?: () => void;
   requestRender?: () => void;
@@ -89,31 +101,55 @@ export class InfoOverlay implements Component {
       })
     );
 
-    // Start background fetch for all groups (non-blocking)
-    this.fetchAllBackground();
+    // Fetch the visible tab now; everything else waits for idle.
+    this.fetchActiveGroup();
+    this.schedulePrefetch();
+  }
+
+  /** Fetch one group, tracking its loading state. Safe to call repeatedly. */
+  private fetchGroup(groupId: string): void {
+    if (this._destroyed) return;
+    if (this.fetched.has(groupId)) return;
+    this.fetched.add(groupId);
+    infoRegistry.getGroupData(groupId).then(() => {
+      this.groupLoading.set(groupId, false);
+    }).catch(() => {
+      this.groupLoading.set(groupId, false);
+    });
   }
 
   /**
-   * Fetch all groups in background. Each resolves independently.
+   * Fetch the currently visible group.
    *
-   * Each fetch is deferred to a macrotask (setTimeout 0) so the constructor
-   * returns immediately. Without this, getGroupData() runs each group's
-   * dataProvider synchronously up to its first `await` before yielding —
-   * heavy providers (usage stats parse 1GB+ of session files, memory scans)
-   * blocked the session_start handler for seconds.
+   * Deferred to a macrotask because an async dataProvider still runs
+   * synchronously up to its first `await`; calling it inline would put that
+   * work back on the constructor's caller (session_start).
    */
-  private fetchAllBackground(): void {
-    for (const group of this.groups) {
-      // Defer each fetch to a macrotask so the overlay constructs instantly.
-      setTimeout(() => {
-        if (this._destroyed) return;
-        infoRegistry.getGroupData(group.id).then(() => {
-          this.groupLoading.set(group.id, false);
-        }).catch(() => {
-          this.groupLoading.set(group.id, false);
-        });
-      }, 0);
-    }
+  private fetchActiveGroup(): void {
+    const group = this.groups[this.activeTabIndex];
+    if (!group) return;
+    setTimeout(() => this.fetchGroup(group.id), 0);
+  }
+
+  /**
+   * Warm the remaining tabs once the app is idle.
+   *
+   * Fetching every group up front cost seconds of startup for panels the user
+   * may never open. Prefetching after a delay keeps tab switches instant
+   * without paying for them before the first prompt is ready.
+   */
+  private schedulePrefetch(): void {
+    if (this.prefetchTimer) return;
+    this.prefetchTimer = setTimeout(() => {
+      this.prefetchTimer = null;
+      if (this._destroyed) return;
+      for (const group of this.groups) {
+        if (group.id === this.groups[this.activeTabIndex]?.id) continue;
+        this.fetchGroup(group.id);
+      }
+    }, PREFETCH_DELAY_MS);
+    // Never hold the process open just to warm a panel.
+    this.prefetchTimer.unref?.();
   }
 
   /**
@@ -127,29 +163,30 @@ export class InfoOverlay implements Component {
       this.applyOrder();
     }
 
-    // Ensure every group has real (non-empty) data.
-    // Registration notifications inject `{}` to trigger re-sync; we must
-    // not treat that as fetched data or the stats render as "—".
+    // Adopt any data the registry already has. Registration notifications
+    // inject `{}` to trigger a re-sync; that is not real data and must not be
+    // treated as fetched, or the stats render as "—".
+    //
+    // Groups are NOT fetched here: doing so would defeat lazy loading, since
+    // syncGroups() runs on every render. Fetches are driven by tab visibility
+    // (fetchActiveGroup) and the idle prefetch instead.
     for (const group of this.groups) {
       const existing = this.groupData.get(group.id);
       const hasRealData = existing && Object.keys(existing).length > 0;
-      if (!hasRealData) {
-        const cached = infoRegistry.getCachedData(group.id);
-        if (cached && Object.keys(cached).length > 0) {
-          this.groupData.set(group.id, cached);
-        } else if (!this.groupLoading.get(group.id)) {
-          this.groupLoading.set(group.id, true);
-          infoRegistry.getGroupData(group.id).then((data) => {
-            this.groupData.set(group.id, data);
-            this.groupLoading.set(group.id, false);
-            this.lastGlobalUpdate = Date.now();
-            this.requestRender?.();
-          }).catch(() => {
-            this.groupLoading.set(group.id, false);
-          });
-        }
+      if (hasRealData) continue;
+
+      const cached = infoRegistry.getCachedData(group.id);
+      if (cached && Object.keys(cached).length > 0) {
+        this.groupData.set(group.id, cached);
       }
     }
+
+    // A late-arriving group may now be the visible one, and the prefetch pass
+    // may have already run — make sure the active tab still gets its data.
+    if (hadNewGroups) {
+      this.fetchActiveGroup();
+      this.schedulePrefetch();
+    }
   }
 
   private applyOrder(): void {
@@ -169,23 +206,59 @@ export class InfoOverlay implements Component {
    */
   destroy(): void {
     this._destroyed = true;
+    this.cancelBootTimer();
+    if (this.prefetchTimer) {
+      clearTimeout(this.prefetchTimer);
+      this.prefetchTimer = null;
+    }
     for (const unsub of this.unsubscribers) {
       unsub();
     }
     this.unsubscribers = [];
   }
 
+  /** Stop the boot auto-close timer, if one is pending. */
+  private cancelBootTimer(): void {
+    if (this.bootTimer) {
+      clearTimeout(this.bootTimer);
+      this.bootTimer = null;
+    }
+  }
+
+  /**
+   * Auto-close the overlay after `ms`, unless the user interacts first.
+   *
+   * Used when the overlay is shown on boot: the dashboard is informational, so
+   * it should get out of the way on its own rather than requiring a keypress.
+   */
+  startBootTimer(ms: number): void {
+    this.cancelBootTimer();
+    if (!Number.isFinite(ms) || ms <= 0) return;
+    this.bootTimer = setTimeout(() => {
+      this.bootTimer = null;
+      if (this._destroyed) return;
+      this.destroy();
+      this.onClose?.();
+    }, ms);
+    this.bootTimer.unref?.();
+  }
+
   invalidate(): void {
     this.syncGroups();
   }
 
   handleInput(data: string): void {
+    // Any keypress means the user is driving; stop the boot auto-close.
+    this.cancelBootTimer();
+
     if (data === "\x1b[C" || data === "l") {
       this.activeTabIndex = (this.activeTabIndex + 1) % this.groups.length;
       this.scrollOffset = 0;
+      this.fetchActiveGroup();
     } else if (data === "\x1b[D" || data === "h") {
       this.activeTabIndex = (this.activeTabIndex - 1 + this.groups.length) % this.groups.length;
       this.scrollOffset = 0;
+      this.fetchActiveGroup();
     } else if (data === "\x1b[B" || data === "j") {
       this.scrollOffset++;
     } else if (data === "\x1b[A" || data === "k") {
@@ -211,12 +284,15 @@ export class InfoOverlay implements Component {
     if (!group) return;
     this.groupLoading.set(group.id, true);
     this.requestRender?.();
+    // Explicit refresh must bypass the lazy-load guard.
+    this.fetched.add(group.id);
     infoRegistry.refreshGroup(group.id);
   }
 
   private refreshAll(): void {
     for (const group of this.groups) {
       this.groupLoading.set(group.id, true);
+      this.fetched.add(group.id);
     }
     this.requestRender?.();
     infoRegistry.refreshAll();

package/packages/info-screen/types.ts

@@ -47,11 +47,26 @@ export interface InfoGroup {
   dataProvider: () => Promise<GroupData>;
 }
 
+/** How the dashboard behaves at startup. */
+export type BootMode = "on" | "off" | "auto-close";
+
+/** All valid boot modes, in the order the settings UI cycles them. */
+export const BOOT_MODES: BootMode[] = ["on", "auto-close", "off"];
+
 /** Settings for info-screen in settings.json */
 export interface InfoScreenSettings {
-  /** Whether to show dashboard on boot */
-  showOnBoot: boolean;
-  /** Timeout in ms waiting for modules at boot */
+  /**
+   * What the dashboard does at startup:
+   *  - "on":         show it and leave it up until dismissed (q/Esc)
+   *  - "off":        do not show it at all (no data is fetched)
+   *  - "auto-close": show it, then close after `bootTimeoutMs`
+   */
+  bootMode: BootMode;
+  /**
+   * How long the boot dashboard stays up in "auto-close" mode, in ms.
+   * Any keypress cancels the timer and keeps the overlay open.
+   * Does not apply to the overlay opened via /unipi:info.
+   */
   bootTimeoutMs: number;
   /** Per-group settings */
   groups: Record<string, GroupSettings>;
@@ -69,8 +84,8 @@ export interface GroupSettings {
 
 /** Default settings */
 export const DEFAULT_SETTINGS: InfoScreenSettings = {
-  showOnBoot: true,
-  bootTimeoutMs: 8000,
+  bootMode: "auto-close",
+  bootTimeoutMs: 2000,
   groups: {},
   groupOrder: [],
 };