@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatEditReviewSession.js

@@ -0,0 +1,323 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+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 { 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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { ChatEditKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
+import { ChatEditingModifiedDocumentEntry } from '../../chat/browser/chatEditing/chatEditingModifiedDocumentEntry.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+let InlineChatEditReviewSession = class InlineChatEditReviewSession extends Disposable {
+    constructor(
+        chatSessionResource,
+        _targetUri,
+        _instantiationService,
+        _textModelService,
+        _textFileService,
+        _filesConfigurationService,
+        _logService,
+        _fileService
+    ) {
+        super();
+        this.chatSessionResource = chatSessionResource;
+        this._targetUri = _targetUri;
+        this._instantiationService = _instantiationService;
+        this._textModelService = _textModelService;
+        this._textFileService = _textFileService;
+        this._filesConfigurationService = _filesConfigurationService;
+        this._logService = _logService;
+        this._fileService = _fileService;
+        this.isGlobalEditingSession = false;
+        this._entriesObs = observableValue(this, []);
+        this.entries = this._entriesObs;
+        this._entries = ( new ResourceMap());
+        this._initialContents = ( new ResourceMap());
+        this._readonlyLocks = ( new ResourceMap());
+        this._externalEditListener = this._register(( new MutableDisposable()));
+        this._externalEditEntriesInFlight = ( new ResourceMap());
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+    }
+    async beginTurn(response) {
+        this._requestId = response.requestId;
+        this._externalEditListener.clear();
+        try {
+            if (this._textFileService.isDirty(this._targetUri)) {
+                const saved = await this._textFileService.save(this._targetUri);
+                if (this._store.isDisposed) {
+                    return;
+                }
+                if (!saved) {
+                    throw ( new CancellationError());
+                }
+            }
+            this._readonlyLocks.set(this._targetUri, true);
+            await this._filesConfigurationService.updateReadonly(this._targetUri, this._getReadonlyMessage());
+            if (this._store.isDisposed) {
+                return;
+            }
+            let initialContent;
+            if (!( this._entries.has(this._targetUri))) {
+                initialContent = await this._readCurrentContent(this._targetUri);
+                if (this._store.isDisposed) {
+                    return;
+                }
+                this._initialContents.set(this._targetUri, initialContent);
+            } else {
+                initialContent = this._initialContents.get(this._targetUri) ?? "";
+            }
+            const entry = await this._getOrCreateEntry(this._targetUri, this._getTelemetryInfo(response), initialContent);
+            if (this._store.isDisposed || !entry) {
+                return;
+            }
+            for (const tracked of ( this._entries.values())) {
+                tracked.startExternalEdit();
+            }
+            this._externalEditListener.value = response.onDidChange(() => {
+                void this._processExternalEdits(response);
+            });
+            void this._processExternalEdits(response);
+        } catch (error) {
+            this._logService.error(`Failed to prepare inline chat review for ${this._targetUri}`, error);
+            await this._resetReadonlyLocks();
+            throw error;
+        }
+    }
+    async endTurn(response) {
+        this._externalEditListener.clear();
+        try {
+            await this._processExternalEdits(response);
+            if (this._store.isDisposed) {
+                return;
+            }
+        } finally {
+            if (!this._store.isDisposed) {
+                for (const entry of ( this._entries.values())) {
+                    try {
+                        await entry.revertToDisk();
+                    } catch (error) {
+                        this._logService.error(
+                            `Failed to reload inline chat review entry from disk for ${entry.modifiedURI}`,
+                            error
+                        );
+                    }
+                }
+                for (const entry of ( this._entries.values())) {
+                    entry.stopExternalEdit();
+                }
+            }
+            await this._resetReadonlyLocks();
+        }
+    }
+    getEntry(uri) {
+        return this._entries.get(uri);
+    }
+    readEntry(uri, reader) {
+        this._entriesObs.read(reader);
+        return this._entries.get(uri);
+    }
+    async accept(...uris) {
+        await Promise.all(( this._getEntries(uris).map(entry => entry.accept())));
+    }
+    async reject(...uris) {
+        await Promise.all(( this._getEntries(uris).map(entry => entry.reject())));
+    }
+    dispose() {
+        this._externalEditListener.clear();
+        this._onDidDispose.fire();
+        for (const entry of ( this._entries.values())) {
+            entry.stopExternalEdit();
+        }
+        void this._resetReadonlyLocks();
+        super.dispose();
+    }
+    _getEntries(uris) {
+        const entries = [...( this._entries.values())];
+        return uris.length === 0 ? entries : entries.filter(entry => ( uris.some(uri => isEqual(entry.modifiedURI, uri))));
+    }
+    async _processExternalEdits(response) {
+        for (const part of response.response.value) {
+            if (part.kind !== "externalEdit") {
+                continue;
+            }
+            try {
+                await this._getOrCreateExternalEditEntry(part, this._getTelemetryInfo(response));
+                if (this._store.isDisposed) {
+                    return;
+                }
+            } catch (error) {
+                this._logService.error(`Failed to create inline chat review entry for ${part.uri}`, error);
+            }
+        }
+    }
+    async _getOrCreateExternalEditEntry(edit, telemetryInfo) {
+        if (edit.editKind === "delete" || edit.editKind === "rename" || isEqual(edit.uri, this._targetUri)) {
+            return;
+        }
+        if (( this._entries.has(edit.uri))) {
+            const entry = await this._getOrCreateEntry(edit.uri, telemetryInfo, this._initialContents.get(edit.uri) ?? "");
+            if (this._store.isDisposed || !entry) {
+                return;
+            }
+            entry.startExternalEdit();
+            return;
+        }
+        const inFlight = this._externalEditEntriesInFlight.get(edit.uri);
+        if (inFlight) {
+            await inFlight;
+            if (this._store.isDisposed) {
+                return;
+            }
+            return;
+        }
+        const createEntry = this._createExternalEditEntry(edit, telemetryInfo);
+        this._externalEditEntriesInFlight.set(edit.uri, createEntry);
+        try {
+            await createEntry;
+            if (this._store.isDisposed) {
+                return;
+            }
+        } finally {
+            if (this._externalEditEntriesInFlight.get(edit.uri) === createEntry) {
+                this._externalEditEntriesInFlight.delete(edit.uri);
+            }
+        }
+    }
+    async _createExternalEditEntry(edit, telemetryInfo) {
+        let initialContent = this._initialContents.get(edit.uri);
+        if (initialContent === undefined) {
+            initialContent = await this._readBeforeContent(edit);
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._initialContents.set(edit.uri, initialContent);
+        }
+        const editKind = edit.editKind === "create" ? ChatEditKind.Created : ChatEditKind.Modified;
+        await this._getOrCreateEntry(edit.uri, telemetryInfo, initialContent, true, editKind);
+        if (this._store.isDisposed) {
+            return;
+        }
+    }
+    async _readCurrentContent(resource) {
+        try {
+            const ref = await this._textModelService.createModelReference(resource);
+            try {
+                return ref.object.textEditorModel.getValue();
+            } finally {
+                ref.dispose();
+            }
+        } catch (error) {
+            this._logService.warn(
+                `Failed to read model content for ${resource}; reading from disk instead.`,
+                error
+            );
+            return ( (await this._fileService.readFile(resource)).value.toString());
+        }
+    }
+    async _readBeforeContent(edit) {
+        if (!edit.beforeContentUri) {
+            return "";
+        }
+        try {
+            return ( (await this._fileService.readFile(edit.beforeContentUri)).value.toString());
+        } catch (error) {
+            this._logService.warn(`Failed to read pre-edit content for ${edit.uri}.`, error);
+            return "";
+        }
+    }
+    async _getOrCreateEntry(
+        resource,
+        telemetryInfo,
+        initialContent,
+        startExternalEdit = false,
+        editKind = ChatEditKind.Modified
+    ) {
+        const existingEntry = this._entries.get(resource);
+        if (existingEntry) {
+            if (telemetryInfo.requestId !== existingEntry.telemetryInfo.requestId) {
+                existingEntry.updateTelemetryInfo(telemetryInfo);
+            }
+            if (startExternalEdit) {
+                existingEntry.startExternalEdit();
+            }
+            return existingEntry;
+        }
+        const ref = await this._textModelService.createModelReference(resource);
+        if (this._store.isDisposed) {
+            ref.dispose();
+            return undefined;
+        }
+        const entry = this._register(
+            this._instantiationService.createInstance(ChatEditingModifiedDocumentEntry, ref, {
+                collapse: _tx => {}
+            }, telemetryInfo, editKind, initialContent)
+        );
+        if (startExternalEdit) {
+            entry.startExternalEdit();
+        }
+        this._entries.set(resource, entry);
+        this._entriesObs.set([...( this._entries.values())], undefined);
+        return entry;
+    }
+    _getTelemetryInfo(response) {
+        const requestId = this._requestId ?? response.requestId;
+        return new class {
+            get agentId() {
+                return response.agent?.id;
+            }
+            get modelId() {
+                return response.request?.modelId;
+            }
+            get modeId() {
+                return response.request?.modeInfo?.telemetryModeId;
+            }
+            get command() {
+                return response.slashCommand?.name;
+            }
+            get sessionResource() {
+                return response.session.sessionResource;
+            }
+            get requestId() {
+                return requestId;
+            }
+            get result() {
+                return response.result;
+            }
+            get applyCodeBlockSuggestionId() {
+                return response.request?.modeInfo?.applyCodeBlockSuggestionId;
+            }
+            get feature() {
+                return "inlineChat";
+            }
+        }();
+    }
+    _getReadonlyMessage() {
+        return {
+            value: ( localize(13083, "Editor is read-only while Copilot is editing this file."))
+        };
+    }
+    async _resetReadonlyLocks() {
+        const resources = [...( this._readonlyLocks.keys())];
+        this._readonlyLocks.clear();
+        for (const resource of resources) {
+            try {
+                await this._filesConfigurationService.updateReadonly(resource, "reset");
+            } catch (error) {
+                this._logService.error(`Failed to release inline chat read-only lock for ${resource}`, error);
+            }
+        }
+    }
+};
+InlineChatEditReviewSession = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, ITextModelService)), ( __param(4, ITextFileService)), ( __param(5, IFilesConfigurationService)), ( __param(6, ILogService)), ( __param(7, IFileService))], InlineChatEditReviewSession));
+
+export { InlineChatEditReviewSession };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionResolver.d.ts

