@xynogen/pix-pretty 1.0.0 → 1.1.0

package/package.json

@@ -1,54 +1,55 @@
 {
-  "name": "@xynogen/pix-pretty",
-  "version": "1.0.0",
-  "description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, FFF search, and paste chip formatting",
-  "type": "module",
-  "main": "src/index.ts",
-  "scripts": {
-    "test": "bun test"
-  },
-  "files": [
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "pi": {
-    "extensions": [
-      "./src/index.ts",
-      "./src/paste-chips.ts",
-      "./src/thinking.ts"
-    ]
-  },
-  "keywords": [
-    "pi",
-    "pi-package",
-    "pi-extension",
-    "syntax-highlighting",
-    "fff",
-    "paste-chips",
-    "tool-rendering"
-  ],
-  "author": "xynogen",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/xynogen/pix-mono.git",
-    "directory": "packages/pix-pretty"
-  },
-  "homepage": "https://github.com/xynogen/pix-mono/tree/main/packages/pix-pretty#readme",
-  "bugs": {
-    "url": "https://github.com/xynogen/pix-mono/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "cli-highlight": "^2.1.11",
-    "@ff-labs/fff-node": "^0.5.2",
-    "diff": "^7.0.0"
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
-  }
+	"name": "@xynogen/pix-pretty",
+	"version": "1.1.0",
+	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, FFF search, and paste chip formatting",
+	"type": "module",
+	"main": "src/index.ts",
+	"scripts": {
+		"test": "bun test"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./src/index.ts",
+			"./src/paste-chips.ts",
+			"./src/thinking.ts"
+		]
+	},
+	"keywords": [
+		"pi",
+		"pi-package",
+		"pi-extension",
+		"syntax-highlighting",
+		"fff",
+		"paste-chips",
+		"tool-rendering"
+	],
+	"author": "xynogen",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/xynogen/pix-mono.git",
+		"directory": "packages/pix-pretty"
+	},
+	"homepage": "https://github.com/xynogen/pix-mono/tree/main/packages/pix-pretty#readme",
+	"bugs": {
+		"url": "https://github.com/xynogen/pix-mono/issues"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"dependencies": {
+		"cli-highlight": "^2.1.11",
+		"@ff-labs/fff-node": "^0.5.2",
+		"diff": "^7.0.0"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	}
 }

package/src/index.test.ts

