@pi-archimedes/ui 2.9.0

package/src/thinking/theme.ts

@@ -0,0 +1,156 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  highlightCode as piHighlightCode,
+  initTheme as piInitTheme,
+} from "@earendil-works/pi-coding-agent";
+import type { MarkdownTheme } from "@earendil-works/pi-tui";
+import {
+  deriveDimColor,
+  hslToRgb,
+  parseAnsiFgToRgb,
+  rgbToHsl,
+  rgbToTruecolorFg,
+  hexToRgb,
+} from "@pi-archimedes/core/color";
+
+export interface MutedThemeOptions {
+  saturationFactor?: number; // default 0.5
+  codeDefaultLightness?: number; // default 0.85 — lighter than the token dim floor
+}
+
+const DEFAULT_ANCHOR_L = 0.4;
+const DEFAULT_CODE_DEFAULT_L = 0.85;
+
+// Matches any foreground-color SGR escape: truecolor (38;2;r;g;b) or 256-palette (38;5;n).
+// We intentionally only target fg color escapes; bg (48;...) and style escapes
+// (bold/italic/reset/etc.) are left untouched.
+const FG_COLOR_ESCAPE_RE = /\x1b\[38;(?:2;\d{1,3};\d{1,3};\d{1,3}|5;\d{1,3})m/g;
+
+// pi 0.84.4's module-level `highlightCode` reads a *global* Theme
+// singleton that throws until `initTheme()` runs. pi's interactive
+// mode initializes it at startup, but contexts that build the muted
+// theme without going through that initialization (e.g. unit tests)
+// would otherwise get "Theme not initialized. Call initTheme() first."
+// We probe on first use and, only when the global is not set, call
+// `initTheme("dark")` — built-in theme, no file watcher attached.
+let piThemeReady = false;
+function ensurePiHighlightable(): void {
+  if (piThemeReady) return;
+  piThemeReady = true;
+  try {
+    piHighlightCode(""); // probe: throws when the global is unset
+  } catch (err) {
+    // Only fall back when the probe failed for the known reason, so an
+    // already-established pi theme is never clobbered by a surprise. 
+    if (String(err).includes("Theme not initialized")) piInitTheme("dark");
+  }
+}
+
+/**
+ * Rewrite every foreground-color SGR escape in `line` to its dimmed truecolor
+ * variant, preserving all other content (text, non-color escapes, resets).
+ *
+ * The cache memoizes raw→dim escape strings; callers should share a single
+ * cache across all lines in one theme-build invocation — highlightCode runs
+ * on every streaming chunk so the rewrite must be cheap.
+ */
+export function dimAnsiLine(
+  line: string,
+  anchorL: number,
+  saturationFactor: number,
+  cache: Map<string, string>,
+): string {
+  return line.replace(FG_COLOR_ESCAPE_RE, (match) => {
+    const cached = cache.get(match);
+    if (cached !== undefined) return cached;
+    const rgb = parseAnsiFgToRgb(match);
+    if (!rgb) {
+      cache.set(match, match);
+      return match;
+    }
+    // deriveDimColor takes hex; we already have rgb, so build a hex string.
+    const hex =
+      "#" +
+      [rgb.r, rgb.g, rgb.b]
+        .map((v) => v.toString(16).padStart(2, "0"))
+        .join("");
+    const dimHex = deriveDimColor(hex, anchorL, saturationFactor);
+    const dimmed = rgbToTruecolorFg(hexToRgb(dimHex));
+    cache.set(match, dimmed);
+    return dimmed;
+  });
+}
+
+export function buildMutedMarkdownTheme(
+  piTheme: Theme,
+  opts: MutedThemeOptions = {},
+): MarkdownTheme {
+  const saturationFactor = opts.saturationFactor ?? 0.5;
+  const codeDefaultL = opts.codeDefaultLightness ?? DEFAULT_CODE_DEFAULT_L;
+
+  // Anchor lightness: derived from the theme's thinkingText foreground color.
+  const thinkingAnsi = piTheme.getFgAnsi("thinkingText");
+  const anchorRgb = parseAnsiFgToRgb(thinkingAnsi);
+  const anchorHsl = anchorRgb ? rgbToHsl(anchorRgb) : null;
+  const anchorL = anchorHsl ? anchorHsl.l : DEFAULT_ANCHOR_L;
+
+  // Default fg color used for UN-highlighted chars inside code blocks.
+  // cli-highlight only emits color escapes for recognized tokens — the gaps
+  // between them (operators, whitespace, unrecognized identifiers) render in
+  // the terminal's default color (often bright white on dark themes).
+  //
+  // We build a color that harmonizes with thinkingText (same hue/saturation)
+  // but sits at a BRIGHTER lightness than the token dim floor (anchorL),
+  // so white text is dimmed noticeably less than the colored tokens. Prepend
+  // this escape per line and re-emit it after every `\x1b[39m` fg reset so
+  // the gaps inherit this color instead of the terminal default.
+  const codeDefaultFg = anchorHsl
+    ? rgbToTruecolorFg(
+      hslToRgb({
+        h: anchorHsl.h,
+        s: anchorHsl.s,
+        l: codeDefaultL,
+      }),
+    )
+    : "";
+
+  // Shared memoization cache for the entire theme lifetime.
+  const dimCache = new Map<string, string>();
+
+  const fg = (token: string, text: string) =>
+    piTheme.fg(token as Parameters<Theme["fg"]>[0], text);
+
+  return {
+    codeBlockIndent: "",
+    heading: (text) => `\x1b[1m${rgbToTruecolorFg(hexToRgb("#FFD700"))}${text}\x1b[39m\x1b[22m`,
+    link: (text) => `\x1b[4m${fg("thinkingText", text)}\x1b[24m`,
+    linkUrl: (text) => fg("dim", text),
+    code: (text) => fg("dim", text),
+    codeBlock: (text) => fg("thinkingText", text),
+    codeBlockBorder: (text) => fg("dim", text),
+    quote: (text) => fg("thinkingText", text),
+    quoteBorder: (text) => fg("dim", text),
+    hr: (text) => fg("dim", text),
+    listBullet: (text) => fg("dim", text),
+    bold: (text) => `\x1b[1m${rgbToTruecolorFg(hexToRgb("#FFD700"))}${text}\x1b[39m\x1b[22m`,
+    italic: (text) => `\x1b[3m${text}\x1b[23m`,
+    strikethrough: (text) => `\x1b[9m${fg("dim", text)}\x1b[29m`,
+    underline: (text) => `\x1b[4m${fg("thinkingText", text)}\x1b[24m`,
+    highlightCode: (code, lang) => {
+      ensurePiHighlightable();
+      const lines = piHighlightCode(code, lang);
+      return lines.map((l) => {
+        const dimmed = dimAnsiLine(l, anchorL, saturationFactor, dimCache);
+        if (!codeDefaultFg) return dimmed;
+        // Blanket the line in the code-default color; after every fg reset
+        // (emitted by cli-highlight between colored tokens) re-open the
+        // default so un-tokenized chars inherit it.
+        const withDefault = dimmed.replace(
+          /\x1b\[39m/g,
+          `\x1b[39m${codeDefaultFg}`,
+        );
+        return `${codeDefaultFg}${withDefault}\x1b[39m`;
+      });
+    },
+  };
+}

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/transform.ts

@@ -0,0 +1,21 @@
+import { unindentCodeBlocks } from "./unindent.js";
+
+/**
+ * message_end handler: mutate thinking content before it reaches the UI.
+ *
+ * Only does unindent of fenced code blocks. The "Thinking..." label is
+ * prepended inside updateContent (patch.ts) so it appears during streaming,
+ * not just after thinking completes.
+ */
+export function transformThinkingContent(
+	message: { role: string; content: Array<{ type: string; thinking?: string }> },
+): void {
+	if (message.role !== "assistant") return;
+
+	for (const content of message.content) {
+		if (content.type === "thinking" && content.thinking?.trim()) {
+			const trimmed = content.thinking.trim();
+			content.thinking = unindentCodeBlocks(trimmed);
+		}
+	}
+}

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");
+      }),
+    );
+  });
+});

