@xynogen/pix-pretty 1.6.3 → 1.7.0

package/src/thinking.test.ts

@@ -1,251 +0,0 @@
-/**
- * Tests for leaked-reasoning splitting into native content blocks.
- *
- * splitThinking() turns leaked `<think>`/`<thinking>` spans into real
- * `thinking` content blocks (rendered dim + italic by pi's native
- * `thinkingText` styling) while keeping surrounding answer text as `text`
- * blocks.
- */
-
-import { describe, expect, it } from "bun:test";
-import { splitThinking, stripPartialTailTag } from "./thinking";
-
-type Block = { type: string; text?: string; thinking?: string };
-
-function texts(blocks: Block[]): string[] {
-	return blocks.filter((b) => b.type === "text").map((b) => b.text ?? "");
-}
-function thinkings(blocks: Block[]): string[] {
-	return blocks
-		.filter((b) => b.type === "thinking")
-		.map((b) => b.thinking ?? "");
-}
-
-describe("splitThinking", () => {
-	describe("closed thinking blocks", () => {
-		it("turns a <thinking> span into a thinking block", () => {
-			const out = splitThinking("<thinking>This is reasoning</thinking>");
-			expect(out).toEqual([
-				{ type: "thinking", thinking: "This is reasoning" },
-			]);
-		});
-
-		it("turns a <think> span into a thinking block", () => {
-			const out = splitThinking("<think>This is reasoning</think>");
-			expect(out).toEqual([
-				{ type: "thinking", thinking: "This is reasoning" },
-			]);
-		});
-
-		it("preserves multi-line reasoning inside one thinking block", () => {
-			const out = splitThinking("<thinking>Line 1\nLine 2\nLine 3</thinking>");
-			expect(out).toEqual([
-				{ type: "thinking", thinking: "Line 1\nLine 2\nLine 3" },
-			]);
-		});
-
-		it("emits one thinking block per closed span in order", () => {
-			const out = splitThinking(
-				"<thinking>First block</thinking> Some text <thinking>Second block</thinking>",
-			);
-			expect(thinkings(out)).toEqual(["First block", "Second block"]);
-			expect(texts(out)).toEqual(["Some text"]);
-		});
-
-		it("drops empty thinking spans", () => {
-			const out = splitThinking("Before <thinking></thinking> After");
-			expect(thinkings(out)).toEqual([]);
-			expect(texts(out).join(" ")).toContain("Before");
-			expect(texts(out).join(" ")).toContain("After");
-		});
-
-		it("drops whitespace-only thinking spans", () => {
-			const out = splitThinking("Before <thinking>   \n  </thinking> After");
-			expect(thinkings(out)).toEqual([]);
-		});
-
-		it("trims whitespace from thinking content", () => {
-			const out = splitThinking(
-				"<thinking>\n  This is reasoning  \n</thinking>",
-			);
-			expect(out).toEqual([
-				{ type: "thinking", thinking: "This is reasoning" },
-			]);
-		});
-
-		it("handles mixed case tag names", () => {
-			const out = splitThinking(
-				"<THINKING>uppercase</THINKING> <ThInKiNg>mixedcase</ThInKiNg>",
-			);
-			expect(thinkings(out)).toEqual(["uppercase", "mixedcase"]);
-		});
-	});
-
-	describe("dangling/unclosed blocks", () => {
-		it("treats a trailing <thinking> as a thinking block", () => {
-			const out = splitThinking("Some text <thinking>Reasoning without close");
-			expect(texts(out)).toEqual(["Some text"]);
-			expect(thinkings(out)).toEqual(["Reasoning without close"]);
-		});
-
-		it("treats a trailing <think> as a thinking block", () => {
-			const out = splitThinking("Some text <think>Reasoning without close");
-			expect(texts(out)).toEqual(["Some text"]);
-			expect(thinkings(out)).toEqual(["Reasoning without close"]);
-		});
-
-		it("captures the remainder of a leading unclosed tag as reasoning", () => {
-			const out = splitThinking("<thinking>Unclosed\nMore text after");
-			expect(thinkings(out)).toEqual(["Unclosed\nMore text after"]);
-			expect(texts(out)).toEqual([]);
-		});
-	});
-
-	describe("orphan tags", () => {
-		it("removes orphan closing tags from text", () => {
-			const out = splitThinking("Some text </thinking> more text");
-			const joined = texts(out).join(" ");
-			expect(joined).not.toContain("</thinking>");
-			expect(joined).not.toContain("<thinking>");
-			expect(joined).toContain("Some text");
-			expect(joined).toContain("more text");
-		});
-
-		it("treats a trailing open tag as a (possibly empty) reasoning span", () => {
-			const out = splitThinking("Text <think> orphan tag");
-			expect(texts(out)).toEqual(["Text"]);
-			expect(thinkings(out)).toEqual(["orphan tag"]);
-		});
-
-		it("handles multiple orphan tags", () => {
-			const out = splitThinking(
-				"</thinking> text </think> more <thinking> stuff </think>",
-			);
-			const joined = texts(out).join(" ");
-			expect(joined).not.toContain("<thinking>");
-			expect(joined).not.toContain("</thinking>");
-			expect(joined).not.toContain("</think>");
-			expect(joined).toContain("text");
-			expect(thinkings(out).join(" ")).toContain("stuff");
-		});
-	});
-
-	describe("text without thinking tags", () => {
-		it("returns the original text block unchanged", () => {
-			const input = "This is regular text without any tags";
-			expect(splitThinking(input)).toEqual([{ type: "text", text: input }]);
-		});
-
-		it("preserves markdown formatting verbatim", () => {
-			const input = "# Header\n\n**bold** and *italic*";
-			expect(splitThinking(input)).toEqual([{ type: "text", text: input }]);
-		});
-	});
-
-	describe("mixed content order", () => {
-		it("keeps text before a thinking block", () => {
-			const out = splitThinking(
-				"Response text here\n\n<thinking>reasoning</thinking>",
-			);
-			expect(out).toEqual([
-				{ type: "text", text: "Response text here" },
-				{ type: "thinking", thinking: "reasoning" },
-			]);
-		});
-
-		it("keeps text after a thinking block", () => {
-			const out = splitThinking(
-				"<thinking>reasoning</thinking>\n\nMore response text",
-			);
-			expect(out).toEqual([
-				{ type: "thinking", thinking: "reasoning" },
-				{ type: "text", text: "More response text" },
-			]);
-		});
-
-		it("keeps text between multiple thinking blocks in order", () => {
-			const out = splitThinking(
-				"<thinking>first</thinking>\n\nMiddle text\n\n<thinking>second</thinking>",
-			);
-			expect(out).toEqual([
-				{ type: "thinking", thinking: "first" },
-				{ type: "text", text: "Middle text" },
-				{ type: "thinking", thinking: "second" },
-			]);
-		});
-	});
-
-	describe("streaming (partial tail tags)", () => {
-		it("strips a half-streamed opening tag", () => {
-			expect(stripPartialTailTag("Hello <thin")).toBe("Hello ");
-			expect(stripPartialTailTag("Hello <")).toBe("Hello ");
-			expect(stripPartialTailTag("Hello <thinking")).toBe("Hello ");
-		});
-
-		it("strips a half-streamed closing tag", () => {
-			expect(stripPartialTailTag("reasoning </thinkin")).toBe("reasoning ");
-			expect(stripPartialTailTag("reasoning </")).toBe("reasoning ");
-		});
-
-		it("keeps non-reasoning partial tags", () => {
-			expect(stripPartialTailTag("a generic <div")).toBe("a generic <div");
-			expect(stripPartialTailTag("math: 1 < 2")).toBe("math: 1 < 2");
-		});
-
-		it("keeps complete tags (only the trailing fragment is stripped)", () => {
-			expect(stripPartialTailTag("<thinking>body")).toBe("<thinking>body");
-		});
-
-		it("emits a thinking block for an open span before the close arrives", () => {
-			const midStream = "<thinking>I am reasoning about";
-			const out = splitThinking(stripPartialTailTag(midStream));
-			expect(out).toEqual([
-				{ type: "thinking", thinking: "I am reasoning about" },
-			]);
-		});
-
-		it("renders progressively without flashing a partial close tag", () => {
-			const step1 = splitThinking(stripPartialTailTag("<think>step one"));
-			const step2 = splitThinking(
-				stripPartialTailTag("<think>step one and two</thi"),
-			);
-			const step3 = splitThinking(
-				stripPartialTailTag("<think>step one and two</think>\n\nAnswer"),
-			);
-			expect(step1).toEqual([{ type: "thinking", thinking: "step one" }]);
-			expect(step2).toEqual([
-				{ type: "thinking", thinking: "step one and two" },
-			]);
-			expect(step3).toEqual([
-				{ type: "thinking", thinking: "step one and two" },
-				{ type: "text", text: "Answer" },
-			]);
-		});
-	});
-
-	describe("edge cases", () => {
-		it("returns a single text block for an empty string", () => {
-			expect(splitThinking("")).toEqual([{ type: "text", text: "" }]);
-		});
-
-		it("collapses an all-empty reasoning message to one empty text block", () => {
-			expect(splitThinking("<thinking></thinking>")).toEqual([
-				{ type: "text", text: "" },
-			]);
-		});
-
-		it("handles thinking content with special characters", () => {
-			const out = splitThinking(
-				"<thinking>Special chars: $@#%^&*()</thinking>",
-			);
-			expect(thinkings(out)).toEqual(["Special chars: $@#%^&*()"]);
-		});
-
-		it("handles thinking content with code-like syntax", () => {
-			const out = splitThinking(
-				"<thinking>const x = 5;\nreturn x + 1;</thinking>",
-			);
-			expect(thinkings(out)).toEqual(["const x = 5;\nreturn x + 1;"]);
-		});
-	});
-});