@@ -0,0 +1,30 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+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 { IChatModelReference } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { ResolvedChatSessionsExtensionPoint } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IInlineChatSessionResolver } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionResolver.service";
+/** Result of resolving the chat model used by the editor inline chat surface. */
+export interface IInlineChatSessionResolution {
+    readonly modelRef: IChatModelReference;
+    /**
+     * The chat session contribution the widget must lock to so requests carry
+     * `agentIdSilent` and reach the Agent Host agent instead of the default inline
+     * participant. `undefined` for a local fallback session, which must stay on the
+     * legacy extension-host agent.
+     */
+    readonly lockToAgent: ResolvedChatSessionsExtensionPoint | undefined;
+}
+/** Builds the Agent Host metadata for an editor inline chat session. */
+export declare function getInlineChatSessionMeta(languageId: string | undefined, targetUri: URI): Record<string, unknown>;
+/** Applies editor inline chat-specific Agent Host and local-session fallback policy. */
+export declare class InlineChatSessionResolver implements IInlineChatSessionResolver {
+    private readonly _chatSessionsService;
+    private readonly _chatService;
+    private readonly _configurationService;
+    readonly _serviceBrand: undefined;
+    constructor(_chatSessionsService: IChatSessionsService, _chatService: IChatService, _configurationService: IConfigurationService);
+    resolve(token: CancellationToken, languageId: string | undefined, targetUri: URI): Promise<IInlineChatSessionResolution | undefined>;
+}

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionResolver.js

