fix: resolve debounce promise hanging in GhostInlineCompletionProvider

Fixed timeout issues in request deduplication tests by ensuring all pending
debounce promises are properly resolved. The previous implementation would
create new promises on each call but never resolve old ones when the timer
was cleared and reset.

Changes:
- Added pendingDebounceResolvers array to track all promise resolvers
- Resolve all accumulated promises when debounce timer fires
- Distinguish between 'typing ahead' (reuse request) and 'diverging' (flush and start new)
- Clear pending resolvers in dispose() method
- Updated test helpers to properly handle async timer advancement

All 5458 tests now pass, including the 5 request deduplication tests that
were previously timing out after 20 seconds.

Author: markijbema

src/services/ghost/classic-auto-complete/GhostInlineCompletionProvider.ts

@@ -204,6 +204,8 @@ export class GhostInlineCompletionProvider implements vscode.InlineCompletionIte
 			clearTimeout(this.debounceTimer)
 			this.debounceTimer = null
 		}
+		// Clear pending debounce resolvers
+		this.pendingDebounceResolvers = []
 		// Cancel all pending requests
 		for (const pending of this.pendingRequests.values()) {
 			pending.abortController.abort()
@@ -292,16 +294,58 @@ export class GhostInlineCompletionProvider implements vscode.InlineCompletionIte
 		}
 	}
 