package/src/thinking.ts

@@ -1,207 +0,0 @@
-/**
- * Convert leaked reasoning tags into native `thinking` content blocks.
- *
- * Some openai-compatible providers leak raw <think>/<thinking> tags into the
- * visible assistant `content[].text` (the real reasoning travels the proper
- * `reasoning_content` channel). Instead of stripping or restyling them, we
- * split each affected text block into ordered `text` + `thinking` content
- * blocks. Pi renders `thinking` blocks dim + italic via the `thinkingText`
- * theme token natively (see assistant-message.ts) — no ANSI injection, no
- * markdown blockquote shim.
- *
- * Approach:
- *   - During streaming (`message_update`), rebuild the event's message so a
- *     reasoning block appears the moment the open tag streams in — no waiting
- *     for the close tag. splitThinking() captures the dangling-open case, and
- *     a trailing half-streamed tag (e.g. "<thin") is stripped so it never
- *     flashes as literal text.
- *
- *     Safety: `event.message` is a per-event shallow copy, but its content
- *     blocks are the provider's LIVE accumulating objects (providers do
- *     `block.text += delta`). We therefore never mutate text blocks in
- *     place — we replace `message.content` with fresh block objects. The
- *     TUI receives the same event object after extensions run, so the rebuilt
- *     content is what gets rendered live.
- *
- *   - On `message_end`, split every affected text block and return the
- *     replacement via the supported channel. (The finalized message comes
- *     from `response.result()` — a fresh object that never saw the streaming
- *     rebuild — so this step is still required for persistence.)
- *
- * Persistence trade-off: the replacement is persisted and round-trips to the
- * provider next turn. The synthesized `thinking` blocks carry no
- * thinkingSignature (none was received — the reasoning leaked into the text
- * channel), so signature-validating APIs (e.g. Anthropic) may reject or drop
- * them on multi-turn. Accepted in exchange for native dim+italic rendering.
- *
- * To add a new tag variant, append to TAG_NAMES below.
- */
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-// Reasoning tag names to render. Add new variants here.
-const TAG_NAMES = ["think", "thinking"] as const;
-const TAG_ALT = TAG_NAMES.join("|");
-
-// Closed block: <think>...</think>
-const CLOSED_BLOCK_RE = new RegExp(`<(${TAG_ALT})>([\\s\\S]*?)<\\/\\1>`, "gi");
-// Dangling open block with no close (stream cut off, or close never emitted)
-const OPEN_TAIL_RE = new RegExp(`<(${TAG_ALT})>([\\s\\S]*)$`, "i");
-// Any orphan tags left over.
-const ORPHAN_TAG_RE = new RegExp(`<\\/?(${TAG_ALT})>`, "gi");
-
-interface TextBlock {
-	type: "text";
-	text: string;
-}
-interface ThinkingBlock {
-	type: "thinking";
-	thinking: string;
-}
-type Block = TextBlock | ThinkingBlock | { type: string; [k: string]: unknown };
-interface Msg {
-	role?: string;
-	content?: Block[];
-}
-
-// Trailing half-streamed tag, e.g. "<", "</", "<thin", "</thinkin".
-// Only used during streaming so an incomplete tag never flashes as text.
-const PARTIAL_TAIL_RE = /<\/?([a-zA-Z]*)$/;
-
-function stripPartialTailTag(text: string): string {
-	const match = text.match(PARTIAL_TAIL_RE);
-	if (!match) return text;
-	const fragment = match[1].toLowerCase();
-	if (TAG_NAMES.some((tag) => tag.startsWith(fragment))) {
-		return text.slice(0, match.index);
-	}
-	return text;
-}
-
-// Push a text block only when it has visible content. Surrounding whitespace
-// between reasoning and answer text is dropped so the native renderer doesn't
-// emit stray blank paragraphs.
-// True when the text contains any reasoning tag (open, close, or orphan).
-function hasReasoningTag(text: string): boolean {
-	ORPHAN_TAG_RE.lastIndex = 0;
-	return ORPHAN_TAG_RE.test(text);
-}
-
-function pushText(blocks: Block[], text: string): void {
-	const trimmed = text.trim();
-	if (trimmed) blocks.push({ type: "text", text: trimmed });
-}
-
-function pushThinking(blocks: Block[], thinking: string): void {
-	const trimmed = thinking.trim();
-	if (trimmed) blocks.push({ type: "thinking", thinking: trimmed });
-}
-
-/**
- * Split leaked reasoning text into ordered native content blocks.
- *
- * Reasoning spans (`<think>…</think>`, plus a trailing unclosed `<think>…`)
- * become real `thinking` blocks, which pi renders dim + italic via the
- * `thinkingText` theme token — no ANSI injection, no markdown blockquote.
- * Everything else stays a `text` block. Returns the original single text
- * block unchanged when no reasoning tags are present.
- */
-function splitThinking(text: string): Block[] {
-	if (!hasReasoningTag(text)) {
-		return [{ type: "text", text }];
-	}
-
-	const blocks: Block[] = [];
-	let rest = text;
-
-	// Consume closed reasoning blocks left-to-right, preserving order with the
-	// surrounding answer text.
-	CLOSED_BLOCK_RE.lastIndex = 0;
-	let match = CLOSED_BLOCK_RE.exec(rest);
-	while (match) {
-		pushText(blocks, rest.slice(0, match.index));
-		pushThinking(blocks, match[2]);
-		rest = rest.slice(match.index + match[0].length);
-		CLOSED_BLOCK_RE.lastIndex = 0;
-		match = CLOSED_BLOCK_RE.exec(rest);
-	}
-
-	// A dangling open block (close tag not yet streamed / never emitted): the
-	// remainder after the open tag is reasoning.
-	const openMatch = OPEN_TAIL_RE.exec(rest);
-	if (openMatch) {
-		// Leading text may still carry orphan tags (e.g. a stray `</think>`).
-		pushText(
-			blocks,
-			openMatch.input.slice(0, openMatch.index).replace(ORPHAN_TAG_RE, ""),
-		);
-		pushThinking(blocks, openMatch[2].replace(ORPHAN_TAG_RE, ""));
-	} else {
-		// Strip any orphan tags from the trailing text.
-		pushText(blocks, rest.replace(ORPHAN_TAG_RE, ""));
-	}
-
-	// All-empty (e.g. `<think></think>`) collapses to a single empty text block
-	// so the message never becomes contentless.
-	return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
-}
-
-// Export for testing
-export { splitThinking, stripPartialTailTag };
-
-export default function thinkingExtension(pi: ExtensionAPI) {
-	// Live conversion during streaming: rebuild the event's message so a native
-	// thinking block appears as soon as the open tag streams in, token by token.
-	pi.on("message_update", (event) => {
-		const ev = event as {
-			message?: Msg;
-			assistantMessageEvent?: { type?: string };
-		};
-		const msg = ev.message;
-		if (msg?.role !== "assistant" || !Array.isArray(msg.content)) return;
-
-		// Only text stream events can change text blocks; skip toolcall/thinking
-		// channel deltas to avoid pointless re-renders.
-		const streamType = ev.assistantMessageEvent?.type;
-		if (streamType && !streamType.startsWith("text_")) return;
-
-		msg.content = msg.content.flatMap((block): Block[] => {
-			if (block.type !== "text") return [block];
-			const tb = block as TextBlock;
-			if (typeof tb.text !== "string" || !tb.text.includes("<")) return [block];
-			// Strip a half-streamed tag so it never flashes as literal text.
-			const stripped = stripPartialTailTag(tb.text);
-			// Nothing reasoning-related: leave unrelated "<" text alone entirely.
-			if (!hasReasoningTag(stripped) && stripped === tb.text) return [block];
-			// New objects — never mutate the provider's accumulating block.
-			return splitThinking(stripped);
-		});
-	});
-
-	pi.on("message_end", (event) => {
-		const msg = (event as { message?: Msg }).message;
-		if (msg?.role !== "assistant" || !Array.isArray(msg.content)) return;
-
-		let changed = false;
-		const content = msg.content.flatMap((block): Block[] => {
-			if (block.type !== "text") return [block];
-			const tb = block as TextBlock;
-			if (typeof tb.text !== "string") return [block];
-			if (!hasReasoningTag(tb.text)) return [block];
-			changed = true;
-			return splitThinking(tb.text);
-		});
-
-		// Return the replacement so the native thinking blocks are persisted.
-		// Persistence note: this rewrites leaked reasoning from `text` into real
-		// `thinking` content blocks, which round-trip to the provider next turn.
-		// The blocks carry no thinkingSignature (we never received one — the
-		// reasoning leaked into the text channel), so signature-validating APIs
-		// may reject or drop them on multi-turn. Accepted trade-off for native
-		// dim+italic rendering via the `thinkingText` theme token.
-		if (changed) {
-			msg.content = content;
-			return { message: msg as unknown as never };
-		}
-	});
-}