@@ -0,0 +1,79 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { isCancellationError, onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { withChatSurfaceMeta } from '../../../../platform/agentHost/common/meta/agentChatSurfaceMeta.js';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatConfiguration, ChatAgentLocation, getLocalFallbackSessionTypeSelectionReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { SessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+
+function getInlineChatSessionMeta(languageId, targetUri) {
+    return withChatSurfaceMeta(undefined, {
+        surface: "editorInline",
+        languageId,
+        targetUri: ( targetUri.toString())
+    });
+}
+let InlineChatSessionResolver = class InlineChatSessionResolver {
+    constructor(_chatSessionsService, _chatService, _configurationService) {
+        this._chatSessionsService = _chatSessionsService;
+        this._chatService = _chatService;
+        this._configurationService = _configurationService;
+    }
+    async resolve(token, languageId, targetUri) {
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const meta = getInlineChatSessionMeta(languageId, targetUri);
+        let modelRef;
+        const agentHostEnabled = this._configurationService.getValue(ChatConfiguration.InlineChatAgentHostEnabled) === true;
+        const contribution = agentHostEnabled ? this._chatSessionsService.getChatSessionContribution(SessionType.AgentHostCopilot) : undefined;
+        const didAttemptAgentHost = contribution?.locations?.includes(ChatAgentLocation.EditorInline) === true;
+        if (didAttemptAgentHost) {
+            try {
+                const item = await this._chatSessionsService.createNewChatSessionItem(SessionType.AgentHostCopilot, {
+                    prompt: "",
+                    isEphemeral: true,
+                    _meta: meta
+                }, token);
+                modelRef = item && (await this._chatService.acquireOrLoadSession(
+                    item.resource,
+                    ChatAgentLocation.EditorInline,
+                    token,
+                    "InlineChatSessionResolver#resolve"
+                ));
+            } catch (error) {
+                if (isCancellationError(error) || token.isCancellationRequested) {
+                    throw error;
+                }
+                onUnexpectedError(error);
+            }
+        }
+        if (token.isCancellationRequested) {
+            modelRef?.dispose();
+            return undefined;
+        }
+        if (modelRef) {
+            return {
+                modelRef,
+                lockToAgent: contribution
+            };
+        }
+        modelRef = this._chatService.startNewLocalSession(ChatAgentLocation.EditorInline, {
+            canUseTools: false ,
+            sessionTypeSelectionReason: didAttemptAgentHost ? getLocalFallbackSessionTypeSelectionReason(SessionType.AgentHostCopilot, false) : undefined
+        });
+        if (token.isCancellationRequested) {
+            modelRef.dispose();
+            return undefined;
+        }
+        return {
+            modelRef,
+            lockToAgent: undefined
+        };
+    }
+};
+InlineChatSessionResolver = ( __decorate([( __param(0, IChatSessionsService)), ( __param(1, IChatService)), ( __param(2, IConfigurationService))], InlineChatSessionResolver));
+
+export { InlineChatSessionResolver, getInlineChatSessionMeta };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionServiceImpl.d.ts

@@ -1,16 +1,20 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IActiveCodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
 import { IInlineChatSession } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService";
 import { IInlineChatSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
+import { IInlineChatSessionResolver } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionResolver.service";
 export declare class InlineChatError extends Error {
     static readonly code = "InlineChatError";
     constructor(message: string);
@@ -20,9 +24,9 @@ export declare class InlineChatSessionServiceImpl implements IInlineChatSessionS
     _serviceBrand: undefined;
     readonly onWillStartSession: Event<IActiveCodeEditor>;
     readonly onDidChangeSessions: Event<this>;
-    constructor(chatService: IChatService, chatAgentService: IChatAgentService);
+    constructor(chatService: IChatService, chatAgentService: IChatAgentService, inlineChatSessionResolver: IInlineChatSessionResolver, instantiationService: IInstantiationService, chatEditingService: IChatEditingService);
     dispose(): void;
-    createSession(editor: IActiveCodeEditor): IInlineChatSession;
+    createSession(editor: IActiveCodeEditor, isNotebook: boolean, token: CancellationToken): Promise<IInlineChatSession>;
     getSessionByTextModel(uri: URI): IInlineChatSession | undefined;
     getSessionBySessionUri(sessionResource: URI): IInlineChatSession | undefined;
 }