@zenodinh/pi-render 0.1.0 → 0.1.3

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

@@ -1,145 +0,0 @@
-// spec: specs/write.ts RowSpec — buildCall(args, ctx) -> { title }; build(result, ctx) -> model;
-// project(model, view, paint) -> the row string. The collapsed summary derives from the args
-// (path + content size); the host result carries only a one-line confirmation, so it is not trusted
-// for counts. Cases: written row, empty content, trailing newline, error row, args gate, paint-only.
-
-import { readFileSync } from "node:fs";
-import { describe, expect, test } from "vitest";
-import { assertNoRealEscapes, markerPaint, testRenderContext } from "../../../../test/fakes/index.ts";
-import type { CallModel, RenderContext, RowPaint, RowView, ToolResult } from "../../../core/types.ts";
-import { writeRow } from "./write.ts";
-
-const { spec } = writeRow;
-
-// recorded-from: pi host write tool_result, 2026-10-06 (T-18 host facts, pi 1.0.4) — details are
-// undefined and content is the one-line confirmation. It carries no counts.
-function writeResult(path: string): ToolResult {
-	return { content: [{ type: "text", text: `Successfully wrote to ${path}` }] };
-}
-
-// invented: host write error text; the predecessor recorded no error capture for this row.
-const ERROR_RESULT: ToolResult = {
-	content: [{ type: "text", text: "ENOENT: no such file or directory, open '/repo/src/app.ts'" }],
-};
-
-const PATH = "/repo/src/app.ts";
-// invented: arithmetic fixture — "line one"(8) + "\n"(1) + "line two"(8) = 17 bytes over 2 lines, so
-// the pinned counts are literals the code under test cannot recompute to agree with itself.
-const CONTENT = "line one\nline two";
-
-// invented: identity paint so AC-1/AC-2 goldens are readable plain text; AC-5 drives the marker fake.
-const PLAIN: RowPaint = {
-	title: (text) => text,
-	output: (text) => text,
-	muted: (text) => text,
-	accent: (text) => text,
-	error: (text) => text,
-	warning: (text) => text,
-	gutter: (text) => text,
-	match: (text) => text,
-	diffAdded: (text) => text,
-	diffRemoved: (text) => text,
-	diffContext: (text) => text,
-};
-
-const COLLAPSED: RowView = { expanded: false, isError: false, isPartial: false };
-const EXPANDED: RowView = { expanded: true, isError: false, isPartial: false };
-
-function row(args: Record<string, unknown>, overrides: Partial<RenderContext> = {}): RenderContext {
-	return testRenderContext({ cwd: "/repo", args }).derive(overrides);
-}
-
-/** Narrows build()'s "unknown" away so a spec regression surfaces as a named failure, not a type error. */
-function written(args: Record<string, unknown>, overrides: Partial<RenderContext> = {}) {
-	const model = spec.build(writeResult(PATH), row(args, overrides));
-	if (model === "unknown") throw new Error("write build returned unknown for a written row");
-	return model;
-}
-
-describe("write spec — args gate (AC-4)", () => {
-	test("incomplete args show the tool name only", () => {
-		const ctx = row({}, { argsComplete: false });
-		const call: CallModel = spec.buildCall({}, ctx);
-		expect(call.title).toBe("write");
-		expect(call.title).not.toContain("src/");
-	});
-
-	test("a path streamed before argsComplete is not guessed onto the call line", () => {
-		const call = spec.buildCall({ path: PATH }, row({ path: PATH }, { argsComplete: false }));
-		expect(call.title).toBe("write");
-	});
-
-	test("complete args put the shortened path on the call line", () => {
-		const call = spec.buildCall({ path: PATH }, row({ path: PATH }));
-		expect(call.title).toBe("write: src/app.ts");
-	});
-});
-
-describe("write spec — golden row (AC-1)", () => {
-	test("collapsed line shows path and args-derived counts", () => {
-		const out = spec.project(written({ path: PATH, content: CONTENT }), COLLAPSED, PLAIN);
-		expect(out).toBe("✎ src/app.ts (2 lines · 17 bytes)");
-		expect(out.split("\n")).toHaveLength(1);
-	});
-
-	test("expanded body shows the written content", () => {
-		const out = spec.project(written({ path: PATH, content: CONTENT }), EXPANDED, PLAIN);
-		expect(out).toBe("line one\nline two");
-	});
-
-	test("empty content is 0 lines · 0 bytes", () => {
-		const out = spec.project(written({ path: "/repo/src/empty.ts", content: "" }), COLLAPSED, PLAIN);
-		expect(out).toBe("✎ src/empty.ts (0 lines · 0 bytes)");
-	});
-
-	test("a trailing newline is not an extra line", () => {
-		const out = spec.project(written({ path: "/repo/src/one.ts", content: "a\n" }), COLLAPSED, PLAIN);
-		expect(out).toBe("✎ src/one.ts (1 lines · 2 bytes)");
-	});
-});
-
-describe("write spec — error row (AC-2)", () => {
-	test("collapsed line carries the error summary", () => {
-		const model = spec.build(ERROR_RESULT, row({ path: PATH }, { isError: true }));
-		if (model === "unknown") throw new Error("write build returned unknown for an error row");
-		const out = spec.project(model, COLLAPSED, PLAIN);
-		expect(out).toBe("✎ src/app.ts ✗ ENOENT: no such file or directory, open '/repo/src/app.ts'");
-	});
-
-	test("expanded body carries the error text", () => {
-		const model = spec.build(ERROR_RESULT, row({ path: PATH }, { isError: true }));
-		if (model === "unknown") throw new Error("write build returned unknown for an error row");
-		const out = spec.project(model, EXPANDED, PLAIN);
-		expect(out).toBe("ENOENT: no such file or directory, open '/repo/src/app.ts'");
-	});
-});
-
-describe("write spec — paint-only color (AC-5)", () => {
-	test("collapsed and expanded emit only marker escapes", () => {
-		const paint = markerPaint();
-		const model = written({ path: PATH, content: CONTENT });
-		const collapsed = spec.project(model, COLLAPSED, paint);
-		const expanded = spec.project(model, EXPANDED, paint);
-		expect(() => assertNoRealEscapes(collapsed)).not.toThrow();
-		expect(() => assertNoRealEscapes(expanded)).not.toThrow();
-		// Role use is pinned: a bare interpolation (no paint call) would satisfy the escape check alone.
-		expect(collapsed).toContain(paint.title("src/app.ts"));
-		expect(collapsed).toContain(paint.muted("(2 lines · 17 bytes)"));
-		expect(expanded).toContain(paint.output("line one"));
-	});
-});
-
-describe("write spec — no execution ported (AC-3)", () => {
-	test("the source contains no execute, tool-registration or model-facing text", () => {
-		const source = readFileSync(new URL("./write.ts", import.meta.url), "utf8");
-		for (const pattern of [/\bexecute\b/, /registerTool/, /as unknown as/, /\bprompt\b/, /\bToolDefinition\b/]) {
-			expect(source).not.toMatch(pattern);
-		}
-		expect(writeRow.descriptor).toEqual({
-			key: "row.write",
-			name: "Write row",
-			defaultEnabled: true,
-			settings: [],
-		});
-	});
-});

