@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpPromptArgumentPick.js

@@ -0,0 +1,372 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { timeout, disposableTimeout, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { getIconClasses } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/getIconClasses';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { TerminalLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { QueryBuilder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/queryBuilder';
+import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service';
+import { ITerminalService, ITerminalGroupService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+
+const SHELL_INTEGRATION_TIMEOUT = 5000;
+const NO_SHELL_INTEGRATION_IDLE = 1000;
+const SUGGEST_DEBOUNCE = 200;
+let McpPromptArgumentPick = class McpPromptArgumentPick extends Disposable {
+    constructor(prompt, _quickInputService, _terminalService, _searchService, _workspaceContextService, _labelService, _fileService, _modelService, _languageService, _terminalGroupService, _instantiationService, _codeEditorService, _editorService) {
+        super();
+        this.prompt = prompt;
+        this._quickInputService = _quickInputService;
+        this._terminalService = _terminalService;
+        this._searchService = _searchService;
+        this._workspaceContextService = _workspaceContextService;
+        this._labelService = _labelService;
+        this._fileService = _fileService;
+        this._modelService = _modelService;
+        this._languageService = _languageService;
+        this._terminalGroupService = _terminalGroupService;
+        this._instantiationService = _instantiationService;
+        this._codeEditorService = _codeEditorService;
+        this._editorService = _editorService;
+        this.quickPick = this._register(_quickInputService.createQuickPick({ useSeparators: true }));
+    }
+    async createArgs(token) {
+        const { quickPick, prompt } = this;
+        quickPick.totalSteps = prompt.arguments.length;
+        quickPick.step = 0;
+        quickPick.ignoreFocusOut = true;
+        quickPick.sortByLabel = false;
+        const args = {};
+        const backSnapshots = [];
+        for (let i = 0; i < prompt.arguments.length; i++) {
+            const arg = prompt.arguments[i];
+            const restore = backSnapshots.at(i);
+            quickPick.step = i + 1;
+            quickPick.placeholder = arg.required ? arg.description : `${arg.description || ''} (${( localize(8849, 'Optional'))})`;
+            quickPick.title = ( localize(8850, 'Value for: {0}', arg.title || arg.name));
+            quickPick.value = restore?.value ?? ((args.hasOwnProperty(arg.name) && args[arg.name]) || '');
+            quickPick.items = restore?.items ?? [];
+            quickPick.activeItems = restore?.activeItems ?? [];
+            quickPick.buttons = i > 0 ? [this._quickInputService.backButton] : [];
+            const value = await this._getArg(arg, !!restore, args, token);
+            if (value.type === 'back') {
+                i -= 2;
+            }
+            else if (value.type === 'cancel') {
+                return undefined;
+            }
+            else if (value.type === 'arg') {
+                backSnapshots[i] = { value: quickPick.value, items: quickPick.items.slice(), activeItems: quickPick.activeItems.slice() };
+                args[arg.name] = value.value;
+            }
+            else {
+                assertNever();
+            }
+        }
+        quickPick.value = '';
+        quickPick.placeholder = ( localize(8851, 'Loading...'));
+        quickPick.busy = true;
+        return args;
+    }
+    async _getArg(arg, didRestoreState, argsSoFar, token) {
+        const { quickPick } = this;
+        const store = ( new DisposableStore());
+        const input$ = observableValue(this, quickPick.value);
+        const asyncPicks = [
+            {
+                name: ( localize(8852, 'Suggestions')),
+                observer: this._promptCompletions(arg, input$, argsSoFar),
+            },
+            {
+                name: ( localize(8853, 'Active File')),
+                observer: this._activeFileCompletions(),
+            },
+            {
+                name: ( localize(8854, 'Files')),
+                observer: this._fileCompletions(input$),
+            }
+        ];
+        store.add(autorun(reader => {
+            if (didRestoreState) {
+                input$.read(reader);
+                return;
+            }
+            let items = [];
+            items.push({ id: 'insert-text', label: ( localize(8855, 'Insert as text')), iconClass: ThemeIcon.asClassName(Codicon.textSize), action: 'text', alwaysShow: true });
+            items.push({ id: 'run-command', label: ( localize(8856, 'Run as Command')), description: ( localize(8857, 'Inserts the command output as the prompt argument')), iconClass: ThemeIcon.asClassName(Codicon.terminal), action: 'command', alwaysShow: true });
+            let busy = false;
+            for (const pick of asyncPicks) {
+                const state = pick.observer.read(reader);
+                busy ||= state.busy;
+                if (state.picks) {
+                    items.push({ label: pick.name, type: 'separator' });
+                    items = items.concat(state.picks);
+                }
+            }
+            const previouslyActive = quickPick.activeItems;
+            quickPick.busy = busy;
+            quickPick.items = items;
+            const lastActive = items.find(i => ( previouslyActive.some(a => a.id === i.id)));
+            const serverSuggestions = asyncPicks[0].observer;
+            if (lastActive) {
+                quickPick.activeItems = [lastActive];
+            }
+            else if (serverSuggestions.read(reader).picks?.length) {
+                quickPick.activeItems = [items[3]];
+            }
+            else if (busy) {
+                quickPick.activeItems = [];
+            }
+            else {
+                quickPick.activeItems = [items[0]];
+            }
+        }));
+        try {
+            const value = await ( new Promise(resolve => {
+                if (token) {
+                    store.add(token.onCancellationRequested(() => {
+                        resolve(undefined);
+                    }));
+                }
+                store.add(quickPick.onDidChangeValue(value => {
+                    quickPick.validationMessage = undefined;
+                    input$.set(value, undefined);
+                }));
+                store.add(quickPick.onDidAccept(() => {
+                    const item = quickPick.selectedItems[0];
+                    if (!quickPick.value && arg.required && (!item || item.action === 'text' || item.action === 'command')) {
+                        quickPick.validationMessage = ( localize(8858, "This argument is required"));
+                    }
+                    else if (!item) {
+                        resolve({ id: 'insert-text', label: '', action: 'text' });
+                    }
+                    else {
+                        resolve(item);
+                    }
+                }));
+                store.add(quickPick.onDidTriggerButton(() => {
+                    resolve('back');
+                }));
+                store.add(quickPick.onDidHide(() => {
+                    resolve(undefined);
+                }));
+                quickPick.show();
+            }));
+            if (value === 'back') {
+                return { type: 'back' };
+            }
+            if (value === undefined) {
+                return { type: 'cancel' };
+            }
+            store.clear();
+            const cts = ( new CancellationTokenSource());
+            store.add(toDisposable(() => cts.dispose(true)));
+            store.add(quickPick.onDidHide(() => store.dispose()));
+            switch (value.action) {
+                case 'text':
+                    return { type: 'arg', value: quickPick.value || undefined };
+                case 'command':
+                    if (!quickPick.value) {
+                        return { type: 'arg', value: undefined };
+                    }
+                    quickPick.busy = true;
+                    return { type: 'arg', value: await this._getTerminalOutput(quickPick.value, cts.token) };
+                case 'suggest':
+                    return { type: 'arg', value: value.label };
+                case 'file':
+                    quickPick.busy = true;
+                    return { type: 'arg', value: await this._fileService.readFile(value.uri).then(c => ( c.value.toString())) };
+                case 'selectedText':
+                    return { type: 'arg', value: value.selectedText };
+                default:
+                    assertNever(value);
+            }
+        }
+        finally {
+            store.dispose();
+        }
+    }
+    _promptCompletions(arg, input, argsSoFar) {
+        const alreadyResolved = {};
+        for (const [key, value] of Object.entries(argsSoFar)) {
+            if (value) {
+                alreadyResolved[key] = value;
+            }
+        }
+        return this._asyncCompletions(input, async (i, t) => {
+            const items = await this.prompt.complete(arg.name, i, alreadyResolved, t);
+            return ( items.map((i) => ({ id: `suggest:${i}`, label: i, action: 'suggest' })));
+        });
+    }
+    _fileCompletions(input) {
+        const qb = this._instantiationService.createInstance(QueryBuilder);
+        return this._asyncCompletions(input, async (i, token) => {
+            if (!i) {
+                return [];
+            }
+            const query = qb.file(this._workspaceContextService.getWorkspace().folders, {
+                filePattern: i,
+                maxResults: 10,
+            });
+            const { results } = await this._searchService.fileSearch(query, token);
+            return ( results.map((i) => ({
+                id: ( i.resource.toString()),
+                label: basename(i.resource),
+                description: this._labelService.getUriLabel(i.resource),
+                iconClasses: getIconClasses(this._modelService, this._languageService, i.resource),
+                uri: i.resource,
+                action: 'file',
+            })));
+        });
+    }
+    _activeFileCompletions() {
+        const activeEditorChange = observableSignalFromEvent(this, this._editorService.onDidActiveEditorChange);
+        const activeEditor = derived(reader => {
+            activeEditorChange.read(reader);
+            return this._codeEditorService.getActiveCodeEditor();
+        });
+        const resourceObs = ( ( activeEditor
+            .map(e => e ? ( observableSignalFromEvent(this, e.onDidChangeModel).map(() => e.getModel()?.uri)) : undefined))
+            .map((o, reader) => o?.read(reader)));
+        const selectionObs = ( ( activeEditor
+            .map(e => e ? ( observableSignalFromEvent(this, e.onDidChangeCursorSelection).map(() => ({ range: e.getSelection(), model: e.getModel() }))) : undefined))
+            .map((o, reader) => o?.read(reader)));
+        return derived(reader => {
+            const resource = resourceObs.read(reader);
+            if (!resource) {
+                return { busy: false, picks: [] };
+            }
+            const items = [];
+            items.push({
+                id: 'active-file',
+                label: ( localize(8859, 'Active File')),
+                description: this._labelService.getUriLabel(resource),
+                iconClasses: getIconClasses(this._modelService, this._languageService, resource),
+                uri: resource,
+                action: 'file',
+            });
+            const selection = selectionObs.read(reader);
+            if (selection && selection.model && selection.range && !selection.range.isEmpty()) {
+                const selectedText = selection.model.getValueInRange(selection.range);
+                const lineCount = selection.range.endLineNumber - selection.range.startLineNumber + 1;
+                const description = lineCount === 1
+                    ? ( localize(8860, 'line {0}', selection.range.startLineNumber))
+                    : ( localize(8861, '{0} lines', lineCount));
+                items.push({
+                    id: 'selected-text',
+                    label: ( localize(8862, 'Selected Text')),
+                    description,
+                    selectedText,
+                    iconClass: ThemeIcon.asClassName(Codicon.selection),
+                    uri: resource,
+                    action: 'selectedText',
+                });
+            }
+            return { picks: items, busy: false };
+        });
+    }
+    _asyncCompletions(input, mapper) {
+        const promise = derived(reader => {
+            const queryValue = input.read(reader);
+            const cts = ( new CancellationTokenSource());
+            reader.store.add(toDisposable(() => cts.dispose(true)));
+            return ( new ObservablePromise(timeout(SUGGEST_DEBOUNCE, cts.token)
+                .then(() => mapper(queryValue, cts.token))
+                .catch(() => [])));
+        });
+        return ( promise.map((value, reader) => {
+            const result = value.promiseResult.read(reader);
+            return { picks: result?.data || [], busy: result === undefined };
+        }));
+    }
+    async _getTerminalOutput(command, token) {
+        const terminal = (this._terminal ??= this._register(await this._terminalService.createTerminal({
+            config: {
+                name: ( localize(8863, "MCP Terminal")),
+                isTransient: true,
+                forceShellIntegration: true,
+                isFeatureTerminal: true,
+            },
+            location: TerminalLocation.Panel,
+        })));
+        this._terminalService.setActiveInstance(terminal);
+        this._terminalGroupService.showPanel(false);
+        const shellIntegration = terminal.capabilities.get(TerminalCapability.CommandDetection);
+        if (shellIntegration) {
+            return this._getTerminalOutputInner(terminal, command, shellIntegration, token);
+        }
+        const store = ( new DisposableStore());
+        return await ( new Promise(resolve => {
+            store.add(terminal.capabilities.onDidAddCapability(e => {
+                if (e.id === TerminalCapability.CommandDetection) {
+                    store.dispose();
+                    resolve(this._getTerminalOutputInner(terminal, command, e.capability, token));
+                }
+            }));
+            store.add(token.onCancellationRequested(() => {
+                store.dispose();
+                resolve(undefined);
+            }));
+            store.add(disposableTimeout(() => {
+                store.dispose();
+                resolve(this._getTerminalOutputInner(terminal, command, undefined, token));
+            }, SHELL_INTEGRATION_TIMEOUT));
+        }));
+    }
+    async _getTerminalOutputInner(terminal, command, shellIntegration, token) {
+        const store = ( new DisposableStore());
+        return ( new Promise(resolve => {
+            let allData = '';
+            store.add(terminal.onLineData(d => allData += d + '\n'));
+            if (shellIntegration) {
+                store.add(shellIntegration.onCommandFinished(e => resolve(e.getOutput() || allData)));
+            }
+            else {
+                const done = store.add(( new RunOnceScheduler(() => resolve(allData), NO_SHELL_INTEGRATION_IDLE)));
+                store.add(terminal.onData(() => done.schedule()));
+            }
+            store.add(token.onCancellationRequested(() => resolve(undefined)));
+            store.add(terminal.onDisposed(() => resolve(undefined)));
+            terminal.runCommand(command, true);
+        })).finally(() => {
+            store.dispose();
+        });
+    }
+};
+McpPromptArgumentPick = ( __decorate([
+    ( __param(1, IQuickInputService)),
+    ( __param(2, ITerminalService)),
+    ( __param(3, ISearchService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, IFileService)),
+    ( __param(7, IModelService)),
+    ( __param(8, ILanguageService)),
+    ( __param(9, ITerminalGroupService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, ICodeEditorService)),
+    ( __param(12, IEditorService))
+], McpPromptArgumentPick));
+
+export { McpPromptArgumentPick };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chat/notebookChatUtils.d.ts

@@ -0,0 +1,4 @@
+import { INotebookOutputVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries";
+import { ICellOutputViewModel, INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+export declare const NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST: string[];
+export declare function createNotebookOutputVariableEntry(outputViewModel: ICellOutputViewModel, mimeType: string, notebookEditor: INotebookEditor): INotebookOutputVariableEntry | undefined;

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chat/notebookChatUtils.js

@@ -0,0 +1,58 @@
+
+import { normalizeDriveLetter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
+import { basenameOrAuthority } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+const NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST = [
+    'text/plain',
+    'text/html',
+    'application/vnd.code.notebook.error',
+    'application/vnd.code.notebook.stdout',
+    'application/x.notebook.stdout',
+    'application/x.notebook.stream',
+    'application/vnd.code.notebook.stderr',
+    'application/x.notebook.stderr',
+    'image/png',
+    'image/jpeg',
+    'image/svg',
+];
+function createNotebookOutputVariableEntry(outputViewModel, mimeType, notebookEditor) {
+    const cellFromViewModelHandle = outputViewModel.cellViewModel.handle;
+    const notebookModel = notebookEditor.textModel;
+    const cell = notebookEditor.getCellByHandle(cellFromViewModelHandle);
+    if (!cell || cell.outputsViewModels.length === 0 || !notebookModel) {
+        return;
+    }
+    const notebookUri = notebookModel.uri;
+    const cellUri = cell.uri;
+    const cellIndex = notebookModel.cells.indexOf(cell.model);
+    const outputId = outputViewModel?.model.outputId;
+    let outputIndex = 0;
+    if (outputId !== undefined) {
+        outputIndex = cell.outputsViewModels.findIndex(output => {
+            return output.model.outputId === outputId;
+        });
+    }
+    const outputCellUri = CellUri.generateCellOutputUriWithIndex(notebookUri, cellUri, outputIndex);
+    const fileName = normalizeDriveLetter(basenameOrAuthority(notebookUri));
+    const l = {
+        value: outputCellUri,
+        id: ( outputCellUri.toString()),
+        name: ( localize(
+            9228,
+            "{0} • Cell {1} • Output {2}",
+            fileName,
+            `${cellIndex + 1}`,
+            `${outputIndex + 1}`
+        )),
+        icon: mimeType === 'application/vnd.code.notebook.error' ? ThemeIcon.fromId('error') : undefined,
+        kind: 'notebookOutput',
+        outputIndex,
+        mimeType
+    };
+    return l;
+}
+
+export { NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST, createNotebookOutputVariableEntry };

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/cellOperations.d.ts

@@ -0,0 +1,26 @@
+import { ResourceEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService";
+import { IBulkEditService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService.service";
+import { IPosition } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { INotebookActionContext, INotebookCellActionContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions";
+import { IActiveNotebookEditor, ICellViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { CellViewModel, NotebookViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookViewModelImpl";
+import { CellKind, IOutputDto, NotebookCellMetadata } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { ICellRange } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { INotebookKernelHistoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service";
+export declare function changeCellToKind(kind: CellKind, context: INotebookActionContext, language?: string, mime?: string): Promise<void>;
+export declare function runDeleteAction(editor: IActiveNotebookEditor, cell: ICellViewModel): void;
+export declare function moveCellRange(context: INotebookActionContext, direction: "up" | "down"): Promise<void>;
+export declare function copyCellRange(context: INotebookCellActionContext, direction: "up" | "down"): Promise<void>;
+export declare function joinSelectedCells(bulkEditService: IBulkEditService, notificationService: INotificationService, context: INotebookCellActionContext): Promise<void>;
+export declare function joinNotebookCells(editor: IActiveNotebookEditor, range: ICellRange, direction: "above" | "below", constraint?: CellKind): Promise<{
+    edits: ResourceEdit[];
+    cell: ICellViewModel;
+    endFocus: ICellRange;
+    endSelections: ICellRange[];
+} | null>;
+export declare function joinCellsWithSurrounds(bulkEditService: IBulkEditService, context: INotebookCellActionContext, direction: "above" | "below"): Promise<void>;
+export declare function computeCellLinesContents(cell: ICellViewModel, splitPoints: IPosition[]): string[] | null;
+export declare function insertCell(languageService: ILanguageService, editor: IActiveNotebookEditor, index: number, type: CellKind, direction?: "above" | "below", initialText?: string, ui?: boolean, kernelHistoryService?: INotebookKernelHistoryService): CellViewModel | null;
+export declare function insertCellAtIndex(viewModel: NotebookViewModel, index: number, source: string, language: string, type: CellKind, metadata: NotebookCellMetadata | undefined, outputs: IOutputDto[], synchronous: boolean, pushUndoStop: boolean): CellViewModel;