@pi-unipi/footer 0.1.1

package/src/events.ts

@@ -0,0 +1,256 @@
+/**
+ * @pi-unipi/footer — Event subscription wiring
+ *
+ * Wires FooterRegistry to UNIPI_EVENTS for all relevant events.
+ * Each event handler updates the registry cache for the appropriate group.
+ *
+ * Note: pi.events.on() returns an unsubscribe function directly.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { UNIPI_EVENTS } from "@pi-unipi/core";
+import type { FooterRegistry } from "./registry/index.js";
+
+/** Cleanup function returned by subscribeToEvents */
+type UnsubscribeFn = () => void;
+
+/**
+ * Subscribe to all relevant UNIPI_EVENTS and wire them to the registry.
+ * Returns an unsubscribe function for cleanup on session shutdown.
+ */
+export function subscribeToEvents(
+  pi: ExtensionAPI,
+  registry: FooterRegistry,
+): UnsubscribeFn {
+  const unsubscribers: UnsubscribeFn[] = [];
+
+  // ─── Compactor events ───────────────────────────────────────────────────
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.COMPACTOR_STATS_UPDATED, (event: unknown) => {
+      try {
+        registry.updateData("compactor", event);
+      } catch (err) {
+        console.error("[footer] Compactor stats handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.COMPACTOR_COMPACTED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("compactor") as Record<string, unknown> | undefined;
+        registry.updateData("compactor", { ...existing, lastCompaction: event });
+      } catch (err) {
+        console.error("[footer] Compaction handler error:", err);
+      }
+    })
+  );
+
+  // ─── Memory events ─────────────────────────────────────────────────────
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MEMORY_STORED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("memory") as Record<string, unknown> | undefined;
+        registry.updateData("memory", { ...existing, lastStored: event });
+      } catch (err) {
+        console.error("[footer] Memory stored handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MEMORY_DELETED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("memory") as Record<string, unknown> | undefined;
+        registry.updateData("memory", { ...existing, lastDeleted: event });
+      } catch (err) {
+        console.error("[footer] Memory deleted handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MEMORY_CONSOLIDATED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("memory") as Record<string, unknown> | undefined;
+        registry.updateData("memory", { ...existing, lastConsolidated: event });
+      } catch (err) {
+        console.error("[footer] Memory consolidated handler error:", err);
+      }
+    })
+  );
+
+  // ─── MCP events ────────────────────────────────────────────────────────
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MCP_SERVER_STARTED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("mcp") as Record<string, unknown> | undefined;
+        const evt = event as Record<string, unknown> | undefined;
+        const toolCount = typeof evt?.toolCount === "number" ? evt.toolCount : 0;
+        const serversTotal = (typeof existing?.serversTotal === "number" ? existing.serversTotal : 0) + 1;
+        const serversActive = (typeof existing?.serversActive === "number" ? existing.serversActive : 0) + 1;
+        const toolsTotal = (typeof existing?.toolsTotal === "number" ? existing.toolsTotal : 0) + toolCount;
+        registry.updateData("mcp", { ...existing, serversTotal, serversActive, toolsTotal, lastServerStarted: event });
+      } catch (err) {
+        console.error("[footer] MCP server started handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MCP_SERVER_STOPPED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("mcp") as Record<string, unknown> | undefined;
+        const evt = event as Record<string, unknown> | undefined;
+        const stoppedName = typeof evt?.name === "string" ? evt.name : "";
+        const serversActive = Math.max(0, (typeof existing?.serversActive === "number" ? existing.serversActive : 1) - 1);
+        // Subtract tools for this server if tracked
+        const lastStartedTools = existing?.lastServerStarted as Record<string, unknown> | undefined;
+        const lastStartedName = typeof lastStartedTools?.name === "string" ? lastStartedTools.name : "";
+        const lastStartedCount = typeof lastStartedTools?.toolCount === "number" ? lastStartedTools.toolCount : 0;
+        let toolsTotal = typeof existing?.toolsTotal === "number" ? existing.toolsTotal : 0;
+        if (stoppedName && stoppedName === lastStartedName) {
+          toolsTotal = Math.max(0, toolsTotal - lastStartedCount);
+        }
+        registry.updateData("mcp", { ...existing, serversActive, toolsTotal, lastServerStopped: event });
+      } catch (err) {
+        console.error("[footer] MCP server stopped handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MCP_SERVER_ERROR, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("mcp") as Record<string, unknown> | undefined;
+        const serversTotal = (typeof existing?.serversTotal === "number" ? existing.serversTotal : 0) + 1;
+        const serversFailed = (typeof existing?.serversFailed === "number" ? existing.serversFailed : 0) + 1;
+        registry.updateData("mcp", { ...existing, serversTotal, serversFailed, lastServerError: event });
+      } catch (err) {
+        console.error("[footer] MCP server error handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MCP_TOOLS_REGISTERED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("mcp") as Record<string, unknown> | undefined;
+        const evt = event as Record<string, unknown> | undefined;
+        const toolNames = Array.isArray(evt?.toolNames) ? evt.toolNames : [];
+        const toolsTotal = (typeof existing?.toolsTotal === "number" ? existing.toolsTotal : 0) + toolNames.length;
+        registry.updateData("mcp", { ...existing, toolsTotal, lastToolsRegistered: event });
+      } catch (err) {
+        console.error("[footer] MCP tools registered handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MCP_TOOLS_UNREGISTERED, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("mcp") as Record<string, unknown> | undefined;
+        const evt = event as Record<string, unknown> | undefined;
+        const toolNames = Array.isArray(evt?.toolNames) ? evt.toolNames : [];
+        const toolsTotal = Math.max(0, (typeof existing?.toolsTotal === "number" ? existing.toolsTotal : 0) - toolNames.length);
+        registry.updateData("mcp", { ...existing, toolsTotal, lastToolsUnregistered: event });
+      } catch (err) {
+        console.error("[footer] MCP tools unregistered handler error:", err);
+      }
+    })
+  );
+
+  // ─── Ralph events ──────────────────────────────────────────────────────
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.RALPH_LOOP_START, (event: unknown) => {
+      try {
+        registry.updateData("ralph", { ...(event as Record<string, unknown>), active: true });
+      } catch (err) {
+        console.error("[footer] Ralph loop start handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.RALPH_LOOP_END, (event: unknown) => {
+      try {
+        registry.updateData("ralph", { ...(event as Record<string, unknown>), active: false });
+      } catch (err) {
+        console.error("[footer] Ralph loop end handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.RALPH_ITERATION_DONE, (event: unknown) => {
+      try {
+        const existing = registry.getGroupData("ralph") as Record<string, unknown> | undefined;
+        registry.updateData("ralph", { ...existing, lastIteration: event });
+      } catch (err) {
+        console.error("[footer] Ralph iteration handler error:", err);
+      }
+    })
+  );
+
+  // ─── Workflow events ───────────────────────────────────────────────────
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.WORKFLOW_START, (event: unknown) => {
+      try {
+        registry.updateData("workflow", { ...(event as Record<string, unknown>), active: true, startTime: Date.now() });
+      } catch (err) {
+        console.error("[footer] Workflow start handler error:", err);
+      }
+    })
+  );
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.WORKFLOW_END, (event: unknown) => {
+      try {
+        registry.updateData("workflow", { ...(event as Record<string, unknown>), active: false });
+      } catch (err) {
+        console.error("[footer] Workflow end handler error:", err);
+      }
+    })
+  );
+
+  // ─── Notification events ───────────────────────────────────────────────
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.NOTIFICATION_SENT, (event: unknown) => {
+      try {
+        registry.updateData("notify", event);
+      } catch (err) {
+        console.error("[footer] Notification handler error:", err);
+      }
+    })
+  );
+
+  // ─── Module ready events ───────────────────────────────────────────────
+
+  unsubscribers.push(
+    pi.events.on(UNIPI_EVENTS.MODULE_READY, (_event: unknown) => {
+      try {
+        // Invalidate all caches when new modules load — they may bring fresh data
+        registry.invalidateAll();
+      } catch (err) {
+        console.error("[footer] Module ready handler error:", err);
+      }
+    })
+  );
+
+  // Return composite unsubscribe function
+  return () => {
+    for (const unsub of unsubscribers) {
+      try {
+        unsub();
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  };
+}

package/src/index.ts

@@ -0,0 +1,208 @@
+/**
+ * @pi-unipi/footer — Extension entry point
+ *
+ * Main extension function that registers commands, subscribes to events,
+ * initializes renderer on session_start.
+ */
+
+import type { ExtensionAPI, Theme } from "@mariozechner/pi-coding-agent";
+import { UNIPI_EVENTS, emitEvent, UNIPI_PREFIX, FOOTER_COMMANDS } from "@pi-unipi/core";
+import { FooterRegistry, getFooterRegistry } from "./registry/index.js";
+import { FooterRenderer } from "./rendering/renderer.js";
+import { subscribeToEvents } from "./events.js";
+import { loadFooterSettings, saveFooterSettings } from "./config.js";
+import { getPreset } from "./presets.js";
+import { registerCommands } from "./commands.js";
+
+// Import segment groups
+import { CORE_SEGMENTS } from "./segments/core.js";
+import { COMPACTOR_SEGMENTS } from "./segments/compactor.js";
+import { MEMORY_SEGMENTS } from "./segments/memory.js";
+import { MCP_SEGMENTS } from "./segments/mcp.js";
+import { RALPH_SEGMENTS } from "./segments/ralph.js";
+import { WORKFLOW_SEGMENTS } from "./segments/workflow.js";
+import { KANBOARD_SEGMENTS } from "./segments/kanboard.js";
+import { NOTIFY_SEGMENTS } from "./segments/notify.js";
+import { STATUS_EXT_SEGMENTS } from "./segments/status-ext.js";
+
+import type { FooterGroup, FooterSegment } from "./types.js";
+import { getThinkingLevel, rainbowBorder } from "./segments/core.js";
+
+/** All segment groups */
+const ALL_GROUPS: FooterGroup[] = [
+  { id: "core", name: "Core", icon: "", segments: CORE_SEGMENTS, defaultShow: true },
+  { id: "compactor", name: "Compactor", icon: "", segments: COMPACTOR_SEGMENTS, defaultShow: true },
+  { id: "memory", name: "Memory", icon: "", segments: MEMORY_SEGMENTS, defaultShow: true },
+  { id: "mcp", name: "MCP", icon: "", segments: MCP_SEGMENTS, defaultShow: true },
+  { id: "ralph", name: "Ralph", icon: "", segments: RALPH_SEGMENTS, defaultShow: true },
+  { id: "workflow", name: "Workflow", icon: "", segments: WORKFLOW_SEGMENTS, defaultShow: true },
+  { id: "kanboard", name: "Kanboard", icon: "", segments: KANBOARD_SEGMENTS, defaultShow: true },
+  { id: "notify", name: "Notify", icon: "", segments: NOTIFY_SEGMENTS, defaultShow: false },
+  { id: "status_ext", name: "Extensions", icon: "", segments: STATUS_EXT_SEGMENTS, defaultShow: true },
+];
+
+/** Build a segment lookup from all groups */
+function buildSegmentLookup(): Map<string, FooterSegment> {
+  const map = new Map<string, FooterSegment>();
+  for (const group of ALL_GROUPS) {
+    for (const segment of group.segments) {
+      map.set(segment.id, segment);
+    }
+  }
+  return map;
+}
+
+/** Extension state */
+interface FooterState {
+  enabled: boolean;
+  registry: FooterRegistry;
+  renderer: FooterRenderer;
+  segmentLookup: Map<string, FooterSegment>;
+  unsubscribeEvents: (() => void) | null;
+  piContext: unknown;
+  footerData: unknown;
+  tuiRef: any;
+}
+
+export default function footerExtension(pi: ExtensionAPI): void {
+  // Build segment lookup
+  const segmentLookup = buildSegmentLookup();
+
+  // Create state
+  const state: FooterState = {
+    enabled: true,
+    registry: getFooterRegistry(),
+    renderer: new FooterRenderer(
+      getFooterRegistry(),
+      { get: (id: string) => segmentLookup.get(id) },
+      loadFooterSettings().preset,
+    ),
+    segmentLookup,
+    unsubscribeEvents: null,
+    piContext: null,
+    footerData: null,
+    tuiRef: null,
+  };
+
+  // Register all groups in the registry
+  for (const group of ALL_GROUPS) {
+    state.registry.registerGroup(group);
+  }
+
+  // ─── Session lifecycle ──────────────────────────────────────────────────
+
+  pi.on("session_start", async (_event, ctx) => {
+    const settings = loadFooterSettings();
+    state.enabled = settings.enabled;
+    state.piContext = ctx;
+    state.renderer.setPreset(settings.preset);
+    state.renderer.setActive(settings.enabled);
+
+    if (!settings.enabled || !ctx.hasUI) return;
+
+    // Subscribe to events
+    state.unsubscribeEvents = subscribeToEvents(pi, state.registry);
+
+    // Setup footer + widgets
+    setupFooterUI(pi, ctx, state);
+  });
+
+  pi.on("session_shutdown", async () => {
+    state.renderer.setActive(false);
+    state.unsubscribeEvents?.();
+    state.unsubscribeEvents = null;
+    state.piContext = null;
+    state.footerData = null;
+    state.tuiRef = null;
+  });
+
+  // ─── Register commands ──────────────────────────────────────────────────
+
+  registerCommands(pi, state, ALL_GROUPS);
+
+  // ─── Emit MODULE_READY ──────────────────────────────────────────────────
+
+  pi.on("session_start", async () => {
+    emitEvent(pi as any, UNIPI_EVENTS.MODULE_READY, {
+      name: "@pi-unipi/footer",
+      version: "0.1.0",
+      commands: [`${UNIPI_PREFIX}${FOOTER_COMMANDS.FOOTER}`, `${UNIPI_PREFIX}${FOOTER_COMMANDS.FOOTER_SETTINGS}`],
+      tools: [],
+    });
+  });
+}
+
+// ─── Footer UI setup ────────────────────────────────────────────────────────
+
+function setupFooterUI(pi: ExtensionAPI, ctx: any, state: FooterState): void {
+  // Register footer (minimal — handles branch changes)
+  ctx.ui.setFooter((tui: any, _theme: Theme, footerData: any) => {
+    state.tuiRef = tui;
+    state.footerData = footerData;
+    state.renderer.setContext(state.piContext, footerData);
+
+    const unsub = footerData.onBranchChange(() => {
+      state.renderer.resetLayoutCache();
+    });
+
+    return {
+      dispose: unsub,
+      invalidate() {
+        state.renderer.resetLayoutCache();
+      },
+      render(): string[] {
+        return [];
+      },
+    };
+  });
+
+  // Top row widget
+  ctx.ui.setWidget("footer-top", (_tui: any, theme: Theme) => {
+    // Update the renderer's theme-like
+    const themeLike = { fg: (color: string, text: string) => theme.fg(color as any, text) };
+    // We need to patch the context with proper theme
+    state.renderer.setContext(state.piContext, state.footerData);
+
+    return {
+      dispose() {},
+      invalidate() {
+        state.renderer.resetLayoutCache();
+      },
+      render(width: number): string[] {
+        if (!state.enabled || !state.piContext) return [];
+
+        // Build layout with proper theme by creating segment contexts
+        const layout = state.renderer.computeLayout(width);
+        return layout.topContent ? [layout.topContent] : [];
+      },
+    };
+  }, { placement: "aboveEditor" });
+
+  // Secondary row widget + rainbow input border for xhigh thinking
+  ctx.ui.setWidget("footer-secondary", (_tui: any, _theme: Theme) => {
+    return {
+      dispose() {},
+      invalidate() {
+        state.renderer.resetLayoutCache();
+      },
+      render(width: number): string[] {
+        if (!state.enabled || !state.piContext) return [];
+
+        const lines: string[] = [];
+
+        // Rainbow border for input bar when thinking level is xhigh
+        const thinkingLevel = getThinkingLevel(state.piContext);
+        if (thinkingLevel === "xhigh") {
+          lines.push(rainbowBorder(width));
+        }
+
+        const layout = state.renderer.computeLayout(width);
+        if (layout.secondaryContent) {
+          lines.push(layout.secondaryContent);
+        }
+
+        return lines;
+      },
+    };
+  }, { placement: "belowEditor" });
+}

package/src/presets.ts

@@ -0,0 +1,131 @@
+/**
+ * @pi-unipi/footer — Presets system
+ *
+ * Preset definitions: default, minimal, compact, full, nerd, ascii.
+ * Each preset defines which segments appear on left, right, and secondary rows,
+ * plus separator style and color scheme.
+ */
+
+import type { PresetDef, SeparatorStyle, ColorScheme } from "./types.js";
+import { getDefaultColors } from "./rendering/theme.js";
+
+/** Default preset — balanced view */
+const DEFAULT_PRESET: PresetDef = {
+  leftSegments: [
+    "model", "thinking", "path", "git", "context_pct", "cost",
+  ],
+  rightSegments: [
+    "compactions", "tokens_saved", "project_count", "loop_status",
+  ],
+  secondarySegments: [
+    "current_command", "session_events",
+  ],
+  separator: "powerline-thin",
+  colors: getDefaultColors(),
+};
+
+/** Minimal preset — just the essentials */
+const MINIMAL_PRESET: PresetDef = {
+  leftSegments: [
+    "path", "git", "context_pct",
+  ],
+  rightSegments: [],
+  secondarySegments: [],
+  separator: "pipe",
+  colors: getDefaultColors(),
+};
+
+/** Compact preset — core + key stats */
+const COMPACT_PRESET: PresetDef = {
+  leftSegments: [
+    "model", "git", "cost", "context_pct",
+  ],
+  rightSegments: [
+    "compactions", "total_count",
+  ],
+  secondarySegments: [],
+  separator: "dot",
+  colors: getDefaultColors(),
+};
+
+/** Full preset — everything */
+const FULL_PRESET: PresetDef = {
+  leftSegments: [
+    "model", "thinking", "path", "git", "context_pct", "cost",
+    "tokens_total", "tokens_in", "tokens_out",
+  ],
+  rightSegments: [
+    "session_events", "compactions", "tokens_saved", "compression_ratio",
+    "indexed_docs", "sandbox_runs", "search_queries",
+    "project_count", "total_count", "consolidations",
+    "servers_total", "servers_active", "tools_total", "servers_failed",
+    "active_loops", "total_iterations", "loop_status",
+    "current_command", "command_duration",
+    "docs_count", "tasks_done", "tasks_total", "task_pct",
+    "extension_statuses",
+  ],
+  secondarySegments: [
+    "hostname", "time",
+    "platforms_enabled", "last_sent",
+  ],
+  separator: "powerline-thin",
+  colors: getDefaultColors(),
+};
+
+/** Nerd preset — maximum detail for Nerd Font users */
+const NERD_PRESET: PresetDef = {
+  leftSegments: [
+    "model", "thinking", "path", "git", "context_pct", "cost",
+    "tokens_total",
+  ],
+  rightSegments: [
+    "session_events", "compactions", "tokens_saved",
+    "project_count", "total_count",
+    "servers_total", "servers_active", "tools_total",
+    "active_loops", "loop_status",
+    "current_command",
+    "docs_count", "tasks_done", "tasks_total", "task_pct",
+    "extension_statuses",
+  ],
+  secondarySegments: [
+    "hostname", "time",
+    "compression_ratio", "indexed_docs",
+    "platforms_enabled", "last_sent",
+  ],
+  separator: "powerline",
+  colors: getDefaultColors(),
+};
+
+/** ASCII preset — safe for any terminal */
+const ASCII_PRESET: PresetDef = {
+  leftSegments: [
+    "model", "path", "git", "context_pct", "cost",
+  ],
+  rightSegments: [
+    "compactions", "tokens_saved", "project_count",
+  ],
+  secondarySegments: [],
+  separator: "ascii",
+  colors: getDefaultColors(),
+};
+
+/** All preset definitions */
+export const PRESETS: Record<string, PresetDef> = {
+  default: DEFAULT_PRESET,
+  minimal: MINIMAL_PRESET,
+  compact: COMPACT_PRESET,
+  full: FULL_PRESET,
+  nerd: NERD_PRESET,
+  ascii: ASCII_PRESET,
+};
+
+/** Valid preset names */
+export const PRESET_NAMES = Object.keys(PRESETS);
+
+/**
+ * Get a preset definition by name.
+ * Falls back to "default" if the name is not recognized.
+ */
+export function getPreset(name: string): PresetDef {
+  return PRESETS[name] ?? PRESETS.default ?? DEFAULT_PRESET;
+}