@codingame/monaco-vscode-api 1.79.0 → 1.79.1

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

@@ -0,0 +1,379 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { createCancelablePromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { CONTEXT_PROVIDER_EXISTS } from './interactiveSessionContextKeys.js';
+import { InteractiveSessionModel, InteractiveSessionWelcomeMessageModel } from './interactiveSessionModel.js';
+import { InteractiveSessionVoteDirection, InteractiveSessionCopyKind } from './interactiveSessionService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+const serializedInteractiveSessionKey = 'interactive.sessions';
+const maxPersistedSessions = 20;
+let InteractiveSessionService = class InteractiveSessionService extends Disposable {
+    constructor(storageService, logService, extensionService, instantiationService, telemetryService, contextKeyService) {
+        super();
+        this.storageService = storageService;
+        this.logService = logService;
+        this.extensionService = extensionService;
+        this.instantiationService = instantiationService;
+        this.telemetryService = telemetryService;
+        this.contextKeyService = contextKeyService;
+        this._providers = ( new Map());
+        this._sessionModels = ( new Map());
+        this._pendingRequests = ( new Map());
+        this._onDidPerformUserAction = this._register(( new Emitter()));
+        this.onDidPerformUserAction = this._onDidPerformUserAction.event;
+        this._hasProvider = CONTEXT_PROVIDER_EXISTS.bindTo(this.contextKeyService);
+        const sessionData = storageService.get(serializedInteractiveSessionKey, 1 , '');
+        if (sessionData) {
+            this._persistedSessions = this.deserializeInteractiveSessions(sessionData);
+            const countsForLog = ( Object.keys(this._persistedSessions)).length;
+            this.trace('constructor', `Restored ${countsForLog} persisted sessions`);
+        }
+        else {
+            this._persistedSessions = {};
+            this.trace('constructor', 'No persisted sessions');
+        }
+        this._register(storageService.onWillSaveState(() => this.saveState()));
+    }
+    saveState() {
+        let allSessions = Array.from(( this._sessionModels.values()))
+            .filter(session => session.getRequests().length > 0);
+        allSessions = allSessions.concat(( Object.values(this._persistedSessions)).filter(session => session.requests.length));
+        allSessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
+        allSessions = allSessions.slice(0, maxPersistedSessions);
+        this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`);
+        const serialized = JSON.stringify(allSessions);
+        this.storageService.store(serializedInteractiveSessionKey, serialized, 1 , 1 );
+    }
+    notifyUserAction(action) {
+        if (action.action.kind === 'vote') {
+            this.telemetryService.publicLog2('interactiveSessionVote', {
+                providerId: action.providerId,
+                direction: action.action.direction === InteractiveSessionVoteDirection.Up ? 'up' : 'down'
+            });
+        }
+        else if (action.action.kind === 'copy') {
+            this.telemetryService.publicLog2('interactiveSessionCopy', {
+                providerId: action.providerId,
+                copyKind: action.action.copyType === InteractiveSessionCopyKind.Action ? 'action' : 'toolbar'
+            });
+        }
+        else if (action.action.kind === 'insert') {
+            this.telemetryService.publicLog2('interactiveSessionInsert', {
+                providerId: action.providerId,
+                newFile: !!action.action.newFile
+            });
+        }
+        else if (action.action.kind === 'command') {
+            const command = CommandsRegistry.getCommand(action.action.command.commandId);
+            const commandId = command ? action.action.command.commandId : 'INVALID';
+            this.telemetryService.publicLog2('interactiveSessionCommand', {
+                providerId: action.providerId,
+                commandId
+            });
+        }
+        else if (action.action.kind === 'runInTerminal') {
+            this.telemetryService.publicLog2('interactiveSessionRunInTerminal', {
+                providerId: action.providerId,
+                languageId: action.action.languageId ?? ''
+            });
+        }
+        this._onDidPerformUserAction.fire(action);
+    }
+    trace(method, message) {
+        this.logService.trace(`InteractiveSessionService#${method}: ${message}`);
+    }
+    error(method, message) {
+        this.logService.error(`InteractiveSessionService#${method} ${message}`);
+    }
+    deserializeInteractiveSessions(sessionData) {
+        try {
+            const arrayOfSessions = JSON.parse(sessionData);
+            if (!Array.isArray(arrayOfSessions)) {
+                throw new Error('Expected array');
+            }
+            const sessions = arrayOfSessions.reduce((acc, session) => {
+                acc[session.sessionId] = session;
+                return acc;
+            }, {});
+            return sessions;
+        }
+        catch (err) {
+            this.error('deserializeInteractiveSessions', `Malformed session data: ${err}. [${sessionData.substring(0, 20)}${sessionData.length > 20 ? '...' : ''}]`);
+            return {};
+        }
+    }
+    getHistory() {
+        const sessions = ( Object.values(this._persistedSessions));
+        sessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
+        return ( sessions.map(item => {
+            return {
+                sessionId: item.sessionId,
+                title: item.requests[0]?.message || '',
+            };
+        }));
+    }
+    startSession(providerId, token) {
+        this.trace('startSession', `providerId=${providerId}`);
+        return this._startSession(providerId, undefined, token);
+    }
+    _startSession(providerId, someSessionHistory, token) {
+        const model = this.instantiationService.createInstance(InteractiveSessionModel, providerId, someSessionHistory);
+        this._sessionModels.set(model.sessionId, model);
+        const modelInitPromise = this.initializeSession(model, someSessionHistory, token);
+        modelInitPromise.then(resolvedModel => {
+            if (!resolvedModel) {
+                model.dispose();
+                this._sessionModels.delete(model.sessionId);
+            }
+        }).catch(err => {
+            this.trace('startSession', `initializeSession failed: ${err}`);
+            model.dispose();
+            this._sessionModels.delete(model.sessionId);
+        });
+        return model;
+    }
+    async initializeSession(model, sessionHistory, token) {
+        await this.extensionService.activateByEvent(`onInteractiveSession:${model.providerId}`);
+        const provider = this._providers.get(model.providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${model.providerId}`);
+        }
+        let session;
+        try {
+            session = withNullAsUndefined(await provider.prepareSession(model.providerState, token));
+        }
+        catch (err) {
+            this.trace('initializeSession', `Provider initializeSession threw: ${err}`);
+        }
+        if (!session) {
+            if (sessionHistory) {
+                this._persistedSessions[sessionHistory.sessionId] = sessionHistory;
+            }
+            this.trace('startSession', 'Provider returned no session');
+            return undefined;
+        }
+        this.trace('startSession', `Provider returned session`);
+        const welcomeMessage = sessionHistory ? undefined : withNullAsUndefined(await provider.provideWelcomeMessage?.(token));
+        const welcomeModel = welcomeMessage && ( new InteractiveSessionWelcomeMessageModel(( welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item)), session.responderUsername, session.responderAvatarIconUri));
+        model.initialize(session, welcomeModel);
+        return model;
+    }
+    retrieveSession(sessionId) {
+        const model = this._sessionModels.get(sessionId);
+        if (model) {
+            return model;
+        }
+        const sessionData = this._persistedSessions[sessionId];
+        if (!sessionData) {
+            return undefined;
+        }
+        delete this._persistedSessions[sessionId];
+        return this._startSession(sessionData.providerId, sessionData, CancellationToken.None);
+    }
+    async sendRequest(sessionId, request) {
+        const messageText = typeof request === 'string' ? request : request.message;
+        this.trace('sendRequest', `sessionId: ${sessionId}, message: ${messageText.substring(0, 20)}${messageText.length > 20 ? '[...]' : ''}}`);
+        if (!messageText.trim()) {
+            this.trace('sendRequest', 'Rejected empty message');
+            return false;
+        }
+        const model = this._sessionModels.get(sessionId);
+        if (!model) {
+            throw new Error(`Unknown session: ${sessionId}`);
+        }
+        await model.waitForInitialization();
+        const provider = this._providers.get(model.providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${model.providerId}`);
+        }
+        if (( this._pendingRequests.has(sessionId))) {
+            this.trace('sendRequest', `Session ${sessionId} already has a pending request`);
+            return false;
+        }
+        this._sendRequestAsync(model, provider, request);
+        return true;
+    }
+    _sendRequestAsync(model, provider, message) {
+        const request = model.addRequest(message);
+        let gotProgress = false;
+        const requestType = typeof message === 'string' ?
+            (message.startsWith('/') ? 'slashCommand' : 'string') :
+            'followup';
+        const rawResponsePromise = createCancelablePromise(async (token) => {
+            const progressCallback = (progress) => {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                gotProgress = true;
+                if ('content' in progress) {
+                    this.trace('sendRequest', `Provider returned progress for session ${model.sessionId}, ${progress.content.length} chars`);
+                }
+                else {
+                    this.trace('sendRequest', `Provider returned id for session ${model.sessionId}, ${progress.responseId}`);
+                }
+                model.acceptResponseProgress(request, progress);
+            };
+            const stopWatch = ( new StopWatch(false));
+            token.onCancellationRequested(() => {
+                this.trace('sendRequest', `Request for session ${model.sessionId} was cancelled`);
+                this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
+                    providerId: provider.id,
+                    timeToFirstProgress: -1,
+                    totalTime: stopWatch.elapsed(),
+                    result: 'cancelled',
+                    requestType
+                });
+                model.cancelRequest(request);
+            });
+            let rawResponse = await provider.provideReply({ session: model.session, message: request.message }, progressCallback, token);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            else {
+                if (!rawResponse) {
+                    this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
+                    rawResponse = { session: model.session, errorDetails: { message: ( localize('emptyResponse', "Provider returned null response")) } };
+                }
+                const result = rawResponse.errorDetails?.responseIsFiltered ? 'filtered' :
+                    rawResponse.errorDetails && gotProgress ? 'errorWithOutput' :
+                        rawResponse.errorDetails ? 'error' :
+                            'success';
+                this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
+                    providerId: provider.id,
+                    timeToFirstProgress: rawResponse.timings?.firstProgress ?? 0,
+                    totalTime: rawResponse.timings?.totalElapsed ?? 0,
+                    result,
+                    requestType
+                });
+                model.completeResponse(request, rawResponse);
+                this.trace('sendRequest', `Provider returned response for session ${model.sessionId}`);
+                if (provider.provideFollowups) {
+                    Promise.resolve(provider.provideFollowups(model.session, CancellationToken.None)).then(followups => {
+                        model.setFollowups(request, withNullAsUndefined(followups));
+                    });
+                }
+            }
+        });
+        this._pendingRequests.set(model.sessionId, rawResponsePromise);
+        rawResponsePromise.finally(() => {
+            this._pendingRequests.delete(model.sessionId);
+        });
+        return rawResponsePromise;
+    }
+    async getSlashCommands(sessionId, token) {
+        const model = this._sessionModels.get(sessionId);
+        if (!model) {
+            throw new Error(`Unknown session: ${sessionId}`);
+        }
+        await model.waitForInitialization();
+        const provider = this._providers.get(model.providerId);
+        if (!provider) {
+            throw new Error(`Unknown provider: ${model.providerId}`);
+        }
+        if (!provider.provideSlashCommands) {
+            return;
+        }
+        return withNullAsUndefined(await provider.provideSlashCommands(model.session, token));
+    }
+    async addInteractiveRequest(context) {
+        const model = Iterable.first(( this._sessionModels.values()));
+        if (!model) {
+            this.trace('addInteractiveRequest', 'No session available');
+            return;
+        }
+        const provider = this._providers.get(model.providerId);
+        if (!provider || !provider.resolveRequest) {
+            this.trace('addInteractiveRequest', 'No provider available');
+            return undefined;
+        }
+        this.trace('addInteractiveRequest', `Calling resolveRequest for session ${model.sessionId}`);
+        const request = await provider.resolveRequest(model.session, context, CancellationToken.None);
+        if (!request) {
+            this.trace('addInteractiveRequest', `Provider returned no request for session ${model.sessionId}`);
+            return;
+        }
+        this.trace('addInteractiveRequest', `Sending resolved request for session ${model.sessionId}`);
+        this.sendRequest(model.sessionId, request.message);
+    }
+    async sendInteractiveRequestToProvider(sessionId, message) {
+        this.trace('sendInteractiveRequestToProvider', `sessionId: ${sessionId}`);
+        await this.sendRequest(sessionId, message.message);
+    }
+    getProviders() {
+        return Array.from(( this._providers.keys()));
+    }
+    async addCompleteRequest(sessionId, message, response) {
+        this.trace('addCompleteRequest', `message: ${message}`);
+        const model = this._sessionModels.get(sessionId);
+        if (!model) {
+            throw new Error(`Unknown session: ${sessionId}`);
+        }
+        await model.waitForInitialization();
+        const request = model.addRequest(message);
+        model.acceptResponseProgress(request, {
+            content: response.message,
+        });
+        model.completeResponse(request, {
+            session: model.session,
+            errorDetails: response.errorDetails,
+        });
+    }
+    cancelCurrentRequestForSession(sessionId) {
+        this.trace('cancelCurrentRequestForSession', `sessionId: ${sessionId}`);
+        this._pendingRequests.get(sessionId)?.cancel();
+    }
+    clearSession(sessionId) {
+        this.trace('clearSession', `sessionId: ${sessionId}`);
+        const model = this._sessionModels.get(sessionId);
+        if (!model) {
+            throw new Error(`Unknown session: ${sessionId}`);
+        }
+        this._persistedSessions[sessionId] = model.toJSON();
+        model.dispose();
+        this._sessionModels.delete(sessionId);
+        this._pendingRequests.get(sessionId)?.cancel();
+    }
+    registerProvider(provider) {
+        this.trace('registerProvider', `Adding new interactive session provider`);
+        if (( this._providers.has(provider.id))) {
+            throw new Error(`Provider ${provider.id} already registered`);
+        }
+        this._providers.set(provider.id, provider);
+        this._hasProvider.set(true);
+        return toDisposable(() => {
+            this.trace('registerProvider', `Disposing interactive session provider`);
+            this._providers.delete(provider.id);
+            this._hasProvider.set(this._providers.size > 0);
+        });
+    }
+    getProviderInfos() {
+        return ( Array.from(( this._providers.values())).map(provider => {
+            return {
+                id: provider.id,
+                displayName: provider.displayName
+            };
+        }));
+    }
+};
+InteractiveSessionService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IContextKeyService))
+], InteractiveSessionService));
+export { InteractiveSessionService };

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

