@astrofoundry/pi-astro 0.9.0 → 0.11.0

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

@@ -0,0 +1,222 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+type Handler = (event: unknown, ctx: unknown) => void | Promise<void>;
+type CommandHandler = (args: string, ctx: unknown) => Promise<void> | void;
+
+interface FakePi {
+    handlers: Record<string, Handler>;
+    commands: Map<string, { handler: CommandHandler; getArgumentCompletions?: (p: string) => unknown }>;
+    getThinkingLevel: ReturnType<typeof vi.fn>;
+    on: (event: string, h: Handler) => void;
+    registerCommand: (
+        name: string,
+        opts: {
+            description?: string;
+            handler: CommandHandler;
+            getArgumentCompletions?: (p: string) => unknown;
+        },
+    ) => void;
+}
+
+function makePi(): FakePi {
+    const handlers: Record<string, Handler> = {};
+    const commands = new Map<string, { handler: CommandHandler; getArgumentCompletions?: (p: string) => unknown }>();
+    return {
+        handlers,
+        commands,
+        getThinkingLevel: vi.fn(() => "medium"),
+        on: (event, h) => {
+            handlers[event] = h;
+        },
+        registerCommand: (name, opts) => {
+            commands.set(name, {
+                handler: opts.handler,
+                getArgumentCompletions: opts.getArgumentCompletions,
+            });
+        },
+    };
+}
+
+interface FakeCtx {
+    ui: {
+        notify: ReturnType<typeof vi.fn>;
+        setFooter: ReturnType<typeof vi.fn>;
+    };
+    cwd: string;
+    model: { id: string } | undefined;
+    sessionManager: { getBranch: () => unknown[] };
+    getContextUsage: () => { tokens: number | null; contextWindow: number; percent: number | null } | undefined;
+}
+
+function makeCtx(overrides: Partial<FakeCtx> = {}): FakeCtx {
+    return {
+        ui: {
+            notify: vi.fn(),
+            setFooter: vi.fn(),
+        },
+        cwd: "/Users/astro/proj",
+        model: { id: "anthropic/claude-sonnet-4-6" },
+        sessionManager: { getBranch: () => [] },
+        getContextUsage: () => undefined,
+        ...overrides,
+    };
+}
+
+describe("astro-footer extension", () => {
+    const origEnv = { ...process.env };
+
+    beforeEach(() => {
+        vi.resetModules();
+        delete process.env.ASTRO_FOOTER_NERD_FONTS;
+        delete process.env.TERM_PROGRAM;
+        delete process.env.TERM;
+        delete process.env.LC_TERMINAL;
+    });
+
+    afterEach(() => {
+        for (const k of Object.keys(process.env)) {
+            if (!(k in origEnv)) delete process.env[k];
+        }
+        for (const [k, v] of Object.entries(origEnv)) {
+            process.env[k] = v;
+        }
+    });
+
+    async function load(): Promise<typeof import("./index.ts")> {
+        return await import("./index.ts");
+    }
+
+    async function install(): Promise<{ pi: FakePi; mod: Awaited<ReturnType<typeof load>> }> {
+        const mod = await load();
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        return { pi, mod };
+    }
+
+    it("registers /footer command and session_start handler", async () => {
+        const { pi } = await install();
+        expect(pi.commands.has("footer")).toBe(true);
+        expect(pi.handlers.session_start).toBeDefined();
+    });
+
+    it("session_start activates the footer via ctx.ui.setFooter", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        expect(ctx.ui.setFooter).toHaveBeenCalledTimes(1);
+    });
+
+    it("/footer status reports current state", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("status", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/astro-footer: on/), "info");
+    });
+
+    it("/footer off restores the default footer", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("off", ctx);
+        expect(ctx.ui.setFooter).toHaveBeenCalledWith(undefined);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/off/), "info");
+    });
+
+    it("/footer on re-activates after being off", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("off", ctx);
+        await pi.commands.get("footer")!.handler("on", ctx);
+        const setFooterCalls = ctx.ui.setFooter.mock.calls;
+        expect(setFooterCalls[0][0]).toBeUndefined();
+        expect(typeof setFooterCalls[1][0]).toBe("function");
+    });
+
+    it("/footer with unknown subcommand warns", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("nonsense", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/unknown subcommand/), "warning");
+    });
+
+    it("argument autocomplete returns on/off/status", async () => {
+        const { pi } = await install();
+        const completions = pi.commands.get("footer")!.getArgumentCompletions!("");
+        expect(completions).toEqual(
+            expect.arrayContaining([
+                { value: "on", label: "on" },
+                { value: "off", label: "off" },
+                { value: "status", label: "status" },
+            ]),
+        );
+    });
+
+    it("renders a single-line footer with model, path, git, and extension statuses", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install();
+        const ctx = makeCtx({
+            sessionManager: {
+                getBranch: () => [
+                    {
+                        type: "message",
+                        message: {
+                            role: "assistant",
+                            usage: { input: 1000, output: 200, cost: { total: 0.05 } },
+                        },
+                    },
+                ],
+            },
+            getContextUsage: () => ({ tokens: 50, contextWindow: 200_000, percent: 0.25 }),
+        });
+        await pi.handlers.session_start({}, ctx);
+        const factory = ctx.ui.setFooter.mock.calls[0][0] as (
+            tui: unknown,
+            theme: unknown,
+            footerData: unknown,
+        ) => { render: (w: number) => string[] };
+        const fakeTheme = {
+            fg: (_role: string, text: string) => text,
+            bold: (text: string) => text,
+        };
+        const fakeFooterData = {
+            getGitBranch: () => "main",
+            getExtensionStatuses: () => new Map([["caveman", "🪨 caveman:full"]]),
+            getAvailableProviderCount: () => 1,
+            onBranchChange: () => () => {},
+        };
+        const component = factory({}, fakeTheme, fakeFooterData);
+        const lines = component.render(120);
+        expect(lines).toHaveLength(1);
+        const line = lines[0];
+        expect(line).toContain("claude-sonnet-4-6");
+        expect(line).toContain("proj");
+        expect(line).toContain("main");
+        expect(line).toContain("1.2k");
+        expect(line).toContain("$0.05");
+        expect(line).toContain("25%");
+        expect(line).toContain("🪨 caveman:full");
+    });
+
+    it("renders without right side when there's nothing to show", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        const factory = ctx.ui.setFooter.mock.calls[0][0] as (
+            tui: unknown,
+            theme: unknown,
+            footerData: unknown,
+        ) => { render: (w: number) => string[] };
+        const fakeTheme = { fg: (_role: string, text: string) => text };
+        const fakeFooterData = {
+            getGitBranch: () => null,
+            getExtensionStatuses: () => new Map(),
+            getAvailableProviderCount: () => 1,
+            onBranchChange: () => () => {},
+        };
+        const component = factory({}, fakeTheme, fakeFooterData);
+        const lines = component.render(80);
+        expect(lines).toHaveLength(1);
+        expect(lines[0]).not.toContain("$");
+        expect(lines[0]).toContain("proj");
+    });
+});

