@xzzpig/pi-starline 0.1.0

package/extensions/starline/editor-cursor.ts

@@ -0,0 +1,55 @@
+/**
+ * Editor cursor styling.
+ *
+ * Pi's editor draws its cursor in software, as a reverse-video run around the
+ * grapheme under the cursor (`\x1b[7m` … `\x1b[0m`), emitted right after the
+ * zero-width CURSOR_MARKER that tells the TUI where to put the real terminal
+ * cursor. Restyling is therefore a string rewrite over the rendered lines —
+ * no editor internals involved.
+ *
+ * - `block`     leave it alone (upstream behaviour)
+ * - `underline` draw an underline instead of the reverse block
+ * - `terminal`  remove it, letting the real terminal cursor show through, so
+ *               its shape and blink follow the terminal's own configuration
+ */
+
+export type EditorCursorStyle = "block" | "underline" | "terminal";
+
+export function parseEditorCursorStyle(value: unknown): EditorCursorStyle {
+	return value === "underline" || value === "terminal" || value === "block" ? value : "block";
+}
+
+/**
+ * Reverse-video run containing no further escapes. The single-grapheme check
+ * happens in the replacer: a longer run is deliberate styling somewhere else in
+ * the line (a selection highlight, say) and must not be rewritten.
+ */
+const REVERSE_RUN = /\x1b\[7m([^\x1b]*)\x1b\[0m/g;
+
+const graphemeSegmenter =
+	typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
+		? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+		: undefined;
+
+function isSingleGrapheme(text: string): boolean {
+	if (text.length === 0) return false;
+	if (!graphemeSegmenter) return [...text].length === 1;
+	const iterator = graphemeSegmenter.segment(text)[Symbol.iterator]();
+	const first = iterator.next();
+	return !first.done && first.value.segment === text;
+}
+
+/** Restyle the software cursor in one rendered line. */
+export function applyEditorCursorStyle(line: string, style: EditorCursorStyle): string {
+	if (style === "block" || !line.includes("\x1b[7m")) return line;
+	return line.replace(REVERSE_RUN, (match, run: string) => {
+		if (!isSingleGrapheme(run)) return match;
+		return style === "underline" ? `\x1b[4m${run}\x1b[0m` : run;
+	});
+}
+
+/** Restyle the software cursor across rendered editor lines. */
+export function applyEditorCursorStyleToLines(lines: string[], style: EditorCursorStyle): string[] {
+	if (style === "block") return lines;
+	return lines.map((line) => applyEditorCursorStyle(line, style));
+}

package/extensions/starline/editor-factory-marker.ts

@@ -0,0 +1,49 @@
+/**
+ * Marks the editor factory Starline installed, so a re-entrant install
+ * recognises its own work instead of wrapping it a second time.
+ *
+ * Marks are written under BOTH `pi-starline.*` and the pre-rename
+ * `pi-zentui.*` keys, and both are read back. Package load order is not
+ * controlled by either side: pi-zentui loading first only needs the legacy
+ * keys read, but pi-starline loading first (the alphabetically-first, and
+ * therefore common, order) needs a pi-zentui reader loading second to still
+ * find the mark under the legacy key it looks for. Writing only the new key
+ * would leave that direction unprotected and a second, stacked editor
+ * factory would get built.
+ */
+
+const EDITOR_FACTORY = Symbol.for("pi-starline.editor-factory");
+const EDITOR_BASE_FACTORY = Symbol.for("pi-starline.editor-base-factory");
+const LEGACY_EDITOR_FACTORY = Symbol.for("pi-zentui.editor-factory");
+const LEGACY_EDITOR_BASE_FACTORY = Symbol.for("pi-zentui.editor-base-factory");
+
+type Marked = Record<PropertyKey, unknown>;
+
+function asMarked(factory: unknown): Marked | undefined {
+	return typeof factory === "function" || (typeof factory === "object" && factory !== null)
+		? (factory as Marked)
+		: undefined;
+}
+
+export function markEditorFactory<T extends object>(factory: T, baseFactory?: object): T {
+	const marked = factory as unknown as Marked;
+	marked[EDITOR_FACTORY] = true;
+	marked[LEGACY_EDITOR_FACTORY] = true;
+	if (baseFactory) {
+		marked[EDITOR_BASE_FACTORY] = baseFactory;
+		marked[LEGACY_EDITOR_BASE_FACTORY] = baseFactory;
+	}
+	return factory;
+}
+
+export function isStarlineEditorFactory(factory: unknown): boolean {
+	const marked = asMarked(factory);
+	if (!marked) return false;
+	return marked[EDITOR_FACTORY] === true || marked[LEGACY_EDITOR_FACTORY] === true;
+}
+
+export function getStarlineEditorBaseFactory<T>(factory: unknown): T | undefined {
+	const marked = asMarked(factory);
+	if (!marked) return undefined;
+	return (marked[EDITOR_BASE_FACTORY] ?? marked[LEGACY_EDITOR_BASE_FACTORY]) as T | undefined;
+}

package/extensions/starline/editor-metadata-format.ts

@@ -0,0 +1,259 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { PolishedTuiConfig } from "./config";
+import { type FormatToken, parseFooterFormat } from "./footer-format";
+import { EDITOR_ACCENT_FALLBACK, renderStyleForSourceOrFallback, safeThemeFg } from "./style";
+
+export type EditorMetadataValues = {
+	model: string;
+	modelId: string;
+	modelName: string;
+	provider: string;
+	thinking: string;
+	sessionName: string;
+};
+
+type RenderedTokens = {
+	styled: string;
+	hasDynamic: boolean;
+	hasNonEmptyDynamic: boolean;
+};
+
+const ESC = 0x1b;
+const BEL = 0x07;
+const CAN = 0x18;
+const SUB = 0x1a;
+const C1_DCS = 0x90;
+const C1_CSI = 0x9b;
+const C1_ST = 0x9c;
+const C1_OSC = 0x9d;
+const C1_SOS = 0x98;
+const C1_PM = 0x9e;
+const C1_APC = 0x9f;
+
+function consumeCsi(value: string, start: number): number {
+	for (let index = start; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === CAN || code === SUB) return index + 1;
+		if (code >= 0x40 && code <= 0x7e) return index + 1;
+	}
+	return value.length;
+}
+
+function consumeControlString(value: string, start: number, allowBel: boolean): number {
+	for (let index = start; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === CAN || code === SUB) return index + 1;
+		if (allowBel && code === BEL) return index + 1;
+		if (code === C1_ST) return index + 1;
+		if (code === ESC && value.charCodeAt(index + 1) === 0x5c) return index + 2;
+	}
+	return value.length;
+}
+
+function consumeEscape(value: string, start: number): number {
+	if (start + 1 >= value.length) return value.length;
+	const next = value.charCodeAt(start + 1);
+	if (next === 0x5b) return consumeCsi(value, start + 2);
+	if (next === 0x5d) return consumeControlString(value, start + 2, true);
+	if (next === 0x50 || next === 0x58 || next === 0x5e || next === 0x5f) {
+		return consumeControlString(value, start + 2, false);
+	}
+
+	let index = start + 1;
+	while (index < value.length) {
+		const code = value.charCodeAt(index);
+		if (code >= 0x20 && code <= 0x2f) {
+			index += 1;
+			continue;
+		}
+		return code >= 0x30 && code <= 0x7e ? index + 1 : index;
+	}
+	return value.length;
+}
+
+function isNormalizedWhitespace(code: number): boolean {
+	return (
+		code === 0x09 ||
+		code === 0x0a ||
+		code === 0x0b ||
+		code === 0x0c ||
+		code === 0x0d ||
+		code === 0x85 ||
+		code === 0x2028 ||
+		code === 0x2029
+	);
+}
+
+export function sanitizeEditorMetadataText(value: string): string {
+	let sanitized = "";
+	for (let index = 0; index < value.length; ) {
+		const code = value.charCodeAt(index);
+		if (code === ESC) {
+			index = consumeEscape(value, index);
+			continue;
+		}
+		if (code === C1_CSI) {
+			index = consumeCsi(value, index + 1);
+			continue;
+		}
+		if (code === C1_OSC) {
+			index = consumeControlString(value, index + 1, true);
+			continue;
+		}
+		if (code === C1_DCS || code === C1_SOS || code === C1_PM || code === C1_APC) {
+			index = consumeControlString(value, index + 1, false);
+			continue;
+		}
+		if (isNormalizedWhitespace(code)) {
+			sanitized += " ";
+			do index += 1;
+			while (index < value.length && isNormalizedWhitespace(value.charCodeAt(index)));
+			continue;
+		}
+		if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) {
+			index += 1;
+			continue;
+		}
+		sanitized += value[index];
+		index += 1;
+	}
+	return sanitized;
+}
+
+function editorThinkingStyle(config: PolishedTuiConfig, level: string): string | undefined {
+	switch (level.toLowerCase()) {
+		case "minimal":
+			return config.colors.editorThinkingMinimal ?? config.colors.editorThinking;
+		case "low":
+			return config.colors.editorThinkingLow ?? config.colors.editorThinking;
+		case "medium":
+			return config.colors.editorThinkingMedium ?? config.colors.editorThinking;
+		case "high":
+			return config.colors.editorThinkingHigh ?? config.colors.editorThinking;
+		case "xhigh":
+			return config.colors.editorThinkingXhigh ?? config.colors.editorThinking;
+		default:
+			return config.colors.editorThinking;
+	}
+}
+
+function renderVariable(
+	name: string,
+	values: EditorMetadataValues,
+	uiTheme: Theme,
+	config: PolishedTuiConfig,
+): { plain: string; styled: string } {
+	const colorSource = config.colorSources.editor;
+	const thinking = values.thinking.toLowerCase() === "off" ? "" : values.thinking;
+	const raw =
+		name === "model"
+			? values.model
+			: name === "model_id"
+				? values.modelId
+				: name === "model_name"
+					? values.modelName
+					: name === "provider"
+						? values.provider
+						: name === "thinking"
+							? thinking
+							: name === "session_name"
+								? values.sessionName
+								: "";
+	const plain = sanitizeEditorMetadataText(raw);
+	if (!plain) return { plain: "", styled: "" };
+
+	if (name === "model" || name === "model_id" || name === "model_name") {
+		return {
+			plain,
+			styled: renderStyleForSourceOrFallback(
+				uiTheme,
+				colorSource,
+				config.colors.editorModel,
+				EDITOR_ACCENT_FALLBACK,
+				plain,
+			),
+		};
+	}
+	if (name === "provider") {
+		return {
+			plain,
+			styled: renderStyleForSourceOrFallback(
+				uiTheme,
+				colorSource,
+				config.colors.editorProvider,
+				"text",
+				plain,
+			),
+		};
+	}
+	if (name === "thinking") {
+		return {
+			plain,
+			styled: renderStyleForSourceOrFallback(
+				uiTheme,
+				colorSource,
+				editorThinkingStyle(config, plain),
+				"muted",
+				plain,
+			),
+		};
+	}
+	if (name === "session_name") {
+		return { plain, styled: safeThemeFg(uiTheme, "border", plain) };
+	}
+	return { plain: "", styled: "" };
+}
+
+function renderTokens(
+	tokens: FormatToken[],
+	values: EditorMetadataValues,
+	uiTheme: Theme,
+	config: PolishedTuiConfig,
+): RenderedTokens {
+	let styled = "";
+	let hasDynamic = false;
+	let hasNonEmptyDynamic = false;
+
+	for (const token of tokens) {
+		if (token.kind === "text") {
+			const plain = sanitizeEditorMetadataText(token.value);
+			if (plain) styled += safeThemeFg(uiTheme, "border", plain);
+			continue;
+		}
+		if (token.kind === "fill") {
+			hasDynamic = true;
+			continue;
+		}
+		if (token.kind === "var") {
+			hasDynamic = true;
+			const rendered = renderVariable(token.name, values, uiTheme, config);
+			styled += rendered.styled;
+			if (rendered.plain) hasNonEmptyDynamic = true;
+			continue;
+		}
+
+		const rendered = renderTokens(token.tokens, values, uiTheme, config);
+		const visible = !rendered.hasDynamic || rendered.hasNonEmptyDynamic;
+		hasDynamic = true;
+		if (visible) {
+			styled += rendered.styled;
+			hasNonEmptyDynamic = true;
+		}
+	}
+
+	return { styled, hasDynamic, hasNonEmptyDynamic };
+}
+
+export function renderEditorMetadataFormat(
+	format: string,
+	values: EditorMetadataValues,
+	uiTheme: Theme,
+	config: PolishedTuiConfig,
+): string {
+	return renderTokens(
+		parseFooterFormat(sanitizeEditorMetadataText(format)),
+		values,
+		uiTheme,
+		config,
+	).styled;
+}

