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

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

@@ -0,0 +1,395 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { toDisposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { getCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
+import { OffsetEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/offsetEdit';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { nullDocumentDiff } from '../../../../../editor/common/diff/documentDiffProvider.js';
+import { TextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { OverviewRulerLane, MinimapPosition } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { SingleModelEditStackElement } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/editStack';
+import { ModelDecorationOptions, createTextBufferFactoryFromSnapshot } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { OffsetEdits } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModelOffsetEdit';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+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 { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorSelectionBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { IUndoRedoService } from '@codingame/monaco-vscode-api/vscode/vs/platform/undoRedo/common/undoRedo.service';
+import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { stringToSnapshot } from '@codingame/monaco-vscode-aff8bc9b-c6f8-578f-9c8a-f70d14f9c13c-common/vscode/vs/workbench/services/textfile/common/textfiles';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { WorkingSetEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatEditingCodeEditorIntegration } from './chatEditingCodeEditorIntegration.js';
+import { AbstractChatEditingModifiedFileEntry, pendingRewriteMinimap } from './chatEditingModifiedFileEntry.js';
+import { ChatEditingTextModelContentProvider, ChatEditingSnapshotTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
+import { observableValue, transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+var ChatEditingModifiedDocumentEntry_1;
+let ChatEditingModifiedDocumentEntry = class ChatEditingModifiedDocumentEntry extends AbstractChatEditingModifiedFileEntry {
+    static { ChatEditingModifiedDocumentEntry_1 = this; }
+    static { this._lastEditDecorationOptions = ModelDecorationOptions.register({
+        isWholeLine: true,
+        description: 'chat-last-edit',
+        className: 'chat-editing-last-edit-line',
+        marginClassName: 'chat-editing-last-edit',
+        overviewRuler: {
+            position: OverviewRulerLane.Full,
+            color: themeColorFromId(editorSelectionBackground)
+        },
+    }); }
+    static { this._pendingEditDecorationOptions = ModelDecorationOptions.register({
+        isWholeLine: true,
+        description: 'chat-pending-edit',
+        className: 'chat-editing-pending-edit',
+        minimap: {
+            position: MinimapPosition.Inline,
+            color: themeColorFromId(pendingRewriteMinimap)
+        }
+    }); }
+    constructor(resourceRef, _multiDiffEntryDelegate, telemetryInfo, kind, initialContent, markerService, modelService, textModelService, languageService, configService, fileConfigService, chatService, _editorWorkerService, _textFileService, fileService, undoRedoService, instantiationService, _accessibilitySignalService) {
+        super(resourceRef.object.textEditorModel.uri, telemetryInfo, kind, configService, fileConfigService, chatService, fileService, undoRedoService, instantiationService);
+        this._multiDiffEntryDelegate = _multiDiffEntryDelegate;
+        this._editorWorkerService = _editorWorkerService;
+        this._textFileService = _textFileService;
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._edit = OffsetEdit.empty;
+        this._isEditFromUs = false;
+        this._allEditsAreFromUs = true;
+        this._diffOperationIds = 0;
+        this._diffInfo = observableValue(this, nullDocumentDiff);
+        this.changesCount = ( this._diffInfo.map(diff => diff.changes.length));
+        this._editDecorationClear = this._register(( new RunOnceScheduler(
+            () => { this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, []); },
+            500
+        )));
+        this._editDecorations = [];
+        this.docFileEditorModel = this._register(resourceRef).object;
+        this.modifiedModel = resourceRef.object.textEditorModel;
+        this.originalURI = ChatEditingTextModelContentProvider.getFileURI(telemetryInfo.sessionId, this.entryId, this.modifiedURI.path);
+        this.initialContent = initialContent ?? this.modifiedModel.getValue();
+        const docSnapshot = this.originalModel = this._register(modelService.createModel(createTextBufferFactoryFromSnapshot(initialContent ? stringToSnapshot(initialContent) : this.modifiedModel.createSnapshot()), languageService.createById(this.modifiedModel.getLanguageId()), this.originalURI, false));
+        (async () => {
+            const reference = await textModelService.createModelReference(docSnapshot.uri);
+            if (this._store.isDisposed) {
+                reference.dispose();
+                return;
+            }
+            this._register(reference);
+        })();
+        this._register(this.modifiedModel.onDidChangeContent(e => this._mirrorEdits(e)));
+        this._register(toDisposable(() => {
+            this._clearCurrentEditLineDecoration();
+        }));
+        this._diffTrimWhitespace = observableConfigValue('diffEditor.ignoreTrimWhitespace', true, configService);
+        this._register(autorun(r => {
+            this._diffTrimWhitespace.read(r);
+            this._updateDiffInfoSeq();
+        }));
+        const resourceFilter = this._register(( new MutableDisposable()));
+        this._register(autorun(r => {
+            const res = this.isCurrentlyBeingModifiedBy.read(r);
+            if (res) {
+                const req = res.session.getRequests().find(value => value.id === res.requestId);
+                resourceFilter.value = markerService.installResourceFilter(this.modifiedURI, req?.message.text || ( localize(4684, "Chat Edits")));
+            }
+            else {
+                resourceFilter.clear();
+            }
+        }));
+    }
+    _clearCurrentEditLineDecoration() {
+        this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, []);
+    }
+    equalsSnapshot(snapshot) {
+        return !!snapshot &&
+            ( this.modifiedURI.toString()) === ( snapshot.resource.toString()) &&
+            this.modifiedModel.getLanguageId() === snapshot.languageId &&
+            this.originalModel.getValue() === snapshot.original &&
+            this.modifiedModel.getValue() === snapshot.current &&
+            this._edit.equals(snapshot.originalToCurrentEdit) &&
+            this.state.get() === snapshot.state;
+    }
+    createSnapshot(requestId, undoStop) {
+        return {
+            resource: this.modifiedURI,
+            languageId: this.modifiedModel.getLanguageId(),
+            snapshotUri: ChatEditingSnapshotTextModelContentProvider.getSnapshotFileURI(this._telemetryInfo.sessionId, requestId, undoStop, this.modifiedURI.path),
+            original: this.originalModel.getValue(),
+            current: this.modifiedModel.getValue(),
+            originalToCurrentEdit: this._edit,
+            state: this.state.get(),
+            telemetryInfo: this._telemetryInfo
+        };
+    }
+    restoreFromSnapshot(snapshot, restoreToDisk = true) {
+        this._stateObs.set(snapshot.state, undefined);
+        this.originalModel.setValue(snapshot.original);
+        if (restoreToDisk) {
+            this._setDocValue(snapshot.current);
+        }
+        this._edit = snapshot.originalToCurrentEdit;
+        this._updateDiffInfoSeq();
+    }
+    resetToInitialContent() {
+        this._setDocValue(this.initialContent);
+    }
+    async _areOriginalAndModifiedIdentical() {
+        const diff = await this._diffOperation;
+        return diff ? diff.identical : false;
+    }
+    _resetEditsState(tx) {
+        super._resetEditsState(tx);
+        this._clearCurrentEditLineDecoration();
+    }
+    _mirrorEdits(event) {
+        const edit = OffsetEdits.fromContentChanges(event.changes);
+        if (this._isEditFromUs) {
+            const e_sum = this._edit;
+            const e_ai = edit;
+            this._edit = e_sum.compose(e_ai);
+        }
+        else {
+            const e_ai = this._edit;
+            const e_user = edit;
+            const e_user_r = e_user.tryRebase(e_ai.inverse(this.originalModel.getValue()), true);
+            if (e_user_r === undefined) {
+                this._edit = e_ai.compose(e_user);
+            }
+            else {
+                const edits = OffsetEdits.asEditOperations(e_user_r, this.originalModel);
+                this.originalModel.applyEdits(edits);
+                this._edit = e_ai.tryRebase(e_user_r);
+            }
+            this._allEditsAreFromUs = false;
+            this._updateDiffInfoSeq();
+            const didResetToOriginalContent = this.modifiedModel.getValue() === this.initialContent;
+            const currentState = this._stateObs.get();
+            switch (currentState) {
+                case WorkingSetEntryState.Modified:
+                    if (didResetToOriginalContent) {
+                        this._stateObs.set(WorkingSetEntryState.Rejected, undefined);
+                        break;
+                    }
+            }
+        }
+    }
+    _createUndoRedoElement(response) {
+        const request = response.session.getRequests().find(req => req.id === response.requestId);
+        const label = request?.message.text ? ( localize(4685, "Chat Edit: '{0}'", request.message.text)) : ( localize(4686, "Chat Edit"));
+        return ( new SingleModelEditStackElement(label, 'chat.edit', this.modifiedModel, null));
+    }
+    async acceptAgentEdits(resource, textEdits, isLastEdits, responseModel) {
+        assertType(textEdits.every(TextEdit.isTextEdit), 'INVALID args, can only handle text edits');
+        assert(isEqual(resource, this.modifiedURI), ' INVALID args, can only edit THIS document');
+        const ops = ( textEdits.map(TextEdit.asEditOperation));
+        const undoEdits = this._applyEdits(ops);
+        const maxLineNumber = undoEdits.reduce((max, op) => Math.max(max, op.range.startLineNumber), 0);
+        const newDecorations = [
+            {
+                options: ChatEditingModifiedDocumentEntry_1._pendingEditDecorationOptions,
+                range: ( new Range(maxLineNumber + 1, 1, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER))
+            }
+        ];
+        if (maxLineNumber > 0) {
+            newDecorations.push({
+                options: ChatEditingModifiedDocumentEntry_1._lastEditDecorationOptions,
+                range: ( new Range(maxLineNumber, 1, maxLineNumber, Number.MAX_SAFE_INTEGER))
+            });
+        }
+        this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, newDecorations);
+        transaction((tx) => {
+            if (!isLastEdits) {
+                this._stateObs.set(WorkingSetEntryState.Modified, tx);
+                this._isCurrentlyBeingModifiedByObs.set(responseModel, tx);
+                const lineCount = this.modifiedModel.getLineCount();
+                this._rewriteRatioObs.set(Math.min(1, maxLineNumber / lineCount), tx);
+            }
+            else {
+                this._resetEditsState(tx);
+                this._updateDiffInfoSeq();
+                this._rewriteRatioObs.set(1, tx);
+                this._editDecorationClear.schedule();
+            }
+        });
+    }
+    async _acceptHunk(change) {
+        if (!this._diffInfo.get().changes.includes(change)) {
+            return false;
+        }
+        const edits = [];
+        for (const edit of change.innerChanges ?? []) {
+            const newText = this.modifiedModel.getValueInRange(edit.modifiedRange);
+            edits.push(EditOperation.replace(edit.originalRange, newText));
+        }
+        this.originalModel.pushEditOperations(null, edits, _ => null);
+        await this._updateDiffInfoSeq();
+        if (this._diffInfo.get().identical) {
+            this._stateObs.set(WorkingSetEntryState.Accepted, undefined);
+        }
+        this._accessibilitySignalService.playSignal(AccessibilitySignal.editsKept, { allowManyInParallel: true });
+        return true;
+    }
+    async _rejectHunk(change) {
+        if (!this._diffInfo.get().changes.includes(change)) {
+            return false;
+        }
+        const edits = [];
+        for (const edit of change.innerChanges ?? []) {
+            const newText = this.originalModel.getValueInRange(edit.originalRange);
+            edits.push(EditOperation.replace(edit.modifiedRange, newText));
+        }
+        this.modifiedModel.pushEditOperations(null, edits, _ => null);
+        await this._updateDiffInfoSeq();
+        if (this._diffInfo.get().identical) {
+            this._stateObs.set(WorkingSetEntryState.Rejected, undefined);
+        }
+        this._accessibilitySignalService.playSignal(AccessibilitySignal.editsUndone, { allowManyInParallel: true });
+        return true;
+    }
+    _applyEdits(edits) {
+        this._isEditFromUs = true;
+        try {
+            let result = [];
+            this.modifiedModel.pushEditOperations(null, edits, (undoEdits) => {
+                result = undoEdits;
+                return null;
+            });
+            return result;
+        }
+        finally {
+            this._isEditFromUs = false;
+        }
+    }
+    async _updateDiffInfoSeq() {
+        const myDiffOperationId = ++this._diffOperationIds;
+        await Promise.resolve(this._diffOperation);
+        if (this._diffOperationIds === myDiffOperationId) {
+            const thisDiffOperation = this._updateDiffInfo();
+            this._diffOperation = thisDiffOperation;
+            await thisDiffOperation;
+        }
+    }
+    async _updateDiffInfo() {
+        if (this.originalModel.isDisposed() || this.modifiedModel.isDisposed()) {
+            return undefined;
+        }
+        const docVersionNow = this.modifiedModel.getVersionId();
+        const snapshotVersionNow = this.originalModel.getVersionId();
+        const ignoreTrimWhitespace = this._diffTrimWhitespace.get();
+        const diff = await this._editorWorkerService.computeDiff(this.originalModel.uri, this.modifiedModel.uri, { ignoreTrimWhitespace, computeMoves: false, maxComputationTimeMs: 3000 }, 'advanced');
+        if (this.originalModel.isDisposed() || this.modifiedModel.isDisposed()) {
+            return undefined;
+        }
+        if (this.modifiedModel.getVersionId() === docVersionNow && this.originalModel.getVersionId() === snapshotVersionNow) {
+            const diff2 = diff ?? nullDocumentDiff;
+            this._diffInfo.set(diff2, undefined);
+            this._edit = OffsetEdits.fromLineRangeMapping(this.originalModel, this.modifiedModel, diff2.changes);
+            return diff2;
+        }
+        return undefined;
+    }
+    async _doAccept(tx) {
+        this.originalModel.setValue(this.modifiedModel.createSnapshot());
+        this._diffInfo.set(nullDocumentDiff, tx);
+        this._edit = OffsetEdit.empty;
+        await this._collapse(tx);
+        const config = this._fileConfigService.getAutoSaveConfiguration(this.modifiedURI);
+        if (!config.autoSave || !this._textFileService.isDirty(this.modifiedURI)) {
+            try {
+                await this._textFileService.save(this.modifiedURI, {
+                    reason: SaveReason.EXPLICIT,
+                    force: true,
+                    ignoreErrorHandler: true
+                });
+            }
+            catch {
+            }
+        }
+    }
+    async _doReject(tx) {
+        if (this.createdInRequestId === this._telemetryInfo.requestId) {
+            await this.docFileEditorModel.revert({ soft: true });
+            await this._fileService.del(this.modifiedURI);
+            this._onDidDelete.fire();
+        }
+        else {
+            this._setDocValue(this.originalModel.getValue());
+            if (this._allEditsAreFromUs) {
+                await this.docFileEditorModel.save({ reason: SaveReason.EXPLICIT, skipSaveParticipants: true });
+            }
+            await this._collapse(tx);
+        }
+    }
+    _setDocValue(value) {
+        if (this.modifiedModel.getValue() !== value) {
+            this.modifiedModel.pushStackElement();
+            const edit = EditOperation.replace(this.modifiedModel.getFullModelRange(), value);
+            this._applyEdits([edit]);
+            this._updateDiffInfoSeq();
+            this.modifiedModel.pushStackElement();
+        }
+    }
+    async _collapse(transaction) {
+        this._multiDiffEntryDelegate.collapse(transaction);
+    }
+    _createEditorIntegration(editor) {
+        const codeEditor = getCodeEditor(editor.getControl());
+        assertType(codeEditor);
+        const diffInfo = ( this._diffInfo.map(value => {
+            return {
+                ...value,
+                originalModel: this.originalModel,
+                modifiedModel: this.modifiedModel,
+                keep: changes => this._acceptHunk(changes),
+                undo: changes => this._rejectHunk(changes)
+            };
+        }));
+        return this._instantiationService.createInstance(ChatEditingCodeEditorIntegration, this, codeEditor, diffInfo);
+    }
+};
+ChatEditingModifiedDocumentEntry = ChatEditingModifiedDocumentEntry_1 = ( __decorate([
+    ( __param(5, IMarkerService)),
+    ( __param(6, IModelService)),
+    ( __param(7, ITextModelService)),
+    ( __param(8, ILanguageService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IFilesConfigurationService)),
+    ( __param(11, IChatService)),
+    ( __param(12, IEditorWorkerService)),
+    ( __param(13, ITextFileService)),
+    ( __param(14, IFileService)),
+    ( __param(15, IUndoRedoService)),
+    ( __param(16, IInstantiationService)),
+    ( __param(17, IAccessibilitySignalService))
+], ChatEditingModifiedDocumentEntry));
+
+export { ChatEditingModifiedDocumentEntry };

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

@@ -0,0 +1,98 @@
+import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, ITransaction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { OffsetEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/offsetEdit";
+import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 { IUndoRedoElement } from "@codingame/monaco-vscode-api/vscode/vs/platform/undoRedo/common/undoRedo";
+import { IUndoRedoService } from "@codingame/monaco-vscode-api/vscode/vs/platform/undoRedo/common/undoRedo.service";
+import { IEditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { IFilesConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { ICellEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { IChatAgentResult } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { ChatEditKind, IModifiedFileEntry, IModifiedFileEntryEditorIntegration, 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";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+declare class AutoAcceptControl {
+    readonly total: number;
+    readonly remaining: number;
+    readonly cancel: () => void;
+    constructor(total: number, remaining: number, cancel: () => void);
+}
+export declare const pendingRewriteMinimap: string;
+export declare abstract class AbstractChatEditingModifiedFileEntry extends Disposable implements IModifiedFileEntry {
+    readonly modifiedURI: URI;
+    protected _telemetryInfo: IModifiedEntryTelemetryInfo;
+    protected _fileConfigService: IFilesConfigurationService;
+    protected readonly _chatService: IChatService;
+    protected readonly _fileService: IFileService;
+    private readonly _undoRedoService;
+    protected readonly _instantiationService: IInstantiationService;
+    static readonly scheme = "modified-file-entry";
+    private static lastEntryId;
+    readonly entryId: string;
+    protected readonly _onDidDelete: Emitter<void>;
+    readonly onDidDelete: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    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>;
+    protected readonly _rewriteRatioObs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<number, void>;
+    readonly rewriteRatio: IObservable<number>;
+    private readonly _reviewModeTempObs;
+    readonly reviewMode: IObservable<boolean>;
+    private readonly _autoAcceptCtrl;
+    readonly autoAcceptController: IObservable<AutoAcceptControl | undefined>;
+    protected readonly _autoAcceptTimeout: IObservable<number>;
+    get telemetryInfo(): IModifiedEntryTelemetryInfo;
+    readonly createdInRequestId: string | undefined;
+    get lastModifyingRequestId(): string;
+    private _refCounter;
+    readonly abstract originalURI: URI;
+    constructor(modifiedURI: URI, _telemetryInfo: IModifiedEntryTelemetryInfo, kind: ChatEditKind, configService: IConfigurationService, _fileConfigService: IFilesConfigurationService, _chatService: IChatService, _fileService: IFileService, _undoRedoService: IUndoRedoService, _instantiationService: IInstantiationService);
+    dispose(): void;
+    acquire(): this;
+    enableReviewModeUntilSettled(): void;
+    updateTelemetryInfo(telemetryInfo: IModifiedEntryTelemetryInfo): void;
+    accept(tx: ITransaction | undefined): Promise<void>;
+    protected abstract _doAccept(tx: ITransaction | undefined): Promise<void>;
+    reject(tx: ITransaction | undefined): Promise<void>;
+    protected abstract _doReject(tx: ITransaction | undefined): Promise<void>;
+    private _notifyAction;
+    private readonly _editorIntegrations;
+    getEditorIntegration(pane: IEditorPane): IModifiedFileEntryEditorIntegration;
+    protected abstract _createEditorIntegration(editor: IEditorPane): IModifiedFileEntryEditorIntegration;
+    abstract readonly changesCount: IObservable<number>;
+    acceptStreamingEditsStart(responseModel: IChatResponseModel, tx: ITransaction): void;
+    protected abstract _createUndoRedoElement(response: IChatResponseModel): IUndoRedoElement | undefined;
+    abstract acceptAgentEdits(uri: URI, edits: (TextEdit | ICellEditOperation)[], isLastEdits: boolean, responseModel: IChatResponseModel): Promise<void>;
+    acceptStreamingEditsEnd(tx: ITransaction): Promise<void>;
+    protected abstract _areOriginalAndModifiedIdentical(): Promise<boolean>;
+    protected _resetEditsState(tx: ITransaction): void;
+    abstract createSnapshot(requestId: string | undefined, undoStop: string | undefined): ISnapshotEntry;
+    abstract equalsSnapshot(snapshot: ISnapshotEntry | undefined): boolean;
+    abstract restoreFromSnapshot(snapshot: ISnapshotEntry, restoreToDisk?: boolean): void;
+    abstract resetToInitialContent(): void;
+    abstract initialContent: string;
+}
+export interface IModifiedEntryTelemetryInfo {
+    readonly agentId: string | undefined;
+    readonly command: string | undefined;
+    readonly sessionId: string;
+    readonly requestId: string;
+    readonly result: IChatAgentResult | undefined;
+}
+export interface ISnapshotEntry {
+    readonly resource: URI;
+    readonly languageId: string;
+    readonly snapshotUri: URI;
+    readonly original: string;
+    readonly current: string;
+    readonly originalToCurrentEdit: OffsetEdit;
+    readonly state: WorkingSetEntryState;
+    telemetryInfo: IModifiedEntryTelemetryInfo;
+}
+export {};