omp-uwu 0.3.0 → 0.4.0

package/README.md

@@ -26,6 +26,8 @@ Restart omp. uwu mode is **on** by default in every session.
 
 The palette colors chat markdown and the user-message bubble without putting ANSI codes into message text/history. It is applied as an in-memory TUI theme; components sharing those colors can change too. The host's in-memory theme setter pauses automatic theme detection until omp restarts. The TUI also shows a theme-accent `(◕ᴗ◕✿) uwu` status badge; other clients/plain output are not colorized.
 
+With colors on, the TUI also paints **sparkles** in the agent's chat prose: `uwu`/`owo` get a per-letter pastel rainbow, and kaomoji (listed or not, e.g. `(◕ᴗ◕✿)`, `(ﾉ◕ヮ◕)ﾉ`) and glyphs like `♡ ☆ ✧ ✿` get a pastel tint. This happens at render time through omp's per-message text color transform, which only ever sees plain prose runs, so inline code, code blocks, link targets and the stored message text stay untouched. omp's `AssistantMessageComponent` is not part of the extension API, so the plugin finds it through its shared `Container` base class when the first assistant message is created; if a future omp changes that shape, sparkles are simply skipped and the palette still applies.
+
 ## What gets uwufied, and what doesn't
 
 | uwufied | kept byte-for-byte |
@@ -36,7 +38,7 @@ The palette colors chat markdown and the user-message bubble without putting ANS
 | | Tool-call arguments and file contents the agent writes or edits |
 | | Commit messages and prompts sent to subagents |
 
