@pi-archimedes/core 0.2.0

package/src/startup/sections.ts

@@ -0,0 +1,266 @@
+import { clampLine, stripAnsi } from "../text.js";
+import { gray, rgb, extractRgb, lerp } from "../color.js";
+import { TRUECOLOR } from "./logo.js";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+// ── Types ──────────────────────────────────────────────────────
+
+export const SECTION_KEYS = ["Models", "Context", "Prompts", "Skills", "Extensions", "Themes"] as const;
+export type SectionKey = (typeof SECTION_KEYS)[number];
+type RenderSectionKey = SectionKey | "Version";
+
+export interface ParsedSection {
+  name: SectionKey;
+  items: string[];
+}
+
+interface RenderSection {
+  name: RenderSectionKey;
+  items: string[];
+}
+
+// ── Animation constants ────────────────────────────────────────
+
+export const RAMP_FRAMES = 22;
+export const STAGGER_FRAMES = 0;
+export const BASE_FADE_DELAY = 3;
+export const MAX_STAGGER = BASE_FADE_DELAY + 5 * STAGGER_FRAMES;
+
+// ── Section detection & parsing ────────────────────────────────
+
+export function detectSection(plain: string): SectionKey | undefined {
+  for (const key of SECTION_KEYS) {
+    if (plain.includes(`[${key}]`)) return key;
+  }
+  return undefined;
+}
+
+export function parseSectionText(plain: string): ParsedSection | undefined {
+  const sectionName = detectSection(plain);
+  if (!sectionName) return undefined;
+
+  const names: string[] = [];
+  const lines = plain.split("\n");
+  let currentSource = "";
+  let sourceIndent = 0;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("[")) continue;
+    if (/^(user|project|path)$/.test(trimmed)) { currentSource = ""; sourceIndent = 0; continue; }
+
+    const indent = line.length - line.trimStart().length;
+
+    // Track package source headers (e.g. "git:github.com/...", "npm:@foo/bar")
+    // Extract name from the header itself + let children inherit the prefix
+    if (/^(git:|npm:)\S+\//.test(trimmed)) {
+      currentSource = trimmed.startsWith("git:") ? "git:" : "npm:";
+      sourceIndent = indent;
+      // Extract name from source header (e.g. "npm:@foo/pi-tavily-tools" → "npm:pi-tavily-tools")
+      const showSource = sectionName === "Extensions" || sectionName === "Skills";
+      const name = extractName(trimmed, sectionName);
+      if (name && showSource) names.push(name);
+      continue;
+    }
+
+    // Reset source prefix when indent returns to source level or shallower
+    if (currentSource && indent <= sourceIndent) {
+      currentSource = "";
+      sourceIndent = 0;
+    }
+
+    if (/^(index\.(ts|js)|src|dist|out|build|lib|bin)$/i.test(trimmed)) continue;
+    // Skip resolved file paths only under source headers (e.g. "dist/index.js" under npm:)
+    if (currentSource) {
+      if (/\/(src|dist|out|build|lib|bin)\//.test(trimmed)) continue;
+      if (/\.(ts|js)$/.test(trimmed) && trimmed.includes("/") && !/SKILL\.(ts|js)$/i.test(trimmed)) continue;
+    }
+
+    const name = extractName(trimmed, sectionName);
+    // Prompts/Context don't need source prefix — only Extensions/Skills
+    const showSource = sectionName === "Extensions" || sectionName === "Skills";
+    if (name) names.push(showSource && currentSource ? currentSource + name : name);
+  }
+
+  // Deduplicate by bare name (without prefix) — prefer prefixed version
+  const seen = new Map<string, string>();
+  for (const n of names) {
+    if (/^(index|dist|src|out|lib|bin)$/i.test(n)) continue;
+    const bare = n.replace(/^(npm:|git:)/, "");
+    if (!seen.has(bare) || n.includes(":")) seen.set(bare, n);
+  }
+  return { name: sectionName, items: [...seen.values()] };
+}
+
+export function parseModelScope(plain: string): ParsedSection | undefined {
+  const m = plain.match(/Model scope:\s*(.+)/i);
+  if (!m) return undefined;
+  const raw = m[1].replace(/\s*\(Ctrl\+\w[\w\s]*\)/gi, "");
+  const items = raw.split(",").map(s => s.trim()).filter(Boolean);
+  return items.length > 0 ? { name: "Models", items } : undefined;
+}
+
+// ── Name extraction helpers ────────────────────────────────────
+
+function detectOrigin(path: string): { prefix: string; clean: string } {
+  if (/^npm:/.test(path)) return { prefix: "npm:", clean: path.slice(4) };
+  if (/^git:/.test(path)) return { prefix: "git:", clean: path.slice(4) };
+  if (/^https?:\/\//.test(path)) return { prefix: "git:", clean: path };
+  return { prefix: "", clean: path };
+}
+
+function cleanName(name: string): string {
+  return name.replace(/\.(ts|js|json|md|git)$/i, "");
+}
+
+type Extractor = (clean: string, prefix: string) => string;
+
+const defaultExtract: Extractor = (clean, prefix) =>
+  prefix + cleanName(clean.split("/").pop() ?? clean);
+
+const sectionExtractors: Record<SectionKey, Extractor> = {
+  Models: defaultExtract,
+  Themes: defaultExtract,
+  Prompts: (clean) => {
+    const base = clean.split("/").pop() ?? clean;
+    return cleanName(base) || clean;
+  },
+  Context: (clean) => clean.split("/").pop() ?? clean,
+  Skills: (clean, prefix) => {
+    if (!clean.includes("/")) return defaultExtract(clean, prefix);
+    const parts = clean.split("/");
+    const file = parts.pop() ?? "";
+    if (/^SKILL\.(md|ts|js)$/i.test(file)) {
+      return prefix + cleanName(parts.pop() ?? file);
+    }
+    return prefix + cleanName(file);
+  },
+  Extensions: (clean, prefix) => {
+    const stripped = clean.replace(/^https?:\/\/[^/]+\//, "");
+    const parts = stripped.split("/").filter(p => {
+      const lower = p.toLowerCase();
+      return p && !/^(index\.(ts|js)|src|dist|out|build|lib|bin)$/.test(lower);
+    });
+    if (parts.length > 0) return prefix + cleanName(parts.pop()!);
+    return prefix + cleanName(clean);
+  },
+};
+
+export function extractName(path: string, section: SectionKey): string {
+  const trimmed = path.trim();
+  const { prefix, clean } = detectOrigin(trimmed);
+  return sectionExtractors[section](clean, prefix);
+}
+
+// ── Column formatter ───────────────────────────────────────────
+
+function pad(s: string, w: number): string {
+  const vw = visibleWidth(s);
+  return vw >= w ? s : s + " ".repeat(w - vw);
+}
+
+export function formatColumns(sections: RenderSection[], theme: Theme, maxW: number, ref: { frame: number; revealed: boolean; revealedAt: number; scaffoldAt: number; settled: boolean }): string[] {
+  if (sections.length === 0) return [];
+
+  const dim = (t: string) => theme.fg("dim", t);
+  const muted = (t: string) => theme.fg("muted", t);
+
+  const headerW = Math.max(...sections.map(s => s.name.length + 2)) + 2;
+
+  const itemAge = ref.revealed ? ref.frame - ref.revealedAt : 0;
+  const labelAge = ref.revealed ? ref.frame - ref.scaffoldAt : 0;
+
+  // RGB endpoints for fade ramps (truecolor only)
+  const fadeStartRgb: [number, number, number] = [20, 20, 20];
+  let dimRgb: [number, number, number] | undefined;
+  let mutedRgb: [number, number, number] | undefined;
+  const labelRamping = TRUECOLOR && ref.revealed && labelAge < RAMP_FRAMES + MAX_STAGGER;
+  const itemRamping = TRUECOLOR && ref.revealed && itemAge < RAMP_FRAMES + MAX_STAGGER;
+  if (labelRamping || itemRamping) {
+    dimRgb = extractRgb(theme.fg("dim", " "));
+    mutedRgb = extractRgb(theme.fg("muted", " "));
+  }
+
+  const lines: string[] = [];
+
+  for (let si = 0; si < sections.length; si++) {
+    const sec = sections[si];
+    if (sec.items.length === 0) continue;
+
+    const availableW = maxW - headerW - 1;
+
+    // Label fade: near-invisible → dim (static dim when not revealed)
+    const secLabelAge = Math.max(0, labelAge - BASE_FADE_DELAY - si * STAGGER_FRAMES);
+    const wrapLabel = ref.revealed
+      ? buildItemWrapper(secLabelAge, true, fadeStartRgb, dimRgb, dim)
+      : dim;
+    const header = wrapLabel(`[${sec.name}]`);
+    const paddedHeader = header + " ".repeat(Math.max(0, headerW - sec.name.length - 2));
+
+    // Item fade: near-invisible → muted
+    const secItemAge = Math.max(0, itemAge - BASE_FADE_DELAY - si * STAGGER_FRAMES);
+    const wrapItems = buildItemWrapper(secItemAge, ref.revealed, fadeStartRgb, mutedRgb, muted);
+
+    // Style prefix (npm:/git:) dimmer than the name
+    const styleItem = (raw: string): string => {
+      const prefixMatch = raw.match(/^(npm:|git:)/);
+      if (prefixMatch) {
+        const pfx = prefixMatch[1];
+        const name = raw.slice(pfx.length);
+        return wrapLabel(pfx) + wrapItems(name);
+      }
+      return wrapItems(raw);
+    };
+
+    let currentLine = "";
+    let currentStyled = "";
+    let firstLine = true;
+
+    for (const item of sec.items) {
+      const itemW = visibleWidth(item);
+      const currentW = visibleWidth(currentLine);
+
+      if (currentLine && currentW + 2 + itemW > availableW) {
+        lines.push(firstLine ? `${paddedHeader} ${currentStyled}` : " ".repeat(headerW + 1) + currentStyled);
+        currentLine = item;
+        currentStyled = styleItem(item);
+        firstLine = false;
+      } else {
+        currentLine = currentLine ? currentLine + "  " + item : item;
+        currentStyled = currentStyled ? currentStyled + "  " + styleItem(item) : styleItem(item);
+      }
+    }
+    if (currentLine) {
+      const rawLine = firstLine ? `${paddedHeader} ${currentStyled}` : " ".repeat(headerW + 1) + currentStyled;
+      lines.push(clampLine(rawLine, maxW));
+    }
+
+    if (sec.name === "Version") {
+      lines.push("");
+    }
+  }
+
+  return lines;
+}
+
+export function buildItemWrapper(
+  sectionAge: number,
+  revealed: boolean,
+  startRgb: [number, number, number] | undefined,
+  mutedRgb: [number, number, number] | undefined,
+  muted: (t: string) => string,
+): (text: string) => string {
+  if (!revealed) return (text) => text; // placeholders already styled
+
+  // No truecolor or ramp done → static muted
+  if (!startRgb || !mutedRgb || sectionAge >= RAMP_FRAMES) return muted;
+
+  const t = Math.min(1, sectionAge / RAMP_FRAMES);
+  const eased = 1 - (1 - t) * (1 - t);
+  const r = lerp(startRgb[0], mutedRgb[0], eased);
+  const g = lerp(startRgb[1], mutedRgb[1], eased);
+  const b = lerp(startRgb[2], mutedRgb[2], eased);
+  return (text) => rgb(r, g, b, text);
+}

package/src/startup/version.ts

@@ -0,0 +1,26 @@
+const NPM_REGISTRY_URL = "https://registry.npmjs.org/@earendil-works/pi-coding-agent/latest";
+const FETCH_TIMEOUT_MS = 4000;
+
+export async function fetchLatestVersion(): Promise<string | undefined> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(NPM_REGISTRY_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!res.ok) return undefined;
+    const data = (await res.json()) as { version?: string };
+    return data.version;
+  } catch {
+    return undefined;
+  }
+}
+
+export function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^v/, "").split(".").map(Number);
+  const pb = b.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return 1;
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return -1;
+  }
+  return 0;
+}