package/extensions/astro-footer/index.ts

@@ -0,0 +1,146 @@
+import type {
+    ExtensionAPI,
+    ExtensionContext,
+    ReadonlyFooterDataProvider,
+} from "@mariozechner/pi-coding-agent";
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { detectNerdFonts, iconsFor, type IconSet } from "./icons.ts";
+import {
+    renderContext,
+    renderCost,
+    renderExtensionStatus,
+    renderGit,
+    renderModel,
+    renderPath,
+    renderPi,
+    renderThinking,
+    renderTokens,
+    type ThemeFn,
+} from "./segments.ts";
+
+interface UsageTotals {
+    input: number;
+    output: number;
+    cost: number;
+}
+
+function collectUsage(ctx: ExtensionContext): UsageTotals {
+    const totals: UsageTotals = { input: 0, output: 0, cost: 0 };
+    for (const entry of ctx.sessionManager.getBranch()) {
+        if (entry.type !== "message") continue;
+        if (entry.message.role !== "assistant") continue;
+        const msg = entry.message as AssistantMessage;
+        totals.input += msg.usage.input;
+        totals.output += msg.usage.output;
+        totals.cost += msg.usage.cost.total;
+    }
+    return totals;
+}
+
+function buildLine(
+    theme: ThemeFn,
+    icons: IconSet,
+    ctx: ExtensionContext,
+    pi: ExtensionAPI,
+    footerData: ReadonlyFooterDataProvider,
+    width: number,
+): string {
+    const usage = collectUsage(ctx);
+    const totalTokens = usage.input + usage.output;
+    const contextUsage = ctx.getContextUsage();
+    const thinkingLevel = pi.getThinkingLevel();
+    const branch = footerData.getGitBranch();
+    const statuses = footerData.getExtensionStatuses();
+
+    const left = [
+        renderPi(theme, icons),
+        renderModel(theme, icons, ctx.model?.id),
+        renderThinking(theme, icons, thinkingLevel),
+        renderPath(theme, icons, ctx.cwd),
+        renderGit(theme, icons, branch),
+    ].filter((s): s is string => Boolean(s));
+
+    const right: string[] = [];
+    const tokenSegment = renderTokens(theme, icons, totalTokens);
+    if (tokenSegment) right.push(tokenSegment);
+    const costSegment = renderCost(theme, icons, usage.cost);
+    if (costSegment) right.push(costSegment);
+    const contextSegment = renderContext(theme, icons, contextUsage?.percent ?? null);
+    if (contextSegment) right.push(contextSegment);
+    for (const [, value] of statuses) {
+        if (value) right.push(renderExtensionStatus(theme, value));
+    }
+
+    const sep = ` ${theme.fg("border", icons.separator)} `;
+    const leftStr = left.join(sep);
+    const rightStr = right.join(sep);
+
+    if (rightStr.length === 0) return truncateToWidth(leftStr, width);
+
+    const padWidth = Math.max(1, width - visibleWidth(leftStr) - visibleWidth(rightStr));
+    return truncateToWidth(leftStr + " ".repeat(padWidth) + rightStr, width);
+}
+
+export default function astroFooterExtension(pi: ExtensionAPI): void {
+    const useNerd = detectNerdFonts();
+    const icons = iconsFor(useNerd);
+
+    let enabled = true;
+
+    function activate(ctx: ExtensionContext): void {
+        ctx.ui.setFooter((_tui, theme, footerData) => {
+            const themeFn: ThemeFn = {
+                fg: (role, text) => theme.fg(role, text),
+            };
+            return {
+                invalidate() {},
+                render(width: number): string[] {
+                    return [buildLine(themeFn, icons, ctx, pi, footerData, width)];
+                },
+            };
+        });
+    }
+
+    pi.on("session_start", async (_event, ctx) => {
+        if (enabled) activate(ctx);
+    });
+
+    pi.registerCommand("footer", {
+        description: "Toggle astro-footer. Usage: /footer [on|off|status].",
+        getArgumentCompletions: (prefix) => {
+            const items = ["on", "off", "status"];
+            const lower = prefix.toLowerCase();
+            const matches = items
+                .filter((value) => value.startsWith(lower))
+                .map((value) => ({ value, label: value }));
+            return matches.length > 0 ? matches : null;
+        },
+        handler: async (args, ctx) => {
+            const sub = args.trim().toLowerCase() || "status";
+            if (sub === "status") {
+                ctx.ui.notify(
+                    enabled ? `astro-footer: on (${useNerd ? "nerd" : "ascii"} icons)` : "astro-footer: off",
+                    "info",
+                );
+                return;
+            }
+            if (sub === "on") {
+                enabled = true;
+                activate(ctx);
+                ctx.ui.notify("astro-footer: on", "info");
+                return;
+            }
+            if (sub === "off") {
+                enabled = false;
+                ctx.ui.setFooter(undefined);
+                ctx.ui.notify("astro-footer: off (default footer restored)", "info");
+                return;
+            }
+            ctx.ui.notify(
+                `astro-footer: unknown subcommand "${sub}". Use on|off|status.`,
+                "warning",
+            );
+        },
+    });
+}

