@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -4,14 +4,14 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { IChatTransferService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatTransferService.service';
 
 let ChatTransferContribution = class ChatTransferContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.chatTransfer'; }
+    static {
+        this.ID = "workbench.contrib.chatTransfer";
+    }
     constructor(chatTransferService) {
         super();
         chatTransferService.checkAndSetTransferredWorkspaceTrust();
     }
 };
-ChatTransferContribution = ( __decorate([
-    ( __param(0, IChatTransferService))
-], ChatTransferContribution));
+ChatTransferContribution = ( __decorate([( __param(0, IChatTransferService))], ChatTransferContribution));
 
 export { ChatTransferContribution };

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

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { AsyncIterableObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { AsyncIterableProducer } 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';
 import { CharCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
@@ -28,7 +28,7 @@ import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
 import { IAiEditTelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/telemetry/aiEditTelemetry/aiEditTelemetryService.service';
 import { reviewEdits, reviewNotebookEdits } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { insertCell } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/controller/cellOperations';
+import { insertCell } from '@codingame/monaco-vscode-api/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 { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 import { ICodeMapperService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.service';
@@ -36,7 +36,16 @@ import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { isResponseVM, isRequestVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
 
 let InsertCodeBlockOperation = class InsertCodeBlockOperation {
-    constructor(editorService, textFileService, bulkEditService, codeEditorService, chatService, languageService, dialogService, aiEditTelemetryService) {
+    constructor(
+        editorService,
+        textFileService,
+        bulkEditService,
+        codeEditorService,
+        chatService,
+        languageService,
+        dialogService,
+        aiEditTelemetryService
+    ) {
         this.editorService = editorService;
         this.textFileService = textFileService;
         this.bulkEditService = bulkEditService;
@@ -50,15 +59,13 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
         const activeEditorControl = getEditableActiveCodeEditor(this.editorService);
         if (activeEditorControl) {
             await this.handleTextEditor(activeEditorControl, context);
-        }
-        else {
+        } else {
             const activeNotebookEditor = getActiveNotebookEditor(this.editorService);
             if (activeNotebookEditor) {
                 await this.handleNotebookEditor(activeNotebookEditor, context);
-            }
-            else {
+            } else {
                 this.notify(( localize(
-                    4831,
+                    4873,
                     "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."
                 )));
             }
@@ -67,47 +74,58 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
             const requestId = context.element.requestId;
             const request = context.element.session.getItems().find(item => item.id === requestId && isRequestVM(item));
             notifyUserAction(this.chatService, context, {
-                kind: 'insert',
+                kind: "insert",
                 codeBlockIndex: context.codeBlockIndex,
                 totalCharacters: context.code.length,
-                totalLines: context.code.split('\n').length,
+                totalLines: context.code.split("\n").length,
                 languageId: context.languageId,
-                modelId: request?.modelId ?? '',
+                modelId: request?.modelId ?? ""
             });
             const codeBlockInfo = context.element.model.codeBlockInfos?.at(context.codeBlockIndex);
             this.aiEditTelemetryService.handleCodeAccepted({
-                acceptanceMethod: 'insertAtCursor',
+                acceptanceMethod: "insertAtCursor",
                 suggestionId: codeBlockInfo?.suggestionId,
                 editDeltaInfo: EditDeltaInfo.fromText(context.code),
-                feature: 'sideBarChat',
+                feature: "sideBarChat",
                 languageId: context.languageId,
                 modeId: context.element.model.request?.modeInfo?.modeId,
                 modelId: request?.modelId,
-                presentation: 'codeBlock',
+                presentation: "codeBlock",
                 applyCodeBlockSuggestionId: undefined,
-                source: undefined,
+                source: undefined
             });
         }
     }
     async handleNotebookEditor(notebookEditor, codeBlockContext) {
         if (notebookEditor.isReadOnly) {
-            this.notify(( localize(4832, "Cannot insert the code block to read-only notebook editor.")));
+            this.notify(( localize(4874, "Cannot insert the code block to read-only notebook editor.")));
             return false;
         }
         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",
+            codeBlockContext.code,
+            true
+        );
         return true;
     }
     async handleTextEditor(codeEditor, codeBlockContext) {
         const activeModel = codeEditor.getModel();
         if (isReadOnly(activeModel, this.textFileService)) {
-            this.notify(( localize(4833, "Cannot insert the code block to read-only code editor.")));
+            this.notify(( localize(4875, "Cannot insert the code block to read-only code editor.")));
             return false;
         }
         const range = codeEditor.getSelection() ?? ( new Range(activeModel.getLineCount(), 1, activeModel.getLineCount(), 1));
         const text = reindent(codeBlockContext.code, activeModel, range.startLineNumber);
-        const edits = [( new ResourceTextEdit(activeModel.uri, { range, text }))];
+        const edits = [( new ResourceTextEdit(activeModel.uri, {
+            range,
+            text
+        }))];
         await this.bulkEditService.apply(edits);
         this.codeEditorService.listCodeEditors().find(editor => editor.getModel()?.uri.toString() === ( activeModel.uri.toString()))?.focus();
         return true;
@@ -116,18 +134,22 @@ let InsertCodeBlockOperation = class InsertCodeBlockOperation {
         this.dialogService.info(message);
     }
 };
-InsertCodeBlockOperation = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, ITextFileService)),
-    ( __param(2, IBulkEditService)),
-    ( __param(3, ICodeEditorService)),
-    ( __param(4, IChatService)),
-    ( __param(5, ILanguageService)),
-    ( __param(6, IDialogService)),
-    ( __param(7, IAiEditTelemetryService))
-], InsertCodeBlockOperation));
+InsertCodeBlockOperation = ( __decorate([( __param(0, IEditorService)), ( __param(1, ITextFileService)), ( __param(2, IBulkEditService)), ( __param(3, ICodeEditorService)), ( __param(4, IChatService)), ( __param(5, ILanguageService)), ( __param(6, IDialogService)), ( __param(7, IAiEditTelemetryService))], InsertCodeBlockOperation));
 let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
