@dungle-scrubs/tallow 0.8.26 → 0.8.28

package/extensions/upstream-check/__tests__/upstream-check.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import registerUpstream from "../index.js";
+
+describe("upstream-check extension", () => {
+	test("does not register command when packages/tallow-tui is absent", () => {
+		const tmpDir = mkdtempSync(join(tmpdir(), "upstream-test-"));
+		const originalCwd = process.cwd();
+		try {
+			process.chdir(tmpDir);
+			const commands: string[] = [];
+			const pi = {
+				registerCommand: (name: string) => {
+					commands.push(name);
+				},
+			} as unknown as ExtensionAPI;
+
+			registerUpstream(pi);
+			expect(commands).not.toContain("upstream");
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(tmpDir, { recursive: true, force: true });
+		}
+	});
+
+	test("registers upstream command when packages/tallow-tui exists", () => {
+		const tmpDir = mkdtempSync(join(tmpdir(), "upstream-test-"));
+		mkdirSync(join(tmpDir, "packages", "tallow-tui"), { recursive: true });
+		const originalCwd = process.cwd();
+		try {
+			process.chdir(tmpDir);
+			const commands: string[] = [];
+			const pi = {
+				registerCommand: (name: string) => {
+					commands.push(name);
+				},
+			} as unknown as ExtensionAPI;
+
+			registerUpstream(pi);
+			expect(commands).toContain("upstream");
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(tmpDir, { recursive: true, force: true });
+		}
+	});
+});

package/extensions/welcome-screen/__tests__/welcome-screen.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import welcomeScreen from "../index.js";
+
+describe("welcome-screen extension", () => {
+	test("registers session_start handler", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		welcomeScreen(pi);
+		expect(events).toContain("session_start");
+	});
+
+	test("does not register any commands or tools", () => {
+		const commands: string[] = [];
+		const tools: string[] = [];
+		const pi = {
+			on: () => {},
+			registerCommand: (name: string) => {
+				commands.push(name);
+			},
+			registerTool: (opts: { name: string }) => {
+				tools.push(opts.name);
+			},
+		} as unknown as ExtensionAPI;
+
+		welcomeScreen(pi);
+		expect(commands).toHaveLength(0);
+		expect(tools).toHaveLength(0);
+	});
+});

package/extensions/welcome-screen/extension.json

@@ -0,0 +1,20 @@
+{
+	"name": "welcome-screen",
+	"version": "0.1.0",
+	"description": "ASCII art welcome screen with version display and update notification",
+	"whenToUse": "Replaces the default startup header with a branded ASCII art welcome screen.",
+	"capabilities": {
+		"events": ["session_start"]
+	},
+	"permissionSurface": {
+		"filesystem": "none",
+		"shell": false,
+		"network": true,
+		"subprocess": false
+	},
+	"category": "ui",
+	"tags": ["welcome", "header", "startup", "branding"],
+	"files": ["index.ts"],
+	"relationships": [],
+	"npmDependencies": {}
+}

package/extensions/welcome-screen/index.ts

