@astrofoundry/pi-astro 0.14.1 → 0.14.3

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

@@ -6,6 +6,7 @@ const baseStats: WelcomeStats = {
     contextWindow: 1_000_000,
     extensionCount: 9,
     cavemanLevel: undefined,
+    pkgVersion: "0.14.2",
 };
 
 describe("composeWelcome", () => {
@@ -48,6 +49,16 @@ describe("composeWelcome", () => {
         expect(() => composeWelcome(40, 1, baseStats)).not.toThrow();
     });
 
+    it("renders the version subtitle when pkgVersion is provided", () => {
+        const lines = composeWelcome(120, 1, baseStats);
+        expect(lines.join("\n")).toContain("v0.14.2");
+    });
+
+    it("omits the version row when pkgVersion is undefined", () => {
+        const lines = composeWelcome(120, 1, { ...baseStats, pkgVersion: undefined });
+        expect(lines.join("\n")).not.toMatch(/v\d+\.\d+\.\d+/);
+    });
+
     it("produces deterministic output for the same seed", () => {
         const a = composeWelcome(120, 99, baseStats);
         const b = composeWelcome(120, 99, baseStats);

package/extensions/astro-welcome/compose.ts

@@ -9,6 +9,7 @@ export interface WelcomeStats {
     contextWindow: number | undefined;
     extensionCount: number;
     cavemanLevel: string | undefined;
+    pkgVersion: string | undefined;
 }
 
 const TITLE = "★ ASTRO PI ★";
@@ -69,10 +70,12 @@ class CompositeMask implements Mask {
 }
 
 export function composeWelcome(width: number, seed: number, stats: WelcomeStats): string[] {
-    const totalRows = ART_HEIGHT + 7;
+    const hasVersion = !!stats.pkgVersion;
+    const versionRow = 1;
+    const artStartRow = hasVersion ? 2 : 1;
+    const totalRows = artStartRow + ART_HEIGHT + 6;
     const safeWidth = Math.max(40, width);
     const artStartCol = Math.max(0, Math.floor((safeWidth - ART_WIDTH) / 2));
-    const artStartRow = 1;
 
     const mask = new CompositeMask(totalRows, safeWidth);
     mask.occupyArt(artStartRow, artStartCol, ART_HEIGHT, ART_WIDTH);
@@ -81,6 +84,13 @@ export function composeWelcome(width: number, seed: number, stats: WelcomeStats)
     const titlePlaced = centerInLine(titleLine, safeWidth);
     mask.occupy(0, titlePlaced.col, visibleWidth(titleLine));
 
+    let versionPlaced: { line: string; col: number } | null = null;
+    if (hasVersion) {
+        const versionLine = fg(PALETTE.hint, `v${stats.pkgVersion}`);
+        versionPlaced = centerInLine(versionLine, safeWidth);
+        mask.occupy(versionRow, versionPlaced.col, visibleWidth(versionLine));
+    }
+
     const taglineRaw = pickMessage(seed);
     const taglineLine = fg(PALETTE.tagline, taglineRaw);
     const taglineRow = artStartRow + ART_HEIGHT + 1;
@@ -106,6 +116,7 @@ export function composeWelcome(width: number, seed: number, stats: WelcomeStats)
         let line = stars[r] ?? " ".repeat(safeWidth);
 
         if (r === 0) line = overlay(line, titlePlaced.line, safeWidth);
+        if (versionPlaced && r === versionRow) line = overlay(line, versionPlaced.line, safeWidth);
         if (r === taglineRow) line = overlay(line, taglinePlaced.line, safeWidth);
         if (r === statsRow) line = overlay(line, statsPlaced.line, safeWidth);
         if (r === hintRow) line = overlay(line, hintPlaced.line, safeWidth);

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

@@ -23,35 +23,65 @@ interface FakeCtx {
     hasUI: boolean;
     cwd: string;
     model: { id: string; contextWindow: number } | undefined;
-    sessionManager: { getEntries: () => unknown[] };
+    sessionManager: { getEntries: () => unknown[]; getBranch: () => 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;
+        sessionManager: { getEntries: () => [], getBranch: () => [] },
+        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,116 @@ 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 (after a short delay)", 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).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(100);
+        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);
+        vi.advanceTimersByTime(100);
+        expect(ctx.ui.custom).not.toHaveBeenCalled();
+    });
+
+    it("does not show welcome a second time within the same process", async () => {
+        const { pi } = await install();
+        const ctx1 = makeCtx();
+        await pi.handlers.session_start({}, ctx1);
+        vi.advanceTimersByTime(100);
+        ctx1._factory!.component!.handleInput!("x");
+        await ctx1._factory!.settle;
+        const ctx2 = makeCtx();
+        await pi.handlers.session_start({}, ctx2);
+        vi.advanceTimersByTime(100);
+        expect(ctx2.ui.custom).not.toHaveBeenCalled();
     });
 
-    it("clears the header automatically after 6 seconds", async () => {
+    it("skips welcome when session already has assistant activity (e.g. /reload mid-session)", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx({
+            sessionManager: {
+                getBranch: () => [
+                    { type: "message", message: { role: "assistant" } },
+                ],
+                getEntries: () => [],
+            },
+        });
+        await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
+        expect(ctx.ui.custom).not.toHaveBeenCalled();
+    });
+
+    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);
+        vi.advanceTimersByTime(100);
+        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);
+        vi.advanceTimersByTime(100);
+        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 after mount)", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
-        await pi.handlers.session_start({ reason: "startup" }, ctx);
+        await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
+        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("before_agent_start fired during the 100ms mount-delay cancels the overlay entirely", 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);
+        await pi.handlers.before_agent_start({ prompt: "fast" }, ctx);
+        vi.advanceTimersByTime(200);
+        expect(ctx.ui.custom).not.toHaveBeenCalled();
+    });
+
+    it("dismiss is idempotent — second trigger does not throw", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
+        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);
+        vi.advanceTimersByTime(100);
+        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");
@@ -156,13 +227,12 @@ describe("astro-welcome extension", () => {
                 getEntries: () => [
                     { type: "custom", customType: "caveman-mode", data: { level: "ultra" } },
                 ],
+                getBranch: () => [],
             },
         });
