@pi-archimedes/core 2.0.1 → 2.2.0

package/src/startup/logo.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fc from "fast-check";
+import { stripAnsi } from "../text.js";
+
+// ── Helpers for dynamic imports with controlled TRUECOLOR ────────────────────
+
+async function importLogoWithTruecolor(truecolor: boolean) {
+	vi.resetModules();
+
+	// Set env before the module loads
+	const origColorterm = process.env.COLORTERM;
+	const origTerm = process.env.TERM;
+	const origTermProgram = process.env.TERM_PROGRAM;
+	const origWtSession = process.env.WT_SESSION;
+
+	if (truecolor) {
+		process.env.COLORTERM = "truecolor";
+	} else {
+		delete process.env.COLORTERM;
+		process.env.TERM = "xterm";
+		delete process.env.TERM_PROGRAM;
+		delete process.env.WT_SESSION;
+	}
+
+	const mod = await import("./logo.js");
+
+	// Restore env
+	if (origColorterm === undefined) delete process.env.COLORTERM;
+	else process.env.COLORTERM = origColorterm;
+	if (origTerm === undefined) delete process.env.TERM;
+	else process.env.TERM = origTerm;
+	if (origTermProgram === undefined) delete process.env.TERM_PROGRAM;
+	else process.env.TERM_PROGRAM = origTermProgram;
+	if (origWtSession === undefined) delete process.env.WT_SESSION;
+	else process.env.WT_SESSION = origWtSession;
+
+	return mod;
+}
+
+// ── LOGO structure (static, no env dependency) ──────────────────────────────
+
+describe("LOGO structure", () => {
+	it("has 8 rows", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO.length).toBe(8);
+	});
+
+	it("each row has 16 characters", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		for (const row of mod.LOGO) {
+			expect(row.length).toBe(16);
+		}
+	});
+
+	it("first row is 12 blocks + 4 spaces", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO[0]).toBe("████████████    ");
+	});
+
+	it("last row is 4 blocks + 6 spaces + 4 blocks", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO[7]).toBe("████        ████");
+	});
+
+	it("LOGO contains only block chars and spaces", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		for (const row of mod.LOGO) {
+			for (const ch of row) {
+				expect(ch === " " || ch === "█").toBe(true);
+			}
+		}
+	});
+});
+
+// ── Animation constants ──────────────────────────────────────────────────────
+
+describe("animation constants", () => {
+	it("CHAR_FADE_FRAMES is 22", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.CHAR_FADE_FRAMES).toBe(22);
+	});
+
+	it("LOGO_SETTLE_FRAME is 90", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO_SETTLE_FRAME).toBe(90);
+	});
+
+	it("LOGO_PAD is 0", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO_PAD).toBe(0);
+	});
+
+	it("LOGO_GAP is 4", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO_GAP).toBe(4);
+	});
+});
+
+// ── TRUECOLOR detection ──────────────────────────────────────────────────────
+
+describe("TRUECOLOR", () => {
+	it("is true when COLORTERM contains truecolor", async () => {
+		const mod = await importLogoWithTruecolor(true);
+		expect(mod.TRUECOLOR).toBe(true);
+	});
+
+	it("is false when no truecolor env vars set", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.TRUECOLOR).toBe(false);
+	});
+});
+
+// ── getShinedLogo — non-truecolor ────────────────────────────────────────────
+
+describe("getShinedLogo (non-truecolor)", () => {
+	let mod: typeof import("./logo.js");
+
+	beforeEach(async () => {
+		mod = await importLogoWithTruecolor(false);
+	});
+
+	it("returns LOGO unchanged when TRUECOLOR is false", () => {
+		const result = mod.getShinedLogo(0, "wave");
+		expect(result).toBe(mod.LOGO);
+	});
+
+	it("returns LOGO at any frame when TRUECOLOR is false", () => {
+		expect(mod.getShinedLogo(999, "wave")).toBe(mod.LOGO);
+	});
+
+	it("returns 8 rows regardless of frame", () => {
+		expect(mod.getShinedLogo(50, "diagonal").length).toBe(8);
+	});
+});
+
+// ── getShinedLogo — truecolor ────────────────────────────────────────────────
+
+describe("getShinedLogo (truecolor)", () => {
+	let mod: typeof import("./logo.js");
+
+	beforeEach(async () => {
+		mod = await importLogoWithTruecolor(true);
+	});
+
+	it("returns 8 rows", () => {
+		expect(mod.getShinedLogo(0, "wave").length).toBe(8);
+	});
+
+	it("returns different output than LOGO when TRUECOLOR is true", () => {
+		const result = mod.getShinedLogo(50, "wave");
+		expect(result).not.toBe(mod.LOGO);
+	});
+
+	it("early frames show spaces for not-yet-revealed chars", () => {
+		const result = mod.getShinedLogo(0, "vertical");
+		// At frame 0, nothing should be revealed yet
+		for (const row of result) {
+			const stripped = stripAnsi(row);
+			expect(stripped).toMatch(/^[\s]*$/);
+		}
+	});
+
+	it("late frames show all characters revealed", () => {
+		const result = mod.getShinedLogo(200, "vertical");
+		for (let i = 0; i < result.length; i++) {
+			const stripped = stripAnsi(result[i]!);
+			const expected = stripAnsi(mod.LOGO[i]!);
+			expect(stripped).toBe(expected);
+		}
+	});
+
+	it("output contains ANSI gray escapes", () => {
+		const result = mod.getShinedLogo(50, "wave");
+		const joined = result.join("\n");
+		expect(joined).toMatch(/\x1b\[38;2;\d+;\d+;\d+m/);
+	});
+
+	it("default style is wave", () => {
+		const result1 = mod.getShinedLogo(50);
+		const result2 = mod.getShinedLogo(50, "wave");
+		expect(result1).toEqual(result2);
+	});
+});
+
+// ── All animation styles ─────────────────────────────────────────────────────
+
+describe("animation styles", () => {
+	const styles = [
+		"diagonal",
+		"top-right",
+		"bottom-left",
+		"bottom-right",
+		"center-out",
+		"wave",
+		"horizontal",
+		"vertical",
+		"vertical-up",
+	] as const;
+
+	it.each(styles)("style '%s' produces valid reveal times", async (style) => {
+		const mod = await importLogoWithTruecolor(true);
+		const result = mod.getShinedLogo(100, style);
+		expect(result.length).toBe(8);
+		// Each row should be a string
+		for (const row of result) {
+			expect(typeof row).toBe("string");
+		}
+	});
+
+	it.each(styles)("style '%s' fully reveals at high frame count", async (style) => {
+		const mod = await importLogoWithTruecolor(true);
+		const result = mod.getShinedLogo(500, style);
+		for (let i = 0; i < result.length; i++) {
+			const stripped = stripAnsi(result[i]!);
+			const expected = stripAnsi(mod.LOGO[i]!);
+			expect(stripped).toBe(expected);
+		}
+	});
+});
+
+// ── Properties ───────────────────────────────────────────────────────────────
+
+describe("properties", () => {
+	it("getShinedLogo always returns 8 rows (truecolor)", async () => {
+		const mod = await importLogoWithTruecolor(true);
+		fc.assert(
+			fc.property(fc.nat(1000), n => {
+				return mod.getShinedLogo(n, "wave").length === 8;
+			}),
+		);
+	});
+
+	it("each row visible width equals 16 after stripping ANSI (truecolor)", async () => {
+		const mod = await importLogoWithTruecolor(true);
+		fc.assert(
+			fc.property(fc.nat(500), n => {
+				const result = mod.getShinedLogo(n, "diagonal");
+				for (const row of result) {
+					const stripped = stripAnsi(row);
+					// stripAnsi trims, so we check the raw row length instead
+					// The actual row length (including ANSI) may vary, but the
+					// visible content should always be 16 chars
+					// Since stripAnsi trims trailing spaces, check untrimmed
+					const raw = row.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "");
+					if (raw.length !== 16) return false;
+				}
+				return true;
+			}),
+		);
+	});
+
+	it("getShinedLogo returns 8 rows (non-truecolor)", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		fc.assert(
+			fc.property(fc.nat(1000), n => {
+				return mod.getShinedLogo(n, "wave").length === 8;
+			}),
+		);
+	});
+});

