@workweave/router 0.2.6 → 0.2.7

package/pi-router/src/wooly.ts

@@ -0,0 +1,408 @@
+/**
+ * Wooly's animation-only terminal component, extracted from Loom's default
+ * text renderer. The coaching reader, narration state, high-resolution image
+ * transport, and video-game dialogue box deliberately do not live in this
+ * extension.
+ */
+
+import type { Component, TUI } from "@mariozechner/pi-tui";
+
+type Rgb = readonly [red: number, green: number, blue: number];
+type Pixel = Rgb | null;
+type Canvas = Pixel[][];
+type WoolyAnimation = "wave" | "jump" | "spin" | "retract";
+
+type SpriteSpec = {
+	width: number;
+	pixelHeight: number;
+	bodyX: number;
+	bodyY: number;
+	bodyRadius: number;
+	legBottom: number;
+	compact: boolean;
+};
+
+const RESET = "\x1b[0m";
+const WOOLY_ORANGE: Rgb = [235, 73, 28];
+const WOOLY_BLACK: Rgb = [34, 29, 27];
+const HORIZONTAL_SUBPIXELS = 2;
+const QUADRANT_GLYPHS = [" ", "▘", "▝", "▀", "▖", "▌", "▞", "▛", "▗", "▚", "▐", "▜", "▄", "▙", "▟", "█"] as const;
+const FULL_SPEC: SpriteSpec = {
+	width: 21,
+	pixelHeight: 14,
+	bodyX: 10,
+	bodyY: 5,
+	bodyRadius: 4.5,
+	legBottom: 13,
+	compact: false,
+};
+const COMPACT_SPEC: SpriteSpec = {
+	width: 15,
+	pixelHeight: 10,
+	bodyX: 7,
+	bodyY: 3.5,
+	bodyRadius: 3,
+	legBottom: 9,
+	compact: true,
+};
+const FRAME_COUNT = 8;
+const ANIMATION_SEQUENCE: readonly WoolyAnimation[] = ["wave", "jump", "spin", "retract"];
+const WAVE_LIFT = [0, 0.45, 1, 1, 1, 1, 0.55, 0.2] as const;
+const WAVE_SWAY = [0, 0, -1, 1, -1, 1, 0, 0] as const;
+const JUMP_OFFSETS = [0, 1, 1, 1, 1, 1, 1, 0] as const;
+const JUMP_TUCK = [0, 0, 1, 1, 1, 1, 0, 0] as const;
+const RETRACT_AMOUNT = [0, 0.35, 0.7, 1, 1, 0.7, 0.35, 0] as const;
+const MIN_VISIBLE_WIDTH = 20;
+const MIN_VISIBLE_ROWS = 18;
+const MIN_FULL_WIDTH = 44;
+const MIN_FULL_ROWS = 30;
+const LEFT_PADDING = 2;
+
+export const WOOLY_FRAME_INTERVAL_MS = 200;
+export const WOOLY_ANIMATION_DELAY_MS = 5_000;
+
+function foreground([red, green, blue]: Rgb): string {
+	return `\x1b[38;2;${red};${green};${blue}m`;
+}
+
+function background([red, green, blue]: Rgb): string {
+	return `\x1b[48;2;${red};${green};${blue}m`;
+}
+
+function colorsMatch(first: Rgb, second: Rgb): boolean {
+	return first[0] === second[0] && first[1] === second[1] && first[2] === second[2];
+}
+
+function averageColors(colors: Rgb[]): Rgb {
+	const totals = colors.reduce(
+		(sum, color) => [sum[0] + color[0], sum[1] + color[1], sum[2] + color[2]],
+		[0, 0, 0],
+	);
+	return [
+		Math.round(totals[0] / colors.length),
+		Math.round(totals[1] / colors.length),
+		Math.round(totals[2] / colors.length),
+	];
+}
+
+function colorDistance(first: Rgb, second: Rgb): number {
+	return (first[0] - second[0]) ** 2 + (first[1] - second[1]) ** 2 + (first[2] - second[2]) ** 2;
+}
+
+function renderQuadrantBlock(topLeft: Pixel, topRight: Pixel, bottomLeft: Pixel, bottomRight: Pixel): string {
+	const pixels = [topLeft, topRight, bottomLeft, bottomRight] as const;
+	let occupiedMask = 0;
+	let featureMask = 0;
+	const yarnColors: Rgb[] = [];
+	for (let index = 0; index < pixels.length; index++) {
+		const pixel = pixels[index];
+		if (pixel === null) continue;
+		occupiedMask |= 1 << index;
+		if (colorsMatch(pixel, WOOLY_BLACK)) featureMask |= 1 << index;
+		else yarnColors.push(pixel);
+	}
+
+	if (occupiedMask === 0) return " ";
+	if (occupiedMask !== 0b1111) {
+		if (featureMask !== 0) return `${foreground(WOOLY_BLACK)}${QUADRANT_GLYPHS[featureMask]}${RESET}`;
+		return `${foreground(averageColors(yarnColors))}${QUADRANT_GLYPHS[occupiedMask]}${RESET}`;
+	}
+	if (featureMask !== 0) {
+		if (featureMask === 0b1111) return `${foreground(WOOLY_BLACK)}█${RESET}`;
+		return `${foreground(WOOLY_BLACK)}${background(averageColors(yarnColors))}${QUADRANT_GLYPHS[featureMask]}${RESET}`;
+	}
+
+	let darkest = yarnColors[0]!;
+	let lightest = yarnColors[0]!;
+	for (const color of yarnColors.slice(1)) {
+		const luminance = color[0] * 0.2126 + color[1] * 0.7152 + color[2] * 0.0722;
+		const darkestLuminance = darkest[0] * 0.2126 + darkest[1] * 0.7152 + darkest[2] * 0.0722;
+		const lightestLuminance = lightest[0] * 0.2126 + lightest[1] * 0.7152 + lightest[2] * 0.0722;
+		if (luminance < darkestLuminance) darkest = color;
+		if (luminance > lightestLuminance) lightest = color;
+	}
+	if (colorsMatch(darkest, lightest)) return `${foreground(darkest)}█${RESET}`;
+
+	let darkMask = 0;
+	for (let index = 0; index < pixels.length; index++) {
+		const pixel = pixels[index]!;
+		if (colorDistance(pixel, darkest) <= colorDistance(pixel, lightest)) darkMask |= 1 << index;
+	}
+	if (darkMask === 0 || darkMask === 0b1111) return `${foreground(averageColors(yarnColors))}█${RESET}`;
+	return `${foreground(darkest)}${background(lightest)}${QUADRANT_GLYPHS[darkMask]}${RESET}`;
+}
+
+function createCanvas(spec: SpriteSpec): Canvas {
+	return Array.from({ length: spec.pixelHeight }, () => Array<Pixel>(spec.width * HORIZONTAL_SUBPIXELS).fill(null));
+}
+
+function scaleX(value: number): number {
+	return value * HORIZONTAL_SUBPIXELS;
+}
+
+function interpolate(from: number, to: number, amount: number): number {
+	return from + (to - from) * amount;
+}
+
+function paint(canvas: Canvas, x: number, y: number, color: Rgb): void {
+	if (y < 0 || y >= canvas.length || x < 0 || x >= canvas[0]!.length) return;
+	canvas[y]![x] = color;
+}
+
+function drawLine(canvas: Canvas, fromX: number, fromY: number, toX: number, toY: number, color: Rgb): void {
+	let x = Math.round(fromX);
+	let y = Math.round(fromY);
+	const endX = Math.round(toX);
+	const endY = Math.round(toY);
+	const deltaX = Math.abs(endX - x);
+	const stepX = x < endX ? 1 : -1;
+	const deltaY = -Math.abs(endY - y);
+	const stepY = y < endY ? 1 : -1;
+	let error = deltaX + deltaY;
+
+	while (true) {
+		paint(canvas, x, y, color);
+		if (x === endX && y === endY) return;
+		const doubledError = error * 2;
+		if (doubledError >= deltaY) {
+			error += deltaY;
+			x += stepX;
+		}
+		if (doubledError <= deltaX) {
+			error += deltaX;
+			y += stepY;
+		}
+	}
+}
+
+function clampChannel(value: number): number {
+	return Math.max(0, Math.min(255, Math.round(value)));
+}
+
+function shadeOrange(amount: number): Rgb {
+	return [
+		clampChannel(WOOLY_ORANGE[0] + amount),
+		clampChannel(WOOLY_ORANGE[1] + amount * 0.62),
+		clampChannel(WOOLY_ORANGE[2] + amount * 0.28),
+	];
+}
+
+function drawLimbs(
+	canvas: Canvas,
+	spec: SpriteSpec,
+	spinFrame: number,
+	waveFrame: number,
+	jumpFrame: number,
+	retractFrame: number,
+): void {
+	const angle = (spinFrame * Math.PI) / 4;
+	const turn = Math.sin(angle);
+	const bob = spinFrame % 2;
+	const radius = spec.bodyRadius;
+	const shoulderY = spec.bodyY;
+	const elbowY = spec.bodyY + radius * 0.35;
+	const handY = Math.min(spec.legBottom - 1, spec.bodyY + radius * 0.92 + bob);
+	const armReach = (spec.compact ? 2.1 : 3.4) - 1;
+	const sway = turn * (spec.compact ? 0.7 : 1.2);
+	const waveLift = WAVE_LIFT[waveFrame] ?? 0;
+	const waveSway = (WAVE_SWAY[waveFrame] ?? 0) * (spec.compact ? 0.45 : 0.75);
+	const retractAmount = RETRACT_AMOUNT[retractFrame] ?? 0;
+	if (retractAmount === 1) return;
+
+	const leftShoulderX = spec.bodyX - radius + 1;
+	const leftElbowX = interpolate(spec.bodyX - radius - 1, leftShoulderX, retractAmount);
+	const leftElbowY = interpolate(elbowY, shoulderY, retractAmount);
+	const leftHandX = interpolate(spec.bodyX - radius - armReach + sway, leftShoulderX, retractAmount);
+	const leftHandY = interpolate(handY, shoulderY, retractAmount);
+	drawLine(canvas, scaleX(leftShoulderX), shoulderY, scaleX(leftElbowX), leftElbowY, WOOLY_BLACK);
+	drawLine(canvas, scaleX(leftElbowX), leftElbowY, scaleX(leftHandX), leftHandY, WOOLY_BLACK);
+
+	const normalRightElbowX = spec.bodyX + radius + 1;
+	const normalRightHandX = spec.bodyX + radius + armReach + sway;
+	const raisedRightElbowX = spec.bodyX + radius + 1;
+	const raisedRightElbowY = spec.bodyY - radius * 0.05;
+	const raisedRightHandX = spec.bodyX + radius + armReach * 0.65 + waveSway;
+	const raisedRightHandY = spec.bodyY - radius * 0.82;
+	const rightShoulderX = spec.bodyX + radius - 1;
+	const animatedRightElbowX = interpolate(normalRightElbowX, raisedRightElbowX, waveLift);
+	const animatedRightElbowY = interpolate(elbowY, raisedRightElbowY, waveLift);
+	const animatedRightHandX = interpolate(normalRightHandX, raisedRightHandX, waveLift);
+	const animatedRightHandY = interpolate(handY, raisedRightHandY, waveLift);
+	const rightElbowX = interpolate(animatedRightElbowX, rightShoulderX, retractAmount);
+	const rightElbowY = interpolate(animatedRightElbowY, shoulderY, retractAmount);
+	const rightHandX = interpolate(animatedRightHandX, rightShoulderX, retractAmount);
+	const rightHandY = interpolate(animatedRightHandY, shoulderY, retractAmount);
+	drawLine(canvas, scaleX(rightShoulderX), shoulderY, scaleX(rightElbowX), rightElbowY, WOOLY_BLACK);
+	drawLine(canvas, scaleX(rightElbowX), rightElbowY, scaleX(rightHandX), rightHandY, WOOLY_BLACK);
+
+	const legTop = spec.bodyY + radius - 1;
+	const legBottom = interpolate(spec.legBottom - (JUMP_TUCK[jumpFrame] ?? 0), legTop, retractAmount);
+	const legSpread = spec.compact ? 1.45 : 2.35;
+	const legShift = turn * (spec.compact ? 0.45 : 0.8);
+	const leftFootX = scaleX(interpolate(spec.bodyX - legSpread + legShift, spec.bodyX, retractAmount));
+	const rightFootX = scaleX(interpolate(spec.bodyX + legSpread + legShift, spec.bodyX, retractAmount));
+	const footReach = HORIZONTAL_SUBPIXELS * (1 - retractAmount);
+	drawLine(canvas, leftFootX, legTop, leftFootX, legBottom, WOOLY_BLACK);
+	drawLine(canvas, rightFootX, legTop, rightFootX, legBottom, WOOLY_BLACK);
+	drawLine(canvas, leftFootX, legBottom, leftFootX - footReach, legBottom, WOOLY_BLACK);
+	drawLine(canvas, rightFootX, legBottom, rightFootX + footReach, legBottom, WOOLY_BLACK);
+}
+
+function drawYarnBody(canvas: Canvas, spec: SpriteSpec, frame: number): void {
+	const angle = (frame * Math.PI) / 4;
+	for (let y = 0; y < spec.pixelHeight; y++) {
+		for (let x = 0; x < spec.width * HORIZONTAL_SUBPIXELS; x++) {
+			const logicalX = x / HORIZONTAL_SUBPIXELS;
+			const normalizedX = (logicalX - spec.bodyX) / spec.bodyRadius;
+			const normalizedY = (y - spec.bodyY) / spec.bodyRadius;
+			const distanceSquared = normalizedX ** 2 + normalizedY ** 2;
+			if (distanceSquared > 1) continue;
+
+			const edgeShade = -23 * Math.max(0, Math.sqrt(distanceSquared) - 0.58);
+			const lightShade = -normalizedX * 13 - normalizedY * 10;
+			const yarnWave =
+				Math.sin(logicalX * 0.92 + y * 1.47 + angle * 1.8) +
+				Math.sin(logicalX * 1.73 - y * 0.61 - angle * 1.15) * 0.65;
+			const yarnShade = yarnWave > 0.9 ? 20 : yarnWave < -0.9 ? -18 : yarnWave * 5;
+			paint(canvas, x, y, shadeOrange(edgeShade + lightShade + yarnShade));
+		}
+	}
+}
+
+function drawEye(canvas: Canvas, centerX: number, centerY: number): void {
+	const left = Math.round(centerX - 0.5);
+	paint(canvas, left, Math.round(centerY), WOOLY_BLACK);
+	paint(canvas, left + 1, Math.round(centerY), WOOLY_BLACK);
+}
+
+function drawSmile(canvas: Canvas, centerX: number, centerY: number): void {
+	const roundedX = Math.round(centerX);
+	const roundedY = Math.round(centerY);
+	paint(canvas, roundedX - 2, roundedY, WOOLY_BLACK);
+	for (let offset = -1; offset <= 1; offset++) paint(canvas, roundedX + offset, roundedY + 1, WOOLY_BLACK);
+	paint(canvas, roundedX + 2, roundedY, WOOLY_BLACK);
+}
+
+function drawFace(canvas: Canvas, spec: SpriteSpec, frame: number): void {
+	if (frame >= 3 && frame <= 5) return;
+	const angle = (frame * Math.PI) / 4;
+	const faceX = scaleX(spec.bodyX - Math.sin(angle) * spec.bodyRadius * 0.58);
+	const eyeY = spec.bodyY - spec.bodyRadius * 0.4;
+	const mouthY = spec.bodyY + spec.bodyRadius * 0.04 - 1;
+	if (frame === 2 || frame === 6) {
+		drawEye(canvas, faceX, eyeY);
+		drawSmile(canvas, faceX, mouthY);
+		return;
+	}
+
+	const eyeSpacing = scaleX(frame === 0 ? 2 : 1);
+	drawEye(canvas, faceX - eyeSpacing, eyeY);
+	drawEye(canvas, faceX + eyeSpacing, eyeY);
+	drawSmile(canvas, faceX, mouthY);
+}
+
+function liftCanvas(canvas: Canvas, offset: number): Canvas {
+	if (offset === 0) return canvas;
+	return canvas.map((row, y) => canvas[y + offset]?.slice() ?? Array<Pixel>(row.length).fill(null));
+}
+
+function buildSprite(spec: SpriteSpec, animation: WoolyAnimation | null, frame: number): string[] {
+	const spinFrame = animation === "spin" ? frame : 0;
+	const waveFrame = animation === "wave" ? frame : 0;
+	const jumpFrame = animation === "jump" ? frame : 0;
+	const retractFrame = animation === "retract" ? frame : 0;
+	const canvas = createCanvas(spec);
+	drawLimbs(canvas, spec, spinFrame, waveFrame, jumpFrame, retractFrame);
+	drawYarnBody(canvas, spec, spinFrame);
+	drawFace(canvas, spec, spinFrame);
+	const renderedCanvas = liftCanvas(canvas, JUMP_OFFSETS[jumpFrame] ?? 0);
+
+	const lines: string[] = [];
+	for (let y = 0; y < spec.pixelHeight; y += 2) {
+		let line = "";
+		for (let x = 0; x < spec.width; x++) {
+			const pixelX = x * HORIZONTAL_SUBPIXELS;
+			line += renderQuadrantBlock(
+				renderedCanvas[y]![pixelX]!,
+				renderedCanvas[y]![pixelX + 1]!,
+				renderedCanvas[y + 1]?.[pixelX] ?? null,
+				renderedCanvas[y + 1]?.[pixelX + 1] ?? null,
+			);
+		}
+		lines.push(line);
+	}
+	return lines;
+}
+
+export class WoolyComponent implements Component {
+	private interval: ReturnType<typeof setInterval> | undefined;
+	private frame = 0;
+	private idleElapsedMs = 0;
+	private animation: WoolyAnimation | null = null;
+	private nextAnimationIndex = 0;
+	private cachedKey = "";
+	private cachedLines: string[] = [];
+
+	constructor(private readonly ui: TUI) {
+		this.interval = setInterval(() => {
+			if (!this.advanceAnimation()) return;
+			this.cachedKey = "";
+			this.ui.requestRender();
+		}, WOOLY_FRAME_INTERVAL_MS);
+		this.interval.unref();
+	}
+
+	private advanceAnimation(): boolean {
+		if (this.animation === null) {
+			this.idleElapsedMs += WOOLY_FRAME_INTERVAL_MS;
+			if (this.idleElapsedMs < WOOLY_ANIMATION_DELAY_MS) return false;
+			this.animation = ANIMATION_SEQUENCE[this.nextAnimationIndex]!;
+			this.nextAnimationIndex = (this.nextAnimationIndex + 1) % ANIMATION_SEQUENCE.length;
+			this.frame = 1;
+			return true;
+		}
+		if (this.frame < FRAME_COUNT - 1) {
+			this.frame++;
+		} else {
+			this.frame = 0;
+			this.animation = null;
+			this.idleElapsedMs = 0;
+		}
+		return true;
+	}
+
+	invalidate(): void {
+		this.cachedKey = "";
+	}
+
+	render(width: number): string[] {
+		const rows = this.ui.terminal.rows;
+		const mode =
+			width < MIN_VISIBLE_WIDTH || rows < MIN_VISIBLE_ROWS
+				? "hidden"
+				: width < MIN_FULL_WIDTH || rows < MIN_FULL_ROWS
+					? "compact"
+					: "full";
+		const cacheKey = `${mode}:${width}:${rows}:${this.animation ?? "idle"}:${this.frame}`;
+		if (cacheKey === this.cachedKey) return this.cachedLines;
+		if (mode === "hidden") {
+			this.cachedLines = [];
+			this.cachedKey = cacheKey;
+			return this.cachedLines;
+		}
+
+		const spec = mode === "full" ? FULL_SPEC : COMPACT_SPEC;
+		const sprite = buildSprite(spec, this.animation, this.frame);
+		const leftPadding = Math.max(0, Math.min(LEFT_PADDING, width - spec.width));
+		this.cachedLines = sprite.map((line) => `${" ".repeat(leftPadding)}${line}`);
+		this.cachedKey = cacheKey;
+		return this.cachedLines;
+	}
+
+	dispose(): void {
+		if (this.interval !== undefined) {
+			clearInterval(this.interval);
+			this.interval = undefined;
+		}
+	}
+}

package/uninstall.sh

@@ -523,6 +523,9 @@ if [ -f "$settings_file" ]; then
          then del(.statusLine) else . end)
     | (if (.apiKeyHelper // "" | tostring | endswith("weave-key.sh"))
          then del(.apiKeyHelper) else . end)
+    | (if (.attribution.commit == "Co-Authored-By: Weave Router <noreply@workweave.ai>"
+              and .attribution.pr == "🤖 Generated with [Weave Router](https://router.workweave.ai)")
+         then del(.attribution) else . end)
   ' "$settings_file")"
   printf '%s\n' "$cleaned" >"$settings_file"
   ok "Cleaned $settings_file"