package/extensions/astro-footer/segments.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { iconsFor } from "./icons.ts";
+import {
+    renderContext,
+    renderCost,
+    renderExtensionStatus,
+    renderGit,
+    renderModel,
+    renderPath,
+    renderPi,
+    renderThinking,
+    renderTokens,
+    type ThemeFn,
+} from "./segments.ts";
+
+const fakeTheme: ThemeFn = {
+    fg: (role, text) => `<${role}>${text}</${role}>`,
+};
+
+const ICONS = iconsFor(false);
+
+describe("segments", () => {
+    it("renderPi shows pi icon with accent color", () => {
+        expect(renderPi(fakeTheme, ICONS)).toBe("<accent>π</accent>");
+    });
+
+    it("renderModel returns null when no model", () => {
+        expect(renderModel(fakeTheme, ICONS, undefined)).toBeNull();
+    });
+
+    it("renderModel uses the last segment of a slash-separated id", () => {
+        const out = renderModel(fakeTheme, ICONS, "anthropic/claude-sonnet-4-6");
+        expect(out).toContain("claude-sonnet-4-6");
+        expect(out).not.toContain("anthropic/");
+    });
+
+    it("renderThinking returns null when level missing", () => {
+        expect(renderThinking(fakeTheme, ICONS, undefined)).toBeNull();
+    });
+
+    it("renderThinking labels each level", () => {
+        expect(renderThinking(fakeTheme, ICONS, "off")).toContain("think:off");
+        expect(renderThinking(fakeTheme, ICONS, "minimal")).toContain("think:min");
+        expect(renderThinking(fakeTheme, ICONS, "low")).toContain("think:low");
+        expect(renderThinking(fakeTheme, ICONS, "medium")).toContain("think:med");
+        expect(renderThinking(fakeTheme, ICONS, "high")).toContain("think:high");
+        expect(renderThinking(fakeTheme, ICONS, "xhigh")).toContain("think:xhi");
+    });
+
+    it("renderThinking falls back gracefully on unknown level", () => {
+        const out = renderThinking(fakeTheme, ICONS, "weird");
+        expect(out).toContain("think:weird");
+    });
+
+    it("renderPath shows the basename of cwd", () => {
+        const out = renderPath(fakeTheme, ICONS, "/Users/astro/proj");
+        expect(out).toContain("proj");
+    });
+
+    it("renderGit returns null when no branch", () => {
+        expect(renderGit(fakeTheme, ICONS, null)).toBeNull();
+    });
+
+    it("renderGit shows branch name in success colour", () => {
+        const out = renderGit(fakeTheme, ICONS, "feat-foo");
+        expect(out).toContain("<success>feat-foo</success>");
+    });
+
+    it("renderTokens hides when total is zero", () => {
+        expect(renderTokens(fakeTheme, ICONS, 0)).toBeNull();
+    });
+
+    it("renderTokens formats large totals", () => {
+        expect(renderTokens(fakeTheme, ICONS, 1234)).toContain("1.2k");
+    });
+
+    it("renderCost hides when zero", () => {
+        expect(renderCost(fakeTheme, ICONS, 0)).toBeNull();
+    });
+
+    it("renderCost formats sub-dollar costs", () => {
+        expect(renderCost(fakeTheme, ICONS, 0.123)).toContain("$0.123");
+    });
+
+    it("renderContext hides when percent is null", () => {
+        expect(renderContext(fakeTheme, ICONS, null)).toBeNull();
+    });
+
+    it("renderContext uses dim colour below 70%", () => {
+        const out = renderContext(fakeTheme, ICONS, 0.5);
+        expect(out).toContain("<dim>");
+    });
+
+    it("renderContext uses warning colour at and above 70%", () => {
+        const out = renderContext(fakeTheme, ICONS, 0.7);
+        expect(out).toContain("<warning>");
+    });
+
+    it("renderContext uses error colour at and above 90%", () => {
+        const out = renderContext(fakeTheme, ICONS, 0.95);
+        expect(out).toContain("<error>");
+    });
+
+    it("renderExtensionStatus uses muted colour", () => {
+        expect(renderExtensionStatus(fakeTheme, "🪨 caveman:full")).toBe("<muted>🪨 caveman:full</muted>");
+    });
+});

