@pi-archimedes/core 2.0.1 → 2.2.0

package/src/thinking/patch.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+// Symbols used by patch.ts to mark patched prototypes
+const PATCHED_KEY = Symbol.for("archimedes:thinkingPatched");
+const PATCH_VERSION_KEY = Symbol.for("archimedes:thinkingPatchVersion");
+
+// Dynamic import after mocking the pi-coding-agent module
+async function importPatch() {
+	vi.resetModules();
+	const mod = await import("./patch.js");
+	return mod.patchThinkingRenderer;
+}
+
+describe("patchThinkingRenderer", () => {
+	afterEach(() => {
+		vi.resetModules();
+	});
+
+	it("returns early when AssistantMessageComponent is undefined", async () => {
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: undefined,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		// Should not throw
+		patch(() => ({} as any));
+	});
+
+	it("returns early when prototype is null", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype = null;
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+		// Prototype must still be null — no patching occurred
+		expect(MockClass.prototype).toBeNull();
+	});
+
+	it("returns early when updateContent is not a function", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = "not a function";
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+		// PATCHED_KEY must NOT be set — early return before patching
+		expect(MockClass.prototype[PATCHED_KEY]).toBeUndefined();
+	});
+
+	it("returns early when class name does not match", async () => {
+		const WrongName = function () {};
+		WrongName.prototype.updateContent = function () {};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: WrongName,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+		// PATCHED_KEY must NOT be set — name mismatch causes early return
+		expect(WrongName.prototype[PATCHED_KEY]).toBeUndefined();
+	});
+
+	it("returns early when source lacks thinking check", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			// Does NOT contain: content.type === "thinking"
+			this.doSomething();
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+		// PATCHED_KEY must NOT be set — signature mismatch causes early return
+		expect(MockClass.prototype[PATCHED_KEY]).toBeUndefined();
+	});
+
+	it("returns early when source lacks markdownTheme reference", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			// Has thinking check but no markdownTheme
+			if (this.content.type === "thinking") {
+				this.render();
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+		// PATCHED_KEY must NOT be set — signature mismatch causes early return
+		expect(MockClass.prototype[PATCHED_KEY]).toBeUndefined();
+	});
+
+	it("patches successfully when signature matches", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			if (this.content.type === "thinking") {
+				this.markdownTheme.codeBlockIndent = "";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+
+		// The prototype should be marked as patched
+		expect(MockClass.prototype[PATCHED_KEY]).toBe(true);
+		expect(MockClass.prototype[PATCH_VERSION_KEY]).toBe("1.0.0");
+	});
+
+	it("marks prototype with correct version", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			if (this.content.type === "thinking") {
+				this.markdownTheme.codeBlockIndent = "";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "2.5.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+
+		expect(MockClass.prototype[PATCH_VERSION_KEY]).toBe("2.5.0");
+	});
+
+	it("re-patches when version changes", async () => {
+		// First patch with version 1.0.0
+		const MockClassV1 = function AssistantMessageComponent() {};
+		MockClassV1.prototype.updateContent = function updateContent() {
+			if (this.content.type === "thinking") {
+				this.markdownTheme.codeBlockIndent = "";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClassV1,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patchV1 = await importPatch();
+		patchV1(() => ({} as any));
+		expect(MockClassV1.prototype[PATCH_VERSION_KEY]).toBe("1.0.0");
+
+		// Now simulate a version change with a fresh class
+		const MockClassV2 = function AssistantMessageComponent() {};
+		MockClassV2.prototype.updateContent = function updateContent() {
+			if (this.content.type === "thinking") {
+				this.markdownTheme.codeBlockIndent = "";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClassV2,
+			VERSION: "2.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patchV2 = await importPatch();
+		patchV2(() => ({} as any));
+		expect(MockClassV2.prototype[PATCH_VERSION_KEY]).toBe("2.0.0");
+	});
+
+	it("re-patches on same version to update getTheme closure", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			if (this.content.type === "thinking") {
+				this.markdownTheme.codeBlockIndent = "";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+
+		// First patch
+		patch(() => ({} as any));
+		expect(MockClass.prototype[PATCHED_KEY]).toBe(true);
+		const first = MockClass.prototype.updateContent;
+
+		// Second patch (same version) — must produce a new function
+		patch(() => ({} as any));
+		expect(MockClass.prototype[PATCHED_KEY]).toBe(true);
+		expect(MockClass.prototype[PATCH_VERSION_KEY]).toBe("1.0.0");
+		// The patched function must be a new closure (not the same reference)
+		expect(MockClass.prototype.updateContent).not.toBe(first);
+	});
+});

package/src/thinking/theme.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { dimAnsiLine, buildMutedMarkdownTheme } from "./theme.js";
+import { stripAnsi } from "../text.js";
+
+// ── dimAnsiLine ──────────────────────────────────────────────────────────────
+
+describe("dimAnsiLine", () => {
+	const makeCache = () => new Map<string, string>();
+
+	it("dims a single truecolor fg escape", () => {
+		const cache = makeCache();
+		const input = "\x1b[38;2;255;128;64mhello";
+		const result = dimAnsiLine(input, 0.4, 0.5, cache);
+		// Output should still be a truecolor fg escape (38;2;...)
+		expect(result).toMatch(/\x1b\[38;2;\d+;\d+;\d+mhello/);
+		// But the color should be different (dimmed)
+		expect(result).not.toBe(input);
+	});
+
+	it("dims multiple fg escapes in one line", () => {
+		const cache = makeCache();
+		const input = "\x1b[38;2;255;0;0mred\x1b[38;2;0;0;255mblue";
+		const result = dimAnsiLine(input, 0.4, 0.5, cache);
+		// Both escapes should be rewritten to dimmed versions
+		expect(result).not.toContain("\x1b[38;2;255;0;0m");
+		expect(result).not.toContain("\x1b[38;2;0;0;255m");
+		// Text content preserved
+		expect(stripAnsi(result)).toBe("redblue");
+	});
+
+	it("leaves lines with no fg escapes unchanged", () => {
+		const cache = makeCache();
+		const input = "plain text without escapes";
+		const result = dimAnsiLine(input, 0.4, 0.5, cache);
+		expect(result).toBe(input);
+	});
+
+	it("preserves non-fg escapes (bold, italic, reset)", () => {
+		const cache = makeCache();
+		const input = "\x1b[1mbold\x1b[0m \x1b[3mitalic\x1b[23m";
+		const result = dimAnsiLine(input, 0.4, 0.5, cache);
+		expect(result).toContain("\x1b[1m");
+		expect(result).toContain("\x1b[0m");
+		expect(result).toContain("\x1b[3m");
+		expect(result).toContain("\x1b[23m");
+	});
+
+	it("cache hit returns same result", () => {
+		const cache = makeCache();
+		const escape = "\x1b[38;2;200;100;50m";
+		const input = `${escape}text`;
+		const first = dimAnsiLine(input, 0.4, 0.5, cache);
+		const second = dimAnsiLine(input, 0.4, 0.5, cache);
+		expect(first).toBe(second);
+		// Cache should have the entry
+		expect(cache.has(escape)).toBe(true);
+	});
+
+	it("passes through unrecognized escapes unchanged", () => {
+		const cache = makeCache();
+		// A bg escape (48;2;...) should not be matched by FG_COLOR_ESCAPE_RE
+		const input = "\x1b[48;2;10;10;10mbg text";
+		const result = dimAnsiLine(input, 0.4, 0.5, cache);
+		expect(result).toBe(input);
+	});
+
+	it("dims 256-palette fg escapes to truecolor", () => {
+		const cache = makeCache();
+		const input = "\x1b[38;5;196mred"; // 256-palette red
+		const result = dimAnsiLine(input, 0.4, 0.5, cache);
+		// Output should be truecolor (38;2;...), not 256-palette
+		expect(result).toMatch(/\x1b\[38;2;\d+;\d+;\d+mred/);
+		expect(result).not.toContain("\x1b[38;5;");
+	});
+
+	it("handles empty string", () => {
+		const cache = makeCache();
+		expect(dimAnsiLine("", 0.4, 0.5, cache)).toBe("");
+	});
+
+	it("property: preserves non-ANSI text content", () => {
+		fc.assert(
+			fc.property(
+				fc.string({ maxLength: 200 }),
+				(s) => {
+					const cache = makeCache();
+					const result = dimAnsiLine(s, 0.4, 0.5, cache);
+					return stripAnsi(s) === stripAnsi(result);
+				},
+			),
+		);
+	});
+
+	it("property: never introduces 38;5; escapes (only produces truecolor 38;2;)", () => {
+		fc.assert(
+			fc.property(
+				fc.string({ maxLength: 200 }),
+				(s) => {
+					const cache = makeCache();
+					const result = dimAnsiLine(s, 0.4, 0.5, cache);
+					// Any 38;5; in output must have been in the input
+					// (dimAnsiLine only produces 38;2; output)
+					const inputHas256 = s.includes("38;5;");
+					const outputHas256 = result.includes("38;5;");
+					// If input didn't have 38;5;, output shouldn't either
+					// (because we only dim via truecolor)
+					if (!inputHas256) {
+						return !outputHas256;
+					}
+					// If input had 38;5;, they get replaced with 38;2;
+					// So output should NOT have 38;5; either
+					return !outputHas256;
+				},
+			),
+		);
+	});
+});
+
+// ── buildMutedMarkdownTheme ──────────────────────────────────────────────────
+
+describe("buildMutedMarkdownTheme", () => {
+	const mockTheme = {
+		fg: (token: string, text: string) => `\x1b[38;2;180;180;180m${text}\x1b[0m`,
+		getFgAnsi: (token: string) => "\x1b[38;2;180;180;180m",
+		italic: (text: string) => `\x1b[3m${text}\x1b[23m`,
+	};
+
+	it("returns MarkdownTheme with all required fields", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		expect(typeof theme.codeBlockIndent).toBe("string");
+		expect(typeof theme.heading).toBe("function");
+		expect(typeof theme.link).toBe("function");
+		expect(typeof theme.linkUrl).toBe("function");
+		expect(typeof theme.code).toBe("function");
+		expect(typeof theme.codeBlock).toBe("function");
+		expect(typeof theme.codeBlockBorder).toBe("function");
+		expect(typeof theme.quote).toBe("function");
+		expect(typeof theme.quoteBorder).toBe("function");
+		expect(typeof theme.hr).toBe("function");
+		expect(typeof theme.listBullet).toBe("function");
+		expect(typeof theme.bold).toBe("function");
+		expect(typeof theme.italic).toBe("function");
+		expect(typeof theme.strikethrough).toBe("function");
+		expect(typeof theme.underline).toBe("function");
+		expect(typeof theme.highlightCode).toBe("function");
+	});
+
+	it("heading uses gold color (#FFD700)", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		const result = theme.heading("Title");
+		// Gold is #FFD700 = rgb(255, 215, 0)
+		expect(result).toContain("\x1b[38;2;255;215;0m");
+		expect(result).toContain("Title");
+	});
+
+	it("bold uses gold color (#FFD700)", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		const result = theme.bold("Strong");
+		expect(result).toContain("\x1b[38;2;255;215;0m");
+		expect(result).toContain("Strong");
+	});
+
+	it("codeBlock uses thinkingText", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		const result = theme.codeBlock("code here");
+		expect(result).toContain("code here");
+	});
+
+	it("italic wraps with ANSI italic codes", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		const result = theme.italic("slanted");
+		expect(result).toContain("\x1b[3m");
+		expect(result).toContain("\x1b[23m");
+		expect(result).toContain("slanted");
+	});
+
+	it("codeBlockIndent is empty string", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		expect(theme.codeBlockIndent).toBe("");
+	});
+
+	it("highlightCode returns array of strings", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		const result = theme.highlightCode!("const x = 1;", "javascript");
+		expect(Array.isArray(result)).toBe(true);
+		expect(result.length).toBeGreaterThan(0);
+	});
+
+	it("highlightCode dims ANSI escapes in output", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any);
+		const result = theme.highlightCode!("const x = 1;", "javascript");
+		// Output should contain dimmed truecolor escapes
+		const joined = result.join("\n");
+		expect(joined).toMatch(/\x1b\[38;2;\d+;\d+;\d+m/);
+	});
+
+	it("different saturationFactor produces different dimmed output", () => {
+		const cache = new Map<string, string>();
+		const input = "\x1b[38;2;255;128;64mhello";
+		const resultLow = dimAnsiLine(input, 0.4, 0.3, cache);
+		const cache2 = new Map<string, string>();
+		const resultHigh = dimAnsiLine(input, 0.4, 0.7, cache2);
+		// Same input with different saturation factors must produce different escapes
+		expect(resultLow).not.toBe(resultHigh);
+		// Both must still be valid truecolor fg escapes
+		expect(resultLow).toMatch(/\x1b\[38;2;\d+;\d+;\d+mhello/);
+		expect(resultHigh).toMatch(/\x1b\[38;2;\d+;\d+;\d+mhello/);
+	});
+
+	it("accepts custom codeDefaultLightness", () => {
+		const theme = buildMutedMarkdownTheme(mockTheme as any, { codeDefaultLightness: 0.9 });
+		const result = theme.highlightCode!("test", "plaintext");
+		expect(Array.isArray(result)).toBe(true);
+	});
+});