package/themes/themes.test.ts

@@ -1,251 +0,0 @@
-// Fixture provenance — schema: recorded-from @earendil-works/pi-coding-agent@1.0.4
-//   (dist/modes/interactive/theme/theme-schema.json, located with findPackageJSON), read 2026-10-06.
-// Fixture provenance — palettes: recorded-from @shikijs/themes 4.4.3 (dracula-soft, one-dark-pro), read 2026-10-06.
-
-// shape: type predicates + plain functions — trigger #7 (fixed-shape record) narrowed from `unknown`;
-//   a class, enum, namespace, or registry would be ceremony over two data files.
-import { readFileSync } from "node:fs";
-import { findPackageJSON } from "node:module";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, test } from "vitest";
-
-const HOST_PACKAGE = "@earendil-works/pi-coding-agent";
-const SCHEMA_ENTRY = "dist/modes/interactive/theme/theme-schema.json";
-const THEME_FILE_NAMES = ["dracula-soft.json", "one-dark.json"] as const;
-const HEX_COLOR = /^#[0-9a-f]{6}$/;
-const COLOR_FUNCTION = /^ok(lch|hsl)\(/i;
-const EXPORT_TOKENS = ["pageBg", "cardBg", "infoBg"];
-const THINKING_TOKENS = [
-	"thinkingOff",
-	"thinkingMinimal",
-	"thinkingLow",
-	"thinkingMedium",
-	"thinkingHigh",
-	"thinkingXhigh",
-	"thinkingMax",
-];
-const TEXT_BACKGROUND_TOKENS = [
-	"selectedBg",
-	"userMessageBg",
-	"customMessageBg",
-	"toolPendingBg",
-	"toolSuccessBg",
-	"toolErrorBg",
-	"searchMatchBg",
-];
-
-function readJson(path: string): unknown {
-	const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
-	return parsed;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function asRecord(value: unknown, label: string): Record<string, unknown> {
-	if (!isRecord(value)) throw new Error(`${label}: expected an object, got ${typeof value}`);
-	return value;
-}
-
-function asStringArray(value: unknown, label: string): string[] {
-	if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
-		throw new Error(`${label}: expected a string array`);
-	}
-	return value;
-}
-
-function asString(value: unknown, label: string): string {
-	if (typeof value !== "string") throw new Error(`${label}: expected a string, got ${typeof value}`);
-	return value;
-}
-
-const hostPackageJson = findPackageJSON(HOST_PACKAGE, import.meta.url);
-if (hostPackageJson === undefined) {
-	throw new Error(`${HOST_PACKAGE} is not resolvable — the pinned host devDependency supplies theme-schema.json`);
-}
-const schema = asRecord(readJson(join(dirname(hostPackageJson), SCHEMA_ENTRY)), "theme-schema.json");
-const schemaProperties = asRecord(schema.properties, "theme-schema.properties");
-const colorValueSpec = asRecord(
-	asRecord(schema.$defs, "theme-schema.$defs").colorValue,
-	"theme-schema.$defs.colorValue",
-);
-const colorTokens = Object.keys(
-	asRecord(asRecord(schemaProperties.colors, "theme-schema.properties.colors").properties, "colors.properties"),
-);
-const exportTokens = Object.keys(
-	asRecord(asRecord(schemaProperties.export, "theme-schema.properties.export").properties, "export.properties"),
-);
-const requiredTopLevel = asStringArray(schema.required, "theme-schema.required");
-const appearances = asStringArray(
-	asRecord(schemaProperties.appearance, "theme-schema.properties.appearance").enum,
-	"theme-schema.properties.appearance.enum",
-);
-const colorValueBranches = (Array.isArray(colorValueSpec.oneOf) ? colorValueSpec.oneOf : []).map((branch, index) =>
-	asRecord(branch, `theme-schema.$defs.colorValue.oneOf[${index}]`),
-);
-
-/** Spec: theme-schema.json $defs.colorValue — a string (#RGB/#RRGGBB, OKLCH, OKHSL, var name, ""), or a 0-255 index. */
-function isColorValue(value: unknown): boolean {
-	return colorValueBranches.some((branch) => {
-		if (branch.type === "string") return typeof value === "string";
-		if (branch.type !== "integer" || typeof value !== "number" || !Number.isInteger(value)) return false;
-		const minimum = typeof branch.minimum === "number" ? branch.minimum : Number.NEGATIVE_INFINITY;
-		const maximum = typeof branch.maximum === "number" ? branch.maximum : Number.POSITIVE_INFINITY;
-		return value >= minimum && value <= maximum;
-	});
-}
-
-interface Theme {
-	readonly label: string;
-	readonly doc: Record<string, unknown>;
-	readonly colors: Record<string, unknown>;
-	readonly vars: Record<string, unknown>;
-}
-
-function readTheme(file: string): Theme {
-	const doc = asRecord(readJson(fileURLToPath(new URL(file, import.meta.url))), file);
-	return {
-		label: file,
-		doc,
-		colors: asRecord(doc.colors, `${file}.colors`),
-		vars: doc.vars === undefined ? {} : asRecord(doc.vars, `${file}.vars`),
-	};
-}
-
-/** Host literal grammar (theme.js resolveVarRefs): "#…", "", a palette index, okhsl()/oklch() — anything else names a var. */
-function resolveColor(theme: Theme, value: unknown): unknown {
-	if (typeof value === "string" && value !== "" && !value.startsWith("#") && !COLOR_FUNCTION.test(value)) {
-		return theme.vars[value];
-	}
-	return value;
-}
-
-function hexOf(theme: Theme, value: unknown, label: string): string {
-	const resolved = resolveColor(theme, value);
-	if (typeof resolved !== "string" || !HEX_COLOR.test(resolved)) {
-		throw new Error(`${theme.label}.${label}: expected a #rrggbb color, got ${JSON.stringify(resolved)}`);
-	}
-	return resolved;
-}
-
-function exportColor(theme: Theme, key: string): unknown {
-	return asRecord(theme.doc.export, `${theme.label}.export`)[key];
-}
-
-function relativeLuminance(hex: string): number {
-	const rgb = Number.parseInt(hex.slice(1), 16);
-	const channel = (byte: number): number => {
-		const ratio = byte / 255;
-		return ratio <= 0.04045 ? ratio / 12.92 : ((ratio + 0.055) / 1.055) ** 2.4;
-	};
-	return 0.2126 * channel((rgb >> 16) & 0xff) + 0.7152 * channel((rgb >> 8) & 0xff) + 0.0722 * channel(rgb & 0xff);
-}
-
-function contrastRatio(a: string, b: string): number {
-	const lighter = Math.max(relativeLuminance(a), relativeLuminance(b));
-	const darker = Math.min(relativeLuminance(a), relativeLuminance(b));
-	return (lighter + 0.05) / (darker + 0.05);
-}
-
-describe("host theme definitions", () => {
-	for (const theme of THEME_FILE_NAMES.map(readTheme)) {
-		test(`${theme.label} validates against the host theme schema`, () => {
-			// spec: schema requires {name, colors}; name matches ^[^/]+$; appearance ∈ {dark, light}; no key outside
-			//   properties; colors carries the schema's own 56 token names, each a $defs.colorValue.
-			// fails_when: the host would reject the file — a missing/extra/mistyped token, an unknown key, a bad name or appearance.
-			for (const key of requiredTopLevel) {
-				expect(Object.hasOwn(theme.doc, key), `missing top-level "${key}"`).toBe(true);
-			}
-			const schemaTopLevel = new Set(Object.keys(schemaProperties));
-			expect(Object.keys(theme.doc).filter((key) => !schemaTopLevel.has(key))).toEqual([]);
-			expect(asString(theme.doc.name, "name")).not.toContain("/");
-			expect(appearances).toContain(theme.doc.appearance);
-
-			expect(colorTokens).toHaveLength(56);
-			expect(Object.keys(theme.colors).sort()).toEqual([...colorTokens].sort());
-			for (const token of colorTokens) {
-				expect(isColorValue(theme.colors[token]), `${theme.label}.colors.${token}`).toBe(true);
-			}
-			for (const [name, value] of Object.entries(theme.vars)) {
-				expect(isColorValue(value), `${theme.label}.vars.${name}`).toBe(true);
-			}
-			const exportSection = Object.entries(asRecord(theme.doc.export, `${theme.label}.export`));
-			expect(exportSection.map(([key]) => key).filter((key) => !exportTokens.includes(key))).toEqual([]);
-			for (const [key, value] of exportSection) {
-				expect(isColorValue(value), `${theme.label}.export.${key}`).toBe(true);
-			}
-		});
-
-		test(`${theme.label} resolves every color through its vars`, () => {
-			// spec: each value is a form the host parses (#rrggbb / "" / 0-255 / okhsl|oklch) or the name of a declared var;
-			//   the host throws "Variable reference not found" for an undeclared name.
-			// fails_when: a token or export color names a var that does not exist.
-			for (const token of colorTokens) {
-				hexOf(theme, theme.colors[token], token);
-			}
-			for (const token of EXPORT_TOKENS) {
-				hexOf(theme, exportColor(theme, token), `export.${token}`);
-			}
-			const referenced = new Set<string>();
-			const collect = (value: unknown): void => {
-				if (typeof value === "string" && value !== "" && !value.startsWith("#") && !COLOR_FUNCTION.test(value)) {
-					referenced.add(value);
-					expect(Object.hasOwn(theme.vars, value), `undeclared var "${value}"`).toBe(true);
-				}
-			};
-			for (const token of colorTokens) collect(theme.colors[token]);
-			for (const token of EXPORT_TOKENS) collect(exportColor(theme, token));
-			expect(Object.keys(theme.vars).filter((name) => !referenced.has(name))).toEqual([]);
-		});
-
-		test(`${theme.label} is dark with readable text on every background`, () => {
-			// spec: export.pageBg is the page the theme assumes; text > muted > dim in contrast against it, and text stays
-			//   legible on every *Bg token the renderer draws content over.
-			// fails_when: a light page background, or a foreground that vanishes against the page or a message/tool background.
-			const page = hexOf(theme, exportColor(theme, "pageBg"), "export.pageBg");
-			expect(relativeLuminance(page)).toBeLessThan(0.1);
-
-			const text = hexOf(theme, theme.colors.text, "text");
-			const onPage = contrastRatio(text, page);
-			const onMuted = contrastRatio(hexOf(theme, theme.colors.muted, "muted"), page);
-			const onDim = contrastRatio(hexOf(theme, theme.colors.dim, "dim"), page);
-			expect(onPage).toBeGreaterThanOrEqual(4.5);
-			expect(onMuted).toBeGreaterThanOrEqual(3);
-			expect(onDim).toBeGreaterThanOrEqual(1.5);
-			expect(onPage).toBeGreaterThan(onMuted);
-			expect(onMuted).toBeGreaterThan(onDim);
-
-			for (const token of TEXT_BACKGROUND_TOKENS) {
-				const background = hexOf(theme, theme.colors[token], token);
-				expect(contrastRatio(text, background), `text on ${token}`).toBeGreaterThanOrEqual(3);
-			}
-		});
-
-		test(`${theme.label} steps its thinking tiers monotonically`, () => {
-			// spec: the renderer maps thinking level to a border color; off → max must read brighter tier by tier.
-			// fails_when: a lower tier renders brighter than a higher one, two tiers collapse to one color, or the ladder
-			//   fails to span the range.
-			const tierColors = THINKING_TOKENS.map((token) => hexOf(theme, theme.colors[token], token));
-			expect(new Set(tierColors).size).toBe(THINKING_TOKENS.length);
-			const luminances = tierColors.map(relativeLuminance);
-			const steps = luminances.slice(1).map((luminance, index) => luminance - (luminances[index] ?? 0));
-			expect(steps.every((step) => step > 0)).toBe(true);
-			expect(Math.max(...luminances) - Math.min(...luminances)).toBeGreaterThan(0.2);
-		});
-	}
-
-	test("the two themes are distinct dark palettes", () => {
-		// spec: dracula-soft and one-dark are independent community palettes — no shared token value, different page background.
-		// fails_when: one file is a copy of the other, so the theme list ships the same look twice.
-		const first = readTheme("dracula-soft.json");
-		const second = readTheme("one-dark.json");
-		const shared = colorTokens.filter(
-			(token) => hexOf(first, first.colors[token], token) === hexOf(second, second.colors[token], token),
-		);
-		expect(shared).toEqual([]);
-		expect(first.doc.appearance).toBe(second.doc.appearance);
-		expect(exportColor(first, "pageBg")).not.toBe(exportColor(second, "pageBg"));
-	});
-});