Better getting started experience for Jupyter (microsoft#152380)

* Initial run of Jupyter new experience

* Add ability to skip a walkthrough on install

* Try different wording in quickpick

* Fix walkthrough code

* Update demo

* Adjust wording

* Better comment

* Remove some old code

* Extra spacing

* Allow passing context through extension install

* Await notebook extension activation

* Fix quick input

* Address sandeep comment

* Address comments

Author: lramos15

src/vs/platform/extensionManagement/common/abstractExtensionManagementService.ts

@@ -238,7 +238,7 @@ export abstract class AbstractExtensionManagementService extends Disposable impl
 								} catch (error) { /* ignore */ }
 							}
 						}
-						installResults.push({ local, identifier: task.identifier, operation: task.operation, source: task.source });
+						installResults.push({ local, identifier: task.identifier, operation: task.operation, source: task.source, context: options.context });
 					} catch (error) {
 						if (!URI.isUri(task.source)) {
 							reportTelemetry(this.telemetryService, task.operation === InstallOperation.Update ? 'extensionGallery:update' : 'extensionGallery:install', { extensionData: getGalleryExtensionTelemetryData(task.source), duration: new Date().getTime() - startTime, error });
@@ -277,7 +277,7 @@ export abstract class AbstractExtensionManagementService extends Disposable impl
 				}
 			}
 
-			this._onDidInstallExtensions.fire(allInstallExtensionTasks.map(({ task }) => ({ identifier: task.identifier, operation: InstallOperation.Install, source: task.source })));
+			this._onDidInstallExtensions.fire(allInstallExtensionTasks.map(({ task }) => ({ identifier: task.identifier, operation: InstallOperation.Install, source: task.source, context: options.context })));
 			throw error;
 		} finally {
 			/* Remove the gallery tasks from the cache */

src/vs/platform/extensionManagement/common/extensionManagement.ts

@@ -352,6 +352,7 @@ export interface InstallExtensionResult {
 	readonly operation: InstallOperation;
 	readonly source?: URI | IGalleryExtension;
 	readonly local?: ILocalExtension;
+	readonly context?: IStringDictionary<any>;
 }
 
 export interface DidUninstallExtensionEvent {
@@ -384,7 +385,18 @@ export class ExtensionManagementError extends Error {
 	}
 }
 
-export type InstallOptions = { isBuiltin?: boolean; isMachineScoped?: boolean; donotIncludePackAndDependencies?: boolean; installGivenVersion?: boolean; installPreReleaseVersion?: boolean; operation?: InstallOperation };
+export type InstallOptions = {
+	isBuiltin?: boolean;
+	isMachineScoped?: boolean;
+	donotIncludePackAndDependencies?: boolean;
+	installGivenVersion?: boolean;
+	installPreReleaseVersion?: boolean;
+	operation?: InstallOperation;
+	/**
+	 * Context passed through to InstallExtensionResult
+	 */
+	context?: IStringDictionary<any>;
+};
 export type InstallVSIXOptions = Omit<InstallOptions, 'installGivenVersion'> & { installOnlyNewlyAddedFromExtensionPack?: boolean };
 export type UninstallOptions = { donotIncludePack?: boolean; donotCheckDependents?: boolean };
 

src/vs/workbench/contrib/extensions/browser/extensionsWorkbenchService.ts

@@ -1201,7 +1201,7 @@ export class ExtensionsWorkbenchService extends Disposable implements IExtension
 		return false;
 	}
 
-	install(extension: URI | IExtension, installOptions?: InstallOptions | InstallVSIXOptions): Promise<IExtension> {
+	install(extension: URI | IExtension, installOptions?: InstallOptions | InstallVSIXOptions, progressLocation?: ProgressLocation): Promise<IExtension> {
 		if (extension instanceof URI) {
 			return this.installWithProgress(() => this.installFromVSIX(extension, installOptions));
 		}
@@ -1216,7 +1216,7 @@ export class ExtensionsWorkbenchService extends Disposable implements IExtension
 			return Promise.reject(new Error('Missing gallery'));
 		}
 
-		return this.installWithProgress(() => this.installFromGallery(extension, gallery, installOptions), gallery.displayName);
+		return this.installWithProgress(() => this.installFromGallery(extension, gallery, installOptions), gallery.displayName, progressLocation);
 	}
 
 	setEnablement(extensions: IExtension | IExtension[], enablementState: EnablementState): Promise<void> {
@@ -1314,10 +1314,10 @@ export class ExtensionsWorkbenchService extends Disposable implements IExtension
 		return extension;
 	}
 
