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

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

@@ -0,0 +1,20 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { ITextModelContentProvider } from "@codingame/monaco-vscode-model-service-override/vscode/vs/editor/common/services/resolverService";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
+export declare class ChatEditingTextModelContentProvider implements ITextModelContentProvider {
+    private readonly _chatEditingService;
+    private readonly _modelService;
+    static readonly scheme = "chat-editing-text-model";
+    static getFileURI(chatSessionId: string, documentId: string, path: string): URI;
+    constructor(_chatEditingService: IChatEditingService, _modelService: IModelService);
+    provideTextContent(resource: URI): Promise<ITextModel | null>;
+}
+export declare class ChatEditingSnapshotTextModelContentProvider implements ITextModelContentProvider {
+    private readonly _chatEditingService;
+    private readonly _modelService;
+    static getSnapshotFileURI(chatSessionId: string, requestId: string | undefined, undoStop: string | undefined, path: string): URI;
+    constructor(_chatEditingService: IChatEditingService, _modelService: IModelService);
+    provideTextContent(resource: URI): Promise<ITextModel | null>;
+}

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

@@ -0,0 +1,69 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { chatEditingSnapshotScheme } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { ChatEditingSession } from './chatEditingSession.js';
+
+var ChatEditingTextModelContentProvider_1;
+let ChatEditingTextModelContentProvider = class ChatEditingTextModelContentProvider {
+    static { ChatEditingTextModelContentProvider_1 = this; }
+    static { this.scheme = 'chat-editing-text-model'; }
+    static getFileURI(chatSessionId, documentId, path) {
+        return ( URI.from({
+            scheme: ChatEditingTextModelContentProvider_1.scheme,
+            path,
+            query: JSON.stringify({ kind: 'doc', documentId, chatSessionId }),
+        }));
+    }
+    constructor(_chatEditingService, _modelService) {
+        this._chatEditingService = _chatEditingService;
+        this._modelService = _modelService;
+    }
+    async provideTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing && !existing.isDisposed()) {
+            return existing;
+        }
+        const data = JSON.parse(resource.query);
+        const session = this._chatEditingService.getEditingSession(data.chatSessionId);
+        const entry = session?.entries.get().find(candidate => candidate.entryId === data.documentId);
+        if (!entry) {
+            return null;
+        }
+        return this._modelService.getModel(entry.originalURI);
+    }
+};
+ChatEditingTextModelContentProvider = ChatEditingTextModelContentProvider_1 = ( __decorate([
+    ( __param(1, IModelService))
+], ChatEditingTextModelContentProvider));
+let ChatEditingSnapshotTextModelContentProvider = class ChatEditingSnapshotTextModelContentProvider {
+    static getSnapshotFileURI(chatSessionId, requestId, undoStop, path) {
+        return ( URI.from({
+            scheme: chatEditingSnapshotScheme,
+            path,
+            query: JSON.stringify({ sessionId: chatSessionId, requestId: requestId ?? '', undoStop: undoStop ?? '' }),
+        }));
+    }
+    constructor(_chatEditingService, _modelService) {
+        this._chatEditingService = _chatEditingService;
+        this._modelService = _modelService;
+    }
+    async provideTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing && !existing.isDisposed()) {
+            return existing;
+        }
+        const data = JSON.parse(resource.query);
+        const session = this._chatEditingService.getEditingSession(data.sessionId);
+        if (!(session instanceof ChatEditingSession) || !data.requestId) {
+            return null;
+        }
+        return session.getSnapshotModel(data.requestId, data.undoStop || undefined, resource);
+    }
+};
+ChatEditingSnapshotTextModelContentProvider = ( __decorate([
+    ( __param(1, IModelService))
+], ChatEditingSnapshotTextModelContentProvider));
+
+export { ChatEditingSnapshotTextModelContentProvider, ChatEditingTextModelContentProvider };

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