@@ -0,0 +1,189 @@
+/**
+ * Welcome Screen Extension
+ *
+ * Replaces the default pi framework startup header with a branded ASCII art
+ * welcome screen showing the tallow logo, version, and update availability.
+ *
+ * The ASCII art is the tallow "T_" mark — a blocky amber T with a cursor,
+ * evoking the retro CRT terminal aesthetic of the logo.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { TUI } from "@mariozechner/pi-tui";
+import { visibleWidth } from "@mariozechner/pi-tui";
+import { TALLOW_VERSION } from "../../runtime/config.js";
+
+/** Timeout for npm registry fetch (ms). */
+const FETCH_TIMEOUT = 4_000;
+
+/** Registry URL for the tallow package. */
+const REGISTRY_URL = "https://registry.npmjs.org/@dungle-scrubs/tallow/latest";
+
+// ─── ASCII Art ───────────────────────────────────────────────────────────────
+
+/**
+ * The tallow "T_" mark — a blocky T with a cursor block.
+ * Proportions mirror the logo: wide top bar, centered thick stem, cursor lower-right.
+ */
+const LOGO_LINES = [" ▐████████████▌ ", "      ████      ", "      ████  ▐█▌ "];
+
+// ─── Version Check ───────────────────────────────────────────────────────────
+
+/**
+ * Fetch the latest published version from the npm registry.
+ *
+ * @returns Latest version string, or null on failure
+ */
+async function fetchLatestVersion(): Promise<string | null> {
+	if (process.env.PI_SKIP_VERSION_CHECK === "1" || process.env.PI_OFFLINE) {
+		return null;
+	}
+	try {
+		const res = await fetch(REGISTRY_URL, {
+			signal: AbortSignal.timeout(FETCH_TIMEOUT),
+		});
+		if (!res.ok) return null;
+		const data = (await res.json()) as { version?: string };
+		return data.version ?? null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Compare two semver strings. Returns true if `latest` is newer than `current`.
+ *
+ * @param current - Currently installed version
+ * @param latest - Latest available version
+ * @returns True if latest is a newer version
+ */
+function isNewerVersion(current: string, latest: string): boolean {
+	const parse = (v: string): number[] => v.split(".").map(Number);
+	const c = parse(current);
+	const l = parse(latest);
+	for (let i = 0; i < 3; i++) {
+		if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+		if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+	}
+	return false;
+}
+
+// ─── Colors ──────────────────────────────────────────────────────────────────
+
+/** Amber/gold (matches the logo glow). */
+const AMBER = "\x1b[38;2;255;191;0m";
+/** Dim amber for version text. */
+const DIM_AMBER = "\x1b[38;2;180;130;30m";
+/** Green for update notification. */
+const GREEN = "\x1b[38;2;100;220;100m";
+/** Reset all styles. */
+const RESET = "\x1b[0m";
+
+// ─── Rendering ───────────────────────────────────────────────────────────────
+
+/**
+ * Center a styled string within a given terminal width.
+ *
+ * @param line - Styled line (may contain ANSI escapes)
+ * @param width - Terminal width
+ * @returns Left-padded line
+ */
+function centerLine(line: string, width: number): string {
+	const lineWidth = visibleWidth(line);
+	const left = Math.max(0, Math.floor((width - lineWidth) / 2));
+	return " ".repeat(left) + line;
+}
+
+/**
+ * Build the welcome screen lines.
+ *
+ * @param width - Terminal width for centering
+ * @param updateVersion - Newer version available, or null
+ * @returns Array of styled terminal lines
+ */
+function buildWelcomeLines(width: number, updateVersion: string | null): string[] {
+	const lines: string[] = [];
+
+	// Logo with amber coloring
+	for (const logoLine of LOGO_LINES) {
+		lines.push(centerLine(`${AMBER}${logoLine}${RESET}`, width));
+	}
+
+	// Version line — dim amber, centered below logo
+	lines.push(centerLine(`${DIM_AMBER}tallow v${TALLOW_VERSION}${RESET}`, width));
+
+	// Update notification
+	if (updateVersion) {
+		lines.push(centerLine(`${GREEN}update available: v${updateVersion}${RESET}`, width));
+	}
+
+	return lines;
+}
+
+// ─── Extension Entry ─────────────────────────────────────────────────────────
+
+/**
+ * Welcome screen extension.
+ * Replaces the default header with an ASCII art logo on session_start.
+ *
+ * @param pi - Extension API
+ */
+export default function welcomeScreenExtension(pi: ExtensionAPI): void {
+	pi.on("session_start", async (_event, ctx) => {
+		// Skip for resumed/continued sessions — only show on fresh instances.
+		// Filter to message entries only — metadata entries like model_change and
+		// thinking_level_change are injected during session setup and exist even
+		// on a brand-new session. The role lives on entry.message, not the entry itself.
+		const hasConversation = ctx.sessionManager.getEntries().some((e) => {
+			const msg = (e as unknown as Record<string, unknown>).message as
+				| { role?: string }
+				| undefined;
+			return msg?.role === "user" || msg?.role === "assistant";
+		});
+		if (hasConversation) return;
+
+		let updateVersion: string | null = null;
+		let tuiRef: TUI | null = null;
+
+		// Set the header immediately with current version (no update info yet)
+		ctx.ui.setHeader((tui, _theme) => {
+			tuiRef = tui;
+
+			return {
+				render(width: number): string[] {
+					return buildWelcomeLines(width, updateVersion);
+				},
+				invalidate(): void {
+					// No cached state to clear
+				},
+			};
+		});
+
+		// Clear the changelog "What's New" children from the header container.
+		// setHeader only replaces the builtInHeader text component — the changelog
+		// section (DynamicBorder, "What's New" heading, Markdown body) lives as
+		// separate children in headerContainer and persists unless removed.
+		// headerContainer is the first child of the root TUI component.
+		queueMicrotask(() => {
+			if (!tuiRef) return;
+			const tuiChildren = (tuiRef as unknown as Record<string, unknown>).children as
+				| Array<Record<string, unknown>>
+				| undefined;
+			// headerContainer is the first child of the TUI root
+			const headerContainer = tuiChildren?.[0]?.children as { length: number } | undefined;
+			if (headerContainer && headerContainer.length > 2) {
+				// Keep [0]=Spacer and [1]=custom header, drop the rest (bottom spacer + changelog)
+				headerContainer.length = 2;
+				tuiRef.requestRender();
+			}
+		});
+
+		// Fire-and-forget version check — re-renders header when resolved
+		fetchLatestVersion().then((latest) => {
+			if (latest && isNewerVersion(TALLOW_VERSION, latest)) {
+				updateVersion = latest;
+				tuiRef?.requestRender();
+			}
+		});
+	});
+}

package/extensions/wezterm-notify/__tests__/index.test.ts

@@ -157,13 +157,44 @@ describe("wezterm-notify lifecycle", () => {
 		const inputResult = rig.lifecycle.onInput();
 
 		expect(inputResult).toEqual({ action: "continue" });
-		expect(getStatusWrites(rig)).toEqual(["", "working", "done", ""]);
+		// agent_end is a no-op; input transitions working → done
+		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
 		expect(getHeartbeatWrites(rig)).toEqual(["0"]);
 		expect(rig.heartbeatStartCount).toBe(1);
 		expect(rig.heartbeatStopCount).toBe(1);
 		expect(rig.activeHeartbeatCount).toBe(0);
 	});
 
+	it("stays working through tool execution between agent_end and next agent_start", () => {
+		const rig = createLifecycleRig();
+
+		rig.lifecycle.onSessionStart();
+		rig.lifecycle.onBeforeAgentStart();
+		rig.lifecycle.onAgentStart();
+		// Model returns a tool call — agent_end fires but tool is still executing
+		rig.lifecycle.onAgentEnd();
+		rig.tickHeartbeat();
+		rig.tickHeartbeat();
+
+		// Status should still be "working" — heartbeat should still be active
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
+		expect(rig.activeHeartbeatCount).toBe(1);
+
+		// Tool finishes, next turn starts
+		rig.lifecycle.onBeforeAgentStart();
+		rig.lifecycle.onAgentStart();
+		rig.lifecycle.onAgentEnd();
+
+		// Still working — no flicker to "done" between turns
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
+		expect(rig.activeHeartbeatCount).toBe(1);
+
+		// Final input prompt appears
+		rig.lifecycle.onInput();
+		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
+		expect(rig.activeHeartbeatCount).toBe(0);
+	});
+
 	it("coalesces duplicate starts without clear flicker", () => {
 		const rig = createLifecycleRig();
 
@@ -173,26 +204,30 @@ describe("wezterm-notify lifecycle", () => {
 		rig.lifecycle.onAgentStart();
 		rig.tickHeartbeat();
 		rig.tickHeartbeat();
+		// agent_end is a no-op — heartbeat keeps running
 		rig.lifecycle.onAgentEnd();
 
-		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
 		expect(getHeartbeatWrites(rig)).toEqual(["0", "1", "2"]);
 		expect(rig.heartbeatStartCount).toBe(1);
-		expect(rig.heartbeatStopCount).toBe(1);
-		expect(rig.activeHeartbeatCount).toBe(0);
+		// Heartbeat still active (only input/shutdown stops it)
+		expect(rig.heartbeatStopCount).toBe(0);
+		expect(rig.activeHeartbeatCount).toBe(1);
 	});
 
 	it("does not permanently clear when input arrives before start", () => {
 		const rig = createLifecycleRig();
 
 		rig.lifecycle.onSessionStart();
+		// Input arrives while not working — no-op (already idle)
 		const inputResult = rig.lifecycle.onInput();
 		rig.lifecycle.onBeforeAgentStart();
 		rig.lifecycle.onAgentStart();
 		rig.lifecycle.onAgentEnd();
 
 		expect(inputResult).toEqual({ action: "continue" });
-		expect(getStatusWrites(rig)).toEqual(["", "working", "done"]);
+		// agent_end is a no-op, so status stays "working"
+		expect(getStatusWrites(rig)).toEqual(["", "working"]);
 	});
 
 	it("starts heartbeat once per interval and leaves no orphan timers", () => {
@@ -205,18 +240,21 @@ describe("wezterm-notify lifecycle", () => {
 		expect(rig.heartbeatStartCount).toBe(1);
 		expect(rig.activeHeartbeatCount).toBe(1);
 
+		// agent_end no longer stops heartbeat — stays active through tool execution
 		rig.lifecycle.onAgentEnd();
+		expect(rig.heartbeatStopCount).toBe(0);
+		expect(rig.activeHeartbeatCount).toBe(1);
+
+		// input stops the heartbeat
+		rig.lifecycle.onInput();
 		expect(rig.heartbeatStopCount).toBe(1);
 		expect(rig.activeHeartbeatCount).toBe(0);
 
-		const heartbeatAfterCompletion = getHeartbeatWrites(rig).length;
+		const heartbeatAfterInput = getHeartbeatWrites(rig).length;
 		rig.tickHeartbeat();
-		expect(getHeartbeatWrites(rig)).toHaveLength(heartbeatAfterCompletion);
-
-		rig.lifecycle.onSessionShutdown();
-		expect(rig.heartbeatStopCount).toBe(1);
-		expect(rig.activeHeartbeatCount).toBe(0);
+		expect(getHeartbeatWrites(rig)).toHaveLength(heartbeatAfterInput);
 
+		// Session shutdown also stops heartbeat cleanly
 		rig.lifecycle.onBeforeAgentStart();
 		expect(rig.heartbeatStartCount).toBe(2);
 		expect(rig.activeHeartbeatCount).toBe(1);

package/extensions/wezterm-notify/index.ts

@@ -175,11 +175,13 @@ export function createWeztermNotifyLifecycle(
 			enterWorking();
 		},
 		onAgentEnd: () => {
-			leaveWorking("done");
+			// Intentional no-op: tools may still be executing after the model
+			// finishes generating (e.g. subagent parallel runs). Stay "working"
+			// until the input prompt appears, which signals the turn is truly done.
 		},
 		onInput: () => {
-			if (!isWorking) {
-				leaveWorking("");
+			if (isWorking) {
+				leaveWorking("done");
 			}
 
 			return { action: "continue" as const };