@pi-unipi/info-screen 0.1.1

package/index.ts

@@ -0,0 +1,191 @@
+/**
+ * @pi-unipi/info-screen — Extension entry
+ *
+ * Dashboard and module registry for Unipi.
+ * Shows configurable info overlay on boot and via /unipi:info command.
+ *
+ * Usage:
+ *   /unipi:info          - Show info dashboard
+ *   /unipi:info-settings - Configure info display
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { UNIPI_EVENTS, MODULES, UNIPI_PREFIX, emitEvent, getPackageVersion } from "@pi-unipi/core";
+import { infoRegistry } from "./registry.js";
+import { registerCoreGroups, trackModule, trackTool } from "./core-groups.js";
+
+/** Re-export infoRegistry for external use */
+export { infoRegistry };
+import { getInfoSettings } from "./config.js";
+import { InfoOverlay } from "./tui/info-overlay.js";
+import { SettingsOverlay } from "./settings/settings-tui.js";
+
+/** Package version */
+const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
+
+/** Module ready tracking */
+let moduleReady = false;
+let moduleReadyResolve: (() => void) | null = null;
+const moduleReadyPromise = new Promise<void>((resolve) => {
+  moduleReadyResolve = resolve;
+});
+
+/** Timeout for waiting for modules */
+const MODULE_WAIT_TIMEOUT_MS = 2000;
+
+/**
+ * Wait for all modules to announce, then return.
+ */
+async function waitForModules(): Promise<void> {
+  const settings = getInfoSettings();
+  const timeoutMs = settings.bootTimeoutMs;
+
+  // Wait for module ready or timeout
+  await Promise.race([
+    moduleReadyPromise,
+    new Promise<void>((resolve) => setTimeout(resolve, timeoutMs)),
+  ]);
+}
+
+export default function (pi: ExtensionAPI) {
+  // Register core groups on load
+  registerCoreGroups();
+
+
+
+  // Listen for module announcements
+  pi.events.on(UNIPI_EVENTS.MODULE_READY, (event: any) => {
+    if (event.name && event.name !== MODULES.INFO_SCREEN) {
+      // Track the module
+      trackModule(event.name, event.version || "unknown");
+
+      // Track tools from this module
+      if (event.tools && Array.isArray(event.tools)) {
+        for (const tool of event.tools) {
+          trackTool(tool, event.name);
+        }
+      }
+
+      // Signal that a module has announced
+      if (!moduleReady) {
+        moduleReady = true;
+        moduleReadyResolve?.();
+      }
+    }
+  });
+
+  // Listen for info group registrations via events
+  pi.events.on(UNIPI_EVENTS.INFO_GROUP_REGISTERED, (_event: any) => {
+    // Group already registered via globalThis in registerGroup()
+  });
+
+  // Also track built-in tools by intercepting tool calls
+  const trackedBuiltinTools = new Set<string>();
+  pi.on("tool_call", async (event, _ctx) => {
+    const toolName = event.toolName;
+    if (!trackedBuiltinTools.has(toolName)) {
+      trackedBuiltinTools.add(toolName);
+      trackTool(toolName, "builtin");
+    }
+    return undefined; // Don't block the tool call
+  });
+
+  // Session lifecycle
+  pi.on("session_start", async (_event, ctx) => {
+    const settings = getInfoSettings();
+
+    // Show dashboard on boot if enabled
+    if (settings.showOnBoot) {
+      // Wait for other modules to announce
+      await waitForModules();
+
+      // Show the overlay
+      ctx.ui.custom(
+        (tui, _theme, _keybindings, done) => {
+          const overlay = new InfoOverlay();
+          overlay.onClose = () => done(undefined);
+          // Wrap handleInput to trigger re-render after state changes
+          const originalHandleInput = overlay.handleInput?.bind(overlay);
+          overlay.handleInput = (data: string) => {
+            originalHandleInput?.(data);
+            tui.requestRender();
+          };
+          return overlay;
+        },
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "80%",
+            minWidth: 60,
+            anchor: "center",
+            margin: 2,
+          },
+        }
+      );
+    }
+
+    // Announce module
+    emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
+      name: MODULES.INFO_SCREEN,
+      version: VERSION,
+      commands: ["unipi:info", "unipi:info-settings"],
+      tools: [],
+    });
+  });
+
+  // Register /unipi:info command
+  pi.registerCommand(`${UNIPI_PREFIX}info`, {
+    description: "Show info screen dashboard",
+    handler: async (_args, ctx) => {
+      ctx.ui.custom(
+        (tui, _theme, _keybindings, done) => {
+          const overlay = new InfoOverlay();
+          overlay.onClose = () => done(undefined);
+          const originalHandleInput = overlay.handleInput?.bind(overlay);
+          overlay.handleInput = (data: string) => {
+            originalHandleInput?.(data);
+            tui.requestRender();
+          };
+          return overlay;
+        },
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "80%",
+            minWidth: 60,
+            anchor: "center",
+            margin: 2,
+          },
+        }
+      );
+    },
+  });
+
+  // Register /unipi:info-settings command
+  pi.registerCommand(`${UNIPI_PREFIX}info-settings`, {
+    description: "Configure info screen display",
+    handler: async (_args, ctx) => {
+      ctx.ui.custom(
+        (tui, _theme, _keybindings, done) => {
+          const overlay = new SettingsOverlay();
+          overlay.onClose = () => done(undefined);
+          const originalHandleInput = overlay.handleInput?.bind(overlay);
+          overlay.handleInput = (data: string) => {
+            originalHandleInput?.(data);
+            tui.requestRender();
+          };
+          return overlay;
+        },
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "60%",
+            minWidth: 50,
+            anchor: "center",
+            margin: 2,
+          },
+        }
+      );
+    },
+  });
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@pi-unipi/info-screen",
+  "version": "0.1.1",
+  "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
+  "type": "module",
+  "license": "MIT",
+  "author": "Neuron Mr White",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Neuron-Mr-White/unipi.git",
+    "directory": "packages/info-screen"
+  },
+  "homepage": "https://github.com/Neuron-Mr-White/unipi#readme",
+  "bugs": {
+    "url": "https://github.com/Neuron-Mr-White/unipi/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-coding-agent",
+    "unipi",
+    "info-screen",
+    "dashboard"
+  ],
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  },
+  "files": [
+    "*.ts",
+    "tui/*.ts",
+    "settings/*.ts",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pi-unipi/core": "*"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0"
+  }
+}

