@astrofoundry/pi-astro 0.9.0 → 0.11.0

package/README.md

@@ -62,10 +62,11 @@ pi                # launch; confirm [Extensions] lists astro-agents, claude-glob
 - `multi-edit` — registers the enhanced `edit` tool
 - `gemini-image` — registers `gemini_image` tool (requires a Gemini API key; prompts and saves on first use)
 - `security-guard` — blocks/prompts destructive bash commands and sensitive file access; configure at `~/.pi/agent/security-guard.json` (example written on first run); `/security-guard status|reload|test`
-- `notify-on-stop` — runs a shell command when the agent finishes a turn (sound, voice, desktop notification). macOS default: plays the Glass system sound **and** speaks "Agent done" via `say` using the **`Samantha (Enhanced)`** voice. Linux default: `notify-send "pi" "Agent done"`. Override the voice with `PI_STOP_NOTIFY_VOICE=<voice-name>` (macOS only; e.g. `Alex`, `Karen`, `Daniel (Enhanced)`). Replace the full command with `PI_STOP_NOTIFY='afplay /System/Library/Sounds/Glass.aiff && say "Done"'`. Disable everything with `PI_STOP_NOTIFY_OFF=1`. `/notify status|test|off`.
+- `notify-on-stop` — runs a shell command when the agent finishes a turn (sound, voice, desktop notification). **Default: off.** Enable with `/notify on` (state persists in `~/.pi/agent/notify-on-stop.json`); disable with `/notify off`. macOS default command: plays the Glass system sound **and** speaks "Agent done" via `say` using the **`Samantha (Enhanced)`** voice. Linux default: `notify-send "pi" "Agent done"`. Override the voice with `PI_STOP_NOTIFY_VOICE=<voice-name>` (macOS only; e.g. `Alex`, `Karen`, `Daniel (Enhanced)`). Replace the full command with `PI_STOP_NOTIFY='afplay /System/Library/Sounds/Glass.aiff && say "Done"'`. Hard-kill (overrides `/notify on`) with `PI_STOP_NOTIFY_OFF=1`. Commands: `/notify [on|off|status|test]`. See [extensions/notify-on-stop/README.md](extensions/notify-on-stop/README.md) for full details.
   - **macOS voice install (required once for the default):** open **System Settings → Accessibility → Spoken Content → System Voice → Manage Voices…**, expand **English**, check **Samantha (Enhanced)**, click **Done** to download (~500 MB – 1 GB). Verify with `say -v "Samantha (Enhanced)" hi`. If the voice is missing, `say` errors silently and you'll only hear the Glass sound.
 - `vscode-image` — only active inside VS Code's integrated terminal (`TERM_PROGRAM=vscode`). Switches pi-tui's image output to the **Kitty graphics protocol** so images returned by tools like `gemini_image` render as real pixels instead of the `[Image: …]` text fallback. **Requires enabling `Terminal › Integrated: Enable Images` in VS Code settings** (off by default); restart the integrated terminal after flipping it. Disable with `PI_VSCODE_IMAGE_OFF=1`. `/vscode-image` prints current status.
 - `claude-globals` — auto-injects `~/.claude/CLAUDE.md` into every pi session's system prompt
+- `astro-footer` — single-line powerline-style footer: pi marker, model, thinking level, cwd basename, git branch, total tokens, cost, context %, plus any extension statuses (`ctx.ui.setStatus`). Auto-detects Nerd Fonts (iTerm/WezTerm/Kitty/Ghostty/Alacritty) with ASCII fallback. Override via `ASTRO_FOOTER_NERD_FONTS=0|1`. Toggle with `/footer [on|off|status]`. See [extensions/astro-footer/README.md](extensions/astro-footer/README.md).
 - `caveman` — `/caveman [lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra|off|status]` toggles a persistent compressed-output mode. No argument toggles between off and the default level (`full`). Active level is shown as a footer badge and survives `/reload`. The skill body at `skills/caveman/SKILL.md` is also available as a one-shot via `/skill:caveman`.
 
 **Bundled subagents** (callable via `astro_agent`):

package/extensions/astro-agents/index.ts