-	private installWithProgress<T>(installTask: () => Promise<T>, extensionName?: string): Promise<T> {
+	private installWithProgress<T>(installTask: () => Promise<T>, extensionName?: string, progressLocation?: ProgressLocation): Promise<T> {
 		const title = extensionName ? nls.localize('installing named extension', "Installing '{0}' extension....", extensionName) : nls.localize('installing extension', 'Installing extension....');
 		return this.progressService.withProgress({
-			location: ProgressLocation.Extensions,
+			location: progressLocation ?? ProgressLocation.Extensions,
 			title
 		}, () => installTask());
 	}

src/vs/workbench/contrib/extensions/common/extensions.ts

@@ -17,6 +17,7 @@ import { IView, IViewPaneContainer } from 'vs/workbench/common/views';
 import { RawContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { IExtensionsStatus } from 'vs/workbench/services/extensions/common/extensions';
 import { IExtensionEditorOptions } from 'vs/workbench/contrib/extensions/common/extensionsInput';
+import { ProgressLocation } from 'vs/platform/progress/common/progress';
 
 export const VIEWLET_ID = 'workbench.view.extensions';
 
@@ -101,7 +102,7 @@ export interface IExtensionsWorkbenchService {
 	getExtensions(extensionInfos: IExtensionInfo[], options: IExtensionQueryOptions, token: CancellationToken): Promise<IExtension[]>;
 	canInstall(extension: IExtension): Promise<boolean>;
 	install(vsix: URI, installOptions?: InstallVSIXOptions): Promise<IExtension>;
-	install(extension: IExtension, installOptions?: InstallOptions): Promise<IExtension>;
+	install(extension: IExtension, installOptions?: InstallOptions, progressLocation?: ProgressLocation): Promise<IExtension>;
 	uninstall(extension: IExtension): Promise<void>;
 	installVersion(extension: IExtension, version: string, installOptions?: InstallOptions): Promise<IExtension>;
 	reinstall(extension: IExtension): Promise<IExtension>;

src/vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar.ts

@@ -19,11 +19,11 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { ThemeIcon } from 'vs/platform/theme/common/themeService';
 import { Extensions as WorkbenchExtensions, IWorkbenchContribution, IWorkbenchContributionsRegistry } from 'vs/workbench/common/contributions';
 import { ViewContainerLocation } from 'vs/workbench/common/views';
-import { IExtensionsViewPaneContainer, VIEWLET_ID as EXTENSION_VIEWLET_ID } from 'vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionsViewPaneContainer, IExtensionsWorkbenchService, VIEWLET_ID as EXTENSION_VIEWLET_ID } from 'vs/workbench/contrib/extensions/common/extensions';
 import { CENTER_ACTIVE_CELL } from 'vs/workbench/contrib/notebook/browser/contrib/navigation/arrow';
 import { NOTEBOOK_ACTIONS_CATEGORY, SELECT_KERNEL_ID } from 'vs/workbench/contrib/notebook/browser/controller/coreActions';
 import { NOTEBOOK_MISSING_KERNEL_EXTENSION, NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_KERNEL_COUNT, NOTEBOOK_KERNEL_SOURCE_COUNT } from 'vs/workbench/contrib/notebook/common/notebookContextKeys';
-import { getNotebookEditorFromEditorPane, INotebookEditor, KERNEL_EXTENSIONS } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { getNotebookEditorFromEditorPane, INotebookEditor, INotebookExtensionRecommendation, KERNEL_RECOMMENDATIONS } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { NotebookEditorWidget } from 'vs/workbench/contrib/notebook/browser/notebookEditorWidget';
 import { configureKernelIcon, selectKernelIcon } from 'vs/workbench/contrib/notebook/browser/notebookIcons';
 import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel';
@@ -34,6 +34,11 @@ import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle
 import { IPaneCompositePartService } from 'vs/workbench/services/panecomposite/browser/panecomposite';
 import { IStatusbarEntry, IStatusbarEntryAccessor, IStatusbarService, StatusbarAlignment } from 'vs/workbench/services/statusbar/browser/statusbar';
 import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { ProgressLocation } from 'vs/platform/progress/common/progress';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { Codicon } from 'vs/base/common/codicons';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 
 registerAction2(class extends Action2 {
 	constructor() {
@@ -103,10 +108,13 @@ registerAction2(class extends Action2 {
 	): Promise<boolean> {
 		const notebookKernelService = accessor.get(INotebookKernelService);
 		const editorService = accessor.get(IEditorService);
+		const productService = accessor.get(IProductService);
 		const quickInputService = accessor.get(IQuickInputService);
 		const labelService = accessor.get(ILabelService);
 		const logService = accessor.get(ILogService);
 		const paneCompositeService = accessor.get(IPaneCompositePartService);
+		const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+		const extensionHostService = accessor.get(IExtensionService);
 
 		let editor: INotebookEditor | undefined;
 		if (context !== undefined && 'notebookEditorId' in context) {
@@ -229,11 +237,25 @@ registerAction2(class extends Action2 {
 			});
 		}
 
+		let suggestedExtension: INotebookExtensionRecommendation | undefined;
 		if (!all.length && !sourceActions.length) {
+			const activeNotebookModel = getNotebookEditorFromEditorPane(editorService.activeEditorPane)?.textModel;
+			if (activeNotebookModel) {
+				const language = this.getSuggestedLanguage(activeNotebookModel);
+				suggestedExtension = language ? this.getSuggestedKernelFromLanguage(activeNotebookModel.viewType, language) : undefined;
+			}
+			if (suggestedExtension) {
+				// We have a suggested kernel, show an option to install it
+				quickPickItems.push({
+					id: 'installSuggested',
+					description: suggestedExtension.displayName ?? suggestedExtension.extensionId,
+					label: nls.localize('installSuggestedKernel', '$({0}) Install suggested extensions', Codicon.lightbulb.id),
+				});
+			}
 			// there is no kernel, show the install from marketplace
 			quickPickItems.push({
 				id: 'install',
-				label: nls.localize('installKernels', "Install kernels from the marketplace"),
+				label: nls.localize('searchForKernels', "Browse marketplace for kernel extensions"),
 			});
 		}
 
@@ -258,7 +280,22 @@ registerAction2(class extends Action2 {
 			// actions
 
 			if (pick.id === 'install') {
-				await this._showKernelExtension(paneCompositeService, notebook.viewType);
+				await this._showKernelExtension(
+					paneCompositeService,
+					extensionWorkbenchService,
+					extensionHostService,
+					notebook.viewType
+				);
+				// suggestedExtension must be defined for this option to be shown, but still check to make TS happy
+			} else if (pick.id === 'installSuggested' && suggestedExtension) {
+				await this._showKernelExtension(
+					paneCompositeService,
+					extensionWorkbenchService,
+					extensionHostService,
+					notebook.viewType,
+					suggestedExtension.extensionId,
+					productService.quality !== 'stable'
+				);
 			} else if ('action' in pick) {
 				// selected explicilty, it should trigger the execution?
 				pick.action.runAction();
@@ -268,17 +305,69 @@ registerAction2(class extends Action2 {
 		return false;
 	}
 
-	private async _showKernelExtension(paneCompositePartService: IPaneCompositePartService, viewType: string) {
-		const viewlet = await paneCompositePartService.openPaneComposite(EXTENSION_VIEWLET_ID, ViewContainerLocation.Sidebar, true);
-		const view = viewlet?.getViewPaneContainer() as IExtensionsViewPaneContainer | undefined;
+	/**
+	 * Examine the most common language in the notebook
+	 * @param notebookTextModel The notebook text model
+	 * @returns What the suggested language is for the notebook. Used for kernal installing
+	 */
+	private getSuggestedLanguage(notebookTextModel: NotebookTextModel): string | undefined {
+		const metaData = notebookTextModel.metadata;
+		let suggestedKernelLanguage: string | undefined = (metaData.custom as any)?.metadata?.language_info?.name;
+		// TODO how do we suggest multi language notebooks?
+		if (!suggestedKernelLanguage) {
+			const cellLanguages = notebookTextModel.cells.map(cell => cell.language).filter(language => language !== 'markdown');
+			// Check if cell languages is all the same
+			if (cellLanguages.length > 1) {
+				const firstLanguage = cellLanguages[0];
+				if (cellLanguages.every(language => language === firstLanguage)) {
+					suggestedKernelLanguage = firstLanguage;
+				}
+			}
+		}
+		return suggestedKernelLanguage;
+	}
 
-		const extId = KERNEL_EXTENSIONS.get(viewType);
+	/**
+	 * Given a language and notebook view type suggest a kernel for installation
+	 * @param language The language to find a suggested kernel extension for
+	 * @returns A recommednation object for the recommended extension, else undefined
+	 */
+	private getSuggestedKernelFromLanguage(viewType: string, language: string): INotebookExtensionRecommendation | undefined {
+		const recommendation = KERNEL_RECOMMENDATIONS.get(viewType)?.get(language);
+		return recommendation;
+	}
+
+	private async _showKernelExtension(
+		paneCompositePartService: IPaneCompositePartService,
+		extensionWorkbenchService: IExtensionsWorkbenchService,
+		extensionService: IExtensionService,
+		viewType: string,
+		extId?: string,
+		isInsiders?: boolean
+	) {
+		// If extension id is provided attempt to install the extension as the user has requested the suggested ones be installed
 		if (extId) {
-			view?.search(`@id:${extId}`);
-		} else {
-			const pascalCased = viewType.split(/[^a-z0-9]/ig).map(uppercaseFirstLetter).join('');
-			view?.search(`@tag:notebookKernel${pascalCased}`);
+			const extension = (await extensionWorkbenchService.getExtensions([{ id: extId }], CancellationToken.None))[0];
+			const canInstall = await extensionWorkbenchService.canInstall(extension);
+			// If we can install then install it, otherwise we will fall out into searching the viewlet
+			if (canInstall) {
+				await extensionWorkbenchService.install(
+					extension,
+					{
+						installPreReleaseVersion: isInsiders ?? false,
+						context: { skipWalkthrough: true }
+					},
+					ProgressLocation.Notification
+				);
+				await extensionService.activateByEvent(`onNotebook:${viewType}`);
+				return;
+			}
 		}
+
+		const viewlet = await paneCompositePartService.openPaneComposite(EXTENSION_VIEWLET_ID, ViewContainerLocation.Sidebar, true);
+		const view = viewlet?.getViewPaneContainer() as IExtensionsViewPaneContainer | undefined;
+		const pascalCased = viewType.split(/[^a-z0-9]/ig).map(uppercaseFirstLetter).join('');
+		view?.search(`@tag:notebookKernel${pascalCased}`);
 	}
 });
 

src/vs/workbench/contrib/notebook/browser/notebookBrowser.ts

@@ -49,6 +49,18 @@ export const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
 export const KERNEL_EXTENSIONS = new Map<string, string>([
 	[IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID],
 ]);
+// @TODO lramos15, place this in a similar spot to our normal recommendations.
+export const KERNEL_RECOMMENDATIONS = new Map<string, Map<string, INotebookExtensionRecommendation>>();
+KERNEL_RECOMMENDATIONS.set(IPYNB_VIEW_TYPE, new Map<string, INotebookExtensionRecommendation>());
+KERNEL_RECOMMENDATIONS.get(IPYNB_VIEW_TYPE)?.set('python', {
+	extensionId: 'ms-python.python',
+	displayName: 'Python + Jupyter',
+});
+
+export interface INotebookExtensionRecommendation {
+	extensionId: string;
+	displayName?: string;
+}
 
 //#endregion
 

src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStarted.contribution.ts

@@ -30,6 +30,7 @@ import { isLinux, isMacintosh, isWindows, OperatingSystem as OS } from 'vs/base/
 import { IExtensionManagementServerService } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { StartupPageContribution, } from 'vs/workbench/contrib/welcomeGettingStarted/browser/startupPage';
+import { ExtensionsInput } from 'vs/workbench/contrib/extensions/common/extensionsInput';
 
 
 export * as icons from 'vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedIcons';
@@ -49,7 +50,11 @@ registerAction2(class extends Action2 {
 		});
 	}
 
-	public run(accessor: ServicesAccessor, walkthroughID: string | { category: string; step: string } | undefined, toSide: boolean | undefined) {
+	public run(
+		accessor: ServicesAccessor,
+		walkthroughID: string | { category: string; step: string } | undefined,
+		toSide: boolean | undefined
+	) {
 		const editorGroupsService = accessor.get(IEditorGroupsService);
 		const instantiationService = accessor.get(IInstantiationService);
 		const editorService = accessor.get(IEditorService);
@@ -80,8 +85,19 @@ registerAction2(class extends Action2 {
 				}
 			}
 
-			// Otherwise, just make a new one.
-			editorService.openEditor(instantiationService.createInstance(GettingStartedInput, { selectedCategory: selectedCategory, selectedStep: selectedStep }), {}, toSide ? SIDE_GROUP : undefined);
+			const activeEditor = editorService.activeEditor;
+			const gettingStartedInput = instantiationService.createInstance(GettingStartedInput, { selectedCategory: selectedCategory, selectedStep: selectedStep });
+			// If it's the extension install page then lets replace it with the getting started page
+			if (activeEditor instanceof ExtensionsInput) {
+				const activeGroup = editorGroupsService.activeGroup;
+				activeGroup.replaceEditors([{
+					editor: activeEditor,
+					replacement: gettingStartedInput
+				}]);
+			} else {
+				// else open respecting toSide
+				editorService.openEditor(gettingStartedInput, { preserveFocus: toSide ?? false }, toSide ? SIDE_GROUP : undefined);
+			}
 		} else {
 			editorService.openEditor(new GettingStartedInput({}), {});
 		}

src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.ts

@@ -136,7 +136,7 @@ export class WalkthroughsService extends Disposable implements IWalkthroughsServ
 	private steps = new Map<string, IWalkthroughStep>();
 
 	private tasExperimentService?: IWorkbenchAssignmentService;
-	private sessionInstalledExtensions = new Set<string>();
+	private sessionInstalledExtensions: Set<string> = new Set<string>();
 
 	private categoryVisibilityContextKeys = new Set<string>();
 	private stepCompletionContextKeyExpressions = new Set<ContextKeyExpression>();
@@ -235,7 +235,9 @@ export class WalkthroughsService extends Disposable implements IWalkthroughsServ
 		this._register(this.extensionManagementService.onDidInstallExtensions(async (result) => {
 			const hadLastFoucs = await this.hostService.hadLastFocus();
 			for (const e of result) {
-				if (hadLastFoucs) {
+				// If the window had last focus and the install didn't specify to skip the walkthrough
+				// Then add it to the sessionInstallExtensions to be opened
+				if (hadLastFoucs && !e?.context?.skipWalkthrough) {
 					this.sessionInstalledExtensions.add(e.identifier.id.toLowerCase());
 				}
 				this.progressByEvent(`extensionInstalled:${e.identifier.id.toLowerCase()}`);
@@ -425,20 +427,19 @@ export class WalkthroughsService extends Disposable implements IWalkthroughsServ
 
 		this.storageService.store(walkthroughMetadataConfigurationKey, JSON.stringify([...this.metadata.entries()]), StorageScope.PROFILE, StorageTarget.USER);
 
-
 		if (sectionToOpen && this.configurationService.getValue<string>('workbench.welcomePage.walkthroughs.openOnInstall')) {
 			type GettingStartedAutoOpenClassification = {
 				id: {
 					classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight';
-					owner: 'JacksonKearl';
+					owner: 'lramos15';
 					comment: 'Used to understand what walkthroughs are consulted most frequently';
 				};
 			};
 			type GettingStartedAutoOpenEvent = {
 				id: string;
 			};
 			this.telemetryService.publicLog2<GettingStartedAutoOpenEvent, GettingStartedAutoOpenClassification>('gettingStarted.didAutoOpenWalkthrough', { id: sectionToOpen });
-			this.commandService.executeCommand('workbench.action.openWalkthrough', sectionToOpen);
+			this.commandService.executeCommand('workbench.action.openWalkthrough', sectionToOpen, true);
 		}
 	}