package/extensions/astro-footer/segments.ts

@@ -0,0 +1,76 @@
+import type { ThemeColor } from "@mariozechner/pi-coding-agent";
+import type { IconSet } from "./icons.ts";
+import { formatCost, formatPathBasename, formatPercent, formatTokens } from "./format.ts";
+
+export interface ThemeFn {
+    fg: (role: ThemeColor, text: string) => string;
+}
+
+const THINKING_LABELS: Record<string, string> = {
+    off: "off",
+    minimal: "min",
+    low: "low",
+    medium: "med",
+    high: "high",
+    xhigh: "xhi",
+};
+
+const THINKING_COLORS: Record<string, ThemeColor> = {
+    off: "dim",
+    minimal: "muted",
+    low: "accent",
+    medium: "accent",
+    high: "warning",
+    xhigh: "error",
+};
+
+export function renderPi(theme: ThemeFn, icons: IconSet): string {
+    return theme.fg("accent", icons.pi);
+}
+
+export function renderModel(theme: ThemeFn, icons: IconSet, modelId: string | undefined): string | null {
+    if (!modelId) return null;
+    const short = modelId.split("/").pop() ?? modelId;
+    return `${theme.fg("muted", icons.model)} ${theme.fg("text", short)}`.trim();
+}
+
+export function renderThinking(theme: ThemeFn, icons: IconSet, level: string | undefined): string | null {
+    if (!level) return null;
+    const label = THINKING_LABELS[level] ?? level;
+    const color = THINKING_COLORS[level] ?? "dim";
+    return `${theme.fg(color, icons.thinking)} ${theme.fg(color, `think:${label}`)}`.trim();
+}
+
+export function renderPath(theme: ThemeFn, icons: IconSet, cwd: string): string {
+    const name = formatPathBasename(cwd);
+    return `${theme.fg("dim", icons.path)} ${theme.fg("accent", name)}`.trim();
+}
+
+export function renderGit(theme: ThemeFn, icons: IconSet, branch: string | null): string | null {
+    if (!branch) return null;
+    return `${theme.fg("success", icons.git)} ${theme.fg("success", branch)}`.trim();
+}
+
+export function renderTokens(theme: ThemeFn, icons: IconSet, totalTokens: number): string | null {
+    if (totalTokens === 0) return null;
+    return `${theme.fg("muted", icons.tokens)} ${theme.fg("text", formatTokens(totalTokens))}`.trim();
+}
+
+export function renderCost(theme: ThemeFn, icons: IconSet, costUsd: number): string | null {
+    if (costUsd === 0) return null;
+    return `${theme.fg("muted", icons.cost)} ${theme.fg("text", formatCost(costUsd))}`.trim();
+}
+
+export function renderContext(
+    theme: ThemeFn,
+    icons: IconSet,
+    percent: number | null,
+): string | null {
+    if (percent === null) return null;
+    const role: ThemeColor = percent >= 0.9 ? "error" : percent >= 0.7 ? "warning" : "dim";
+    return `${theme.fg(role, icons.context)} ${theme.fg(role, formatPercent(percent))}`.trim();
+}
+
+export function renderExtensionStatus(theme: ThemeFn, value: string): string {
+    return theme.fg("muted", value);
+}

