@codingame/monaco-vscode-chat-service-override 13.1.7 → 14.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/codeBlockOperations.js

@@ -1,6 +1,5 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { AsyncIterableObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
@@ -8,12 +7,12 @@ import { CharCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cha
 import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { splitLines } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
-import { isDiffEditor, isCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { getCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
 import { ResourceTextEdit, IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService';
 import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language';
-import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
@@ -25,9 +24,11 @@ import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workben
 import { InlineChatController } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 import { insertCell } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/controller/cellOperations';
 import { CellKind, NOTEBOOK_EDITOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { getReferencesAsDocumentContext } from '../../common/chatCodeMapperService.js';
+import { ICodeMapperService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatCodeMapperService.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { isResponseVM, isRequestVM } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 
 let InsertCodeBlockOperation = class InsertCodeBlockOperation {
     constructor(editorService, textFileService, bulkEditService, codeEditorService, chatService, languageService, dialogService) {
@@ -51,7 +52,7 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
             }
             else {
                 this.notify(( localize(
-                    4280,
+                    4359,
                     "To insert the code block, open a code editor or notebook editor and set the cursor at the location where to insert the code block."
                 )));
             }
@@ -64,7 +65,7 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
     }
     async handleNotebookEditor(notebookEditor, codeBlockContext) {
         if (notebookEditor.isReadOnly) {
-            this.notify(( localize(4281, "Cannot insert the code block to read-only notebook editor.")));
+            this.notify(( localize(4360, "Cannot insert the code block to read-only notebook editor.")));
             return false;
         }
         const focusRange = notebookEditor.getFocus();
@@ -75,7 +76,7 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
     async handleTextEditor(codeEditor, codeBlockContext) {
         const activeModel = codeEditor.getModel();
         if (isReadOnly(activeModel, this.textFileService)) {
-            this.notify(( localize(4282, "Cannot insert the code block to read-only code editor.")));
+            this.notify(( localize(4361, "Cannot insert the code block to read-only code editor.")));
             return false;
         }
         const range = codeEditor.getSelection() ?? ( new Range(activeModel.getLineCount(), 1, activeModel.getLineCount(), 1));
@@ -99,54 +100,54 @@ InsertCodeBlockOperation = ( __decorate([
     ( __param(6, IDialogService))
 ], InsertCodeBlockOperation));
 let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
-    constructor(editorService, textFileService, bulkEditService, codeEditorService, chatService, languageFeaturesService, progressService, languageService, fileService, dialogService, logService) {
+    constructor(editorService, textFileService, chatService, languageService, fileService, dialogService, logService, codeMapperService, progressService, quickInputService, labelService) {
         this.editorService = editorService;
         this.textFileService = textFileService;
-        this.bulkEditService = bulkEditService;
-        this.codeEditorService = codeEditorService;
         this.chatService = chatService;
-        this.languageFeaturesService = languageFeaturesService;
-        this.progressService = progressService;
         this.languageService = languageService;
         this.fileService = fileService;
         this.dialogService = dialogService;
         this.logService = logService;
+        this.codeMapperService = codeMapperService;
+        this.progressService = progressService;
+        this.quickInputService = quickInputService;
+        this.labelService = labelService;
     }
     async run(context) {
-        if (this.inlineChatPreview && this.inlineChatPreview.isOpen()) {
-            await this.dialogService.info(( localize(
-                4283,
-                "Another code change is being previewed. Please apply or discard the pending changes first."
-            )));
+        let activeEditorControl = getEditableActiveCodeEditor(this.editorService);
+        const codemapperUri = await this.evaluateURIToUse(context.codemapperUri, activeEditorControl);
+        if (!codemapperUri) {
             return;
         }
-        let activeEditorControl = getEditableActiveCodeEditor(this.editorService);
-        if (context.codemapperUri && !isEqual(activeEditorControl?.getModel().uri, context.codemapperUri)) {
+        if (codemapperUri && !isEqual(activeEditorControl?.getModel().uri, codemapperUri)) {
             try {
-                if (!(await this.fileService.exists(context.codemapperUri))) {
-                    await this.fileService.writeFile(context.codemapperUri, VSBuffer.fromString(''));
+                const editorPane = await this.editorService.openEditor({ resource: codemapperUri });
+                const codeEditor = getCodeEditor(editorPane?.getControl());
+                if (codeEditor && codeEditor.hasModel()) {
+                    this.tryToRevealCodeBlock(codeEditor, context.code);
+                    activeEditorControl = codeEditor;
                 }
-                await this.editorService.openEditor({ resource: context.codemapperUri });
-                activeEditorControl = getEditableActiveCodeEditor(this.editorService);
-                if (activeEditorControl) {
-                    this.tryToRevealCodeBlock(activeEditorControl, context.code);
+                else {
+                    this.notify(( localize(4362, "Failed to open {0} in a code editor.", (codemapperUri.toString()))));
+                    return;
                 }
             }
             catch (e) {
-                this.logService.info('[ApplyCodeBlockOperation] error opening code mapper file', context.codemapperUri, e);
+                this.logService.info('[ApplyCodeBlockOperation] error opening code mapper file', codemapperUri, e);
+                return;
             }
         }
         let result = undefined;
         if (activeEditorControl) {
-            await this.handleTextEditor(activeEditorControl, context);
+            result = await this.handleTextEditor(activeEditorControl, context.code);
         }
         else {
             const activeNotebookEditor = getActiveNotebookEditor(this.editorService);
             if (activeNotebookEditor) {
-                result = await this.handleNotebookEditor(activeNotebookEditor, context);
+                result = await this.handleNotebookEditor(activeNotebookEditor, context.code);
             }
             else {
-                this.notify(( localize(4284, "To apply this code block, open a code or notebook editor.")));
+                this.notify(( localize(4363, "To apply this code block, open a code or notebook editor.")));
             }
         }
         notifyUserAction(this.chatService, context, {
@@ -154,107 +155,143 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
             codeBlockIndex: context.codeBlockIndex,
             totalCharacters: context.code.length,
             codeMapper: result?.codeMapper,
-            editsProposed: !!result?.edits,
+            editsProposed: !!result?.editsProposed
         });
     }
-    async handleNotebookEditor(notebookEditor, codeBlockContext) {
+    async evaluateURIToUse(resource, activeEditorControl) {
+        if (resource && (await this.fileService.exists(resource))) {
+            return resource;
+        }
+        const activeEditorOption = activeEditorControl?.getModel().uri ? { label: ( localize(
+            4364,
+            "Active editor '{0}'",
+            this.labelService.getUriLabel(activeEditorControl.getModel().uri, { relative: true })
+        )), id: 'activeEditor' } : undefined;
+        const untitledEditorOption = { label: ( localize(4365, "New untitled editor")), id: 'newUntitledFile' };
+        const options = [];
+        if (resource) {
+            options.push({ label: ( localize(
+                4366,
+                "New file '{0}'",
+                this.labelService.getUriLabel(resource, { relative: true })
+            )), id: 'createFile' });
+            options.push(untitledEditorOption);
+            if (activeEditorOption) {
+                options.push(activeEditorOption);
+            }
+        }
+        else {
+            if (activeEditorOption) {
+                options.push(activeEditorOption);
+            }
+            options.push(untitledEditorOption);
+        }
+        const selected = options.length > 1 ? await this.quickInputService.pick(options, { placeHolder: ( localize(4367, "Select where to apply the code block")) }) : options[0];
+        if (selected) {
+            switch (selected.id) {
+                case 'createFile':
+                    if (resource) {
+                        try {
+                            await this.fileService.writeFile(resource, VSBuffer.fromString(''));
+                        }
+                        catch (error) {
+                            this.notify(( localize(4368, "Failed to create file: {0}", error.message)));
+                            return ( URI.from({ scheme: 'untitled', path: resource.path }));
+                        }
+                    }
+                    return resource;
+                case 'newUntitledFile':
+                    return ( URI.from({ scheme: 'untitled', path: resource ? resource.path : 'Untitled-1' }));
+                case 'activeEditor':
+                    return activeEditorControl?.getModel().uri;
+            }
+        }
+        return undefined;
+    }
+    async handleNotebookEditor(notebookEditor, code) {
         if (notebookEditor.isReadOnly) {
-            this.notify(( localize(4285, "Cannot apply code block to read-only notebook editor.")));
+            this.notify(( localize(4369, "Cannot apply code block to read-only notebook editor.")));
             return undefined;
         }
         const focusRange = notebookEditor.getFocus();
         const next = Math.max(focusRange.end - 1, 0);
-        insertCell(this.languageService, notebookEditor, next, CellKind.Code, 'below', codeBlockContext.code, true);
+        insertCell(this.languageService, notebookEditor, next, CellKind.Code, 'below', code, true);
         return undefined;
     }
-    async handleTextEditor(codeEditor, codeBlockContext) {
-        if (isReadOnly(codeEditor.getModel(), this.textFileService)) {
-            this.notify(( localize(4286, "Cannot apply code block to read-only file.")));
+    async handleTextEditor(codeEditor, code) {
+        const activeModel = codeEditor.getModel();
+        if (isReadOnly(activeModel, this.textFileService)) {
+            this.notify(( localize(4370, "Cannot apply code block to read-only file.")));
+            return undefined;
+        }
+        const codeBlock = { code, resource: activeModel.uri, markdownBeforeBlock: undefined };
+        const codeMapper = this.codeMapperService.providers[0]?.displayName;
+        if (!codeMapper) {
+            this.notify(( localize(4371, "No code mapper available.")));
             return undefined;
         }
-        const result = await this.computeEdits(codeEditor, codeBlockContext);
-        if (result.edits) {
-            const showWithPreview = await this.applyWithInlinePreview(result.edits, codeEditor);
-            if (!showWithPreview) {
-                await this.bulkEditService.apply(result.edits, { showPreview: true });
-                const activeModel = codeEditor.getModel();
-                this.codeEditorService.listCodeEditors().find(editor => editor.getModel()?.uri.toString() === ( activeModel.uri.toString()))?.focus();
+        let editsProposed = false;
+        const cancellationTokenSource = ( new CancellationTokenSource());
+        try {
+            const iterable = await this.progressService.withProgress({ location: ProgressLocation.Notification, delay: 500, sticky: true, cancellable: true }, async (progress) => {
+                progress.report({ message: ( localize(4372, "Applying code block using {0}...", codeMapper)) });
+                const editsIterable = this.getEdits(codeBlock, cancellationTokenSource.token);
+                return await this.waitForFirstElement(editsIterable);
+            }, () => cancellationTokenSource.cancel());
+            editsProposed = await this.applyWithInlinePreview(iterable, codeEditor, cancellationTokenSource);
+        }
+        catch (e) {
+            if (!isCancellationError(e)) {
+                this.notify(( localize(4373, "Failed to apply code block: {0}", e.message)));
             }
         }
-        return result;
+        finally {
+            cancellationTokenSource.dispose();
+        }
+        return {
+            editsProposed,
+            codeMapper
+        };
     }
-    async computeEdits(codeEditor, codeBlockActionContext) {
-        const activeModel = codeEditor.getModel();
-        const mappedEditsProviders = this.languageFeaturesService.mappedEditsProvider.ordered(activeModel);
-        if (mappedEditsProviders.length > 0) {
-            const docRefs = [];
-            collectDocumentContextFromSelections(codeEditor, docRefs);
-            collectDocumentContextFromContext(codeBlockActionContext, docRefs);
-            const cancellationTokenSource = ( new CancellationTokenSource());
-            let codeMapper;
-            try {
-                const result = await this.progressService.withProgress({ location: ProgressLocation.Notification, delay: 500, sticky: true, cancellable: true }, async (progress) => {
-                    for (const provider of mappedEditsProviders) {
-                        codeMapper = provider.displayName;
-                        progress.report({ message: ( localize(4287, "Applying code block using {0}...", codeMapper)) });
-                        const mappedEdits = await provider.provideMappedEdits(activeModel, [codeBlockActionContext.code], {
-                            documents: docRefs,
-                            conversation: getChatConversation(codeBlockActionContext),
-                        }, cancellationTokenSource.token);
-                        if (mappedEdits) {
-                            return { edits: mappedEdits.edits, codeMapper };
-                        }
-                    }
-                    return undefined;
-                }, () => cancellationTokenSource.cancel());
-                if (result) {
-                    return result;
-                }
-            }
-            catch (e) {
-                if (!isCancellationError(e)) {
-                    this.notify(( localize(4288, "Failed to apply code block: {0}", e.message)));
+    getEdits(codeBlock, token) {
+        return ( new AsyncIterableObject(async (executor) => {
+            const request = {
+                codeBlocks: [codeBlock]
+            };
+            const response = {
+                textEdit: (target, edit) => {
+                    executor.emitOne(edit);
                 }
+            };
+            const result = await this.codeMapperService.mapCode(request, response, token);
+            if (result?.errorMessage) {
+                executor.reject(( new Error(result.errorMessage)));
             }
-            finally {
-                cancellationTokenSource.dispose();
-            }
-            return { edits: [], codeMapper };
-        }
-        return { edits: [], codeMapper: undefined };
+        }));
     }
-    async applyWithInlinePreview(edits, codeEditor) {
-        const firstEdit = edits[0];
-        if (!ResourceTextEdit.is(firstEdit)) {
-            return false;
-        }
-        const resource = firstEdit.resource;
-        const textEdits = coalesce(( edits.map(
-            edit => ResourceTextEdit.is(edit) && isEqual(resource, edit.resource) ? edit.textEdit : undefined
-        )));
-        if (textEdits.length !== edits.length) {
-            return false;
+    async waitForFirstElement(iterable) {
+        const iterator = iterable[Symbol.asyncIterator]();
+        let result = await iterator.next();
+        if (result.done) {
+            return {
+                async *[Symbol.asyncIterator]() {
+                    return;
+                }
+            };
         }
-        const editorToApply = await this.codeEditorService.openCodeEditor({ resource }, codeEditor);
-        if (editorToApply) {
-            const inlineChatController = InlineChatController.get(editorToApply);
-            if (inlineChatController) {
-                const tokenSource = ( new CancellationTokenSource());
-                let isOpen = true;
-                const firstEdit = textEdits[0];
-                editorToApply.revealLineInCenterIfOutsideViewport(firstEdit.range.startLineNumber);
-                const promise = inlineChatController.reviewEdits(textEdits[0].range, AsyncIterableObject.fromArray([textEdits]), tokenSource.token);
-                promise.finally(() => {
-                    isOpen = false;
-                    tokenSource.dispose();
-                });
-                this.inlineChatPreview = {
-                    promise,
-                    isOpen: () => isOpen,
-                    cancel: () => tokenSource.cancel(),
-                };
-                return true;
+        return {
+            async *[Symbol.asyncIterator]() {
+                while (!result.done) {
+                    yield result.value;
+                    result = await iterator.next();
+                }
             }
+        };
+    }
+    async applyWithInlinePreview(edits, codeEditor, tokenSource) {
+        const inlineChatController = InlineChatController.get(codeEditor);
+        if (inlineChatController) {
+            return inlineChatController.reviewEdits(edits, tokenSource.token);
         }
         return false;
     }
@@ -274,15 +311,15 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
 ApplyCodeBlockOperation = ( __decorate([
     ( __param(0, IEditorService)),
     ( __param(1, ITextFileService)),
-    ( __param(2, IBulkEditService)),
-    ( __param(3, ICodeEditorService)),
-    ( __param(4, IChatService)),
-    ( __param(5, ILanguageFeaturesService)),
-    ( __param(6, IProgressService)),
-    ( __param(7, ILanguageService)),
-    ( __param(8, IFileService)),
-    ( __param(9, IDialogService)),
-    ( __param(10, ILogService))
+    ( __param(2, IChatService)),
+    ( __param(3, ILanguageService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, ILogService)),
+    ( __param(7, ICodeMapperService)),
+    ( __param(8, IProgressService)),
+    ( __param(9, IQuickInputService)),
+    ( __param(10, ILabelService))
 ], ApplyCodeBlockOperation));
 function notifyUserAction(chatService, context, action) {
     if (isResponseVM(context.element)) {
@@ -311,60 +348,24 @@ function getEditableActiveCodeEditor(editorService) {
     if (activeCodeEditorInNotebook && activeCodeEditorInNotebook.hasTextFocus() && activeCodeEditorInNotebook.hasModel()) {
         return activeCodeEditorInNotebook;
     }
-    let activeEditorControl = editorService.activeTextEditorControl;
-    if (isDiffEditor(activeEditorControl)) {
-        activeEditorControl = activeEditorControl.getOriginalEditor().hasTextFocus() ? activeEditorControl.getOriginalEditor() : activeEditorControl.getModifiedEditor();
-    }
-    if (!isCodeEditor(activeEditorControl)) {
-        return undefined;
+    let codeEditor = getCodeEditor(editorService.activeTextEditorControl);
+    if (!codeEditor) {
+        for (const editor of editorService.visibleTextEditorControls) {
+            codeEditor = getCodeEditor(editor);
+            if (codeEditor) {
+                break;
+            }
+        }
     }
-    if (!activeEditorControl.hasModel()) {
+    if (!codeEditor || !codeEditor.hasModel()) {
         return undefined;
     }
-    return activeEditorControl;
+    return codeEditor;
 }
 function isReadOnly(model, textFileService) {
     const activeTextModel = textFileService.files.get(model.uri) ?? textFileService.untitled.get(model.uri);
     return !!activeTextModel?.isReadonly();
 }
-function collectDocumentContextFromSelections(codeEditor, result) {
-    const activeModel = codeEditor.getModel();
-    const currentDocUri = activeModel.uri;
-    const currentDocVersion = activeModel.getVersionId();
-    const selections = codeEditor.getSelections();
-    if (selections.length > 0) {
-        result.push([
-            {
-                uri: currentDocUri,
-                version: currentDocVersion,
-                ranges: selections,
-            }
-        ]);
-    }
-}
-function collectDocumentContextFromContext(context, result) {
-    if (isResponseVM(context.element) && context.element.usedContext?.documents) {
-        result.push(context.element.usedContext.documents);
-    }
-}
-function getChatConversation(context) {
-    if (isResponseVM(context.element)) {
-        return [{
-                type: 'response',
-                message: context.element.response.getMarkdown(),
-                references: getReferencesAsDocumentContext(context.element.contentReferences)
-            }];
-    }
-    else if (isRequestVM(context.element)) {
-        return [{
-                type: 'request',
-                message: context.element.messageText,
-            }];
-    }
-    else {
-        return [];
-    }
-}
 function reindent(codeBlockContent, model, seletionStartLine) {
     const newContent = splitLines(codeBlockContent);
     if (newContent.length === 0) {