@oh-my-pi/pi-tui 15.11.4 → 15.11.7

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [15.11.5] - 2026-06-12
+### Added
+
+- Added `fuzzyRank` to return sorted matches together with a fuzzy score
+- Added a configurable `Input.prompt` field (defaults to `"> "`; set to `""` for chrome-less embedding inside custom banners)
+
+### Changed
+
+- Changed fuzzy matching to normalize queries and text into words, including camelCase and punctuation separators, before scoring
+- Changed `Input.setValue` to place the cursor at the end of the new value instead of clamping it to its previous position, so typing after seeding a prefilled value appends rather than prepends
+
+### Fixed
+
+- Fixed multi-word searches so `fuzzyMatch` no longer matches when query letters are only scattered across unrelated words
+
 ## [15.11.4] - 2026-06-12
 ### Added
 

package/dist/types/components/input.d.ts

@@ -4,6 +4,8 @@ import { type Component, type Focusable } from "../tui";
  */
 export declare class Input implements Component, Focusable {
     #private;
+    /** Rendered before the editable area; set to "" for chrome-less embedding. */
+    prompt: string;
     onSubmit?: (value: string) => void;
     onEscape?: () => void;
     /** Focusable interface - set by TUI when focus changes */

package/dist/types/fuzzy.d.ts

@@ -1,15 +1,24 @@
 /**
  * Fuzzy matching utilities.
- * Matches if all query characters appear in order (not necessarily consecutive).
+ *
+ * Matching is deliberately word-local for normal words. This keeps a query like
+ * "image provider" from matching a long setting description only because the
+ * letters i-m-a-g-e appear somewhere in order across unrelated words.
+ *
  * Lower score = better match.
  */
 export interface FuzzyMatch {
     matches: boolean;
     score: number;
 }
+export interface FuzzyFilterResult<T> {
+    item: T;
+    score: number;
+}
 export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
 /**
  * Filter and sort items by fuzzy match quality (best matches first).
  * Supports space-separated tokens: all tokens must match.
  */
+export declare function fuzzyRank<T>(items: T[], query: string, getText: (item: T) => string): FuzzyFilterResult<T>[];
 export declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "15.11.4",
+	"version": "15.11.7",
 	"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": "15.11.4",
-		"@oh-my-pi/pi-utils": "15.11.4",
+		"@oh-my-pi/pi-natives": "15.11.7",
+		"@oh-my-pi/pi-utils": "15.11.7",
 		"lru-cache": "11.5.1",
 		"marked": "^18.0.4"
 	},

package/src/components/input.ts

