@underactive/pi-topping-statusline 0.2.4 → 0.2.6

package/README.md

@@ -21,6 +21,9 @@ Then `/reload` (or restart pi). Requirements: a [Nerd Font](https://www.nerdfont
 truecolor terminal for the default look — the Symbols setting in
 `/topping-statusline-settings` (`unicode` or `ascii`) drops the font requirement.
 
+The bar's color depth follows pi's terminal detection, so `PI_TRUE_COLOR` and the
+`terminal.trueColor` setting pick 24-bit or 256-color output for it too.
+
 ## Configuration — `/topping-statusline-settings`
 
 `/topping-statusline-settings` opens a settings TUI with a live preview of the box's top and

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@underactive/pi-topping-statusline",
-	"version": "0.2.4",
+	"version": "0.2.6",
 	"description": "oh-my-pi's powerline statusline as a pi extension with some customizations",
 	"keywords": [
 		"pi-package",
@@ -45,9 +45,9 @@
 		"@earendil-works/pi-tui": "*"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-ai": "0.99.2",
-		"@earendil-works/pi-coding-agent": "0.99.2",
-		"@earendil-works/pi-tui": "0.99.2",
+		"@earendil-works/pi-ai": "1.0.3",
+		"@earendil-works/pi-coding-agent": "1.0.3",
+		"@earendil-works/pi-tui": "1.0.3",
 		"@types/node": "^22.0.0",
 		"typescript": "^5.7.0"
 	}

package/src/nvidia-green.ts

@@ -41,11 +41,9 @@ function buildAnsiByShade(mode: ColorMode): string[] {
 
 export class NvidiaGreenBorder implements BorderColorizer {
 	#phaseDeg: number;
-	readonly #ansiByShade: string[];
 
 	constructor(phaseDeg = 0) {
 		this.#phaseDeg = wrapDeg(phaseDeg);
-		this.#ansiByShade = buildAnsiByShade(detectColorMode());
 	}
 
 	step(deltaDeg: number): void {
@@ -61,6 +59,6 @@ export class NvidiaGreenBorder implements BorderColorizer {
 		const u = (1 - Math.cos(2 * Math.PI * t)) / 2;
 		const eased = u ** GREEN_BIAS;
 		const shadeIndex = Math.round((1 - eased) * (GREEN_SHADE_COUNT - 1));
-		return this.#ansiByShade[shadeIndex];
+		return buildAnsiByShade(detectColorMode())[shadeIndex];
 	}
 }

package/src/rainbow.ts

@@ -80,12 +80,11 @@ export interface BorderColorizer {
  */
 export class RainbowBorder implements BorderColorizer {
 	#phaseDeg: number;
-	readonly #mode: ColorMode;
+	#mode: ColorMode | undefined;
 	readonly #ansiByHue: string[] = [];
 
 	constructor(phaseDeg = 0) {
 		this.#phaseDeg = wrapDeg(phaseDeg);
-		this.#mode = detectColorMode();
 	}
 
 	/** Advance the whole spectrum by `deltaDeg` (mod 360). */
@@ -99,12 +98,17 @@ export class RainbowBorder implements BorderColorizer {
 	}
 
 	prefix(perimeterPos: number, perimeter: number): string {
+		const mode = detectColorMode();
+		if (mode !== this.#mode) {
+			this.#mode = mode;
+			this.#ansiByHue.length = 0;
+		}
 		const hue = (this.#phaseDeg + (360 * perimeterPos) / perimeter) % 360;
 		const bucket = Math.round(hue) % 360;
 		let ansi = this.#ansiByHue[bucket];
 		if (ansi === undefined) {
 			const hex = rgbToHex(hslToRgb(bucket, SATURATION, LIGHTNESS));
-			ansi = hexToFgAnsi(hex, this.#mode);
+			ansi = hexToFgAnsi(hex, mode);
 			this.#ansiByHue[bucket] = ansi;
 		}
 		return ansi;

package/src/tests/color-mode.test.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resetCapabilitiesCache, setCapabilities, setCapabilityOverrides } from "@earendil-works/pi-tui";
+import { NvidiaGreenBorder } from "../nvidia-green.ts";
+import { RainbowBorder } from "../rainbow.ts";
+import { detectColorMode, hexToFgAnsi, theme } from "../theme.ts";
+
+function forceTrueColor(trueColor: boolean): void {
+	setCapabilities({ images: null, trueColor, hyperlinks: false });
+}
+
+function resetCapabilities(): void {
+	setCapabilityOverrides({});
+	resetCapabilitiesCache();
+}
+
+test("forced 256-color capabilities select 256-color escapes", () => {
+	try {
+		forceTrueColor(false);
+		assert.equal(detectColorMode(), "256color");
+		assert.equal(hexToFgAnsi("#ff0000"), "\x1b[38;5;196m");
+	} finally {
+		resetCapabilities();
+	}
+});
+
+test("forced truecolor capabilities select 24-bit escapes", () => {
+	try {
+		forceTrueColor(true);
+		assert.equal(detectColorMode(), "truecolor");
+		assert.equal(hexToFgAnsi("#ff0000"), "\x1b[38;2;255;0;0m");
+	} finally {
+		resetCapabilities();
+	}
+});
+
+test("the shared theme invalidates cached escapes when the mode changes", () => {
+	try {
+		forceTrueColor(true);
+		assert.match(theme.getFgAnsi("statusLineBg"), /^\x1b\[38;2;/);
+		assert.match(theme.getBgAnsi(), /^\x1b\[48;2;/);
+
+		forceTrueColor(false);
+		assert.match(theme.getFgAnsi("statusLineBg"), /^\x1b\[38;5;/);
+		assert.match(theme.getBgAnsi(), /^\x1b\[48;5;/);
+		assert.match(theme.fadeFg("warning", "statusLineBg", 2, "x"), /^\x1b\[38;5;/);
+		assert.match(theme.fadeAnsi("\x1b[38;2;254;188;56mA\x1b[39m", 0.5), /^\x1b\[38;5;/);
+
+		forceTrueColor(true);
+		assert.match(theme.getFgAnsi("statusLineBg"), /^\x1b\[38;2;/);
+	} finally {
+		resetCapabilities();
+	}
+});
+
+test("session-long border colorizers follow mode changes", () => {
+	try {
+		forceTrueColor(true);
+		const rainbow = new RainbowBorder(0);
+		const nvidia = new NvidiaGreenBorder(0);
+		assert.match(rainbow.colorChar("─", 0, 28), /^\x1b\[38;2;/);
+		assert.match(nvidia.colorChar("─", 0, 28), /^\x1b\[38;2;/);
+
+		forceTrueColor(false);
+		assert.match(rainbow.colorChar("─", 0, 28), /^\x1b\[38;5;/);
+		assert.match(nvidia.colorChar("─", 0, 28), /^\x1b\[38;5;/);
+
+		forceTrueColor(true);
+		assert.match(rainbow.colorChar("─", 0, 28), /^\x1b\[38;2;/);
+		assert.match(nvidia.colorChar("─", 0, 28), /^\x1b\[38;2;/);
+	} finally {
+		resetCapabilities();
+	}
+});
+
+test("pi capability overrides take precedence over terminal hints", () => {
+	const previousColorTerm = process.env.COLORTERM;
+	try {
+		process.env.COLORTERM = "truecolor";
+		setCapabilityOverrides({ trueColor: false });
+		assert.equal(detectColorMode(), "256color");
+		assert.match(theme.getFgAnsi("statusLineBg"), /^\x1b\[38;5;/);
+	} finally {
+		if (previousColorTerm === undefined) delete process.env.COLORTERM;
+		else process.env.COLORTERM = previousColorTerm;
+		resetCapabilities();
+	}
+});
+
+test("PI_TRUE_COLOR controls capability detection", () => {
+	const previousTrueColor = process.env.PI_TRUE_COLOR;
+	const previousHyperlinks = process.env.PI_HYPERLINKS;
+	try {
+		process.env.PI_HYPERLINKS = "0";
+		process.env.PI_TRUE_COLOR = "0";
+		resetCapabilitiesCache();
+		assert.equal(detectColorMode(), "256color");
+
+		process.env.PI_TRUE_COLOR = "1";
+		resetCapabilitiesCache();
+		assert.equal(detectColorMode(), "truecolor");
+	} finally {
+		if (previousTrueColor === undefined) delete process.env.PI_TRUE_COLOR;
+		else process.env.PI_TRUE_COLOR = previousTrueColor;
+		if (previousHyperlinks === undefined) delete process.env.PI_HYPERLINKS;
+		else process.env.PI_HYPERLINKS = previousHyperlinks;
+		resetCapabilities();
+	}
+});

package/src/theme.ts

@@ -8,6 +8,7 @@
  * embedded here. Values are hex strings (truecolor), 256-palette indices
  * (numbers), or "" for the terminal default color.
  */
+import { getTerminalColorMode } from "@earendil-works/pi-tui";
 
 export type SymbolPreset = "unicode" | "nerd" | "ascii";
 
@@ -230,13 +231,9 @@ export const MAJOR_COLOR_HEXES = [
 
 export type ColorMode = "truecolor" | "256color";
 
+/** Defer to pi's cached terminal detection, which honors PI_TRUE_COLOR, terminal.trueColor, and capability overrides. */
 export function detectColorMode(): ColorMode {
-	const colorterm = process.env.COLORTERM;
-	if (colorterm === "truecolor" || colorterm === "24bit") return "truecolor";
-	if (process.env.WT_SESSION) return "truecolor";
-	const term = process.env.TERM || "";
-	if (term === "dumb" || term === "" || term === "linux") return "256color";
-	return "truecolor";
+	return getTerminalColorMode();
 }
 
 export function parseHex(hex: string): [number, number, number] | undefined {
@@ -314,12 +311,26 @@ function bgAnsi(color: ColorValue, mode: ColorMode): string {
 // ═══════════════════════════════════════════════════════════════════════════
 
 class StatusTheme {
-	#mode: ColorMode = detectColorMode();
+	#mode: ColorMode | undefined;
 	#preset: SymbolPreset = "nerd";
 	#symbols: StatusSymbols = NERD_SYMBOLS;
 	#fgCache = new Map<StatusColor, string>();
 	#bgAnsi: string | undefined;
 
+	/**
+	 * Pi imports extensions before it applies terminal.trueColor and reapplies
+	 * overrides when settings change, so resolve the mode on use and drop stale ANSI.
+	 */
+	#currentMode(): ColorMode {
+		const mode = detectColorMode();
+		if (mode !== this.#mode) {
+			this.#mode = mode;
+			this.#fgCache.clear();
+			this.#bgAnsi = undefined;
+		}
+		return mode;
+	}
+
 	setSymbolPreset(preset: SymbolPreset): SymbolPreset {
 		const previous = this.#preset;
 		this.#preset = preset;
@@ -345,16 +356,18 @@ class StatusTheme {
 	}
 
 	getFgAnsi(color: StatusColor): string {
+		const mode = this.#currentMode();
 		let ansi = this.#fgCache.get(color);
 		if (ansi === undefined) {
-			ansi = fgAnsi(FG_COLORS[color], this.#mode);
+			ansi = fgAnsi(FG_COLORS[color], mode);
 			this.#fgCache.set(color, ansi);
 		}
 		return ansi;
 	}
 
 	getBgAnsi(): string {
-		if (this.#bgAnsi === undefined) this.#bgAnsi = bgAnsi(STATUS_LINE_BG, this.#mode);
+		const mode = this.#currentMode();
+		if (this.#bgAnsi === undefined) this.#bgAnsi = bgAnsi(STATUS_LINE_BG, mode);
 		return this.#bgAnsi;
 	}
 
@@ -376,7 +389,7 @@ class StatusTheme {
 		const r = Math.round(a[0] * (1 - eased) + b[0] * eased);
 		const g = Math.round(a[1] * (1 - eased) + b[1] * eased);
 		const bl = Math.round(a[2] * (1 - eased) + b[2] * eased);
-		const ansi = rgbToFgAnsi(r, g, bl, this.#mode);
+		const ansi = rgbToFgAnsi(r, g, bl, this.#currentMode());
 		return `${ansi}${text}\x1b[39m`;
 	}
 
@@ -392,7 +405,7 @@ class StatusTheme {
 		const alpha = Math.max(0, Math.min(1, opacity));
 		if (alpha >= 1) return text;
 		const target = colorValueToRgb(STATUS_LINE_BG);
-		const mode = this.#mode;
+		const mode = this.#currentMode();
 		return text.replace(SGR_COLOR_RE, (_m, tcPlane, r, g, b, ixPlane, index) => {
 			let plane = "38";
 			let rgb: [number, number, number] = DEFAULT_FG_RGB;