@sayknow-cli/tui 0.3.7 → 0.3.8

package/dist/types/animation-scheduler.d.ts

@@ -0,0 +1,13 @@
+export type AnimationCadence = 16 | 80;
+type AnimationCallback = (now: number) => void;
+export interface AnimationRegistration {
+    unregister(): void;
+}
+export declare function registerAnimationCallback(callback: AnimationCallback, cadence?: AnimationCadence): AnimationRegistration;
+export declare const __animationSchedulerTestHooks: {
+    getActiveTimerCount(cadence?: AnimationCadence): number;
+    getRegistrantCount(cadence?: AnimationCadence): number;
+    getStartedTimerCount(cadence?: AnimationCadence): number;
+    reset(): void;
+};
+export {};

package/dist/types/autocomplete.d.ts

@@ -1,4 +1,5 @@
 export declare function getSlashCommandMatchRank(query: string, commandName: string): number;
+export declare function extractSlashCommandTokenPrefix(text: string): string | null;
 export interface AutocompleteItem {
     value: string;
     label: string;

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

@@ -1,4 +1,4 @@
-import type { AutocompleteProvider } from "../autocomplete";
+import { type AutocompleteProvider } from "../autocomplete";
 import type { SymbolTheme } from "../symbols";
 import { type Component, type Focusable } from "../tui";
 import { type SelectListTheme } from "./select-list";
@@ -24,6 +24,13 @@ interface HistoryStorage {
     add(prompt: string, cwd?: string): Promise<void>;
     getRecent(limit: number, cwd?: string): HistoryEntry[];
 }
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __editorPerfCounters: {
+    layoutTextInvocations: number;
+    layoutLogicalLinesProcessed: number;
+    visibleWidthMeasurements: number;
+    reset(): void;
+};
 export declare class Editor implements Component, Focusable {
     #private;
     /** Focusable interface - set by TUI when focus changes */
@@ -46,6 +53,7 @@ export declare class Editor implements Component, Focusable {
     onTab?: (text: string) => boolean | undefined;
     disableSubmit: boolean;
     constructor(theme: EditorTheme);
+    dispose(): void;
     setAutocompleteProvider(provider: AutocompleteProvider): void;
     getAutocompleteProvider(): AutocompleteProvider | undefined;
     /** Whether the autocomplete dropdown is currently open. */
@@ -66,7 +74,7 @@ export declare class Editor implements Component, Focusable {
     setPlaceholder(placeholder: string | undefined): void;
     /**
      * Get the available width for top border content given a total terminal width.
-     * Accounts for the border characters and horizontal padding when visible.
+     * Accounts for right gutter, border characters, and horizontal padding when visible.
      */
     getTopBorderAvailableWidth(terminalWidth: number): number;
     /**
@@ -76,6 +84,7 @@ export declare class Editor implements Component, Focusable {
     getUseTerminalCursor(): boolean;
     setMaxHeight(maxHeight: number | undefined): void;
     setPaddingX(paddingX: number): void;
+    setRightGutterWidth(width: number): void;
     getAutocompleteMaxVisible(): number;
     setAutocompleteMaxVisible(maxVisible: number): void;
     setHistoryStorage(storage: HistoryStorage): void;

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

@@ -1,11 +1,20 @@
 import type { TUI } from "../tui";
 import { Text } from "./text";
+export interface LoaderOptions {
+    timeDependentColor?: boolean;
+}
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __loaderPerfCounters: {
+    liveIntervals: number;
+    startedIntervals: number;
+    reset(): void;
+};
 export declare class Loader extends Text {
     #private;
     private spinnerColorFn;
     private messageColorFn;
     private message;
-    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string, spinnerFrames?: string[]);
+    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string, spinnerFrames?: string[], options?: LoaderOptions);
     render(width: number): string[];
     start(): void;
     stop(): void;

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

@@ -1,8 +1,16 @@
 import type { SymbolTheme } from "../symbols";
 import type { Component } from "../tui";
+/** Test-only clock seam for streaming throttle tests. */
+export declare function __setMarkdownNowForTest(now: (() => number) | undefined): void;
 /** Test/diagnostic seam: number of synchronous highlight invocations since the last reset. */
 export declare function getMarkdownHighlightCallCount(): number;
 export declare function resetMarkdownHighlightCallCount(): void;
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __markdownPerfCounters: {
+    lexerInvocations: number;
+    lexedBytes: number;
+    reset(): void;
+};
 /** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
 export declare function clearRenderCache(): void;
 /**
@@ -53,7 +61,12 @@ export interface MarkdownTheme {
 export declare class Markdown implements Component {
     #private;
     constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle, codeBlockIndent?: number);
-    setText(text: string): void;
+    setOnStaleThrottle(callback: (() => void) | undefined): void;
+    setText(text: string, options?: {
+        streaming?: boolean;
+    }): void;
+    setStreaming(streaming: boolean): void;
+    dispose(): void;
     invalidate(): void;
     render(width: number): string[];
 }

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./animation-scheduler";
 export * from "./autocomplete";
 export * from "./components/box";
 export * from "./components/cancellable-loader";

package/dist/types/tui.d.ts

@@ -130,6 +130,11 @@ export declare class Container implements Component {
     invalidate(): void;
     render(width: number): string[];
 }
+type TuiRenderCounterSnapshot = {
+    debugRedrawEnvReads: number;
+    debugRedrawAppendWrites: number;
+    differentialGuardVisibleWidthCalls: number;
+};
 /**
  * TUI - Main class for managing terminal UI with differential rendering
  */
@@ -138,6 +143,8 @@ export declare class TUI extends Container {
     terminal: Terminal;
     /** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
     onDebug?: () => void;
+    static resetRenderCountersForTest(): void;
+    static getRenderCountersForTest(): TuiRenderCounterSnapshot;
     overlayStack: {
         component: Component;
         options?: OverlayOptions;
@@ -145,6 +152,7 @@ export declare class TUI extends Container {
         hidden: boolean;
     }[];
     constructor(terminal: Terminal, showHardwareCursor?: boolean);
+    dispose(): void;
     get fullRedraws(): number;
     getShowHardwareCursor(): boolean;
     setShowHardwareCursor(enabled: boolean): void;
@@ -175,16 +183,17 @@ export declare class TUI extends Container {
     removeInputListener(listener: InputListener): void;
     stop(): void;
     /**
-     * Multiplexer-aware resize render request.
+     * Viewport-repaint-aware resize render request.
      *
      * A forced full redraw (`requestRender(true)`) resets `#previousWidth`/`#previousHeight`
      * to -1, which makes `#doRender` treat the frame as a width change and fall into the
      * `fullRender` path. In terminal multiplexers that path skips the scrollback-clearing
      * `3J` escape (users navigate scrollback history), so replaying every transcript line
      * piles it back on top of scrollback — the "top of screen scrolls down to the prompt at
-     * high speed" resize storm. Here we keep force off in multiplexers so `#doRender`'s
-     * height-change branch takes the viewport-only `multiplexerViewportRepaint` path instead.
-     * Set `PI_TUI_LEGACY_MULTIPLEXER_FULL_RENDER=1` to restore the legacy forced redraw.
+     * high speed" resize storm. Windows Terminal can also visibly jump to the
+     * transcript top during streaming redraws, so viewport-repaint sessions keep
+     * force off and let `#doRender` repaint only the live viewport. Set
+     * `PI_TUI_LEGACY_MULTIPLEXER_FULL_RENDER=1` to restore the legacy tmux redraw.
      */
     requestResizeRender(): void;
     requestRender(force?: boolean, source?: string): void;

package/dist/types/utils.d.ts

@@ -1,9 +1,19 @@
 import { Ellipsis, type ExtractSegmentsResult, type SliceResult } from "@sayknow-cli/natives";
 export { Ellipsis } from "@sayknow-cli/natives";
 export { getDefaultTabWidth, getIndentation } from "@sayknow-cli/utils";
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __textHelperPerfCounters: {
+    truncateToWidthCalls: number;
+    wrapTextWithAnsiCalls: number;
+    truncateLinesToWidthCalls: number;
+    visibleWidthsCalls: number;
+    reset(): void;
+};
+export declare function invalidateTabWidthCache(): void;
 export declare function isPrintableAscii(text: string): boolean;
 export declare function sliceWithWidth(line: string, startCol: number, length: number, strict?: boolean | null): SliceResult;
 export declare function truncateToWidth(text: string, maxWidth: number, ellipsisKind?: Ellipsis | null, pad?: boolean | null): string;
+export declare function truncateLinesToWidth(lines: readonly string[], maxWidth: number, ellipsisKind?: Ellipsis | null, pad?: boolean | null): string[];
 export declare function wrapTextWithAnsi(text: string, width: number): string[];
 export declare function extractSegments(line: string, beforeEnd: number, afterStart: number, afterLen: number, strictAfter: boolean): ExtractSegmentsResult;
 /**
@@ -24,6 +34,8 @@ export declare function visibleWidthRaw(str: string): number;
  * Calculate the visible width of a string in terminal columns.
  */
 export declare function visibleWidth(str: string): number;
+export declare function visibleWidthsNative(lines: readonly string[]): number[];
+export declare function visibleWidths(lines: readonly string[]): number[];
 /**
  * Normalize text for terminal output without changing logical editor content.
  * Some terminals render canonically decomposed Hangul jamo or precomposed

package/package.json

@@ -1,9 +1,9 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/tui",
-	"version": "0.3.7",
+	"version": "0.3.8",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
-	"homepage": "https://github.com/jaybeyond/Sayknow_CLI",
+	"homepage": "https://sayknow-cli.com",
 	"author": "jaybeyond",
 	"contributors": [
 		"Mario Zechner"
@@ -38,8 +38,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@sayknow-cli/natives": "0.3.7",
-		"@sayknow-cli/utils": "0.3.7",
+		"@sayknow-cli/natives": "0.3.8",
+		"@sayknow-cli/utils": "0.3.8",
 		"lru-cache": "11.3.6",
 		"marked": "^18.0.3"
 	},

package/src/animation-scheduler.ts

@@ -0,0 +1,99 @@
+export type AnimationCadence = 16 | 80;
+
+type TimerHandle = ReturnType<typeof setInterval>;
+type AnimationCallback = (now: number) => void;
+
+interface CadenceBucket {
+	callbacks: Set<AnimationCallback>;
+	timer?: TimerHandle;
+	startedTimers: number;
+}
+
+const buckets = new Map<AnimationCadence, CadenceBucket>();
+
+function getBucket(cadence: AnimationCadence): CadenceBucket {
+	let bucket = buckets.get(cadence);
+	if (!bucket) {
+		bucket = { callbacks: new Set(), startedTimers: 0 };
+		buckets.set(cadence, bucket);
+	}
+	return bucket;
+}
+
+function startBucket(cadence: AnimationCadence, bucket: CadenceBucket): void {
+	if (bucket.timer) return;
+	bucket.timer = setInterval(() => {
+		const now = performance.now();
+		// Snapshot so re-entrant register/unregister during a tick is safe, and
+		// isolate each callback so one throwing registrant cannot starve siblings
+		// or surface as an uncaught exception that kills the shared timer.
+		for (const callback of [...bucket.callbacks]) {
+			try {
+				callback(now);
+			} catch (err) {
+				console.error("[animation-scheduler] callback threw:", err);
+			}
+		}
+	}, cadence);
+	bucket.startedTimers += 1;
+	bucket.timer?.unref?.();
+}
+
+function stopBucket(bucket: CadenceBucket): void {
+	if (!bucket.timer) return;
+	clearInterval(bucket.timer);
+	bucket.timer = undefined;
+}
+
+export interface AnimationRegistration {
+	unregister(): void;
+}
+
+export function registerAnimationCallback(
+	callback: AnimationCallback,
+	cadence: AnimationCadence = 80,
+): AnimationRegistration {
+	const bucket = getBucket(cadence);
+	bucket.callbacks.add(callback);
+	startBucket(cadence, bucket);
+	let registered = true;
+
+	return {
+		unregister(): void {
+			if (!registered) return;
+			registered = false;
+			bucket.callbacks.delete(callback);
+			if (bucket.callbacks.size === 0) stopBucket(bucket);
+		},
+	};
+}
+
+export const __animationSchedulerTestHooks = {
+	getActiveTimerCount(cadence?: AnimationCadence): number {
+		if (cadence !== undefined) return getBucket(cadence).timer ? 1 : 0;
+		let count = 0;
+		for (const bucket of buckets.values()) {
+			if (bucket.timer) count += 1;
+		}
+		return count;
+	},
+	getRegistrantCount(cadence?: AnimationCadence): number {
+		if (cadence !== undefined) return getBucket(cadence).callbacks.size;
+		let count = 0;
+		for (const bucket of buckets.values()) count += bucket.callbacks.size;
+		return count;
+	},
+	getStartedTimerCount(cadence?: AnimationCadence): number {
+		if (cadence !== undefined) return getBucket(cadence).startedTimers;
+		let count = 0;
+		for (const bucket of buckets.values()) count += bucket.startedTimers;
+		return count;
+	},
+	reset(): void {
+		for (const bucket of buckets.values()) {
+			stopBucket(bucket);
+			bucket.callbacks.clear();
+			bucket.startedTimers = 0;
+		}
+	},
+};

package/src/autocomplete.ts

@@ -189,7 +189,20 @@ function normalizeSlashCommandText(value: string): string {
 		.trim()
 		.replace(/\s+/g, " ");
 }
+const NON_COMMAND_SLASH_PREFIX_PRECEDERS = new Set(["/", "\\", ":", ".", "~"]);
 
+export function extractSlashCommandTokenPrefix(text: string): string | null {
+	const slashIndex = text.lastIndexOf("/");
+	if (slashIndex === -1) return null;
+
+	const token = text.slice(slashIndex);
+	if (/[\s]/.test(token)) return null;
+
+	const charBeforeSlash = text[slashIndex - 1];
+	if (charBeforeSlash && NON_COMMAND_SLASH_PREFIX_PRECEDERS.has(charBeforeSlash)) return null;
+
+	return token;
+}
 export interface AutocompleteItem {
 	value: string;
 	label: string;
@@ -272,6 +285,66 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		this.#basePath = basePath;
 	}
 
+	#getCommandName(cmd: SlashCommand | AutocompleteItem): string {
+		return "name" in cmd ? cmd.name : cmd.value;
+	}
+
+	#getSlashCommandNameSuggestions(prefix: string): AutocompleteItem[] {
+		const lowerPrefix = prefix.toLowerCase();
+
+		return this.#commands
+			.filter(cmd => {
+				const name = this.#getCommandName(cmd);
+				if (!name) return false;
+				if (fuzzyMatch(lowerPrefix, name.toLowerCase())) return true;
+				if (getSlashCommandMatchRank(lowerPrefix, name.toLowerCase()) < 4) return true;
+				const desc = cmd.description?.toLowerCase();
+				return desc ? fuzzyMatch(lowerPrefix, desc) : false;
+			})
+			.map((cmd, index) => {
+				const name = this.#getCommandName(cmd);
+				const lowerName = name?.toLowerCase() ?? "";
+				const lowerDesc = cmd.description?.toLowerCase() ?? "";
+				const nameScore = fuzzyMatch(lowerPrefix, lowerName) ? fuzzyScore(lowerPrefix, lowerName) : 0;
+				const descScore = fuzzyMatch(lowerPrefix, lowerDesc) ? fuzzyScore(lowerPrefix, lowerDesc) * 0.5 : 0;
+				const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
+				const desc = cmd.description ?? "";
+				const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
+				const priority = "priority" in cmd && typeof cmd.priority === "number" ? cmd.priority : 0;
+				return {
+					value: name,
+					label: "name" in cmd ? cmd.name : cmd.label,
+					score: Math.max(nameScore, descScore),
+					priority,
+					matchRank: getSlashCommandMatchRank(lowerPrefix, lowerName),
+					index,
+					...(fullDesc && { description: fullDesc }),
+				} as AutocompleteItem & { score: number; priority: number; matchRank: number; index: number };
+			})
+			.sort((a, b) => a.matchRank - b.matchRank || b.priority - a.priority || b.score - a.score || a.index - b.index)
+			.map(({ score: _score, priority: _priority, matchRank: _matchRank, index: _index, ...rest }) => rest);
+	}
+
+	#getInlineSlashCommandNameSuggestions(prefix: string): AutocompleteItem[] {
+		if (prefix.length === 0) return this.#getSlashCommandNameSuggestions(prefix);
+
+		const normalizedPrefix = normalizeSlashCommandText(prefix);
+		return this.#getSlashCommandNameSuggestions(prefix).filter(item => {
+			const lowerValue = item.value.toLowerCase();
+			if (lowerValue.startsWith(prefix.toLowerCase())) return true;
+			if (!normalizedPrefix) return true;
+			return normalizeSlashCommandText(item.value).startsWith(normalizedPrefix);
+		});
+	}
+
+	#extractSlashCommandPrefix(text: string): string | null {
+		return extractSlashCommandTokenPrefix(text);
+	}
+
+	#isKnownCommandItem(item: AutocompleteItem): boolean {
+		return this.#commands.some(cmd => this.#getCommandName(cmd) === item.value);
+	}
+
 	async getSuggestions(
 		lines: string[],
 		cursorLine: number,
@@ -301,52 +374,14 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 			};
 		}
 
-		// Check for slash commands
+		// Check for slash commands at the submitted-message start
 		if (textBeforeCursor.startsWith("/")) {
 			const spaceIndex = textBeforeCursor.indexOf(" ");
 
 			if (spaceIndex === -1) {
 				// No space yet - complete command names
 				const prefix = textBeforeCursor.slice(1); // Remove the "/"
-				const lowerPrefix = prefix.toLowerCase();
-
-				// Filter commands using fuzzy matching (subsequence match)
-				const matches = this.#commands
-					.filter(cmd => {
-						const name = "name" in cmd ? cmd.name : cmd.value;
-						if (!name) return false;
-						// Match name, normalized slash-name aliases, or description.
-						if (fuzzyMatch(lowerPrefix, name.toLowerCase())) return true;
-						if (getSlashCommandMatchRank(lowerPrefix, name.toLowerCase()) < 4) return true;
-						const desc = cmd.description?.toLowerCase();
-						return desc ? fuzzyMatch(lowerPrefix, desc) : false;
-					})
-					.map((cmd, index) => {
-						const name = "name" in cmd ? cmd.name : cmd.value;
-						const lowerName = name?.toLowerCase() ?? "";
-						const lowerDesc = cmd.description?.toLowerCase() ?? "";
-						// Score name matches higher than description matches
-						const nameScore = fuzzyMatch(lowerPrefix, lowerName) ? fuzzyScore(lowerPrefix, lowerName) : 0;
-						const descScore = fuzzyMatch(lowerPrefix, lowerDesc) ? fuzzyScore(lowerPrefix, lowerDesc) * 0.5 : 0;
-						const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
-						const desc = cmd.description ?? "";
-						const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
-						const priority = "priority" in cmd && typeof cmd.priority === "number" ? cmd.priority : 0;
-						return {
-							value: name,
-							label: "name" in cmd ? cmd.name : cmd.label,
-							score: Math.max(nameScore, descScore),
-							priority,
-							matchRank: getSlashCommandMatchRank(lowerPrefix, lowerName),
-							index,
-							...(fullDesc && { description: fullDesc }),
-						};
-					})
-					.sort(
-						(a, b) =>
-							a.matchRank - b.matchRank || b.priority - a.priority || b.score - a.score || a.index - b.index,
-					)
-					.map(({ score: _score, priority: _priority, matchRank: _matchRank, index: _index, ...rest }) => rest);
+				const matches = this.#getSlashCommandNameSuggestions(prefix);
 
 				if (matches.length === 0) return null;
 
@@ -354,36 +389,54 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 					items: matches,
 					prefix: textBeforeCursor,
 				};
-			} else {
-				// Space found - complete command arguments
-				const commandName = textBeforeCursor.slice(1, spaceIndex); // Command without "/"
-				const argumentText = textBeforeCursor.slice(spaceIndex + 1); // Text after space
+			}
 
-				const command = this.#commands.find(cmd => {
-					const name = "name" in cmd ? cmd.name : cmd.value;
-					return name === commandName;
-				});
-				if (!command || !("getArgumentCompletions" in command) || !command.getArgumentCompletions) {
-					return null; // No argument completion for this command
-				}
+			// Space found - complete command arguments
+			const commandName = textBeforeCursor.slice(1, spaceIndex); // Command without "/"
+			const argumentText = textBeforeCursor.slice(spaceIndex + 1); // Text after space
+
+			const command = this.#commands.find(cmd => this.#getCommandName(cmd) === commandName);
+			if (!command || !("getArgumentCompletions" in command) || !command.getArgumentCompletions) {
+				return null; // No argument completion for this command
+			}
+
+			const argumentSuggestions = await command.getArgumentCompletions(argumentText);
+			if (!Array.isArray(argumentSuggestions) || argumentSuggestions.length === 0) {
+				return null;
+			}
+
+			return {
+				items: argumentSuggestions,
+				prefix: argumentText,
+			};
+		}
 
-				const argumentSuggestions = await command.getArgumentCompletions(argumentText);
-				if (!Array.isArray(argumentSuggestions) || argumentSuggestions.length === 0) {
-					return null;
+		const pathMatch = this.#extractPathPrefix(textBeforeCursor, false);
+		let pathSuggestions: AutocompleteItem[] | null = null;
+		const slashPrefix = this.#extractSlashCommandPrefix(textBeforeCursor);
+		if (slashPrefix) {
+			if (pathMatch === slashPrefix && slashPrefix.startsWith("/")) {
+				pathSuggestions = await this.#getFileSuggestions(pathMatch);
+				if (pathSuggestions.length > 0) {
+					return {
+						items: pathSuggestions,
+						prefix: pathMatch,
+					};
 				}
+			}
 
+			const matches = this.#getInlineSlashCommandNameSuggestions(slashPrefix.slice(1));
+			if (matches.length > 0) {
 				return {
-					items: argumentSuggestions,
-					prefix: argumentText,
+					items: matches,
+					prefix: slashPrefix,
 				};
 			}
 		}
 
 		// Check for file paths - triggered by Tab or if we detect a path pattern
-		const pathMatch = this.#extractPathPrefix(textBeforeCursor, false);
-
 		if (pathMatch !== null) {
-			const suggestions = await this.#getFileSuggestions(pathMatch);
+			const suggestions = pathSuggestions ?? (await this.#getFileSuggestions(pathMatch));
 			if (suggestions.length === 0) return null;
 
 			// Check if we have an exact match that is a directory
@@ -418,9 +471,12 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
 		const afterCursor = currentLine.slice(cursorCol);
 
-		// Check if we're completing a slash command (prefix starts with "/" but NOT a file path)
-		// Slash commands are at the start of the line and don't contain path separators after the first /
-		const isSlashCommand = prefix.startsWith("/") && beforePrefix.trim() === "" && !prefix.slice(1).includes("/");
+		// Check if we're completing a slash command name. Start-of-line commands
+		// execute on submit; inline slash tokens are completed as ordinary text.
+		const isSlashCommand =
+			prefix.startsWith("/") &&
+			!prefix.slice(1).includes("/") &&
+			(beforePrefix.trim() === "" || this.#isKnownCommandItem(item));
 		if (isSlashCommand) {
 			// This is a command name completion
 			const newLine = `${beforePrefix}/${item.value} ${afterCursor}`;
@@ -855,40 +911,7 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		if (textBeforeCursor.length <= 1) return null; // Bare "/" alone, don't auto-complete
 		if (textBeforeCursor.includes(" ")) return null; // Only complete command name, not args
 
-		const prefix = textBeforeCursor.slice(1);
-		const lowerPrefix = prefix.toLowerCase();
-
-		const matches = this.#commands
-			.filter(cmd => {
-				const name = "name" in cmd ? cmd.name : cmd.value;
-				if (!name) return false;
-				if (fuzzyMatch(lowerPrefix, name.toLowerCase())) return true;
-				if (getSlashCommandMatchRank(lowerPrefix, name.toLowerCase()) < 4) return true;
-				const desc = cmd.description?.toLowerCase();
-				return desc ? fuzzyMatch(lowerPrefix, desc) : false;
-			})
-			.map((cmd, index) => {
-				const name = "name" in cmd ? cmd.name : cmd.value;
-				const lowerName = name?.toLowerCase() ?? "";
-				const lowerDesc = cmd.description?.toLowerCase() ?? "";
-				const nameScore = fuzzyMatch(lowerPrefix, lowerName) ? fuzzyScore(lowerPrefix, lowerName) : 0;
-				const descScore = fuzzyMatch(lowerPrefix, lowerDesc) ? fuzzyScore(lowerPrefix, lowerDesc) * 0.5 : 0;
-				const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
-				const desc = cmd.description ?? "";
-				const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
-				const priority = "priority" in cmd && typeof cmd.priority === "number" ? cmd.priority : 0;
-				return {
-					value: name,
-					label: "name" in cmd ? cmd.name : cmd.label,
-					score: Math.max(nameScore, descScore),
-					priority,
-					matchRank: getSlashCommandMatchRank(lowerPrefix, lowerName),
-					index,
-					...(fullDesc && { description: fullDesc }),
-				} as AutocompleteItem & { score: number; priority: number; matchRank: number; index: number };
-			})
-			.sort((a, b) => a.matchRank - b.matchRank || b.priority - a.priority || b.score - a.score || a.index - b.index)
-			.map(({ score: _score, priority: _priority, matchRank: _matchRank, index: _index, ...rest }) => rest);
+		const matches = this.#getSlashCommandNameSuggestions(textBeforeCursor.slice(1));
 
 		if (matches.length === 0) return null;
 		return { items: matches, prefix: textBeforeCursor };