@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionWordCounter.js

@@ -0,0 +1,25 @@
+const wordSeparatorCharPattern = /[\s\|\-]/;
+function getNWords(str, numWordsToCount) {
+    let wordCount = numWordsToCount;
+    let i = 0;
+    while (i < str.length && wordCount > 0) {
+        while (i < str.length && str[i].match(wordSeparatorCharPattern)) {
+            i++;
+        }
+        while (i < str.length && !str[i].match(wordSeparatorCharPattern)) {
+            i++;
+        }
+        wordCount--;
+    }
+    const value = str.substring(0, i);
+    return {
+        value,
+        actualWordCount: numWordsToCount - wordCount,
+        isFullString: i >= str.length
+    };
+}
+function countWords(str) {
+    const result = getNWords(str, Number.MAX_SAFE_INTEGER);
+    return result.actualWordCount;
+}
+export { countWords, getNWords };

package/dist/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser.js

@@ -0,0 +1,27 @@
+import { NOTEBOOK_EDITOR_ID } from '../common/notebookCommon.js';
+import { isCompositeNotebookEditorInput } from '../common/notebookEditorInput.js';
+const IPYNB_VIEW_TYPE = 'jupyter-notebook';
+const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
+const KERNEL_RECOMMENDATIONS = ( new Map());
+KERNEL_RECOMMENDATIONS.set(IPYNB_VIEW_TYPE, ( new Map()));
+KERNEL_RECOMMENDATIONS.get(IPYNB_VIEW_TYPE)?.set('python', {
+    extensionIds: [
+        'ms-python.python',
+        JUPYTER_EXTENSION_ID
+    ],
+    displayName: 'Python + Jupyter',
+});
+function getNotebookEditorFromEditorPane(editorPane) {
+    if (!editorPane) {
+        return;
+    }
+    if (editorPane.getId() === NOTEBOOK_EDITOR_ID) {
+        return editorPane.getControl();
+    }
+    const input = editorPane.input;
+    if (input && isCompositeNotebookEditorInput(input)) {
+        return editorPane.getControl().notebookEditor;
+    }
+    return undefined;
+}
+export { IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID, KERNEL_RECOMMENDATIONS, getNotebookEditorFromEditorPane };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookCommon.js

