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

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

@@ -0,0 +1,122 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { FileSystemProviderCapabilities, FileType } 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 { 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';
+import { ChatEditingNotebookSnapshotScheme, deserializeSnapshot } from './chatEditingModifiedNotebookSnapshot.js';
+import { ChatEditingSession } from '../chatEditingSession.js';
+
+var ChatEditingNotebookFileSystemProvider_1;
+let ChatEditingNotebookFileSystemProviderContrib = class ChatEditingNotebookFileSystemProviderContrib extends Disposable {
+    static { this.ID = 'chatEditingNotebookFileSystemProviderContribution'; }
+    constructor(fileService, instantiationService) {
+        super();
+        this.fileService = fileService;
+        const fileSystemProvider = instantiationService.createInstance(ChatEditingNotebookFileSystemProvider);
+        this._register(this.fileService.registerProvider(ChatEditingNotebookSnapshotScheme, fileSystemProvider));
+    }
+};
+ChatEditingNotebookFileSystemProviderContrib = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IInstantiationService))
+], ChatEditingNotebookFileSystemProviderContrib));
+let ChatEditingNotebookFileSystemProvider = class ChatEditingNotebookFileSystemProvider {
+    static { ChatEditingNotebookFileSystemProvider_1 = this; }
+    static { this.registeredFiles = ( new ResourceMap()); }
+    static registerFile(resource, buffer) {
+        ChatEditingNotebookFileSystemProvider_1.registeredFiles.set(resource, buffer);
+        return {
+            dispose() {
+                if (ChatEditingNotebookFileSystemProvider_1.registeredFiles.get(resource) === buffer) {
+                    ChatEditingNotebookFileSystemProvider_1.registeredFiles.delete(resource);
+                }
+            }
+        };
+    }
+    constructor(_chatEditingService, notebookService) {
+        this._chatEditingService = _chatEditingService;
+        this.notebookService = notebookService;
+        this.capabilities = FileSystemProviderCapabilities.Readonly | FileSystemProviderCapabilities.FileAtomicRead | FileSystemProviderCapabilities.FileReadWrite;
+        this.onDidChangeCapabilities = Event.None;
+        this.onDidChangeFile = Event.None;
+    }
+    watch(_resource, _opts) {
+        return Disposable.None;
+    }
+    async stat(_resource) {
+        return {
+            type: FileType.File,
+            ctime: 0,
+            mtime: 0,
+            size: 0
+        };
+    }
+    mkdir(_resource) {
+        throw ( new Error('Method not implemented1.'));
+    }
+    readdir(_resource) {
+        throw ( new Error('Method not implemented2.'));
+    }
+    delete(_resource, _opts) {
+        throw ( new Error('Method not implemented3.'));
+    }
+    rename(_from, _to, _opts) {
+        throw ( new Error('Method not implemented4.'));
+    }
+    copy(_from, _to, _opts) {
+        throw ( new Error('Method not implemented5.'));
+    }
+    async readFile(resource) {
+        const buffer = ChatEditingNotebookFileSystemProvider_1.registeredFiles.get(resource);
+        if (buffer) {
+            return buffer.buffer;
+        }
+        const queryData = JSON.parse(resource.query);
+        if (!queryData.viewType) {
+            throw ( new Error('File not found, viewType not found'));
+        }
+        const session = this._chatEditingService.getEditingSession(queryData.sessionId);
+        if (!(session instanceof ChatEditingSession) || !queryData.requestId) {
+            throw ( new Error('File not found, session not found'));
+        }
+        const snapshotEntry = session.getSnapshot(queryData.requestId, queryData.undoStop || undefined, resource);
+        if (!snapshotEntry) {
+            throw ( new Error('File not found, snapshot not found'));
+        }
+        const { data } = deserializeSnapshot(snapshotEntry.current);
+        const { serializer } = await this.notebookService.withNotebookDataProvider(queryData.viewType);
+        return serializer.notebookToData(data).then(s => s.buffer);
+    }
+    writeFile(__resource, _content, _opts) {
+        throw ( new Error('Method not implemented7.'));
+    }
+    readFileStream(__resource, _opts, _token) {
+        throw ( new Error('Method not implemented8.'));
+    }
+    open(__resource, _opts) {
+        throw ( new Error('Method not implemented9.'));
+    }
+    close(_fd) {
+        throw ( new Error('Method not implemented10.'));
+    }
+    read(_fd, _pos, _data, _offset, _length) {
+        throw ( new Error('Method not implemented11.'));
+    }
+    write(_fd, _pos, _data, _offset, _length) {
+        throw ( new Error('Method not implemented12.'));
+    }
+    cloneFile(_from, __to) {
+        throw ( new Error('Method not implemented13.'));
+    }
+};
+ChatEditingNotebookFileSystemProvider = ChatEditingNotebookFileSystemProvider_1 = ( __decorate([
+    ( __param(0, IChatEditingService)),
+    ( __param(1, INotebookService))
+], ChatEditingNotebookFileSystemProvider));
+
+export { ChatEditingNotebookFileSystemProvider, ChatEditingNotebookFileSystemProviderContrib };

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