package/src/startup/sections.test.ts

@@ -0,0 +1,314 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ── Mocks ────────────────────────────────────────────────────────────────────
+
+// Force TRUECOLOR=false so formatColumns output is deterministic across envs
+vi.mock("./logo.js", async (importOriginal) => ({ ...(await importOriginal()), TRUECOLOR: false }));
+
+// Mock pi-tui — visibleWidth and truncateToWidth
+vi.mock("@earendil-works/pi-tui", () => ({
+	visibleWidth: (s: string) => s.length,
+	truncateToWidth: (s: string, w: number) => s.slice(0, w),
+}));
+
+// ── Imports ──────────────────────────────────────────────────────────────────
+
+import {
+	detectSection,
+	parseSectionText,
+	parseModelScope,
+	extractName,
+	formatColumns,
+	buildItemWrapper,
+	SECTION_KEYS,
+	RAMP_FRAMES,
+} from "./sections.js";
+
+// ── detectSection ────────────────────────────────────────────────────────────
+
+describe("detectSection", () => {
+	it("finds Models section key", () => {
+		expect(detectSection("[Models]\nclaude-sonnet")).toBe("Models");
+	});
+
+	it("finds Context section key", () => {
+		expect(detectSection("some text [Context] more")).toBe("Context");
+	});
+
+	it("finds Prompts section key", () => {
+		expect(detectSection("[Prompts]")).toBe("Prompts");
+	});
+
+	it("finds Skills section key", () => {
+		expect(detectSection("Skills: [Skills] list")).toBe("Skills");
+	});
+
+	it("finds Extensions section key", () => {
+		expect(detectSection("[Extensions]\nfoo")).toBe("Extensions");
+	});
+
+	it("finds Themes section key", () => {
+		expect(detectSection("[Themes]\ndark")).toBe("Themes");
+	});
+
+	it("returns undefined for non-section text", () => {
+		expect(detectSection("just some random text")).toBeUndefined();
+	});
+
+	it("returns undefined for empty string", () => {
+		expect(detectSection("")).toBeUndefined();
+	});
+
+	it("returns undefined for bracketed text that is not a section key", () => {
+		expect(detectSection("[NotASection]")).toBeUndefined();
+	});
+
+	it("returns the first matching section key", () => {
+		const text = "[Models]\n[Context]";
+		expect(detectSection(text)).toBe("Models");
+	});
+});
+
+// ── parseSectionText ─────────────────────────────────────────────────────────
+
+describe("parseSectionText", () => {
+	it("extracts items correctly", () => {
+		const text = "[Models]\nclaude-sonnet\ngpt-4";
+		const result = parseSectionText(text);
+		expect(result).not.toBeUndefined();
+		expect(result!.name).toBe("Models");
+		expect(result!.items).toContain("claude-sonnet");
+		expect(result!.items).toContain("gpt-4");
+	});
+
+	it("returns undefined for non-section text", () => {
+		expect(parseSectionText("no section here")).toBeUndefined();
+	});
+
+	it("deduplicates items", () => {
+		const text = "[Models]\nclaude-sonnet\nclaude-sonnet\ngpt-4";
+		const result = parseSectionText(text);
+		expect(result).not.toBeUndefined();
+		const sonnetCount = result!.items.filter(i => i === "claude-sonnet").length;
+		expect(sonnetCount).toBe(1);
+	});
+
+	it("prefers prefixed over bare names", () => {
+		const text = "[Extensions]\nnpm:@foo/bar\n@foo/bar";
+		const result = parseSectionText(text);
+		expect(result).not.toBeUndefined();
+		// Should prefer the prefixed version
+		expect(result!.items.some(i => i.startsWith("npm:"))).toBe(true);
+	});
+
+	it("skips empty lines and bracket lines", () => {
+		const text = "[Themes]\n\ndark\n[Other]\nlight";
+		const result = parseSectionText(text);
+		expect(result).not.toBeUndefined();
+		expect(result!.items).toContain("dark");
+		// "light" is under [Other] which isn't a recognized section,
+		// but since we detected [Themes] first, items under [Other] should be skipped
+	});
+
+	it("handles empty section (no items)", () => {
+		const text = "[Models]";
+		const result = parseSectionText(text);
+		expect(result).not.toBeUndefined();
+		expect(result!.items.length).toBe(0);
+	});
+});
+
+// ── parseModelScope ──────────────────────────────────────────────────────────
+
+describe("parseModelScope", () => {
+	it("extracts model names from 'Model scope:' line", () => {
+		const text = "Model scope: claude-sonnet, gpt-4";
+		const result = parseModelScope(text);
+		expect(result).not.toBeUndefined();
+		expect(result!.name).toBe("Models");
+		expect(result!.items).toContain("claude-sonnet");
+		expect(result!.items).toContain("gpt-4");
+	});
+
+	it("strips keyboard shortcut hints", () => {
+		const text = "Model scope: claude-sonnet (Ctrl+1), gpt-4 (Ctrl+2)";
+		const result = parseModelScope(text);
+		expect(result).not.toBeUndefined();
+		expect(result!.items).toContain("claude-sonnet");
+		expect(result!.items).not.toContain("(Ctrl+1)");
+	});
+
+	it("returns undefined when no Model scope line", () => {
+		expect(parseModelScope("some random text")).toBeUndefined();
+	});
+
+	it("returns undefined for empty items", () => {
+		expect(parseModelScope("Model scope:  ")).toBeUndefined();
+	});
+
+	it("handles single model", () => {
+		const result = parseModelScope("Model scope: only-one");
+		expect(result).not.toBeUndefined();
+		expect(result!.items).toEqual(["only-one"]);
+	});
+});
+
+// ── extractName ──────────────────────────────────────────────────────────────
+
+describe("extractName", () => {
+	it("extracts Models name from path", () => {
+		expect(extractName("/path/to/claude-sonnet", "Models")).toBe("claude-sonnet");
+	});
+
+	it("extracts Themes name from path", () => {
+		expect(extractName("/path/to/dark-theme", "Themes")).toBe("dark-theme");
+	});
+
+	it("extracts Prompts name (strips extension)", () => {
+		expect(extractName("/path/to/my-prompt.ts", "Prompts")).toBe("my-prompt");
+	});
+
+	it("extracts Context name (basename only)", () => {
+		expect(extractName("/path/to/context-file.md", "Context")).toBe("context-file.md");
+	});
+
+	it("extracts Skills name from SKILL.md path", () => {
+		expect(extractName("/path/to/my-skill/SKILL.md", "Skills")).toBe("my-skill");
+	});
+
+	it("extracts Skills name from SKILL.ts path", () => {
+		expect(extractName("/path/to/my-skill/SKILL.ts", "Skills")).toBe("my-skill");
+	});
+
+	it("handles npm: prefix for Extensions", () => {
+		expect(extractName("npm:@foo/bar", "Extensions")).toBe("npm:bar");
+	});
+
+	it("handles git: prefix for Extensions", () => {
+		expect(extractName("git:github.com/user/repo", "Extensions")).toBe("git:repo");
+	});
+
+	it("strips file extensions for Models", () => {
+		expect(extractName("/path/to/model.ts", "Models")).toBe("model");
+	});
+
+	it("handles simple name without path", () => {
+		expect(extractName("simple-name", "Models")).toBe("simple-name");
+	});
+});
+
+// ── formatColumns ────────────────────────────────────────────────────────────
+
+describe("formatColumns", () => {
+	const mockTheme = {
+		fg: (token: string, text: string) => text,
+		getFgAnsi: (token: string) => "",
+	} as any;
+
+	const mockRef = {
+		frame: 100,
+		revealed: true,
+		revealedAt: 0,
+		scaffoldAt: 0,
+		settled: true,
+	};
+
+	it("returns empty array for empty sections", () => {
+		expect(formatColumns([], mockTheme, 80, mockRef)).toEqual([]);
+	});
+
+	it("returns empty array for sections with no items", () => {
+		const sections = [{ name: "Models" as const, items: [] }];
+		expect(formatColumns(sections, mockTheme, 80, mockRef)).toEqual([]);
+	});
+
+	it("formats a single section with items", () => {
+		const sections = [{ name: "Models" as const, items: ["claude-sonnet", "gpt-4"] }];
+		const result = formatColumns(sections, mockTheme, 80, mockRef);
+		expect(result.length).toBeGreaterThan(0);
+		// Should contain the section header
+		expect(result.some(line => line.includes("[Models]"))).toBe(true);
+	});
+
+	it("formats multiple sections", () => {
+		const sections = [
+			{ name: "Models" as const, items: ["claude"] },
+			{ name: "Themes" as const, items: ["dark"] },
+		];
+		const result = formatColumns(sections, mockTheme, 80, mockRef);
+		expect(result.some(line => line.includes("[Models]"))).toBe(true);
+		expect(result.some(line => line.includes("[Themes]"))).toBe(true);
+	});
+
+	it("adds blank line after Version section", () => {
+		const sections = [{ name: "Version" as const, items: ["1.0.0"] }];
+		const result = formatColumns(sections, mockTheme, 80, mockRef);
+		expect(result).toContain("");
+	});
+
+	it("wraps items to new lines when exceeding width", () => {
+		const longItems = Array.from({ length: 20 }, (_, i) => `model-${i}`);
+		const sections = [{ name: "Models" as const, items: longItems }];
+		const result = formatColumns(sections, mockTheme, 40, mockRef);
+		// With narrow width, items should wrap to multiple lines
+		expect(result.length).toBeGreaterThan(1);
+	});
+
+	it("handles unrevealed state", () => {
+		const sections = [{ name: "Models" as const, items: ["test"] }];
+		const unrevealedRef = { ...mockRef, revealed: false };
+		const result = formatColumns(sections, mockTheme, 80, unrevealedRef);
+		expect(result.length).toBeGreaterThan(0);
+	});
+});
+
+// ── buildItemWrapper ─────────────────────────────────────────────────────────
+
+describe("buildItemWrapper", () => {
+	const muted = (t: string) => `\x1b[90m${t}\x1b[0m`;
+
+	it("returns identity function when not revealed", () => {
+		const wrapper = buildItemWrapper(0, false, undefined, undefined, muted);
+		expect(wrapper("hello")).toBe("hello");
+	});
+
+	it("returns muted function when no RGB data", () => {
+		const wrapper = buildItemWrapper(10, true, undefined, undefined, muted);
+		expect(wrapper("hello")).toBe(muted("hello"));
+	});
+
+	it("returns muted function when ramp is complete", () => {
+		const startRgb = [20, 20, 20] as [number, number, number];
+		const mutedRgb = [100, 100, 100] as [number, number, number];
+		const wrapper = buildItemWrapper(RAMP_FRAMES, true, startRgb, mutedRgb, muted);
+		expect(wrapper("hello")).toBe(muted("hello"));
+	});
+
+	it("returns rgb-colored function during ramp", () => {
+		const startRgb = [20, 20, 20] as [number, number, number];
+		const mutedRgb = [200, 200, 200] as [number, number, number];
+		const wrapper = buildItemWrapper(1, true, startRgb, mutedRgb, muted);
+		const result = wrapper("hello");
+		// Should be a truecolor ANSI escape, not the muted fallback
+		expect(result).toMatch(/\x1b\[38;2;\d+;\d+;\d+mhello\x1b\[0m/);
+		expect(result).not.toContain("\x1b[90m");
+	});
+
+	it("lerps colors correctly at midpoint", () => {
+		const startRgb = [0, 0, 0] as [number, number, number];
+		const endRgb = [200, 200, 200] as [number, number, number];
+		// At exactly RAMP_FRAMES / 2, t = 0.5, eased = 0.75
+		const midAge = Math.floor(RAMP_FRAMES / 2);
+		const wrapper = buildItemWrapper(midAge, true, startRgb, endRgb, muted);
+		const result = wrapper("x");
+		// eased = 1 - (1-0.5)^2 = 0.75
+		// lerp(0, 200, 0.75) = 150
+		expect(result).toContain("\x1b[38;2;150;150;150mx\x1b[0m");
+	});
+
+	it("returns muted when mutedRgb is undefined", () => {
+		const startRgb = [20, 20, 20] as [number, number, number];
+		const wrapper = buildItemWrapper(5, true, startRgb, undefined, muted);
+		expect(wrapper("hello")).toBe(muted("hello"));
+	});
+});

package/src/startup/version.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { compareVersions } from "./version.js";
+
+// ── Version generator for property tests ─────────────────────────────────────
+
+const versionArb = fc.tuple(fc.nat(100), fc.nat(100), fc.nat(100)).map(
+	([major, minor, patch]) => `${major}.${minor}.${patch}`,
+);
+
+// ── compareVersions ──────────────────────────────────────────────────────────
+
+describe("compareVersions", () => {
+	it('returns 0 for equal versions', () => {
+		expect(compareVersions("1.0.0", "1.0.0")).toBe(0);
+	});
+
+	it('returns 1 when first version is greater', () => {
+		expect(compareVersions("2.0.0", "1.9.9")).toBe(1);
+	});
+
+	it('returns -1 when second version is greater', () => {
+		expect(compareVersions("1.0.0", "2.0.0")).toBe(-1);
+	});
+
+	it("handles v prefix on first argument", () => {
+		expect(compareVersions("v1.2.3", "1.2.3")).toBe(0);
+	});
+
+	it("handles v prefix on second argument", () => {
+		expect(compareVersions("1.2.3", "v1.2.3")).toBe(0);
+	});
+
+	it("handles v prefix on both arguments", () => {
+		expect(compareVersions("v2.0.0", "v1.0.0")).toBe(1);
+	});
+
+	it("handles partial versions (2 parts vs 3 parts)", () => {
+		expect(compareVersions("1.0", "1.0.0")).toBe(0);
+	});
+
+	it("handles partial versions with difference", () => {
+		expect(compareVersions("1.1", "1.0.5")).toBe(1);
+	});
+
+	it("handles zero-padded versions", () => {
+		expect(compareVersions("01.02.03", "1.2.3")).toBe(0);
+	});
+
+	it("compares minor version correctly", () => {
+		expect(compareVersions("1.2.0", "1.1.9")).toBe(1);
+		expect(compareVersions("1.1.0", "1.2.0")).toBe(-1);
+	});
+
+	it("compares patch version correctly", () => {
+		expect(compareVersions("1.0.5", "1.0.3")).toBe(1);
+		expect(compareVersions("1.0.3", "1.0.5")).toBe(-1);
+	});
+
+	it("handles all-zero versions", () => {
+		expect(compareVersions("0.0.0", "0.0.0")).toBe(0);
+	});
+
+	// ── Property tests ───────────────────────────────────────────────────
+
+	it("property: reflexive — compareVersions(a, a) === 0", () => {
+		fc.assert(
+			fc.property(versionArb, a => {
+				return compareVersions(a, a) === 0;
+			}),
+		);
+	});
+
+	it("property: antisymmetric — compareVersions(a, b) === -compareVersions(b, a)", () => {
+		fc.assert(
+			fc.property(versionArb, versionArb, (a, b) => {
+				return compareVersions(a, b) === -compareVersions(b, a);
+			}),
+		);
+	});
+
+	it("property: transitivity — if a<b and b<c then a<c", () => {
+		fc.assert(
+			fc.property(
+				fc.tuple(versionArb, versionArb, versionArb),
+				([a, b, c]) => {
+					const ab = compareVersions(a, b);
+					const bc = compareVersions(b, c);
+					const ac = compareVersions(a, c);
+					if (ab < 0 && bc < 0) {
+						return ac < 0;
+					}
+					return true;
+				},
+			),
+		);
+	});
+});