@@ -1,9 +1,87 @@
+import { encodeBase64, VSBuffer, decodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+const NOTEBOOK_EDITOR_ID = 'workbench.editor.notebook';
 var CellKind;
 ( (function(CellKind) {
     CellKind[CellKind["Markup"] = 1] = "Markup";
     CellKind[CellKind["Code"] = 2] = "Code";
 })(CellKind || (CellKind = {})));
+var SelectionStateType;
+( (function(SelectionStateType) {
+    SelectionStateType[SelectionStateType["Handle"] = 0] = "Handle";
+    SelectionStateType[SelectionStateType["Index"] = 1] = "Index";
+})(SelectionStateType || (SelectionStateType = {})));
+var CellUri;
+( (function(CellUri) {
+    CellUri.scheme = Schemas.vscodeNotebookCell;
+    const _lengths = ['W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f'];
+    const _padRegexp = ( new RegExp(`^[${_lengths.join('')}]+`));
+    const _radix = 7;
+    function generate(notebook, handle) {
+        const s = ( handle.toString(_radix));
+        const p = s.length < _lengths.length ? _lengths[s.length - 1] : 'z';
+        const fragment = `${p}${s}s${encodeBase64(VSBuffer.fromString(notebook.scheme), true, true)}`;
+        return notebook.with({ scheme: CellUri.scheme, fragment });
+    }
+    CellUri.generate = generate;
+    function parse(cell) {
+        if (cell.scheme !== CellUri.scheme) {
+            return undefined;
+        }
+        const idx = cell.fragment.indexOf('s');
+        if (idx < 0) {
+            return undefined;
+        }
+        const handle = parseInt(cell.fragment.substring(0, idx).replace(_padRegexp, ''), _radix);
+        const _scheme = ( decodeBase64(cell.fragment.substring(idx + 1)).toString());
+        if (isNaN(handle)) {
+            return undefined;
+        }
+        return {
+            handle,
+            notebook: cell.with({ scheme: _scheme, fragment: null })
+        };
+    }
+    CellUri.parse = parse;
+    function generateCellOutputUri(notebook, outputId) {
+        return notebook.with({
+            scheme: Schemas.vscodeNotebookCellOutput,
+            fragment: `op${outputId ?? ''},${notebook.scheme !== Schemas.file ? notebook.scheme : ''}`
+        });
+    }
+    CellUri.generateCellOutputUri = generateCellOutputUri;
+    function parseCellOutputUri(uri) {
+        if (uri.scheme !== Schemas.vscodeNotebookCellOutput) {
+            return;
+        }
+        const match = /^op([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})?\,(.*)$/i.exec(uri.fragment);
+        if (!match) {
+            return undefined;
+        }
+        const outputId = (match[1] && match[1] !== '') ? match[1] : undefined;
+        const scheme = match[2];
+        return {
+            outputId,
+            notebook: uri.with({
+                scheme: scheme || Schemas.file,
+                fragment: null
+            })
+        };
+    }
+    CellUri.parseCellOutputUri = parseCellOutputUri;
+    function generateCellPropertyUri(notebook, handle, scheme) {
+        return CellUri.generate(notebook, handle).with({ scheme: scheme });
+    }
+    CellUri.generateCellPropertyUri = generateCellPropertyUri;
+    function parseCellPropertyUri(uri, propertyScheme) {
+        if (uri.scheme !== propertyScheme) {
+            return undefined;
+        }
+        return CellUri.parse(uri.with({ scheme: CellUri.scheme }));
+    }
+    CellUri.parseCellPropertyUri = parseCellPropertyUri;
+})(CellUri || (CellUri = {})));
 function isTextStreamMime(mimeType) {
     return ['application/vnd.code.notebook.stdout', 'application/vnd.code.notebook.stderr'].includes(mimeType);
 }
-export { CellKind, isTextStreamMime };
+export { CellKind, CellUri, NOTEBOOK_EDITOR_ID, SelectionStateType, isTextStreamMime };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput.js

@@ -0,0 +1,249 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import { SimpleNotebookProviderInfo, INotebookService } from './notebookService.js';
+import { joinPath, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { INotebookEditorModelResolverService } from './notebookEditorModelResolverService.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { AbstractResourceEditorInput } from '../../../common/editor/resourceEditorInput.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+let NotebookEditorInput = class NotebookEditorInput extends AbstractResourceEditorInput {
+    static create(instantiationService, resource, viewType, options = {}) {
+        return instantiationService.createInstance(NotebookEditorInput, resource, viewType, options);
+    }
+    constructor(resource, viewType, options, _notebookService, _notebookModelResolverService, _fileDialogService, _instantiationService, labelService, fileService) {
+        super(resource, undefined, labelService, fileService);
+        this.viewType = viewType;
+        this.options = options;
+        this._notebookService = _notebookService;
+        this._notebookModelResolverService = _notebookModelResolverService;
+        this._fileDialogService = _fileDialogService;
+        this._instantiationService = _instantiationService;
+        this._editorModelReference = null;
+        this._defaultDirtyState = false;
+        this._defaultDirtyState = !!options.startDirty;
+        this._sideLoadedListener = _notebookService.onDidAddNotebookDocument(e => {
+            if (e.viewType === this.viewType && ( e.uri.toString()) === ( this.resource.toString())) {
+                this.resolve().catch(onUnexpectedError);
+            }
+        });
+    }
+    dispose() {
+        this._sideLoadedListener.dispose();
+        this._editorModelReference?.dispose();
+        this._editorModelReference = null;
+        super.dispose();
+    }
+    get typeId() {
+        return NotebookEditorInput.ID;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = 0 ;
+        if (this.resource.scheme === Schemas.untitled) {
+            capabilities |= 4 ;
+        }
+        if (this._editorModelReference) {
+            if (this._editorModelReference.object.isReadonly()) {
+                capabilities |= 2 ;
+            }
+        }
+        else {
+            if (this.fileService.hasCapability(this.resource, 2048 )) {
+                capabilities |= 2 ;
+            }
+        }
+        if (!((capabilities & 2) )) {
+            capabilities |= 128 ;
+        }
+        return capabilities;
+    }
+    getDescription(verbosity = 1 ) {
+        if (!this.hasCapability(4 ) || this._editorModelReference?.object.hasAssociatedFilePath()) {
+            return super.getDescription(verbosity);
+        }
+        return undefined;
+    }
+    isDirty() {
+        if (!this._editorModelReference) {
+            return this._defaultDirtyState;
+        }
+        return this._editorModelReference.object.isDirty();
+    }
+    async save(group, options) {
+        if (this._editorModelReference) {
+            if (this.hasCapability(4 )) {
+                return this.saveAs(group, options);
+            }
+            else {
+                await this._editorModelReference.object.save(options);
+            }
+            return this;
+        }
+        return undefined;
+    }
+    async saveAs(group, options) {
+        if (!this._editorModelReference) {
+            return undefined;
+        }
+        const provider = this._notebookService.getContributedNotebookType(this.viewType);
+        if (!provider) {
+            return undefined;
+        }
+        const pathCandidate = this.hasCapability(4 ) ? await this._suggestName(provider, this.labelService.getUriBasenameLabel(this.resource)) : this._editorModelReference.object.resource;
+        let target;
+        if (this._editorModelReference.object.hasAssociatedFilePath()) {
+            target = pathCandidate;
+        }
+        else {
+            target = await this._fileDialogService.pickFileToSave(pathCandidate, options?.availableFileSystems);
+            if (!target) {
+                return undefined;
+            }
+        }
+        if (!provider.matches(target)) {
+            const patterns = ( provider.selectors.map(pattern => {
+                if (typeof pattern === 'string') {
+                    return pattern;
+                }
+                if (glob.isRelativePattern(pattern)) {
+                    return `${pattern} (base ${pattern.base})`;
+                }
+                if (pattern.exclude) {
+                    return `${pattern.include} (exclude: ${pattern.exclude})`;
+                }
+                else {
+                    return `${pattern.include}`;
+                }
+            })).join(', ');
+            throw new Error(`File name ${target} is not supported by ${provider.providerDisplayName}.\n\nPlease make sure the file name matches following patterns:\n${patterns}`);
+        }
+        return await this._editorModelReference.object.saveAs(target);
+    }
+    async _suggestName(provider, suggestedFilename) {
+        const firstSelector = provider.selectors[0];
+        let selectorStr = firstSelector && typeof firstSelector === 'string' ? firstSelector : undefined;
+        if (!selectorStr && firstSelector) {
+            const include = firstSelector.include;
+            if (typeof include === 'string') {
+                selectorStr = include;
+            }
+        }
+        if (selectorStr) {
+            const matches = /^\*\.([A-Za-z_-]*)$/.exec(selectorStr);
+            if (matches && matches.length > 1) {
+                const fileExt = matches[1];
+                if (!suggestedFilename.endsWith(fileExt)) {
+                    return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename + '.' + fileExt);
+                }
+            }
+        }
+        return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename);
+    }
+    async rename(group, target) {
+        if (this._editorModelReference) {
+            const contributedNotebookProviders = this._notebookService.getContributedNotebookTypes(target);
+            if (contributedNotebookProviders.find(provider => provider.id === this._editorModelReference.object.viewType)) {
+                return this._move(group, target);
+            }
+        }
+        return undefined;
+    }
+    _move(_group, newResource) {
+        const editorInput = NotebookEditorInput.create(this._instantiationService, newResource, this.viewType);
+        return { editor: editorInput };
+    }
+    async revert(_group, options) {
+        if (this._editorModelReference && this._editorModelReference.object.isDirty()) {
+            await this._editorModelReference.object.revert(options);
+        }
+    }
+    async resolve(_options, perf) {
+        if (!(await this._notebookService.canResolve(this.viewType))) {
+            return null;
+        }
+        perf?.mark('extensionActivated');
+        this._sideLoadedListener.dispose();
+        if (!this._editorModelReference) {
+            const ref = await this._notebookModelResolverService.resolve(this.resource, this.viewType);
+            if (this._editorModelReference) {
+                ref.dispose();
+                return this._editorModelReference.object;
+            }
+            this._editorModelReference = ref;
+            if (this.isDisposed()) {
+                this._editorModelReference.dispose();
+                this._editorModelReference = null;
+                return null;
+            }
+            this._register(this._editorModelReference.object.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+            this._register(this._editorModelReference.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
+            if (this._editorModelReference.object.isDirty()) {
+                this._onDidChangeDirty.fire();
+            }
+        }
+        else {
+            this._editorModelReference.object.load();
+        }
+        if (this.options._backupId) {
+            const info = await this._notebookService.withNotebookDataProvider(this._editorModelReference.object.notebook.viewType);
+            if (!(info instanceof SimpleNotebookProviderInfo)) {
+                throw new Error('CANNOT open file notebook with this provider');
+            }
+            const data = await info.serializer.dataToNotebook(VSBuffer.fromString(JSON.stringify({ __webview_backup: this.options._backupId })));
+            this._editorModelReference.object.notebook.applyEdits([
+                {
+                    editType: 1 ,
+                    index: 0,
+                    count: this._editorModelReference.object.notebook.length,
+                    cells: data.cells
+                }
+            ], true, undefined, () => undefined, undefined, false);
+            if (this.options._workingCopy) {
+                this.options._backupId = undefined;
+                this.options._workingCopy = undefined;
+                this.options.startDirty = undefined;
+            }
+        }
+        return this._editorModelReference.object;
+    }
+    toUntyped() {
+        return {
+            resource: this.preferredResource,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof NotebookEditorInput) {
+            return this.viewType === otherInput.viewType && isEqual(this.resource, otherInput.resource);
+        }
+        return false;
+    }
+};
+NotebookEditorInput.ID = 'workbench.input.notebook';
+NotebookEditorInput = ( __decorate([
+    ( __param(3, INotebookService)),
+    ( __param(4, INotebookEditorModelResolverService)),
+    ( __param(5, IFileDialogService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IFileService))
+], NotebookEditorInput));
+function isCompositeNotebookEditorInput(thing) {
+    return !!thing
+        && typeof thing === 'object'
+        && Array.isArray(thing.editorInputs)
+        && (thing.editorInputs.every(input => input instanceof NotebookEditorInput));
+}
+export { NotebookEditorInput, isCompositeNotebookEditorInput };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const INotebookEditorModelResolverService = ( createDecorator('INotebookModelResolverService'));
+export { INotebookEditorModelResolverService };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookService.js

@@ -0,0 +1,10 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const INotebookService = ( createDecorator('notebookService'));
+class SimpleNotebookProviderInfo {
+    constructor(viewType, serializer, extensionData) {
+        this.viewType = viewType;
+        this.serializer = serializer;
+        this.extensionData = extensionData;
+    }
+}
+export { INotebookService, SimpleNotebookProviderInfo };

package/dist/vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js

@@ -3,7 +3,7 @@ import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { MenuId, MenuItemAction, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { raceTimeout, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
 import { AbstractEditorCommandsQuickAccessProvider } from 'monaco-editor/esm/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js';
 import { Language } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -22,6 +22,10 @@ import { IPreferencesService } from '../../../services/preferences/common/prefer
 import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
 import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
 import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { ISemanticSimilarityService } from '../../../services/semanticSimilarity/common/semanticSimilarityService.js';
+import { IInteractiveSessionService } from '../../interactiveSession/common/interactiveSessionService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IInteractiveSessionWidgetService } from '../../interactiveSession/browser/interactiveSessionWidget.js';
 let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider {
     get activeTextEditorControl() { return this.editorService.activeTextEditorControl; }
     get defaultFilterValue() {
@@ -30,13 +34,22 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
         }
         return undefined;
     }
-    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService, productService) {
+    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService, productService, semanticSimilarityService, interactiveSessionService) {
         super({
             showAlias: !Language.isDefaultVariant(),
-            noResultsPick: {
-                label: ( localize('noCommandResults', "No matching commands")),
-                commandId: ''
-            }
+            noResultsPick: (filter) => {
+                const info = this.interactiveSessionService.getProviderInfos()[0];
+                return info
+                    ? {
+                        label: ( localize('askXInInteractiveSession', "Ask {0}: {1}", info.displayName, filter)),
+                        commandId: AskInInteractiveAction.ID,
+                        accept: () => commandService.executeCommand(AskInInteractiveAction.ID, filter)
+                    }
+                    : {
+                        label: ( localize('noCommandResults', "No matching commands")),
+                        commandId: ''
+                    };
+            },
         }, instantiationService, keybindingService, commandService, telemetryService, dialogService);
         this.editorService = editorService;
         this.menuService = menuService;
@@ -45,12 +58,12 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
         this.editorGroupService = editorGroupService;
         this.preferencesService = preferencesService;
         this.productService = productService;
-        this.extensionRegistrationRace = Promise.race([
-            timeout(800),
-            this.extensionService.whenInstalledExtensionsRegistered()
-        ]);
-        this._register(configurationService.onDidChangeConfiguration((e) => this.updateSuggestedCommandIds(e)));
-        this.updateSuggestedCommandIds();
+        this.semanticSimilarityService = semanticSimilarityService;
+        this.interactiveSessionService = interactiveSessionService;
+        this.extensionRegistrationRace = raceTimeout(this.extensionService.whenInstalledExtensionsRegistered(), 800);
+        this.useSemanticSimilarity = false;
+        this._register(configurationService.onDidChangeConfiguration((e) => this.updateOptions(e)));
+        this.updateOptions();
     }
     get configuration() {
         const commandPaletteConfig = this.configurationService.getValue().workbench.commandPalette;
@@ -59,8 +72,8 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
             experimental: commandPaletteConfig.experimental
         };
     }
-    updateSuggestedCommandIds(e) {
-        if (e && !e.affectsConfiguration('workbench.commandPalette.experimental.suggestCommands')) {
+    updateOptions(e) {
+        if (e && !e.affectsConfiguration('workbench.commandPalette.experimental')) {
             return;
         }
         const config = this.configuration;
@@ -68,6 +81,7 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
             ? ( new Set(this.productService.commandPaletteSuggestedCommandIds))
             : undefined;
         this.options.suggestedCommandIds = suggestedCommandIds;
+        this.useSemanticSimilarity = config.experimental.useSemanticSimilarity;
     }
     async getCommandPicks(token) {
         await this.extensionRegistrationRace;
@@ -77,18 +91,62 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
         return ( [
             ...this.getCodeEditorCommandPicks(),
             ...this.getGlobalCommandPicks()
-        ].map(c => ({
-            ...c,
+        ].map(picks => ({
+            ...picks,
             buttons: [{
                     iconClass: ThemeIcon.asClassName(Codicon.gear),
                     tooltip: ( localize('configure keybinding', "Configure Keybinding")),
                 }],
             trigger: () => {
-                this.preferencesService.openGlobalKeybindingSettings(false, { query: `@command:${c.commandId}` });
+                this.preferencesService.openGlobalKeybindingSettings(false, { query: `@command:${picks.commandId}` });
                 return TriggerAction.CLOSE_PICKER;
             },
         })));
     }
+    hasAdditionalCommandPicks(filter, token) {
+        if (!this.useSemanticSimilarity || filter === '' || token.isCancellationRequested || !this.semanticSimilarityService.isEnabled()) {
+            return false;
+        }
+        return true;
+    }
+    async getAdditionalCommandPicks(allPicks, picksSoFar, filter, token) {
+        if (!this.hasAdditionalCommandPicks(filter, token)) {
+            return [];
+        }
+        const format = ( allPicks.map(p => p.commandId));
+        let scores;
+        try {
+            await timeout(CommandsQuickAccessProvider.SEMANTIC_SIMILARITY_DEBOUNCE, token);
+            scores = await this.semanticSimilarityService.getSimilarityScore(filter, format, token);
+        }
+        catch (e) {
+            return [];
+        }
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const sortedIndices = ( scores.map((_, i) => i)).sort((a, b) => scores[b] - scores[a]);
+        const setOfPicksSoFar = ( new Set(( picksSoFar.map(p => p.commandId))));
+        const additionalPicks = picksSoFar.length > 0
+            ? [{
+                    type: 'separator',
+                    label: ( localize('semanticSimilarity', "similar commands"))
+                }]
+            : [];
+        let numOfSmartPicks = 0;
+        for (const i of sortedIndices) {
+            const score = scores[i];
+            if (score < CommandsQuickAccessProvider.SEMANTIC_SIMILARITY_THRESHOLD || numOfSmartPicks === CommandsQuickAccessProvider.SEMANTIC_SIMILARITY_MAX_PICKS) {
+                break;
+            }
+            const pick = allPicks[i];
+            if (!( setOfPicksSoFar.has(pick.commandId))) {
+                additionalPicks.push(pick);
+                numOfSmartPicks++;
+            }
+        }
+        return additionalPicks;
+    }
     getGlobalCommandPicks() {
         const globalCommandPicks = [];
         const scopedContextKeyService = this.editorService.activeEditorPane?.scopedContextKeyService || this.editorGroupService.activeGroup.scopedContextKeyService;
@@ -117,6 +175,9 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
         return globalCommandPicks;
     }
 };
+CommandsQuickAccessProvider.SEMANTIC_SIMILARITY_MAX_PICKS = 3;
+CommandsQuickAccessProvider.SEMANTIC_SIMILARITY_THRESHOLD = 0.8;
+CommandsQuickAccessProvider.SEMANTIC_SIMILARITY_DEBOUNCE = 200;
 CommandsQuickAccessProvider = ( __decorate([
     ( __param(0, IEditorService)),
     ( __param(1, IMenuService)),
@@ -129,7 +190,9 @@ CommandsQuickAccessProvider = ( __decorate([
     ( __param(8, IConfigurationService)),
     ( __param(9, IEditorGroupsService)),
     ( __param(10, IPreferencesService)),
-    ( __param(11, IProductService))
+    ( __param(11, IProductService)),
+    ( __param(12, ISemanticSimilarityService)),
+    ( __param(13, IInteractiveSessionService))
 ], CommandsQuickAccessProvider));
 class ShowAllCommandsAction extends Action2 {
     constructor() {
@@ -150,4 +213,39 @@ class ShowAllCommandsAction extends Action2 {
     }
 }
 ShowAllCommandsAction.ID = 'workbench.action.showCommands';
-export { CommandsQuickAccessProvider, ShowAllCommandsAction };
+class AskInInteractiveAction extends Action2 {
+    constructor() {
+        super({
+            id: AskInInteractiveAction.ID,
+            title: { value: ( localize('askInInteractiveSession', "Ask In Interactive Session")), original: 'Ask In Interactive Session' },
+            f1: false
+        });
+    }
+    async run(accessor, filter) {
+        const interactiveSessionService = accessor.get(IInteractiveSessionService);
+        const interactiveSessionWidgetService = accessor.get(IInteractiveSessionWidgetService);
+        const logService = accessor.get(ILogService);
+        if (!filter) {
+            throw new Error('No filter provided.');
+        }
+        let providerId;
+        const providerInfos = interactiveSessionService.getProviderInfos();
+        switch (providerInfos.length) {
+            case 0:
+                throw new Error('No interactive session provider found.');
+            case 1:
+                providerId = providerInfos[0].id;
+                break;
+            default:
+                logService.warn('Multiple interactive session providers found. Using the first one.');
+                providerId = providerInfos[0].id;
+                break;
+        }
+        const widget = await interactiveSessionWidgetService.revealViewForProvider(providerId);
+        if (widget?.viewModel) {
+            interactiveSessionService.sendInteractiveRequestToProvider(widget.viewModel.sessionId, { message: filter });
+        }
+    }
+}
+AskInInteractiveAction.ID = 'workbench.action.askCommandInInteractiveSession';
+export { AskInInteractiveAction, CommandsQuickAccessProvider, ShowAllCommandsAction };