@rosetears/aili-pi 0.1.0 → 0.1.3

package/extensions/zentui/fixed-editor/selection.ts

@@ -0,0 +1,217 @@
+/**
+ * Drag-to-select state, highlight rendering, and text extraction.
+ *
+ * The selection operates on raw transcript lines (ANSI-styled strings).
+ * Highlight uses SGR 7 (inverse video) / SGR 27 (inverse off).
+ *
+ * @internal
+ */
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+/** ANSI / OSC escape sequence patterns for stripping. */
+const ANSI_RE = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+const OSC_RE = /\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g;
+
+function stripAnsi(line: string): string {
+	return line.replace(OSC_RE, "").replace(ANSI_RE, "");
+}
+
+/** OSC 8 hyperlink: \x1b]8;;params ST TEXT \x1b]8;; ST
+ * Supports both ST (\x1b\\) and BEL (\x07) terminators. */
+const OSC8_RE = /\x1b\]8;;([^\x1b\x07]*)(?:\x07|\x1b\\)([\s\S]*?)\x1b\]8;;(?:\x07|\x1b\\)/g;
+
+/**
+ * Replace OSC 8 hyperlinks with their URL before stripping.
+ * Format: \x1b]8;;[key=val;]URL\x1b\\TEXT\x1b]8;;\x1b\\
+ * If the URL differs from the visible text, both are included.
+ */
+function extractOsc8Links(line: string): string {
+	return line.replace(OSC8_RE, (_match, params: string, text: string) => {
+		const parts = params.split(";");
+		const url = parts[parts.length - 1] ?? "";
+		const visible = stripAnsi(text);
+		if (!url) return visible;
+		if (visible && visible !== url) return `${visible} ${url}`;
+		return url;
+	});
+}
+
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/** Slice text by visible column boundaries (grapheme-aware). */
+function sliceColumns(text: string, startCol: number, endCol: number): string {
+	let col = 0;
+	let result = "";
+	for (const { segment } of graphemeSegmenter.segment(text)) {
+		const width = Math.max(0, visibleWidth(segment));
+		if (col >= startCol && col < endCol) result += segment;
+		col += width;
+	}
+	return result;
+}
+
+function comparePoints(a: { line: number; col: number }, b: { line: number; col: number }): number {
+	return a.line === b.line ? a.col - b.col : a.line - b.line;
+}
+
+/** Track an in-progress drag selection over transcript lines. */
+export class SelectionState {
+	private anchor: { line: number; col: number } | null = null;
+	private focus: { line: number; col: number } | null = null;
+	private dragging = false;
+
+	start(line: number, col: number): void {
+		this.anchor = { line, col };
+		this.focus = { line, col };
+		this.dragging = true;
+	}
+
+	extend(line: number, col: number): void {
+		this.focus = { line, col };
+	}
+
+	clear(): void {
+		this.anchor = null;
+		this.focus = null;
+		this.dragging = false;
+	}
+
+	get active(): boolean {
+		return this.anchor !== null && this.focus !== null;
+	}
+
+	get isDragging(): boolean {
+		return this.dragging;
+	}
+
+	setDragging(value: boolean): void {
+		this.dragging = value;
+	}
+
+	/** Get the normalized (start ≤ end) selection bounds. */
+	private get bounds(): {
+		start: { line: number; col: number };
+		end: { line: number; col: number };
+	} | null {
+		if (!this.anchor || !this.focus) return null;
+		return comparePoints(this.anchor, this.focus) <= 0
+			? { start: this.anchor, end: this.focus }
+			: { start: this.focus, end: this.anchor };
+	}
+
+	/** Get column range for a given line index, or null if line is not selected. */
+	getRangeForLine(lineIndex: number): { startCol: number; endCol: number } | null {
+		const b = this.bounds;
+		if (!b) return null;
+		if (lineIndex < b.start.line || lineIndex > b.end.line) return null;
+		return {
+			startCol: lineIndex === b.start.line ? b.start.col : 0,
+			endCol: lineIndex === b.end.line ? b.end.col : Number.POSITIVE_INFINITY,
+		};
+	}
+
+	/**
+	 * Extract selected text from raw lines.
+	 * @param lines Full array of transcript lines (ANSI-styled).
+	 * @returns Stripped text, or "" if selection is empty.
+	 */
+	getSelectedText(lines: string[]): string {
+		const b = this.bounds;
+		if (!b) return "";
+		if (b.start.line === b.end.line && b.start.col === b.end.col) return "";
+
+		const selected: string[] = [];
+		for (let i = b.start.line; i <= b.end.line; i++) {
+			const plain = stripAnsi(extractOsc8Links(lines[i] ?? ""));
+			const startCol = i === b.start.line ? b.start.col : 0;
+			const endCol = i === b.end.line ? b.end.col : Number.POSITIVE_INFINITY;
+			selected.push(sliceColumns(plain, startCol, endCol));
+		}
+		return selected
+			.join("\n")
+			.replace(/[ \t]+$/gm, "")
+			.trimEnd();
+	}
+}
+
+/**
+ * Apply inverse-video highlight to a rendered line for the current selection.
+ * Preserves all original ANSI styling (colors, bold, etc.) — only layers
+ * a subtle background tint (SGR 48; 256-color dark gray) on top of the
+ * selected range so original foreground colors remain visible.
+ *
+ * @param line The raw ANSI-styled line.
+ * @param lineIndex The absolute transcript line index.
+ * @param selection Current selection state.
+ */
+export function highlightSelection(
+	line: string,
+	lineIndex: number,
+	selection: SelectionState,
+): string {
+	const range = selection.getRangeForLine(lineIndex);
+	if (!range) return line;
+
+	const maxCol = visibleWidth(line);
+	const startCol = Math.max(0, Math.min(range.startCol, maxCol));
+	const endCol = Math.max(startCol + 1, Math.min(range.endCol, maxCol));
+	if (startCol >= endCol) return line;
+
+	let result = "";
+	let col = 0;
+	let inverseOn = false;
+	let i = 0;
+
+	while (i < line.length) {
+		// Escape sequence — pass through, does not consume visible columns.
+		if (line[i] === "\x1b") {
+			if (line[i + 1] === "[") {
+				// CSI: \x1b[...final-byte
+				let j = i + 2;
+				while (j < line.length && !/[@-~]/.test(line[j] ?? "")) j++;
+				j++;
+				result += line.slice(i, j);
+				i = j;
+				continue;
+			}
+			if (line[i + 1] === "]") {
+				// OSC: \x1b]...BEL or \x1b]...ST
+				let j = i + 2;
+				while (
+					j < line.length &&
+					line[j] !== "\x07" &&
+					!(line[j] === "\x1b" && line[j + 1] === "\\")
+				)
+					j++;
+				if (line[j] === "\x07") j++;
+				else j += 2;
+				result += line.slice(i, j);
+				i = j;
+				continue;
+			}
+			// Other escape: ESC + single char
+			result += line.slice(i, i + 2);
+			i += 2;
+			continue;
+		}
+
+		// Visible character.
+		const char = line[i] ?? "";
+		const w = visibleWidth(char);
+		if (!inverseOn && col < endCol && col + w > startCol) {
+			result += "\x1b[48;5;238m";
+			inverseOn = true;
+		}
+		if (inverseOn && col >= endCol) {
+			result += "\x1b[49m";
+			inverseOn = false;
+		}
+		result += char;
+		col += w;
+		i++;
+	}
+
+	if (inverseOn) result += "\x1b[49m";
+	return result;
+}