+	private pendingDebounceResolvers: Array<() => void> = []
+	private lastDebouncedPrompt: { prompt: GhostPrompt; prefix: string; suffix: string } | null = null
+
 	private debouncedFetchAndCacheSuggestion(prompt: GhostPrompt, prefix: string, suffix: string): Promise<void> {
-		if (this.debounceTimer !== null) {
-			clearTimeout(this.debounceTimer)
+		// Check if we have a pending request with a different prefix/suffix
+		if (this.debounceTimer !== null && this.lastDebouncedPrompt) {
+			const lastPrompt = this.lastDebouncedPrompt
+
+			// Check if this is a "typing ahead" scenario (new prefix starts with old prefix and same suffix)
+			const isTypingAhead = prefix.startsWith(lastPrompt.prefix) && suffix === lastPrompt.suffix
+
+			// Check if prefix has truly diverged (not just typing ahead)
+			const hasDiverged = !isTypingAhead && (lastPrompt.prefix !== prefix || lastPrompt.suffix !== suffix)
+
+			if (hasDiverged) {
+				// Prefix/suffix has diverged - flush the pending request immediately
+				clearTimeout(this.debounceTimer)
+				this.debounceTimer = null
+
+				// Trigger the previous request
+				const previousResolvers = this.pendingDebounceResolvers.splice(0)
+				this.fetchAndCacheSuggestion(lastPrompt.prompt, lastPrompt.prefix, lastPrompt.suffix).then(() => {
+					previousResolvers.forEach((r) => r())
+				})
+			} else {
+				// Same prefix/suffix or typing ahead - just clear the timer to restart debounce
+				clearTimeout(this.debounceTimer)
+			}
 		}
 
+		// Store the current prompt
+		this.lastDebouncedPrompt = { prompt, prefix, suffix }
+
 		return new Promise<void>((resolve) => {
+			// Add this resolver to the list
+			this.pendingDebounceResolvers.push(resolve)
+
 			this.debounceTimer = setTimeout(async () => {
 				this.debounceTimer = null
-				await this.fetchAndCacheSuggestion(prompt, prefix, suffix)
-				resolve()
+				// Use the last prompt that was set
+				if (this.lastDebouncedPrompt) {
+					await this.fetchAndCacheSuggestion(
+						this.lastDebouncedPrompt.prompt,
+						this.lastDebouncedPrompt.prefix,
+						this.lastDebouncedPrompt.suffix,
+					)
+					this.lastDebouncedPrompt = null
+				}
+
+				// Resolve all pending promises
+				const resolvers = this.pendingDebounceResolvers.splice(0)
+				resolvers.forEach((r) => r())
 			}, DEBOUNCE_DELAY_MS)
 		})
 	}

src/services/ghost/classic-auto-complete/__tests__/GhostInlineCompletionProvider.request-deduplication.test.ts

@@ -33,8 +33,12 @@ describe("GhostInlineCompletionProvider - Request Deduplication", () => {
 	// Helper to call provideInlineCompletionItems and advance timers
 	async function provideWithDebounce(doc: vscode.TextDocument, pos: vscode.Position) {
 		const promise = provider.provideInlineCompletionItems_Internal(doc, pos, {} as any, {} as any)
-		await vi.advanceTimersByTimeAsync(300) // Advance past debounce delay
-		return promise
+		// Wait a tick to let the promise chain set up
+		await Promise.resolve()
+		// Advance timers past debounce delay
+		await vi.advanceTimersByTimeAsync(300)
+		// Wait for the completion to finish
+		return await promise
 	}
 
 	beforeEach(() => {
@@ -49,9 +53,16 @@ describe("GhostInlineCompletionProvider - Request Deduplication", () => {
 
 		mockContextProvider = {
 			getIde: vi.fn().mockReturnValue(mockIde),
-			getFormattedContext: vi.fn().mockResolvedValue(""),
-			getFimFormattedContext: vi.fn().mockResolvedValue({ prefix: "" }),
-			getFimCompiledPrefix: vi.fn().mockResolvedValue(""),
+			getProcessedSnippets: vi.fn().mockResolvedValue({
+				filepathUri: "file:///test.ts",
+				helper: {
+					lang: { name: "typescript", singleLineComment: "//" },
+					prunedPrefix: "",
+					prunedSuffix: "",
+				},
+				snippetsWithUris: [],
+				workspaceDirs: [],
+			}),
 		}
 
 		mockModel = {
@@ -93,17 +104,25 @@ describe("GhostInlineCompletionProvider - Request Deduplication", () => {
 		let callCount = 0
 		vi.mocked(mockModel.generateResponse).mockImplementation(async (_sys, _user, onChunk) => {
 			callCount++
-			onChunk({ type: "text", text: "test suggestion" })
+			onChunk({ type: "text", text: "<COMPLETION>test suggestion</COMPLETION>" })
 			return mockResponse
 		})
 
 		const document = new MockTextDocument(vscode.Uri.file("/test/file.ts"), "const x = \nconst y = 2")
 		const position = new vscode.Position(0, 10)
 
-		// Make two identical requests quickly
-		const promise1 = provideWithDebounce(document, position)
-		const promise2 = provideWithDebounce(document, position)
+		// Make two identical requests - the second should reuse the first's pending request
+		const promise1 = provider.provideInlineCompletionItems_Internal(document, position, {} as any, {} as any)
+
+		// Wait a tick to let the first request's debounce timer start
+		await Promise.resolve()
+
+		const promise2 = provider.provideInlineCompletionItems_Internal(document, position, {} as any, {} as any)
 
+		// Advance timers to trigger the debounce
+		await vi.advanceTimersByTimeAsync(300)
+
+		// Wait for both promises to complete
 		await Promise.all([promise1, promise2])
 
 		// Should only call the API once due to deduplication
@@ -122,20 +141,26 @@ describe("GhostInlineCompletionProvider - Request Deduplication", () => {
 		let callCount = 0
 		vi.mocked(mockModel.generateResponse).mockImplementation(async (_sys, _user, onChunk) => {
 			callCount++
-			onChunk({ type: "text", text: "function test() {}" })
+			onChunk({ type: "text", text: "<COMPLETION>function test() {}</COMPLETION>" })
 			return mockResponse
 		})
 
 		const document = new MockTextDocument(vscode.Uri.file("/test/file.ts"), "const x = f\nconst y = 2")
 		const position1 = new vscode.Position(0, 11)
-		const position2 = new vscode.Position(0, 12) // User typed one more character
 
 		// Start first request
-		const promise1 = provideWithDebounce(document, position1)
+		const promise1 = provider.provideInlineCompletionItems_Internal(document, position1, {} as any, {} as any)
+
+		// Wait a tick
+		await Promise.resolve()
 
+		// User types ahead - new document with one more character
 		const document2 = new MockTextDocument(vscode.Uri.file("/test/file.ts"), "const x = fu\nconst y = 2")
+		const position2 = new vscode.Position(0, 12)
+		const promise2 = provider.provideInlineCompletionItems_Internal(document2, position2, {} as any, {} as any)
 
-		const promise2 = provideWithDebounce(document2, position2)
+		// Advance timers
+		await vi.advanceTimersByTimeAsync(300)
 
 		await Promise.all([promise1, promise2])
 
@@ -156,19 +181,25 @@ describe("GhostInlineCompletionProvider - Request Deduplication", () => {
 
 		vi.mocked(mockModel.generateResponse).mockImplementation(async (_sys, _user, onChunk) => {
 			callCount++
-			onChunk({ type: "text", text: "test suggestion" })
+			onChunk({ type: "text", text: "<COMPLETION>test suggestion</COMPLETION>" })
 			return mockResponse
 		})
 
 		const document1 = new MockTextDocument(vscode.Uri.file("/test/file.ts"), "const x = f\nconst y = 2")
-		const document2 = new MockTextDocument(vscode.Uri.file("/test/file.ts"), "const x = g\nconst y = 2")
-
 		const position = new vscode.Position(0, 11)
 
 		// Start first request
-		const promise1 = provideWithDebounce(document1, position)
+		const promise1 = provider.provideInlineCompletionItems_Internal(document1, position, {} as any, {} as any)
+
+		// Wait a tick
+		await Promise.resolve()
+
+		// User changes to different prefix - this should cancel the first request
+		const document2 = new MockTextDocument(vscode.Uri.file("/test/file.ts"), "const x = g\nconst y = 2")
+		const promise2 = provider.provideInlineCompletionItems_Internal(document2, position, {} as any, {} as any)
 
-		const promise2 = provideWithDebounce(document2, position)
+		// Advance timers
+		await vi.advanceTimersByTimeAsync(300)
 
 		await Promise.all([promise1, promise2])