@@ -73,7 +73,7 @@ export default function astroAgentsExtension(pi: ExtensionAPI): void {
         description:
             "Delegate a task to a named subagent in an isolated pi subprocess. Agents are discovered from bundled (astro-agents/agents/), user-level (~/.pi/agent/agents/), and project-local (.pi/agents/) sources.",
         parameters: params,
-        async execute(_toolCallId, input, signal, _onUpdate, ctx) {
+        async execute(_toolCallId, input, signal, onUpdate, ctx) {
             const scope: AgentScope = input.scope ?? "user";
 
             const agents = discoverAgents({
@@ -102,12 +102,26 @@ export default function astroAgentsExtension(pi: ExtensionAPI): void {
 
             const skillPaths = agent.skills ? resolvePackageSkills(agent.skills, ctx) : [];
 
+            const detailsBase = {
+                agent: agent.name,
+                source: agent.source,
+                color: agent.color,
+            };
+
             const result = await runAgent({
                 agent,
                 task: input.task,
                 cwd: ctx.cwd,
                 skillPaths,
                 signal,
+                onUpdate: onUpdate
+                    ? (text) => {
+                          onUpdate({
+                              content: [{ type: "text", text }],
+                              details: detailsBase,
+                          });
+                      }
+                    : undefined,
             });
 
             if (result.exitCode !== 0) {
@@ -120,11 +134,7 @@ export default function astroAgentsExtension(pi: ExtensionAPI): void {
 
             return {
                 content: [{ type: "text", text }],
-                details: {
-                    agent: agent.name,
-                    source: agent.source,
-                    color: agent.color,
-                },
+                details: detailsBase,
             };
         },
     });

package/extensions/astro-agents/spawn.test.ts

@@ -198,6 +198,103 @@ describe("runAgent (spawn.ts)", () => {
         expect(res.stderr).toContain("spawn failed");
     });
 
+    it("streams onUpdate after each message_end and uses agent_end as final state", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+
+        const updates: string[] = [];
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+            onUpdate: (text) => updates.push(text),
+        });
+
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text: "first" }] },
+            }) + "\n",
+        );
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text: "second" }] },
+            }) + "\n",
+        );
+        fake.close(0);
+
+        const res = await promise;
+        expect(updates).toEqual(["first", "second"]);
+        expect(res.text).toBe("second");
+    });
+
+    it("does not emit duplicate onUpdate when message text is unchanged", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+
+        const updates: string[] = [];
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+            onUpdate: (text) => updates.push(text),
+        });
+
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text: "only-text" }] },
+            }) + "\n",
+        );
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "tool", content: [{ type: "text", text: "ignored-tool-result" }] },
+            }) + "\n",
+        );
+        fake.close(0);
+
+        await promise;
+        expect(updates).toEqual(["only-text"]);
+    });
+
+    it("falls back to agent_end messages when message_end events are absent", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+
+        const updates: string[] = [];
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+            onUpdate: (text) => updates.push(text),
+        });
+
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "agent_end",
+                messages: [{ role: "assistant", content: [{ type: "text", text: "final" }] }],
+            }) + "\n",
+        );
+        fake.close(0);
+
+        const res = await promise;
+        expect(res.text).toBe("final");
+        expect(updates).toEqual(["final"]);
+    });
+
     it("kills process on abort signal", async () => {
         const { spawn } = await import("node:child_process");
         const fake = makeFakeProc();

package/extensions/astro-agents/spawn.ts

@@ -19,6 +19,11 @@ interface AgentEndEvent {
     messages?: AssistantMessage[];
 }
 
+interface MessageEndEvent {
+    type: "message_end";
+    message?: AssistantMessage;
+}
+
 interface UnknownEvent {
     type?: string;
     [key: string]: unknown;
@@ -73,10 +78,11 @@ export interface RunAgentOptions {
     cwd: string;
     skillPaths?: string[];
     signal?: AbortSignal | undefined;
+    onUpdate?: (text: string) => void;
 }
 
 export async function runAgent(options: RunAgentOptions): Promise<SpawnResult> {
-    const { agent, task, cwd, skillPaths, signal } = options;
+    const { agent, task, cwd, skillPaths, signal, onUpdate } = options;
 
     const args = ["--mode", "json", "-p", "--no-session"];
     let tmpDir: string | null = null;
@@ -112,6 +118,15 @@ export async function runAgent(options: RunAgentOptions): Promise<SpawnResult> {
             let stdoutBuffer = "";
             let stderrBuffer = "";
             const collectedMessages: AssistantMessage[] = [];
+            let lastEmittedText = "";
+
+            const emitProgress = (): void => {
+                if (!onUpdate) return;
+                const text = extractTextFromMessages(collectedMessages);
+                if (!text || text === lastEmittedText) return;
+                lastEmittedText = text;
+                onUpdate(text);
+            };
 
             const handleLine = (line: string): void => {
                 if (!line.trim()) return;
@@ -121,9 +136,21 @@ export async function runAgent(options: RunAgentOptions): Promise<SpawnResult> {
                 } catch {
                     return;
                 }
+                if (event.type === "message_end") {
+                    const msg = (event as MessageEndEvent).message;
+                    if (msg) {
+                        collectedMessages.push(msg);
+                        emitProgress();
+                    }
+                    return;
+                }
                 if (event.type === "agent_end") {
                     const end = event as AgentEndEvent;
-                    if (end.messages) collectedMessages.push(...end.messages);
+                    if (end.messages && end.messages.length > collectedMessages.length) {
+                        collectedMessages.length = 0;
+                        collectedMessages.push(...end.messages);
+                        emitProgress();
+                    }
                 }
             };
 

package/extensions/astro-footer/README.md

@@ -0,0 +1,63 @@
+# astro-footer
+
+Single-line powerline-style footer for the [pi coding agent](https://github.com/badlogic/pi-mono). Replaces the built-in footer with a compact status line:
+
+```
+π › claude-sonnet-4-6 › think:med › pi-astro › main                    1.2k › $0.05 › 25% › 🪨 caveman:full
+```
+
+Ships as part of [`@astrofoundry/pi-astro`](../../README.md). No extra install. Auto-activates on every pi session.
+
+## What it shows
+
+**Left side:**
+
+| Segment | Value |
+|---|---|
+| `π` | Pi marker |
+| **model** | Last segment of the active model id (e.g. `claude-sonnet-4-6`) |
+| **thinking** | Current thinking level (`think:off` … `think:xhi`), colour-coded |
+| **path** | Current working directory's basename |
+| **git** | Current branch (hidden when not in a git repo) |
+
+**Right side:**
+
+| Segment | Value |
+|---|---|
+| **tokens** | Cumulative input + output tokens for the session (`1.2k`, `45M`) |
+| **cost** | Cumulative session cost (`$0.05`, `$1.23`) |
+| **context** | Context window usage as a percentage; **yellow ≥ 70%, red ≥ 90%** |
+| **extension statuses** | Anything any extension has published via `ctx.ui.setStatus(key, text)` (e.g. caveman's `🪨 caveman:full`) |
+
+Segments hide automatically when the data isn't available (no model, no git, zero cost, etc.).
+
+## Commands
+
+| Command | Effect |
+|---|---|
+| `/footer` or `/footer status` | Print current state |
+| `/footer on` | Enable (re-activate after `/footer off`) |
+| `/footer off` | Restore pi's built-in footer |
+
+Argument autocomplete is wired — type `/footer ` and tab-cycle.
+
+## Icons
+
+Auto-detects Nerd Fonts in iTerm, WezTerm, Kitty, Ghostty, Alacritty, and falls back to plain ASCII glyphs everywhere else.
+
+Override the auto-detection:
+
+```bash
+export ASTRO_FOOTER_NERD_FONTS=1   # force Nerd Font icons
+export ASTRO_FOOTER_NERD_FONTS=0   # force ASCII icons
+```
+
+Read at extension load — restart pi after changing.
+
+## Extension-status pass-through
+
+Any other extension that calls `ctx.ui.setStatus(key, text)` automatically appears on the right side, in muted colour. No config required.
+
+This is what surfaces caveman's mode badge, notify-on-stop's state, and any future extension's status without each rolling its own footer renderer.
+
+To remove an extension's status from the footer, the extension itself calls `ctx.ui.setStatus(key, undefined)`.

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

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { formatCost, formatPathBasename, formatPercent, formatTokens } from "./format.ts";
+
+describe("formatTokens", () => {
+    it("returns plain integer below 1000", () => {
+        expect(formatTokens(0)).toBe("0");
+        expect(formatTokens(999)).toBe("999");
+    });
+
+    it("formats thousands with one decimal under 10k", () => {
+        expect(formatTokens(1000)).toBe("1.0k");
+        expect(formatTokens(1234)).toBe("1.2k");
+        expect(formatTokens(9999)).toBe("10.0k");
+    });
+
+    it("formats thousands without decimals at and above 10k", () => {
+        expect(formatTokens(10_000)).toBe("10k");
+        expect(formatTokens(45_678)).toBe("46k");
+        expect(formatTokens(999_999)).toBe("1000k");
+    });
+
+    it("formats millions", () => {
+        expect(formatTokens(1_000_000)).toBe("1.0M");
+        expect(formatTokens(1_500_000)).toBe("1.5M");
+        expect(formatTokens(45_678_900)).toBe("46M");
+    });
+});
+
+describe("formatCost", () => {
+    it("returns $0 for zero", () => {
+        expect(formatCost(0)).toBe("$0");
+    });
+
+    it("uses 4 decimals below 1 cent", () => {
+        expect(formatCost(0.0001)).toBe("$0.0001");
+        expect(formatCost(0.0099)).toBe("$0.0099");
+    });
+
+    it("uses 3 decimals between 1 cent and 1 dollar", () => {
+        expect(formatCost(0.01)).toBe("$0.010");
+        expect(formatCost(0.123)).toBe("$0.123");
+        expect(formatCost(0.999)).toBe("$0.999");
+    });
+
+    it("uses 2 decimals at and above 1 dollar", () => {
+        expect(formatCost(1)).toBe("$1.00");
+        expect(formatCost(12.345)).toBe("$12.35");
+    });
+});
+
+describe("formatPercent", () => {
+    it("renders em-dash for null", () => {
+        expect(formatPercent(null)).toBe("—");
+    });
+
+    it("rounds to nearest integer percent", () => {
+        expect(formatPercent(0)).toBe("0%");
+        expect(formatPercent(0.4567)).toBe("46%");
+        expect(formatPercent(1)).toBe("100%");
+    });
+});
+
+describe("formatPathBasename", () => {
+    it("returns last segment for unix path", () => {
+        expect(formatPathBasename("/Users/astro/wb/github/astrofoundry/pi-astro")).toBe("pi-astro");
+    });
+
+    it("strips trailing slashes", () => {
+        expect(formatPathBasename("/foo/bar/")).toBe("bar");
+    });
+
+    it("handles root path", () => {
+        expect(formatPathBasename("/")).toBe("/");
+    });
+
+    it("handles relative path", () => {
+        expect(formatPathBasename("just-folder")).toBe("just-folder");
+    });
+
+    it("handles windows-style separators", () => {
+        expect(formatPathBasename("C:\\Users\\astro\\proj")).toBe("proj");
+    });
+});

package/extensions/astro-footer/format.ts

@@ -0,0 +1,23 @@
+export function formatTokens(n: number): string {
+    if (n < 1000) return `${n}`;
+    if (n < 1_000_000) return `${(n / 1000).toFixed(n < 10_000 ? 1 : 0)}k`;
+    return `${(n / 1_000_000).toFixed(n < 10_000_000 ? 1 : 0)}M`;
+}
+
+export function formatCost(usd: number): string {
+    if (usd === 0) return "$0";
+    if (usd < 0.01) return `$${usd.toFixed(4)}`;
+    if (usd < 1) return `$${usd.toFixed(3)}`;
+    return `$${usd.toFixed(2)}`;
+}
+
+export function formatPercent(percent: number | null): string {
+    if (percent === null) return "—";
+    return `${Math.round(percent * 100)}%`;
+}
+
+export function formatPathBasename(cwd: string): string {
+    const trimmed = cwd.replace(/[\\/]+$/, "");
+    const segments = trimmed.split(/[\\/]/);
+    return segments[segments.length - 1] || trimmed || "/";
+}

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

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { detectNerdFonts, iconsFor } from "./icons.ts";
+
+describe("detectNerdFonts", () => {
+    it("returns true when ASTRO_FOOTER_NERD_FONTS=1", () => {
+        expect(detectNerdFonts({ ASTRO_FOOTER_NERD_FONTS: "1" })).toBe(true);
+    });
+
+    it("returns false when ASTRO_FOOTER_NERD_FONTS=0 even on a nerd-friendly terminal", () => {
+        expect(detectNerdFonts({ ASTRO_FOOTER_NERD_FONTS: "0", TERM_PROGRAM: "iTerm.app" })).toBe(false);
+    });
+
+    it("detects iTerm via TERM_PROGRAM", () => {
+        expect(detectNerdFonts({ TERM_PROGRAM: "iTerm.app" })).toBe(true);
+    });
+
+    it("detects WezTerm via TERM_PROGRAM", () => {
+        expect(detectNerdFonts({ TERM_PROGRAM: "WezTerm" })).toBe(true);
+    });
+
+    it("detects ghostty via TERM_PROGRAM", () => {
+        expect(detectNerdFonts({ TERM_PROGRAM: "ghostty" })).toBe(true);
+    });
+
+    it("detects kitty via TERM", () => {
+        expect(detectNerdFonts({ TERM: "xterm-kitty" })).toBe(true);
+    });
+
+    it("detects iTerm2 via LC_TERMINAL", () => {
+        expect(detectNerdFonts({ LC_TERMINAL: "iTerm2" })).toBe(true);
+    });
+
+    it("returns false for an unknown terminal", () => {
+        expect(detectNerdFonts({ TERM: "xterm-256color", TERM_PROGRAM: "Apple_Terminal" })).toBe(false);
+    });
+
+    it("returns false when env is empty", () => {
+        expect(detectNerdFonts({})).toBe(false);
+    });
+});
+
+describe("iconsFor", () => {
+    it("returns nerd-font icons when true", () => {
+        const icons = iconsFor(true);
+        expect(icons.separator).toBe("");
+        expect(icons.git).toBe("");
+    });
+
+    it("returns ascii icons when false", () => {
+        const icons = iconsFor(false);
+        expect(icons.separator).toBe("›");
+        expect(icons.git).toBe("git");
+    });
+});

package/extensions/astro-footer/icons.ts

@@ -0,0 +1,54 @@
+export interface IconSet {
+    pi: string;
+    model: string;
+    thinking: string;
+    path: string;
+    git: string;
+    tokens: string;
+    cost: string;
+    context: string;
+    separator: string;
+}
+
+const NERD: IconSet = {
+    pi: "π",
+    model: "",
+    thinking: "",
+    path: "",
+    git: "",
+    tokens: "",
+    cost: "",
+    context: "",
+    separator: "",
+};
+
+const ASCII: IconSet = {
+    pi: "π",
+    model: "@",
+    thinking: "?",
+    path: "/",
+    git: "git",
+    tokens: "tok",
+    cost: "$",
+    context: "ctx",
+    separator: "›",
+};
+
+const NERD_TERM_PROGRAMS = new Set(["iTerm.app", "WezTerm", "ghostty"]);
+const NERD_TERMS = ["xterm-kitty", "alacritty", "wezterm"];
+
+export function detectNerdFonts(env: NodeJS.ProcessEnv = process.env): boolean {
+    const override = env.ASTRO_FOOTER_NERD_FONTS;
+    if (override === "1") return true;
+    if (override === "0") return false;
+    const program = env.TERM_PROGRAM ?? "";
+    if (NERD_TERM_PROGRAMS.has(program)) return true;
+    const term = env.TERM ?? "";
+    if (NERD_TERMS.some((t) => term === t || term.startsWith(`${t}-`))) return true;
+    if (env.LC_TERMINAL === "iTerm2") return true;
+    return false;
+}
+
+export function iconsFor(useNerd: boolean): IconSet {
+    return useNerd ? NERD : ASCII;
+}