package/src/text.ts

@@ -0,0 +1,42 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+// Inline stripSgr — narrow SGR-only strip (no trim) for char-level checks
+const stripSgr = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
+
+/** Strip ALL ANSI escapes (SGR color/style + OSC sequences). Trims whitespace. Use for text extraction. */
+export function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?(?:\x07|\x1b\\)/g, "").trim();
+}
+
+/** Clamp a line to maxW visible characters, preserving ANSI escapes. */
+export function clampLine(line: string, maxW: number): string {
+  return truncateToWidth(line, maxW);
+}
+
+/** Clamp an array of lines to maxW visible characters each. */
+export function clampLines(lines: string[], maxW: number): string[] {
+  return lines.map((l) => clampLine(l, maxW));
+}
+
+// isParentBorder uses the narrow SGR-only strip (no trim) for char-level checks
+export const isParentBorder = (s: string) => {
+  const clean = stripSgr(s);
+  return clean.length > 0 && clean[0] === "─";
+};
+
+export function formatKey(key: string | undefined): string {
+  if (!key) return "that key";
+  return key
+    .split("+")
+    .map((part) => {
+      const lower = part.toLowerCase();
+      if (lower === "ctrl") return "Ctrl";
+      if (lower === "alt") return "Alt";
+      if (lower === "shift") return "Shift";
+      if (lower === "cmd" || lower === "meta") return "Cmd";
+      return part.length === 1
+        ? part.toUpperCase()
+        : part[0]!.toUpperCase() + part.slice(1);
+    })
+    .join("+");
+}

