@oh-my-pi/pi-tui 16.1.7 → 16.1.8

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [16.1.8] - 2026-06-20
+
+### Added
+
+- Added an optional synchronous dynamic description hook for slash-command autocomplete items.
+
+### Fixed
+
+- Fixed Markdown component to strip inline `<span>` and `<text>` tags while preserving their contents and unescaping nested HTML entities (`&lt;`, `&gt;`, `&quot;`, `&apos;`, `&amp;`), preventing raw LLM block/inline formatting residues from leaking into rendered TUI output.
+
 ## [16.1.7] - 2026-06-20
 
 ### Fixed

package/dist/types/autocomplete.d.ts

@@ -18,6 +18,8 @@ export interface SlashCommand {
     aliases?: string[];
     description?: string;
     argumentHint?: string;
+    /** Dynamic display-only description for slash-command autocomplete. Must be synchronous and side-effect free. */
+    getAutocompleteDescription?: () => string | undefined;
     getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
     /** Return inline hint text for the current argument state (shown as dim ghost text after cursor) */
     getInlineHint?(argumentText: string): string | null;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "16.1.7",
+	"version": "16.1.8",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -37,8 +37,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "16.1.7",
-		"@oh-my-pi/pi-utils": "16.1.7",
+		"@oh-my-pi/pi-natives": "16.1.8",
+		"@oh-my-pi/pi-utils": "16.1.8",
 		"lru-cache": "11.5.1",
 		"marked": "^18.0.5"
 	},

package/src/autocomplete.ts

