@xynogen/pix-pretty 1.6.3 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.6.3",
+	"version": "1.6.4",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, FFF search, and paste chip formatting",
 	"type": "module",
 	"main": "src/index.ts",
@@ -28,13 +28,6 @@
 		"README.md",
 		"LICENSE"
 	],
-	"pi": {
-		"extensions": [
-			"./src/index.ts",
-			"./src/paste-chips.ts",
-			"./src/thinking.ts"
-		]
-	},
 	"keywords": [
 		"pi",
 		"pi-package",

package/src/index.test.ts

@@ -1,33 +1,13 @@
 /**
- * Basic smoke tests for pix-pretty extensions
+ * Smoke tests for pix-pretty (pure lib).
+ * UI extension tests moved to pix-display.
  */
 
 import { describe, expect, it } from "bun:test";
 
 describe("pix-pretty", () => {
-	it("exports are valid TypeScript modules", () => {
-		// Smoke test - just verify the files can be imported
-		expect(true).toBe(true);
-	});
-
-	describe("tool rendering extension", () => {
-		it("main extension exports a function", async () => {
-			const mainModule = await import("./index");
-			expect(mainModule.default).toBeFunction();
-		});
-	});
-
-	describe("paste-chips extension", () => {
-		it("paste-chips extension exports a function", async () => {
-			const pasteChipsModule = await import("./paste-chips");
-			expect(pasteChipsModule.default).toBeFunction();
-		});
-	});
-
-	describe("thinking extension", () => {
-		it("thinking extension exports a function", async () => {
-			const thinkingModule = await import("./thinking");
-			expect(thinkingModule.default).toBeFunction();
-		});
+	it("main module exports a function", async () => {
+		const mod = await import("./index");
+		expect(mod.default).toBeFunction();
 	});
 });

package/src/index.ts

@@ -1,26 +1,8 @@
 /**
  * pi-pretty — Pretty terminal output for pi built-in tools.
  *
- * Entry point: initialises theme + highlight cache, registers FFF slash
- * commands (/fff-rescan etc.). Individual tool renderers live in the
- * standalone pix-{read,bash,ls,find,grep,edit,write} packages — each
- * self-registers via its own pi extension entry point.
- *
- * Modules:
- *   types.ts          shared interfaces/types
- *   config.ts         theme + thresholds
- *   ansi.ts           ANSI codes, low-contrast fix
- *   utils.ts          helpers + renderToolError
- *   lang.ts           language detection
- *   icons.ts          Nerd Font file-type icons
- *   highlight.ts      cli-highlight engine + ANSI cache
- *   renderers.ts      renderFileContent/Bash/Tree/Find/Grep
- *   fff.ts            Fast File Finder + cursor store + module singleton
- *   diff.ts           unified diff parser
- *   diff-render.ts    split/word-level diff renderer
- *   resize.ts         terminal resize invalidation registry
- *   tools/            per-tool registrar helpers (context type)
- *   commands/         slash command registrars (fff)
+ * Pure rendering library — no Pi lifecycle hooks or extensions.
+ * UI features (paste chips, thinking blocks) live in pix-display.
  */
 
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
@@ -48,3 +30,9 @@ export default function piPrettyExtension(pi: PiPrettyApi): void {
 	// Commands become available once pix-grep initialises the finder.
 	registerFffCommands(pi, fffState);
 }
+
+/**
+ * piPrettyExtension still exports a default function for packages that
+ * import it as an extension (pix-core activates it for theme + FFF).
+ * UI extensions (paste-chips, thinking) moved to pix-display.
+ */

package/src/paste-chips.test.ts

@@ -1,162 +0,0 @@
-/**
- * Tests for paste-chips marker restyling and width safety.
- *
- * Regression: restyling markers can widen lines (e.g. "#1" → "text"),
- * which caused a TUI crash when the restyled line exceeded terminal width.
- * See: pi-crash.log — "Rendered line 38 exceeds terminal width (285 > 283)"
- */
-
-import { describe, expect, it } from "bun:test";
-import { visibleWidth } from "@earendil-works/pi-tui";
-import { endsWithMarker, restyleMarkers } from "./paste-chips";
-
-const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
-
-// ─── restyleMarkers ──────────────────────────────────────────────────────────
-
-describe("paste-chips restyleMarkers", () => {
-	describe("text markers", () => {
-		it("restyles chars marker to colored icon text chip", () => {
-			const result = restyleMarkers("[paste #1 2232 chars]", new Set());
-			expect(result).toContain("\x1b[");
-			expect(stripAnsi(result)).toBe("󰉿 text 2.2k chars");
-		});
-
-		it("restyles lines marker to colored icon text chip", () => {
-			const result = restyleMarkers("[paste #2 +42 lines]", new Set());
-			expect(stripAnsi(result)).toBe("󰉿 text 42 lines");
-		});
-
-		it("restyles bare marker (no size info) to text chip with id", () => {
-			const result = restyleMarkers("[paste #3]", new Set());
-			expect(stripAnsi(result)).toBe("󰉿 text #3");
-		});
-	});
-
-	describe("image markers", () => {
-		it("restyles marker to colored icon image chip when ID is in imageIds", () => {
-			const imageIds = new Set([1]);
-			const result = restyleMarkers("[paste #1 58 chars]", imageIds);
-			expect(result).toContain("\x1b[");
-			expect(stripAnsi(result)).toBe("󰋩 image #1");
-		});
-
-		it("does not restyle non-image ID as image", () => {
-			const imageIds = new Set([1]);
-			const result = restyleMarkers("[paste #2 100 chars]", imageIds);
-			expect(stripAnsi(result)).toBe("󰉿 text 100 chars");
-		});
-	});
-
-	describe("multiple markers in one line", () => {
-		it("restyles all markers in a single line", () => {
-			const imageIds = new Set([1]);
-			const line =
-				"before [paste #1 58 chars] middle [paste #2 +10 lines] after";
-			const result = restyleMarkers(line, imageIds);
-			expect(stripAnsi(result)).toBe(
-				"before 󰋩 image #1 middle 󰉿 text 10 lines after",
-			);
-		});
-	});
-
-	describe("no markers", () => {
-		it("returns line unchanged when no markers present", () => {
-			const line = "just regular text with no paste markers";
-			expect(restyleMarkers(line, new Set())).toBe(line);
-		});
-
-		it("returns empty string unchanged", () => {
-			expect(restyleMarkers("", new Set())).toBe("");
-		});
-	});
-
-	describe("ANSI-styled markers", () => {
-		it("restyles markers embedded in ANSI sequences", () => {
-			const line = "\x1b[38;2;84;92;126m[paste #1 500 chars]\x1b[0m";
-			const result = restyleMarkers(line, new Set());
-			expect(stripAnsi(result)).toBe("󰉿 text 500 chars");
-		});
-	});
-});
-
-// ─── Width safety (regression for crash) ─────────────────────────────────────
-
-describe("paste-chips width safety", () => {
-	it("restyling a chars marker can decrease visible width", () => {
-		const original = "[paste #1 2232 chars]";
-		const restyled = restyleMarkers(original, new Set());
-		expect(visibleWidth(restyled)).toBeLessThan(visibleWidth(original));
-	});
-
-	it("restyling a lines marker can decrease visible width", () => {
-		// "[paste #2 +42 lines]" (20 chars) → "[paste text +42]" (16 chars) = -4 width
-		const original = "[paste #2 +42 lines]";
-		const restyled = restyleMarkers(original, new Set());
-		expect(visibleWidth(restyled)).toBeLessThan(visibleWidth(original));
-	});
-
-	it("restyling to image label changes width", () => {
-		// "[paste #1 58 chars]" (19 chars) → "[paste image #1]" (16 chars)
-		const imageIds = new Set([1]);
-		const original = "[paste #1 58 chars]";
-		const restyled = restyleMarkers(original, imageIds);
-		expect(visibleWidth(restyled)).not.toBe(visibleWidth(original));
-	});
-
-	it("chars marker with large char count compacts metadata", () => {
-		const original = "[paste #1 9999 chars]";
-		const restyled = restyleMarkers(original, new Set());
-		expect(stripAnsi(restyled)).toBe("󰉿 text 10k chars");
-		expect(visibleWidth(restyled)).toBeLessThan(visibleWidth(original));
-	});
-
-	it("chars marker with multi-digit ID omits id from text chip", () => {
-		const original = "[paste #10 9999 chars]";
-		const restyled = restyleMarkers(original, new Set());
-		expect(stripAnsi(restyled)).toBe("󰉿 text 10k chars");
-		expect(visibleWidth(restyled)).toBeLessThan(visibleWidth(original));
-	});
-
-	describe("width behavior", () => {
-		it("icon chip stays within terminal width when marker line fits", () => {
-			const terminalWidth = 283;
-			const marker = "[paste #1 2232 chars]";
-			const padding = " ".repeat(terminalWidth - visibleWidth(marker));
-			const line = marker + padding;
-
-			expect(visibleWidth(line)).toBe(terminalWidth);
-
-			const restyled = restyleMarkers(line, new Set());
-			expect(visibleWidth(restyled)).toBeLessThanOrEqual(terminalWidth);
-		});
-	});
-});
-
-// ─── endsWithMarker (trailing-space gate) ──────────────────────────────
-
-describe("paste-chips endsWithMarker", () => {
-	it("matches a chars marker at end of string", () => {
-		expect(endsWithMarker("[paste #1 2232 chars]")).toBe(true);
-	});
-
-	it("matches a lines marker at end of string", () => {
-		expect(endsWithMarker("hello [paste #2 +42 lines]")).toBe(true);
-	});
-
-	it("matches a bare marker at end of string", () => {
-		expect(endsWithMarker("[paste #3]")).toBe(true);
-	});
-
-	it("does not match when marker is not at the end", () => {
-		expect(endsWithMarker("[paste #1 58 chars] trailing")).toBe(false);
-	});
-
-	it("does not match plain text", () => {
-		expect(endsWithMarker("just some text")).toBe(false);
-	});
-
-	it("does not match a lone trailing space", () => {
-		expect(endsWithMarker(" ")).toBe(false);
-	});
-});

package/src/paste-chips.ts

@@ -1,217 +0,0 @@
-/**
- * paste-chips — collapse pasted image paths into Pi paste markers, and
- * re-render all paste markers with type-aware labels.
- *
- *   /tmp/pi-clipboard-abc.png   →  buffer: [paste #1 58 chars]
- *                                  display: [paste image #1]
- *
- *   long pasted text            →  buffer: [paste #2 +42 lines]
- *                                  display: [paste text +42]
- *
- * Atomic deletion + cursor handling come from Pi's marker grammar.
- * On submit, getExpandedText() restores the real path/text for the model.
- * The display rewrite is purely visual (render layer); buffer is untouched.
- */
-
-import type {
-	ExtensionAPI,
-	KeybindingsManager,
-} from "@earendil-works/pi-coding-agent";
-import { CustomEditor } from "@earendil-works/pi-coding-agent";
-import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { BOLD, FG_BLUE, FG_DIM, FG_GREEN, RST } from "./ansi.js";
-
-// Upstream stopped re-exporting `EditorFactory` from the package entry point,
-// so we reconstruct its signature locally from the still-exported primitives.
-// This matches ctx.ui.setEditorComponent's expected factory shape.
-type EditorFactory = (
-	tui: TUI,
-	theme: EditorTheme,
-	keybindings: KeybindingsManager,
-) => CustomEditor;
-
-// ─── Constants ────────────────────────────────────────────────────────────────
-
-const IMAGE_EXTS = new Set([
-	".png",
-	".jpg",
-	".jpeg",
-	".gif",
-	".webp",
-	".bmp",
-	".tif",
-	".tiff",
-	".heic",
-	".heif",
-]);
-
-// Group 1 = prefix char (or empty at start), Group 2 = path
-const PATH_RE = /(^|[^\w/])((?:~|\/)[^\s,;'"(){}[\]]+)/g;
-
-// Pi's marker grammar — must match exactly for atomic segmentation.
-// e.g. `[paste #1 58 chars]` or `[paste #2 +42 lines]`
-const MARKER_RE = /\[paste #(\d+)( (\+(\d+) lines|(\d+) chars))?\]/g;
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function extOf(p: string): string {
-	const dot = p.lastIndexOf(".");
-	return dot >= 0 ? p.slice(dot).toLowerCase() : "";
-}
-
-function isImagePath(p: string): boolean {
-	return IMAGE_EXTS.has(extOf(p));
-}
-
-function makeMarker(id: number, charCount: number): string {
-	return `[paste #${id} ${charCount} chars]`;
-}
-
-// ─── Editor internals (Pi's TS-private fields are runtime-public JS) ─────────
-
-type EditorInternals = {
-	pastes: Map<number, string>;
-	pasteCounter: number;
-};
-
-// ─── Path → marker rewriter ──────────────────────────────────────────────────
-
-/**
- * Walk `text`, for each image path: allocate a new paste ID, register the
- * real path in editor.pastes, remember the ID as an image, and emit a
- * Pi-format marker so deletion is atomic.
- */
-function replaceImagePaths(
-	text: string,
-	internals: EditorInternals,
-	imageIds: Set<number>,
-): string {
-	return text.replace(PATH_RE, (_, prefix: string, rawPath: string) => {
-		if (!isImagePath(rawPath)) return prefix + rawPath;
-		internals.pasteCounter += 1;
-		const id = internals.pasteCounter;
-		internals.pastes.set(id, rawPath);
-		imageIds.add(id);
-		return prefix + makeMarker(id, rawPath.length);
-	});
-}
-
-// ─── Display rewriter ────────────────────────────────────────────────────────
-
-/**
- * Re-style every paste marker in a rendered line:
- *   image  → `󰋩 image #N` with blue icon/label
- *   text   → `󰉿 text Lines lines` or `󰉿 text Chars chars` with green icon/label
- *
- * Width-preserving is not required — Pi re-wraps each render call.
- */
-export function restyleMarkers(line: string, imageIds: Set<number>): string {
-	return line.replace(
-		MARKER_RE,
-		(_full, idStr, _g2, _g3, linesStr, charsStr) => {
-			const id = Number.parseInt(idStr, 10);
-			if (imageIds.has(id)) {
-				return chip(FG_BLUE, "󰋩", "image", `#${id}`);
-			}
-			if (linesStr) {
-				return chip(FG_GREEN, "󰉿", "text", `${linesStr} lines`);
-			}
-			if (charsStr) {
-				return chip(FG_GREEN, "󰉿", "text", `${compactNumber(charsStr)} chars`);
-			}
-			return chip(FG_GREEN, "󰉿", "text", `#${id}`);
-		},
-	);
-}
-
-function chip(
-	color: string,
-	icon: string,
-	label: string,
-	meta: string,
-): string {
-	return `${color}${BOLD}${icon} ${label}${RST}${FG_DIM} ${meta}${RST}`;
-}
-
-/** True when `text` ends with a Pi paste marker (chip), e.g. `[paste #1 58 chars]`. */
-export function endsWithMarker(text: string): boolean {
-	return /\[paste #\d+[^\]]*\]$/.test(text);
-}
-
-function compactNumber(raw: string): string {
-	const n = Number.parseInt(raw, 10);
-	if (!Number.isFinite(n)) return raw;
-	if (n < 1_000) return `${n}`;
-	if (n < 1_000_000) return `${(n / 1_000).toFixed(1).replace(/\.0$/, "")}k`;
-	return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, "")}m`;
-}
-
-// ─── Custom editor ────────────────────────────────────────────────────────────
-
-// handlePaste is TS-private in CustomEditor but runtime-public JS. We patch it
-// per-instance, capturing the base implementation, so large text pastes get the
-// same trailing-space treatment as image chips.
-type PasteHandler = { handlePaste(text: string): void };
-
-class ChipEditor extends CustomEditor {
-	private readonly imageIds = new Set<number>();
-
-	constructor(...args: ConstructorParameters<typeof CustomEditor>) {
-		super(...args);
-		this.patchHandlePaste();
-	}
-
-	override insertTextAtCursor(text: string): void {
-		const internals = this as unknown as EditorInternals;
-		const replaced = replaceImagePaths(text, internals, this.imageIds);
-		// Append a trailing space when the insertion ends with a paste marker so
-		// the cursor lands after the chip rather than inside it.
-		super.insertTextAtCursor(
-			endsWithMarker(replaced) ? `${replaced} ` : replaced,
-		);
-	}
-
-	private patchHandlePaste(): void {
-		const self = this as unknown as PasteHandler;
-		const base = self.handlePaste.bind(self);
-		self.handlePaste = (pastedText: string) => {
-			const before = this.getText();
-			base(pastedText);
-			const after = this.getText();
-			// Only nudge a space when the paste collapsed into a marker chip;
-			// inline small pastes (no marker) are left untouched.
-			if (endsWithMarker(after) && after !== before) {
-				super.insertTextAtCursor(" ");
-			}
-		};
-	}
-
-	override render(width: number): string[] {
-		const raw = super.render(width);
-		return raw.map((line) => {
-			const restyled = restyleMarkers(line, this.imageIds);
-			// Restyling may widen lines (e.g. "#1" → "text"), so clamp to width.
-			if (visibleWidth(restyled) > width) {
-				return truncateToWidth(restyled, width, "");
-			}
-			return restyled;
-		});
-	}
-}
-
-// ─── Extension ────────────────────────────────────────────────────────────────
-
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", (_event, ctx) => {
-		if (!ctx.hasUI) return;
-		const factory: EditorFactory = (tui, theme, keybindings) =>
-			new ChipEditor(tui, theme, keybindings);
-		ctx.ui.setEditorComponent(factory);
-	});
-
-	pi.on("session_shutdown", (_event, ctx) => {
-		if (!ctx.hasUI) return;
-		ctx.ui.setEditorComponent(undefined);
-	});
-}

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 };
-		}
-	});
-}