@@ -0,0 +1,15 @@
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { ICell, ICellDto2, ICellEditOperation, NotebookCellsModelMoveEvent, NotebookCellTextModelSplice, NotebookTextModelChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { ICellDiffInfo } from "./notebookCellChanges.js";
+export declare function adjustCellDiffForKeepingADeletedCell(originalCellIndex: number, cellDiffInfo: ICellDiffInfo[], applyEdits: typeof NotebookTextModel.prototype.applyEdits): ICellDiffInfo[];
+export declare function adjustCellDiffForRevertingADeletedCell(originalCellIndex: number, cellDiffInfo: ICellDiffInfo[], cellToInsert: ICellDto2, applyEdits: typeof NotebookTextModel.prototype.applyEdits, createModifiedCellDiffInfo: (modifiedCellIndex: number, originalCellIndex: number) => ICellDiffInfo): ICellDiffInfo[];
+export declare function adjustCellDiffForRevertingAnInsertedCell(modifiedCellIndex: number, cellDiffInfo: ICellDiffInfo[], applyEdits: typeof NotebookTextModel.prototype.applyEdits): ICellDiffInfo[];
+export declare function adjustCellDiffForKeepingAnInsertedCell(modifiedCellIndex: number, cellDiffInfo: ICellDiffInfo[], cellToInsert: ICellDto2, applyEdits: typeof NotebookTextModel.prototype.applyEdits, createModifiedCellDiffInfo: (modifiedCellIndex: number, originalCellIndex: number) => ICellDiffInfo): ICellDiffInfo[];
+export declare function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change: NotebookCellTextModelSplice<ICell>, cellDiffInfo: ICellDiffInfo[], modifiedModelCellCount: number, originalModelCellCount: number, applyEdits: typeof NotebookTextModel.prototype.applyEdits, createModifiedCellDiffInfo: (modifiedCellIndex: number, originalCellIndex: number) => ICellDiffInfo): ICellDiffInfo[];
+export declare function adjustCellDiffAndOriginalModelBasedOnCellMovements(event: NotebookCellsModelMoveEvent<ICell>, cellDiffInfo: ICellDiffInfo[]): [
+    ICellDiffInfo[],
+    ICellEditOperation[]
+] | undefined;
+export declare function getCorrespondingOriginalCellIndex(modifiedCellIndex: number, cellDiffInfo: ICellDiffInfo[]): number | undefined;
+export declare function isTransientIPyNbExtensionEvent(notebookKind: string, e: NotebookTextModelChangedEvent): boolean;
+export declare function calculateNotebookRewriteRatio(cellsDiff: ICellDiffInfo[], originalModel: NotebookTextModel, modifiedModel: NotebookTextModel): number;

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

