@codingame/monaco-vscode-chat-service-override 15.0.2 → 16.0.0

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

@@ -0,0 +1,578 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { debouncedObservable, observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { LineRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/lineRange';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { nullDocumentDiff } from '../../../../../../editor/common/diff/documentDiffProvider.js';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { NotebookDeletedCellDecorator } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookDeletedCellDecorator';
+import { NotebookInsertedCellDecorator } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookInsertedCellDecorator';
+import { NotebookModifiedCellDecorator } from '../../../../notebook/browser/diff/inlineDiff/notebookModifiedCellDecorator.js';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { CellKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatEditingCodeEditorIntegration } from '../chatEditingCodeEditorIntegration.js';
+import { sortCellChanges, countChanges } from './notebookCellChanges.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+let ChatEditingNotebookEditorIntegration = class ChatEditingNotebookEditorIntegration extends Disposable {
+    constructor(_entry, editor, notebookModel, originalModel, cellChanges, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        const notebookEditor = getNotebookEditorFromEditorPane(editor);
+        assertType(notebookEditor);
+        this.notebookEditor = notebookEditor;
+        this.integration = this.instantiationService.createInstance(ChatEditingNotebookEditorWidgetIntegration, _entry, notebookEditor, notebookModel, originalModel, cellChanges);
+        this._register(editor.onDidChangeControl(() => {
+            const notebookEditor = getNotebookEditorFromEditorPane(editor);
+            if (notebookEditor && notebookEditor !== this.notebookEditor) {
+                this.notebookEditor = notebookEditor;
+                this.integration.dispose();
+                this.integration = this.instantiationService.createInstance(ChatEditingNotebookEditorWidgetIntegration, _entry, notebookEditor, notebookModel, originalModel, cellChanges);
+            }
+        }));
+    }
+    get currentIndex() {
+        return this.integration.currentIndex;
+    }
+    reveal(firstOrLast) {
+        return this.integration.reveal(firstOrLast);
+    }
+    next(wrap) {
+        return this.integration.next(wrap);
+    }
+    previous(wrap) {
+        return this.integration.previous(wrap);
+    }
+    enableAccessibleDiffView() {
+        this.integration.enableAccessibleDiffView();
+    }
+    acceptNearestChange(change) {
+        this.integration.acceptNearestChange(change);
+    }
+    rejectNearestChange(change) {
+        this.integration.rejectNearestChange(change);
+    }
+    toggleDiff(change) {
+        return this.integration.toggleDiff(change);
+    }
+    dispose() {
+        this.integration.dispose();
+        super.dispose();
+    }
+};
+ChatEditingNotebookEditorIntegration = ( __decorate([
+    ( __param(5, IInstantiationService))
+], ChatEditingNotebookEditorIntegration));
+let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditorWidgetIntegration extends Disposable {
+    constructor(_entry, notebookEditor, notebookModel, originalModel, cellChanges, instantiationService, _editorService, _chatAgentService, notebookEditorService, accessibilitySignalService) {
+        super();
+        this._entry = _entry;
+        this.notebookEditor = notebookEditor;
+        this.notebookModel = notebookModel;
+        this.cellChanges = cellChanges;
+        this.instantiationService = instantiationService;
+        this._editorService = _editorService;
+        this._chatAgentService = _chatAgentService;
+        this.accessibilitySignalService = accessibilitySignalService;
+        this._currentIndex = observableValue(this, -1);
+        this.currentIndex = this._currentIndex;
+        this._currentChange = observableValue(this, undefined);
+        this.currentChange = this._currentChange;
+        this.cellEditorIntegrations = ( new Map());
+        this.mdCellEditorAttached = observableValue(this, -1);
+        this.markupCellListeners = ( new Map());
+        const onDidChangeVisibleRanges = debouncedObservable(observableFromEvent(notebookEditor.onDidChangeVisibleRanges, () => notebookEditor.visibleRanges), 50);
+        this._register(toDisposable(() => {
+            this.markupCellListeners.forEach((v) => v.dispose());
+        }));
+        let originalReadonly = undefined;
+        const shouldBeReadonly = ( _entry.isCurrentlyBeingModifiedBy.map(value => !!value));
+        this._register(autorun(r => {
+            const isReadOnly = shouldBeReadonly.read(r);
+            const notebookEditor = notebookEditorService.retrieveExistingWidgetFromURI(_entry.modifiedURI)?.value;
+            if (!notebookEditor) {
+                return;
+            }
+            originalReadonly ??= notebookEditor.isReadOnly;
+            if (isReadOnly) {
+                notebookEditor.setOptions({ isReadOnly: true });
+            }
+            else if (originalReadonly === false) {
+                notebookEditor.setOptions({ isReadOnly: false });
+                const timeout = setTimeout(() => {
+                    notebookEditor.setOptions({ isReadOnly: true });
+                    notebookEditor.setOptions({ isReadOnly: false });
+                    disposable.dispose();
+                }, 100);
+                const disposable = toDisposable(() => clearTimeout(timeout));
+                this._register(disposable);
+            }
+        }));
+        let lastModifyingRequestId;
+        this._store.add(autorun(r => {
+            if (!_entry.isCurrentlyBeingModifiedBy.read(r)
+                && !_entry.isProcessingResponse.read(r)
+                && lastModifyingRequestId !== _entry.lastModifyingRequestId
+                && ( cellChanges.read(r).some(c => c.type !== 'unchanged' && !c.diff.read(r).identical))) {
+                lastModifyingRequestId = _entry.lastModifyingRequestId;
+                this.reveal(true);
+            }
+        }));
+        this._register(autorun(r => {
+            if (this.notebookEditor.textModel !== this.notebookModel) {
+                return;
+            }
+            const sortedCellChanges = sortCellChanges(cellChanges.read(r));
+            const changes = sortedCellChanges.filter(c => c.type !== 'delete');
+            onDidChangeVisibleRanges.read(r);
+            if (!changes.length) {
+                this.cellEditorIntegrations.forEach(({ diff }) => {
+                    diff.set({ ...diff.get(), ...nullDocumentDiff }, undefined);
+                });
+                return;
+            }
+            this.mdCellEditorAttached.read(r);
+            const validCells = ( new Set());
+            changes.forEach((change) => {
+                if (change.modifiedCellIndex === undefined || change.modifiedCellIndex >= notebookModel.cells.length) {
+                    return;
+                }
+                const cell = notebookModel.cells[change.modifiedCellIndex];
+                const editor = notebookEditor.codeEditors.find(([vm,]) => vm.handle === notebookModel.cells[change.modifiedCellIndex].handle)?.[1];
+                const modifiedModel = change.modifiedModel.promiseResult.read(r)?.data;
+                const originalModel = change.originalModel.promiseResult.read(r)?.data;
+                if (!cell || !originalModel || !modifiedModel) {
+                    return;
+                }
+                if (!editor) {
+                    if (!( this.markupCellListeners.has(cell.handle)) && cell.cellKind === CellKind.Markup) {
+                        const cellModel = this.notebookEditor.getViewModel()?.viewCells.find(c => c.handle === cell.handle);
+                        if (cellModel) {
+                            const listener = cellModel.onDidChangeEditorAttachState(() => {
+                                if (cellModel.editorAttached) {
+                                    this.mdCellEditorAttached.set(cell.handle, undefined);
+                                    listener.dispose();
+                                    this.markupCellListeners.delete(cell.handle);
+                                }
+                            });
+                            this.markupCellListeners.set(cell.handle, listener);
+                        }
+                    }
+                    return;
+                }
+                const diff = {
+                    ...change.diff.read(r),
+                    modifiedModel,
+                    originalModel,
+                    keep: change.keep,
+                    undo: change.undo
+                };
+                validCells.add(cell);
+                const currentDiff = this.cellEditorIntegrations.get(cell);
+                if (currentDiff) {
+                    if (!areDocumentDiff2Equal(currentDiff.diff.get(), diff)) {
+                        currentDiff.diff.set(diff, undefined);
+                    }
+                }
+                else {
+                    const diff2 = observableValue(`diff${cell.handle}`, diff);
+                    const integration = this.instantiationService.createInstance(ChatEditingCodeEditorIntegration, _entry, editor, diff2);
+                    this.cellEditorIntegrations.set(cell, { integration, diff: diff2 });
+                    this._register(integration);
+                    this._register(editor.onDidDispose(() => {
+                        this.cellEditorIntegrations.get(cell)?.integration.dispose();
+                        this.cellEditorIntegrations.delete(cell);
+                    }));
+                    this._register(editor.onDidChangeModel(() => {
+                        if (editor.getModel() !== cell.textModel) {
+                            this.cellEditorIntegrations.get(cell)?.integration.dispose();
+                            this.cellEditorIntegrations.delete(cell);
+                        }
+                    }));
+                }
+            });
+            this.cellEditorIntegrations.forEach((v, cell) => {
+                if (!( validCells.has(cell))) {
+                    v.integration.dispose();
+                    this.cellEditorIntegrations.delete(cell);
+                }
+            });
+        }));
+        this._register(autorun(r => {
+            const currentChange = this.currentChange.read(r);
+            if (!currentChange) {
+                this._currentIndex.set(-1, undefined);
+                return;
+            }
+            let index = 0;
+            const sortedCellChanges = sortCellChanges(cellChanges.read(r));
+            for (const change of sortedCellChanges) {
+                if (currentChange && currentChange.change === change) {
+                    if (change.type === 'modified') {
+                        index += currentChange.index;
+                    }
+                    break;
+                }
+                if (change.type === 'insert' || change.type === 'delete') {
+                    index++;
+                }
+                else if (change.type === 'modified') {
+                    index += change.diff.read(r).changes.length;
+                }
+            }
+            this._currentIndex.set(index, undefined);
+        }));
+        const cellsAreVisible = ( onDidChangeVisibleRanges.map(v => v.length > 0));
+        const debouncedChanges = debouncedObservable(cellChanges, 10);
+        this._register(autorun(r => {
+            if (this.notebookEditor.textModel !== this.notebookModel || !cellsAreVisible.read(r) || !this.notebookEditor.getViewModel()) {
+                return;
+            }
+            const changes = debouncedChanges.read(r).filter(c => c.type === 'insert' ? !c.diff.read(r).identical : true);
+            const modifiedChanges = changes.filter(c => c.type === 'modified');
+            this.createDecorators();
+            this.insertedCellDecorator?.apply(changes);
+            this.modifiedCellDecorator?.apply(modifiedChanges);
+            this.deletedCellDecorator?.apply(changes, originalModel);
+        }));
+    }
+    createDecorators() {
+        const cellChanges = this.cellChanges.get();
+        const accessibilitySignalService = this.accessibilitySignalService;
+        this.insertedCellDecorator ??= this._register(this.instantiationService.createInstance(NotebookInsertedCellDecorator, this.notebookEditor));
+        this.modifiedCellDecorator ??= this._register(this.instantiationService.createInstance(NotebookModifiedCellDecorator, this.notebookEditor));
+        if (this.deletedCellDecorator) {
+            this._store.delete(this.deletedCellDecorator);
+            this.deletedCellDecorator.dispose();
+        }
+        this.deletedCellDecorator = this._register(this.instantiationService.createInstance(NotebookDeletedCellDecorator, this.notebookEditor, {
+            className: 'chat-diff-change-content-widget',
+            telemetrySource: 'chatEditingNotebookHunk',
+            menuId: MenuId.ChatEditingEditorHunk,
+            argFactory: (deletedCellIndex) => {
+                return {
+                    accept() {
+                        const entry = cellChanges.find(c => c.type === 'delete' && c.originalCellIndex === deletedCellIndex);
+                        if (entry) {
+                            return entry.keep(entry.diff.get().changes[0]);
+                        }
+                        accessibilitySignalService.playSignal(AccessibilitySignal.editsKept, { allowManyInParallel: true });
+                        return Promise.resolve(true);
+                    },
+                    reject() {
+                        const entry = cellChanges.find(c => c.type === 'delete' && c.originalCellIndex === deletedCellIndex);
+                        if (entry) {
+                            return entry.undo(entry.diff.get().changes[0]);
+                        }
+                        accessibilitySignalService.playSignal(AccessibilitySignal.editsUndone, { allowManyInParallel: true });
+                        return Promise.resolve(true);
+                    },
+                };
+            }
+        }));
+    }
+    getCell(modifiedCellIndex) {
+        const cell = this.notebookModel.cells[modifiedCellIndex];
+        const integration = this.cellEditorIntegrations.get(cell)?.integration;
+        return integration;
+    }
+    reveal(firstOrLast) {
+        const changes = sortCellChanges(this.cellChanges.get().filter(c => c.type !== 'unchanged'));
+        if (!changes.length) {
+            return undefined;
+        }
+        const change = firstOrLast ? changes[0] : changes[changes.length - 1];
+        this._revealFirstOrLast(change, firstOrLast);
+    }
+    _revealFirstOrLast(change, firstOrLast = true) {
+        switch (change.type) {
+            case 'insert':
+            case 'modified':
+                {
+                    const index = firstOrLast || change.type === 'insert' ? 0 : change.diff.get().changes.length - 1;
+                    const cellIntegration = this.getCell(change.modifiedCellIndex);
+                    if (cellIntegration) {
+                        cellIntegration.reveal(firstOrLast);
+                        this._currentChange.set({ change: change, index }, undefined);
+                        return true;
+                    }
+                    else {
+                        return this._revealChange(change, index);
+                    }
+                }
+            case 'delete':
+                this.deletedCellDecorator?.reveal(change.originalCellIndex);
+                this._currentChange.set({ change: change, index: 0 }, undefined);
+                return true;
+        }
+        return false;
+    }
+    _revealChange(change, indexInCell) {
+        switch (change.type) {
+            case 'insert':
+            case 'modified':
+                {
+                    const textChange = change.diff.get().changes[indexInCell];
+                    const cellViewModel = this.getCellViewModel(change);
+                    if (cellViewModel) {
+                        this.revealChangeInView(cellViewModel, textChange?.modified);
+                        this._currentChange.set({ change: change, index: indexInCell }, undefined);
+                    }
+                    return true;
+                }
+            case 'delete':
+                this.deletedCellDecorator?.reveal(change.originalCellIndex);
+                this._currentChange.set({ change: change, index: 0 }, undefined);
+                return true;
+        }
+        return false;
+    }
+    getCellViewModel(change) {
+        if (change.type === 'delete' || change.modifiedCellIndex === undefined) {
+            return undefined;
+        }
+        const cell = this.notebookModel.cells[change.modifiedCellIndex];
+        const cellViewModel = this.notebookEditor.getViewModel()?.viewCells.find(c => c.handle === cell.handle);
+        return cellViewModel;
+    }
+    async revealChangeInView(cell, lines) {
+        const targetLines = lines ?? ( new LineRange(0, 0));
+        await this.notebookEditor.focusNotebookCell(cell, 'container', { focusEditorLine: targetLines.startLineNumber });
+        await this.notebookEditor.revealRangeInCenterAsync(cell, ( new Range(targetLines.startLineNumber, 0, targetLines.endLineNumberExclusive, 0)));
+    }
+    next(wrap) {
+        const changes = sortCellChanges(this.cellChanges.get().filter(c => c.type !== 'unchanged'));
+        const currentChange = this.currentChange.get();
+        if (!currentChange) {
+            const firstChange = changes[0];
+            if (firstChange) {
+                return this._revealFirstOrLast(firstChange);
+            }
+            return false;
+        }
+        switch (currentChange.change.type) {
+            case 'modified':
+                {
+                    const cellIntegration = this.getCell(currentChange.change.modifiedCellIndex);
+                    if (cellIntegration) {
+                        if (cellIntegration.next(false)) {
+                            this._currentChange.set({ change: currentChange.change, index: cellIntegration.currentIndex.get() }, undefined);
+                            return true;
+                        }
+                    }
+                    const isLastChangeInCell = currentChange.index === lastChangeIndex(currentChange.change);
+                    const index = isLastChangeInCell ? 0 : currentChange.index + 1;
+                    const change = isLastChangeInCell ? changes[changes.indexOf(currentChange.change) + 1] : currentChange.change;
+                    if (change) {
+                        return this._revealChange(change, index);
+                    }
+                }
+                break;
+            case 'insert':
+            case 'delete':
+                {
+                    const nextChange = changes[changes.indexOf(currentChange.change) + 1];
+                    if (nextChange) {
+                        return this._revealFirstOrLast(nextChange, true);
+                    }
+                }
+                break;
+        }
+        if (wrap) {
+            return this.next(false);
+        }
+        return false;
+    }
+    previous(wrap) {
+        const changes = sortCellChanges(this.cellChanges.get().filter(c => c.type !== 'unchanged'));
+        const currentChange = this.currentChange.get();
+        if (!currentChange) {
+            const lastChange = changes[changes.length - 1];
+            if (lastChange) {
+                return this._revealFirstOrLast(lastChange, false);
+            }
+            return false;
+        }
+        switch (currentChange.change.type) {
+            case 'modified':
+                {
+                    const cellIntegration = this.getCell(currentChange.change.modifiedCellIndex);
+                    if (cellIntegration) {
+                        if (cellIntegration.previous(false)) {
+                            this._currentChange.set({ change: currentChange.change, index: cellIntegration.currentIndex.get() }, undefined);
+                            return true;
+                        }
+                    }
+                    const isFirstChangeInCell = currentChange.index === 0;
+                    const change = isFirstChangeInCell ? changes[changes.indexOf(currentChange.change) - 1] : currentChange.change;
+                    if (change) {
+                        const index = isFirstChangeInCell ? lastChangeIndex(change) : currentChange.index - 1;
+                        return this._revealChange(change, index);
+                    }
+                }
+                break;
+            case 'insert':
+            case 'delete':
+                {
+                    const prevChange = changes[changes.indexOf(currentChange.change) - 1];
+                    if (prevChange) {
+                        return this._revealFirstOrLast(prevChange, false);
+                    }
+                }
+                break;
+        }
+        if (wrap) {
+            const lastChange = changes[changes.length - 1];
+            if (lastChange) {
+                return this._revealFirstOrLast(lastChange, false);
+            }
+        }
+        return false;
+    }
+    enableAccessibleDiffView() {
+        const cell = this.notebookEditor.getActiveCell()?.model;
+        if (cell) {
+            const integration = this.cellEditorIntegrations.get(cell)?.integration;
+            integration?.enableAccessibleDiffView();
+        }
+    }
+    acceptNearestChange(change) {
+        change.accept();
+        this.next(true);
+    }
+    rejectNearestChange(change) {
+        change.reject();
+        this.next(true);
+    }
+    async toggleDiff(_change) {
+        const defaultAgentName = this._chatAgentService.getDefaultAgent(ChatAgentLocation.EditingSession)?.fullName;
+        const diffInput = {
+            original: { resource: this._entry.originalURI, options: { selection: undefined } },
+            modified: { resource: this._entry.modifiedURI, options: { selection: undefined } },
+            label: defaultAgentName
+                ? ( localize(
+                4695,
+                '{0} (changes from {1})',
+                basename(this._entry.modifiedURI),
+                defaultAgentName
+            ))
+                : ( localize(4696, '{0} (changes from chat)', basename(this._entry.modifiedURI)))
+        };
+        await this._editorService.openEditor(diffInput);
+    }
+};
+ChatEditingNotebookEditorWidgetIntegration = ( __decorate([
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IChatAgentService)),
+    ( __param(8, INotebookEditorService)),
+    ( __param(9, IAccessibilitySignalService))
+], ChatEditingNotebookEditorWidgetIntegration));
+class ChatEditingNotebookDiffEditorIntegration extends Disposable {
+    constructor(notebookDiffEditor, cellChanges) {
+        super();
+        this.notebookDiffEditor = notebookDiffEditor;
+        this.cellChanges = cellChanges;
+        this._currentIndex = observableValue(this, -1);
+        this.currentIndex = this._currentIndex;
+        this._store.add(autorun(r => {
+            const index = notebookDiffEditor.currentChangedIndex.read(r);
+            const numberOfCellChanges = cellChanges.read(r).filter(c => !c.diff.read(r).identical);
+            if (numberOfCellChanges.length && index >= 0 && index < numberOfCellChanges.length) {
+                const changesSoFar = countChanges(numberOfCellChanges.slice(0, index + 1));
+                this._currentIndex.set(changesSoFar - 1, undefined);
+            }
+            else {
+                this._currentIndex.set(-1, undefined);
+            }
+        }));
+    }
+    reveal(firstOrLast) {
+        const changes = sortCellChanges(this.cellChanges.get().filter(c => c.type !== 'unchanged'));
+        if (!changes.length) {
+            return undefined;
+        }
+        if (firstOrLast) {
+            this.notebookDiffEditor.firstChange();
+        }
+        else {
+            this.notebookDiffEditor.lastChange();
+        }
+    }
+    next(_wrap) {
+        const changes = this.cellChanges.get().filter(c => !c.diff.get().identical).length;
+        if (this.notebookDiffEditor.currentChangedIndex.get() === changes - 1) {
+            return false;
+        }
+        this.notebookDiffEditor.nextChange();
+        return true;
+    }
+    previous(_wrap) {
+        const changes = this.cellChanges.get().filter(c => !c.diff.get().identical).length;
+        if (this.notebookDiffEditor.currentChangedIndex.get() === changes - 1) {
+            return false;
+        }
+        this.notebookDiffEditor.nextChange();
+        return true;
+    }
+    enableAccessibleDiffView() {
+    }
+    acceptNearestChange(change) {
+        change.accept();
+        this.next(true);
+    }
+    rejectNearestChange(change) {
+        change.reject();
+        this.next(true);
+    }
+    async toggleDiff(_change) {
+    }
+}
+function areDocumentDiff2Equal(diff1, diff2) {
+    if (diff1.changes !== diff2.changes) {
+        return false;
+    }
+    if (diff1.identical !== diff2.identical) {
+        return false;
+    }
+    if (diff1.moves !== diff2.moves) {
+        return false;
+    }
+    if (diff1.originalModel !== diff2.originalModel) {
+        return false;
+    }
+    if (diff1.modifiedModel !== diff2.modifiedModel) {
+        return false;
+    }
+    if (diff1.keep !== diff2.keep) {
+        return false;
+    }
+    if (diff1.undo !== diff2.undo) {
+        return false;
+    }
+    if (diff1.quitEarly !== diff2.quitEarly) {
+        return false;
+    }
+    return true;
+}
+function lastChangeIndex(change) {
+    if (change.type === 'modified') {
+        return change.diff.get().changes.length - 1;
+    }
+    return 0;
+}
+
+export { ChatEditingNotebookDiffEditorIntegration, ChatEditingNotebookEditorIntegration };

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

