@astrofoundry/pi-astro 0.18.5 → 0.18.6

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

@@ -193,7 +193,8 @@ describe("segments", () => {
         expect(out).toContain("2.1k");
     });
 
-    it("renderExtensionStatus uses muted colour", () => {
+    it("renderExtensionStatus uses muted colour, unless the status is already styled", () => {
         expect(renderExtensionStatus(fakeTheme, "🪨 caveman:full")).toBe("<muted>🪨 caveman:full</muted>");
+        expect(renderExtensionStatus(fakeTheme, "\u001b[36m⠋ astro.arcane 0:05\u001b[0m")).toBe("\u001b[36m⠋ astro.arcane 0:05\u001b[0m");
     });
 });

package/extensions/astro-footer/segments.ts

@@ -133,6 +133,7 @@ export function renderCache(
     return `${theme.fg("muted", icons.cacheRead)}${theme.fg("text", formatTokens(cacheRead))} ${theme.fg("muted", icons.cacheWrite)}${theme.fg("text", formatTokens(cacheWrite))}`;
 }
 
+/** Statuses that already carry ANSI styling (for example a coloured spinner) render as they are. */
 export function renderExtensionStatus(theme: ThemeFn, value: string): string {
-    return theme.fg("muted", value);
+    return value.includes("\u001b[") ? value : theme.fg("muted", value);
 }

package/extensions/astro-subagents/index.ts

@@ -3,10 +3,11 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
+import { type Static, Type } from "typebox";
 import { type AgentConfig, type AgentDirs, type AgentScope, BUNDLED_NAMESPACE, defaultDirs, discoverAgents, formatAgentList, resolveSkills } from "./agents.ts";
 import { childRemaining, currentDepth, type DispatchDefaults, finalOutput, isFailed, resultOutput, type RunResult, runAgent } from "./child.ts";
 import { renderCall, renderResult, type SubagentDetails } from "./render.ts";
+import { startTicker } from "./ticker.ts";
 
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
@@ -151,6 +152,23 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
             ],
             parameters: Params,
             async execute(_id, params, signal, onUpdate, ctx) {
+                const label = params.chain?.length ? `chain of ${params.chain.length}` : params.tasks?.length ? `${params.tasks.length} agents` : (params.agent ?? "subagent");
+                const stopTicker = startTicker(ctx, label);
+                try {
+                    return await runTool(params, signal, onUpdate, ctx);
+                } finally {
+                    stopTicker();
+                }
+            },
+            renderCall: (args, theme) => renderCall(args, theme),
+            renderResult: (result, { expanded }, theme) => renderResult(result as AgentToolResult<SubagentDetails>, expanded, theme),
+        });
+    }
+
+    type ToolParams = Static<typeof Params>;
+    type ToolResult = AgentToolResult<SubagentDetails> & { isError?: boolean };
+
+    async function runTool(params: ToolParams, signal: AbortSignal | undefined, onUpdate: ((r: ToolResult) => void) | undefined, ctx: ExtensionContext): Promise<ToolResult> {
                 const scope: AgentScope = params.agentScope ?? "user";
                 const discovery = listAgents(ctx.cwd, scope);
                 const agents = discovery.agents;
@@ -227,10 +245,6 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
                     return { content: [{ type: "text", text: `Agent ${result.stopReason ?? "failed"}: ${resultOutput(result)}` }], details: details("single", [result]), isError: true };
                 }
                 return { content: [{ type: "text", text: finalOutput(result.messages) || "(no output)" }], details: details("single", [result]) };
