@bismawy/pi-arnative 0.2.9 → 0.2.10

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.2.10] - 2026-10-01
+
+### Added
+- The working loader now shows elapsed turn time next to the label — `⠴ Working (50s)`, `⠴ Executing (1m 5s)`. One `setInterval(1s)` per turn (`extensions/footer.ts`), cleared on `turn_end`/`session_shutdown`; the suffix only appears from 1s (no `(0s)` flicker) and the timer keeps counting across tool switches inside a turn. With parallel tools the label follows the last started tool and only falls back to `Working` when every `toolCallId` has ended.
+
+### Fixed
+- Tool image previews (e.g. `read` on a PNG) no longer break the layout. pi renders a preview as an extra child below the tool box, padded with `result.rows - 1` blank rows, and the gap-stripping patch deleted exactly those rows — the terminal then painted the image over the rows underneath (chat text, editor, footer). Only the leading Spacer is dropped now; from the image sequence on, every line is kept.
+
 ## [0.2.9] - 2026-09-30
 
 ### Fixed

package/extensions/footer.ts

@@ -58,6 +58,23 @@ let assistantStartMs: number | null = null;
 let assistantChars = 0;
 let latestSpeed: number | null = null;
 
+// Live elapsed clock for the working loader: "⠴ Working (50s)".
+const WORK_TIMER_KEY = Symbol.for("pi-arnative.workTimer");
+const WORK_LABEL = "Working";
+let workVerb = WORK_LABEL;
+let workStartMs: number | null = null;
+let workUI: { setWorkingMessage?: (message?: string) => void } | null = null;
+// Verbs of tools still running (toolCallId -> verb): the label must not reset to
+// "Working" while a sibling tool is still going (pi executes tools in parallel).
+const activeToolVerbs = new Map<string, string>();
+
+/** Label while `active` tools remain: last started wins, empty -> default. */
+export function currentToolVerb(active: ReadonlyMap<string, string>): string {
+	let verb = WORK_LABEL;
+	for (const v of active.values()) verb = v;
+	return verb;
+}
+
 function run(cmd: string, args: string[], cwd: string): Promise<string> {
 	return new Promise((resolve) => {
 		execFile(cmd, args, { cwd, timeout: 2000 }, (err, stdout) => {
@@ -233,9 +250,48 @@ function mcpStatusOf(sub: string): string {
 	return "Executing";
 }
 
+/** Loader label with the elapsed suffix; no suffix below 1s (avoids a "(0s)" flicker). */
+export function workingLabel(verb: string, elapsedMs: number): string {
+	return elapsedMs >= 1000 ? `${verb} (${formatDuration(elapsedMs)})` : verb;
+}
+
+function paintWorking(): void {
+	if (!workUI || workStartMs === null) return;
+	try {
+		workUI.setWorkingMessage?.(workingLabel(workVerb, Date.now() - workStartMs));
+	} catch {
+		// ignore
+	}
+}
+
+function stopWorkingClock(): void {
+	const t = (globalThis as Record<symbol, any>)[WORK_TIMER_KEY];
+	if (t) clearInterval(t);
+	(globalThis as Record<symbol, any>)[WORK_TIMER_KEY] = null;
+	workStartMs = null;
+	activeToolVerbs.clear();
+}
+
+/** Start (or restart) the 1s tick from a fresh turn. */
+function startWorkingClock(ctx: { ui?: any }): void {
+	stopWorkingClock();
+	workUI = ctx.ui ?? null;
+	workVerb = WORK_LABEL;
+	workStartMs = Date.now();
+	(globalThis as Record<symbol, any>)[WORK_TIMER_KEY] = setInterval(paintWorking, 1000);
+}
+
+/** Swap the verb (tool change) without resetting the turn clock. */
+function setWorkingVerb(ctx: { ui?: any }, verb: string): void {
+	workUI = ctx.ui ?? null;
+	workVerb = verb;
+	if (workStartMs === null) workStartMs = Date.now();
+	paintWorking();
+}
+
 export function getToolWorkingMessage(toolName: string, args?: any): string {
 	const n = (toolName ?? "").trim();
-	if (!n) return "Working";
+	if (!n) return WORK_LABEL;
 
 	// Standard / file tools
 	if (n === "edit") return "Editing";
@@ -263,7 +319,7 @@ export function getToolWorkingMessage(toolName: string, args?: any): string {
 		return mcpStatusOf(sub);
 	}
 
-	return "Working";
+	return WORK_LABEL;
 }
 
 export default function (pi: ExtensionAPI) {
@@ -278,6 +334,9 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_start", async (event, ctx) => {
+		// A /reload re-imports this module while the old instance's interval (and its
+		// ctx.ui closures) may still be alive; clear it before starting a new one.
+		stopWorkingClock();
 		if (event.reason !== "reload") {
 			sessionStartMs = Date.now();
 			(globalThis as Record<symbol, number>)[SESSION_START_KEY] = sessionStartMs;
@@ -502,29 +561,19 @@ export default function (pi: ExtensionAPI) {
 		(globalThis as Record<symbol, any>)[MODEL_KEY] = currentModel;
 		(globalThis as Record<symbol, any>)[THINKING_KEY] = currentThinkingLevel;
 		(globalThis as Record<symbol, any>)[CWD_KEY] = ctx.cwd;
-		try {
-			ctx.ui?.setWorkingMessage?.();
-		} catch {
-			// ignore
-		}
+		startWorkingClock(ctx);
 		void refreshGit(ctx.cwd).then(() => poke());
 	});
 
 	pi.on("tool_execution_start", async (event, ctx) => {
-		try {
-			const msg = getToolWorkingMessage(event.toolName, event.args);
-			ctx.ui?.setWorkingMessage?.(msg);
-		} catch {
-			// ignore
-		}
+		const verb = getToolWorkingMessage(event.toolName, event.args);
+		activeToolVerbs.set(event.toolCallId, verb);
+		setWorkingVerb(ctx, verb);
 	});
 
-	pi.on("tool_execution_end", async (_event, ctx) => {
-		try {
-			ctx.ui?.setWorkingMessage?.();
-		} catch {
-			// ignore
-		}
+	pi.on("tool_execution_end", async (event, ctx) => {
+		activeToolVerbs.delete(event.toolCallId);
+		setWorkingVerb(ctx, currentToolVerb(activeToolVerbs));
 	});
 
 	pi.on("message_update", async (event) => {
@@ -566,6 +615,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("turn_end", async (_event, ctx) => {
+		stopWorkingClock();
 		try {
 			ctx.ui?.setWorkingMessage?.();
 		} catch {
@@ -587,6 +637,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
+		stopWorkingClock();
 		rerender = null;
 		const cur = ((globalThis as Record<symbol, number>)[GEN_KEY] ?? 0);
 		if (cur !== runtimeGen) return;
@@ -638,6 +689,19 @@ if (isMain(import.meta.url)) {
 	assert(getToolWorkingMessage("todo") === "Updating tasks", "todo -> Updating tasks");
 	assert(getToolWorkingMessage("unknown_tool") === "Working", "unknown -> Working");
 	assert(getToolWorkingMessage("mcp", { tool: "fetch_repo" }) === "Fetching", "mcp fetch -> Fetching");
+
+	// Self-check: working loader clock
+	assert(workingLabel("Working", 0) === "Working", "no elapsed suffix below 1s");
+	assert(workingLabel("Working", 999) === "Working", "no elapsed suffix at 999ms");
+	assert(workingLabel("Working", 50_000) === "Working (50s)", "elapsed seconds suffix");
+	assert(workingLabel("Executing", 65_000) === "Executing (1m 5s)", "elapsed minutes suffix");
+	assert(currentToolVerb(new Map()) === WORK_LABEL, "no active tool -> default label");
+	assert(currentToolVerb(new Map([["a", "Reading"], ["b", "Writing"]])) === "Writing", "parallel tools: last started wins");
+	assert(currentToolVerb(new Map([["a", "Reading"]])) === "Reading", "after one ends, the remaining tool's label shows");
+	startWorkingClock({ ui: { setWorkingMessage: () => {} } });
+	assert(Boolean((globalThis as Record<symbol, unknown>)[WORK_TIMER_KEY]), "clock starts: timer stored on globalThis");
+	stopWorkingClock();
+	assert((globalThis as Record<symbol, unknown>)[WORK_TIMER_KEY] == null, "clock stops: reload guard clears the timer");
 	assert(boxed.slice(0, 4).every((l) => visibleWidth(l) === visibleWidth(D) + 5), "uniform box width (sides + prompt)");
 	assert(boxEditorLines(["\u2500\u2500\u2500\u2500"], 1, plain).length === 1, "too narrow: left unchanged");
 

package/extensions/tools.ts

@@ -215,6 +215,23 @@ const OWN_BOX = new Set<string>();
 const hasOwnRendererDef = (self: { toolDefinition?: { renderCall?: unknown; renderResult?: unknown } }): boolean =>
 	Boolean(self?.toolDefinition?.renderCall || self?.toolDefinition?.renderResult);
 
+// Inline image line: kitty (\x1b_G) or iTerm2 (\x1b]1337;File=) graphics payload.
+// pi renders a tool's image preview as an extra child BELOW the box, padding it with
+// `result.rows - 1` blank rows; the last row carries a cursor-up prefix before the
+// sequence. Not exported by pi-tui, so match both prefixes.
+export const isImageLine = (line: string): boolean => line.includes("\x1b_G") || line.includes("\x1b]1337;File=");
+
+/** Drop the leading Spacer only when an image preview follows: its blank tail rows
+ *  are the image's vertical space, and deleting them made the terminal draw the
+ *  image over the rows below (chat text, editor, footer). */
+export function stripEdgesKeepingImages(lines: string[]): string[] {
+	const firstImage = lines.findIndex(isImageLine);
+	if (firstImage < 0) return stripBlankEdges(lines);
+	let s = 0;
+	while (s < firstImage && isBlankLine(lines[s])) s++;
+	return lines.slice(s);
+}
+
 const GAP_KEY = Symbol.for("pi-arnative.toolGapStripped");
 if (ToolExecutionComponent?.prototype?.render && !(globalThis as Record<symbol, boolean>)[GAP_KEY]) {
 	(globalThis as Record<symbol, boolean>)[GAP_KEY] = true;
@@ -222,7 +239,7 @@ if (ToolExecutionComponent?.prototype?.render && !(globalThis as Record<symbol,
 	ToolExecutionComponent.prototype.render = function (width: number): string[] {
 		const lines = origRender.call(this, width);
 		const name = (this as { toolName?: string }).toolName ?? "";
-		return OWN_BOX.has(name) || !hasOwnRendererDef(this) ? stripBlankEdges(lines) : lines;
+		return OWN_BOX.has(name) || !hasOwnRendererDef(this) ? stripEdgesKeepingImages(lines) : lines;
 	};
 }
 
@@ -682,6 +699,23 @@ if (isMain(import.meta.url)) {
 	assert(stripBlankEdges(["", "\x1b[2m\x1b[22m", "x"]).join() === "x", "blank ANSI line counts as blank");
 	assert(stripBlankEdges(["a"]).join() === "a", "no blanks: kept intact");
 
+	// Image preview: pi pads the image with blank rows (`result.rows - 1`), and the last
+	// one carries a cursor-up prefix before the sequence. Those rows are the image's
+	// vertical space — deleting them made the terminal paint the image over whatever
+	// sits below (chat text, editor, footer). Regression: preview destroyed the layout.
+	const kittySeq = "\x1b[5A\x1b_Ga=T,f=100,i=7,q=2,C=1,m=0;AAAA\x1b\\";
+	const itermSeq = "\x1b]1337;File=inline=1:AAAA\x07";
+	const withImage = ["", "╭─╮", "│ ✓ read form_crop.png │", "╰─╯", "", kittySeq, "", ""];
+	const kept = stripEdgesKeepingImages(withImage);
+	assert(kept.length === 7, "image: only the leading gap dropped, blank tail kept");
+	assert(kept[0] === "╭─╮", "image: leading Spacer removed");
+	assert(kept.indexOf(kittySeq) === 4 && kept.length - 5 === 2, "image: rows after the sequence intact");
+	assert(
+		stripEdgesKeepingImages(["", "a", "", "b", "  ", ""]).join() === "a,,b",
+		"no image: falls back to plain edge stripping",
+	);
+	assert(isImageLine(itermSeq) && !isImageLine("│ plain text │"), "image line detection: kitty + iTerm2 only");
+
 	// tools without their own renderer -> same box (memory_write etc.)
 	const noRenderer = { toolName: "memory_write", toolDefinition: {} };
 	// tool with no definition (e.g. "Tool glob not found") -> still a box, not plain text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bismawy/pi-arnative",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Arnative look for Pi: warm-neutral themes, rounded tool boxes, tabbed header, compact footer, transcript clock, and a /usage dashboard.",
   "keywords": [
     "pi-package",