@astrofoundry/pi-astro 0.14.1 → 0.14.2

package/extensions/astro-welcome/index.test.ts

@@ -25,33 +25,63 @@ interface FakeCtx {
     model: { id: string; contextWindow: number } | undefined;
     sessionManager: { getEntries: () => unknown[] };
     ui: {
-        setHeader: ReturnType<typeof vi.fn>;
-        onTerminalInput: ReturnType<typeof vi.fn>;
+        custom: ReturnType<typeof vi.fn>;
     };
 }
 
-function makeCtx(overrides: Partial<FakeCtx> = {}): FakeCtx & { _terminalListener: ((data: string) => unknown) | null } {
-    const state = { listener: null as ((data: string) => unknown) | null };
-    const onTerminalInput = vi.fn((handler: (data: string) => unknown) => {
-        state.listener = handler;
-        return () => {
-            state.listener = null;
-        };
-    });
+interface CapturedComponent {
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput?(data: string): void;
+    dispose?(): void;
+}
+
+interface CapturedFactory {
+    options: unknown;
+    done: (result: unknown) => void;
+    component: CapturedComponent | null;
+    settle: Promise<unknown>;
+}
+
+function makeCtx(overrides: Partial<FakeCtx> = {}): FakeCtx & { _factory: CapturedFactory | null } {
+    const state: { factory: CapturedFactory | null } = { factory: null };
+    const customMock = vi.fn(
+        (
+            factory: (
+                tui: { requestRender: () => void },
+                theme: unknown,
+                kb: unknown,
+                done: (result: unknown) => void,
+            ) => CapturedComponent,
+            options: unknown,
+        ) => {
+            let resolveSettle: (r: unknown) => void = () => {};
+            const settle = new Promise<unknown>((resolve) => {
+                resolveSettle = resolve;
+            });
+            const cap: CapturedFactory = {
+                options,
+                done: (r: unknown) => resolveSettle(r),
+                component: null,
+                settle,
+            };
+            state.factory = cap;
+            const tui = { requestRender: vi.fn() };
+            cap.component = factory(tui, {}, {}, cap.done);
+            return cap.settle;
+        },
+    );
     return {
         hasUI: true,
         cwd: "/Users/astro/proj",
         model: { id: "anthropic/claude-sonnet-4-6", contextWindow: 1_000_000 },
         sessionManager: { getEntries: () => [] },
-        ui: {
-            setHeader: vi.fn(),
-            onTerminalInput,
-        },
-        get _terminalListener() {
-            return state.listener;
+        ui: { custom: customMock },
+        get _factory() {
+            return state.factory;
         },
         ...overrides,
-    } as FakeCtx & { _terminalListener: ((data: string) => unknown) | null };
+    } as FakeCtx & { _factory: CapturedFactory | null };
 }
 
 describe("astro-welcome extension", () => {
@@ -72,75 +102,71 @@ describe("astro-welcome extension", () => {
         return { pi, mod };
     }
 
-    it("registers session_start and before_agent_start listeners", async () => {
+    it("registers session_start and before_agent_start handlers", async () => {
         const { pi } = await install();
         expect(pi.handlers.session_start).toBeDefined();
         expect(pi.handlers.before_agent_start).toBeDefined();
     });
 
-    it("on startup session_start, sets a header and arms a terminal-input listener", async () => {
+    it("session_start opens a centered overlay via ctx.ui.custom", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
-        expect(ctx.ui.setHeader).toHaveBeenCalledTimes(1);
-        expect(ctx.ui.onTerminalInput).toHaveBeenCalledTimes(1);
+        await pi.handlers.session_start({}, ctx);
+        expect(ctx.ui.custom).toHaveBeenCalledTimes(1);
+        const opts = ctx._factory!.options as { overlay: boolean; overlayOptions: { anchor: string } };
+        expect(opts.overlay).toBe(true);
+        expect(opts.overlayOptions.anchor).toBe("center");
     });
 
     it("does nothing when ctx.hasUI is false", async () => {
         const { pi } = await install();
         const ctx = makeCtx({ hasUI: false });
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
-        expect(ctx.ui.setHeader).not.toHaveBeenCalled();
+        await pi.handlers.session_start({}, ctx);
+        expect(ctx.ui.custom).not.toHaveBeenCalled();
     });
 
-    it("clears the header automatically after 6 seconds", async () => {
+    it("auto-dismisses after 6 seconds via done(undefined)", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
+        await pi.handlers.session_start({}, ctx);
+        const settle = ctx._factory!.settle;
         vi.advanceTimersByTime(6_000);
-        const calls = ctx.ui.setHeader.mock.calls;
-        expect(calls.length).toBe(2);
-        expect(calls[1][0]).toBeUndefined();
+        await expect(settle).resolves.toBeUndefined();
     });
 
-    it("clears the header on the first terminal input keystroke", async () => {
+    it("dismisses on first handleInput keystroke", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
-        const listener = ctx._terminalListener;
-        expect(listener).not.toBeNull();
-        const result = listener!("a");
-        expect(result).toBeUndefined();
-        expect(ctx.ui.setHeader).toHaveBeenLastCalledWith(undefined);
+        await pi.handlers.session_start({}, ctx);
+        const settle = ctx._factory!.settle;
+        ctx._factory!.component!.handleInput!("x");
+        await expect(settle).resolves.toBeUndefined();
     });
 
-    it("clears the header on before_agent_start", async () => {
+    it("dismisses on before_agent_start (external dismiss)", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
+        await pi.handlers.session_start({}, ctx);
+        const settle = ctx._factory!.settle;
         await pi.handlers.before_agent_start({ prompt: "hi" }, ctx);
-        expect(ctx.ui.setHeader).toHaveBeenLastCalledWith(undefined);
+        await expect(settle).resolves.toBeUndefined();
     });
 
-    it("dismiss is idempotent — second trigger does not double-clear", async () => {
+    it("dismiss is idempotent — second trigger does not throw", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
-        await pi.handlers.before_agent_start({ prompt: "hi" }, ctx);
-        const before = ctx.ui.setHeader.mock.calls.length;
+        await pi.handlers.session_start({}, ctx);
+        ctx._factory!.component!.handleInput!("a");
+        await ctx._factory!.settle;
+        expect(() => ctx._factory!.component!.handleInput!("b")).not.toThrow();
         vi.advanceTimersByTime(6_000);
-        expect(ctx.ui.setHeader.mock.calls.length).toBe(before);
     });
 
-    it("renders header with all stats and dismiss hint visible", async () => {
+    it("renders all stats and the dismiss hint in the overlay component", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
-        const factory = ctx.ui.setHeader.mock.calls[0][0] as (
-            tui: unknown,
-            theme: unknown,
-        ) => { render: (w: number) => string[] };
-        const lines = factory({}, {}).render(120);
+        await pi.handlers.session_start({}, ctx);
+        const lines = ctx._factory!.component!.render(120);
         const joined = lines.join("\n");
         expect(joined).toContain("ASTRO PI");
         expect(joined).toContain("anthropic/claude-sonnet-4-6");
@@ -158,11 +184,8 @@ describe("astro-welcome extension", () => {
                 ],
             },
         });
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
-        const factory = ctx.ui.setHeader.mock.calls[0][0] as (
-            tui: unknown,
-            theme: unknown,
-        ) => { render: (w: number) => string[] };
-        expect(factory({}, {}).render(120).join("\n")).toContain("caveman: ultra");
+        await pi.handlers.session_start({}, ctx);
+        const lines = ctx._factory!.component!.render(120);
+        expect(lines.join("\n")).toContain("caveman: ultra");
     });
 });

package/extensions/astro-welcome/index.ts

@@ -1,11 +1,15 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { composeWelcome, type WelcomeStats } from "./compose.ts";
+import { ART_HEIGHT, ART_WIDTH } from "./art.ts";
 
 const DISMISS_AFTER_MS = 6_000;
+const OVERLAY_WIDTH = Math.max(ART_WIDTH + 30, 70);
+const OVERLAY_HEIGHT = ART_HEIGHT + 7;
 
 function readCavemanLevel(ctx: ExtensionContext): string | undefined {
-    for (let i = ctx.sessionManager.getEntries().length - 1; i >= 0; i--) {
-        const entry = ctx.sessionManager.getEntries()[i];
+    const entries = ctx.sessionManager.getEntries();
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
         if (entry.type === "custom" && entry.customType === "caveman-mode") {
             const data = entry.data as { level?: string } | undefined;
             return data?.level ?? undefined;
@@ -14,74 +18,74 @@ function readCavemanLevel(ctx: ExtensionContext): string | undefined {
     return undefined;
 }
 
-function modelDisplayShort(modelId: string | undefined): string | undefined {
-    if (!modelId) return undefined;
-    const trimmed = modelId.trim();
-    if (trimmed.length === 0) return undefined;
-    return trimmed;
-}
-
 export default function astroWelcomeExtension(pi: ExtensionAPI): void {
-    let dismissed = false;
-    let timer: ReturnType<typeof setTimeout> | null = null;
-    let unsubscribeInput: (() => void) | null = null;
-    let activeCtx: ExtensionContext | null = null;
-
-    function dismiss(): void {
-        if (dismissed) return;
-        dismissed = true;
-        if (timer !== null) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        if (unsubscribeInput !== null) {
-            try {
-                unsubscribeInput();
-            } catch {
-                /* ignore unsubscribe errors */
-            }
-            unsubscribeInput = null;
-        }
-        try {
-            activeCtx?.ui.setHeader(undefined);
-        } catch {
-            /* ignore header clear errors */
-        }
-        activeCtx = null;
-    }
+    let externalDismiss: (() => void) | null = null;
 
     pi.on("session_start", async (_event, ctx) => {
         if (!ctx.hasUI) return;
-        dismissed = false;
-        activeCtx = ctx;
-        const seed = Date.now() & 0xffff_ffff;
 
+        const seed = Date.now() & 0xffff_ffff;
         const stats: WelcomeStats = {
-            modelDisplay: modelDisplayShort(ctx.model?.id),
+            modelDisplay: ctx.model?.id,
             contextWindow: ctx.model?.contextWindow,
             extensionCount: pi.getAllTools().length,
             cavemanLevel: readCavemanLevel(ctx),
         };
 
-        ctx.ui.setHeader((_tui, _theme) => ({
-            invalidate() {},
-            render(width: number): string[] {
-                return composeWelcome(width, seed, stats);
-            },
-        }));
+        let dismissed = false;
+        let timer: ReturnType<typeof setTimeout> | null = null;
 
-        timer = setTimeout(dismiss, DISMISS_AFTER_MS);
-        try {
-            unsubscribeInput = ctx.ui.onTerminalInput(() => {
-                dismiss();
-                return undefined;
+        ctx.ui
+            .custom(
+                (tui, _theme, _kb, done) => {
+                    const dismiss = (): void => {
+                        if (dismissed) return;
+                        dismissed = true;
+                        if (timer !== null) {
+                            clearTimeout(timer);
+                            timer = null;
+                        }
+                        externalDismiss = null;
+                        done(undefined);
+                    };
+
+                    timer = setTimeout(dismiss, DISMISS_AFTER_MS);
+                    externalDismiss = dismiss;
+
+                    return {
+                        invalidate(): void {
+                            tui.requestRender();
+                        },
+                        render(width: number): string[] {
+                            return composeWelcome(width, seed, stats);
+                        },
+                        handleInput(): void {
+                            dismiss();
+                        },
+                        dispose(): void {
+                            if (timer !== null) {
+                                clearTimeout(timer);
+                                timer = null;
+                            }
+                            externalDismiss = null;
+                        },
+                    };
+                },
+                {
+                    overlay: true,
+                    overlayOptions: {
+                        anchor: "center",
+                        width: OVERLAY_WIDTH,
+                        maxHeight: OVERLAY_HEIGHT,
+                    },
+                },
+            )
+            .catch(() => {
+                /* overlay close errors are not fatal */
             });
-        } catch {
-            /* terminal input listener not supported in this mode */
-        }
     });
 
     pi.on("before_agent_start", async () => {
-        dismiss();
+        externalDismiss?.();
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"