package/extensions/zentui/fixed-editor/terminal-modes.ts

@@ -0,0 +1,75 @@
+/**
+ * Terminal escape sequence constants and helpers.
+ *
+ * @internal
+ */
+
+/** Enter alternate screen buffer. */
+export const ENTER_ALT_SCREEN = "\x1b[?1049h";
+
+/** Exit alternate screen buffer. */
+export const EXIT_ALT_SCREEN = "\x1b[?1049l";
+
+/** Enable SGR mouse reporting (button-event ?1002 + SGR ?1006 encoding).
+ * Requires app-level drag-select because native terminal selection is
+ * disabled while any mouse reporting mode is active. */
+export const ENABLE_MOUSE_SGR = "\x1b[?1002h\x1b[?1006h";
+
+/** Disable mouse reporting (all modes we may have enabled). */
+export const DISABLE_MOUSE = "\x1b[?1002l\x1b[?1006l\x1b[?1000l";
+
+/** Disable alternate scroll (xterm wheel-as-arrow in alt screen). */
+export const DISABLE_ALT_SCROLL = "\x1b[?1007l";
+
+/** Enable alternate scroll. */
+export const ENABLE_ALT_SCROLL = "\x1b[?1007h";
+
+/** Reset scroll region to full screen. */
+export const RESET_SCROLL_REGION = "\x1b[r";
+
+/** Begin synchronized output (reduce flicker). */
+export const SYNC_BEGIN = "\x1b[?2026h";
+
+/** End synchronized output. */
+export const SYNC_END = "\x1b[?2026l";
+
+/** Hide cursor. */
+export const HIDE_CURSOR = "\x1b[?25l";
+
+/** Show cursor. */
+export const SHOW_CURSOR = "\x1b[?25h";
+
+/** Clear entire line. */
+export const CLEAR_LINE = "\x1b[2K";
+
+/** Disable auto-wrap (DECAWM off). */
+export const DISABLE_AUTOWRAP = "\x1b[?7l";
+
+/** Enable auto-wrap (DECAWM on). */
+export const ENABLE_AUTOWRAP = "\x1b[?7h";
+
+/** Set scroll region to rows [top, bottom] (1-indexed). */
+export function setScrollRegion(top: number, bottom: number): string {
+	return `\x1b[${top};${bottom}r`;
+}
+
+/** Move cursor to absolute position (1-indexed row, col). */
+export function cursorTo(row: number, col: number): string {
+	return `\x1b[${row};${col}H`;
+}
+
+/**
+ * Emit all sequences needed to restore the terminal to a safe state.
+ * Call on dispose and process.exit to avoid leaving the terminal broken.
+ */
+export function emergencyTerminalReset(): string {
+	return (
+		SYNC_BEGIN +
+		RESET_SCROLL_REGION +
+		DISABLE_MOUSE +
+		ENABLE_ALT_SCROLL +
+		EXIT_ALT_SCREEN +
+		SHOW_CURSOR +
+		SYNC_END
+	);
+}

