@zigai/pi-footer 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigai/pi-footer",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Pi package that replaces Pi's footer with a compact status line.",
   "keywords": [
     "footer",

package/src/footer-component.ts

@@ -0,0 +1,41 @@
+export const FOOTER_COMPONENT_MARKER = Symbol.for("zigai.pi-footer.component");
+export const FOOTER_COMPONENT_KIND = Symbol.for("zigai.pi-footer.component-kind");
+
+export type FooterComponentKind = "live" | "bridge";
+
+export type MarkedFooterComponent = {
+    [FOOTER_COMPONENT_MARKER]: true;
+    [FOOTER_COMPONENT_KIND]: FooterComponentKind;
+};
+
+function isObject(value: unknown): value is object {
+    return typeof value === "object" && value !== null;
+}
+
+export function markFooterComponent<T extends object>(
+    component: T,
+    kind: FooterComponentKind,
+): T & MarkedFooterComponent {
+    Object.defineProperty(component, FOOTER_COMPONENT_MARKER, {
+        configurable: false,
+        enumerable: false,
+        value: true,
+    });
+    Object.defineProperty(component, FOOTER_COMPONENT_KIND, {
+        configurable: true,
+        enumerable: false,
+        value: kind,
+    });
+    return component as T & MarkedFooterComponent;
+}
+
+export function getFooterComponentKind(value: unknown): FooterComponentKind | undefined {
+    if (!isObject(value)) return undefined;
+
+    const candidate = value as Partial<MarkedFooterComponent>;
+    if (candidate[FOOTER_COMPONENT_MARKER] !== true) return undefined;
+
+    const kind = candidate[FOOTER_COMPONENT_KIND];
+    if (kind === "live" || kind === "bridge") return kind;
+    return undefined;
+}

package/src/footer-rendering.ts

@@ -1,4 +1,3 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 import {
@@ -11,6 +10,7 @@ import {
 } from "./constants.ts";
 import type {
     ContextUsage,
+    FooterContext,
     FooterData,
     FooterItem,
     FooterKey,
@@ -128,7 +128,7 @@ function getContextText(usage: ContextUsage, fallbackWindow?: number): string {
     return `${contextPercent.toFixed(1)}%/${formatTokens(contextWindow)}`;
 }
 
-function getMcpText(ctx: ExtensionContext, footerData: FooterData): string | null {
+function getMcpText(ctx: FooterContext, footerData: FooterData): string | null {
     const statuses = Array.from(footerData.getExtensionStatuses().values())
         .map(sanitizeStatusText)
         .filter((status) => status.length > 0);
@@ -136,7 +136,7 @@ function getMcpText(ctx: ExtensionContext, footerData: FooterData): string | nul
     const mcpStatus = statuses.find((status) => /^MCP:/i.test(status));
     if (mcpStatus !== undefined && mcpStatus.length > 0) return mcpStatus;
 
-    const serverCount = (ctx as ExtensionContext & { mcpServers?: unknown[] }).mcpServers?.length;
+    const serverCount = ctx.mcpServers?.length;
     if (typeof serverCount === "number") {
         return `MCP: ${serverCount} servers`;
     }
@@ -217,7 +217,7 @@ function renderPadding(width: number, variant: FooterVariant): string {
 }
 
 function buildFooterItems(
-    ctx: ExtensionContext,
+    ctx: FooterContext,
     footerData: FooterData,
     thinkingLevel: string,
 ): Partial<Record<FooterKey, FooterItem>> {
@@ -278,7 +278,7 @@ function buildFooterItems(
 }
 
 export function createFooterComponent(
-    ctx: ExtensionContext,
+    ctx: FooterContext,
     footerData: FooterData,
     getThinkingLevel: () => string,
     requestRender: () => void,

package/src/footer-transition.ts

@@ -0,0 +1,189 @@
+import {
+    InteractiveMode,
+    type ExtensionContext,
+    type SessionShutdownEvent,
+} from "@earendil-works/pi-coding-agent";
+
+import { markFooterComponent, getFooterComponentKind } from "./footer-component.ts";
+import { createFooterComponent } from "./footer-rendering.ts";
+import type { ContextUsage, FooterContext, FooterData, FooterModel } from "./types.ts";
+
+const RESET_PATCH_MARKER = Symbol.for("zigai.pi-footer.reset-extension-ui-patch");
+const TRANSITION_STATE_KEY = "__zigaiPiFooterTransitionState__";
+const BRIDGE_FOOTER_TTL_MS = 15_000;
+
+type FooterComponent = ReturnType<typeof createFooterComponent>;
+type FooterFactory = (
+    tui: { requestRender(): void },
+    theme: unknown,
+    footerData: FooterData,
+) => FooterComponent;
+
+type FooterResetHost = {
+    customFooter?: unknown;
+    resetExtensionUI(): void;
+    setExtensionFooter(factory: FooterFactory | undefined): void;
+};
+
+type PatchableInteractiveModePrototype = {
+    customFooter?: unknown;
+    resetExtensionUI?: (this: FooterResetHost) => void;
+    setExtensionFooter?: (this: FooterResetHost, factory: FooterFactory | undefined) => void;
+    [RESET_PATCH_MARKER]?: true;
+};
+
+type FooterSnapshot = {
+    context: FooterContext;
+    thinkingLevel: string;
+};
+
+type MaybeMcpContext = ExtensionContext & {
+    mcpServers?: unknown[];
+};
+
+type FooterTransitionState = {
+    latestSnapshot?: FooterSnapshot;
+    pendingShutdownReason?: SessionShutdownEvent["reason"];
+    liveInstallGeneration: number;
+};
+
+type FooterTransitionGlobal = typeof globalThis & {
+    [TRANSITION_STATE_KEY]?: FooterTransitionState;
+};
+
+function getTransitionState(): FooterTransitionState {
+    const globalState = globalThis as FooterTransitionGlobal;
+    let state = globalState[TRANSITION_STATE_KEY];
+    if (state === undefined) {
+        state = { liveInstallGeneration: 0 };
+        globalState[TRANSITION_STATE_KEY] = state;
+    }
+    return state;
+}
+
+function cloneContextUsage(usage: ContextUsage): ContextUsage {
+    if (usage === undefined) return undefined;
+    return { ...usage };
+}
+
+function cloneModel(model: ExtensionContext["model"]): FooterModel | undefined {
+    if (model === undefined) return undefined;
+
+    return {
+        provider: model.provider,
+        id: model.id,
+        contextWindow: model.contextWindow,
+    };
+}
+
+function cloneMcpServers(ctx: ExtensionContext): unknown[] | undefined {
+    const servers = (ctx as MaybeMcpContext).mcpServers;
+    if (!Array.isArray(servers)) return undefined;
+
+    return Array.from<unknown>({ length: servers.length });
+}
+
+function createFooterSnapshot(ctx: ExtensionContext, thinkingLevel: string): FooterSnapshot {
+    const usage = cloneContextUsage(ctx.getContextUsage());
+
+    return {
+        context: {
+            cwd: ctx.cwd,
+            model: cloneModel(ctx.model),
+            mcpServers: cloneMcpServers(ctx),
+            getContextUsage() {
+                return usage;
+            },
+        },
+        thinkingLevel,
+    };
+}
+
+function shouldBridgeFooter(kind: string | undefined, state: FooterTransitionState): boolean {
+    if (kind !== "live" && kind !== "bridge") return false;
+    if (state.latestSnapshot === undefined) return false;
+    if (state.pendingShutdownReason === undefined) return false;
+    if (state.pendingShutdownReason === "quit") return false;
+    return true;
+}
+
+function installBridgeFooter(host: FooterResetHost, snapshot: FooterSnapshot): void {
+    const generationAtInstall = getTransitionState().liveInstallGeneration;
+
+    host.setExtensionFooter((tui, _theme, footerData) => {
+        const component = createFooterComponent(
+            snapshot.context,
+            footerData,
+            () => snapshot.thinkingLevel,
+            () => tui.requestRender(),
+        );
+        return markFooterComponent(component, "bridge");
+    });
+
+    const timeout = setTimeout(() => {
+        const state = getTransitionState();
+        if (state.liveInstallGeneration !== generationAtInstall) return;
+        if (getFooterComponentKind(host.customFooter) !== "bridge") return;
+        host.setExtensionFooter(undefined);
+    }, BRIDGE_FOOTER_TTL_MS);
+    timeout.unref?.();
+}
+
+export function patchFooterReset(): void {
+    // Pi resets extension-owned UI between session replacements before the
+    // replacement session has emitted session_start. Reinstall a snapshot-backed
+    // bridge footer in that same reset call so the built-in footer never paints
+    // during the handoff.
+    const prototype = InteractiveMode.prototype as unknown as PatchableInteractiveModePrototype;
+    if (prototype[RESET_PATCH_MARKER] === true) return;
+
+    const originalReset = prototype.resetExtensionUI;
+    const setExtensionFooter = prototype.setExtensionFooter;
+    if (typeof originalReset !== "function") return;
+    if (typeof setExtensionFooter !== "function") return;
+
+    prototype.resetExtensionUI = function patchedFooterReset(this: FooterResetHost): void {
+        const footerKind = getFooterComponentKind(this.customFooter);
+        const state = getTransitionState();
+        const snapshot = state.latestSnapshot;
+        const bridgeFooter = shouldBridgeFooter(footerKind, state);
+
+        originalReset.call(this);
+        state.pendingShutdownReason = undefined;
+
+        if (!bridgeFooter || snapshot === undefined) return;
+        installBridgeFooter(this, snapshot);
+    };
+
+    prototype[RESET_PATCH_MARKER] = true;
+}
+
+export function installLiveFooter(ctx: ExtensionContext, getThinkingLevel: () => string): void {
+    ctx.ui.setFooter((tui, _theme, footerData) => {
+        const component = createFooterComponent(ctx, footerData, getThinkingLevel, () =>
+            tui.requestRender(),
+        );
+        return markFooterComponent(component, "live");
+    });
+
+    const state = getTransitionState();
+    state.latestSnapshot = createFooterSnapshot(ctx, getThinkingLevel());
+    state.pendingShutdownReason = undefined;
+    state.liveInstallGeneration += 1;
+}
+
+export function rememberFooterForTransition(
+    ctx: ExtensionContext,
+    reason: SessionShutdownEvent["reason"],
+    thinkingLevel: string,
+): void {
+    const state = getTransitionState();
+    state.pendingShutdownReason = reason;
+
+    if (reason === "quit") {
+        state.latestSnapshot = undefined;
+        return;
+    }
+
+    state.latestSnapshot = createFooterSnapshot(ctx, thinkingLevel);
+}

package/src/index.ts

@@ -1,24 +1,27 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
-import { createFooterComponent } from "./footer-rendering.ts";
+import {
+    installLiveFooter,
+    patchFooterReset,
+    rememberFooterForTransition,
+} from "./footer-transition.ts";
+import { patchTuiShrinkRedraw } from "./tui-shrink-redraw.ts";
 
 export default function uiEnhancements(pi: ExtensionAPI) {
+    patchFooterReset();
+    patchTuiShrinkRedraw();
+
+    const getThinkingLevel = () => pi.getThinkingLevel();
+
     const installFooter = (ctx: ExtensionContext) => {
-        ctx.ui.setFooter((tui, _theme, footerData) =>
-            createFooterComponent(
-                ctx,
-                footerData,
-                () => pi.getThinkingLevel(),
-                () => tui.requestRender(),
-            ),
-        );
+        installLiveFooter(ctx, getThinkingLevel);
     };
 
     pi.on("session_start", async (_event, ctx) => {
         installFooter(ctx);
     });
 
-    pi.on("session_shutdown", async (_event, ctx) => {
-        ctx.ui.setFooter(undefined);
+    pi.on("session_shutdown", async (event, ctx) => {
+        rememberFooterForTransition(ctx, event.reason, getThinkingLevel());
     });
 }

package/src/tui-shrink-redraw.ts

@@ -0,0 +1,95 @@
+import { TUI } from "@earendil-works/pi-tui";
+
+const TUI_SHRINK_REDRAW_PATCH_MARKER = Symbol.for("zigai.pi-footer.tui-shrink-redraw-patch");
+
+type PatchableTuiInstance = {
+    previousLines?: unknown;
+    previousViewportTop?: unknown;
+    fullRedrawCount?: unknown;
+    overlayStack?: unknown;
+    requestRender(force?: boolean): void;
+};
+
+type PatchableTuiPrototype = {
+    doRender?: (this: PatchableTuiInstance) => void;
+    requestRender?: (this: PatchableTuiInstance, force?: boolean) => void;
+    [TUI_SHRINK_REDRAW_PATCH_MARKER]?: true;
+};
+
+function getLineCount(tui: PatchableTuiInstance): number {
+    if (!Array.isArray(tui.previousLines)) return 0;
+    return tui.previousLines.length;
+}
+
+function getNumber(value: unknown): number | undefined {
+    if (typeof value !== "number") return undefined;
+    if (!Number.isFinite(value)) return undefined;
+    return value;
+}
+
+function hasOverlayStack(tui: PatchableTuiInstance): boolean {
+    if (!Array.isArray(tui.overlayStack)) return false;
+    return tui.overlayStack.length > 0;
+}
+
+function fullRedrawOccurred(previous: number | undefined, next: number | undefined): boolean {
+    if (previous === undefined || next === undefined) return false;
+    return next > previous;
+}
+
+function shouldForceRedrawAfterShrink(
+    tui: PatchableTuiInstance,
+    previousLineCount: number,
+    nextLineCount: number,
+    previousViewportTop: number | undefined,
+    previousFullRedrawCount: number | undefined,
+): boolean {
+    if (nextLineCount >= previousLineCount) return false;
+    if (previousViewportTop === undefined || previousViewportTop <= 0) return false;
+    if (hasOverlayStack(tui)) return false;
+
+    const nextFullRedrawCount = getNumber(tui.fullRedrawCount);
+    if (fullRedrawOccurred(previousFullRedrawCount, nextFullRedrawCount)) return false;
+
+    return true;
+}
+
+export function patchTuiShrinkRedraw(): void {
+    // Pi's differential renderer does not re-anchor the viewport when content
+    // shrinks while scrolled. That can leave the footer one row above the
+    // terminal bottom after a transient loader/widget row disappears. Force a
+    // one-shot full redraw after such a shrink so the viewport snaps back to the
+    // bottom without requiring extension widgets to render placeholder rows.
+    const prototype = TUI.prototype as unknown as PatchableTuiPrototype;
+    if (prototype[TUI_SHRINK_REDRAW_PATCH_MARKER] === true) return;
+
+    const originalDoRender = prototype.doRender;
+    const originalRequestRender = prototype.requestRender;
+    if (typeof originalDoRender !== "function") return;
+    if (typeof originalRequestRender !== "function") return;
+
+    prototype.doRender = function patchedDoRender(this: PatchableTuiInstance): void {
+        const previousLineCount = getLineCount(this);
+        const previousViewportTop = getNumber(this.previousViewportTop);
+        const previousFullRedrawCount = getNumber(this.fullRedrawCount);
+
+        originalDoRender.call(this);
+
+        const nextLineCount = getLineCount(this);
+        if (
+            !shouldForceRedrawAfterShrink(
+                this,
+                previousLineCount,
+                nextLineCount,
+                previousViewportTop,
+                previousFullRedrawCount,
+            )
+        ) {
+            return;
+        }
+
+        originalRequestRender.call(this, true);
+    };
+
+    prototype[TUI_SHRINK_REDRAW_PATCH_MARKER] = true;
+}

package/src/types.ts

@@ -32,6 +32,17 @@ export type FooterKey = "path" | "branch" | "provider" | "model" | "thinking" |
 export type Rgb = [number, number, number];
 export type SegmentColors = { bg: string; fg: string };
 export type ContextUsage = ReturnType<ExtensionContext["getContextUsage"]>;
+export type FooterModel = {
+    provider: string;
+    id: string;
+    contextWindow?: number;
+};
+export type FooterContext = {
+    cwd: string;
+    model?: FooterModel;
+    mcpServers?: unknown[];
+    getContextUsage(): ContextUsage;
+};
 
 export type FooterData = {
     getGitBranch(): string | null;