package/extensions/gemini-image/index.ts

@@ -4,6 +4,7 @@ import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-age
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { GoogleGenAI } from "@google/genai";
 import { StringEnum } from "@mariozechner/pi-ai";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "typebox";
 import { persistApiKey, resolveExistingApiKey } from "./credentials.ts";
 import {
@@ -72,6 +73,13 @@ type Params = {
     skip_confirm?: boolean;
 };
 
+interface GeminiImageDetails {
+    model: ImageModel;
+    images: number;
+    savedPaths: string[];
+    actualCostUsd?: number;
+}
+
 async function ensureApiKey(ctx: ExtensionContext): Promise<string> {
     const existing = resolveExistingApiKey();
     if (existing) return existing;
@@ -410,15 +418,35 @@ export default function geminiImageExtension(pi: ExtensionAPI): void {
                 ...call.images.map((img) => ({ type: "image" as const, data: img.data, mimeType: img.mimeType })),
             ];
 
-            return {
-                content,
-                details: {
-                    model: finalModel,
-                    images: call.images.length,
-                    savedPaths,
-                    actualCostUsd: actual?.usd,
-                },
+            const details: GeminiImageDetails = {
+                model: finalModel,
+                images: call.images.length,
+                savedPaths,
+                actualCostUsd: actual?.usd,
             };
+
+            return { content, details };
+        },
+        renderResult(result, { expanded, isPartial }, theme, _context) {
+            if (isPartial) {
+                return new Text(theme.fg("warning", "Generating..."), 0, 0);
+            }
+            const details = result.details as GeminiImageDetails | undefined;
+            if (!details) {
+                return new Text(theme.fg("dim", "(no details)"), 0, 0);
+            }
+            const plural = details.images === 1 ? "image" : "images";
+            let text = theme.fg("toolTitle", theme.bold(details.model));
+            text += theme.fg("muted", ` · ${details.images} ${plural}`);
+            if (typeof details.actualCostUsd === "number") {
+                text += theme.fg("dim", ` · $${details.actualCostUsd.toFixed(4)}`);
+            }
+            if (expanded) {
+                for (const path of details.savedPaths) {
+                    text += "\n" + theme.fg("dim", `  ${path}`);
+                }
+            }
+            return new Text(text, 0, 0);
         },
     });
 }