@@ -28,6 +28,8 @@ export class Input implements Component, Focusable {
 	#value: string = "";
 	#cursor: number = 0; // Cursor position in the value
 	#useTerminalCursor = false;
+	/** Rendered before the editable area; set to "" for chrome-less embedding. */
+	prompt = "> ";
 	onSubmit?: (value: string) => void;
 	onEscape?: () => void;
 
@@ -50,7 +52,8 @@ export class Input implements Component, Focusable {
 
 	setValue(value: string): void {
 		this.#value = value;
-		this.#cursor = Math.min(this.#cursor, value.length);
+		// Callers seed or replace the value wholesale; typing continues at the end.
+		this.#cursor = value.length;
 	}
 
 	setUseTerminalCursor(useTerminalCursor: boolean): void {
@@ -399,8 +402,8 @@ export class Input implements Component, Focusable {
 
 	render(width: number): readonly string[] {
 		// Calculate visible window
-		const prompt = "> ";
-		const availableWidth = width - prompt.length;
+		const prompt = this.prompt;
+		const availableWidth = width - visibleWidth(prompt);
 
 		if (availableWidth <= 0) {
 			return [prompt];

package/src/fuzzy.ts

@@ -1,6 +1,10 @@
 /**
  * Fuzzy matching utilities.
- * Matches if all query characters appear in order (not necessarily consecutive).
+ *
+ * Matching is deliberately word-local for normal words. This keeps a query like
+ * "image provider" from matching a long setting description only because the
+ * letters i-m-a-g-e appear somewhere in order across unrelated words.
+ *
  * Lower score = better match.
  */
 
@@ -9,56 +13,107 @@ export interface FuzzyMatch {
 	score: number;
 }
 
+export interface FuzzyFilterResult<T> {
+	item: T;
+	score: number;
+}
+
+interface CharacterMatch {
+	matches: boolean;
+	score: number;
+	span: number;
+}
+
+interface SearchWord {
+	text: string;
+	index: number;
+	ordinal: number;
+}
+
+interface SearchIndex {
+	normalized: string;
+	compact: string;
+	/** Start offsets of each word within `compact` (cumulative word lengths). */
+	compactWordStarts: Set<number>;
+	words: SearchWord[];
+}
+
 const ALPHANUMERIC_SWAP_PENALTY = 5;
+const COMPACT_PHRASE_BONUS = 1200;
+const PHRASE_BONUS = 1000;
 
-function scoreMatch(queryLower: string, textLower: string): FuzzyMatch {
+function normalizeForSearch(value: string): string {
+	return value
+		.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+		.replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, " ")
+		.trim()
+		.replace(/\s+/g, " ");
+}
+
+function buildSearchIndex(text: string): SearchIndex {
+	const normalized = normalizeForSearch(text);
+	if (normalized.length === 0) {
+		return { normalized, compact: "", compactWordStarts: new Set(), words: [] };
+	}
+
+	const words: SearchWord[] = [];
+	const compactWordStarts = new Set<number>();
+	let index = 0;
+	let compactIndex = 0;
+	let ordinal = 0;
+	for (const word of normalized.split(" ")) {
+		words.push({ text: word, index, ordinal });
+		compactWordStarts.add(compactIndex);
+		index += word.length + 1;
+		compactIndex += word.length;
+		ordinal++;
+	}
+
+	return { normalized, compact: normalized.replaceAll(" ", ""), compactWordStarts, words };
+}
+
+function scoreCharacters(queryLower: string, textLower: string): CharacterMatch {
 	if (queryLower.length === 0) {
-		return { matches: true, score: 0 };
+		return { matches: true, score: 0, span: 0 };
 	}
 
 	if (queryLower.length > textLower.length) {
-		return { matches: false, score: 0 };
+		return { matches: false, score: 0, span: 0 };
 	}
 
 	let queryIndex = 0;
 	let score = 0;
+	let firstMatchIndex = -1;
 	let lastMatchIndex = -1;
 	let consecutiveMatches = 0;
 
 	for (let i = 0; i < textLower.length && queryIndex < queryLower.length; i++) {
 		if (textLower[i] === queryLower[queryIndex]) {
-			const isWordBoundary = i === 0 || /[\s\-_./:]/.test(textLower[i - 1]!);
+			if (firstMatchIndex < 0) firstMatchIndex = i;
 
-			// Reward consecutive matches
 			if (lastMatchIndex === i - 1) {
 				consecutiveMatches++;
 				score -= consecutiveMatches * 5;
 			} else {
 				consecutiveMatches = 0;
-				// Penalize gaps
 				if (lastMatchIndex >= 0) {
 					score += (i - lastMatchIndex - 1) * 2;
 				}
 			}
 
-			// Reward word boundary matches
-			if (isWordBoundary) {
-				score -= 10;
-			}
-
-			// Slight penalty for later matches
 			score += i * 0.1;
-
 			lastMatchIndex = i;
 			queryIndex++;
 		}
 	}
 
 	if (queryIndex < queryLower.length) {
-		return { matches: false, score: 0 };
+		return { matches: false, score: 0, span: 0 };
 	}
 
-	return { matches: true, score };
+	return { matches: true, score, span: lastMatchIndex - firstMatchIndex + 1 };
 }
 
 function buildAlphanumericSwapQueries(queryLower: string): string[] {
@@ -76,68 +131,168 @@ function buildAlphanumericSwapQueries(queryLower: string): string[] {
 	return [...variants];
 }
 
-export function fuzzyMatch(query: string, text: string): FuzzyMatch {
-	const queryLower = query.toLowerCase();
-	const textLower = text.toLowerCase();
+function withPosition(score: number, index: number): number {
+	return score + index * 0.01;
+}
+
+function isWordBoundaryPhrase(normalized: string, index: number, length: number): boolean {
+	const before = index === 0 || normalized[index - 1] === " ";
+	const afterIndex = index + length;
+	const after = afterIndex === normalized.length || normalized[afterIndex] === " ";
+	return before && after;
+}
+
+function scoreTokenAgainstWord(token: string, word: SearchWord): FuzzyMatch | null {
+	if (word.text === token) {
+		return { matches: true, score: withPosition(-200, word.index) };
+	}
+
+	if (word.text.startsWith(token)) {
+		return { matches: true, score: withPosition(-170 + (word.text.length - token.length) * 0.5, word.index) };
+	}
+
+	if (token.startsWith(word.text) && token.length - word.text.length <= 2) {
+		return { matches: true, score: withPosition(-150 + token.length - word.text.length, word.index) };
+	}
+
+	const substringIndex = word.text.indexOf(token);
+	if (substringIndex >= 0) {
+		return { matches: true, score: withPosition(-20 + substringIndex, word.index) };
+	}
+
+	const characterMatch = scoreCharacters(token, word.text);
+	if (!characterMatch.matches) return null;
+
+	const maxSpan = Math.max(token.length + 2, Math.ceil(token.length * 1.8));
+	if (characterMatch.span > maxSpan) return null;
+
+	return { matches: true, score: withPosition(-40 + characterMatch.score, word.index) };
+}
+
+function scoreAcronym(token: string, index: SearchIndex): FuzzyMatch | null {
+	if (token.length < 2 || token.length > 4 || index.words.length === 0) return null;
+
+	let queryIndex = 0;
+	let firstOrdinal = -1;
+	let lastOrdinal = -1;
+	let firstTextIndex = 0;
 
-	const direct = scoreMatch(queryLower, textLower);
-	if (direct.matches) {
-		return direct;
+	for (const word of index.words) {
+		if (word.text[0] !== token[queryIndex]) continue;
+		if (firstOrdinal < 0) {
+			firstOrdinal = word.ordinal;
+			firstTextIndex = word.index;
+		}
+		lastOrdinal = word.ordinal;
+		queryIndex++;
+		if (queryIndex === token.length) break;
+	}
+
+	if (queryIndex < token.length || firstOrdinal < 0 || lastOrdinal < 0) return null;
+
+	const wordSpan = lastOrdinal - firstOrdinal + 1;
+	if (wordSpan > token.length + 2) return null;
+
+	return { matches: true, score: withPosition(-30 + wordSpan * 4 - token.length * 2, firstTextIndex) };
+}
+
+function scoreTokenDirect(token: string, index: SearchIndex): FuzzyMatch {
+	if (token.length === 0) return { matches: true, score: 0 };
+
+	let best: FuzzyMatch | null = null;
+	const compactIndex = index.compact.indexOf(token);
+	if (compactIndex >= 0 && index.compactWordStarts.has(compactIndex)) {
+		best = { matches: true, score: withPosition(-140, compactIndex) };
+	}
+
+	for (const word of index.words) {
+		const match = scoreTokenAgainstWord(token, word);
+		if (match && (!best || match.score < best.score)) {
+			best = match;
+		}
 	}
 
-	let bestSwap: FuzzyMatch | null = null;
-	for (const variant of buildAlphanumericSwapQueries(queryLower)) {
-		const match = scoreMatch(variant, textLower);
+	const acronym = scoreAcronym(token, index);
+	if (acronym && (!best || acronym.score < best.score)) {
+		best = acronym;
+	}
+
+	return best ?? { matches: false, score: 0 };
+}
+
+function scoreToken(token: string, index: SearchIndex): FuzzyMatch {
+	let best = scoreTokenDirect(token, index);
+	if (best.matches) return best;
+
+	for (const variant of buildAlphanumericSwapQueries(token)) {
+		const match = scoreTokenDirect(variant, index);
 		if (!match.matches) continue;
 		const score = match.score + ALPHANUMERIC_SWAP_PENALTY;
-		if (!bestSwap || score < bestSwap.score) {
-			bestSwap = { matches: true, score };
+		if (!best.matches || score < best.score) {
+			best = { matches: true, score };
 		}
 	}
 
-	return bestSwap ?? direct;
+	return best;
 }
 
-/**
- * Filter and sort items by fuzzy match quality (best matches first).
- * Supports space-separated tokens: all tokens must match.
- */
-export function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[] {
-	if (!query.trim()) {
-		return items;
+export function fuzzyMatch(query: string, text: string): FuzzyMatch {
+	const normalizedQuery = normalizeForSearch(query);
+	if (normalizedQuery.length === 0) {
+		return { matches: true, score: 0 };
 	}
 
-	const tokens = query
-		.trim()
-		.split(/\s+/)
-		.filter(t => t.length > 0);
+	const index = buildSearchIndex(text);
+	if (index.words.length === 0) {
+		return { matches: false, score: 0 };
+	}
 
-	if (tokens.length === 0) {
-		return items;
+	let totalScore = 0;
+	const phraseIndex = index.normalized.indexOf(normalizedQuery);
+	if (phraseIndex >= 0 && isWordBoundaryPhrase(index.normalized, phraseIndex, normalizedQuery.length)) {
+		totalScore -= PHRASE_BONUS;
+		totalScore += phraseIndex * 0.01;
 	}
 
-	const results: { item: T; totalScore: number }[] = [];
+	const compactQuery = normalizedQuery.replaceAll(" ", "");
+	const compactPhraseIndex = index.compact.indexOf(compactQuery);
+	if (compactPhraseIndex >= 0 && index.compactWordStarts.has(compactPhraseIndex)) {
+		totalScore -= COMPACT_PHRASE_BONUS;
+		totalScore += compactPhraseIndex * 0.01;
+	}
 
-	for (const item of items) {
-		const text = getText(item);
-		let totalScore = 0;
-		let allMatch = true;
-
-		for (const token of tokens) {
-			const match = fuzzyMatch(token, text);
-			if (match.matches) {
-				totalScore += match.score;
-			} else {
-				allMatch = false;
-				break;
-			}
+	for (const token of normalizedQuery.split(" ")) {
+		const match = scoreToken(token, index);
+		if (!match.matches) {
+			return { matches: false, score: 0 };
 		}
+		totalScore += match.score;
+	}
+
+	return { matches: true, score: totalScore };
+}
 
-		if (allMatch) {
-			results.push({ item, totalScore });
+/**
+ * Filter and sort items by fuzzy match quality (best matches first).
+ * Supports space-separated tokens: all tokens must match.
+ */
+export function fuzzyRank<T>(items: T[], query: string, getText: (item: T) => string): FuzzyFilterResult<T>[] {
+	if (!query.trim()) {
+		return items.map(item => ({ item, score: 0 }));
+	}
+
+	const results: FuzzyFilterResult<T>[] = [];
+	for (const item of items) {
+		const match = fuzzyMatch(query, getText(item));
+		if (match.matches) {
+			results.push({ item, score: match.score });
 		}
 	}
 
-	results.sort((a, b) => a.totalScore - b.totalScore);
-	return results.map(r => r.item);
+	results.sort((a, b) => a.score - b.score);
+	return results;
+}
+
+export function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[] {
+	return fuzzyRank(items, query, getText).map(result => result.item);
 }

package/src/tui.ts

@@ -2712,6 +2712,18 @@ export class TUI extends Container {
 	#emitAltFrame(lines: string[], width: number, height: number): void {
 		const fitted: string[] = new Array(height);
 		for (let r = 0; r < height; r++) fitted[r] = lines[r] ?? "";
+		// Flush queued image-data transmits (`a=t`, no visible output) before the
+		// paint so id-keyed placements and placeholder cells composed into this
+		// frame resolve against loaded data. The normal-screen path flushes these
+		// ahead of its paint; without this, an image first shown inside a
+		// fullscreen overlay (e.g. the settings shape preview) would render as
+		// blank placeholder cells until the overlay closed.
+		const imageTransmits = this.#imageBudget.takeTransmits();
+		if (imageTransmits.length > 0) {
+			let transmitBuffer = "";
+			for (const seq of imageTransmits) transmitBuffer += seq;
+			this.terminal.write(transmitBuffer);
+		}
 		// Skip an identical repaint (the modal is mostly static between
 		// keystrokes) — unless a forced repaint (resetDisplay,
 		// requestRender(true)) is pending: the redraw gesture must repair a