-    constructor(editorService, textFileService, chatService, fileService, dialogService, logService, codeMapperService, progressService, quickInputService, labelService, instantiationService, notebookService) {
+    constructor(
+        editorService,
+        textFileService,
+        chatService,
+        fileService,
+        dialogService,
+        logService,
+        codeMapperService,
+        progressService,
+        quickInputService,
+        labelService,
+        instantiationService,
+        notebookService
+    ) {
         this.editorService = editorService;
         this.textFileService = textFileService;
         this.chatService = chatService;
@@ -149,19 +171,23 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         }
         if (codemapperUri && !isEqual(activeEditorControl?.getModel().uri, codemapperUri) && !this.notebookService.hasSupportedNotebooks(codemapperUri)) {
             try {
-                const editorPane = await this.editorService.openEditor({ resource: codemapperUri });
+                const editorPane = await this.editorService.openEditor({
+                    resource: codemapperUri
+                });
                 const codeEditor = getCodeEditor(editorPane?.getControl());
                 if (codeEditor && codeEditor.hasModel()) {
                     this.tryToRevealCodeBlock(codeEditor, context.code);
                     activeEditorControl = codeEditor;
-                }
-                else {
-                    this.notify(( localize(4834, "Failed to open {0} in a code editor.", (codemapperUri.toString()))));
+                } else {
+                    this.notify(( localize(4876, "Failed to open {0} in a code editor.", (codemapperUri.toString()))));
                     return;
                 }
-            }
-            catch (e) {
-                this.logService.info('[ApplyCodeBlockOperation] error opening code mapper file', codemapperUri, e);
+            } catch (e) {
+                this.logService.info(
+                    "[ApplyCodeBlockOperation] error opening code mapper file",
+                    codemapperUri,
+                    e
+                );
                 return;
             }
         }
@@ -174,29 +200,32 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         }
         let result = undefined;
         if (activeEditorControl && !this.notebookService.hasSupportedNotebooks(codemapperUri)) {
-            result = await this.handleTextEditor(activeEditorControl, context.chatSessionResource, context.code, codeBlockSuggestionId);
-        }
-        else {
+            result = await this.handleTextEditor(
+                activeEditorControl,
+                context.chatSessionResource,
+                context.code,
+                codeBlockSuggestionId
+            );
+        } else {
             const activeNotebookEditor = getActiveNotebookEditor(this.editorService);
             if (activeNotebookEditor) {
                 result = await this.handleNotebookEditor(activeNotebookEditor, context.chatSessionResource, context.code);
-            }
-            else {
-                this.notify(( localize(4835, "To apply this code block, open a code or notebook editor.")));
+            } else {
+                this.notify(( localize(4877, "To apply this code block, open a code or notebook editor.")));
             }
         }
         if (isResponseVM(context.element)) {
             const requestId = context.element.requestId;
             const request = context.element.session.getItems().find(item => item.id === requestId && isRequestVM(item));
             notifyUserAction(this.chatService, context, {
-                kind: 'apply',
+                kind: "apply",
                 codeBlockIndex: context.codeBlockIndex,
                 totalCharacters: context.code.length,
                 codeMapper: result?.codeMapper,
                 editsProposed: !!result?.editsProposed,
-                totalLines: context.code.split('\n').length,
-                modelId: request?.modelId ?? '',
-                languageId: context.languageId,
+                totalLines: context.code.split("\n").length,
+                modelId: request?.modelId ?? "",
+                languageId: context.languageId
             });
         }
     }
