Serialize LSP stop, clean up Git listeners, and miscellaneous robustness fixes

vscode-extension/src/extension.ts

@@ -292,14 +292,6 @@ export async function activate(context: vscode.ExtensionContext) {
     });
     context.subscriptions.push(gitService);
     await gitService.setupGitListener(context);
-
-    // Register listener for disposal
-    context.subscriptions.push({
-        dispose: () => {
-            lspClient.stop();
-        },
-    });
-
     // Index commands initially
     await commandIndexer.indexCommands();
 

vscode-extension/src/lsp-client.ts

@@ -22,6 +22,7 @@ export class DeepLensLspClient implements ISearchProvider {
     private readonly context: vscode.ExtensionContext;
     private isStopping = false;
     private startPromise: Promise<void> | null = null;
+    private stopPromise: Promise<void> | null = null;
     private disposables: vscode.Disposable[] = [];
     public onProgress = new vscode.EventEmitter<{
         state: 'start' | 'report' | 'end';
@@ -280,18 +281,28 @@ export class DeepLensLspClient implements ISearchProvider {
     }
 
     async stop(): Promise<void> {
-        this.isStopping = true;
+        if (this.stopPromise) {
+            await this.stopPromise;
+            return;
+        }
+
+        this.stopPromise = (async () => {
+            this.isStopping = true;
+
+            await this.waitForStartCompletion();
+            await this.stopClientInstance();
 
-        await this.waitForStartCompletion();
-        await this.stopClientInstance();
+            this.disposeTrackedDisposables();
 
-        this.disposeTrackedDisposables();
+            this.onProgress.dispose();
+            this.onRipgrepUnavailable.dispose();
+        })();
 
-        this.onProgress.dispose();
+        await this.stopPromise;
     }
 
     private async waitForStartCompletion(): Promise<void> {
-        if (this.startPromise === undefined) {
+        if (this.startPromise === null) {
             return;
         }
 

vscode-extension/src/reference-code-lens.ts

@@ -20,6 +20,13 @@ enum CodeLensType {
     IMPLEMENTATION = 'implementation',
 }
 
+
+function isSymbolInformationArray(
+    symbols: vscode.DocumentSymbol[] | vscode.SymbolInformation[],
+): symbols is vscode.SymbolInformation[] {
+    return symbols.length > 0 && 'containerName' in symbols[0];
+}
+
 /**
  * CodeLens provider that shows reference and implementation counts above symbols
  * Similar to JetBrains Rider's "Code Vision" feature
@@ -74,9 +81,8 @@ export class ReferenceCodeLensProvider implements vscode.CodeLensProvider {
             // Check if we got DocumentSymbol[] (hierarchy) or SymbolInformation[] (flat)
             if (symbols.length > 0 && 'children' in symbols[0]) {
                 this.collectSymbols(symbols as vscode.DocumentSymbol[], codeLenses, document);
-            } else if (symbols.length > 0 && 'containerName' in symbols[0]) {
-                // Handle flat SymbolInformation[]
-                this.collectFlatSymbols(symbols as unknown as vscode.SymbolInformation[], codeLenses, document);
+            } else if (isSymbolInformationArray(symbols)) {
+                this.collectFlatSymbols(symbols, codeLenses, document);
             }
         } catch (error) {
             console.error('[DeepLens] Error getting document symbols:', error);

vscode-extension/src/search-provider.ts

@@ -1869,8 +1869,7 @@ export class SearchProvider {
         }
 
         return {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            label: label as any,
+            label,
             description,
             detail,
             iconPath: iconPath,

vscode-extension/src/services/git-service.ts

@@ -19,6 +19,7 @@ export interface GitAPI {
 
 export class GitService {
     private gitChangeDebounce: NodeJS.Timeout | undefined;
+    private readonly repoListeners: vscode.Disposable[] = [];
     private readonly onRepoChange: () => Promise<void>;
 
     constructor(onRepoChange: () => Promise<void>) {
@@ -62,11 +63,14 @@ export class GitService {
         let lastHead = repository.state.HEAD?.commit || repository.state.HEAD?.name;
         logger.log(`Monitoring repository at ${repository.rootUri.fsPath} (Initial HEAD: ${lastHead})`);
 
-        repository.state.onDidChange(() => {
+        const stateDisposable = repository.state.onDidChange(() => {
             const currentHead = repository.state.HEAD?.commit || repository.state.HEAD?.name;
 
             if (currentHead !== lastHead) {
-                logger.log(`Git detected HEAD change in ${repository.rootUri.fsPath}: ${lastHead} -> ${currentHead}`);
+                const previousHead = lastHead;
+                logger.log(
+                    `Git detected HEAD change in ${repository.rootUri.fsPath}: ${previousHead} -> ${currentHead}`,
+                );
                 lastHead = currentHead;
 
                 if (this.gitChangeDebounce) {
@@ -75,18 +79,24 @@ export class GitService {
 
                 this.gitChangeDebounce = setTimeout(async () => {
                     logger.log(
-                        `[Git Event] Head moved from ${lastHead} to ${currentHead}. Triggering full workspace refresh.`,
+                        `[Git Event] Head moved from ${previousHead} to ${currentHead}. Triggering full workspace refresh.`,
                     );
                     await this.onRepoChange();
                     logger.log('[Git Event] Workspace refresh finished.');
                 }, 3000);
             }
         });
+
+        this.repoListeners.push(stateDisposable);
     }
 
     public dispose(): void {
         if (this.gitChangeDebounce) {
             clearTimeout(this.gitChangeDebounce);
         }
+        for (const disposable of this.repoListeners) {
+            disposable.dispose();
+        }
+        this.repoListeners.length = 0;
     }
 }

vscode-extension/src/test/benchmark/extension.bench.test.ts

@@ -2,6 +2,7 @@ import * as assert from 'node:assert';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as vscode from 'vscode';
+import { SearchOptions, SearchScope } from '../../../../language-server/src/core/types';
 
 const results: { name: string; avgMs: number; totalMs: number }[] = [];
 
@@ -54,25 +55,40 @@ suite('Extension Performance Test Suite', () => {
     });
 
     test('Command Execution: deeplens.search', async () => {
-        // Wait for extension to be ready
         const extension = vscode.extensions.getExtension('AhmedSamir.deeplens');
         await extension?.activate();
 
-        // Allow some time for language server to start
-        await new Promise((r) => setTimeout(r, 2000));
-
         await benchmark(
             'Execute Search Command',
             async () => {
-                // We just trigger the command, we can't easily measure until results appear without more complex hooks
-                // But checking that the command triggers without error is a start.
-                // In a real scenario, we might want to expose an API to wait for search completion.
                 await vscode.commands.executeCommand('deeplens.search');
-
-                // Close the quick pick if possible (Escape)
                 await vscode.commands.executeCommand('workbench.action.closeQuickOpen');
             },
             5,
         );
     });
+
+    test('Search Request Latency: deeplens/search', async () => {
+        const extension = vscode.extensions.getExtension('AhmedSamir.deeplens');
+        assert.ok(extension, 'Extension should be present');
+        const api = extension.isActive ? extension.exports : await extension.activate();
+
+        // Allow the LSP process to start and complete initialization.
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        const options: SearchOptions = {
+            query: 'test',
+            maxResults: 50,
+            scope: SearchScope.EVERYTHING,
+        };
+
+        await benchmark(
+            'Search Request Latency',
+            async () => {
+                const results = await api.lspClient.search(options);
+                assert.ok(Array.isArray(results), 'Search should return an array');
+            },
+            10,
+        );
+    });
 });