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

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookChatActionsOverlay.js

@@ -0,0 +1,310 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, toDisposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { getNotebookEditorFromEditorPane, CellEditState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { ActionRunner } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { ACTIVE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { autorunWithStore, autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { navigationBearingFakeActionId, AcceptAction, RejectAction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorActions';
+
+let NotebookChatActionsOverlayController = class NotebookChatActionsOverlayController extends Disposable {
+    constructor(notebookEditor, cellDiffInfo, deletedCellDecorator, _chatEditingService, instantiationService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this._chatEditingService = _chatEditingService;
+        const notebookModel = observableFromEvent(this.notebookEditor.onDidChangeModel, e => e);
+        this._register(autorunWithStore((r, store) => {
+            const session = this._chatEditingService.currentEditingSessionObs.read(r);
+            const model = notebookModel.read(r);
+            if (!model || !session) {
+                return;
+            }
+            const entries = session.entries.read(r);
+            const idx = entries.findIndex(e => isEqual(e.modifiedURI, model.uri));
+            if (idx >= 0) {
+                const entry = entries[idx];
+                const nextEntry = entries[(idx + 1) % entries.length];
+                const previousEntry = entries[(idx - 1 + entries.length) % entries.length];
+                store.add(instantiationService.createInstance(NotebookChatActionsOverlay, notebookEditor, entry, cellDiffInfo, nextEntry, previousEntry, deletedCellDecorator));
+            }
+        }));
+    }
+};
+NotebookChatActionsOverlayController = ( __decorate([
+    ( __param(3, IChatEditingService)),
+    ( __param(4, IInstantiationService))
+], NotebookChatActionsOverlayController));
+let NotebookChatActionsOverlay = class NotebookChatActionsOverlay extends Disposable {
+    constructor(notebookEditor, entry, cellDiffInfo, nextEntry, previousEntry, deletedCellDecorator, _editorService, instaService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this._editorService = _editorService;
+        this.focusedDiff = observableValue('focusedDiff', undefined);
+        this.added = false;
+        this._register(notebookEditor.onDidBlurWidget(() => {
+            if (getNotebookEditorFromEditorPane(_editorService.activeEditorPane) !== notebookEditor) {
+                this.focusedDiff.set(undefined, undefined);
+            }
+        }));
+        this._register(notebookEditor.onDidChangeActiveEditor(e => {
+            if (e !== notebookEditor) {
+                this.focusedDiff.set(undefined, undefined);
+            }
+        }));
+        this.toolbarNode = $('div');
+        this.toolbarNode.classList.add('notebook-chat-editor-overlay-widget');
+        this._register(toDisposable(() => this.hide()));
+        this._register(autorun(r => {
+            const diffs = cellDiffInfo.read(r);
+            if (diffs?.some(d => d.type !== 'unchanged')) {
+                this.show();
+            }
+            else {
+                this.hide();
+            }
+        }));
+        const focusedDiff = this.focusedDiff;
+        const _toolbar = instaService.createInstance(MenuWorkbenchToolBar, this.toolbarNode, MenuId.ChatEditingEditorContent, {
+            telemetrySource: 'chatEditor.overlayToolbar',
+            hiddenItemStrategy: HiddenItemStrategy.Ignore,
+            toolbarOptions: {
+                primaryGroup: () => true,
+                useSeparatorsInPrimaryActions: true
+            },
+            menuOptions: { renderShortTitle: true },
+            actionViewItemProvider: (action, options) => {
+                const that = this;
+                if (action.id === navigationBearingFakeActionId) {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, { ...options, icon: false, label: false, keybindingNotRenderedWithLabel: true });
+                        }
+                    });
+                }
+                if (action.id === AcceptAction.ID || action.id === RejectAction.ID) {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, { ...options, icon: false, label: true, keybindingNotRenderedWithLabel: true });
+                            this._reveal = this._store.add(( new MutableDisposable()));
+                        }
+                        set actionRunner(actionRunner) {
+                            super.actionRunner = actionRunner;
+                            const store = ( new DisposableStore());
+                            store.add(actionRunner.onWillRun(_e => {
+                                notebookEditor.focus();
+                            }));
+                            store.add(actionRunner.onDidRun(e => {
+                                if (e.action !== this.action) {
+                                    return;
+                                }
+                                if (entry === nextEntry) {
+                                    return;
+                                }
+                                const change = nextEntry.diffInfo.get().changes.at(0);
+                                return that._editorService.openEditor({
+                                    resource: nextEntry.modifiedURI,
+                                    options: {
+                                        selection: change && Range.fromPositions({ lineNumber: change.original.startLineNumber, column: 1 }),
+                                        revealIfOpened: false,
+                                        revealIfVisible: false,
+                                    }
+                                }, ACTIVE_GROUP);
+                            }));
+                            this._reveal.value = store;
+                        }
+                        get actionRunner() {
+                            return super.actionRunner;
+                        }
+                    });
+                }
+                if (action.id === 'chatEditor.action.navigateNext' || action.id === 'chatEditor.action.navigatePrevious') {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, { ...options, icon: true, label: false, keybindingNotRenderedWithLabel: true });
+                        }
+                        set actionRunner(_) {
+                            const next = action.id === 'chatEditor.action.navigateNext' ? nextEntry : previousEntry;
+                            const direction = action.id === 'chatEditor.action.navigateNext' ? 'next' : 'previous';
+                            super.actionRunner = ( new NextPreviousChangeActionRunner(
+                                notebookEditor,
+                                cellDiffInfo,
+                                entry,
+                                next,
+                                direction,
+                                _editorService,
+                                deletedCellDecorator,
+                                focusedDiff
+                            ));
+                        }
+                        get actionRunner() {
+                            return super.actionRunner;
+                        }
+                    });
+                }
+                return undefined;
+            }
+        });
+        this._register(_toolbar);
+    }
+    show() {
+        if (!this.added) {
+            this.notebookEditor.getDomNode().appendChild(this.toolbarNode);
+            this.added = true;
+        }
+    }
+    hide() {
+        if (this.added) {
+            this.notebookEditor.getDomNode().removeChild(this.toolbarNode);
+            this.added = false;
+        }
+    }
+};
+NotebookChatActionsOverlay = ( __decorate([
+    ( __param(6, IEditorService)),
+    ( __param(7, IInstantiationService))
+], NotebookChatActionsOverlay));
+class NextPreviousChangeActionRunner extends ActionRunner {
+    constructor(notebookEditor, cellDiffInfo, entry, next, direction, editorService, deletedCellDecorator, focusedDiff) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.cellDiffInfo = cellDiffInfo;
+        this.entry = entry;
+        this.next = next;
+        this.direction = direction;
+        this.editorService = editorService;
+        this.deletedCellDecorator = deletedCellDecorator;
+        this.focusedDiff = focusedDiff;
+    }
+    async runAction(_action, _context) {
+        const viewModel = this.notebookEditor.getViewModel();
+        const activeCell = this.notebookEditor.activeCellAndCodeEditor;
+        const cellDiff = this.cellDiffInfo.read(undefined);
+        if (!viewModel || !cellDiff?.length || (!activeCell && this.focusedDiff.read(undefined))) {
+            return this.goToNextEntry();
+        }
+        const nextDiff = this.getNextCellDiff(cellDiff, viewModel);
+        if (nextDiff && (await this.focusDiff(nextDiff, viewModel))) {
+            return;
+        }
+        return this.goToNextEntry();
+    }
+    async focusDiff(diff, viewModel) {
+        if (diff.type === 'delete') {
+            const top = this.deletedCellDecorator.getTop(diff.originalCellIndex);
+            if (typeof top === 'number') {
+                this.focusedDiff.set(diff, undefined);
+                this.notebookEditor.setScrollTop(top);
+                return true;
+            }
+        }
+        else {
+            const index = diff.modifiedCellIndex;
+            this.focusedDiff.set(diff, undefined);
+            await this.notebookEditor.focusNotebookCell(viewModel.viewCells[index], 'container');
+            this.notebookEditor.revealInViewAtTop(viewModel.viewCells[index]);
+            viewModel.viewCells[index].updateEditState(CellEditState.Editing, 'chatEdit');
+            return true;
+        }
+        return false;
+    }
+    getNextCellDiff(cellDiffInfo, viewModel) {
+        const activeCell = this.notebookEditor.activeCellAndCodeEditor;
+        const currentCellIndex = activeCell ? viewModel.viewCells.findIndex(c => c.handle === activeCell[0].handle) : (this.direction === 'next' ? 0 : viewModel.viewCells.length - 1);
+        if (this.focusedDiff.read(undefined)) {
+            const changes = cellDiffInfo.filter(d => d.type !== 'unchanged');
+            const idx = changes.findIndex(d => d === this.focusedDiff.read(undefined));
+            if (idx >= 0) {
+                const next = this.direction === 'next' ? idx + 1 : idx - 1;
+                if (next >= 0 && next < changes.length) {
+                    return changes[next];
+                }
+            }
+        }
+        else if (this.direction === 'next') {
+            let currentIndex = 0;
+            let next;
+            cellDiffInfo
+                .forEach((d, i) => {
+                if (next) {
+                    return;
+                }
+                if (d.type === 'insert' || d.type === 'modified') {
+                    if (d.modifiedCellIndex > currentCellIndex) {
+                        next = d;
+                    }
+                    currentIndex = d.modifiedCellIndex;
+                }
+                else if (d.type === 'unchanged') {
+                    currentIndex = d.modifiedCellIndex;
+                }
+                else if (currentIndex >= currentCellIndex) {
+                    next = d;
+                }
+            });
+            if (next) {
+                return next;
+            }
+        }
+        else {
+            let currentIndex = 0;
+            let previous;
+            cellDiffInfo
+                .forEach((d, i) => {
+                if (d.type === 'insert' || d.type === 'modified') {
+                    if (d.modifiedCellIndex < currentCellIndex) {
+                        previous = d;
+                    }
+                    currentIndex = d.modifiedCellIndex;
+                }
+                else if (d.type === 'unchanged') {
+                    currentIndex = d.modifiedCellIndex;
+                }
+                else if (currentIndex <= currentCellIndex) {
+                    previous = d;
+                }
+            });
+            if (previous) {
+                return previous;
+            }
+        }
+        if (this.canGoToNextEntry()) {
+            return;
+        }
+        return this.direction === 'next' ? cellDiffInfo[0] : cellDiffInfo[cellDiffInfo.length - 1];
+    }
+    canGoToNextEntry() {
+        return this.entry !== this.next;
+    }
+    async goToNextEntry() {
+        if (!this.canGoToNextEntry()) {
+            return;
+        }
+        const change = this.next.diffInfo.get().changes.at(0);
+        this.focusedDiff.set(undefined, undefined);
+        await this.editorService.openEditor({
+            resource: this.next.modifiedURI,
+            options: {
+                selection: change && Range.fromPositions({ lineNumber: change.original.startLineNumber, column: 1 }),
+                revealIfOpened: false,
+                revealIfVisible: false,
+            }
+        }, ACTIVE_GROUP);
+    }
+}
+
+export { NotebookChatActionsOverlay, NotebookChatActionsOverlayController };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookChatEditController.d.ts