@@ -2,7 +2,7 @@
  * Basic smoke tests for pix-pretty extensions
  */
 
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 
 describe("pix-pretty", () => {
 	it("exports are valid TypeScript modules", () => {

package/src/index.ts

@@ -920,7 +920,7 @@ export default function piPrettyExtension(
 	// SDK grep fallback otherwise)
 	// ===================================================================
 
-	if ((fffState.module || createGrepTool)) {
+	if (fffState.module || createGrepTool) {
 		const multiGrepFallback = createGrepTool ? createGrepTool(cwd) : null;
 
 		pi.registerTool({
@@ -1269,9 +1269,12 @@ export default function piPrettyExtension(
 			) {
 				const fp = params.path ?? params.file_path ?? "";
 				const operations = getEditOperations(params);
+				// params is the live tool input (upstream EditToolInput shape); we
+				// type it loosely as EditParams for defensive legacy-field reads, so
+				// cast back to the upstream input when delegating to the real tool.
 				const result = (await origEdit.execute(
 					tid,
-					params,
+					params as unknown as Parameters<typeof origEdit.execute>[1],
 					sig,
 					upd,
 					ctx,
@@ -1409,7 +1412,7 @@ export default function piPrettyExtension(
 
 				const result = (await origWrite.execute(
 					tid,
-					params,
+					params as unknown as Parameters<typeof origWrite.execute>[1],
 					sig,
 					upd,
 					ctx,

package/src/paste-chips.test.ts

@@ -6,7 +6,7 @@
  * See: pi-crash.log — "Rendered line 38 exceeds terminal width (285 > 283)"
  */
 
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { restyleMarkers } from "./paste-chips";
 

package/src/paste-chips.ts

@@ -13,14 +13,22 @@
  * The display rewrite is purely visual (render layer); buffer is untouched.
  */
 
-import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import type {
-	EditorFactory,
 	ExtensionAPI,
 	KeybindingsManager,
 } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+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";
+
+// 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 ────────────────────────────────────────────────────────────────
 
@@ -121,10 +129,6 @@ export function restyleMarkers(line: string, imageIds: Set<number>): string {
 class ChipEditor extends CustomEditor {
 	private readonly imageIds = new Set<number>();
 
-	constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
-		super(tui, theme, keybindings);
-	}
-
 	override insertTextAtCursor(text: string): void {
 		const internals = this as unknown as EditorInternals;
 		super.insertTextAtCursor(replaceImagePaths(text, internals, this.imageIds));

package/src/thinking.test.ts

@@ -2,8 +2,8 @@
  * Tests for thinking tag rendering
  */
 
-import { describe, it, expect } from "bun:test";
-import { renderThinking } from "./thinking";
+import { describe, expect, it } from "bun:test";
+import { renderThinking, stripPartialTailTag } from "./thinking";
 
 describe("thinking tag rendering", () => {
 	describe("closed thinking blocks", () => {
@@ -184,6 +184,50 @@ describe("thinking tag rendering", () => {
 		});
 	});
 
+	describe("streaming (partial tail tags + live rendering)", () => {
+		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("renders an open block as blockquote before close tag arrives", () => {
+			// Simulates mid-stream state: open tag + partial body, no close tag.
+			const midStream = "<thinking>I am reasoning about";
+			const output = renderThinking(stripPartialTailTag(midStream));
+			expect(output).toBe("> I am reasoning about\n\n");
+		});
+
+		it("renders progressively without flashing partial close tag", () => {
+			const step1 = renderThinking(stripPartialTailTag("<think>step one"));
+			const step2 = renderThinking(
+				stripPartialTailTag("<think>step one and two</thi"),
+			);
+			const step3 = renderThinking(
+				stripPartialTailTag("<think>step one and two</think>\n\nAnswer"),
+			);
+			expect(step1).toBe("> step one\n\n");
+			expect(step2).toBe("> step one and two\n\n");
+			expect(step3).toContain("> step one and two");
+			expect(step3).toContain("Answer");
+			expect(step3).not.toContain("<think>");
+		});
+	});
+
 	describe("edge cases", () => {
 		it("handles empty string", () => {
 			const input = "";

package/src/thinking.ts

@@ -8,10 +8,25 @@
  * interfere with the actual response.
  *
  * Approach:
- *   - Do nothing during streaming (no live mutation, no polling, no races).
+ *   - During streaming (`message_update`), re-render the event's message so
+ *     reasoning blocks appear as styled blockquotes the moment the open tag
+ *     streams in — no waiting for the close tag. The dangling-open-block
+ *     handling in renderThinking() covers the not-yet-closed 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
+ *     restyled content is what gets rendered live.
+ *
  *   - On `message_end`, extract and reformat every reasoning block with
  *     visual markers, then return the styled message via the supported
- *     replacement channel.
+ *     replacement channel. (The finalized message comes from
+ *     `response.result()` — a fresh object that never saw the streaming
+ *     restyling — so this step is still required for persistence.)
  *
  * `content[].text` is MARKDOWN rendered by pi's TUI Markdown component.
  * The TUI does NOT parse HTML — <details>/<summary> would render as literal
@@ -44,6 +59,20 @@ interface Msg {
 	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;
+}
+
 // Render a reasoning body as a markdown blockquote.
 function asQuote(body: string, _label: string): string {
 	const lines = body.split("\n");
@@ -74,12 +103,43 @@ function renderThinking(text: string): string {
 }
 
 // Export for testing
-export { renderThinking };
+export { renderThinking, stripPartialTailTag };
 
 export default function thinkingExtension(pi: ExtensionAPI) {
+	// Live styling during streaming: restyle the event's message so reasoning
+	// renders as soon as the open tag appears, 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.map((block) => {
+			if (block.type !== "text") return block;
+			const tb = block as TextBlock;
+			if (typeof tb.text !== "string" || !tb.text.includes("<")) return block;
+			const stripped = stripPartialTailTag(tb.text);
+			const lower = stripped.toLowerCase();
+			const hasTag = TAG_NAMES.some((t) => lower.includes(`<${t}`));
+			// Nothing reasoning-related: leave unrelated "<" text alone entirely.
+			if (!hasTag && stripped === tb.text) return block;
+			const rendered = hasTag ? renderThinking(stripped) : stripped;
+			if (rendered === tb.text) return block;
+			// New object — never mutate the provider's accumulating block.
+			return { ...block, text: rendered };
+		});
+	});
+
 	pi.on("message_end", (event) => {
 		const msg = (event as { message?: Msg }).message;
-		if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content)) return;
+		if (msg?.role !== "assistant" || !Array.isArray(msg.content)) return;
 
 		let changed = false;
 		for (const block of msg.content) {

package/src/types.ts

@@ -161,9 +161,35 @@ export type ReadParams = ReadToolInput;
 
 export type BashParams = BashToolInput;
 
-export type EditParams = EditToolInput;
+// The defensive renderers below accept several legacy / alternate field names
+// (snake_case + singular shapes) that upstream's strict tool-input types no
+// longer declare. We model the full accepted superset here so the runtime
+// fallbacks stay type-safe. These are intentionally standalone (not an
+// intersection with EditToolInput/WriteToolInput) because the upstream `edits`
+// element type is narrower and would conflict with the legacy item shape.
+export type EditOperationInput = {
+	oldText?: string;
+	newText?: string;
+	old_text?: string;
+	new_text?: string;
+};
+
+export type EditParams = {
+	path?: string;
+	file_path?: string;
+	edits?: EditOperationInput[];
+} & EditOperationInput;
+
+export type WriteParams = {
+	path?: string;
+	file_path?: string;
+	content?: string;
+};
 
-export type WriteParams = WriteToolInput;
+// Keep a reference to the upstream input types so the import stays meaningful
+// and future drift is visible at this seam.
+export type UpstreamEditToolInput = EditToolInput;
+export type UpstreamWriteToolInput = WriteToolInput;
 
 // A single old→new replacement extracted from an edit tool call (supports both
 // the single oldText/newText shape and the batched `edits[]` shape).