@@ -0,0 +1,15 @@
+import { INotebookEditorModelResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service";
+import { INotebookLoggingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service";
+import { INotebookEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service";
+import { IEditSessionEntryDiff } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { ISnapshotEntry } from "../chatEditingModifiedFileEntry.js";
+export declare class ChatEditingModifiedNotebookDiff {
+    private readonly original;
+    private readonly modified;
+    private readonly notebookEditorWorkerService;
+    private readonly notebookLoggingService;
+    private readonly notebookEditorModelService;
+    static NewModelCounter: number;
+    constructor(original: ISnapshotEntry, modified: ISnapshotEntry, notebookEditorWorkerService: INotebookEditorWorkerService, notebookLoggingService: INotebookLoggingService, notebookEditorModelService: INotebookEditorModelResolverService);
+    computeDiff(): Promise<IEditSessionEntryDiff>;
+}

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

@@ -0,0 +1,67 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { computeDiff } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/common/notebookDiff';
+import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
+import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
+import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
+
+let ChatEditingModifiedNotebookDiff = class ChatEditingModifiedNotebookDiff {
+    static { this.NewModelCounter = 0; }
+    constructor(original, modified, notebookEditorWorkerService, notebookLoggingService, notebookEditorModelService) {
+        this.original = original;
+        this.modified = modified;
+        this.notebookEditorWorkerService = notebookEditorWorkerService;
+        this.notebookLoggingService = notebookLoggingService;
+        this.notebookEditorModelService = notebookEditorModelService;
+    }
+    async computeDiff() {
+        let added = 0;
+        let removed = 0;
+        const disposables = ( new DisposableStore());
+        try {
+            const [modifiedRef, originalRef] = await Promise.all([
+                this.notebookEditorModelService.resolve(this.modified.snapshotUri),
+                this.notebookEditorModelService.resolve(this.original.snapshotUri)
+            ]);
+            disposables.add(modifiedRef);
+            disposables.add(originalRef);
+            const notebookDiff = await this.notebookEditorWorkerService.computeDiff(this.original.snapshotUri, this.modified.snapshotUri);
+            const result = computeDiff(originalRef.object.notebook, modifiedRef.object.notebook, notebookDiff);
+            result.cellDiffInfo.forEach(diff => {
+                switch (diff.type) {
+                    case 'modified':
+                    case 'insert':
+                        added++;
+                        break;
+                    case 'delete':
+                        removed++;
+                        break;
+                    default:
+                        break;
+                }
+            });
+        }
+        catch (e) {
+            this.notebookLoggingService.error('Notebook Chat', 'Error computing diff:\n' + e);
+        }
+        finally {
+            disposables.dispose();
+        }
+        return {
+            added,
+            removed,
+            identical: added === 0 && removed === 0,
+            quitEarly: false,
+            modifiedURI: this.modified.snapshotUri,
+            originalURI: this.original.snapshotUri,
+        };
+    }
+};
+ChatEditingModifiedNotebookDiff = ( __decorate([
+    ( __param(2, INotebookEditorWorkerService)),
+    ( __param(3, INotebookLoggingService)),
+    ( __param(4, INotebookEditorModelResolverService))
+], ChatEditingModifiedNotebookDiff));
+
+export { ChatEditingModifiedNotebookDiff };

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

@@ -0,0 +1,26 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { NotebookData, TransientOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+type ChatEditingSnapshotNotebookContentQueryData = {
+    sessionId: string;
+    requestId: string | undefined;
+    undoStop: string | undefined;
+    viewType: string;
+};
+export declare const ChatEditingNotebookSnapshotScheme = "chat-editing-notebook-snapshot-model";
+export declare function getNotebookSnapshotFileURI(chatSessionId: string, requestId: string | undefined, undoStop: string | undefined, path: string, viewType: string): URI;
+export declare function parseNotebookSnapshotFileURI(resource: URI): ChatEditingSnapshotNotebookContentQueryData;
+export declare function createSnapshot(notebook: NotebookTextModel, transientOptions: TransientOptions | undefined, outputSizeConfig: IConfigurationService | number): string;
+export declare function restoreSnapshot(notebook: NotebookTextModel, snapshot: string): void;
+export declare class SnapshotComparer {
+    private readonly data;
+    private readonly transientOptions;
+    constructor(initialCotent: string);
+    isEqual(notebook: NotebookData | NotebookTextModel): boolean;
+}
+export declare function deserializeSnapshot(snapshot: string): {
+    transientOptions: TransientOptions | undefined;
+    data: NotebookData;
+};
+export {};

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

@@ -0,0 +1,147 @@
+
+import { VSBuffer, encodeBase64, decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { SnapshotContext } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
+import { NotebookCellTextModel } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
+import { NotebookSetting, CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+const BufferMarker = 'ArrayBuffer-4f56482b-5a03-49ba-8356-210d3b0c1c3d';
+const ChatEditingNotebookSnapshotScheme = 'chat-editing-notebook-snapshot-model';
+function getNotebookSnapshotFileURI(chatSessionId, requestId, undoStop, path, viewType) {
+    return ( URI.from({
+        scheme: ChatEditingNotebookSnapshotScheme,
+        path,
+        query: JSON.stringify({ sessionId: chatSessionId, requestId: requestId ?? '', undoStop: undoStop ?? '', viewType }),
+    }));
+}
+function createSnapshot(notebook, transientOptions, outputSizeConfig) {
+    const outputSizeLimit = (typeof outputSizeConfig === 'number' ? outputSizeConfig : outputSizeConfig.getValue(NotebookSetting.outputBackupSizeLimit)) * 1024;
+    return serializeSnapshot(notebook.createSnapshot({ context: SnapshotContext.Backup, outputSizeLimit, transientOptions }), transientOptions);
+}
+function restoreSnapshot(notebook, snapshot) {
+    try {
+        const { transientOptions, data } = deserializeSnapshot(snapshot);
+        notebook.restoreSnapshot(data, transientOptions);
+        const edits = [];
+        data.cells.forEach((cell, index) => {
+            const internalId = cell.internalMetadata?.internalId;
+            if (internalId) {
+                edits.push({ editType: CellEditType.PartialInternalMetadata, index, internalMetadata: { internalId } });
+            }
+        });
+        notebook.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+    }
+    catch (ex) {
+        console.error('Error restoring Notebook snapshot', ex);
+    }
+}
+class SnapshotComparer {
+    constructor(initialCotent) {
+        this.transientOptions = deserializeSnapshot(initialCotent).transientOptions;
+        this.data = deserializeSnapshot(initialCotent).data;
+    }
+    isEqual(notebook) {
+        if (notebook.cells.length !== this.data.cells.length) {
+            return false;
+        }
+        const transientDocumentMetadata = this.transientOptions?.transientDocumentMetadata || {};
+        const notebookMetadata = filter(notebook.metadata || {}, key => !transientDocumentMetadata[key]);
+        const comparerMetadata = filter(this.data.metadata || {}, key => !transientDocumentMetadata[key]);
+        if (JSON.stringify(notebookMetadata) !== JSON.stringify(comparerMetadata)) {
+            return false;
+        }
+        const transientCellMetadata = this.transientOptions?.transientCellMetadata || {};
+        for (let i = 0; i < notebook.cells.length; i++) {
+            const notebookCell = notebook.cells[i];
+            const comparerCell = this.data.cells[i];
+            if (notebookCell instanceof NotebookCellTextModel) {
+                if (!notebookCell.fastEqual(comparerCell, true)) {
+                    return false;
+                }
+            }
+            else {
+                if (notebookCell.cellKind !== comparerCell.cellKind) {
+                    return false;
+                }
+                if (notebookCell.language !== comparerCell.language) {
+                    return false;
+                }
+                if (notebookCell.mime !== comparerCell.mime) {
+                    return false;
+                }
+                if (notebookCell.source !== comparerCell.source) {
+                    return false;
+                }
+                if (!this.transientOptions?.transientOutputs && notebookCell.outputs.length !== comparerCell.outputs.length) {
+                    return false;
+                }
+                const cellMetadata = filter(notebookCell.metadata || {}, key => !transientCellMetadata[key]);
+                const comparerCellMetadata = filter(comparerCell.metadata || {}, key => !transientCellMetadata[key]);
+                if (JSON.stringify(cellMetadata) !== JSON.stringify(comparerCellMetadata)) {
+                    return false;
+                }
+                if (JSON.stringify(sanitizeCellDto2(notebookCell, true, this.transientOptions)) !== JSON.stringify(sanitizeCellDto2(comparerCell, true, this.transientOptions))) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+function sanitizeCellDto2(cell, ignoreInternalMetadata, transientOptions) {
+    const transientCellMetadata = transientOptions?.transientCellMetadata || {};
+    const outputs = transientOptions?.transientOutputs ? [] : ( cell.outputs.map(output => {
+        return {
+            outputId: output.outputId,
+            metadata: output.metadata,
+            outputs: ( output.outputs.map(item => {
+                return {
+                    data: item.data,
+                    mime: item.mime,
+                };
+            })),
+        };
+    }));
+    return {
+        cellKind: cell.cellKind,
+        language: cell.language,
+        metadata: cell.metadata ? filter(cell.metadata, key => !transientCellMetadata[key]) : cell.metadata,
+        outputs,
+        mime: cell.mime,
+        source: cell.source,
+        collapseState: cell.collapseState,
+        internalMetadata: ignoreInternalMetadata ? undefined : cell.internalMetadata
+    };
+}
+function serializeSnapshot(data, transientOptions) {
+    const dataDto = {
+        cells: ( data.cells.map(cell => sanitizeCellDto2(cell))),
+        metadata: data.metadata,
+    };
+    return JSON.stringify([
+        JSON.stringify(transientOptions),
+        JSON.stringify(dataDto, (_key, value) => {
+            if (value instanceof VSBuffer) {
+                return {
+                    type: BufferMarker,
+                    data: encodeBase64(value)
+                };
+            }
+            return value;
+        })
+    ]);
+}
+function deserializeSnapshot(snapshot) {
+    const [transientOptionsStr, dataStr] = JSON.parse(snapshot);
+    const transientOptions = transientOptionsStr ? JSON.parse(transientOptionsStr) : undefined;
+    const data = JSON.parse(dataStr, (_key, value) => {
+        if (value && value.type === BufferMarker) {
+            return decodeBase64(value.data);
+        }
+        return value;
+    });
+    return { transientOptions, data };
+}
+
+export { ChatEditingNotebookSnapshotScheme, SnapshotComparer, createSnapshot, deserializeSnapshot, getNotebookSnapshotFileURI, restoreSnapshot };

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

@@ -0,0 +1,56 @@
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITransaction, IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ObservableDisposable } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/base/common/observableDisposable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IDocumentDiff } from "../../../../../../editor/common/diff/documentDiffProvider.js";
+import { DetailedLineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
+import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { NotebookCellTextModel } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
+import { WorkingSetEntryState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { IChatResponseModel } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+export declare class ChatEditingNotebookCellEntry extends ObservableDisposable {
+    readonly notebookUri: URI;
+    readonly cell: NotebookCellTextModel;
+    private readonly modifiedModel;
+    private readonly originalModel;
+    private readonly _editorWorkerService;
+    private readonly notebookEditorService;
+    private static readonly _lastEditDecorationOptions;
+    private static readonly _pendingEditDecorationOptions;
+    private _edit;
+    private _isEditFromUs;
+    get isEditFromUs(): boolean;
+    private _allEditsAreFromUs;
+    get allEditsAreFromUs(): boolean;
+    private _diffOperation;
+    private _diffOperationIds;
+    private readonly _diffInfo;
+    get diffInfo(): IObservable<IDocumentDiff>;
+    private readonly _maxModifiedLineNumber;
+    readonly maxModifiedLineNumber: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<number, void>;
+    private readonly _editDecorationClear;
+    private _editDecorations;
+    private readonly _diffTrimWhitespace;
+    protected readonly _stateObs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<WorkingSetEntryState, void>;
+    readonly state: IObservable<WorkingSetEntryState>;
+    protected readonly _isCurrentlyBeingModifiedByObs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<IChatResponseModel | undefined, void>;
+    readonly isCurrentlyBeingModifiedBy: IObservable<IChatResponseModel | undefined>;
+    private readonly initialContent;
+    constructor(notebookUri: URI, cell: NotebookCellTextModel, modifiedModel: ITextModel, originalModel: ITextModel, disposables: DisposableStore, configService: IConfigurationService, _editorWorkerService: IEditorWorkerService, notebookEditorService: INotebookEditorService);
+    clearCurrentEditLineDecoration(): void;
+    private _mirrorEdits;
+    acceptAgentEdits(textEdits: TextEdit[], isLastEdits: boolean, responseModel: IChatResponseModel): void;
+    scheduleEditDecorations(): void;
+    protected _resetEditsState(tx: ITransaction): void;
+    keep(change: DetailedLineRangeMapping): Promise<boolean>;
+    private _acceptHunk;
+    undo(change: DetailedLineRangeMapping): Promise<boolean>;
+    private _rejectHunk;
+    private _applyEdits;
+    private _updateDiffInfoSeq;
+    private _updateDiffInfo;
+}