@@ -175,6 +175,8 @@ export interface SlashCommand {
 	aliases?: string[];
 	description?: string;
 	argumentHint?: string;
+	/** Dynamic display-only description for slash-command autocomplete. Must be synchronous and side-effect free. */
+	getAutocompleteDescription?: () => string | undefined;
 	// Function to get argument completions for this command
 	// Returns null if no argument completion is available
 	getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
@@ -234,6 +236,17 @@ function getCommandAliases(cmd: CommandEntry): string[] {
 	return cmd.aliases.filter(alias => typeof alias === "string" && alias.length > 0);
 }
 
+function getStaticCommandDescription(cmd: CommandEntry): string {
+	return cmd.description ?? "";
+}
+
+function getAutocompleteCommandDescription(cmd: CommandEntry): string {
+	if ("getAutocompleteDescription" in cmd && typeof cmd.getAutocompleteDescription === "function") {
+		return cmd.getAutocompleteDescription() ?? cmd.description ?? "";
+	}
+	return cmd.description ?? "";
+}
+
 function commandMatchesNameOrAlias(cmd: CommandEntry, commandName: string): boolean {
 	const name = getCommandName(cmd);
 	if (name === commandName) return true;
@@ -257,18 +270,31 @@ function buildSlashCommandCompletions(commands: CommandEntry[], lowerPrefix: str
 			const name = getCommandName(cmd);
 			if (!name) return [];
 			const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
-			const desc = cmd.description ?? "";
-			const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
+			const staticDesc = getStaticCommandDescription(cmd);
+			let fullDescMemo: string | undefined;
+			let fullDescComputed = false;
+			// Resolve the (possibly live) display description lazily, only once a
+			// candidate actually matches — getAutocompleteDescription reads live
+			// session state and must not run for every command on each keystroke.
+			const resolveFullDesc = (): string | undefined => {
+				if (!fullDescComputed) {
+					const displayDesc = getAutocompleteCommandDescription(cmd);
+					fullDescMemo = hint ? (displayDesc ? `${hint} - ${displayDesc}` : hint) : displayDesc;
+					fullDescComputed = true;
+				}
+				return fullDescMemo;
+			};
 			const candidates: Array<AutocompleteItem & { score: number }> = [];
 
 			const isSkillCommand = name.startsWith("skill:");
 			const nameScore =
 				lowerPrefix.length === 0 && isSkillCommand ? 950 : scoreCommandTextMatch(lowerPrefix, name.toLowerCase());
-			const lowerDesc = desc.toLowerCase();
+			const lowerDesc = staticDesc.toLowerCase();
 			const descScore =
 				lowerDesc && fuzzyMatch(lowerPrefix, lowerDesc) ? fuzzyScore(lowerPrefix, lowerDesc) * 0.5 : 0;
 			const primaryScore = Math.max(nameScore, descScore);
 			if (primaryScore > 0) {
+				const fullDesc = resolveFullDesc();
 				candidates.push({
 					value: name,
 					label: "name" in cmd ? cmd.name : cmd.label,
@@ -282,6 +308,7 @@ function buildSlashCommandCompletions(commands: CommandEntry[], lowerPrefix: str
 					if (alias === name) continue;
 					const aliasScore = scoreCommandTextMatch(lowerPrefix, alias.toLowerCase());
 					if (aliasScore === 0) continue;
+					const fullDesc = resolveFullDesc();
 					candidates.push({
 						value: alias,
 						label: alias,

package/src/components/markdown.ts

@@ -32,7 +32,43 @@ function isOsc66Line(line: string): boolean {
 }
 
 function normalizeHtmlEntitiesForTerminal(raw: string): string {
-	return raw.replace(/ /gi, " ");
+	const parseCodePoint = (value: number): string => {
+		if (Number.isFinite(value) && value >= 0 && value <= 0x10ffff) {
+			try {
+				return String.fromCodePoint(value);
+			} catch (_) {
+				// Fallback to empty string or original if invalid codepoint
+			}
+		}
+		return "";
+	};
+
+	return raw.replace(/&(amp|lt|gt|quot|apos|nbsp|#\d+|#x[0-9a-fA-F]+);/gi, (match, entity) => {
+		const lower = entity.toLowerCase();
+		switch (lower) {
+			case "nbsp":
+				return " ";
+			case "lt":
+				return "<";
+			case "gt":
+				return ">";
+			case "quot":
+				return '"';
+			case "apos":
+				return "'";
+			case "amp":
+				return "&";
+			default: {
+				if (lower.startsWith("#x")) {
+					return parseCodePoint(Number.parseInt(lower.slice(2), 16));
+				}
+				if (lower.startsWith("#")) {
+					return parseCodePoint(Number(lower.slice(1)));
+				}
+				return match;
+			}
+		}
+	});
 }
 
 interface HtmlListState {
@@ -50,7 +86,7 @@ function createHtmlNormalizationState(): HtmlNormalizationState {
 	return { lists: [], openItems: [], itemHasContent: [] };
 }
 
-const HTML_TAG_REGEX = /<\/?(?:br|p|ol|ul|li)\b(?:\s[^>]*)?\s*\/?>/gi;
+const HTML_TAG_REGEX = /<\/?(?:br|p|ol|ul|li|span|text)\b(?:\s[^>]*)?\s*\/?>/gi;
 
 function htmlTagName(tag: string): string {
 	const match = /^<\/?\s*([A-Za-z][A-Za-z0-9:-]*)/.exec(tag);
@@ -96,22 +132,28 @@ function normalizeHtmlForTerminal(raw: string, state: HtmlNormalizationState = c
 		const tag = match[0];
 		const index = match.index ?? 0;
 		const textBeforeTag = normalizeHtmlEntitiesForTerminal(raw.slice(lastIndex, index));
+		const name = htmlTagName(tag);
+		// Every tag handled here is block-level EXCEPT span and text. For block-level tags,
 		// HTML formatting whitespace between block/list tags (e.g. the newlines and
 		// indentation in pretty-printed `<ul>\n  <li>…`) is not rendered content;
 		// appending it literally would leak source indentation before bullets and
-		// blank rows between items. Every tag handled here is block-level, so a
-		// whitespace-only slice is always insignificant formatting and is dropped.
-		if (textBeforeTag.trim() !== "") {
+		// blank rows between items. A whitespace-only slice is always insignificant formatting
+		// and is dropped. But for inline tags like span and text, surrounding whitespace
+		// is significant and must NOT be dropped.
+		const isInlineTag = name === "span" || name === "text";
+		if (isInlineTag || textBeforeTag.trim() !== "") {
 			output += textBeforeTag;
 			markCurrentHtmlItemContent(state, textBeforeTag);
 		}
 		lastIndex = index + tag.length;
 
-		const name = htmlTagName(tag);
 		const isClosing = /^<\//.test(tag);
 		const isSelfClosing = /\/\s*>$/.test(tag);
 
 		switch (name) {
+			case "span":
+			case "text":
+				break;
 			case "br":
 				output = appendHtmlLineBreak(output, true);
 				break;