package/registry.ts

@@ -0,0 +1,183 @@
+/**
+ * @pi-unipi/info-screen — Registry
+ *
+ * Central registry for info groups. Core groups register at startup.
+ * External modules call registerGroup() to add their groups.
+ */
+
+import type { InfoGroup, GroupData } from "./types.js";
+import { getInfoSettings, isGroupEnabled, isStatEnabled } from "./config.js";
+
+/**
+ * Registry for info-screen groups.
+ *
+ * Usage:
+ * ```ts
+ * import { infoRegistry } from "@pi-unipi/info-screen";
+ *
+ * // Register a group
+ * infoRegistry.registerGroup({
+ *   id: "memory",
+ *   name: "Memory",
+ *   icon: "🧠",
+ *   priority: 60,
+ *   config: {
+ *     showByDefault: true,
+ *     stats: [
+ *       { id: "total", label: "Total", show: true },
+ *     ],
+ *   },
+ *   dataProvider: async () => ({
+ *     total: { value: "42" },
+ *   }),
+ * });
+ *
+ * // Get all registered groups
+ * const groups = infoRegistry.getGroups();
+ * ```
+ */
+class InfoRegistry {
+  /** Registered groups by id */
+  private groups = new Map<string, InfoGroup>();
+
+  /** Cached data per group */
+  private dataCache = new Map<string, GroupData>();
+
+  /** Cache TTL in ms */
+  private cacheTtlMs = 5000;
+
+  /** Last cache update per group */
+  private cacheTimestamps = new Map<string, number>();
+
+  /**
+   * Register an info group.
+   * If a group with the same id exists, it's replaced.
+   */
+  registerGroup(group: InfoGroup): void {
+    this.groups.set(group.id, group);
+  }
+
+  /**
+   * Unregister an info group.
+   */
+  unregisterGroup(groupId: string): void {
+    this.groups.delete(groupId);
+    this.dataCache.delete(groupId);
+    this.cacheTimestamps.delete(groupId);
+  }
+
+  /**
+   * Get all registered groups, sorted by priority.
+   * Respects config — groups with show: false are excluded.
+   */
+  getGroups(): InfoGroup[] {
+    const settings = getInfoSettings();
+    const allGroups = Array.from(this.groups.values());
+
+    return allGroups
+      .filter((group) => {
+        // Check group-level visibility
+        const groupSettings = settings.groups[group.id];
+        if (groupSettings && !groupSettings.show) return false;
+        // If no settings, use group's default
+        if (!groupSettings && !group.config.showByDefault) return false;
+        return true;
+      })
+      .sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Get all registered groups (including hidden ones).
+   */
+  getAllGroups(): InfoGroup[] {
+    return Array.from(this.groups.values())
+      .sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Get a specific group by id.
+   */
+  getGroup(groupId: string): InfoGroup | undefined {
+    return this.groups.get(groupId);
+  }
+
+  /**
+   * Get data for a group, using cache if fresh.
+   */
+  async getGroupData(groupId: string): Promise<GroupData> {
+    const group = this.groups.get(groupId);
+    if (!group) return {};
+
+    // Check cache freshness
+    const now = Date.now();
+    const lastUpdate = this.cacheTimestamps.get(groupId) ?? 0;
+    if (now - lastUpdate < this.cacheTtlMs) {
+      const cached = this.dataCache.get(groupId);
+      if (cached) return cached;
+    }
+
+    // Fetch fresh data
+    try {
+      const data = await group.dataProvider();
+      this.dataCache.set(groupId, data);
+      this.cacheTimestamps.set(groupId, now);
+      return data;
+    } catch (error) {
+      // Silently fall back to cached data
+      return this.dataCache.get(groupId) ?? {};
+    }
+  }
+
+  /**
+   * Manually update data for a group (for live updates).
+   */
+  updateGroupData(groupId: string, data: GroupData): void {
+    this.dataCache.set(groupId, data);
+    this.cacheTimestamps.set(groupId, Date.now());
+  }
+
+  /**
+   * Get filtered stats for a group based on config.
+   * Returns stats that are enabled in both group config and settings.
+   */
+  getVisibleStats(groupId: string): Array<{ id: string; label: string }> {
+    const group = this.groups.get(groupId);
+    if (!group) return [];
+
+    return group.config.stats.filter((stat) => {
+      // Check stat-level visibility from settings
+      if (!isStatEnabled(groupId, stat.id)) return false;
+      // Check stat's own default
+      return stat.show;
+    });
+  }
+
+  /**
+   * Invalidate cache for a group.
+   */
+  invalidateCache(groupId: string): void {
+    this.dataCache.delete(groupId);
+    this.cacheTimestamps.delete(groupId);
+  }
+
+  /**
+   * Invalidate all caches.
+   */
+  invalidateAllCaches(): void {
+    this.dataCache.clear();
+    this.cacheTimestamps.clear();
+  }
+}
+
+/** Singleton registry instance */
+export const infoRegistry = new InfoRegistry();
+
+// Expose globally so other modules can access without direct imports
+// (pi loads extensions independently, so imports may not resolve)
+const globalObj = globalThis as any;
+if (!globalObj.__unipi_info_registry) {
+  globalObj.__unipi_info_registry = infoRegistry;
+}
+export const getGlobalRegistry = (): InfoRegistry => {
+  return globalObj.__unipi_info_registry || infoRegistry;
+};

package/settings/settings-tui.ts

@@ -0,0 +1,287 @@
+/**
+ * @pi-unipi/info-screen — Settings TUI Component
+ *
+ * Interactive settings editor for group and stat visibility.
+ * Displays all groups with toggle switches.
+ */
+
+import type { Component } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { infoRegistry } from "../registry.js";
+import { getInfoSettings, saveInfoSettings, getGroupSettings, setGroupSettings } from "../config.js";
+import type { InfoScreenSettings, GroupSettings } from "../types.js";
+
+/** ANSI escape codes */
+const ansi = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  // Colors
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  gray: "\x1b[90m",
+};
+
+/** Toggle symbols */
+const TOGGLE_ON = `${ansi.green}●${ansi.reset}`;
+const TOGGLE_OFF = `${ansi.dim}○${ansi.reset}`;
+
+/**
+ * Settings overlay component.
+ */
+export class SettingsOverlay implements Component {
+  private settings: InfoScreenSettings;
+  private groups: Array<{ id: string; name: string; icon: string }>;
+  private selectedIndex = 0;
+  private mode: "groups" | "stats" = "groups";
+  private selectedGroupId: string | null = null;
+  /** Callback when overlay should close */
+  onClose?: () => void;
+
+  constructor() {
+    this.settings = getInfoSettings();
+    this.groups = infoRegistry.getAllGroups().map((g) => ({
+      id: g.id,
+      name: g.name,
+      icon: g.icon,
+    }));
+  }
+
+  /**
+   * Invalidate cached render state.
+   */
+  invalidate(): void {
+    // No cached state to invalidate
+  }
+
+  /**
+   * Handle keyboard input.
+   */
+  handleInput(data: string): void {
+    if (this.mode === "groups") {
+      this.handleGroupsInput(data);
+    } else {
+      this.handleStatsInput(data);
+    }
+  }
+
+  /**
+   * Handle input in groups mode.
+   */
+  private handleGroupsInput(data: string): void {
+    switch (data) {
+      case "\x1b[A": // Up
+      case "k":
+        this.selectedIndex = (this.selectedIndex - 1 + this.groups.length) % this.groups.length;
+        break;
+      case "\x1b[B": // Down
+      case "j":
+        this.selectedIndex = (this.selectedIndex + 1) % this.groups.length;
+        break;
+      case " ": // Space - toggle visibility
+      case "\r": // Enter - toggle visibility
+        this.toggleGroupVisibility(this.groups[this.selectedIndex].id);
+        break;
+      case "\x1b[C": // Right - enter stats mode
+      case "l":
+        this.enterStatsMode(this.groups[this.selectedIndex].id);
+        break;
+      case "q": // Quit
+      case "\x1b": // Escape
+        this.onClose?.();
+        break;
+    }
+  }
+
+  /**
+   * Handle input in stats mode.
+   */
+  private handleStatsInput(data: string): void {
+    if (!this.selectedGroupId) return;
+
+    const group = infoRegistry.getGroup(this.selectedGroupId);
+    if (!group) return;
+
+    switch (data) {
+      case "\x1b[A": // Up
+      case "k":
+        this.selectedIndex = (this.selectedIndex - 1 + group.config.stats.length) % group.config.stats.length;
+        break;
+      case "\x1b[B": // Down
+      case "j":
+        this.selectedIndex = (this.selectedIndex + 1) % group.config.stats.length;
+        break;
+      case " ": // Space - toggle stat
+      case "\r": // Enter - toggle stat
+        this.toggleStatVisibility(this.selectedGroupId, group.config.stats[this.selectedIndex].id);
+        break;
+      case "\x1b[D": // Left - back to groups
+      case "h":
+        this.mode = "groups";
+        this.selectedGroupId = null;
+        this.selectedIndex = this.groups.findIndex((g) => g.id === this.selectedGroupId) ?? 0;
+        break;
+      case "q": // Quit from stats mode
+      case "\x1b":
+        this.onClose?.();
+        break;
+    }
+  }
+
+  /**
+   * Toggle group visibility.
+   */
+  private toggleGroupVisibility(groupId: string): void {
+    const groupSettings = getGroupSettings(groupId);
+    groupSettings.show = !groupSettings.show;
+    setGroupSettings(groupId, groupSettings);
+
+    // Update local settings
+    this.settings.groups[groupId] = groupSettings;
+  }
+
+  /**
+   * Toggle stat visibility.
+   */
+  private toggleStatVisibility(groupId: string, statId: string): void {
+    const groupSettings = getGroupSettings(groupId);
+    if (!groupSettings.stats) {
+      groupSettings.stats = {};
+    }
+    groupSettings.stats[statId] = !(groupSettings.stats[statId] ?? true);
+    setGroupSettings(groupId, groupSettings);
+
+    // Update local settings
+    this.settings.groups[groupId] = groupSettings;
+  }
+
+  /**
+   * Enter stats editing mode for a group.
+   */
+  private enterStatsMode(groupId: string): void {
+    this.mode = "stats";
+    this.selectedGroupId = groupId;
+    this.selectedIndex = 0;
+  }
+
+  /**
+   * Render the component.
+   */
+  render(width: number): string[] {
+    if (this.mode === "groups") {
+      return this.renderGroupsMode(width);
+    } else {
+      return this.renderStatsMode(width);
+    }
+  }
+
+  /**
+   * Render groups mode.
+   */
+  private renderGroupsMode(width: number): string[] {
+    const lines: string[] = [];
+
+    // Header
+    lines.push("");
+    lines.push(this.renderCentered(`${ansi.bold}⚙️  Info Screen Settings${ansi.reset}`, width));
+    lines.push("");
+
+    // Separator
+    lines.push(ansi.dim + "─".repeat(width) + ansi.reset);
+    lines.push("");
+
+    // Group list
+    for (let i = 0; i < this.groups.length; i++) {
+      const group = this.groups[i];
+      const isSelected = i === this.selectedIndex;
+      const groupSettings = getGroupSettings(group.id);
+      const isEnabled = groupSettings.show;
+
+      const toggle = isEnabled ? TOGGLE_ON : TOGGLE_OFF;
+      const indicator = isSelected ? `${ansi.cyan}▸${ansi.reset}` : " ";
+
+      let line = `  ${indicator} ${toggle} ${group.icon} ${group.name}`;
+
+      if (isSelected) {
+        line += `  ${ansi.dim}→ stats${ansi.reset}`;
+      }
+
+      if (visibleWidth(line) > width - 2) {
+        line = truncateToWidth(line, width - 2);
+      }
+
+      lines.push(line);
+    }
+
+    // Footer
+    lines.push("");
+    lines.push(ansi.dim + "─".repeat(width) + ansi.reset);
+    lines.push(this.renderCentered(`${ansi.dim}↑↓ select  Space toggle  → stats  q close${ansi.reset}`, width));
+    lines.push("");
+
+    return lines;
+  }
+
+  /**
+   * Render stats mode.
+   */
+  private renderStatsMode(width: number): string[] {
+    const lines: string[] = [];
+    const group = this.selectedGroupId ? infoRegistry.getGroup(this.selectedGroupId) : null;
+
+    if (!group) {
+      lines.push(`${ansi.red}Group not found${ansi.reset}`);
+      return lines;
+    }
+
+    const groupSettings = getGroupSettings(group.id);
+
+    // Header
+    lines.push("");
+    lines.push(this.renderCentered(`${group.icon} ${group.name} Stats`, width));
+    lines.push("");
+
+    // Separator
+    lines.push(ansi.dim + "─".repeat(width) + ansi.reset);
+    lines.push("");
+
+    // Stats list
+    for (let i = 0; i < group.config.stats.length; i++) {
+      const stat = group.config.stats[i];
+      const isSelected = i === this.selectedIndex;
+      const isEnabled = groupSettings.stats?.[stat.id] ?? stat.show;
+
+      const toggle = isEnabled ? TOGGLE_ON : TOGGLE_OFF;
+      const indicator = isSelected ? `${ansi.cyan}▸${ansi.reset}` : " ";
+
+      let line = `  ${indicator} ${toggle} ${stat.label}`;
+
+      if (visibleWidth(line) > width - 2) {
+        line = truncateToWidth(line, width - 2);
+      }
+
+      lines.push(line);
+    }
+
+    // Footer
+    lines.push("");
+    lines.push(ansi.dim + "─".repeat(width) + ansi.reset);
+    lines.push(this.renderCentered(`${ansi.dim}↑↓ select  Space toggle  ← back  q close${ansi.reset}`, width));
+    lines.push("");
+
+    return lines;
+  }
+
+  /**
+   * Center text within width.
+   */
+  private renderCentered(text: string, width: number): string {
+    const visLen = visibleWidth(text);
+    if (visLen >= width) return text;
+
+    const leftPad = Math.floor((width - visLen) / 2);
+    return " ".repeat(leftPad) + text;
+  }
+}