@linxiraos/pi-tui 1.1.26 → 1.2.0

package/src/autocomplete.ts

@@ -263,8 +263,11 @@ export interface AutocompleteProvider {
 
 	/** Get inline hint text to show as dim ghost text after the cursor */
 	getInlineHint?(lines: string[], cursorLine: number, cursorCol: number): string | null;
-	/** Synchronously try to complete a slash command at the start of a line (no async I/O). */
-	/** Returns matched items and the full prefix, or null if not applicable. */
+	/**
+	 * Synchronously list slash command-name completions for a leading slash token (no async I/O).
+	 * Mirrors the command-name branch of {@link getSuggestions}, including the bare `/` listing and
+	 * the collapsed `/skill:` namespace row. Returns null outside a command-name token or with no match.
+	 */
 	trySyncSlashCompletion?(textBeforeCursor: string): { items: AutocompleteItem[]; prefix: string } | null;
 	/**
 	 * Synchronously try to expand text immediately before the cursor (no async I/O).
@@ -589,6 +592,22 @@ function buildMidPromptSkillCompletions(commands: CommandEntry[], lowerPrefix: s
 	);
 }
 
+const DIR_CACHE_MAX = 100;
+const DIR_CACHE_EVICT = 50;
+
+/**
+ * Drops the `count` oldest entries once `map` exceeds `max`. Callers delete a
+ * key before re-setting it, so Map insertion order is refresh order.
+ */
+function evictOldest(map: Map<string, unknown>, max: number, count: number): void {
+	if (map.size <= max) return;
+	let remaining = count;
+	for (const key of map.keys()) {
+		if (remaining-- === 0) break;
+		map.delete(key);
+	}
+}
+
 // Combined provider that handles both slash commands and file paths.
 export class CombinedAutocompleteProvider implements AutocompleteProvider {
 	#commands: CommandEntry[];
@@ -598,6 +617,9 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 	// per-directory readdir fast-path for prefix completions. Global fuzzy
 	// discovery continues to use native fuzzyFind + shared scan cache.
 	#dirCache: Map<string, { entries: fs.Dirent[]; timestamp: number }> = new Map();
+	// Whether a scoped fuzzy query's base (`src/` in `@src/foo`) is a directory;
+	// stat'ing it on every keystroke is redundant while the base is unchanged.
+	#scopedBaseCache: Map<string, { isDirectory: boolean; timestamp: number }> = new Map();
 	readonly #DIR_CACHE_TTL = 2000; // 2 seconds
 
 	constructor(
@@ -806,7 +828,7 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 			};
 		}
 
-		// Slash command suggestions can be accepted before the debounced refresh
+		// Slash command suggestions can be accepted before an async refresh
 		// catches up to newly typed characters. Replace the live command token,
 		// not only the prefix captured when the suggestion list was rendered.
 		// Absolute-path completions share the leading-slash prefix shape but
@@ -976,11 +998,21 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 			baseDir = path.join(this.#basePath, displayBase);
 		}
 
-		try {
-			if (!(await fs.promises.stat(baseDir)).isDirectory()) {
-				return null;
+		const now = Date.now();
+		let cachedBase = this.#scopedBaseCache.get(baseDir);
+		if (!cachedBase || now - cachedBase.timestamp >= this.#DIR_CACHE_TTL) {
+			let isDirectory = false;
+			try {
+				isDirectory = (await fs.promises.stat(baseDir)).isDirectory();
+			} catch {
+				// Missing or inaccessible base: not a scope.
 			}
-		} catch {
+			cachedBase = { isDirectory, timestamp: now };
+			this.#scopedBaseCache.delete(baseDir);
+			this.#scopedBaseCache.set(baseDir, cachedBase);
+			evictOldest(this.#scopedBaseCache, DIR_CACHE_MAX, DIR_CACHE_EVICT);
+		}
+		if (!cachedBase.isDirectory) {
 			return null;
 		}
 
@@ -1003,17 +1035,9 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		}
 
 		const entries = await fs.promises.readdir(searchDir, { withFileTypes: true });
+		this.#dirCache.delete(searchDir);
 		this.#dirCache.set(searchDir, { entries, timestamp: now });
-
-		if (this.#dirCache.size > 100) {
-			const sortedKeys = [...this.#dirCache.entries()]
-				.sort((a, b) => a[1].timestamp - b[1].timestamp)
-				.slice(0, 50)
-				.map(([key]) => key);
-			for (const key of sortedKeys) {
-				this.#dirCache.delete(key);
-			}
-		}
+		evictOldest(this.#dirCache, DIR_CACHE_MAX, DIR_CACHE_EVICT);
 
 		return entries;
 	}
@@ -1021,8 +1045,10 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 	invalidateDirCache(dir?: string): void {
 		if (dir) {
 			this.#dirCache.delete(dir);
+			this.#scopedBaseCache.delete(dir);
 		} else {
 			this.#dirCache.clear();
+			this.#scopedBaseCache.clear();
 		}
 	}
 
@@ -1087,26 +1113,29 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 			const entries = await this.#getCachedDirEntries(searchDir);
 			const suggestions: AutocompleteItem[] = [];
 
-			for (const entry of entries) {
-				if (!entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase())) {
-					continue;
-				}
-				// Skip .git directory
-				if (entry.name === ".git") {
-					continue;
-				}
+			const lowerSearchPrefix = searchPrefix.toLowerCase();
+			// Skip .git directory
+			const matched = entries.filter(
+				entry => entry.name !== ".git" && entry.name.toLowerCase().startsWith(lowerSearchPrefix),
+			);
+			// Directory flag per match; symlinks are stat'ed concurrently to learn whether
+			// they point at a directory. `null` drops a broken symlink, a file deleted
+			// between readdir and stat, or a permission error.
+			const directoryFlags = await Promise.all(
+				matched.map(entry =>
+					!entry.isDirectory() && entry.isSymbolicLink()
+						? fs.promises.stat(path.join(searchDir, entry.name)).then(
+								stats => stats.isDirectory(),
+								() => null,
+							)
+						: entry.isDirectory(),
+				),
+			);
 
-				// Check if entry is a directory (or a symlink pointing to a directory)
-				let isDirectory = entry.isDirectory();
-				if (!isDirectory && entry.isSymbolicLink()) {
-					try {
-						const fullPath = path.join(searchDir, entry.name);
-						isDirectory = (await fs.promises.stat(fullPath)).isDirectory();
-					} catch {
-						// Broken symlink, file deleted between readdir and stat, or permission error
-						continue;
-					}
-				}
+			for (let index = 0; index < matched.length; index++) {
+				const isDirectory = directoryFlags[index];
+				if (typeof isDirectory !== "boolean") continue;
+				const entry = matched[index]!;
 
 				let relativePath: string;
 				const name = entry.name;
@@ -1300,19 +1329,14 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		const slashStart = findLeadingSlashCommandStart(textBeforeCursor);
 		if (slashStart === null) return null;
 		const commandText = textBeforeCursor.slice(slashStart);
-		if (commandText.length <= 1) return null; // Bare "/" alone, don't auto-complete
 		if (commandText.includes(" ")) return null; // Only complete command name, not args
 
-		const prefix = commandText.slice(1);
-		const lowerPrefix = prefix.toLowerCase();
-
-		// The `/skill:` namespace row is excluded here: the sync path submits
-		// immediately after applying, and the bare namespace is not a command.
+		const lowerPrefix = commandText.slice(1).toLowerCase();
 		const matches = buildSlashCommandCompletions(
 			collapseSkillNamespace(this.#commands, lowerPrefix),
 			lowerPrefix,
 			this.#commandUsage,
-		).filter(item => item.value !== SKILL_NAMESPACE);
+		);
 
 		if (matches.length === 0) return null;
 		// Mirror `getSuggestions`: preserve leading whitespace so the editor's

package/src/bracketed-paste.ts

@@ -85,10 +85,17 @@ export class BracketedPasteHandler {
 	 *          buffer); omitted when still buffering.
 	 */
 	process(data: string): PasteResult {
-		if (data.includes(PASTE_START)) {
+		const start = data.indexOf(PASTE_START);
+		const end = data.indexOf(PASTE_END);
+		if (start !== -1 && (end === -1 || start < end)) {
+			if (!this.#active) this.#buffer = "";
 			this.#active = true;
-			this.#buffer = "";
-			data = data.replace(PASTE_START, "");
+			// Only strip nested starts before this paste's first end. Later starts
+			// belong to the next paste in `remaining`.
+			data =
+				end === -1
+					? data.replaceAll(PASTE_START, "")
+					: data.slice(0, end).replaceAll(PASTE_START, "") + data.slice(end);
 		}
 
 		if (!this.#active) return { handled: false };