@@ -1,5 +1,5 @@
 import { NOTEBOOK_EDITOR_ID } from '../common/notebookCommon.js';
-import { isCompositeNotebookEditorInput } from '../common/notebookEditorInput.js';
+import { isCompositeNotebookEditorInput } from '../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
 const IPYNB_VIEW_TYPE = 'jupyter-notebook';
 const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
 const KERNEL_RECOMMENDATIONS = ( new Map());
@@ -19,7 +19,7 @@ function getNotebookEditorFromEditorPane(editorPane) {
         return editorPane.getControl();
     }
     const input = editorPane.input;
-    if (input && isCompositeNotebookEditorInput(input)) {
+    if (input && isCompositeNotebookEditorInput()) {
         return editorPane.getControl().notebookEditor;
     }
     return undefined;

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

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { CommandsHistory } from 'monaco-editor/esm/vs/platform/quickinput/browser/commandsQuickAccess.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';
@@ -16,6 +17,7 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
 import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
@@ -213,6 +215,36 @@ class ShowAllCommandsAction extends Action2 {
     }
 }
 ShowAllCommandsAction.ID = 'workbench.action.showCommands';
+class ClearCommandHistoryAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.clearCommandHistory',
+            title: { value: ( localize('clearCommandHistory', "Clear Command History")), original: 'Clear Command History' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const configurationService = accessor.get(IConfigurationService);
+        const storageService = accessor.get(IStorageService);
+        const dialogService = accessor.get(IDialogService);
+        const commandHistoryLength = CommandsHistory.getConfiguredCommandHistoryLength(configurationService);
+        if (commandHistoryLength > 0) {
+            const { confirmed } = await dialogService.confirm({
+                type: 'warning',
+                message: ( localize(
+                    'confirmClearMessage',
+                    "Do you want to clear the history of recently used commands?"
+                )),
+                detail: ( localize('confirmClearDetail', "This action is irreversible!")),
+                primaryButton: ( localize({ key: 'clearButtonLabel', comment: ['&& denotes a mnemonic'] }, "&&Clear"))
+            });
+            if (!confirmed) {
+                return;
+            }
+            CommandsHistory.clearHistory(configurationService, storageService);
+        }
+    }
+}
 class AskInInteractiveAction extends Action2 {
     constructor() {
         super({
@@ -248,4 +280,4 @@ class AskInInteractiveAction extends Action2 {
     }
 }
 AskInInteractiveAction.ID = 'workbench.action.askCommandInInteractiveSession';
-export { AskInInteractiveAction, CommandsQuickAccessProvider, ShowAllCommandsAction };
+export { AskInInteractiveAction, ClearCommandHistoryAction, CommandsQuickAccessProvider, ShowAllCommandsAction };

package/dist/vscode/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution.js

@@ -0,0 +1,130 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { HelpQuickAccessProvider } from 'monaco-editor/esm/vs/platform/quickinput/browser/helpQuickAccess.js';
+import { ViewQuickAccessProvider, OpenViewPickerAction, QuickAccessViewPickerAction } from './viewQuickAccess.js';
+import { CommandsQuickAccessProvider, ShowAllCommandsAction, ClearCommandHistoryAction, AskInInteractiveAction } from './commandsQuickAccess.js';
+import { MenuRegistry, MenuId, registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { getQuickNavigateHandler, inQuickPickContext } from '../../../browser/quickaccess.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+const quickAccessRegistry = ( Registry.as(Extensions.Quickaccess));
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: HelpQuickAccessProvider,
+    prefix: HelpQuickAccessProvider.PREFIX,
+    placeholder: ( localize(
+        'helpQuickAccessPlaceholder',
+        "Type '{0}' to get help on the actions you can take from here.",
+        HelpQuickAccessProvider.PREFIX
+    )),
+    helpEntries: [{ description: ( localize('helpQuickAccess', "Show all Quick Access Providers")) }]
+});
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: ViewQuickAccessProvider,
+    prefix: ViewQuickAccessProvider.PREFIX,
+    contextKey: 'inViewsPicker',
+    placeholder: ( localize(
+        'viewQuickAccessPlaceholder',
+        "Type the name of a view, output channel or terminal to open."
+    )),
+    helpEntries: [{ description: ( localize('viewQuickAccess', "Open View")), commandId: OpenViewPickerAction.ID }]
+});
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: CommandsQuickAccessProvider,
+    prefix: CommandsQuickAccessProvider.PREFIX,
+    contextKey: 'inCommandsPicker',
+    placeholder: ( localize('commandsQuickAccessPlaceholder', "Type the name of a command to run.")),
+    helpEntries: [{ description: ( localize('commandsQuickAccess', "Show and Run Commands")), commandId: ShowAllCommandsAction.ID }]
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
+    group: '1_open',
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize(
+            { key: 'miCommandPalette', comment: ['&& denotes a mnemonic'] },
+            "&&Command Palette..."
+        ))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarHelpMenu, {
+    group: '1_welcome',
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize(
+            { key: 'miShowAllCommands', comment: ['&& denotes a mnemonic'] },
+            "Show All Commands"
+        ))
+    },
+    order: 2
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
+    group: '1_open',
+    command: {
+        id: OpenViewPickerAction.ID,
+        title: ( localize(
+            { key: 'miOpenView', comment: ['&& denotes a mnemonic'] },
+            "&&Open View..."
+        ))
+    },
+    order: 2
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarGoMenu, {
+    group: '5_infile_nav',
+    command: {
+        id: 'workbench.action.gotoLine',
+        title: ( localize(
+            { key: 'miGotoLine', comment: ['&& denotes a mnemonic'] },
+            "Go to &&Line/Column..."
+        ))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
+    group: '1_command',
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize('commandPalette', "Command Palette..."))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.EditorContext, {
+    group: 'z_commands',
+    when: ( EditorContextKeys.editorSimpleInput.toNegated()),
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize('commandPalette', "Command Palette...")),
+    },
+    order: 1
+});
+registerAction2(ClearCommandHistoryAction);
+registerAction2(ShowAllCommandsAction);
+registerAction2(OpenViewPickerAction);
+registerAction2(QuickAccessViewPickerAction);
+registerAction2(AskInInteractiveAction);
+const inViewsPickerContextKey = 'inViewsPicker';
+const inViewsPickerContext = ( ContextKeyExpr.and(inQuickPickContext, ( ContextKeyExpr.has(inViewsPickerContextKey))));
+const viewPickerKeybinding = QuickAccessViewPickerAction.KEYBINDING;
+const quickAccessNavigateNextInViewPickerId = 'workbench.action.quickOpenNavigateNextInViewPicker';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: quickAccessNavigateNextInViewPickerId,
+    weight: 200  + 50,
+    handler: getQuickNavigateHandler(quickAccessNavigateNextInViewPickerId, true),
+    when: inViewsPickerContext,
+    primary: viewPickerKeybinding.primary,
+    linux: viewPickerKeybinding.linux,
+    mac: viewPickerKeybinding.mac
+});
+const quickAccessNavigatePreviousInViewPickerId = 'workbench.action.quickOpenNavigatePreviousInViewPicker';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: quickAccessNavigatePreviousInViewPickerId,
+    weight: 200  + 50,
+    handler: getQuickNavigateHandler(quickAccessNavigatePreviousInViewPickerId, false),
+    when: inViewsPickerContext,
+    primary: viewPickerKeybinding.primary | 1024 ,
+    linux: viewPickerKeybinding.linux,
+    mac: {
+        primary: viewPickerKeybinding.mac.primary | 1024
+    }
+});