@astrofoundry/pi-astro 0.12.1 → 0.13.0

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

@@ -7,6 +7,7 @@ interface FakePi {
     handlers: Record<string, Handler>;
     commands: Map<string, { handler: CommandHandler; getArgumentCompletions?: (p: string) => unknown }>;
     getThinkingLevel: ReturnType<typeof vi.fn>;
+    getSessionName: ReturnType<typeof vi.fn>;
     on: (event: string, h: Handler) => void;
     registerCommand: (
         name: string,
@@ -18,13 +19,14 @@ interface FakePi {
     ) => void;
 }
 
-function makePi(): FakePi {
+function makePi(sessionName?: string): FakePi {
     const handlers: Record<string, Handler> = {};
     const commands = new Map<string, { handler: CommandHandler; getArgumentCompletions?: (p: string) => unknown }>();
     return {
         handlers,
         commands,
         getThinkingLevel: vi.fn(() => "medium"),
+        getSessionName: vi.fn(() => sessionName),
         on: (event, h) => {
             handlers[event] = h;
         },
@@ -44,11 +46,12 @@ interface FakeCtx {
     };
     cwd: string;
     model: { id: string } | undefined;
+    modelRegistry: { isUsingOAuth: ReturnType<typeof vi.fn> };
     sessionManager: { getBranch: () => unknown[] };
     getContextUsage: () => { tokens: number | null; contextWindow: number; percent: number | null } | undefined;
 }
 
-function makeCtx(overrides: Partial<FakeCtx> = {}): FakeCtx {
+function makeCtx(overrides: Partial<FakeCtx> = {}, oauth = false): FakeCtx {
     return {
         ui: {
             notify: vi.fn(),
@@ -56,18 +59,29 @@ function makeCtx(overrides: Partial<FakeCtx> = {}): FakeCtx {
         },
         cwd: "/Users/astro/proj",
         model: { id: "anthropic/claude-sonnet-4-6" },
+        modelRegistry: { isUsingOAuth: vi.fn(() => oauth) },
         sessionManager: { getBranch: () => [] },
         getContextUsage: () => undefined,
         ...overrides,
     };
 }
 
+const fakeTheme = { fg: (_role: string, text: string) => text };
+
+const fakeFooterDataDefault = {
+    getGitBranch: () => "main",
+    getExtensionStatuses: () => new Map<string, string>(),
+    getAvailableProviderCount: () => 1,
+    onBranchChange: () => () => {},
+};
+
 describe("astro-footer extension", () => {
     const origEnv = { ...process.env };
 
     beforeEach(() => {
         vi.resetModules();
         delete process.env.ASTRO_FOOTER_NERD_FONTS;
+        delete process.env.ASTRO_FOOTER_PATH;
         delete process.env.TERM_PROGRAM;
         delete process.env.TERM;
         delete process.env.LC_TERMINAL;
@@ -86,17 +100,29 @@ describe("astro-footer extension", () => {
         return await import("./index.ts");
     }
 
-    async function install(): Promise<{ pi: FakePi; mod: Awaited<ReturnType<typeof load>> }> {
+    async function install(sessionName?: string): Promise<{ pi: FakePi; mod: Awaited<ReturnType<typeof load>> }> {
         const mod = await load();
-        const pi = makePi();
+        const pi = makePi(sessionName);
         mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
         return { pi, mod };
     }
 
-    it("registers /footer command and session_start handler", async () => {
+    function getFactory(ctx: FakeCtx): (tui: unknown, theme: unknown, footerData: unknown) => {
+        render: (w: number) => string[];
+        dispose?: () => void;
+    } {
+        return ctx.ui.setFooter.mock.calls[0][0] as (
+            tui: unknown,
+            theme: unknown,
+            footerData: unknown,
+        ) => { render: (w: number) => string[]; dispose?: () => void };
+    }
+
+    it("registers /footer command and lifecycle handlers", async () => {
         const { pi } = await install();
         expect(pi.commands.has("footer")).toBe(true);
         expect(pi.handlers.session_start).toBeDefined();
+        expect(pi.handlers.tool_result).toBeDefined();
     });
 
     it("session_start activates the footer via ctx.ui.setFooter", async () => {
@@ -150,7 +176,7 @@ describe("astro-footer extension", () => {
         );
     });
 
-    it("renders a single-line footer with model, path, git, and extension statuses", async () => {
+    it("renders row 1 with model/path/git, tokens split, cost, ctx — and row 2 with statuses", async () => {
         process.env.ASTRO_FOOTER_NERD_FONTS = "0";
         const { pi } = await install();
         const ctx = makeCtx({
@@ -160,7 +186,13 @@ describe("astro-footer extension", () => {
                         type: "message",
                         message: {
                             role: "assistant",
-                            usage: { input: 1000, output: 200, cost: { total: 0.05 } },
+                            usage: {
+                                input: 1234,
+                                output: 567,
+                                cacheRead: 0,
+                                cacheWrite: 0,
+                                cost: { total: 0.05 },
+                            },
                         },
                     },
                 ],
@@ -168,55 +200,144 @@ describe("astro-footer extension", () => {
             getContextUsage: () => ({ tokens: 50, contextWindow: 200_000, percent: 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 factory = getFactory(ctx);
         const fakeFooterData = {
-            getGitBranch: () => "main",
+            ...fakeFooterDataDefault,
             getExtensionStatuses: () => new Map([["caveman", "🪨 caveman:full"]]),
-            getAvailableProviderCount: () => 1,
-            onBranchChange: () => () => {},
         };
-        const component = factory({}, fakeTheme, fakeFooterData);
+        const component = factory({ requestRender: () => {} }, fakeTheme, fakeFooterData);
         const lines = component.render(200);
-        expect(lines).toHaveLength(1);
-        const line = lines[0];
-        expect(line).toContain("Anthropic: 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.0%/200k");
-        expect(line).toContain("🪨 caveman:full");
-    });
-
-    it("renders without right side when there's nothing to show", async () => {
+        expect(lines.length).toBeGreaterThanOrEqual(1);
+        const row1 = lines[0];
+        expect(row1).toContain("Anthropic: Claude Sonnet 4 6");
+        expect(row1).toContain("proj");
+        expect(row1).toContain("main");
+        expect(row1).toContain("↑");
+        expect(row1).toContain("1.2k");
+        expect(row1).toContain("↓");
+        expect(row1).toContain("567");
+        expect(row1).toContain("$0.05");
+        expect(row1).toContain("25.0%/200k");
+        expect(lines.length).toBe(2);
+        expect(lines[1]).toContain("🪨 caveman:full");
+        component.dispose?.();
+    });
+
+    it("OAuth-authed model shows (sub) instead of dollar cost", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install();
+        const ctx = makeCtx(
+            {
+                sessionManager: {
+                    getBranch: () => [
+                        {
+                            type: "message",
+                            message: {
+                                role: "assistant",
+                                usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } },
+                            },
+                        },
+                    ],
+                },
+            },
+            true,
+        );
+        await pi.handlers.session_start({}, ctx);
+        const component = getFactory(ctx)({ requestRender: () => {} }, fakeTheme, fakeFooterDataDefault);
+        const row1 = component.render(200)[0];
+        expect(row1).toContain("(sub)");
+        component.dispose?.();
+    });
+
+    it("renders single line when row 2 is empty", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        const component = getFactory(ctx)({ requestRender: () => {} }, fakeTheme, fakeFooterDataDefault);
+        const lines = component.render(200);
+        expect(lines.length).toBe(1);
+        component.dispose?.();
+    });
+
+    it("subagent count from extension status appears on row 2 and is excluded from generic statuses", 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: () => () => {},
+            ...fakeFooterDataDefault,
+            getExtensionStatuses: () =>
+                new Map([
+                    ["subagents", "2"],
+                    ["caveman", "🪨 caveman:full"],
+                ]),
         };
-        const component = factory({}, fakeTheme, fakeFooterData);
-        const lines = component.render(80);
-        expect(lines).toHaveLength(1);
-        expect(lines[0]).not.toContain("$");
-        expect(lines[0]).toContain("proj");
+        const component = getFactory(ctx)({ requestRender: () => {} }, fakeTheme, fakeFooterData);
+        const lines = component.render(200);
+        expect(lines.length).toBe(2);
+        const row2 = lines[1];
+        expect(row2).toContain("2");
+        expect(row2).toContain("🪨 caveman:full");
+        expect(row2).not.toMatch(/\bsubagents\s*:\s*2\b/);
+        component.dispose?.();
+    });
+
+    it("session name shows on row 2 when set", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install("before-rewrite");
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        const component = getFactory(ctx)({ requestRender: () => {} }, fakeTheme, fakeFooterDataDefault);
+        const lines = component.render(200);
+        expect(lines.length).toBe(2);
+        expect(lines[1]).toContain("before-rewrite");
+        component.dispose?.();
+    });
+
+    it("cache read/write totals show on row 2 when present", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install();
+        const ctx = makeCtx({
+            sessionManager: {
+                getBranch: () => [
+                    {
+                        type: "message",
+                        message: {
+                            role: "assistant",
+                            usage: {
+                                input: 100,
+                                output: 50,
+                                cacheRead: 8500,
+                                cacheWrite: 2100,
+                                cost: { total: 0.01 },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        await pi.handlers.session_start({}, ctx);
+        const component = getFactory(ctx)({ requestRender: () => {} }, fakeTheme, fakeFooterDataDefault);
+        const lines = component.render(200);
+        expect(lines.length).toBe(2);
+        const row2 = lines[1];
+        expect(row2).toContain("cR");
+        expect(row2).toContain("8.5k");
+        expect(row2).toContain("cW");
+        expect(row2).toContain("2.1k");
+        component.dispose?.();
+    });
+
+    it("ASTRO_FOOTER_PATH=full shows the full home-tilded path", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        process.env.ASTRO_FOOTER_PATH = "full";
+        const { pi } = await install();
+        const ctx = makeCtx({ cwd: `${process.env.HOME}/wb/github/astrofoundry/pi-astro` });
+        await pi.handlers.session_start({}, ctx);
+        const component = getFactory(ctx)({ requestRender: () => {} }, fakeTheme, fakeFooterDataDefault);
+        const row1 = component.render(200)[0];
+        expect(row1).toContain("~/wb/github/astrofoundry/pi-astro");
+        component.dispose?.();
     });
 });

package/extensions/astro-footer/index.ts

@@ -5,8 +5,12 @@ import type {
 } from "@mariozechner/pi-coding-agent";
 import type { AssistantMessage } from "@mariozechner/pi-ai";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { resolvePathMode, type PathMode } from "./format.ts";
+import { GitStatusTracker } from "./git-status.ts";
 import { detectNerdFonts, iconsFor, type IconSet } from "./icons.ts";
+import { isAutoCompactEnabled } from "./settings.ts";
 import {
+    renderCache,
     renderContext,
     renderCost,
     renderExtensionStatus,
@@ -14,19 +18,36 @@ import {
     renderModel,
     renderPath,
     renderPi,
+    renderSessionName,
+    renderSessionTime,
+    renderSubagents,
     renderThinking,
     renderTokens,
     type ThemeFn,
 } from "./segments.ts";
 
+const SUBAGENT_STATUS_KEY = "subagents";
+
 interface UsageTotals {
     input: number;
     output: number;
     cost: number;
+    cacheRead: number;
+    cacheWrite: number;
+    paidTurns: number;
+    totalTurns: number;
 }
 
 function collectUsage(ctx: ExtensionContext): UsageTotals {
-    const totals: UsageTotals = { input: 0, output: 0, cost: 0 };
+    const totals: UsageTotals = {
+        input: 0,
+        output: 0,
+        cost: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        paidTurns: 0,
+        totalTurns: 0,
+    };
     for (const entry of ctx.sessionManager.getBranch()) {
         if (entry.type !== "message") continue;
         if (entry.message.role !== "assistant") continue;
@@ -34,71 +55,160 @@ function collectUsage(ctx: ExtensionContext): UsageTotals {
         totals.input += msg.usage.input;
         totals.output += msg.usage.output;
         totals.cost += msg.usage.cost.total;
+        totals.cacheRead += msg.usage.cacheRead;
+        totals.cacheWrite += msg.usage.cacheWrite;
+        totals.totalTurns++;
+        if (msg.usage.cost.total > 0) totals.paidTurns++;
     }
     return totals;
 }
 
-function buildLine(
+function readSubagentCount(footerData: ReadonlyFooterDataProvider): number {
+    const value = footerData.getExtensionStatuses().get(SUBAGENT_STATUS_KEY);
+    if (!value) return 0;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function buildLines(
     theme: ThemeFn,
     icons: IconSet,
     ctx: ExtensionContext,
     pi: ExtensionAPI,
     footerData: ReadonlyFooterDataProvider,
+    gitTracker: GitStatusTracker,
+    pathMode: PathMode,
+    sessionStartedAt: number,
+    autoCompact: boolean,
     width: number,
-): string {
+): string[] {
     const usage = collectUsage(ctx);
-    const totalTokens = usage.input + usage.output;
     const contextUsage = ctx.getContextUsage();
     const thinkingLevel = pi.getThinkingLevel();
     const branch = footerData.getGitBranch();
+    const gitCounts = gitTracker.get();
     const statuses = footerData.getExtensionStatuses();
+    const subagentCount = readSubagentCount(footerData);
+    const sessionName = pi.getSessionName();
+    const usingSubscription =
+        ctx.model !== undefined && ctx.modelRegistry.isUsingOAuth(ctx.model) && usage.totalTurns > 0;
+
+    const sep = ` ${theme.fg("border", icons.separator)} `;
 
-    const left = [
+    const row1Left = [
         renderPi(theme, icons),
         renderModel(theme, icons, ctx.model?.id),
         renderThinking(theme, icons, thinkingLevel),
-        renderPath(theme, icons, ctx.cwd),
-        renderGit(theme, icons, branch),
+        renderPath(theme, icons, ctx.cwd, pathMode),
+        renderGit(theme, icons, branch, gitCounts),
     ].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: contextUsage.percent, contextWindow: contextUsage.contextWindow }
-        : null);
-    if (contextSegment) right.push(contextSegment);
-    for (const [, value] of statuses) {
-        if (value) right.push(renderExtensionStatus(theme, value));
-    }
+    const row1Right: string[] = [];
+    const tokenSegment = renderTokens(theme, icons, usage.input, usage.output);
+    if (tokenSegment) row1Right.push(tokenSegment);
+    const costSegment = renderCost(theme, icons, { costUsd: usage.cost, isSubscription: usingSubscription });
+    if (costSegment) row1Right.push(costSegment);
+    const contextSegment = renderContext(
+        theme,
+        icons,
+        contextUsage
+            ? {
+                  percent: contextUsage.percent,
+                  contextWindow: contextUsage.contextWindow,
+                  autoCompact,
+              }
+            : null,
+    );
+    if (contextSegment) row1Right.push(contextSegment);
 
-    const sep = ` ${theme.fg("border", icons.separator)} `;
-    const leftStr = left.join(sep);
-    const rightStr = right.join(sep);
+    const row2Items: string[] = [];
+    const subagentSegment = renderSubagents(theme, icons, subagentCount);
+    if (subagentSegment) row2Items.push(subagentSegment);
+    const elapsedMs = Math.max(0, Date.now() - sessionStartedAt);
+    const sessionTimeSegment = renderSessionTime(theme, icons, elapsedMs);
+    if (sessionTimeSegment) row2Items.push(sessionTimeSegment);
+    const sessionNameSegment = renderSessionName(theme, icons, sessionName);
+    if (sessionNameSegment) row2Items.push(sessionNameSegment);
+    const cacheSegment = renderCache(theme, icons, usage.cacheRead, usage.cacheWrite);
+    if (cacheSegment) row2Items.push(cacheSegment);
+    for (const [key, value] of statuses) {
+        if (!value || key === SUBAGENT_STATUS_KEY) continue;
+        row2Items.push(renderExtensionStatus(theme, value));
+    }
 
-    if (rightStr.length === 0) return truncateToWidth(leftStr, width);
+    const row1Left2 = row1Left.join(sep);
+    const row1Right2 = row1Right.join(sep);
+    let row1: string;
+    if (row1Right2.length === 0) {
+        row1 = truncateToWidth(row1Left2, width);
+    } else {
+        const padWidth = Math.max(1, width - visibleWidth(row1Left2) - visibleWidth(row1Right2));
+        row1 = truncateToWidth(row1Left2 + " ".repeat(padWidth) + row1Right2, width);
+    }
 
-    const padWidth = Math.max(1, width - visibleWidth(leftStr) - visibleWidth(rightStr));
-    return truncateToWidth(leftStr + " ".repeat(padWidth) + rightStr, width);
+    if (row2Items.length === 0) return [row1];
+    const row2 = truncateToWidth(row2Items.join(sep), width);
+    return [row1, row2];
 }
 
+const REFRESH_INTERVAL_MS = 30_000;
+
 export default function astroFooterExtension(pi: ExtensionAPI): void {
     const useNerd = detectNerdFonts();
     const icons = iconsFor(useNerd);
-
+    const pathMode = resolvePathMode();
     let enabled = true;
+    let sessionStartedAt = Date.now();
+    let autoCompact = true;
+    let activeRequestRender: (() => void) | null = null;
+    let timeTickHandle: ReturnType<typeof setInterval> | null = null;
+
+    const gitTracker = new GitStatusTracker(() => {
+        activeRequestRender?.();
+    });
+
+    function startTimeTicker(): void {
+        if (timeTickHandle !== null) return;
+        timeTickHandle = setInterval(() => {
+            activeRequestRender?.();
+        }, REFRESH_INTERVAL_MS);
+    }
+
+    function stopTimeTicker(): void {
+        if (timeTickHandle === null) return;
+        clearInterval(timeTickHandle);
+        timeTickHandle = null;
+    }
 
     function activate(ctx: ExtensionContext): void {
-        ctx.ui.setFooter((_tui, theme, footerData) => {
+        sessionStartedAt = Date.now();
+        autoCompact = isAutoCompactEnabled(ctx.cwd);
+        gitTracker.refresh(ctx.cwd, true);
+        ctx.ui.setFooter((tui, theme, footerData) => {
+            activeRequestRender = () => tui.requestRender();
+            startTimeTicker();
             const themeFn: ThemeFn = {
                 fg: (role, text) => theme.fg(role, text),
             };
             return {
                 invalidate() {},
+                dispose() {
+                    stopTimeTicker();
+                    activeRequestRender = null;
+                },
                 render(width: number): string[] {
-                    return [buildLine(themeFn, icons, ctx, pi, footerData, width)];
+                    return buildLines(
+                        themeFn,
+                        icons,
+                        ctx,
+                        pi,
+                        footerData,
+                        gitTracker,
+                        pathMode,
+                        sessionStartedAt,
+                        autoCompact,
+                        width,
+                    );
                 },
             };
         });
@@ -108,6 +218,13 @@ export default function astroFooterExtension(pi: ExtensionAPI): void {
         if (enabled) activate(ctx);
     });
 
+    pi.on("tool_result", async (event, ctx) => {
+        if (!enabled) return;
+        if (event.toolName === "edit" || event.toolName === "write" || event.toolName === "bash") {
+            gitTracker.refresh(ctx.cwd);
+        }
+    });
+
     pi.registerCommand("footer", {
         description: "Toggle astro-footer. Usage: /footer [on|off|status].",
         getArgumentCompletions: (prefix) => {
@@ -122,7 +239,9 @@ export default function astroFooterExtension(pi: ExtensionAPI): void {
             const sub = args.trim().toLowerCase() || "status";
             if (sub === "status") {
                 ctx.ui.notify(
-                    enabled ? `astro-footer: on (${useNerd ? "nerd" : "ascii"} icons)` : "astro-footer: off",
+                    enabled
+                        ? `astro-footer: on (${useNerd ? "nerd" : "ascii"} icons, path=${pathMode})`
+                        : "astro-footer: off",
                     "info",
                 );
                 return;
@@ -135,14 +254,12 @@ export default function astroFooterExtension(pi: ExtensionAPI): void {
             }
             if (sub === "off") {
                 enabled = false;
+                stopTimeTicker();
                 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",
-            );
+            ctx.ui.notify(`astro-footer: unknown subcommand "${sub}". Use on|off|status.`, "warning");
         },
     });
 }