package/extensions/zentui/fixed-editor/types.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared types for the fixed/sticky editor compositor.
+ *
+ * @internal
+ */
+
+/** Result of parsing a mouse SGR wheel sequence. */
+export type MouseScrollInput = {
+	direction: "up" | "down";
+	amount: number;
+};
+
+/** Full parsed SGR mouse event. */
+export type MouseEvent = {
+	button: "left" | "middle" | "right" | "wheel-up" | "wheel-down" | "other";
+	action: "press" | "drag" | "release";
+	col: number; // 1-indexed
+	row: number; // 1-indexed
+};
+
+/** Result of parsing a keyboard scroll sequence. */
+export type KeyboardScrollInput = {
+	action: "pageUp" | "pageDown" | "jumpBottom" | "lineUp" | "lineDown";
+};
+
+/** Compositor configuration provided by a getter. */
+export type CompositorConfig = {
+	enabled: boolean;
+	mouseScroll: boolean;
+	copyNotice: boolean;
+};
+
+/** Result of rendering the pinned cluster. */
+export type ClusterRender = {
+	lines: string[];
+	cursor: { row: number; col: number } | null;
+};

package/extensions/zentui/footer-format.ts

@@ -0,0 +1,279 @@
+/**
+ * Starship-style footer format string parser and renderer.
+ *
+ * Pure module (no TUI/config imports) so it is fully unit-testable.
+ *
+ * Supports conditional groups: `( ... )` is dropped when every nested
+ * variable (and nested group) renders empty.
+ */
+
+export type FormatToken =
+	| { kind: "text"; value: string }
+	| { kind: "var"; name: string }
+	| { kind: "fill" }
+	| { kind: "group"; tokens: FormatToken[] };
+
+const TOKEN_REGEX = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}|\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
+
+/**
+ * Tokenize a format string into text/var/fill/group tokens.
+ *
+ * `$name` and `${name}` both produce a variable token. A variable named
+ * `fill` becomes a fill token instead. Parentheses form conditional groups
+ * that drop entirely when all nested vars are empty.
+ */
+export function parseFooterFormat(format: string): FormatToken[] {
+	if (!format) return [];
+	return parseTokenSlice(format, 0, format.length, true).tokens;
+}
+
+function parseTokenSlice(
+	format: string,
+	start: number,
+	end: number,
+	topLevel = false,
+): { tokens: FormatToken[]; nextIndex: number } {
+	const tokens: FormatToken[] = [];
+	let index = start;
+	let textStart = start;
+
+	const flushText = (until: number) => {
+		if (until > textStart) {
+			tokens.push({ kind: "text", value: format.slice(textStart, until) });
+		}
+	};
+
+	while (index < end) {
+		const ch = format[index];
+
+		if (ch === "(") {
+			flushText(index);
+			const nested = parseTokenSlice(format, index + 1, end, false);
+			tokens.push({ kind: "group", tokens: nested.tokens });
+			index = nested.nextIndex;
+			textStart = index;
+			continue;
+		}
+
+		if (ch === ")") {
+			// Nested groups close on `)`. Unmatched top-level `)` is literal text so
+			// trailing tokens like `$cwd) $tokens` are not discarded.
+			if (topLevel) {
+				index += 1;
+				continue;
+			}
+			flushText(index);
+			return { tokens, nextIndex: index + 1 };
+		}
+
+		if (ch === "$") {
+			TOKEN_REGEX.lastIndex = index;
+			const match = TOKEN_REGEX.exec(format);
+			if (match && match.index === index && match.index < end) {
+				const full = match[0];
+				const matchEnd = match.index + full.length;
+				if (matchEnd > end) {
+					index += 1;
+					continue;
+				}
+				flushText(index);
+				const name = match[1] ?? match[2] ?? "";
+				if (name === "fill") {
+					tokens.push({ kind: "fill" });
+				} else {
+					tokens.push({ kind: "var", name });
+				}
+				index = matchEnd;
+				textStart = index;
+				continue;
+			}
+		}
+
+		index += 1;
+	}
+
+	flushText(end);
+	return { tokens, nextIndex: end };
+}
+
+/**
+ * Render tokens into `{ left, middle, right }` based on `$fill` markers.
+ *
+ * - No fill: everything → `left`; `middle` and `right` are `""`.
+ * - One fill: tokens before → `left`, tokens after → `right`; `middle` is `""`.
+ * - Two fills: before the first → `left`, between the two → `middle`
+ *   (centered by the caller via the existing middle-zone logic), after the
+ *   second → `right`.
+ * - Additional fills beyond the first two are ignored.
+ * - `$fill` inside a group is ignored (renders empty).
+ *
+ * Text tokens contribute their `value` verbatim (unstyled/plain); var tokens
+ * contribute `renderVariable(name)` (already styled by caller). No automatic
+ * spaces are inserted — the user controls all spacing.
+ */
+export function renderFormatSplit(
+	tokens: FormatToken[],
+	renderVariable: (name: string) => string,
+): { left: string; middle: string; right: string } {
+	const fillIndices = findTopLevelFillIndices(tokens);
+
+	if (fillIndices.length === 0) {
+		return {
+			left: renderTokenSlice(tokens, 0, tokens.length, renderVariable),
+			middle: "",
+			right: "",
+		};
+	}
+
+	const first = fillIndices[0];
+	const second = fillIndices[1];
+
+	if (first === undefined) {
+		return {
+			left: renderTokenSlice(tokens, 0, tokens.length, renderVariable),
+			middle: "",
+			right: "",
+		};
+	}
+
+	if (second === undefined) {
+		return {
+			left: renderTokenSlice(tokens, 0, first, renderVariable),
+			middle: "",
+			right: renderTokenSlice(tokens, first + 1, tokens.length, renderVariable),
+		};
+	}
+
+	return {
+		left: renderTokenSlice(tokens, 0, first, renderVariable),
+		middle: renderTokenSlice(tokens, first + 1, second, renderVariable),
+		right: renderTokenSlice(tokens, second + 1, tokens.length, renderVariable),
+	};
+}
+
+function findTopLevelFillIndices(tokens: FormatToken[]): number[] {
+	const fillIndices: number[] = [];
+	for (let index = 0; index < tokens.length; index++) {
+		if (tokens[index]?.kind === "fill") fillIndices.push(index);
+	}
+	return fillIndices;
+}
+
+function renderTokenSlice(
+	tokens: FormatToken[],
+	start: number,
+	end: number,
+	renderVariable: (name: string) => string,
+): string {
+	let result = "";
+	for (let i = start; i < end; i++) {
+		const token = tokens[i];
+		if (!token) continue;
+		result += renderToken(token, renderVariable);
+	}
+	return result;
+}
+
+function renderToken(token: FormatToken, renderVariable: (name: string) => string): string {
+	if (token.kind === "text") return token.value;
+	if (token.kind === "var") return renderVariable(token.name);
+	if (token.kind === "fill") return "";
+	// group
+	const rendered = token.tokens.map((child) => renderToken(child, renderVariable)).join("");
+	if (isGroupEmpty(token, renderVariable)) return "";
+	return rendered;
+}
+
+/**
+ * Separator vars only style gaps between content; they must not keep a group
+ * alive when every real content var is empty (e.g. `($sep$tokens)` drops if
+ * tokens is empty).
+ */
+const NON_CONTENT_VARS = new Set(["sep", "separator"]);
+
+/**
+ * A group is empty iff every content var leaf is empty and every nested group
+ * is empty. Text-only groups (no vars) always show. `$sep` / `$separator` are
+ * ignored for emptiness so orphan themed pipes do not force a group to render.
+ */
+function isGroupEmpty(
+	group: FormatToken & { kind: "group" },
+	renderVariable: (name: string) => string,
+): boolean {
+	let sawContentVarOrGroup = false;
+	for (const child of group.tokens) {
+		if (child.kind === "var") {
+			if (NON_CONTENT_VARS.has(child.name)) continue;
+			sawContentVarOrGroup = true;
+			if (renderVariable(child.name) !== "") return false;
+		} else if (child.kind === "group") {
+			sawContentVarOrGroup = true;
+			if (!isGroupEmpty(child, renderVariable)) return false;
+		}
+	}
+	// Text-only groups (or groups with only $sep) are shown only when no content vars.
+	// Groups that only contain $sep still count as empty so they drop.
+	return sawContentVarOrGroup || groupOnlyNonContentVars(group);
+}
+
+function groupOnlyNonContentVars(group: FormatToken & { kind: "group" }): boolean {
+	let sawSep = false;
+	for (const child of group.tokens) {
+		if (child.kind === "text") {
+			if (child.value.trim() !== "") return false;
+			continue;
+		}
+		if (child.kind === "var") {
+			if (!NON_CONTENT_VARS.has(child.name)) return false;
+			sawSep = true;
+			continue;
+		}
+		if (child.kind === "group") return false;
+		if (child.kind === "fill") continue;
+	}
+	return sawSep;
+}
+
+/** One optional SGR sequence (`\x1b[…m`). */
+const ANSI_ONE_SRC = "\u001b\\[[0-9;]*m";
+
+/**
+ * One ` | ` separator unit, plain or with a single ANSI wrapper on either side
+ * of the spaces/pipe (matches `renderStyle(..., " | ")` output).
+ */
+const SEP_UNIT_SRC = `(?:${ANSI_ONE_SRC})?\\s+\\|\\s+(?:${ANSI_ONE_SRC})?`;
+
+/**
+ * Join non-empty parts with a separator (segment-mode style).
+ * Useful when building right-side metrics without orphan pipes.
+ */
+export function joinNonEmpty(parts: string[], separator: string): string {
+	return parts.filter(Boolean).join(separator);
+}
+
+/**
+ * Tidy a rendered format left/middle/right slice:
+ * - collapse repeated pipe separators (plain or simple ANSI-wrapped) into one
+ * - strip leading/trailing pipe separators
+ * - strip leading/trailing whitespace
+ * - drop slices that are only ANSI / whitespace after cleanup
+ */
+export function stripOrphanSeparators(rendered: string): string {
+	if (!rendered) return rendered;
+
+	// Collapse consecutive separator units, keeping the first (preserves themed color).
+	const consecutive = new RegExp(`(${SEP_UNIT_SRC})(?:${SEP_UNIT_SRC})+`, "g");
+	let result = rendered.replace(consecutive, "$1");
+
+	// Strip leading / trailing separator units.
+	result = result.replace(new RegExp(`^(?:${SEP_UNIT_SRC})+`), "");
+	result = result.replace(new RegExp(`(?:${SEP_UNIT_SRC})+$`), "");
+
+	// Strip leading / trailing plain whitespace left by empty groups.
+	result = result.replace(/^\s+/, "").replace(/\s+$/, "");
+
+	// Pure ANSI (or empty) leftovers are not useful content.
+	if (result.replace(new RegExp(ANSI_ONE_SRC, "g"), "").trim() === "") return "";
+
+	return result;
+}