@@ -0,0 +1,320 @@
+
+import { CellEditType, NotebookCellsChangeType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { sortCellChanges } from './notebookCellChanges.js';
+
+function adjustCellDiffForRevertingADeletedCell(originalCellIndex, cellDiffInfo, cellToInsert, applyEdits, createModifiedCellDiffInfo) {
+    cellDiffInfo = sortCellChanges(cellDiffInfo);
+    const indexOfEntry = cellDiffInfo.findIndex(d => d.originalCellIndex === originalCellIndex);
+    if (indexOfEntry === -1) {
+        return cellDiffInfo;
+    }
+    let modifiedCellIndex = -1;
+    for (let i = 0; i < cellDiffInfo.length; i++) {
+        const diff = cellDiffInfo[i];
+        if (i < indexOfEntry) {
+            modifiedCellIndex = Math.max(modifiedCellIndex, diff.modifiedCellIndex ?? modifiedCellIndex);
+            continue;
+        }
+        if (i === indexOfEntry) {
+            const edit = { cells: [cellToInsert], count: 0, editType: CellEditType.Replace, index: modifiedCellIndex + 1, };
+            applyEdits([edit], true, undefined, () => undefined, undefined, true);
+            cellDiffInfo[i] = createModifiedCellDiffInfo(modifiedCellIndex + 1, originalCellIndex);
+            continue;
+        }
+        else {
+            if (typeof diff.modifiedCellIndex === 'number') {
+                diff.modifiedCellIndex++;
+                cellDiffInfo[i] = { ...diff };
+            }
+        }
+    }
+    return cellDiffInfo;
+}
+function adjustCellDiffForRevertingAnInsertedCell(modifiedCellIndex, cellDiffInfo, applyEdits) {
+    if (modifiedCellIndex === -1) {
+        return cellDiffInfo;
+    }
+    cellDiffInfo = ( sortCellChanges(cellDiffInfo)
+        .filter(d => !(d.type === 'insert' && d.modifiedCellIndex === modifiedCellIndex))
+        .map(d => {
+        if (d.type === 'insert' && d.modifiedCellIndex === modifiedCellIndex) {
+            return d;
+        }
+        if (d.type !== 'delete' && d.modifiedCellIndex > modifiedCellIndex) {
+            return {
+                ...d,
+                modifiedCellIndex: d.modifiedCellIndex - 1,
+            };
+        }
+        return d;
+    }));
+    const edit = { cells: [], count: 1, editType: CellEditType.Replace, index: modifiedCellIndex, };
+    applyEdits([edit], true, undefined, () => undefined, undefined, true);
+    return cellDiffInfo;
+}
+function adjustCellDiffForKeepingAnInsertedCell(modifiedCellIndex, cellDiffInfo, cellToInsert, applyEdits, createModifiedCellDiffInfo) {
+    cellDiffInfo = sortCellChanges(cellDiffInfo);
+    if (modifiedCellIndex === -1) {
+        return cellDiffInfo;
+    }
+    const indexOfEntry = cellDiffInfo.findIndex(d => d.modifiedCellIndex === modifiedCellIndex);
+    if (indexOfEntry === -1) {
+        return cellDiffInfo;
+    }
+    let originalCellIndex = -1;
+    for (let i = 0; i < cellDiffInfo.length; i++) {
+        const diff = cellDiffInfo[i];
+        if (i < indexOfEntry) {
+            originalCellIndex = Math.max(originalCellIndex, diff.originalCellIndex ?? originalCellIndex);
+            continue;
+        }
+        if (i === indexOfEntry) {
+            const edit = { cells: [cellToInsert], count: 0, editType: CellEditType.Replace, index: originalCellIndex + 1 };
+            applyEdits([edit], true, undefined, () => undefined, undefined, true);
+            cellDiffInfo[i] = createModifiedCellDiffInfo(modifiedCellIndex, originalCellIndex + 1);
+            continue;
+        }
+        else {
+            if (typeof diff.originalCellIndex === 'number') {
+                diff.originalCellIndex++;
+                cellDiffInfo[i] = { ...diff };
+            }
+        }
+    }
+    return cellDiffInfo;
+}
+function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change, cellDiffInfo, modifiedModelCellCount, originalModelCellCount, applyEdits, createModifiedCellDiffInfo) {
+    cellDiffInfo = sortCellChanges(cellDiffInfo);
+    const numberOfCellsInserted = change[2].length;
+    const numberOfCellsDeleted = change[1];
+    const cells = ( change[2].map(cell => {
+        return {
+            cellKind: cell.cellKind,
+            language: cell.language,
+            metadata: cell.metadata,
+            outputs: cell.outputs,
+            source: cell.getValue(),
+            mime: undefined,
+            internalMetadata: cell.internalMetadata
+        };
+    }));
+    let diffEntryIndex = -1;
+    let indexToInsertInOriginalModel = undefined;
+    if (cells.length) {
+        for (let i = 0; i < cellDiffInfo.length; i++) {
+            const diff = cellDiffInfo[i];
+            if (typeof diff.modifiedCellIndex === 'number' && diff.modifiedCellIndex === change[0]) {
+                diffEntryIndex = i;
+                if (typeof diff.originalCellIndex === 'number') {
+                    indexToInsertInOriginalModel = diff.originalCellIndex;
+                }
+                break;
+            }
+            if (typeof diff.originalCellIndex === 'number') {
+                indexToInsertInOriginalModel = diff.originalCellIndex + 1;
+            }
+        }
+        const edit = {
+            editType: CellEditType.Replace,
+            cells,
+            index: indexToInsertInOriginalModel ?? 0,
+            count: change[1]
+        };
+        applyEdits([edit], true, undefined, () => undefined, undefined, true);
+    }
+    if (numberOfCellsDeleted) {
+        let numberOfOriginalCellsRemovedSoFar = 0;
+        let numberOfModifiedCellsRemovedSoFar = 0;
+        const modifiedIndexesToRemove = ( new Set());
+        for (let i = 0; i < numberOfCellsDeleted; i++) {
+            modifiedIndexesToRemove.add(change[0] + i);
+        }
+        const itemsToRemove = ( new Set());
+        for (let i = 0; i < cellDiffInfo.length; i++) {
+            const diff = cellDiffInfo[i];
+            if (i < diffEntryIndex) {
+                continue;
+            }
+            let changed = false;
+            if (typeof diff.modifiedCellIndex === 'number' && ( modifiedIndexesToRemove.has(diff.modifiedCellIndex))) {
+                numberOfModifiedCellsRemovedSoFar++;
+                if (typeof diff.originalCellIndex === 'number') {
+                    numberOfOriginalCellsRemovedSoFar++;
+                }
+                itemsToRemove.add(diff);
+                continue;
+            }
+            if (typeof diff.modifiedCellIndex === 'number' && numberOfModifiedCellsRemovedSoFar) {
+                diff.modifiedCellIndex -= numberOfModifiedCellsRemovedSoFar;
+                changed = true;
+            }
+            if (typeof diff.originalCellIndex === 'number' && numberOfOriginalCellsRemovedSoFar) {
+                diff.originalCellIndex -= numberOfOriginalCellsRemovedSoFar;
+                changed = true;
+            }
+            if (changed) {
+                cellDiffInfo[i] = { ...diff };
+            }
+        }
+        if (itemsToRemove.size) {
+            Array.from(itemsToRemove)
+                .filter(diff => typeof diff.originalCellIndex === 'number')
+                .forEach(diff => {
+                const edit = {
+                    editType: CellEditType.Replace,
+                    cells: [],
+                    index: diff.originalCellIndex,
+                    count: 1
+                };
+                applyEdits([edit], true, undefined, () => undefined, undefined, true);
+            });
+        }
+        cellDiffInfo = cellDiffInfo.filter(d => !( itemsToRemove.has(d)));
+    }
+    if (numberOfCellsInserted && diffEntryIndex >= 0) {
+        for (let i = 0; i < cellDiffInfo.length; i++) {
+            const diff = cellDiffInfo[i];
+            if (i < diffEntryIndex) {
+                continue;
+            }
+            let changed = false;
+            if (typeof diff.modifiedCellIndex === 'number') {
+                diff.modifiedCellIndex += numberOfCellsInserted;
+                changed = true;
+            }
+            if (typeof diff.originalCellIndex === 'number') {
+                diff.originalCellIndex += numberOfCellsInserted;
+                changed = true;
+            }
+            if (changed) {
+                cellDiffInfo[i] = { ...diff };
+            }
+        }
+    }
+    cells.forEach((_, i) => {
+        const originalCellIndex = i + (indexToInsertInOriginalModel ?? 0);
+        const modifiedCellIndex = change[0] + i;
+        const unchangedCell = createModifiedCellDiffInfo(modifiedCellIndex, originalCellIndex);
+        cellDiffInfo.splice((diffEntryIndex === -1 ? cellDiffInfo.length : diffEntryIndex) + i, 0, unchangedCell);
+    });
+    return cellDiffInfo;
+}
+function adjustCellDiffAndOriginalModelBasedOnCellMovements(event, cellDiffInfo) {
+    const minimumIndex = Math.min(event.index, event.newIdx);
+    const maximumIndex = Math.max(event.index, event.newIdx);
+    const cellDiffs = cellDiffInfo.slice();
+    const indexOfEntry = cellDiffs.findIndex(d => d.modifiedCellIndex === event.index);
+    const indexOfEntryToPlaceBelow = cellDiffs.findIndex(d => d.modifiedCellIndex === event.newIdx);
+    if (indexOfEntry === -1 || indexOfEntryToPlaceBelow === -1) {
+        return undefined;
+    }
+    const entryToBeMoved = { ...cellDiffs[indexOfEntry] };
+    const moveDirection = event.newIdx > event.index ? 'down' : 'up';
+    const startIndex = cellDiffs.findIndex(d => d.modifiedCellIndex === minimumIndex);
+    const endIndex = cellDiffs.findIndex(d => d.modifiedCellIndex === maximumIndex);
+    const movingExistingCell = typeof entryToBeMoved.originalCellIndex === 'number';
+    let originalCellsWereEffected = false;
+    for (let i = 0; i < cellDiffs.length; i++) {
+        const diff = cellDiffs[i];
+        let changed = false;
+        if (moveDirection === 'down') {
+            if (i > startIndex && i <= endIndex) {
+                if (typeof diff.modifiedCellIndex === 'number') {
+                    changed = true;
+                    diff.modifiedCellIndex = diff.modifiedCellIndex - 1;
+                }
+                if (typeof diff.originalCellIndex === 'number' && movingExistingCell) {
+                    diff.originalCellIndex = diff.originalCellIndex - 1;
+                    originalCellsWereEffected = true;
+                    changed = true;
+                }
+            }
+        }
+        else {
+            if (i >= startIndex && i < endIndex) {
+                if (typeof diff.modifiedCellIndex === 'number') {
+                    changed = true;
+                    diff.modifiedCellIndex = diff.modifiedCellIndex + 1;
+                }
+                if (typeof diff.originalCellIndex === 'number' && movingExistingCell) {
+                    diff.originalCellIndex = diff.originalCellIndex + 1;
+                    originalCellsWereEffected = true;
+                    changed = true;
+                }
+            }
+        }
+        if (changed) {
+            cellDiffs[i] = { ...diff };
+        }
+    }
+    entryToBeMoved.modifiedCellIndex = event.newIdx;
+    const originalCellIndex = entryToBeMoved.originalCellIndex;
+    if (moveDirection === 'down') {
+        cellDiffs.splice(endIndex + 1, 0, entryToBeMoved);
+        cellDiffs.splice(startIndex, 1);
+        if (typeof entryToBeMoved.originalCellIndex === 'number') {
+            entryToBeMoved.originalCellIndex = cellDiffs.slice(0, endIndex).reduce((lastOriginalIndex, diff) => typeof diff.originalCellIndex === 'number' ? Math.max(lastOriginalIndex, diff.originalCellIndex) : lastOriginalIndex, -1) + 1;
+        }
+    }
+    else {
+        cellDiffs.splice(endIndex, 1);
+        cellDiffs.splice(startIndex, 0, entryToBeMoved);
+        if (typeof entryToBeMoved.originalCellIndex === 'number') {
+            entryToBeMoved.originalCellIndex = cellDiffs.slice(0, startIndex).reduce((lastOriginalIndex, diff) => typeof diff.originalCellIndex === 'number' ? Math.max(lastOriginalIndex, diff.originalCellIndex) : lastOriginalIndex, -1) + 1;
+        }
+    }
+    if (typeof entryToBeMoved.originalCellIndex === 'number' && originalCellsWereEffected && typeof originalCellIndex === 'number' && entryToBeMoved.originalCellIndex !== originalCellIndex) {
+        const edit = {
+            editType: CellEditType.Move,
+            index: originalCellIndex,
+            length: event.length,
+            newIdx: entryToBeMoved.originalCellIndex
+        };
+        return [cellDiffs, [edit]];
+    }
+    return [cellDiffs, []];
+}
+function getCorrespondingOriginalCellIndex(modifiedCellIndex, cellDiffInfo) {
+    const entry = cellDiffInfo.find(d => d.modifiedCellIndex === modifiedCellIndex);
+    return entry?.originalCellIndex;
+}
+function isTransientIPyNbExtensionEvent(notebookKind, e) {
+    if (notebookKind !== 'jupyter-notebook') {
+        return false;
+    }
+    if (e.rawEvents.every(event => {
+        if (event.kind !== NotebookCellsChangeType.ChangeCellMetadata) {
+            return false;
+        }
+        if (JSON.stringify(event.metadata || {}) === JSON.stringify({ execution_count: null, metadata: {} })) {
+            return true;
+        }
+        return true;
+    })) {
+        return true;
+    }
+    return false;
+}
+function calculateNotebookRewriteRatio(cellsDiff, originalModel, modifiedModel) {
+    const totalNumberOfUpdatedLines = cellsDiff.reduce((totalUpdatedLines, value) => {
+        const getUpadtedLineCount = () => {
+            if (value.type === 'unchanged') {
+                return 0;
+            }
+            if (value.type === 'delete') {
+                return originalModel.cells[value.originalCellIndex].textModel?.getLineCount() ?? 0;
+            }
+            if (value.type === 'insert') {
+                return modifiedModel.cells[value.modifiedCellIndex].textModel?.getLineCount() ?? 0;
+            }
+            return value.diff.get().changes.reduce((maxLineNumber, change) => {
+                return Math.max(maxLineNumber, change.modified.endLineNumberExclusive);
+            }, 0);
+        };
+        return totalUpdatedLines + getUpadtedLineCount();
+    }, 0);
+    const totalNumberOfLines = modifiedModel.cells.reduce((totalLines, cell) => totalLines + (cell.textModel?.getLineCount() ?? 0), 0);
+    return totalNumberOfLines === 0 ? 0 : Math.min(1, totalNumberOfUpdatedLines / totalNumberOfLines);
+}
+
+export { adjustCellDiffAndOriginalModelBasedOnCellAddDelete, adjustCellDiffAndOriginalModelBasedOnCellMovements, adjustCellDiffForKeepingAnInsertedCell, adjustCellDiffForRevertingADeletedCell, adjustCellDiffForRevertingAnInsertedCell, calculateNotebookRewriteRatio, getCorrespondingOriginalCellIndex, isTransientIPyNbExtensionEvent };

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