package/src/thinking/transform.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from "vitest";
+import { transformThinkingContent } from "./transform.js";
+
+describe("transformThinkingContent", () => {
+  it("modifies thinking content on assistant messages", () => {
+    const message = {
+      role: "assistant" as const,
+      content: [
+        { type: "thinking" as const, thinking: "  some thinking  " },
+      ],
+    };
+    transformThinkingContent(message);
+    expect(message.content[0]!.thinking).toBe("some thinking");
+  });
+
+  it("skips non-assistant messages", () => {
+    const message = {
+      role: "user" as const,
+      content: [
+        { type: "thinking" as const, thinking: "  should not change  " },
+      ],
+    };
+    transformThinkingContent(message);
+    expect(message.content[0]!.thinking).toBe("  should not change  ");
+  });
+
+  it("skips empty thinking", () => {
+    const message = {
+      role: "assistant" as const,
+      content: [
+        { type: "thinking" as const, thinking: "   " },
+      ],
+    };
+    transformThinkingContent(message);
+    expect(message.content[0]!.thinking).toBe("   ");
+  });
+
+  it("skips thinking with undefined value", () => {
+    const message = {
+      role: "assistant" as const,
+      content: [
+        { type: "thinking" as const } as { type: string; thinking?: string },
+      ],
+    };
+    transformThinkingContent(message);
+    expect(message.content[0]!.thinking).toBeUndefined();
+  });
+
+  it("calls unindentCodeBlocks on thinking content", () => {
+    const message = {
+      role: "assistant" as const,
+      content: [
+        {
+          type: "thinking" as const,
+          thinking: "```\n    indented code\n    more code\n```",
+        },
+      ],
+    };
+    transformThinkingContent(message);
+    expect(message.content[0]!.thinking).toBe("```\nindented code\nmore code\n```");
+  });
+
+  it("handles mixed content types", () => {
+    const message = {
+      role: "assistant" as const,
+      content: [
+        { type: "text" as const, text: "some text" },
+        { type: "thinking" as const, thinking: "  thinking content  " },
+        { type: "text" as const, text: "more text" },
+      ],
+    };
+    transformThinkingContent(message);
+    expect(message.content[0]).toEqual({ type: "text", text: "some text" });
+    expect(message.content[1]!.thinking).toBe("thinking content");
+    expect(message.content[2]).toEqual({ type: "text", text: "more text" });
+  });
+
+  it("after transform, thinking is trimmed", () => {
+    const message = {
+      role: "assistant" as const,
+      content: [
+        { type: "thinking" as const, thinking: "  hello world  " },
+      ],
+    };
+    transformThinkingContent(message);
+    const thinking = message.content[0]!.thinking;
+    expect(thinking).toBe(thinking?.trim());
+  });
+});

