gsd-pi 2.78.0 → 2.78.1-dev.9d08d820b

package/packages/pi-coding-agent/src/modes/interactive/components/tool-card-cleanup-and-success-runtime.test.ts

@@ -0,0 +1,212 @@
+// Runtime regression tests for the post-compaction tool-card cleanup and the
+// green-bordered success-notification rendering. Replaces the source-grep
+// `src/tests/tui-running-and-success-box.test.ts` that was deleted in #4875
+// (tracked as #4872).
+//
+// The previous tests asserted on identifier presence and method signature
+// shape via regex. A regression that routed `success` notifications through
+// `showStatus` (dim text) by accident would not have failed because the
+// `showSuccess` method would still exist and still match the regex. These
+// tests instead drive the components through the actual scenario and assert
+// on rendered output.
+
+import assert from "node:assert/strict";
+import { describe, it, before } from "node:test";
+
+import { Container, Text } from "@gsd/pi-tui";
+import stripAnsi from "strip-ansi";
+
+import { initTheme, theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { ToolExecutionComponent } from "./tool-execution.js";
+
+// Theme is a globalThis-shared singleton that throws if not initialized.
+// Initialize once before any test that exercises themed rendering.
+before(() => {
+	initTheme("dark");
+});
+
+interface MockTui {
+	renderCount: number;
+	requestRender(): void;
+}
+
+function makeMockTUI(): MockTui {
+	return {
+		renderCount: 0,
+		requestRender() {
+			this.renderCount++;
+		},
+	};
+}
+
+// ─── Bug 1: tool cards stuck in "Running" after compaction ──────────────
+
+describe("ToolExecutionComponent post-compaction cleanup", () => {
+	it("renders 'Running' status while the tool call has no result", () => {
+		// Baseline: a freshly-constructed component (mid-stream) must show
+		// the running badge — this is the state we need to flip OUT of when
+		// compaction removes the result message.
+		const ui = makeMockTUI();
+		const c = new ToolExecutionComponent(
+			"read_file",
+			{ path: "/tmp/x.txt" },
+			{},
+			undefined,
+			ui as never,
+		);
+		const rendered = c.render(60).map(stripAnsi).join("\n");
+		assert.ok(
+			rendered.includes("Running"),
+			"freshly constructed component should render 'Running' badge",
+		);
+	});
+
+	it("markHistoricalNoResult flips a stuck tool card OUT of 'Running'", () => {
+		// Real bug: after session-history replay (post-compaction or session
+		// switch), tool calls without matching tool_result messages stay in
+		// isPartial = true forever. markHistoricalNoResult must produce a
+		// rendered output that no longer reads "Running".
+		const ui = makeMockTUI();
+		const c = new ToolExecutionComponent(
+			"read_file",
+			{ path: "/tmp/x.txt" },
+			{},
+			undefined,
+			ui as never,
+		);
+
+		c.markHistoricalNoResult();
+
+		const rendered = c.render(60).map(stripAnsi).join("\n");
+		assert.ok(
+			!rendered.includes("Running"),
+			"after markHistoricalNoResult, the tool card must NOT render 'Running' — got:\n" +
+				rendered,
+		);
+		assert.ok(
+			rendered.includes("Done"),
+			"flipped card should render 'Done' status (no-result success)",
+		);
+	});
+
+	it("markHistoricalNoResult is idempotent when a real result already exists", () => {
+		// Late-arriving stream events must not clobber legitimate results.
+		// We observe the no-clobber via behaviour: a card that completed
+		// with a real result keeps its "Done" badge and content even if
+		// markHistoricalNoResult fires again afterwards.
+		const ui = makeMockTUI();
+		const c = new ToolExecutionComponent(
+			"read_file",
+			{ path: "/tmp/x.txt" },
+			{},
+			undefined,
+			ui as never,
+		);
+
+		// Use the public completion path the runtime calls.
+		c.updateResult(
+			{
+				content: [{ type: "text", text: "real-result-payload" }],
+				isError: false,
+			},
+			false, // isPartial = false → "Done"
+		);
+
+		const before = c.render(60).map(stripAnsi).join("\n");
+		assert.ok(before.includes("Done"), "after complete(), card shows 'Done'");
+
+		c.markHistoricalNoResult(); // must early-return
+		const after = c.render(60).map(stripAnsi).join("\n");
+		assert.equal(
+			after,
+			before,
+			"markHistoricalNoResult must NOT mutate state when a real result is already present",
+		);
+	});
+});
+
+// ─── Bug 2: success notifications render as a green bordered box ────────
+
+describe("Success-notification rendering — DynamicBorder + success theme", () => {
+	// We drive the same component composition that interactive-mode.showSuccess
+	// builds (DynamicBorder + Text + DynamicBorder, all themed with
+	// theme.fg("success", …)) and assert on the rendered output, rather than
+	// trying to instantiate the full InteractiveMode (which requires a real
+	// session, bridge, and TUI runtime).
+	function buildSuccessNotification(message: string): Container {
+		const c = new Container();
+		const successColor = (text: string) => theme.fg("success", text);
+		c.addChild(new DynamicBorder(successColor));
+		c.addChild(new Text(theme.fg("success", message), 1, 0));
+		c.addChild(new DynamicBorder(successColor));
+		return c;
+	}
+
+	it("renders a top and bottom horizontal border framing the message", () => {
+		const c = buildSuccessNotification("Milestone M042 ready.");
+		const lines = c.render(40);
+
+		// First and last lines should be horizontal-rule borders
+		// (DynamicBorder renders a row of "─" characters).
+		const firstStripped = stripAnsi(lines[0]);
+		const lastStripped = stripAnsi(lines[lines.length - 1]);
+
+		assert.ok(
+			firstStripped.includes("─"),
+			`first line should be a border (got: ${JSON.stringify(firstStripped)})`,
+		);
+		assert.ok(
+			lastStripped.includes("─"),
+			`last line should be a border (got: ${JSON.stringify(lastStripped)})`,
+		);
+		assert.ok(
+			lines.length >= 3,
+			`success notification must have at least 3 lines (top border, message, bottom border) — got ${lines.length}`,
+		);
+	});
+
+	it("the message text appears between the two borders", () => {
+		const c = buildSuccessNotification("Milestone M042 ready.");
+		const lines = c.render(40);
+
+		const messageRow = lines.findIndex((l) => stripAnsi(l).includes("Milestone M042 ready."));
+		assert.ok(messageRow > 0, "message must appear after the top border");
+		assert.ok(
+			messageRow < lines.length - 1,
+			"message must appear before the bottom border",
+		);
+	});
+
+	it("borders carry ANSI styling (not plain dim text like showStatus)", () => {
+		// Goodhart-resistant: if a regression routed success through
+		// showStatus, the borders would be missing AND the rendered text
+		// would be plain (or only dim-styled, not success-colored). We
+		// observe the border lines carry ANSI escape codes — the literal
+		// foreground color depends on the theme (which is system-dependent
+		// in CI), so we don't pin a specific code but DO require styling
+		// to be present.
+		const c = buildSuccessNotification("ok");
+		const lines = c.render(40);
+		const top = lines[0];
+		assert.ok(
+			top !== stripAnsi(top),
+			"top border must contain ANSI styling — a plain unstyled border " +
+				"would indicate the rendering bypassed theme.fg('success', ...)",
+		);
+	});
+
+	it("plain Text status (the showStatus path) does NOT produce a bordered box", () => {
+		// Counter-test: this is what the bug looked like — a single dim Text
+		// with no surrounding border. If anyone ever "fixes" the showSuccess
+		// regression by also adding borders to showStatus, this test will
+		// surface the conflation.
+		const plain = new Text(theme.fg("dim", "Milestone M042 ready."), 1, 0);
+		const lines = plain.render(40);
+		const joined = lines.map(stripAnsi).join("\n");
+		assert.ok(
+			!joined.includes("─"),
+			"plain Text (showStatus path) must NOT contain border characters",
+		);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.test.ts

@@ -159,6 +159,7 @@ function getSlashCommandName(text: string): string {
 
 function createHost(options: HostOptions = {}) {
 	const prompted: string[] = [];
+	const promptOptions: any[] = [];
 	const errors: string[] = [];
 	const warnings: string[] = [];
 	const tips: string[] = [];
@@ -186,8 +187,9 @@ function createHost(options: HostOptions = {}) {
 			isBashRunning: false,
 			isCompacting: false,
 			isStreaming: false,
-			prompt: async (text: string) => {
+			prompt: async (text: string, options?: any) => {
 				prompted.push(text);
+				promptOptions.push(options);
 			},
 		},
 		ui: {
@@ -235,6 +237,7 @@ function createHost(options: HostOptions = {}) {
 	return {
 		host: host as typeof host & { defaultEditor: typeof editor & { onSubmit: (text: string) => Promise<void> } },
 		prompted,
+		promptOptions,
 		errors,
 		warnings,
 		tips,
@@ -244,6 +247,19 @@ function createHost(options: HostOptions = {}) {
 	};
 }
 
+test("input-controller: regular prompt submit preserves pending images", async () => {
+	const { host, prompted, promptOptions } = createHost();
+	host.pendingImages.push({ ...TEST_IMAGE });
+
+	await host.defaultEditor.onSubmit("describe this image [Image #1]");
+
+	assert.deepEqual(prompted, ["describe this image [Image #1]"]);
+	assert.equal(promptOptions[0]?.images?.length, 1);
+	assert.equal(promptOptions[0].images[0].mimeType, "image/png");
+	assert.equal(promptOptions[0].images[0].data, TEST_IMAGE.data);
+	assert.equal(host.pendingImages.length, 0);
+});
+
 test("input-controller: built-in slash commands stay in TUI dispatch", async () => {
 	const { host, prompted, errors, getSettingsOpened, getEditorText } = createHost();
 

package/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.ts

@@ -133,7 +133,7 @@ export function setupEditorSubmitHandler(host: InteractiveModeStateHost & {
 		// submitPromptsDirectly is false — still dispatch via session.prompt so user input
 		// is not silently discarded.
 		try {
-			await host.session.prompt(text);
+			await host.session.prompt(text, { images });
 		} catch (error: unknown) {
 			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
 			host.showError(errorMessage);

package/packages/pi-coding-agent/src/tests/system-prompt-cache-stability.test.ts

@@ -0,0 +1,102 @@
+// @gsd/pi-coding-agent + system-prompt-cache-stability.test — regression
+// coverage for #5019. The system prompt must NOT include a per-call timestamp
+// by default; embedding `Date.toLocaleString()` in the cached prefix
+// invalidates Anthropic prompt-cache hits on every request and incurs the
+// cache-write premium. The opt-in `includeDateTime` flag preserves the prior
+// behavior for callers that explicitly want clock awareness.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildSystemPrompt } from "../core/system-prompt.js";
+
+// ─── Default branch (no customPrompt) ──────────────────────────────────────
+
+test("buildSystemPrompt: default omits 'Current date and time' line", () => {
+	const prompt = buildSystemPrompt({ selectedTools: ["read", "edit"] });
+	assert.ok(
+		!prompt.includes("Current date and time:"),
+		`prompt should not include the dateTime line by default. Got:\n${prompt}`,
+	);
+});
+
+test("buildSystemPrompt: includeDateTime=true emits 'Current date and time' line", () => {
+	const prompt = buildSystemPrompt({
+		selectedTools: ["read", "edit"],
+		includeDateTime: true,
+	});
+	assert.match(
+		prompt,
+		/Current date and time: /,
+		"prompt should include the dateTime line when explicitly opted in",
+	);
+});
+
+test("buildSystemPrompt: includeDateTime=false explicit also omits the line", () => {
+	const prompt = buildSystemPrompt({
+		selectedTools: ["read", "edit"],
+		includeDateTime: false,
+	});
+	assert.ok(!prompt.includes("Current date and time:"));
+});
+
+// ─── Custom-prompt branch ──────────────────────────────────────────────────
+
+test("buildSystemPrompt (customPrompt): default omits 'Current date and time' line", () => {
+	const prompt = buildSystemPrompt({
+		customPrompt: "CUSTOM BASE",
+		selectedTools: ["read"],
+	});
+	assert.ok(!prompt.includes("Current date and time:"));
+});
+
+test("buildSystemPrompt (customPrompt): includeDateTime=true emits the line", () => {
+	const prompt = buildSystemPrompt({
+		customPrompt: "CUSTOM BASE",
+		selectedTools: ["read"],
+		includeDateTime: true,
+	});
+	assert.match(prompt, /Current date and time: /);
+});
+
+// ─── Cache-stability invariant ─────────────────────────────────────────────
+
+test("buildSystemPrompt: two back-to-back default calls produce identical prompts", async () => {
+	// The bug: the previous default-on `dateTime` line included `second: "2-digit"`,
+	// so two calls within the same second could match but any longer gap busted
+	// the cache. Asserting equality across a deliberate sub-second sleep proves
+	// the byte-for-byte stability that Anthropic prompt caching requires.
+	const first = buildSystemPrompt({ selectedTools: ["read", "edit"], cwd: "/tmp/example" });
+	await new Promise((resolve) => setTimeout(resolve, 1100));
+	const second = buildSystemPrompt({ selectedTools: ["read", "edit"], cwd: "/tmp/example" });
+	assert.equal(
+		first,
+		second,
+		"system prompt must be byte-for-byte stable across calls so the prompt cache can hit",
+	);
+});
+
+test("buildSystemPrompt: includeDateTime=true intentionally produces different prompts across the second boundary", async () => {
+	// Inverse of the cache-stability test: when callers opt in, the dateTime
+	// line is expected to vary. This documents the trade-off the flag exists
+	// to surface.
+	const first = buildSystemPrompt({
+		selectedTools: ["read"],
+		cwd: "/tmp/example",
+		includeDateTime: true,
+	});
+	await new Promise((resolve) => setTimeout(resolve, 1100));
+	const second = buildSystemPrompt({
+		selectedTools: ["read"],
+		cwd: "/tmp/example",
+		includeDateTime: true,
+	});
+	assert.notEqual(first, second, "opt-in dateTime is expected to vary across the second boundary");
+});
+
+// ─── Cwd preservation ──────────────────────────────────────────────────────
+
+test("buildSystemPrompt: 'Current working directory' line is preserved (only dateTime is removed)", () => {
+	const prompt = buildSystemPrompt({ selectedTools: ["read"], cwd: "/tmp/example" });
+	assert.match(prompt, /Current working directory: \/tmp\/example/);
+});

package/packages/pi-coding-agent/src/tests/token-telemetry.test.ts

@@ -0,0 +1,200 @@
+// @gsd/pi-coding-agent + token-telemetry.test — coverage for #5023.
+// Verifies the env-gated emitter:
+//   - is silent by default (no behavior change for existing users)
+//   - emits a single valid JSON line when PI_TOKEN_TELEMETRY=1
+//   - record shape captures the cache breakdown the providers already extract
+//   - cacheHitRatio math is correct, including the no-input edge case
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+
+import type { AssistantMessage } from "@gsd/pi-ai";
+
+import { buildTokenTelemetryRecord, emitTokenTelemetry } from "../core/token-telemetry.js";
+
+function makeAssistantMessage(overrides: Partial<AssistantMessage> = {}): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		api: "anthropic-messages",
+		provider: "anthropic",
+		model: "claude-sonnet-4-6",
+		usage: {
+			input: 100,
+			output: 50,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 150,
+			cost: { input: 0.3, output: 0.75, cacheRead: 0, cacheWrite: 0, total: 1.05 },
+		},
+		stopReason: "stop",
+		timestamp: 1700000000000,
+		...overrides,
+	};
+}
+
+// ─── buildTokenTelemetryRecord ─────────────────────────────────────────────
+
+describe("buildTokenTelemetryRecord", () => {
+	test("captures all fields from a typical message", () => {
+		const msg = makeAssistantMessage();
+		const record = buildTokenTelemetryRecord(msg);
+		assert.deepEqual(record, {
+			ts: 1700000000000,
+			model: "claude-sonnet-4-6",
+			stopReason: "stop",
+			input: 100,
+			output: 50,
+			cacheRead: 0,
+			cacheWrite: 0,
+			costTotal: 1.05,
+			cacheHitRatio: 0,
+		});
+	});
+
+	test("cacheHitRatio = read / (read + input) when both present", () => {
+		const msg = makeAssistantMessage({
+			usage: {
+				input: 200,
+				output: 50,
+				cacheRead: 800,
+				cacheWrite: 0,
+				totalTokens: 1050,
+				cost: { input: 0.6, output: 0.75, cacheRead: 0.24, cacheWrite: 0, total: 1.59 },
+			},
+		});
+		const record = buildTokenTelemetryRecord(msg);
+		assert.equal(record.cacheRead, 800);
+		assert.equal(record.input, 200);
+		assert.equal(record.cacheHitRatio, 0.8);
+	});
+
+	test("cacheHitRatio = 0 when both read and input are 0 (no division-by-zero)", () => {
+		const msg = makeAssistantMessage({
+			usage: {
+				input: 0,
+				output: 50,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 50,
+				cost: { input: 0, output: 0.75, cacheRead: 0, cacheWrite: 0, total: 0.75 },
+			},
+		});
+		const record = buildTokenTelemetryRecord(msg);
+		assert.equal(record.cacheHitRatio, 0);
+	});
+
+	test("cacheHitRatio = 1 when only cacheRead present (full hit)", () => {
+		const msg = makeAssistantMessage({
+			usage: {
+				input: 0,
+				output: 50,
+				cacheRead: 5000,
+				cacheWrite: 0,
+				totalTokens: 5050,
+				cost: { input: 0, output: 0.75, cacheRead: 1.5, cacheWrite: 0, total: 2.25 },
+			},
+		});
+		const record = buildTokenTelemetryRecord(msg);
+		assert.equal(record.cacheHitRatio, 1);
+	});
+
+	test("cacheWrite is captured (the cache-miss-with-cache-control case from #5019)", () => {
+		const msg = makeAssistantMessage({
+			usage: {
+				input: 50,
+				output: 100,
+				cacheRead: 0,
+				cacheWrite: 5000,
+				totalTokens: 5150,
+				cost: { input: 0.15, output: 1.5, cacheRead: 0, cacheWrite: 18.75, total: 20.4 },
+			},
+		});
+		const record = buildTokenTelemetryRecord(msg);
+		assert.equal(record.cacheWrite, 5000);
+		assert.equal(record.cacheHitRatio, 0, "no read = ratio 0 even when write is large");
+	});
+
+	test("error stopReason is captured verbatim", () => {
+		const msg = makeAssistantMessage({ stopReason: "error", errorMessage: "rate_limit" });
+		assert.equal(buildTokenTelemetryRecord(msg).stopReason, "error");
+	});
+});
+
+// ─── emitTokenTelemetry ────────────────────────────────────────────────────
+
+describe("emitTokenTelemetry", () => {
+	let captured: string[];
+	let originalWrite: typeof process.stderr.write;
+	let originalEnv: string | undefined;
+
+	beforeEach(() => {
+		captured = [];
+		originalWrite = process.stderr.write.bind(process.stderr);
+		// Replace stderr.write with a capture; preserve the same return contract.
+		process.stderr.write = ((chunk: string | Uint8Array): boolean => {
+			captured.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
+			return true;
+		}) as typeof process.stderr.write;
+		originalEnv = process.env.PI_TOKEN_TELEMETRY;
+	});
+
+	afterEach(() => {
+		process.stderr.write = originalWrite;
+		if (originalEnv === undefined) {
+			delete process.env.PI_TOKEN_TELEMETRY;
+		} else {
+			process.env.PI_TOKEN_TELEMETRY = originalEnv;
+		}
+	});
+
+	test("silent by default (env var unset)", () => {
+		delete process.env.PI_TOKEN_TELEMETRY;
+		emitTokenTelemetry(makeAssistantMessage());
+		assert.equal(captured.length, 0);
+	});
+
+	test("silent when env var has any non-'1' value", () => {
+		process.env.PI_TOKEN_TELEMETRY = "true"; // not literally "1"
+		emitTokenTelemetry(makeAssistantMessage());
+		assert.equal(captured.length, 0, "only literal '1' should enable telemetry");
+	});
+
+	test("emits a single JSON line when PI_TOKEN_TELEMETRY=1", () => {
+		process.env.PI_TOKEN_TELEMETRY = "1";
+		emitTokenTelemetry(makeAssistantMessage());
+		assert.equal(captured.length, 1);
+		assert.ok(captured[0].endsWith("\n"), "line must terminate with newline");
+		const parsed = JSON.parse(captured[0].trimEnd());
+		assert.equal(parsed.model, "claude-sonnet-4-6");
+		assert.equal(parsed.input, 100);
+		assert.equal(parsed.output, 50);
+	});
+
+	test("emitted JSON has the documented shape", () => {
+		process.env.PI_TOKEN_TELEMETRY = "1";
+		emitTokenTelemetry(makeAssistantMessage());
+		const parsed = JSON.parse(captured[0].trimEnd());
+		const keys = Object.keys(parsed).sort();
+		assert.deepEqual(keys, [
+			"cacheHitRatio",
+			"cacheRead",
+			"cacheWrite",
+			"costTotal",
+			"input",
+			"model",
+			"output",
+			"stopReason",
+			"ts",
+		]);
+	});
+
+	test("never throws — telemetry must not break the agent loop", () => {
+		process.env.PI_TOKEN_TELEMETRY = "1";
+		// Force a write failure to exercise the swallow path.
+		process.stderr.write = (() => {
+			throw new Error("simulated stderr failure");
+		}) as typeof process.stderr.write;
+		assert.doesNotThrow(() => emitTokenTelemetry(makeAssistantMessage()));
+	});
+});