@pi-unipi/info-screen 0.1.1

package/config.ts

@@ -0,0 +1,171 @@
+/**
+ * @pi-unipi/info-screen — Config system
+ *
+ * Reads/writes info-screen settings in ~/.pi/agent/settings.json
+ * under the "unipi.info" key.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { InfoScreenSettings, GroupSettings } from "./types.js";
+import { DEFAULT_SETTINGS } from "./types.js";
+
+/** Settings path */
+const SETTINGS_PATH = join(homedir(), ".pi", "agent", "settings.json");
+
+/** Settings key within settings.json */
+const SETTINGS_KEY = "unipi";
+
+/** Cached settings */
+let cachedSettings: InfoScreenSettings | null = null;
+
+/**
+ * Check if value is a plain object.
+ */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Read the full settings file.
+ */
+function readSettingsFile(): Record<string, unknown> {
+  if (!existsSync(SETTINGS_PATH)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write the full settings file.
+ */
+function writeSettingsFile(data: Record<string, unknown>): void {
+  const dir = require("node:path").dirname(SETTINGS_PATH);
+  if (!existsSync(dir)) {
+    require("node:fs").mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(SETTINGS_PATH, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+/**
+ * Get info-screen settings from settings.json.
+ */
+export function getInfoSettings(): InfoScreenSettings {
+  if (cachedSettings) return cachedSettings;
+
+  const settings = readSettingsFile();
+  const unipi = settings[SETTINGS_KEY];
+
+  if (!isRecord(unipi) || !isRecord(unipi.info)) {
+    cachedSettings = { ...DEFAULT_SETTINGS };
+    return cachedSettings;
+  }
+
+  const info = unipi.info as Record<string, unknown>;
+
+  cachedSettings = {
+    showOnBoot: typeof info.showOnBoot === "boolean" ? info.showOnBoot : DEFAULT_SETTINGS.showOnBoot,
+    bootTimeoutMs: typeof info.bootTimeoutMs === "number" ? info.bootTimeoutMs : DEFAULT_SETTINGS.bootTimeoutMs,
+    groups: isRecord(info.groups) ? parseGroupSettings(info.groups) : {},
+  };
+
+  return cachedSettings;
+}
+
+/**
+ * Parse group settings from raw object.
+ */
+function parseGroupSettings(raw: Record<string, unknown>): Record<string, GroupSettings> {
+  const result: Record<string, GroupSettings> = {};
+
+  for (const [key, value] of Object.entries(raw)) {
+    if (!isRecord(value)) continue;
+
+    result[key] = {
+      show: typeof value.show === "boolean" ? value.show : true,
+      stats: isRecord(value.stats) ? parseStatSettings(value.stats) : undefined,
+    };
+  }
+
+  return result;
+}
+
+/**
+ * Parse stat settings from raw object.
+ */
+function parseStatSettings(raw: Record<string, unknown>): Record<string, boolean> {
+  const result: Record<string, boolean> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "boolean") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Save info-screen settings to settings.json.
+ */
+export function saveInfoSettings(settings: InfoScreenSettings): void {
+  const file = readSettingsFile();
+
+  if (!isRecord(file[SETTINGS_KEY])) {
+    file[SETTINGS_KEY] = {};
+  }
+
+  (file[SETTINGS_KEY] as Record<string, unknown>).info = {
+    showOnBoot: settings.showOnBoot,
+    bootTimeoutMs: settings.bootTimeoutMs,
+    groups: settings.groups,
+  };
+
+  writeSettingsFile(file);
+  cachedSettings = settings;
+}
+
+/**
+ * Get settings for a specific group.
+ */
+export function getGroupSettings(groupId: string): GroupSettings {
+  const settings = getInfoSettings();
+  return settings.groups[groupId] ?? { show: true };
+}
+
+/**
+ * Update settings for a specific group.
+ */
+export function setGroupSettings(groupId: string, groupSettings: GroupSettings): void {
+  const settings = getInfoSettings();
+  settings.groups[groupId] = groupSettings;
+  saveInfoSettings(settings);
+}
+
+/**
+ * Check if a group is enabled.
+ */
+export function isGroupEnabled(groupId: string): boolean {
+  const settings = getInfoSettings();
+  if (!(groupId in settings.groups)) return true; // Default to enabled
+  return settings.groups[groupId].show;
+}
+
+/**
+ * Check if a stat within a group is enabled.
+ */
+export function isStatEnabled(groupId: string, statId: string): boolean {
+  const groupSettings = getGroupSettings(groupId);
+  if (!groupSettings.stats) return true; // Default to enabled
+  if (!(statId in groupSettings.stats)) return true;
+  return groupSettings.stats[statId];
+}
+
+/**
+ * Clear cached settings (for testing or reload).
+ */
+export function clearSettingsCache(): void {
+  cachedSettings = null;
+}

package/core-groups.ts

@@ -0,0 +1,482 @@
+/**
+ * @pi-unipi/info-screen — Core group registrations
+ *
+ * Registers the 5 core groups: Overview, Usage, Tools, Extensions, Skills.
+ * These are always available (subject to config visibility).
+ */
+
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { infoRegistry } from "./registry.js";
+import { parseUsageStats, formatTokens, formatCost } from "./usage-parser.js";
+import type { InfoGroup } from "./types.js";
+
+/**
+ * Get package version from package.json.
+ */
+function getPackageVersion(packageDir: string): string {
+  try {
+    const pkgPath = join(packageDir, "package.json");
+    if (!existsSync(pkgPath)) return "0.0.0";
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg?.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+/**
+ * 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", "@mariozechner", "pi-coding-agent", "package.json"),
+    // Alternative locations
+    join(homedir(), ".local", "share", "mise", "installs", "node", "lib", "node_modules", "@mariozechner", "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.
+ */
+function discoverExtensions(): Array<{ name: string; source: string; version: string }> {
+  const extensions: Array<{ name: string; source: string; version: string }> = [];
+  const homeDir = process.env.HOME || process.env.USERPROFILE || homedir();
+  const cwd = process.cwd();
+
+  // Check settings.json for package extensions
+  const settingsPaths = [
+    join(homeDir, ".pi", "agent", "settings.json"),
+    join(cwd, ".pi", "settings.json"),
+  ];
+
+  const counted = new Set<string>();
+
+  for (const settingsPath of settingsPaths) {
+    if (!existsSync(settingsPath)) continue;
+
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      if (typeof settings !== "object" || settings === null) continue;
+
+      const packages = settings.packages;
+      if (!Array.isArray(packages)) continue;
+
+      for (const pkg of packages) {
+        let source: string | undefined;
+        let extensionsFilter: string[] | undefined;
+
+        if (typeof pkg === "string") {
+          source = pkg;
+        } else if (typeof pkg === "object" && pkg !== null) {
+          source = pkg.source;
+          extensionsFilter = pkg.extensions;
+        }
+
+        if (!source) continue;
+
+        // Extract package name from source
+        let name = source;
+        if (source.startsWith("npm:")) {
+          const npmPkg = source.slice(4);
+          // Handle scoped packages like @scope/name
+          if (npmPkg.startsWith("@")) {
+            // @scope/name -> name
+            const parts = npmPkg.split("/");
+            name = parts.length > 1 ? parts[1] : npmPkg;
+          } else {
+            name = npmPkg.split("@")[0];
+          }
+        } else if (source.startsWith("git:")) {
+          name = source.split("/").pop()?.replace(/\.git$/, "") ?? source;
+        }
+
+        // Skip empty names
+        if (!name || name.trim() === "") continue;
+        if (counted.has(name)) continue;
+        counted.add(name);
+
+        extensions.push({
+          name,
+          source: source.startsWith("npm:") ? "npm" : source.startsWith("git:") ? "git" : "local",
+          version: "latest",
+        });
+      }
+    } catch {
+      // Skip malformed settings
+    }
+  }
+
+  // Check extension directories
+  const extensionDirs = [
+    join(homeDir, ".pi", "agent", "extensions"),
+    join(cwd, ".pi", "extensions"),
+  ];
+
+  for (const dir of extensionDirs) {
+    if (!existsSync(dir)) continue;
+
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const name = entry.name;
+        if (counted.has(name)) continue;
+
+        if (entry.isFile() && name.endsWith(".ts")) {
+          counted.add(name.replace(".ts", ""));
+          extensions.push({
+            name: name.replace(".ts", ""),
+            source: "local",
+            version: "local",
+          });
+        } else if (entry.isDirectory()) {
+          counted.add(name);
+          extensions.push({
+            name,
+            source: "local",
+            version: "local",
+          });
+        }
+      }
+    } catch {
+      // Skip unreadable directories
+    }
+  }
+
+  return extensions;
+}
+
+/**
+ * Discover loaded skills by scanning filesystem.
+ */
+function discoverSkills(): Array<{ name: string; source: string }> {
+  const skills: Array<{ name: string; source: string }> = [];
+  const homeDir = process.env.HOME || process.env.USERPROFILE || homedir();
+  const cwd = process.cwd();
+
+  // Skill directories to scan
+  const skillDirs = [
+    join(homeDir, ".pi", "agent", "skills"),
+    join(cwd, ".pi", "skills"),
+  ];
+
+  const counted = new Set<string>();
+
+  for (const dir of skillDirs) {
+    if (!existsSync(dir)) continue;
+
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const name = entry.name;
+        if (counted.has(name)) continue;
+
+        // Check if it has a SKILL.md
+        const skillPath = join(dir, name, "SKILL.md");
+        if (existsSync(skillPath)) {
+          counted.add(name);
+          skills.push({
+            name,
+            source: dir.includes(homeDir) ? "global" : "project",
+          });
+        }
+      }
+    } catch {
+      // Skip unreadable directories
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * Track announced modules.
+ */
+const announcedModules: Array<{ name: string; version: string }> = [];
+
+/**
+ * Track registered tools.
+ */
+const registeredTools: Array<{ name: string; source: string }> = [];
+
+/**
+ * Add a module to the announced list.
+ */
+export function trackModule(name: string, version: string): void {
+  if (!announcedModules.find((m) => m.name === name)) {
+    announcedModules.push({ name, version });
+  }
+}
+
+/**
+ * Get list of announced modules.
+ */
+export function getAnnouncedModules(): Array<{ name: string; version: string }> {
+  return [...announcedModules];
+}
+
+/**
+ * Track a registered tool.
+ */
+export function trackTool(name: string, source: string): void {
+  if (!registeredTools.find((t) => t.name === name)) {
+    registeredTools.push({ name, source });
+  }
+}
+
+/**
+ * Get list of registered tools.
+ */
+export function getRegisteredTools(): Array<{ name: string; source: string }> {
+  return [...registeredTools];
+}
+
+/**
+ * Register all core groups.
+ */
+export function registerCoreGroups(): void {
+  // 1. Overview group
+  infoRegistry.registerGroup({
+    id: "overview",
+    name: "Overview",
+    icon: "📊",
+    priority: 10,
+    config: {
+      showByDefault: true,
+      stats: [
+        { id: "version", label: "Pi Version", show: true },
+        { id: "cwd", label: "Working Directory", show: true },
+        { id: "modules", label: "Active Modules", show: true },
+        { id: "uptime", label: "Session Uptime", show: true },
+      ],
+    },
+    dataProvider: async () => {
+      const cwd = process.cwd();
+      const homeDir = process.env.HOME || process.env.USERPROFILE || homedir();
+      const shortCwd = cwd.startsWith(homeDir) ? `~${cwd.slice(homeDir.length)}` : cwd;
+
+      const modules = getAnnouncedModules();
+      const moduleNames = modules.map((m) => m.name.replace(/^@[^/]+\//, ""));
+
+      return {
+        version: { value: getPiVersion(), detail: "pi" },
+        cwd: { value: shortCwd },
+        modules: {
+          value: String(modules.length),
+          detail: moduleNames.slice(0, 4).join(", ") + (moduleNames.length > 4 ? ` +${moduleNames.length - 4} more` : ""),
+        },
+        uptime: { value: formatUptime(process.uptime()) },
+      };
+    },
+  });
+
+  // 2. Usage group
+  infoRegistry.registerGroup({
+    id: "usage",
+    name: "Usage",
+    icon: "💰",
+    priority: 20,
+    config: {
+      showByDefault: true,
+      stats: [
+        { id: "tokensToday", label: "Tokens Today", show: true },
+        { id: "tokensWeek", label: "Tokens This Week", show: true },
+        { id: "tokensMonth", label: "Tokens This Month", show: true },
+        { id: "costToday", label: "Cost Today", show: true },
+        { id: "costAllTime", label: "Cost All Time", show: true },
+        { id: "topModelToday", label: "Top Model Today", show: true },
+        { id: "topModelWeek", label: "Top Model Week", show: true },
+        { id: "topModelMonth", label: "Top Model Month", show: true },
+        { id: "sessions", label: "Total Sessions", show: true },
+      ],
+    },
+    dataProvider: async () => {
+      const stats = parseUsageStats();
+
+      // Find top model for each period
+      const findTopModel = (modelStats: Record<string, { tokens: number; cost: number; sessions: number }> | undefined) => {
+        if (!modelStats) return { name: "none", cost: 0 };
+        let topName = "none";
+        let topCost = 0;
+        for (const [model, data] of Object.entries(modelStats)) {
+          if (data.cost > topCost) {
+            topCost = data.cost;
+            topName = model;
+          }
+        }
+        // Strip "Claude " prefix for brevity
+        if (topName.startsWith("Claude ")) {
+          topName = topName.slice(7);
+        }
+        return { name: topName, cost: topCost };
+      };
+
+      const topToday = findTopModel(stats.byModelToday);
+      const topWeek = findTopModel(stats.byModelWeek);
+      const topMonth = findTopModel(stats.byModelMonth);
+
+      return {
+        tokensToday: { value: formatTokens(stats.tokens.today) },
+        tokensWeek: { value: formatTokens(stats.tokens.week) },
+        tokensMonth: { value: formatTokens(stats.tokens.month) },
+        costToday: { value: formatCost(stats.cost.today) },
+        costAllTime: { value: formatCost(stats.cost.allTime) },
+        topModelToday: { value: topToday.name, detail: formatCost(topToday.cost) },
+        topModelWeek: { value: topWeek.name, detail: formatCost(topWeek.cost) },
+        topModelMonth: { value: topMonth.name, detail: formatCost(topMonth.cost) },
+        sessions: { value: String(stats.sessionCount) },
+      };
+    },
+  });
+
+  // 3. Tools group
+  infoRegistry.registerGroup({
+    id: "tools",
+    name: "Tools",
+    icon: "🔧",
+    priority: 30,
+    config: {
+      showByDefault: true,
+      stats: [
+        { id: "total", label: "Total Tools", show: true },
+        { id: "builtin", label: "Built-in", show: true },
+        { id: "registered", label: "Registered", show: true },
+        { id: "list", label: "Tools", show: true },
+      ],
+    },
+    dataProvider: async () => {
+      const tools = getRegisteredTools();
+      const builtin = tools.filter((t) => t.source === "builtin");
+      const custom = tools.filter((t) => t.source === "registered");
+
+      // Build tool list - show all
+      const toolNames = tools.map((t) => `${t.name}`);
+
+      return {
+        total: { value: String(tools.length) },
+        builtin: { value: String(builtin.length) },
+        registered: { value: String(custom.length) },
+        list: {
+          value: toolNames.length > 0 ? toolNames[0] : "none",
+          detail: toolNames.length > 1 ? toolNames.slice(1).join("\n") : undefined,
+        },
+      };
+    },
+  });
+
+  // 4. Extensions group
+  infoRegistry.registerGroup({
+    id: "extensions",
+    name: "Extensions",
+    icon: "📦",
+    priority: 40,
+    config: {
+      showByDefault: true,
+      stats: [
+        { id: "count", label: "Total Extensions", show: true },
+        { id: "list", label: "Extensions", show: true },
+      ],
+    },
+    dataProvider: async () => {
+      const extensions = discoverExtensions();
+      const bySource: Record<string, number> = {};
+      for (const ext of extensions) {
+        bySource[ext.source] = (bySource[ext.source] ?? 0) + 1;
+      }
+
+      const breakdown = Object.entries(bySource)
+        .map(([src, count]) => `${count} ${src}`)
+        .join(", ");
+
+      // Build multi-line list - show all
+      const listLines: string[] = [];
+      for (const ext of extensions) {
+        listLines.push(`${ext.name} (${ext.source})`);
+      }
+
+      return {
+        count: { value: String(extensions.length), detail: breakdown || "none" },
+        list: {
+          value: listLines.length > 0 ? listLines[0] : "none",
+          detail: listLines.length > 1 ? listLines.slice(1).join("\n") : undefined,
+        },
+      };
+    },
+  });
+
+  // 5. Skills group
+  infoRegistry.registerGroup({
+    id: "skills",
+    name: "Skills",
+    icon: "🎯",
+    priority: 50,
+    config: {
+      showByDefault: true,
+      stats: [
+        { id: "count", label: "Total Skills", show: true },
+        { id: "global", label: "Global Skills", show: true },
+        { id: "project", label: "Project Skills", show: true },
+        { id: "list", label: "Skills", show: true },
+      ],
+    },
+    dataProvider: async () => {
+      const skills = discoverSkills();
+      const global = skills.filter((s) => s.source === "global");
+      const project = skills.filter((s) => s.source === "project");
+
+      // Build skill list - show all
+      const skillNames = skills.map((s) => `${s.name} (${s.source})`);
+
+      return {
+        count: { value: String(skills.length) },
+        global: { value: String(global.length) },
+        project: { value: String(project.length) },
+        list: {
+          value: skillNames.length > 0 ? skillNames[0] : "none",
+          detail: skillNames.length > 1 ? skillNames.slice(1).join("\n") : undefined,
+        },
+      };
+    },
+  });
+}
+
+/**
+ * Format uptime for display.
+ */
+function formatUptime(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${Math.floor(seconds)}s`;
+}