-Style rules include `r`/`l` → `w`, occasional `th` → `d`, `na/ne/no` → `nya/nye/nyo`, occasional stutter, and a broad rotating selection of kaomoji. The kaomoji selection includes examples from [kaomoji.you](https://kaomoji.you/), such as `٩(◕‿◕｡)۶`, `(ฅ^•ﻌ•^ฅ)`, and `(づ｡◕‿‿◕｡)づ`. Meaning, numbers and warnings must stay readable.
+Style rules include `r`/`l` → `w`, occasional `th` → `d`, `na/ne/no` → `nya/nye/nyo`, occasional stutter, a broad rotating selection of kaomoji, and the odd cute emoji (`✨ 💖 🌸 🎀`). The kaomoji selection includes examples from [kaomoji.you](https://kaomoji.you/), such as `٩(◕‿◕｡)۶`, `(ฅ^•ﻌ•^ฅ)`, and `(づ｡◕‿‿◕｡)づ`. Meaning, numbers and warnings must stay readable.
 
 Here's the same prompt and model, with the mode off and on:
 
@@ -66,7 +68,7 @@ The hook runs after streaming has finished. The TUI refreshes the current assist
 
 ```sh
 omp plugin install omp-uwu          # from npm (recommended)
-omp plugin install omp-uwu@0.3.0    # pin a version
+omp plugin install omp-uwu@0.4.0    # pin a version
 omp plugin uninstall omp-uwu        # remove
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-uwu",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "omp extension for playful uwu chat styling, markdown-safe rewrites, and kawaii kaomoji",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -1,6 +1,7 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { KawaiiTheme } from "./kawaii.ts";
+import { type ContainerClass, installSparkles, sparkle, themePaint } from "./sparkle.ts";
 
 import type { ExtensionAPI, Theme } from "@oh-my-pi/pi-coding-agent";
 import { uwufy } from "./uwufy.ts";
@@ -10,8 +11,9 @@ export const UWU_PROMPT = `
 Write your prose replies to the user in playful "uwu" speak:
 - replace r/l with w in most words ("weawwy", "hewwo"), "th" → "d" occasionally, "na/ne/no" → "nya/nye/nyo" sometimes
 - occasional stutter ("h-hewwo") and cute kaomoji/emoticons, varied naturally: (◕ᴗ◕✿), (o^▽^o), (´｡• ω •｡\u0060), ٩(◕‿◕｡)۶, (✧ω✧), (๑˃ᴗ˂)ﻭ, ヽ(・∀・)ﾉ, (っ˘ω˘ς), (｡•̀ᴗ-)✧, (づ｡◕‿‿◕｡)づ, (ฅ^•ﻌ•^ฅ), (๑>◡<๑), owo, >w<, ^w^, :3; at most one at a sentence end
+- now and then a cute emoji or sparkle instead (✨, 💖, 🌸, 🎀, ♡, ☆), never more than one per paragraph
 - keep it readable; never let the style hide meaning, numbers or warnings
-- colors are only for UI chrome; never insert ANSI color codes into chat text
+- the TUI colors kaomoji, uwu and sparkles by itself; never insert ANSI color codes into chat text
 
 NEVER uwufy any of these — keep them exact and byte-for-byte correct:
 - code, code blocks, inline code, shell commands, file paths, URLs, identifiers, config keys, error messages you quote
@@ -62,6 +64,14 @@ export default function uwuExtension(pi: ExtensionAPI) {
     ctx.ui.setStatus("omp-uwu", badge && ctx.ui.theme ? ctx.ui.theme.fg("accent", badge) : badge);
   };
 
+  // Paints kaomoji/uwu in rendered chat prose at display time only (see sparkle.ts).
+  // Installed at load so the first assistant component, even a resumed one, is caught.
+  const paint = themePaint(() => pi.pi.theme);
+  const host = pi.pi as { Container?: ContainerClass };
+  if (host.Container) {
+    installSparkles(host.Container, { isActive: () => enabled && colorsEnabled, transform: (text) => sparkle(text, paint) });
+  }
+
   const syncColors = (ctx: UiContext) => {
     if (ctx.mode !== "tui" || ctx.agent?.kind === "sub" || !ctx.ui?.theme) return;
     if (enabled && colorsEnabled) kawaiiTheme.enable(ctx.ui.theme);

package/src/kawaii.ts

@@ -57,7 +57,7 @@ export function buildKawaiiTheme(ThemeClass: ThemeRuntime["Theme"], base: Theme)
   }
 
   const preset = base.getSymbolPreset();
-  return new ThemeClass(
+  const theme = new ThemeClass(
     fg as Record<ThemeColor, string>,
     bg as Record<ThemeBg, string>,
     base.getColorMode(),
@@ -65,6 +65,15 @@ export function buildKawaiiTheme(ThemeClass: ThemeRuntime["Theme"], base: Theme)
     {},
     { status: base.getSpinnerFrames("status"), activity: base.getSpinnerFrames("activity") },
   );
+  // A nested colored span (a sparkle, an inline code span) ends in a
+  // foreground reset, which would drop the enclosing heading/link color for the
+  // rest of the span. Switch back to the enclosing color there instead.
+  const plainFg = theme.fg.bind(theme);
+  theme.fg = (color, text) => {
+    const open = theme.getFgAnsi(color);
+    return plainFg(color, open === FG_DEFAULT ? text : text.replaceAll(FG_DEFAULT, open));
+  };
+  return theme;
 }
 
 /** A reversible, ephemeral kawaii theme; never edits the user's theme file. */

package/src/sparkle.ts

@@ -0,0 +1,187 @@
+/**
+ * Render-time "sparkles": paints kaomoji, uwu/owo and cute symbols in the
+ * assistant's chat prose with the kawaii palette.
+ *
+ * Nothing is written into message text, history or model context. omp renders
+ * assistant prose through a per-component text color transform that Markdown
+ * applies to plain-text runs only — never to inline code, code blocks or link
+ * targets — so painting there leaves every exact-text surface untouched.
+ */
+import type { Theme, ThemeColor } from "@oh-my-pi/pi-coding-agent";
+import { EMOTICON_TOKENS } from "./uwufy.ts";
+
+/** Palette keys the kawaii theme sets; painting rotates through them. */
+const TONES: readonly ThemeColor[] = ["accent", "mdLink", "mdCode", "mdListBullet", "mdHeading", "thinkingText"];
+
+/**
+ * Decorative monochrome glyphs worth a tint on their own. Color emoji ignore fg,
+ * and a glyph carrying VS16 renders as emoji, so those are left alone.
+ */
+const SYMBOLS = "♡✧☆★✿❀⋆";
+
+// Known emoticons, longest first so a kaomoji wins over the uwu/♡ inside it.
+// Word-edge guards keep `:3` in `a:3` or `owo` in `owowl` unpainted.
+const KNOWN = [...EMOTICON_TOKENS]
+	.filter((token) => !/^\p{Extended_Pictographic}+$/u.test(token))
+	.sort((a, b) => b.length - a.length)
+	.map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+	.join("|");
+// Unlisted kaomoji: parentheses holding at least one face feature (eyes,
+// mouths, cheeks), no digits and no two letters in a row, optionally hugged by
+// up to two arm glyphs, and not glued to a word. So `(x−y)`, `(a—b)`,
+// `(şimdi)` and `ş(a…)ı` stay plain.
+const FEATURES = "◕ᴗω▽◡•ᵔ˘≧≦˃˂・･︶﹏‿꒳ᗜﻌ∀ヮ´︿◉⊙ಠ︵□ᴥ＾｡⌒⩊ᵕ≖ˆ˶˵ᐛ⁀﹃ↀ✧♡";
+const ARMS = String.raw`٩۶ヽﾉノづっ✧♡☆⌒ヾᕕᕗ\\/`;
+const FACE = String.raw`(?<![\p{L}\p{N}])[${ARMS}]{0,2}\((?=[^()\n]*[${FEATURES}])(?![^()\n]*(?:\p{L}\p{M}*){2})[^()\n\p{N}]{1,16}\)[${ARMS}]{0,2}(?![\p{L}\p{N}])`;
+// Symbols take their combining marks along, so no color code splits a grapheme.
+const SPARKLE = new RegExp(
+	String.raw`(?<![\p{L}\p{N}_])(?:${KNOWN})(?![\p{L}\p{N}_])|${FACE}|[${SYMBOLS}](?!\p{M}*\uFE0F)\p{M}*`,
+	"gu",
+);
+const LETTERS = /^\p{L}+$/u;
+
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export type Paint = (tone: ThemeColor, text: string) => string;
+
+/** FNV-1a; picks a stable starting tone per token. */
+function hash(value: string): number {
+	let h = 0x811c9dc5;
+	for (let i = 0; i < value.length; i++) h = Math.imul(h ^ value.charCodeAt(i), 0x01000193);
+	return h >>> 0;
+}
+
+/**
+ * Paint every sparkle in one plain-text run. Word emoticons (`uwu`, `OwO`) get
+ * a per-letter rainbow; faces and symbols get one tone. Deterministic, so a
+ * re-render of the same run yields the same bytes.
+ */
+export function sparkle(text: string, paint: Paint): string {
+	let ordinal = 0;
+	return text.replace(SPARKLE, (match) => {
+		const start = hash(match) + ordinal++;
+		if (!LETTERS.test(match)) return paint(TONES[start % TONES.length]!, match);
+		let index = 0;
+		let out = "";
+		for (const { segment } of graphemes.segment(match)) out += paint(TONES[(start + index++) % TONES.length]!, segment);
+		return out;
+	});
+}
+
+/** A paint function over the live host theme; unknown colors fall back to plain text. */
+export function themePaint(getTheme: () => Theme | undefined): Paint {
+	return (tone, text) => {
+		try {
+			return getTheme()?.fg(tone, text) ?? text;
+		} catch {
+			return text;
+		}
+	};
+}
+
+type ColorTransform = (text: string) => string;
+
+/** The two public methods of omp's AssistantMessageComponent this relies on. */
+interface AssistantPrototype {
+	updateContent(...args: unknown[]): unknown;
+	setTextColorTransform(transform?: ColorTransform): void;
+}
+
+/** omp's TUI `Container`, the base class of AssistantMessageComponent. */
+export interface ContainerClass {
+	prototype: { addChild(child: unknown): unknown };
+}
+
+export interface SparkleControl {
+	/** Whether new/updated assistant messages should be painted. */
+	isActive(): boolean;
+	/** Stable transform identity; Markdown caches renders by it. */
+	transform: ColorTransform;
+}
+
+/** Process-wide state, so extension reloads swap the control instead of re-patching. */
+interface Registry {
+	control?: SparkleControl;
+	assistant?: AssistantPrototype;
+	watching?: boolean;
+}
+const REGISTRY = Symbol.for("omp-uwu.sparkles");
+
+/** Walk up from an instance to the prototype that defines both assistant methods. */
+function findAssistantPrototype(value: unknown): AssistantPrototype | undefined {
+	for (let proto = value && typeof value === "object" ? Object.getPrototypeOf(value) : null; proto; proto = Object.getPrototypeOf(proto)) {
+		if (
+			Object.hasOwn(proto, "setTextColorTransform") &&
+			Object.hasOwn(proto, "updateContent") &&
+			typeof proto.setTextColorTransform === "function" &&
+			typeof proto.updateContent === "function"
+		) {
+			return proto as AssistantPrototype;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Give every assistant message component the sparkle transform while
+ * `control.isActive()`. A transform set by the host itself (e.g. the
+ * live-voice transcript tint) always wins over sparkles.
+ */
+function patchAssistant(proto: AssistantPrototype, registry: Registry): void {
+	const originalSet = proto.setTextColorTransform;
+	const originalUpdate = proto.updateContent;
+	const hostTransforms = new WeakMap<object, ColorTransform>();
+	const applied = new WeakMap<object, ColorTransform | undefined>();
+
+	proto.setTextColorTransform = function (this: object, transform?: ColorTransform) {
+		if (transform) hostTransforms.set(this, transform);
+		else hostTransforms.delete(this);
+		applied.delete(this);
+		originalSet.call(this, transform);
+	};
+	// Theme changes re-enter updateContent through invalidate(), so toggling
+	// colors repaints existing messages too.
+	proto.updateContent = function (this: object, ...args: unknown[]) {
+		if (!hostTransforms.has(this)) {
+			const control = registry.control;
+			const wanted = control?.isActive() ? control.transform : undefined;
+			if (applied.get(this) !== wanted) {
+				applied.set(this, wanted);
+				originalSet.call(this, wanted);
+			}
+		}
+		return originalUpdate.apply(this, args);
+	};
+}
+
+/**
+ * Hook sparkles into omp's AssistantMessageComponent.
+ *
+ * That class is not part of the extension API, and importing its module by
+ * path loads a second, unused copy when omp runs from its bundle. What
+ * extensions do share with the host is `Container`, its base class, and the
+ * component adds its first child in its constructor before any content
+ * update. So `addChild` is watched until the first assistant component shows
+ * up, its prototype is patched, and the watch is removed again.
+ */
+export function installSparkles(Container: ContainerClass, control: SparkleControl): void {
+	const holder = globalThis as { [REGISTRY]?: Registry };
+	const registry = (holder[REGISTRY] ??= {});
+	registry.control = control;
+	if (registry.assistant || registry.watching) return;
+
+	registry.watching = true;
+	const containerProto = Container.prototype;
+	const originalAdd = containerProto.addChild;
+	const watch = function (this: object, child: unknown) {
+		const assistant = findAssistantPrototype(this) ?? findAssistantPrototype(child);
+		if (assistant) {
+			if (containerProto.addChild === watch) containerProto.addChild = originalAdd;
+			registry.watching = false;
+			registry.assistant = assistant;
+			patchAssistant(assistant, registry);
+		}
+		return originalAdd.call(this, child);
+	};
+	containerProto.addChild = watch;
+}

package/src/uwufy.ts

@@ -23,10 +23,11 @@ export const EMOTICONS = [
 	"(♡˙︶˙♡)", "ヽ(♡‿♡)ノ", "(´꒳`)♡", "(ﾉ´ з `)ノ", "ヾ(・ω・*)",
 	"(⌒ω⌒)ﾉ", "(ᵔ⩊ᵔ)", "(=^･ω･^=)", "(ฅ^•ﻌ•^ฅ)", "(ᵕ—ᴗ—)",
 	"(｡•̀ᴗ-)✧", "(づ｡◕‿‿◕｡)づ", "(っ´▽`)っ", "( ˶ˆᗜˆ˵ )", "(๑>◡<๑)",
+	"✨", "💖", "🌸", "🎀",
 ] as const;
 
 /** Tokens treated as emoticons: never counted as words, never rewritten. */
-const EMOTICON_TOKENS = new Set<string>([
+export const EMOTICON_TOKENS: ReadonlySet<string> = new Set<string>([
 	...EMOTICONS,
 	"UwU",
 	"OwO",