-            },
-            renderCall: (args, theme) => renderCall(args, theme),
-            renderResult: (result, { expanded }, theme) => renderResult(result as AgentToolResult<SubagentDetails>, expanded, theme),
-        });
     }
 
     pi.registerCommand("run", {
@@ -246,16 +260,15 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
                 return;
             }
             const agents = listAgents(ctx.cwd, "user").agents;
-            ctx.ui.notify(`running ${parsed.agent}...`, "info");
-            ctx.ui.setStatus("subagent", `${parsed.agent} running`);
+            const stopTicker = startTicker(ctx, parsed.agent);
             let result: RunResult;
             try {
                 result = await runOne(ctx, agents, parsed.agent, parsed.task, undefined, undefined, undefined, undefined);
             } finally {
-                ctx.ui.setStatus("subagent", undefined);
+                stopTicker();
             }
             const status = isFailed(result) ? "failed" : "done";
-            ctx.ui.notify(`${parsed.agent} ${status}`, isFailed(result) ? "warning" : "info");
+            if (isFailed(result)) ctx.ui.notify(`${parsed.agent} failed`, "warning");
             pi.sendMessage(
                 { customType: "astro-subagents", content: `Result from /run ${parsed.agent} (${status}). Task: ${parsed.task}\n\n${resultOutput(result)}`, display: true },
                 { deliverAs: "followUp", triggerTurn: true },

package/extensions/astro-subagents/ticker.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from "vitest";
+import { formatElapsed, startTicker, tickerText } from "./ticker.ts";
+
+describe("ticker", () => {
+    it("formats elapsed time as m:ss", () => {
+        expect(formatElapsed(0)).toBe("0:00");
+        expect(formatElapsed(59_999)).toBe("0:59");
+        expect(formatElapsed(61_000)).toBe("1:01");
+        expect(formatElapsed(3_600_000)).toBe("60:00");
+    });
+
+    it("cycles spinner frames", () => {
+        expect(tickerText("astro.arcane", 0, 1000)).toBe("⠋ astro.arcane 0:01");
+        expect(tickerText("astro.arcane", 10, 1000)).toBe("⠋ astro.arcane 0:01");
+        expect(tickerText("astro.arcane", 1, 65_000)).toBe("⠙ astro.arcane 1:05");
+    });
+
+    it("paints accent-coloured status until stopped and then clears it", () => {
+        vi.useFakeTimers();
+        const setStatus = vi.fn();
+        const fg = vi.fn((color: string, text: string) => `<${color}>${text}</${color}>`);
+        const ctx = { hasUI: true, ui: { setStatus, theme: { fg } } } as unknown as Parameters<typeof startTicker>[0];
+        let clock = 0;
+        const stop = startTicker(ctx, "astro.network", 100, () => clock);
+        expect(setStatus).toHaveBeenLastCalledWith("subagent", "<accent>⠋ astro.network 0:00</accent>");
+        clock = 1500;
+        vi.advanceTimersByTime(100);
+        expect(setStatus).toHaveBeenLastCalledWith("subagent", "<accent>⠙ astro.network 0:01</accent>");
+        stop();
+        expect(setStatus).toHaveBeenLastCalledWith("subagent", undefined);
+        vi.useRealTimers();
+    });
+
+    it("does nothing without a UI", () => {
+        const setStatus = vi.fn();
+        const stop = startTicker({ hasUI: false, ui: { setStatus } } as unknown as Parameters<typeof startTicker>[0], "x");
+        stop();
+        expect(setStatus).not.toHaveBeenCalled();
+    });
+});

package/extensions/astro-subagents/ticker.ts

@@ -0,0 +1,36 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const STATUS_KEY = "subagent";
+
+export function formatElapsed(ms: number): string {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const minutes = Math.floor(total / 60);
+    const seconds = total % 60;
+    return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
+export function tickerText(label: string, frameIndex: number, elapsedMs: number): string {
+    return `${FRAMES[frameIndex % FRAMES.length]} ${label} ${formatElapsed(elapsedMs)}`;
+}
+
+/**
+ * Animated footer status in the accent colour while a subagent runs.
+ * Returns a stop function that clears the status. A no-op without UI.
+ */
+export function startTicker(ctx: ExtensionContext, label: string, intervalMs = 250, now: () => number = Date.now): () => void {
+    if (!ctx.hasUI) return () => {};
+    const started = now();
+    let frame = 0;
+    const paint = () => {
+        const text = tickerText(label, frame++, now() - started);
+        ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme ? ctx.ui.theme.fg("accent", text) : text);
+    };
+    paint();
+    const timer = setInterval(paint, intervalMs);
+    timer.unref();
+    return () => {
+        clearInterval(timer);
+        ctx.ui.setStatus(STATUS_KEY, undefined);
+    };
+}

package/package.json

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