@@ -204,80 +233,104 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         if (resource && (await this.fileService.exists(resource))) {
             return resource;
         }
-        const activeEditorOption = activeEditorControl?.getModel().uri ? { label: ( localize(
-            4836,
-            "Active editor '{0}'",
-            this.labelService.getUriLabel(activeEditorControl.getModel().uri, { relative: true })
-        )), id: 'activeEditor' } : undefined;
-        const untitledEditorOption = { label: ( localize(4837, "New untitled editor")), id: 'newUntitledFile' };
+        const activeEditorOption = activeEditorControl?.getModel().uri ? {
+            label: ( localize(
+                4878,
+                "Active editor '{0}'",
+                this.labelService.getUriLabel(activeEditorControl.getModel().uri, {
+                    relative: true
+                })
+            )),
+            id: "activeEditor"
+        } : undefined;
+        const untitledEditorOption = {
+            label: ( localize(4879, "New untitled editor")),
+            id: "newUntitledFile"
+        };
         const options = [];
         if (resource) {
-            options.push({ label: ( localize(
-                4838,
-                "New file '{0}'",
-                this.labelService.getUriLabel(resource, { relative: true })
-            )), id: 'createFile' });
+            options.push({
+                label: ( localize(4880, "New file '{0}'", this.labelService.getUriLabel(resource, {
+                    relative: true
+                }))),
+                id: "createFile"
+            });
             options.push(untitledEditorOption);
             if (activeEditorOption) {
                 options.push(activeEditorOption);
             }
-        }
-        else {
+        } else {
             if (activeEditorOption) {
                 options.push(activeEditorOption);
             }
             options.push(untitledEditorOption);
         }