package/src/thinking/unindent.ts

@@ -0,0 +1,74 @@
+/**
+ * Strip common leading whitespace and trailing blank lines from every fenced
+ * code block in `text`.  Returns the transformed string.
+ *
+ * Algorithm per block:
+ * 0. Normalize `\r\n` → `\n` in the full input text before processing.
+ * 1. Find the minimum leading whitespace across all non-empty lines.
+ * 2. Strip that many characters from the start of every line
+ *    (empty lines stay empty — they contribute no content but preserve structure).
+ * 3. Pop trailing empty lines.
+ *
+ * Trailing blank lines are ALWAYS stripped, even from 0-indent blocks.
+ * Leading whitespace is only stripped when minIndent > 0.
+ * Blocks containing only whitespace are left untouched.
+ *
+ * Known limitations:
+ * - Only space-based indentation is handled (tabs are not expanded).
+ * - If one line has 0 indent and others have N indent, nothing is stripped
+ *   (minIndent === 0). This is standard textwrap.dedent behavior.
+ * - Fenced code blocks using 4+ backticks may be misparsed. The regex uses a
+ *   negative lookahead to reject 4+ backtick openings (`/^(```(?!`))/
+ * - Line endings in the output are always `\n` (CRLF input is normalized).
+ */
+export function unindentCodeBlocks(text: string): string {
+	// Step 0: normalize CRLF → LF
+	text = text.replace(/\r\n/g, "\n");
+
+	// Regex matches fenced code blocks with 3 backticks (not 4+).
+	// Group 1: opening fence
+	// Group 2: language tag (may be empty)
+	// Group 3: block content (everything between fences)
+	// Group 4: closing fence
+	const regex = /^(```(?!`))([^\n]*)\n([\s\S]*?)^(```(?!`))[ \t]*$/gm;
+
+	return text.replace(regex, (match, opening, lang, content, closing) => {
+		const lines = content.split("\n");
+
+		// Check if all lines are empty or whitespace-only → leave untouched
+		const allWhitespace = lines.every((line: string) => line.trim() === "");
+		if (allWhitespace) {
+			return match;
+		}
+
+		// Find minimum leading space count across non-empty lines
+		let minIndent = Infinity;
+		for (const line of lines) {
+			if (line.length === 0) continue; // skip empty lines
+			const m = line.match(/^( +)/);
+			if (m) {
+				minIndent = Math.min(minIndent, m[1].length);
+			} else {
+				// Line has no leading spaces → minIndent is 0
+				minIndent = 0;
+				break;
+			}
+		}
+
+		// Strip common leading whitespace (only if minIndent > 0)
+		if (minIndent > 0 && minIndent !== Infinity) {
+			for (let i = 0; i < lines.length; i++) {
+				if (lines[i].length >= minIndent) {
+					lines[i] = lines[i].slice(minIndent);
+				}
+			}
+		}
+
+		// Pop trailing empty lines
+		while (lines.length > 0 && lines[lines.length - 1] === "") {
+			lines.pop();
+		}
+
+		return `${opening}${lang}\n${lines.join("\n")}\n${closing}`;
+	});
+}