@@ -0,0 +1,45 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ReadableStreamEvents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { FileSystemProviderCapabilities, FileType, IFileChange, IFileDeleteOptions, IFileOpenOptions, IFileOverwriteOptions, IFileReadStreamOptions, IFileSystemProvider, IFileWriteOptions, IStat, IWatchOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
+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 { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
+export declare class ChatEditingNotebookFileSystemProviderContrib extends Disposable implements IWorkbenchContribution {
+    private readonly fileService;
+    static ID: string;
+    constructor(fileService: IFileService, instantiationService: IInstantiationService);
+}
+export declare class ChatEditingNotebookFileSystemProvider implements IFileSystemProvider {
+    private readonly _chatEditingService;
+    private readonly notebookService;
+    private static registeredFiles;
+    readonly capabilities: FileSystemProviderCapabilities;
+    static registerFile(resource: URI, buffer: VSBuffer): IDisposable;
+    constructor(_chatEditingService: IChatEditingService, notebookService: INotebookService);
+    readonly onDidChangeCapabilities: Event<any>;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    watch(_resource: URI, _opts: IWatchOptions): IDisposable;
+    stat(_resource: URI): Promise<IStat>;
+    mkdir(_resource: URI): Promise<void>;
+    readdir(_resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    delete(_resource: URI, _opts: IFileDeleteOptions): Promise<void>;
+    rename(_from: URI, _to: URI, _opts: IFileOverwriteOptions): Promise<void>;
+    copy?(_from: URI, _to: URI, _opts: IFileOverwriteOptions): Promise<void>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile?(__resource: URI, _content: Uint8Array, _opts: IFileWriteOptions): Promise<void>;
+    readFileStream?(__resource: URI, _opts: IFileReadStreamOptions, _token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    open?(__resource: URI, _opts: IFileOpenOptions): Promise<number>;
+    close?(_fd: number): Promise<void>;
+    read?(_fd: number, _pos: number, _data: Uint8Array, _offset: number, _length: number): Promise<number>;
+    write?(_fd: number, _pos: number, _data: Uint8Array, _offset: number, _length: number): Promise<number>;
+    cloneFile?(_from: URI, __to: URI): Promise<void>;
+}