@codingame/monaco-vscode-chat-service-override 2.2.2 → 3.0.0

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

@@ -15,10 +15,12 @@ import { IEditorWorkerService } from 'vscode/vscode/vs/editor/common/services/ed
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { UntitledTextEditorInput } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput';
+import { DEFAULT_EDITOR_ASSOCIATION } from 'vscode/vscode/vs/workbench/common/editor';
 
 let InlineChatSessionServiceImpl = class InlineChatSessionServiceImpl {
-    constructor(_inlineChatService, _telemetryService, _modelService, _textModelService, _editorWorkerService, _logService, _instaService, _textFileService) {
+    constructor(_inlineChatService, _telemetryService, _modelService, _textModelService, _editorWorkerService, _logService, _instaService, _editorService) {
         this._inlineChatService = _inlineChatService;
         this._telemetryService = _telemetryService;
         this._modelService = _modelService;
@@ -26,7 +28,7 @@ let InlineChatSessionServiceImpl = class InlineChatSessionServiceImpl {
         this._editorWorkerService = _editorWorkerService;
         this._logService = _logService;
         this._instaService = _instaService;
-        this._textFileService = _textFileService;
+        this._editorService = _editorService;
         this._onWillStartSession = ( new Emitter());
         this.onWillStartSession = this._onWillStartSession.event;
         this._onDidMoveSession = ( new Emitter());
@@ -68,33 +70,40 @@ let InlineChatSessionServiceImpl = class InlineChatSessionServiceImpl {
             return undefined;
         }
         this._logService.trace('[IE] NEW session', provider.debugName);
-        this._logService.trace(`[IE] creating NEW session for ${editor.getId()},  ${provider.debugName}`);
+        this._logService.trace(`[IE] creating NEW session for ${editor.getId()}, ${provider.debugName}`);
         const store = ( new DisposableStore());
+        store.add(this._inlineChatService.onDidChangeProviders(e => {
+            if (e.removed === provider) {
+                this._logService.trace(`[IE] provider GONE for ${editor.getId()}, ${provider.debugName}`);
+                this._releaseSession(session, true);
+            }
+        }));
         const id = generateUuid();
         const targetUri = textModel.uri;
         let textModelN;
         if (options.editMode === "preview" ) {
-            textModelN = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.inMemory, query: ( ( new URLSearchParams({ id, 'inline-chat-textModelN': '' })).toString()) }), true));
+            textModelN = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.vscode, authority: 'inline-chat', path: '', query: ( ( new URLSearchParams({ id, 'textModelN': '' })).toString()) })));
         }
         else {
             store.add((await this._textModelService.createModelReference(textModel.uri)));
             textModelN = textModel;
         }
-        const textModel0 = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.inMemory, query: ( ( new URLSearchParams({ id, 'inline-chat-textModel0': '' })).toString()) }), true));
+        const textModel0 = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.vscode, authority: 'inline-chat', path: '', query: ( ( new URLSearchParams({ id, 'textModel0': '' })).toString()) }), true));
         if (targetUri.scheme === Schemas.untitled) {
-            const untitledTextModel = this._textFileService.untitled.get(targetUri);
-            if (untitledTextModel) {
-                store.add(untitledTextModel.onDidChangeDirty(() => {
-                    if (!untitledTextModel.isDirty()) {
-                        this.releaseSession(session);
-                    }
-                }));
-            }
+            store.add(this._editorService.onDidCloseEditor(() => {
+                if (!this._editorService.isOpened({ resource: targetUri, typeId: UntitledTextEditorInput.ID, editorId: DEFAULT_EDITOR_ASSOCIATION.id })) {
+                    this._releaseSession(session, true);
+                }
+            }));
         }
         let wholeRange = options.wholeRange;
         if (!wholeRange) {
             wholeRange = rawSession.wholeRange ? Range.lift(rawSession.wholeRange) : editor.getSelection();
         }