@@ -0,0 +1,31 @@
+import { ISettableObservable, ObservablePromise } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IDocumentDiff } from "../../../../../../editor/common/diff/documentDiffProvider.js";
+import { DetailedLineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+export type ICellDiffInfo = {
+    originalCellIndex: number;
+    modifiedCellIndex: number;
+    type: "unchanged";
+} & IDocumentDiffWithModelsAndActions | {
+    originalCellIndex: number;
+    modifiedCellIndex: number;
+    type: "modified";
+} & IDocumentDiffWithModelsAndActions | {
+    modifiedCellIndex: undefined;
+    originalCellIndex: number;
+    type: "delete";
+} & IDocumentDiffWithModelsAndActions | {
+    modifiedCellIndex: number;
+    originalCellIndex: undefined;
+    type: "insert";
+} & IDocumentDiffWithModelsAndActions;
+interface IDocumentDiffWithModelsAndActions {
+    diff: ISettableObservable<IDocumentDiff>;
+    originalModel: ObservablePromise<ITextModel>;
+    modifiedModel: ObservablePromise<ITextModel>;
+    keep(changes: DetailedLineRangeMapping): Promise<boolean>;
+    undo(changes: DetailedLineRangeMapping): Promise<boolean>;
+}
+export declare function countChanges(changes: ICellDiffInfo[]): number;
+export declare function sortCellChanges(changes: ICellDiffInfo[]): ICellDiffInfo[];
+export {};

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

@@ -0,0 +1,50 @@
+
+
+function countChanges(changes) {
+    return changes.reduce((count, change) => {
+        const diff = change.diff.get();
+        if (diff.identical) {
+            return count;
+        }
+        switch (change.type) {
+            case 'delete':
+                return count + 1;
+            case 'insert':
+                return count + 1;
+            case 'modified':
+                return count + diff.changes.length;
+            default:
+                return count;
+        }
+    }, 0);
+}
+function sortCellChanges(changes) {
+    return [...changes].sort((a, b) => {
+        if ((a.type === 'unchanged' || a.type === 'modified') &&
+            (b.type === 'unchanged' || b.type === 'modified')) {
+            return a.modifiedCellIndex - b.modifiedCellIndex;
+        }
+        if (a.type === 'delete' && b.type === 'delete') {
+            return a.originalCellIndex - b.originalCellIndex;
+        }
+        if (a.type === 'insert' && b.type === 'insert') {
+            return a.modifiedCellIndex - b.modifiedCellIndex;
+        }
+        if (a.type === 'delete' && b.type === 'insert') {
+            return -1;
+        }
+        if (a.type === 'insert' && b.type === 'delete') {
+            return 1;
+        }
+        if ((a.type === 'delete' && b.type !== 'insert') || (a.type !== 'insert' && b.type === 'delete')) {
+            return a.originalCellIndex - b.originalCellIndex;
+        }
+        const aIndex = a.type === 'delete' ? a.originalCellIndex :
+            (a.type === 'insert' ? a.modifiedCellIndex : a.modifiedCellIndex);
+        const bIndex = b.type === 'delete' ? b.originalCellIndex :
+            (b.type === 'insert' ? b.modifiedCellIndex : b.modifiedCellIndex);
+        return aIndex - bIndex;
+    });
+}
+
+export { countChanges, sortCellChanges };

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

@@ -9,9 +9,10 @@ import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
 import { EditorPane } from "@codingame/monaco-vscode-12c5f9eb-72d3-57ca-babd-5bef7aa9de3b-common/vscode/vs/workbench/browser/parts/editor/editorPane";
 import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
-import { ChatEditorInput } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput";
-import { IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { ChatEditorInput } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput";
 export interface IChatEditorOptions extends IEditorOptions {
     target?: {
         sessionId: string;
@@ -23,12 +24,13 @@ export declare class ChatEditor extends EditorPane {
     private readonly instantiationService;
     private readonly storageService;
     private readonly contextKeyService;
+    private readonly chatService;
     private widget;
     private _scopedContextKeyService;
     get scopedContextKeyService(): IScopedContextKeyService;
     private _memento;
     private _viewState;
-    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, instantiationService: IInstantiationService, storageService: IStorageService, contextKeyService: IContextKeyService);
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, instantiationService: IInstantiationService, storageService: IStorageService, contextKeyService: IContextKeyService, chatService: IChatService);
     private clear;
     protected createEditor(parent: HTMLElement): void;
     protected setEditorVisible(visible: boolean): void;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditor.js

@@ -20,22 +20,24 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/sear
 import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
 import { EditorPane } from '@codingame/monaco-vscode-12c5f9eb-72d3-57ca-babd-5bef7aa9de3b-common/vscode/vs/workbench/browser/parts/editor/editorPane';
 import { Memento } from '@codingame/monaco-vscode-12c5f9eb-72d3-57ca-babd-5bef7aa9de3b-common/vscode/vs/workbench/common/memento';
+import { EDITOR_DRAG_AND_DROP_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
+import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatAgentLocation, ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { clearChatEditor } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/actions/chatClear';
 import { ChatEditorInput } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
 import { ChatWidget } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
-import { EDITOR_DRAG_AND_DROP_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
 
 let ChatEditor = class ChatEditor extends EditorPane {
     get scopedContextKeyService() {
         return this._scopedContextKeyService;
     }
-    constructor(group, telemetryService, themeService, instantiationService, storageService, contextKeyService) {
+    constructor(group, telemetryService, themeService, instantiationService, storageService, contextKeyService, chatService) {
         super(ChatEditorInput.EditorID, group, telemetryService, themeService, storageService);
         this.instantiationService = instantiationService;
         this.storageService = storageService;
         this.contextKeyService = contextKeyService;
+        this.chatService = chatService;
     }
     async clear() {
         if (this.input) {
@@ -46,7 +48,20 @@ let ChatEditor = class ChatEditor extends EditorPane {
         this._scopedContextKeyService = this._register(this.contextKeyService.createScoped(parent));
         const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
         this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, undefined, {
+            autoScroll: mode => mode !== ChatMode.Ask,
+            renderFollowups: true,
             supportsFileReferences: true,
+            supportsAdditionalParticipants: true,
+            rendererOptions: {
+                renderTextEditsAsSummary: (uri) => {
+                    return this.chatService.isEditingLocation(ChatAgentLocation.Panel);
+                },
+                referencesExpandedWhenEmptyResponse: !this.chatService.isEditingLocation(ChatAgentLocation.Panel),
+                progressMessageAtBottomOfResponse: mode => mode !== ChatMode.Ask,
+            },
+            enableImplicitContext: true,
+            enableWorkingSet: this.chatService.isEditingLocation(ChatAgentLocation.Panel) ? 'explicit' : undefined,
+            supportsChangingModes: this.chatService.isEditingLocation(ChatAgentLocation.Panel),
         }, {
             listForeground: editorForeground,
             listBackground: editorBackground,
@@ -91,6 +106,7 @@ let ChatEditor = class ChatEditor extends EditorPane {
         if (this._memento && this._viewState) {
             const widgetViewState = this.widget.getViewState();
             this._viewState.inputValue = widgetViewState.inputValue;
+            this._viewState.inputState = widgetViewState.inputState;
             this._memento.saveMemento();
         }
     }
@@ -108,7 +124,8 @@ ChatEditor = ( __decorate([
     ( __param(2, IThemeService)),
     ( __param(3, IInstantiationService)),
     ( __param(4, IStorageService)),
-    ( __param(5, IContextKeyService))
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IChatService))
 ], ChatEditor));
 
 export { ChatEditor };

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

@@ -2,6 +2,7 @@ import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ViewPane } from "@codingame/monaco-vscode-65619f8f-0eab-5d8b-855a-43b6353fe527-common/vscode/vs/workbench/browser/parts/views/viewPane";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { IExtensionsWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service";
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
@@ -20,3 +21,6 @@ export declare class ChatCompatibilityNotifier extends Disposable implements IWo
     constructor(extensionsWorkbenchService: IExtensionsWorkbenchService, contextKeyService: IContextKeyService, productService: IProductService);
     private registerWelcomeView;
 }
+export declare class MovedChatEditsViewPane extends ViewPane {
+    shouldShowWelcome(): boolean;
+}