package/src/thinking/patch.ts

@@ -0,0 +1,150 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { AssistantMessageComponent } from "@earendil-works/pi-coding-agent";
+import { Markdown, type MarkdownTheme, Spacer, Text } from "@earendil-works/pi-tui";
+import { buildMutedMarkdownTheme } from "./theme.js";
+
+// The label we prepend to visible thinking content.
+const THINKING_LABEL = "\x1b[1m\x1b[38;2;255;215;0mThinking...\x1b[39m\x1b[22m";
+
+/**
+ * Patches `AssistantMessageComponent.prototype.updateContent` so thinking
+ * blocks render with a muted `MarkdownTheme`. Called on every session_start
+ * to capture a fresh `getTheme` closure (required for /resume).
+ */
+export function patchThinkingRenderer(getTheme: () => Theme): void {
+  if (!AssistantMessageComponent) return;
+
+  const proto = AssistantMessageComponent.prototype;
+  if (
+    !proto ||
+    typeof proto.updateContent !== "function" ||
+    AssistantMessageComponent.name !== "AssistantMessageComponent"
+  ) {
+    return;
+  }
+
+  const src = proto.updateContent.toString();
+  if (
+    !src.includes('content.type === "thinking"') ||
+    !src.includes("this.markdownTheme")
+  ) {
+    return;
+  }
+
+  // Re-patch every time — /resume needs a fresh getTheme closure
+  (proto as any).updateContent = function (this: any, message: any): void {
+    this.lastMessage = message;
+
+    this.markdownTheme.codeBlockIndent = "";
+    this.contentContainer.clear();
+
+    const hasVisibleContent = message.content.some(
+      (c: any) =>
+        (c.type === "text" && c.text.trim()) ||
+        (c.type === "thinking" && c.thinking.trim()),
+    );
+
+    if (hasVisibleContent) {
+      this.contentContainer.addChild(new Spacer(1));
+    }
+
+    // Lazy muted theme: built once per updateContent call.
+    let mutedTheme: ReturnType<typeof buildMutedMarkdownTheme> | undefined;
+    let theme: Theme | undefined;
+    let themeFailed = false;
+
+    const ensureTheme = (): Theme | undefined => {
+      if (themeFailed) return undefined;
+      if (!theme) {
+        try {
+          theme = getTheme();
+        } catch {
+          themeFailed = true;
+          return undefined;
+        }
+      }
+      return theme;
+    };
+
+    const ensureMuted = (): MarkdownTheme | undefined => {
+      if (!mutedTheme) {
+        const t = ensureTheme();
+        if (!t) return undefined;
+        mutedTheme = buildMutedMarkdownTheme(t);
+      }
+      return mutedTheme;
+    };
+
+    // Render content in order.
+    for (let i = 0; i < message.content.length; i++) {
+      const content = message.content[i];
+      if (content.type === "text" && content.text.trim()) {
+        this.contentContainer.addChild(
+          new Markdown(content.text.trim(), 1, 0, this.markdownTheme),
+        );
+      } else if (content.type === "thinking" && content.thinking.trim()) {
+        const hasVisibleContentAfter = message.content
+          .slice(i + 1)
+          .some(
+            (c: any) =>
+              (c.type === "text" && c.text.trim()) ||
+              (c.type === "thinking" && c.thinking.trim()),
+          );
+
+        if (this.hideThinkingBlock) {
+          const t = ensureTheme();
+          if (!t) continue;
+          this.contentContainer.addChild(
+            new Text(t.italic(t.fg("thinkingText", this.hiddenThinkingLabel)), 1, 0),
+          );
+          if (hasVisibleContentAfter) {
+            this.contentContainer.addChild(new Spacer(1));
+          }
+        } else {
+          let thinkingContent = content.thinking.trim();
+          if (!thinkingContent.startsWith(THINKING_LABEL)) {
+            thinkingContent = `${THINKING_LABEL}\n\n${thinkingContent}`;
+          }
+          const t = ensureTheme();
+          if (!t) continue;
+          const muted = ensureMuted();
+          this.contentContainer.addChild(
+            new Markdown(thinkingContent, 1, 0, muted ?? this.markdownTheme, {
+              color: (text: string) => t.fg("thinkingText", text),
+              italic: true,
+            }),
+          );
+          if (hasVisibleContentAfter) {
+            this.contentContainer.addChild(new Spacer(1));
+          }
+        }
+      }
+    }
+
+    // Aborted/error rendering.
+    const hasToolCalls = message.content.some((c: any) => c.type === "toolCall");
+    if (!hasToolCalls) {
+      if (message.stopReason === "aborted") {
+        const abortMessage =
+          message.errorMessage && message.errorMessage !== "Request was aborted"
+            ? message.errorMessage
+            : "Operation aborted";
+        this.contentContainer.addChild(new Spacer(1));
+        const t = ensureTheme();
+        if (t) this.contentContainer.addChild(new Text(t.fg("error", abortMessage), 1, 0));
+      } else if (message.stopReason === "error") {
+        const errorMsg = message.errorMessage || "Unknown error";
+        this.contentContainer.addChild(new Spacer(1));
+        const t = ensureTheme();
+        if (t) {
+          this.contentContainer.addChild(
+            new Text(t.fg("error", `Error: ${errorMsg}`), 1, 0),
+          );
+        }
+      }
+    }
+
+    // Bottom padding so next message has breathing room
+    this.contentContainer.addChild(new Spacer(1));
+  };
+}

package/src/thinking/theme.ts

@@ -0,0 +1,132 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { highlightCode as piHighlightCode } from "@earendil-works/pi-coding-agent";
+import type { MarkdownTheme } from "@earendil-works/pi-tui";
+import {
+  deriveDimColor,
+  hslToRgb,
+  parseAnsiFgToRgb,
+  rgbToHsl,
+  rgbToTruecolorFg,
+  hexToRgb,
+} from "../color.js";
+
+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;
+
+/**
+ * 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) => {
+      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.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);
+		}
+	}
+}