-        const selected = options.length > 1 ? await this.quickInputService.pick(options, { placeHolder: ( localize(4839, "Select where to apply the code block")) }) : options[0];
+        const selected = options.length > 1 ? await this.quickInputService.pick(options, {
+            placeHolder: ( localize(4881, "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(4840, "Failed to create file: {0}", error.message)));
-                            return ( URI.from({ scheme: 'untitled', path: resource.path }));
-                        }
+            case "createFile":
+                if (resource) {
+                    try {
+                        await this.fileService.writeFile(resource, VSBuffer.fromString(""));
+                    } catch (error) {
+                        this.notify(( localize(4882, "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 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, chatSessionResource, code) {
         if (notebookEditor.isReadOnly) {
-            this.notify(( localize(4841, "Cannot apply code block to read-only notebook editor.")));
+            this.notify(( localize(4883, "Cannot apply code block to read-only notebook editor.")));
             return undefined;
         }
         const uri = notebookEditor.textModel.uri;
-        const codeBlock = { code, resource: uri, markdownBeforeBlock: undefined };
+        const codeBlock = {
+            code,
+            resource: uri,
+            markdownBeforeBlock: undefined
+        };
         const codeMapper = this.codeMapperService.providers[0]?.displayName;
         if (!codeMapper) {
-            this.notify(( localize(4842, "No code mapper available.")));
+            this.notify(( localize(4884, "No code mapper available.")));
             return undefined;
         }
         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(4843, "Applying code block using {0}...", codeMapper)) });
+            const iterable = await this.progressService.withProgress({
+                location: ProgressLocation.Notification,
+                delay: 500,
+                sticky: true,
+                cancellable: true
+            }, async progress => {
+                progress.report({
+                    message: ( localize(4885, "Applying code block using {0}...", codeMapper))
+                });
                 const editsIterable = this.getNotebookEdits(codeBlock, chatSessionResource, cancellationTokenSource.token);
                 return await this.waitForFirstElement(editsIterable);
             }, () => cancellationTokenSource.cancel());
             editsProposed = await this.applyNotebookEditsWithInlinePreview(iterable, uri, cancellationTokenSource);
-        }
-        catch (e) {
+        } catch (e) {
             if (!isCancellationError(e)) {
-                this.notify(( localize(4844, "Failed to apply code block: {0}", e.message)));
+                this.notify(( localize(4886, "Failed to apply code block: {0}", e.message)));
             }
-        }
-        finally {
+        } finally {
             cancellationTokenSource.dispose();
         }
         return {
@@ -288,31 +341,41 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
     async handleTextEditor(codeEditor, chatSessionResource, code, applyCodeBlockSuggestionId) {
         const activeModel = codeEditor.getModel();
         if (isReadOnly(activeModel, this.textFileService)) {
-            this.notify(( localize(4845, "Cannot apply code block to read-only file.")));
+            this.notify(( localize(4887, "Cannot apply code block to read-only file.")));
             return undefined;
         }
-        const codeBlock = { code, resource: activeModel.uri, chatSessionResource, markdownBeforeBlock: undefined };
+        const codeBlock = {
+            code,
+            resource: activeModel.uri,
+            chatSessionResource,
+            markdownBeforeBlock: undefined
+        };
         const codeMapper = this.codeMapperService.providers[0]?.displayName;
         if (!codeMapper) {
-            this.notify(( localize(4842, "No code mapper available.")));
+            this.notify(( localize(4884, "No code mapper available.")));
             return undefined;
         }
         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(4843, "Applying code block using {0}...", codeMapper)) });
+            const iterable = await this.progressService.withProgress({
+                location: ProgressLocation.Notification,
+                delay: 500,
+                sticky: true,
+                cancellable: true
+            }, async progress => {
+                progress.report({
+                    message: ( localize(4885, "Applying code block using {0}...", codeMapper))
+                });
                 const editsIterable = this.getTextEdits(codeBlock, chatSessionResource, cancellationTokenSource.token);
                 return await this.waitForFirstElement(editsIterable);
             }, () => cancellationTokenSource.cancel());
             editsProposed = await this.applyWithInlinePreview(iterable, codeEditor, cancellationTokenSource, applyCodeBlockSuggestionId);
-        }
-        catch (e) {
+        } catch (e) {
             if (!isCancellationError(e)) {
-                this.notify(( localize(4844, "Failed to apply code block: {0}", e.message)));
+                this.notify(( localize(4886, "Failed to apply code block: {0}", e.message)));
             }
-        }
-        finally {
+        } finally {
             cancellationTokenSource.dispose();
         }
         return {
@@ -321,17 +384,16 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         };
     }
     getTextEdits(codeBlock, chatSessionResource, token) {
-        return ( new AsyncIterableObject(async (executor) => {
+        return ( new AsyncIterableProducer(async executor => {
             const request = {
                 codeBlocks: [codeBlock],
-                chatSessionResource,
+                chatSessionResource
             };
             const response = {
                 textEdit: (target, edit) => {
                     executor.emitOne(edit);
                 },
-                notebookEdit(_resource, _edit) {
-                },
+                notebookEdit(_resource, _edit) {}
             };
             const result = await this.codeMapperService.mapCode(request, response, token);
             if (result?.errorMessage) {
@@ -340,11 +402,11 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         }));
     }
     getNotebookEdits(codeBlock, chatSessionResource, token) {
-        return ( new AsyncIterableObject(async (executor) => {
+        return ( new AsyncIterableProducer(async executor => {
             const request = {
                 codeBlocks: [codeBlock],
                 chatSessionResource,
-                location: 'panel'
+                location: "panel"
             };
             const response = {
                 textEdit: (target, edits) => {
@@ -352,7 +414,7 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
                 },
                 notebookEdit(_resource, edit) {
                     executor.emitOne(edit);
-                },
+                }
             };
             const result = await this.codeMapperService.mapCode(request, response, token);
             if (result?.errorMessage) {
@@ -380,7 +442,13 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         };
     }
     async applyWithInlinePreview(edits, codeEditor, tokenSource, applyCodeBlockSuggestionId) {
-        return this.instantiationService.invokeFunction(reviewEdits, codeEditor, edits, tokenSource.token, applyCodeBlockSuggestionId);
+        return this.instantiationService.invokeFunction(
+            reviewEdits,
+            codeEditor,
+            edits,
+            tokenSource.token,
+            applyCodeBlockSuggestionId
+        );
     }
     async applyNotebookEditsWithInlinePreview(edits, uri, tokenSource) {
         return this.instantiationService.invokeFunction(reviewNotebookEdits, uri, edits, tokenSource.token);
@@ -388,7 +456,10 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
     tryToRevealCodeBlock(codeEditor, codeBlock) {
         const match = codeBlock.match(/(\S[^\n]*)\n/);
         if (match && match[1].length > 10) {
-            const findMatch = codeEditor.getModel().findNextMatch(match[1], { lineNumber: 1, column: 1 }, false, false, null, false);
+            const findMatch = codeEditor.getModel().findNextMatch(match[1], {
+                lineNumber: 1,
+                column: 1
+            }, false, false, null, false);
             if (findMatch) {
                 codeEditor.revealRangeInCenter(findMatch.range);
             }
@@ -398,20 +469,7 @@ let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
         this.dialogService.info(message);
     }
 };
-ApplyCodeBlockOperation = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, ITextFileService)),
-    ( __param(2, IChatService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IDialogService)),
-    ( __param(5, ILogService)),
-    ( __param(6, ICodeMapperService)),
-    ( __param(7, IProgressService)),
-    ( __param(8, IQuickInputService)),
-    ( __param(9, ILabelService)),
-    ( __param(10, IInstantiationService)),
-    ( __param(11, INotebookService))
-], ApplyCodeBlockOperation));
+ApplyCodeBlockOperation = ( __decorate([( __param(0, IEditorService)), ( __param(1, ITextFileService)), ( __param(2, IChatService)), ( __param(3, IFileService)), ( __param(4, IDialogService)), ( __param(5, ILogService)), ( __param(6, ICodeMapperService)), ( __param(7, IProgressService)), ( __param(8, IQuickInputService)), ( __param(9, ILabelService)), ( __param(10, IInstantiationService)), ( __param(11, INotebookService))], ApplyCodeBlockOperation));
 function notifyUserAction(chatService, context, action) {
     if (isResponseVM(context.element)) {
         chatService.notifyUserAction({
@@ -476,12 +534,15 @@ function reindent(codeBlockContent, model, seletionStartLine) {
     }
     const newLines = [];
     for (let i = 0; i < newContent.length; i++) {
-        const { level, length } = indents[i];
+        const {
+            level,
+            length
+        } = indents[i];
         const newLevel = Math.max(0, codeIndentLevel + level - newContentIndentLevel);
-        const newIndentation = formattingOptions.insertSpaces ? ' '.repeat(formattingOptions.tabSize * newLevel) : '\t'.repeat(newLevel);
+        const newIndentation = formattingOptions.insertSpaces ? " ".repeat(formattingOptions.tabSize * newLevel) : "\t".repeat(newLevel);
         newLines.push(newIndentation + newContent[i].substring(length));
     }
-    return newLines.join('\n');
+    return newLines.join("\n");
 }
 function computeIndentation(line, tabSize) {
     let nSpaces = 0;
@@ -498,18 +559,19 @@ function computeIndentation(line, tabSize) {
                 nSpaces = 0;
                 length = i + 1;
             }
-        }
-        else if (chCode === CharCode.Tab) {
+        } else if (chCode === CharCode.Tab) {
             level++;
             nSpaces = 0;
             length = i + 1;
-        }
-        else {
+        } else {
             break;
         }
         i++;
     }
-    return { level, length };
+    return {
+        level,
+        length
+    };
 }
 
 export { ApplyCodeBlockOperation, InsertCodeBlockOperation, computeIndentation };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentSessions.contribution.d.ts

@@ -1 +1 @@
-export {};
+