Implement "clear history" command for interactive sessions (microsoft#178194)

Author: roblourens

src/vs/workbench/contrib/interactiveSession/browser/actions/interactiveSessionActions.ts

@@ -19,6 +19,7 @@ import { IInteractiveSessionEditorOptions, InteractiveSessionEditor } from 'vs/w
 import { InteractiveSessionViewPane } from 'vs/workbench/contrib/interactiveSession/browser/interactiveSessionSidebar';
 import { IInteractiveSessionWidgetService } from 'vs/workbench/contrib/interactiveSession/browser/interactiveSessionWidget';
 import { CONTEXT_IN_INTERACTIVE_INPUT, CONTEXT_IN_INTERACTIVE_SESSION } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionContextKeys';
+import { IInteractiveSessionWidgetHistoryService } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionWidgetHistoryService';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 
 export const INTERACTIVE_SESSION_CATEGORY = { value: localize('interactiveSession.category', "Interactive Session"), original: 'Interactive Session' };
@@ -48,28 +49,6 @@ export function registerInteractiveSessionActions() {
 		}
 	});
 
-	// registerAction2(class OpenInteractiveSessionWindow extends Action2 {
-	// 	constructor() {
-	// 		super({
-	// 			id: 'workbench.action.interactiveSession.start',
-	// 			title: localize('interactiveSession', 'Open Interactive Session...'),
-	// 			icon: Codicon.commentDiscussion,
-	// 			precondition: ContextKeyExpr.and(CTX_INTERACTIVE_EDITOR_VISIBLE),
-	// 			f1: false,
-	// 			menu: {
-	// 				id: MENU_INTERACTIVE_EDITOR_WIDGET,
-	// 				group: 'Z',
-	// 				order: 1
-	// 			}
-	// 		});
-	// 	}
-
-	// 	override run(accessor: ServicesAccessor, ...args: any[]): void {
-	// 		const viewsService = accessor.get(IViewsService);
-	// 		viewsService.openView(InteractiveSessionViewPane.ID, true);
-	// 	}
-	// });
-
 	registerAction2(class ClearEditorAction extends Action2 {
 		constructor() {
 			super({
@@ -96,6 +75,24 @@ export function registerInteractiveSessionActions() {
 		}
 	});
 
+	registerAction2(class ClearEditorAction extends Action2 {
+		constructor() {
+			super({
+				id: 'workbench.action.interactiveSessionEditor.clearHistory',
+				title: {
+					value: localize('interactiveSession.clearHistory.label', "Clear Input History"),
+					original: 'Clear Input History'
+				},
+				category: INTERACTIVE_SESSION_CATEGORY,
+				f1: true,
+			});
+		}
+		async run(accessor: ServicesAccessor, ...args: any[]) {
+			const historyService = accessor.get(IInteractiveSessionWidgetHistoryService);
+			historyService.clearHistory();
+		}
+	});
+
 	registerEditorAction(class FocusInteractiveSessionAction extends EditorAction {
 		constructor() {
 			super({

src/vs/workbench/contrib/interactiveSession/browser/interactiveSession.contribution.ts

@@ -26,6 +26,7 @@ import { IInteractiveSessionWidgetService, InteractiveSessionWidgetService } fro
 import { IInteractiveSessionContributionService } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionContributionService';
 import { IInteractiveSessionService } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionService';
 import { InteractiveSessionService } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionServiceImpl';
+import { IInteractiveSessionWidgetHistoryService, InteractiveSessionWidgetHistoryService } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionWidgetHistoryService';
 import { IEditorResolverService, RegisteredEditorPriority } from 'vs/workbench/services/editor/common/editorResolverService';
 import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle';
 import '../common/interactiveSessionColors';
@@ -117,6 +118,8 @@ registerInteractiveSessionExecuteActions();
 registerSingleton(IInteractiveSessionService, InteractiveSessionService, InstantiationType.Delayed);
 registerSingleton(IInteractiveSessionContributionService, InteractiveSessionContributionService, InstantiationType.Delayed);
 registerSingleton(IInteractiveSessionWidgetService, InteractiveSessionWidgetService, InstantiationType.Delayed);
+registerSingleton(IInteractiveSessionWidgetHistoryService, InteractiveSessionWidgetHistoryService, InstantiationType.Delayed);
 
-import 'vs/workbench/contrib/interactiveSession/browser/contrib/interactiveSessionInputEditorContrib';
 import 'vs/workbench/contrib/interactiveSession/browser/contrib/interactiveSessionCodeBlockCopy';
+import 'vs/workbench/contrib/interactiveSession/browser/contrib/interactiveSessionInputEditorContrib';
+

src/vs/workbench/contrib/interactiveSession/browser/interactiveSessionWidget.ts

@@ -41,6 +41,7 @@ import { InteractiveSessionEditorOptions } from 'vs/workbench/contrib/interactiv
 import { CONTEXT_INTERACTIVE_REQUEST_IN_PROGRESS, CONTEXT_IN_INTERACTIVE_INPUT, CONTEXT_IN_INTERACTIVE_SESSION } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionContextKeys';
 import { IInteractiveSessionReplyFollowup, IInteractiveSessionService, IInteractiveSlashCommand } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionService';
 import { IInteractiveSessionViewModel, InteractiveSessionViewModel, isRequestVM, isResponseVM, isWelcomeVM } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionViewModel';
+import { IInteractiveSessionWidgetHistoryService } from 'vs/workbench/contrib/interactiveSession/common/interactiveSessionWidgetHistoryService';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 
 export const IInteractiveSessionWidgetService = createDecorator<IInteractiveSessionWidgetService>('interactiveSessionWidgetService');
@@ -64,11 +65,9 @@ function revealLastElement(list: WorkbenchObjectTree<any>) {
 }
 
 interface IViewState {
-	history: string[];
 	inputValue: string;
 }
 
-const HISTORY_STORAGE_KEY = 'interactiveSession.history';
 const INPUT_EDITOR_MAX_HEIGHT = 250;
 
 export class InteractiveSessionWidget extends Disposable implements IInteractiveSessionWidget, IHistoryNavigationWidget {
@@ -155,14 +154,15 @@ export class InteractiveSessionWidget extends Disposable implements IInteractive
 		private readonly listBackgroundColorDelegate: () => string,
 		private readonly inputEditorBackgroundColorDelegate: () => string,
 		private readonly resultEditorBackgroundColorDelegate: () => string,
-		@IStorageService private readonly storageService: IStorageService,
+		@IStorageService storageService: IStorageService,
 		@IContextKeyService private readonly contextKeyService: IContextKeyService,
 		@IInstantiationService private readonly instantiationService: IInstantiationService,
 		@IModelService private readonly modelService: IModelService,
 		@IExtensionService private readonly extensionService: IExtensionService,
 		@IInteractiveSessionService private readonly interactiveSessionService: IInteractiveSessionService,
 		@IInteractiveSessionWidgetService interactiveSessionWidgetService: IInteractiveSessionWidgetService,
 		@IContextMenuService private readonly contextMenuService: IContextMenuService,
+		@IInteractiveSessionWidgetHistoryService private readonly historyService: IInteractiveSessionWidgetHistoryService,
 	) {
 		super();
 		CONTEXT_IN_INTERACTIVE_SESSION.bindTo(contextKeyService).set(true);
@@ -171,12 +171,12 @@ export class InteractiveSessionWidget extends Disposable implements IInteractive
 		this._register((interactiveSessionWidgetService as InteractiveSessionWidgetService).register(this));
 		this.initializeSessionModel(true);
 
-		const oldPersistedHistory = JSON.parse(this.storageService.get(this.getHistoryStorageKey(), StorageScope.WORKSPACE, '[]'));
+		const history = this.historyService.getHistory(this.providerId);
+		this.history = new HistoryNavigator(history, 50);
+		this._register(this.historyService.onDidClearHistory(() => this.history.clear()));
+
 		this.memento = new Memento('interactive-session-' + this.providerId, storageService);
 		this.viewState = this.memento.getMemento(StorageScope.WORKSPACE, StorageTarget.USER) as IViewState;
-
-		const history = this.viewState.history ?? oldPersistedHistory;
-		this.history = new HistoryNavigator(history, 50);
 	}
 
 	get element(): HTMLElement {
@@ -637,13 +637,10 @@ export class InteractiveSessionWidget extends Disposable implements IInteractive
 		this._inputEditor.layout({ width: width - inputPartPadding - editorBorder - editorPadding - executeToolbarWidth, height: inputEditorHeight });
 	}
 
-	private getHistoryStorageKey(): string {
-		return HISTORY_STORAGE_KEY + this.providerId;
-	}
-
 	saveState(): void {
 		const inputHistory = this.history.getHistory();
-		this.viewState.history = inputHistory;
+		this.historyService.saveHistory(this.providerId, inputHistory);
+
 		this.viewState.inputValue = this._inputEditor.getValue();
 		this.memento.saveMemento();
 	}

src/vs/workbench/contrib/interactiveSession/common/interactiveSessionWidgetHistoryService.ts

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
+import { Memento } from 'vs/workbench/common/memento';
+
+export const IInteractiveSessionWidgetHistoryService = createDecorator<IInteractiveSessionWidgetHistoryService>('IInteractiveSessionWidgetHistoryService');
+export interface IInteractiveSessionWidgetHistoryService {
+	_serviceBrand: undefined;
+
+	readonly onDidClearHistory: Event<void>;
+
+	clearHistory(): void;
+	getHistory(providerId: string): string[];
+	saveHistory(providerId: string, history: string[]): void;
+}
+
+interface IInteractiveSessionHistory {
+	history: { [providerId: string]: string[] };
+}
+
+export class InteractiveSessionWidgetHistoryService implements IInteractiveSessionWidgetHistoryService {
+	_serviceBrand: undefined;
+
+	private memento: Memento;
+	private viewState: IInteractiveSessionHistory;
+
+	private readonly _onDidClearHistory = new Emitter<void>();
+	readonly onDidClearHistory: Event<void> = this._onDidClearHistory.event;
+
+	constructor(
+		@IStorageService storageService: IStorageService
+	) {
+		this.memento = new Memento('interactive-session', storageService);
+		this.viewState = this.memento.getMemento(StorageScope.WORKSPACE, StorageTarget.USER) as IInteractiveSessionHistory;
+	}
+
+	getHistory(providerId: string): string[] {
+		return this.viewState.history?.[providerId] ?? [];
+	}
+
+	saveHistory(providerId: string, history: string[]): void {
+		if (!this.viewState.history) {
+			this.viewState.history = {};
+		}
+		this.viewState.history[providerId] = history;
+		this.memento.saveMemento();
+	}
+
+	clearHistory(): void {
+		this.viewState.history = {};
+		this.memento.saveMemento();
+		this._onDidClearHistory.fire();
+	}
+}