@@ -0,0 +1,9 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { INotebookEditor, INotebookEditorContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export declare class NotebookChatEditorControllerContrib extends Disposable implements INotebookEditorContribution {
+    static readonly ID: string;
+    readonly _serviceBrand: undefined;
+    constructor(notebookEditor: INotebookEditor, instantiationService: IInstantiationService, configurationService: IConfigurationService);
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookChatEditController.js

@@ -0,0 +1,182 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, dispose, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import { derived, derivedWithStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { observableFromEvent, debouncedObservable2 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
+import { WorkingSetEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { NotebookDeletedCellDecorator, NotebookInsertedCellDecorator, NotebookCellDiffDecorator } from './notebookCellDecorators.js';
+import './notebookSynchronizer.js';
+import { INotebookModelSynchronizerFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizer.service';
+import './notebookOriginalModelRefFactory.js';
+import { INotebookOriginalModelReferenceFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.service';
+import { NotebookChatActionsOverlayController } from './notebookChatActionsOverlay.js';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { registerNotebookContribution } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import './notebookOriginalCellModelFactory.js';
+import { ctxNotebookHasEditorModification } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookChatEditContext';
+
+let NotebookChatEditorControllerContrib = class NotebookChatEditorControllerContrib extends Disposable {
+    static { this.ID = 'workbench.notebook.chatEditorController'; }
+    constructor(notebookEditor, instantiationService, configurationService) {
+        super();
+        this._register(instantiationService.createInstance(NotebookChatEditorController, notebookEditor));
+    }
+};
+NotebookChatEditorControllerContrib = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService))
+], NotebookChatEditorControllerContrib));
+let NotebookChatEditorController = class NotebookChatEditorController extends Disposable {
+    constructor(notebookEditor, _chatEditingService, originalModelRefFactory, synchronizerFactory, instantiationService, contextKeyService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this._chatEditingService = _chatEditingService;
+        this.originalModelRefFactory = originalModelRefFactory;
+        this.synchronizerFactory = synchronizerFactory;
+        this.instantiationService = instantiationService;
+        this._ctxHasEditorModification = ctxNotebookHasEditorModification.bindTo(contextKeyService);
+        this.deletedCellDecorator = this._register(instantiationService.createInstance(NotebookDeletedCellDecorator, notebookEditor));
+        this.insertedCellDecorator = this._register(instantiationService.createInstance(NotebookInsertedCellDecorator, notebookEditor));
+        const notebookModel = observableFromEvent(this.notebookEditor.onDidChangeModel, e => e);
+        const originalModel = observableValue('originalModel', undefined);
+        const readyToRenderViewzones = observableValue('viewModelAttached', false);
+        this._register(Event.once(this.notebookEditor.onDidAttachViewModel)(() => readyToRenderViewzones.set(true, undefined)));
+        const onDidChangeVisibleRanges = debouncedObservable2(observableFromEvent(this.notebookEditor.onDidChangeVisibleRanges, () => this.notebookEditor.visibleRanges), 50);
+        const decorators = ( new Map());
+        let updatedCellDecoratorsOnceBefore = false;
+        let updatedDeletedInsertedDecoratorsOnceBefore = false;
+        const clearDecorators = () => {
+            dispose(Array.from(( decorators.values())));
+            decorators.clear();
+            this.deletedCellDecorator.clear();
+            this.insertedCellDecorator.clear();
+        };
+        this._register(toDisposable(() => clearDecorators()));
+        let notebookSynchronizer;
+        const entryObs = derived((r) => {
+            const session = this._chatEditingService.currentEditingSessionObs.read(r);
+            const model = notebookModel.read(r);
+            if (!model || !session) {
+                return;
+            }
+            return session.readEntry(model.uri, r);
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._register(autorun(r => {
+            const entry = entryObs.read(r);
+            const model = notebookModel.read(r);
+            if (!entry || !model || entry.state.read(r) !== WorkingSetEntryState.Modified) {
+                clearDecorators();
+            }
+        }));
+        const notebookDiffInfo = derivedWithStore(this, (r, store) => {
+            const entry = entryObs.read(r);
+            const model = notebookModel.read(r);
+            if (!entry || !model) {
+                if (notebookSynchronizer && model) {
+                    notebookSynchronizer.object.revert();
+                }
+                return observableValue('DefaultDiffIno', undefined);
+            }
+            notebookSynchronizer = notebookSynchronizer || this._register(this.synchronizerFactory.getOrCreate(model));
+            this.originalModelRefFactory.getOrCreate(entry, model.viewType).then(ref => originalModel.set(this._register(ref).object, undefined));
+            return notebookSynchronizer.object.diffInfo;
+        }).recomputeInitiallyAndOnChange(this._store).flatten();
+        const notebookCellDiffInfo = ( notebookDiffInfo.map(d => d?.cellDiff));
+        this._register(instantiationService.createInstance(NotebookChatActionsOverlayController, notebookEditor, notebookCellDiffInfo, this.deletedCellDecorator));
+        this._register(autorun(r => {
+            entryObs.read(r);
+            clearDecorators();
+        }));
+        this._register(autorun(r => {
+            const diffs = notebookDiffInfo.read(r);
+            if (!diffs || !diffs.cellDiff.length) {
+                clearDecorators();
+                this._ctxHasEditorModification.reset();
+            }
+            else {
+                this._ctxHasEditorModification.set(true);
+            }
+        }));
+        this._register(autorun(r => {
+            const entry = entryObs.read(r);
+            const diffInfo = notebookDiffInfo.read(r);
+            const modified = notebookModel.read(r);
+            const original = originalModel.read(r);
+            onDidChangeVisibleRanges.read(r);
+            if (!entry || !modified || !original || !diffInfo) {
+                return;
+            }
+            if (diffInfo && updatedCellDecoratorsOnceBefore && (diffInfo.modelVersion !== modified.versionId)) {
+                return;
+            }
+            updatedCellDecoratorsOnceBefore = true;
+            const validDiffDecorators = ( new Set());
+            diffInfo.cellDiff.forEach((diff) => {
+                if (diff.type === 'modified') {
+                    const modifiedCell = modified.cells[diff.modifiedCellIndex];
+                    const originalCell = original.cells[diff.originalCellIndex];
+                    const editor = this.notebookEditor.codeEditors.find(([vm,]) => vm.handle === modifiedCell.handle)?.[1];
+                    if (editor) {
+                        const currentDecorator = decorators.get(modifiedCell);
+                        if ((currentDecorator?.modifiedCell !== modifiedCell || currentDecorator?.originalCell !== originalCell)) {
+                            currentDecorator?.dispose();
+                            const decorator = this.instantiationService.createInstance(NotebookCellDiffDecorator, notebookEditor, modifiedCell, originalCell);
+                            decorators.set(modifiedCell, decorator);
+                            validDiffDecorators.add(decorator);
+                            this._register(editor.onDidDispose(() => {
+                                decorator.dispose();
+                                if (decorators.get(modifiedCell) === decorator) {
+                                    decorators.delete(modifiedCell);
+                                }
+                            }));
+                        }
+                        else if (currentDecorator) {
+                            validDiffDecorators.add(currentDecorator);
+                        }
+                    }
+                }
+            });
+            decorators.forEach((v, cell) => {
+                if (!( validDiffDecorators.has(v))) {
+                    v.dispose();
+                    decorators.delete(cell);
+                }
+            });
+        }));
+        this._register(autorun(r => {
+            const entry = entryObs.read(r);
+            const diffInfo = notebookDiffInfo.read(r);
+            const modified = notebookModel.read(r);
+            const original = originalModel.read(r);
+            const ready = readyToRenderViewzones.read(r);
+            if (!ready || !entry || !modified || !original || !diffInfo) {
+                return;
+            }
+            if (diffInfo && updatedDeletedInsertedDecoratorsOnceBefore && (diffInfo.modelVersion !== modified.versionId)) {
+                return;
+            }
+            updatedDeletedInsertedDecoratorsOnceBefore = true;
+            this.insertedCellDecorator.apply(diffInfo.cellDiff);
+            this.deletedCellDecorator.apply(diffInfo.cellDiff, original);
+        }));
+    }
+};
+NotebookChatEditorController = ( __decorate([
+    ( __param(1, IChatEditingService)),
+    ( __param(2, INotebookOriginalModelReferenceFactory)),
+    ( __param(3, INotebookModelSynchronizerFactory)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService))
+], NotebookChatEditorController));
+registerNotebookContribution(NotebookChatEditorControllerContrib.ID, NotebookChatEditorControllerContrib);
+
+export { NotebookChatEditorControllerContrib };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalCellModelFactory.d.ts

@@ -0,0 +1,21 @@
+import { IReference, ReferenceCollection } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { CellKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model";
+import { INotebookOriginalCellModelFactory } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalCellModelFactory.service";
+export declare class OriginalNotebookCellModelReferenceCollection extends ReferenceCollection<ITextModel> {
+    private readonly modelService;
+    private readonly _languageService;
+    constructor(modelService: IModelService, _languageService: ILanguageService);
+    protected createReferencedObject(_key: string, uri: URI, cellValue: string, language: string, cellKind: CellKind): ITextModel;
+    protected destroyReferencedObject(_key: string, model: ITextModel): void;
+}
+export declare class OriginalNotebookCellModelFactory implements INotebookOriginalCellModelFactory {
+    readonly _serviceBrand: undefined;
+    private readonly _data;
+    constructor(instantiationService: IInstantiationService);
+    getOrCreate(uri: URI, cellValue: string, language: string, cellKind: CellKind): IReference<ITextModel>;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalCellModelFactory.js

@@ -0,0 +1,42 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ReferenceCollection } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { CellKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model';
+
+let OriginalNotebookCellModelReferenceCollection = class OriginalNotebookCellModelReferenceCollection extends ReferenceCollection {
+    constructor(modelService, _languageService) {
+        super();
+        this.modelService = modelService;
+        this._languageService = _languageService;
+    }
+    createReferencedObject(_key, uri, cellValue, language, cellKind) {
+        const scheme = `${uri.scheme}-chat-edit`;
+        const originalCellUri = ( URI.from({ scheme, fragment: uri.fragment, path: uri.path }));
+        const languageSelection = this._languageService.getLanguageIdByLanguageName(language) ? this._languageService.createById(language) : cellKind === CellKind.Markup ? this._languageService.createById('markdown') : null;
+        return this.modelService.createModel(cellValue, languageSelection, originalCellUri);
+    }
+    destroyReferencedObject(_key, model) {
+        model.dispose();
+    }
+};
+OriginalNotebookCellModelReferenceCollection = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService))
+], OriginalNotebookCellModelReferenceCollection));
+let OriginalNotebookCellModelFactory = class OriginalNotebookCellModelFactory {
+    constructor(instantiationService) {
+        this._data = instantiationService.createInstance(OriginalNotebookCellModelReferenceCollection);
+    }
+    getOrCreate(uri, cellValue, language, cellKind) {
+        return this._data.acquire(( uri.toString()), uri, cellValue, language, cellKind);
+    }
+};
+OriginalNotebookCellModelFactory = ( __decorate([
+    ( __param(0, IInstantiationService))
+], OriginalNotebookCellModelFactory));
+
+export { OriginalNotebookCellModelFactory, OriginalNotebookCellModelReferenceCollection };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.d.ts

@@ -0,0 +1,23 @@
+import { IReference, ReferenceCollection } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IModifiedFileEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { NotebookTextModel } from "../../../common/model/notebookTextModel.js";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotebookOriginalModelReferenceFactory } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.service";
+export declare class OriginalNotebookModelReferenceCollection extends ReferenceCollection<Promise<NotebookTextModel>> {
+    private readonly notebookService;
+    private readonly modelsToDispose;
+    constructor(notebookService: INotebookService);
+    protected createReferencedObject(key: string, fileEntry: IModifiedFileEntry, viewType: string): Promise<NotebookTextModel>;
+    protected destroyReferencedObject(key: string, modelPromise: Promise<NotebookTextModel>): void;
+}
+export declare class NotebookOriginalModelReferenceFactory implements INotebookOriginalModelReferenceFactory {
+    private readonly instantiationService;
+    readonly _serviceBrand: undefined;
+    private _resourceModelCollection;
+    private get resourceModelCollection();
+    private _asyncModelCollection;
+    private get asyncModelCollection();
+    constructor(instantiationService: IInstantiationService);
+    getOrCreate(fileEntry: IModifiedFileEntry, viewType: string): Promise<IReference<NotebookTextModel>>;
+}