@zenodinh/pi-render 0.0.0-stage → 0.1.0

package/src/renderers/tool/specs/codemode.test.ts

@@ -0,0 +1,212 @@
+/**
+ * codemode.test.ts — the codemode spec through its seam: buildCall, build, project.
+ *
+ * Every scenario enters at the exported spec (or its two sibling exports) and drives it with fixtures
+ * and the T-11 marker double; nothing below the seam is imported.
+ *
+ * shape: fixture records + one literal expectation per case — trigger #7, fixed-shape host payloads
+ * and views; a class or fixture framework would be ceremony over two object literals.
+ */
+
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { assertNoRealEscapes, markerPaint, testRenderContext } from "../../../../test/fakes/index.ts";
+import type { RenderContext, RowPaint, RowView, ToolResult } from "../../../core/types.ts";
+import { descriptor, name, spec } from "./codemode.ts";
+
+/** The spec's own source: the two static claims (no execution, no escape literal) are read off it. */
+const SOURCE = readFileSync(new URL("./codemode.ts", import.meta.url), "utf8");
+
+const PAINT: RowPaint = markerPaint();
+const COLLAPSED: RowView = { expanded: false, isError: false, isPartial: false };
+const EXPANDED: RowView = { expanded: true, isError: false, isPartial: false };
+
+// recorded-from: @earendil-works/pi-coding-agent@1.0.4
+//   dist/extensions/codemode/renderer.js:14-16,52-96 (read 2026-10-07) — the details.calls[] field set
+//   ({name, args, durationMs, cost, error, status}), the "Script … / Wall time … / Output:" header block
+//   the host strips, and its collapsed "Full output: <path>" line.
+// invented: no live codemode session was captured, so the names, paths and timings stand in for real ones.
+const CANONICAL: ToolResult = {
+	content: [
+		{ type: "text", text: "Script completed\nWall time 1.9 seconds\nOutput:\n" },
+		{ type: "text", text: "all good\n" },
+	],
+	details: {
+		calls: [
+			{ name: "read", args: "src/core/log.ts", status: "ok", durationMs: 12, cost: 0.0042 },
+			{ name: "bash", args: "npm test", status: "ok", durationMs: 1400 },
+			{ name: "write", args: "out.txt", status: "ok", durationMs: 3 },
+		],
+		fullOutputPath: "/tmp/pi-codemode/run-1.txt",
+	},
+};
+
+/** Same shape, one call failed and the script's own error text in content. */
+const FAILED: ToolResult = {
+	content: [{ type: "text", text: "boom: exit code 1\nsecond line of the failure\n" }],
+	details: {
+		calls: [
+			{ name: "read", args: "src/core/log.ts", status: "ok", durationMs: 8 },
+			{ name: "bash", args: "npm test", status: "error", durationMs: 900, error: "expected 3 tests, got 2" },
+		],
+	},
+};
+
+/** A "Script failed" header: every call succeeded, the script did not. */
+const SCRIPT_FAILED: ToolResult = {
+	content: [
+		{ type: "text", text: "Script failed\nWall time 2 seconds\nOutput:\n" },
+		{ type: "text", text: "TypeError: x is not a function\n" },
+	],
+	details: { calls: [{ name: "read", args: "a.ts", status: "ok", durationMs: 5 }] },
+};
+
+/** Mid-flight: the last call is still running, so the script body is not final. */
+const STREAMING: ToolResult = {
+	content: [
+		{ type: "text", text: "Script completed\nWall time 1.9 seconds\nOutput:\n" },
+		{ type: "text", text: "all good\n" },
+	],
+	details: { calls: [{ name: "bash", args: "npm test", status: "running" }] },
+};
+
+/** The spec's parse stage, failing loudly when a fixture stops reading as a codemode result. */
+function build(result: ToolResult, ctx: RenderContext = testRenderContext().derive()) {
+	const model = spec.build(result, ctx);
+	if (model === "unknown") throw new Error("fixture did not parse as a codemode result");
+	return model;
+}
+
+describe("codemode spec — the exports T-28 composes", () => {
+	it("AC-1: declares the row.codemode descriptor with no settings", () => {
+		// fails_when: the descriptor a boot test registers drifts from the agreed key or name
+		expect(name).toBe("codemode");
+		expect(descriptor).toEqual({ key: "row.codemode", name: "Codemode row", defaultEnabled: true, settings: [] });
+	});
+});
+
+describe("codemode spec — AC-1 the golden rows", () => {
+	it("AC-1: collapsed, the row is the call count and the status summary", () => {
+		const row = spec.project(build(CANONICAL), COLLAPSED, PAINT);
+		// fails_when: the count, the status, or the truncated-output path is missing or wrong
+		expect(row).toBe(
+			`${PAINT.muted("3 tool calls")} ${PAINT.muted("·")} ${PAINT.accent("✓")} ${PAINT.muted("·")} ${PAINT.muted("Full output: /tmp/pi-codemode/run-1.txt")}`,
+		);
+	});
+
+	it("AC-1: expanded, the row lists every nested call above the script output", () => {
+		const row = spec.project(build(CANONICAL), EXPANDED, PAINT);
+		// fails_when: a call is dropped, mislabelled, or the output keeps the host's header line
+		expect(row).toBe(
+			[
+				`${PAINT.accent("✓")} ${PAINT.title("read")} ${PAINT.muted("src/core/log.ts")} ${PAINT.muted("12ms")} ${PAINT.muted("$0.0042")}`,
+				`${PAINT.accent("✓")} ${PAINT.title("bash")} ${PAINT.muted("npm test")} ${PAINT.muted("1.4s")}`,
+				`${PAINT.accent("✓")} ${PAINT.title("write")} ${PAINT.muted("out.txt")} ${PAINT.muted("3ms")}`,
+				"",
+				PAINT.output("all good"),
+				PAINT.muted("Full output: /tmp/pi-codemode/run-1.txt"),
+			].join("\n"),
+		);
+	});
+
+	it("AC-1: a streaming script streams its calls and withholds the body", () => {
+		const partial: RowView = { ...EXPANDED, isPartial: true };
+		// fails_when: a not-yet-final output is served as the script's result
+		expect(spec.project(build(STREAMING), partial, PAINT)).toBe(
+			`${PAINT.warning("…")} ${PAINT.title("bash")} ${PAINT.muted("npm test")}`,
+		);
+		expect(spec.project(build(STREAMING), { ...COLLAPSED, isPartial: true }, PAINT)).toBe(
+			`${PAINT.muted("1 tool call")} ${PAINT.muted("·")} ${PAINT.warning("…")}`,
+		);
+	});
+
+	it("AC-1: a result with neither details nor text reports unknown", () => {
+		// fails_when: an unrecognized result gets a plausible-looking row instead of the raw fallback
+		expect(spec.build({ content: [] }, testRenderContext().derive())).toBe("unknown");
+	});
+});
+
+describe("codemode spec — AC-2 the error rows", () => {
+	it("AC-2: a failed call shows its error on the collapsed line", () => {
+		const row = spec.project(build(FAILED), { ...COLLAPSED, isError: true }, PAINT);
+		// fails_when: the error renders blank, shows prose instead of the message, or crashes
+		expect(row).toBe(PAINT.error("✗ boom: exit code 1"));
+	});
+
+	it("AC-2: expanded, the error body replaces the call list", () => {
+		const row = spec.project(build(FAILED), { ...EXPANDED, isError: true }, PAINT);
+		// fails_when: the failure body is cut to its first line in the expanded row
+		expect(row).toBe([PAINT.error("boom: exit code 1"), PAINT.error("second line of the failure")].join("\n"));
+	});
+
+	it("AC-2: a failed nested call marks the summary and prints its message expanded", () => {
+		// fails_when: a nested failure reads as ok on the collapsed line, or its message is dropped
+		expect(spec.project(build(FAILED), COLLAPSED, PAINT)).toBe(
+			`${PAINT.muted("2 tool calls")} ${PAINT.muted("·")} ${PAINT.error("✗")}`,
+		);
+		expect(spec.project(build(FAILED), EXPANDED, PAINT)).toBe(
+			[
+				`${PAINT.accent("✓")} ${PAINT.title("read")} ${PAINT.muted("src/core/log.ts")} ${PAINT.muted("8ms")}`,
+				`${PAINT.error("✗")} ${PAINT.title("bash")} ${PAINT.muted("npm test")} ${PAINT.muted("900ms")}`,
+				PAINT.error("    expected 3 tests, got 2"),
+				"",
+				PAINT.output("boom: exit code 1"),
+				PAINT.output("second line of the failure"),
+			].join("\n"),
+		);
+	});
+
+	it("AC-2: a failed script header with successful calls still reads as an error", () => {
+		const row = spec.project(build(SCRIPT_FAILED), COLLAPSED, PAINT);
+		// fails_when: the header is stripped without its verdict, so a failed script reads ok
+		expect(row).toBe(`${PAINT.muted("1 tool call")} ${PAINT.muted("·")} ${PAINT.error("✗")}`);
+		expect(spec.project(build(SCRIPT_FAILED), EXPANDED, PAINT)).toContain("TypeError: x is not a function");
+	});
+});
+
+describe("codemode spec — AC-3 nothing executable is ported", () => {
+	it("AC-3: the source holds no registration, wrapper, or prompt text", () => {
+		const forbidden = [/\bregisterTool\s*\(/, /\bexecute\b/, /\bprompt\b/, /\bas unknown as\b/];
+		// fails_when: the port smuggles an execution or instruction claim back in
+		expect(forbidden.filter((pattern) => pattern.test(SOURCE)).map(String)).toEqual([]);
+	});
+});
+
+describe("codemode spec — AC-4 the args gate", () => {
+	it("AC-4: an incomplete call is titled with the tool name alone", () => {
+		const pending = testRenderContext({ args: {}, argsComplete: false }).derive();
+		// fails_when: a partial argument value or a derived count is shown before the host says it is complete
+		expect(spec.buildCall({ code: "const x = 1\nreturn x" }, pending)).toEqual({ title: "codemode" });
+
+		const unknownGate = testRenderContext({ args: {} }).derive({ argsComplete: undefined });
+		// fails_when: an absent gate flag reads as "complete" and the row guesses from the args
+		expect(spec.buildCall({ code: "return 1" }, unknownGate)).toEqual({ title: "codemode" });
+	});
+
+	it("AC-4: a complete call is titled with the script's line count", () => {
+		const ready = testRenderContext({ args: { code: "const x = 1\nreturn x" } }).derive();
+		// fails_when: the gate never opens, so the row says nothing about the script it will run
+		expect(spec.buildCall({ code: "const x = 1\nreturn x" }, ready)).toEqual({ title: "codemode · 2 lines" });
+		expect(spec.buildCall({ code: "return 1" }, ready)).toEqual({ title: "codemode · 1 line" });
+	});
+});
+
+describe("codemode spec — AC-5 color comes only from paint", () => {
+	it("AC-5: every escape in a rendered row is a paint marker", () => {
+		const rows = [
+			spec.project(build(CANONICAL), COLLAPSED, PAINT),
+			spec.project(build(CANONICAL), EXPANDED, PAINT),
+			spec.project(build(FAILED), { ...COLLAPSED, isError: true }, PAINT),
+		];
+		for (const row of rows) assertNoRealEscapes(row);
+		// fails_when: a role is bypassed, so text reaches the row unpainted
+		expect(rows[0]).toContain(PAINT.muted("3 tool calls"));
+		expect(rows[1]).toContain(PAINT.output("all good"));
+	});
+
+	it("AC-5: the source holds no escape literal", () => {
+		const esc = String.fromCharCode(27);
+		// fails_when: a hardcoded color reaches the terminal without passing through a paint role
+		expect([SOURCE.includes(esc), SOURCE.includes("\\x1b"), SOURCE.includes("\\u001b")]).toEqual([false, false, false]);
+	});
+});

package/src/renderers/tool/specs/codemode.ts

@@ -0,0 +1,248 @@
+/**
+ * codemode.ts — the codemode row: a one-line call count plus status, or the nested calls and output.
+ *
+ * Boundary: `details` and `args` are host data typed `unknown` here, so every field is narrowed by a
+ * predicate before it is read; color arrives only through the `paint` argument — no escape is emitted.
+ *
+ * shape: fixed-shape record — trigger #7, the exported RowSpec's fields are known statically and hold no
+ * state; STATUS_ICON below declares its own dispatch shape.
+ *
+ * ported from pi-pretty-tui/src/features/codemode-collapse/render.ts — survives because: the collapsed
+ * count/status summary, the per-call line, and the rule that a streaming script withholds its output are
+ * what that renderer got right. Its registration, its background-fill wrapper, and its cast sites carry
+ * claims pi-render does not make.
+ */
+
+import type { ModuleDescriptor, RowPaint, RowSpec, RowView, ToolResult } from "../../../core/types.ts";
+
+/** The tool name this spec renders, exactly as the host spells it. */
+export const name = "codemode";
+
+/** Registry descriptor; T-28 owns the defineModule call, this file only declares it. */
+export const descriptor: ModuleDescriptor = {
+	key: "row.codemode",
+	name: "Codemode row",
+	defaultEnabled: true,
+	settings: [],
+};
+
+type CallStatus = "running" | "ok" | "error" | "cancelled";
+
+/** One nested call; `status` stays verbatim so an unrecognized value reports "?" rather than "ok". */
+interface NestedCall {
+	name: string;
+	args: string;
+	status: string;
+	durationMs?: number;
+	cost?: number;
+	error?: string;
+}
+
+/** The parsed result: the nested calls, plus the script's output with the host's header removed. */
+interface CodemodeModel {
+	calls: NestedCall[];
+	output: string;
+	/** A "Script failed" header with successful calls still reads as a failure. */
+	failed: boolean;
+	fullOutputPath?: string;
+}
+
+const MAX_ARGS_PREVIEW = 80;
+const MAX_ERROR_SUMMARY = 80;
+
+/** The host writes the header as its own text block, ending at "Output:" — dist/extensions/codemode/renderer.js:14. */
+const SCRIPT_HEADER = /^Script (completed|failed)\nWall time [\d.]+ seconds\nOutput:\n/;
+
+// shape: dispatch object — trigger #1, four stateless icon handlers on one status discriminator.
+// `accent` carries "ok": RowPaint has no success role, and `muted` would read as metadata.
+const STATUS_ICON: Record<CallStatus, (paint: RowPaint) => string> = {
+	running: (paint) => paint.warning("…"),
+	ok: (paint) => paint.accent("✓"),
+	error: (paint) => paint.error("✗"),
+	cancelled: (paint) => paint.muted("⊘"),
+};
+
+// shape: fixed-shape record — trigger #7, three pure stages over the model above, no state.
+export const spec: RowSpec<CodemodeModel> = {
+	buildCall(args, ctx) {
+		const code = typeof args.code === "string" ? args.code : "";
+		// Fail closed: no argument-derived output until the host affirms its args are complete.
+		if (ctx.argsComplete !== true || code === "") return { title: name };
+		const lines = code.trimEnd().split("\n").length;
+		return { title: `${name} · ${lines} line${lines === 1 ? "" : "s"}` };
+	},
+
+	build(result) {
+		const details = result.details;
+		const record = isRecord(details) ? details : undefined;
+		const blocks = textBlocks(result);
+		if (record === undefined && blocks.length === 0) return "unknown";
+		const parsed = parseOutput(blocks);
+		const fullOutputPath = record?.fullOutputPath;
+		return {
+			calls: parseCalls(record),
+			output: parsed.output,
+			failed: parsed.failed,
+			fullOutputPath: typeof fullOutputPath === "string" ? fullOutputPath : undefined,
+		};
+	},
+
+	project(model, view, paint) {
+		if (view.isError) return errorRow(model, view, paint);
+		if (!view.expanded) return collapsedRow(model, view, paint);
+		return expandedBody(model, view, paint);
+	},
+};
+
+/* ── parse ─────────────────────────────────────────────────────────────────── */
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function textBlocks(result: ToolResult): string[] {
+	const blocks = result.content ?? [];
+	const texts: string[] = [];
+	for (const block of blocks) {
+		if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
+	}
+	return texts;
+}
+
+/** Splits the header off the first block, wherever the host put the output that follows it. */
+function parseOutput(blocks: string[]): { output: string; failed: boolean } {
+	const first = blocks[0];
+	if (first === undefined) return { output: "", failed: false };
+	const header = SCRIPT_HEADER.exec(first);
+	if (header === null) return { output: blocks.join("\n").trimEnd(), failed: false };
+	const rest = [first.slice(header[0].length), ...blocks.slice(1)].filter((part) => part !== "");
+	return { output: rest.join("\n").trimEnd(), failed: header[1] === "failed" };
+}
+
+function parseCalls(details: Record<string, unknown> | undefined): NestedCall[] {
+	const raw = details?.calls;
+	if (!Array.isArray(raw)) return [];
+	const calls: NestedCall[] = [];
+	for (const item of raw) {
+		if (!isRecord(item)) continue;
+		const call: NestedCall = {
+			name: typeof item.name === "string" ? item.name : "",
+			args: typeof item.args === "string" ? item.args : "",
+			status: typeof item.status === "string" ? item.status : "",
+		};
+		if (typeof item.durationMs === "number" && Number.isFinite(item.durationMs)) call.durationMs = item.durationMs;
+		if (typeof item.cost === "number" && Number.isFinite(item.cost)) call.cost = item.cost;
+		if (typeof item.error === "string" && item.error !== "") call.error = item.error;
+		calls.push(call);
+	}
+	return calls;
+}
+
+/* ── project ───────────────────────────────────────────────────────────────── */
+
+function collapsedRow(model: CodemodeModel, view: RowView, paint: RowPaint): string {
+	const icon = statusIcon(aggregateStatus(model, view.isPartial), paint);
+	return `${paint.muted(countLabel(model.calls.length))} ${paint.muted("·")} ${icon}${pathSuffix(model, paint)}`;
+}
+
+function errorRow(model: CodemodeModel, view: RowView, paint: RowPaint): string {
+	const first = firstLine(model.output);
+	if (!view.expanded) {
+		const summary = first === "" ? countLabel(model.calls.length) : clip(first, MAX_ERROR_SUMMARY);
+		return `${paint.error(`✗ ${summary}`)}${pathSuffix(model, paint)}`;
+	}
+	if (first === "") return collapsedRow(model, view, paint);
+	return paintLines(model.output, paint.error).join("\n");
+}
+
+function expandedBody(model: CodemodeModel, view: RowView, paint: RowPaint): string {
+	const rows: string[] = [];
+	for (const call of model.calls) rows.push(...callLines(call, paint));
+	// A streaming script's output is not final: its calls stream, its body waits (the host's contract).
+	const output = view.isPartial ? "" : model.output;
+	if (output !== "") {
+		if (rows.length > 0) rows.push("");
+		rows.push(...paintLines(output, paint.output));
+	}
+	const path = model.fullOutputPath;
+	if (path !== undefined) rows.push(paint.muted(`Full output: ${path}`));
+	return rows.join("\n");
+}
+
+function callLines(call: NestedCall, paint: RowPaint): string[] {
+	let line = `${statusIcon(call.status, paint)} ${paint.title(call.name)}`;
+	if (call.args !== "") line += ` ${paint.muted(clip(call.args, MAX_ARGS_PREVIEW))}`;
+	const duration = formatDuration(call.durationMs);
+	if (duration !== "") line += ` ${paint.muted(duration)}`;
+	const cost = formatCost(call.cost);
+	if (cost !== "") line += ` ${paint.muted(cost)}`;
+	if (call.error === undefined) return [line];
+	// The host hangs a failed call's message under its own line, indented.
+	return [
+		line,
+		paint.error(
+			call.error
+				.split("\n")
+				.map((part) => `    ${part}`)
+				.join("\n"),
+		),
+	];
+}
+
+/* ── helpers ───────────────────────────────────────────────────────────────── */
+
+function aggregateStatus(model: CodemodeModel, isPartial: boolean): CallStatus {
+	if (model.calls.some((call) => call.status === "running")) return "running";
+	if (model.failed || model.calls.some((call) => call.status === "error")) return "error";
+	if (model.calls.some((call) => call.status === "cancelled")) return "cancelled";
+	return isPartial ? "running" : "ok";
+}
+
+function statusIcon(status: string, paint: RowPaint): string {
+	return isCallStatus(status) ? STATUS_ICON[status](paint) : paint.muted("?");
+}
+
+/** A switch, not a table lookup: an inherited member such as "toString" must not read as a status. */
+function isCallStatus(status: string): status is CallStatus {
+	switch (status) {
+		case "running":
+		case "ok":
+		case "error":
+		case "cancelled":
+			return true;
+		default:
+			return false;
+	}
+}
+
+function countLabel(count: number): string {
+	return `${count} tool call${count === 1 ? "" : "s"}`;
+}
+
+function pathSuffix(model: CodemodeModel, paint: RowPaint): string {
+	const path = model.fullOutputPath;
+	return path === undefined ? "" : ` ${paint.muted("·")} ${paint.muted(`Full output: ${path}`)}`;
+}
+
+function paintLines(text: string, role: (line: string) => string): string[] {
+	return text.split("\n").map((line) => role(line));
+}
+
+function formatDuration(ms: number | undefined): string {
+	if (ms === undefined) return "";
+	return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+function formatCost(cost: number | undefined): string {
+	if (cost === undefined || cost === 0) return "";
+	return `$${cost >= 0.01 ? cost.toFixed(2) : cost.toPrecision(2)}`;
+}
+
+function firstLine(text: string): string {
+	const end = text.indexOf("\n");
+	return (end === -1 ? text : text.slice(0, end)).trim();
+}
+
+function clip(text: string, max: number): string {
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}