-        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);
+        vi.advanceTimersByTime(100);
+        const lines = ctx._factory!.component!.render(120);
+        expect(lines.join("\n")).toContain("caveman: ultra");
     });
 });

package/extensions/astro-welcome/index.ts

@@ -1,11 +1,17 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { composeWelcome, type WelcomeStats } from "./compose.ts";
+import { ART_HEIGHT, ART_WIDTH } from "./art.ts";
+import { readPackageVersion } from "./version.ts";
 
 const DISMISS_AFTER_MS = 6_000;
+const MOUNT_DELAY_MS = 100;
+const OVERLAY_WIDTH = Math.max(ART_WIDTH + 30, 70);
+const OVERLAY_HEIGHT = ART_HEIGHT + 8;
 
 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 +20,106 @@ 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;
+function hasSessionActivity(ctx: ExtensionContext): boolean {
+    for (const entry of ctx.sessionManager.getBranch()) {
+        if (entry.type === "message" && entry.message.role === "assistant") return true;
+    }
+    return false;
 }
 
 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 shownThisProcess = false;
+    let externalDismiss: (() => void) | null = null;
+    let dismissedBeforeMount = false;
+    let pendingMount: ReturnType<typeof setTimeout> | null = null;
 
     pi.on("session_start", async (_event, ctx) => {
+        if (shownThisProcess) return;
         if (!ctx.hasUI) return;
-        dismissed = false;
-        activeCtx = ctx;
-        const seed = Date.now() & 0xffff_ffff;
+        if (hasSessionActivity(ctx)) return;
+        shownThisProcess = true;
 
+        const seed = Date.now() & 0xffff_ffff;
+        let pkgVersion: string | undefined;
+        try {
+            pkgVersion = readPackageVersion();
+        } catch {
+            pkgVersion = undefined;
+        }
         const stats: WelcomeStats = {
-            modelDisplay: modelDisplayShort(ctx.model?.id),
+            modelDisplay: ctx.model?.id,
             contextWindow: ctx.model?.contextWindow,
             extensionCount: pi.getAllTools().length,
             cavemanLevel: readCavemanLevel(ctx),
+            pkgVersion,
         };
 
-        ctx.ui.setHeader((_tui, _theme) => ({
-            invalidate() {},
-            render(width: number): string[] {
-                return composeWelcome(width, seed, stats);
-            },
-        }));
+        dismissedBeforeMount = false;
 
-        timer = setTimeout(dismiss, DISMISS_AFTER_MS);
-        try {
-            unsubscribeInput = ctx.ui.onTerminalInput(() => {
-                dismiss();
-                return undefined;
-            });
-        } catch {
-            /* terminal input listener not supported in this mode */
-        }
+        pendingMount = setTimeout(() => {
+            pendingMount = null;
+            if (dismissedBeforeMount) return;
+
+            let dismissed = false;
+            let timer: ReturnType<typeof setTimeout> | null = null;
+
+            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 */
+                });
+        }, MOUNT_DELAY_MS);
     });
 
     pi.on("before_agent_start", async () => {
-        dismiss();
+        if (pendingMount !== null) {
+            clearTimeout(pendingMount);
+            pendingMount = null;
+            dismissedBeforeMount = true;
+        }
+        externalDismiss?.();
     });
 }

package/extensions/astro-welcome/version.ts

@@ -0,0 +1,12 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const extensionDir = path.dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = path.resolve(extensionDir, "..", "..", "package.json");
+
+export function readPackageVersion(): string | undefined {
+    const raw = fs.readFileSync(packageJsonPath, "utf8");
+    const pkg = JSON.parse(raw) as { version?: unknown };
+    return typeof pkg.version === "string" ? pkg.version : undefined;
+}

package/package.json

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