+        if (token.isCancellationRequested) {
+            store.dispose();
+            return undefined;
+        }
         const session = ( new Session(
             options.editMode,
             targetUri,
@@ -140,22 +149,26 @@ let InlineChatSessionServiceImpl = class InlineChatSessionServiceImpl {
         }
     }
     releaseSession(session) {
-        let data;
-        for (const [key, value] of this._sessions) {
-            if (value.session === session) {
-                data = value;
-                value.store.dispose();
-                this._sessions.delete(key);
-                this._logService.trace(`[IE] did RELEASED session for ${value.editor.getId()}, ${session.provider.debugName}`);
+        this._releaseSession(session, false);
+    }
+    _releaseSession(session, byServer) {
+        let tuple;
+        for (const candidate of this._sessions) {
+            if (candidate[1].session === session) {
+                tuple = candidate;
                 break;
             }
         }
-        if (!data) {
+        if (!tuple) {
             return;
         }
         this._keepRecording(session);
         this._telemetryService.publicLog2('interactiveEditor/session', session.asTelemetryData());
-        this._onDidEndSession.fire({ editor: data.editor, session });
+        const [key, value] = tuple;
+        this._sessions.delete(key);
+        this._logService.trace(`[IE] did RELEASED session for ${value.editor.getId()}, ${session.provider.debugName}`);
+        this._onDidEndSession.fire({ editor: value.editor, session, endedByExternalCause: byServer });
+        value.store.dispose();
     }
     stashSession(session, editor, undoCancelEdits) {
         this._keepRecording(session);
@@ -204,7 +217,7 @@ InlineChatSessionServiceImpl = ( __decorate([
     ( __param(4, IEditorWorkerService)),
     ( __param(5, ILogService)),
     ( __param(6, IInstantiationService)),
-    ( __param(7, ITextFileService))
+    ( __param(7, IEditorService))
 ], InlineChatSessionServiceImpl));
 
 export { InlineChatSessionServiceImpl };

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChatServiceImpl.js

@@ -6,22 +6,20 @@ import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/
 import { CTX_INLINE_CHAT_HAS_PROVIDER } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 
 let InlineChatServiceImpl = class InlineChatServiceImpl {
-    get onDidChangeProviders() {
-        return this._onDidChangeProviders.event;
-    }
     constructor(contextKeyService) {
-        this._entries = ( new LinkedList());
         this._onDidChangeProviders = ( new Emitter());
+        this._entries = ( new LinkedList());
+        this.onDidChangeProviders = this._onDidChangeProviders.event;
         this._ctxHasProvider = CTX_INLINE_CHAT_HAS_PROVIDER.bindTo(contextKeyService);
     }
     addProvider(provider) {
         const rm = this._entries.push(provider);
         this._ctxHasProvider.set(true);
-        this._onDidChangeProviders.fire();
+        this._onDidChangeProviders.fire({ added: provider });
         return toDisposable(() => {
             rm();
             this._ctxHasProvider.set(this._entries.size > 0);
-            this._onDidChangeProviders.fire();
+            this._onDidChangeProviders.fire({ removed: provider });
         });
     }
     getAllProvider() {

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

@@ -1,94 +0,0 @@
-import { KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
-import { EditorAction2 } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { InlineChatController, InlineChatRunOptions } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { LOCALIZED_START_INLINE_CHAT_STRING, AbstractInlineChatAction, START_INLINE_CHAT } from './inlineChatActions.js';
-import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
-import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { CTX_INLINE_CHAT_HAS_PROVIDER, CTX_INLINE_CHAT_VISIBLE } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ISpeechService, HasSpeechProvider } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
-import { localize2WithPath } from 'vscode/vscode/vs/nls';
-
-class StartSessionAction extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'inlineChat.start',
-            title: { value: LOCALIZED_START_INLINE_CHAT_STRING, original: 'Start Inline Chat' },
-            category: AbstractInlineChatAction.category,
-            f1: true,
-            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_PROVIDER, EditorContextKeys.writable)),
-            keybinding: {
-                when: EditorContextKeys.focus,
-                weight: 200 ,
-                primary: 2048  | 39 ,
-                secondary: [KeyChord(2048  | 41 , 39 )],
-            },
-            icon: START_INLINE_CHAT
-        });
-    }
-    runEditorCommand(accessor, editor, ..._args) {
-        const configService = accessor.get(IConfigurationService);
-        const speechService = accessor.get(ISpeechService);
-        if (configService.getValue("inlineChat.holdToSpeech" )
-            && speechService.hasSpeechProvider
-        ) {
-            holdForSpeech(accessor, InlineChatController.get(editor), this.desc.id);
-        }
-        let options;
-        const arg = _args[0];
-        if (arg && InlineChatRunOptions.isInteractiveEditorOptions(arg)) {
-            options = arg;
-        }
-        InlineChatController.get(editor)?.run({ ...options });
-    }
-}
-class HoldToSpeak extends AbstractInlineChatAction {
-    constructor() {
-        super({
-            id: 'inlineChat.holdForSpeech',
-            precondition: ( ContextKeyExpr.and(HasSpeechProvider, CTX_INLINE_CHAT_VISIBLE)),
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatActions2',
-                'holdForSpeech',
-                "Hold for Speech"
-            )),
-            keybinding: {
-                when: EditorContextKeys.textInputFocus,
-                weight: 200 ,
-                primary: 2048  | 39 ,
-            },
-        });
-    }
-    runInlineChatCommand(accessor, ctrl, editor, ...args) {
-        holdForSpeech(accessor, ctrl, this.desc.id);
-    }
-}
-function holdForSpeech(accessor, ctrl, commandId) {
-    const keybindingService = accessor.get(IKeybindingService);
-    const commandService = accessor.get(ICommandService);
-    if (!ctrl) {
-        return;
-    }
-    const holdMode = keybindingService.enableKeybindingHoldMode(commandId);
-    if (!holdMode) {
-        return;
-    }
-    let listening = false;
-    const handle = disposableTimeout(() => {
-        commandService.executeCommand('workbench.action.chat.startVoiceChat', { voice: { disableTimeout: true } });
-        listening = true;
-    }, 250);
-    holdMode.finally(() => {
-        if (listening) {
-            commandService.executeCommand('workbench.action.chat.stopListening').finally(() => {
-                ctrl.acceptInput();
-            });
-        }
-        handle.dispose();
-    });
-}
-
-export { HoldToSpeak, StartSessionAction };