package/extensions/starline/extension-status.ts

@@ -0,0 +1,88 @@
+import { stripVTControlCharacters } from "node:util";
+import type {
+	ExtensionStatusColorMode,
+	ExtensionStatusPlacement,
+	PolishedTuiConfig,
+} from "./config";
+import { getExtensionStatusColorMode, getExtensionStatusPlacement } from "./config";
+
+export type ExtensionStatusSegment = {
+	key: string;
+	text: string;
+	placement: ExtensionStatusPlacement;
+	colorMode: ExtensionStatusColorMode;
+};
+
+export type ExtensionStatusSegmentsByPlacement = {
+	left: ExtensionStatusSegment[];
+	middle: ExtensionStatusSegment[];
+	right: ExtensionStatusSegment[];
+};
+
+const safeSgrPattern = /\x1b\[[0-9;:]*m/g;
+const sgrPlaceholderPattern = /__STARLINE_SGR_(\d+)__/g;
+
+function compareKeys(a: ExtensionStatusSegment, b: ExtensionStatusSegment): number {
+	return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+}
+
+function normalizeStatusWhitespace(value: string): string {
+	return value
+		.replace(/[\r\n\t\f\v]+/g, " ")
+		.replace(/[\u0000-\u001f\u007f-\u009f]/g, "")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+export function sanitizeExtensionStatusText(value: string): string {
+	return normalizeStatusWhitespace(stripVTControlCharacters(value));
+}
+
+function hasVisibleStatusText(value: string): boolean {
+	return sanitizeExtensionStatusText(value).length > 0;
+}
+
+export function sanitizeExtensionStatusOriginalText(value: string): string {
+	const safeSequences: string[] = [];
+	const protectedValue = value.replace(safeSgrPattern, (sequence) => {
+		const index = safeSequences.push(sequence) - 1;
+		return `__STARLINE_SGR_${index}__`;
+	});
+	const cleaned = normalizeStatusWhitespace(stripVTControlCharacters(protectedValue));
+	const restored = cleaned.replace(sgrPlaceholderPattern, (_match, indexText: string) => {
+		const index = Number.parseInt(indexText, 10);
+		return safeSequences[index] ?? "";
+	});
+
+	return hasVisibleStatusText(restored) ? restored : "";
+}
+
+export function collectExtensionStatusSegments(
+	statuses: ReadonlyMap<string, string>,
+	config: PolishedTuiConfig,
+): ExtensionStatusSegmentsByPlacement {
+	const segments: ExtensionStatusSegmentsByPlacement = {
+		left: [],
+		middle: [],
+		right: [],
+	};
+
+	for (const [key, value] of statuses.entries()) {
+		const placement = getExtensionStatusPlacement(config, key);
+		if (placement === "off") continue;
+
+		const colorMode = getExtensionStatusColorMode(config, key);
+		const text =
+			colorMode === "original"
+				? sanitizeExtensionStatusOriginalText(value)
+				: sanitizeExtensionStatusText(value);
+		if (!text) continue;
+
+		segments[placement].push({ key, text, placement, colorMode });
+	}
+
+	segments.left.sort(compareKeys);
+	segments.middle.sort(compareKeys);
+	segments.right.sort(compareKeys);
+	return segments;
+}