package/src/thinking/unindent.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { unindentCodeBlocks } from "./unindent.js";
+
+describe("unindentCodeBlocks", () => {
+  it("strips common leading whitespace from fenced code blocks", () => {
+    const input = "```\n    line1\n    line2\n```";
+    expect(unindentCodeBlocks(input)).toBe("```\nline1\nline2\n```");
+  });
+
+  it("preserves empty lines structure", () => {
+    const input = "```\n    line1\n\n    line2\n```";
+    expect(unindentCodeBlocks(input)).toBe("```\nline1\n\nline2\n```");
+  });
+
+  it("leaves whitespace-only blocks untouched", () => {
+    const input = "```\n    \n    \n```";
+    expect(unindentCodeBlocks(input)).toBe("```\n    \n    \n```");
+  });
+
+  it("handles CRLF → LF normalization", () => {
+    const input = "```\r\n    line1\r\n    line2\r\n```";
+    expect(unindentCodeBlocks(input)).toBe("```\nline1\nline2\n```");
+  });
+
+  it("handles blocks with 0 indent on some lines (no stripping)", () => {
+    const input = "```\n    indented\nnotindented\n    indented\n```";
+    expect(unindentCodeBlocks(input)).toBe("```\n    indented\nnotindented\n    indented\n```");
+  });
+
+  it("strips trailing empty lines from code blocks", () => {
+    const input = "```\n    line1\n    line2\n\n\n```";
+    expect(unindentCodeBlocks(input)).toBe("```\nline1\nline2\n```");
+  });
+
+  it("handles language tags", () => {
+    const input = "```python\n    def foo():\n        pass\n```";
+    expect(unindentCodeBlocks(input)).toBe("```python\ndef foo():\n    pass\n```");
+  });
+
+  it("leaves text outside code blocks unchanged", () => {
+    const input = "Some text\n```\n    code\n```\nMore text";
+    expect(unindentCodeBlocks(input)).toBe("Some text\n```\ncode\n```\nMore text");
+  });
+
+  it("handles multiple code blocks", () => {
+    const input = "```\n    block1\n```\n```\n    block2\n```";
+    expect(unindentCodeBlocks(input)).toBe("```\nblock1\n```\n```\nblock2\n```");
+  });
+
+  it("handles empty code blocks with content", () => {
+    const input = "```\n```";
+    expect(unindentCodeBlocks(input)).toBe("```\n```");
+  });
+
+  it("property: idempotence — unindentCodeBlocks(unindentCodeBlocks(x)) === unindentCodeBlocks(x)", () => {
+    fc.assert(
+      fc.property(fc.string({ maxLength: 500 }), (s) => {
+        const once = unindentCodeBlocks(s);
+        const twice = unindentCodeBlocks(once);
+        return once === twice;
+      }),
+    );
+  });
+
+  it("property: output never contains CRLF (\\r\\n)", () => {
+    fc.assert(
+      fc.property(fc.string({ maxLength: 500 }), (s) => {
+        const result = unindentCodeBlocks(s);
+        return !result.includes("\r\n");
+      }),
+    );
+  });
+});