@codingame/monaco-vscode-chat-service-override 1.85.1

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

@@ -0,0 +1,250 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { GlyphMarginLane } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { GutterActionsRegistry } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/editorLineNumberMenu';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { LOCALIZED_START_INLINE_CHAT_STRING } from './inlineChatActions.js';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+
+var InlineChatDecorationsContribution_1;
+const GUTTER_INLINE_CHAT_OPAQUE_ICON = registerIcon('inline-chat-opaque', Codicon.sparkle, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/browser/inlineChatDecorations',
+    'startInlineChatOpaqueIcon',
+    'Icon which spawns the inline chat from the gutter. It is half opaque by default and becomes completely opaque on hover.'
+)));
+const GUTTER_INLINE_CHAT_TRANSPARENT_ICON = registerIcon('inline-chat-transparent', Codicon.sparkle, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/browser/inlineChatDecorations',
+    'startInlineChatTransparentIcon',
+    'Icon which spawns the inline chat from the gutter. It is transparent by default and becomes opaque on hover.'
+)));
+let InlineChatDecorationsContribution = class InlineChatDecorationsContribution extends Disposable {
+    static { InlineChatDecorationsContribution_1 = this; }
+    static { this.TOOLBAR_SETTING_ID = 'inlineChat.showToolbarIcon'; }
+    static { this.GUTTER_SETTING_ID = 'inlineChat.showGutterIcon'; }
+    static { this.GUTTER_ICON_OPAQUE_CLASSNAME = 'codicon-inline-chat-opaque'; }
+    static { this.GUTTER_ICON_TRANSPARENT_CLASSNAME = 'codicon-inline-chat-transparent'; }
+    constructor(_editor, _contextKeyService, _inlineChatService, _inlineChatSessionService, _configurationService, _keybindingService, _debugService) {
+        super();
+        this._editor = _editor;
+        this._inlineChatService = _inlineChatService;
+        this._inlineChatSessionService = _inlineChatSessionService;
+        this._configurationService = _configurationService;
+        this._keybindingService = _keybindingService;
+        this._debugService = _debugService;
+        this._currentBreakpoints = [];
+        this._hasInlineChatSession = false;
+        this._hasActiveDebugSession = false;
+        this._debugSessions = ( new Set());
+        this._localToDispose = ( new DisposableStore());
+        this._gutterDecorationTransparent = this._registerGutterDecoration(true);
+        this._gutterDecorationOpaque = this._registerGutterDecoration(false);
+        this._register(this._configurationService.onDidChangeConfiguration((e) => {
+            if (!e.affectsConfiguration(InlineChatDecorationsContribution_1.GUTTER_SETTING_ID)) {
+                return;
+            }
+            this._onEnablementOrModelChanged();
+        }));
+        this._register(this._inlineChatSessionService.onWillStartSession((e) => {
+            if (e === this._editor) {
+                this._hasInlineChatSession = true;
+                this._onEnablementOrModelChanged();
+            }
+        }));
+        this._register(this._inlineChatSessionService.onDidEndSession((e) => {
+            if (e === this._editor) {
+                this._hasInlineChatSession = false;
+                this._onEnablementOrModelChanged();
+            }
+        }));
+        this._register(this._debugService.onWillNewSession((session) => {
+            this._debugSessions.add(session);
+            if (!this._hasActiveDebugSession) {
+                this._hasActiveDebugSession = true;
+                this._onEnablementOrModelChanged();
+            }
+        }));
+        this._register(this._debugService.onDidEndSession((session) => {
+            this._debugSessions.delete(session);
+            if (this._debugSessions.size === 0) {
+                this._hasActiveDebugSession = false;
+                this._onEnablementOrModelChanged();
+            }
+        }));
+        this._register(this._inlineChatService.onDidChangeProviders(() => this._onEnablementOrModelChanged()));
+        this._register(this._editor.onDidChangeModel(() => this._onEnablementOrModelChanged()));
+        this._register(this._keybindingService.onDidUpdateKeybindings(() => {
+            this._updateDecorationHover();
+            this._onEnablementOrModelChanged();
+        }));
+        this._updateDecorationHover();
+        this._onEnablementOrModelChanged();
+    }
+    _registerGutterDecoration(isTransparent) {
+        return ModelDecorationOptions.register({
+            description: 'inline-chat-decoration',
+            glyphMarginClassName: ThemeIcon.asClassName(isTransparent ? GUTTER_INLINE_CHAT_TRANSPARENT_ICON : GUTTER_INLINE_CHAT_OPAQUE_ICON),
+            glyphMargin: { position: GlyphMarginLane.Left },
+            stickiness: 1 ,
+        });
+    }
+    _updateDecorationHover() {
+        const keybinding = this._keybindingService.lookupKeybinding('inlineChat.start')?.getLabel() ?? undefined;
+        if (this._inlineChatKeybinding === keybinding) {
+            return;
+        }
+        this._inlineChatKeybinding = keybinding;
+        const hoverMessage = ( new MarkdownString(keybinding ? ( localizeWithPath(
+            'vs/workbench/contrib/inlineChat/browser/inlineChatDecorations',
+            'runWithKeybinding',
+            'Start Inline Chat ({0})',
+            keybinding
+        )) : LOCALIZED_START_INLINE_CHAT_STRING));
+        this._gutterDecorationTransparent.glyphMarginHoverMessage = hoverMessage;
+        this._gutterDecorationOpaque.glyphMarginHoverMessage = hoverMessage;
+    }
+    _updateCurrentBreakpoints(uri) {
+        this._currentBreakpoints = this._debugService.getModel().getBreakpoints({ uri });
+    }
+    _onEnablementOrModelChanged() {
+        this._localToDispose.clear();
+        if (!this._editor.hasModel() || this._hasActiveDebugSession || this._hasInlineChatSession || this._showGutterIconMode() === "never"  || !this._hasProvider()) {
+            return;
+        }
+        const editor = this._editor;
+        const decorationUpdateScheduler = ( new RunOnceScheduler(() => this._onSelectionOrContentChanged(editor), 100));
+        this._localToDispose.add(decorationUpdateScheduler);
+        this._localToDispose.add(this._debugService.getModel().onDidChangeBreakpoints(() => {
+            this._updateCurrentBreakpoints(editor.getModel().uri);
+            decorationUpdateScheduler.schedule();
+        }));
+        this._localToDispose.add(this._editor.onDidChangeCursorSelection(() => decorationUpdateScheduler.schedule()));
+        this._localToDispose.add(this._editor.onDidChangeModelContent(() => decorationUpdateScheduler.schedule()));
+        this._localToDispose.add(this._editor.onMouseDown(async (e) => {
+            const showGutterIconMode = this._showGutterIconMode();
+            const gutterDecorationClassName = showGutterIconMode === "always"  ?
+                InlineChatDecorationsContribution_1.GUTTER_ICON_OPAQUE_CLASSNAME :
+                (showGutterIconMode === "mouseover"  ?
+                    InlineChatDecorationsContribution_1.GUTTER_ICON_TRANSPARENT_CLASSNAME : undefined);
+            if (!gutterDecorationClassName || !e.target.element?.classList.contains(gutterDecorationClassName)) {
+                return;
+            }
+            InlineChatController.get(this._editor)?.run();
+        }));
+        this._localToDispose.add({
+            dispose: () => {
+                if (this._gutterDecorationID) {
+                    this._removeGutterDecoration(this._gutterDecorationID);
+                }
+            }
+        });
+        this._updateCurrentBreakpoints(editor.getModel().uri);
+        decorationUpdateScheduler.schedule();
+    }
+    _onSelectionOrContentChanged(editor) {
+        const selection = editor.getSelection();
+        const startLineNumber = selection.startLineNumber;
+        const model = editor.getModel();
+        let isEnabled = false;
+        const hasBreakpoint = ( this._currentBreakpoints.some(bp => bp.lineNumber === startLineNumber));
+        if (!hasBreakpoint) {
+            const selectionIsEmpty = selection.isEmpty();
+            if (selectionIsEmpty) {
+                if (/^\s*$/g.test(model.getLineContent(startLineNumber))) {
+                    isEnabled = true;
+                }
+            }
+            else {
+                const startPosition = selection.getStartPosition();
+                const endPosition = selection.getEndPosition();
+                const startWord = model.getWordAtPosition(startPosition);
+                const endWord = model.getWordAtPosition(endPosition);
+                const isFirstWordCoveredOrNull = !!startWord ? startPosition.column <= startWord.startColumn : true;
+                const isLastWordCoveredOrNull = !!endWord ? endPosition.column >= endWord.endColumn : true;
+                isEnabled = isFirstWordCoveredOrNull && isLastWordCoveredOrNull;
+            }
+        }
+        if (isEnabled) {
+            if (this._gutterDecorationID === undefined) {
+                this._addGutterDecoration(startLineNumber);
+            }
+            else {
+                const decorationRange = model.getDecorationRange(this._gutterDecorationID);
+                if (decorationRange?.startLineNumber !== startLineNumber) {
+                    this._updateGutterDecoration(this._gutterDecorationID, startLineNumber);
+                }
+            }
+        }
+        else if (this._gutterDecorationID) {
+            this._removeGutterDecoration(this._gutterDecorationID);
+        }
+    }
+    _showGutterIconMode() {
+        return this._configurationService.getValue(InlineChatDecorationsContribution_1.GUTTER_SETTING_ID);
+    }
+    _hasProvider() {
+        return !Iterable.isEmpty(this._inlineChatService.getAllProvider());
+    }
+    _addGutterDecoration(lineNumber) {
+        this._editor.changeDecorations((accessor) => {
+            const showGutterIconMode = this._showGutterIconMode();
+            if (showGutterIconMode === "never" ) {
+                return;
+            }
+            this._gutterDecorationID = accessor.addDecoration(( new Range(lineNumber, 0, lineNumber, 0)), showGutterIconMode === "always"  ? this._gutterDecorationOpaque : this._gutterDecorationTransparent);
+        });
+    }
+    _removeGutterDecoration(decorationId) {
+        this._editor.changeDecorations((accessor) => {
+            accessor.removeDecoration(decorationId);
+        });
+        this._gutterDecorationID = undefined;
+    }
+    _updateGutterDecoration(decorationId, lineNumber) {
+        this._editor.changeDecorations((accessor) => {
+            accessor.changeDecoration(decorationId, ( new Range(lineNumber, 0, lineNumber, 0)));
+        });
+    }
+    dispose() {
+        super.dispose();
+        this._localToDispose.dispose();
+    }
+};
+InlineChatDecorationsContribution = InlineChatDecorationsContribution_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IInlineChatService)),
+    ( __param(3, IInlineChatSessionService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IDebugService))
+], InlineChatDecorationsContribution));
+GutterActionsRegistry.registerGutterActionsGenerator(({ lineNumber, editor, accessor }, result) => {
+    const inlineChatService = accessor.get(IInlineChatService);
+    const noProviders = Iterable.isEmpty(inlineChatService.getAllProvider());
+    if (noProviders) {
+        return;
+    }
+    const preferencesService = accessor.get(IPreferencesService);
+    result.push(( new Action('inlineChat.configureShowGutterIcon', ( localizeWithPath(
+        'vs/workbench/contrib/inlineChat/browser/inlineChatDecorations',
+        'configureShowGutterIcon',
+        "Configure Inline Chat Icon"
+    )), undefined, true, () => { preferencesService.openUserSettings({ query: 'inlineChat.showGutterIcon' }); })));
+});
+
+export { InlineChatDecorationsContribution };

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

@@ -0,0 +1,62 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { illegalState } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+let InlineChatNotebookContribution = class InlineChatNotebookContribution {
+    constructor(sessionService, notebookEditorService) {
+        this._store = ( new DisposableStore());
+        this._store.add(sessionService.registerSessionKeyComputer(Schemas.vscodeNotebookCell, {
+            getComparisonKey: (_editor, uri) => {
+                const data = CellUri.parse(uri);
+                if (!data) {
+                    throw illegalState('Expected notebook');
+                }
+                for (const editor of notebookEditorService.listNotebookEditors()) {
+                    if (isEqual(editor.textModel?.uri, data.notebook)) {
+                        return `<notebook>${editor.getId()}#${uri}`;
+                    }
+                }
+                throw illegalState('Expected notebook');
+            }
+        }));
+        this._store.add(sessionService.onWillStartSession(newSessionEditor => {
+            const candidate = CellUri.parse(newSessionEditor.getModel().uri);
+            if (!candidate) {
+                return;
+            }
+            for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
+                if (isEqual(notebookEditor.textModel?.uri, candidate.notebook)) {
+                    let found = false;
+                    const editors = [];
+                    for (const [, codeEditor] of notebookEditor.codeEditors) {
+                        editors.push(codeEditor);
+                        found = codeEditor === newSessionEditor || found;
+                    }
+                    if (found) {
+                        for (const editor of editors) {
+                            if (editor !== newSessionEditor) {
+                                InlineChatController.get(editor)?.finishExistingSession();
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+InlineChatNotebookContribution = ( __decorate([
+    ( __param(0, IInlineChatSessionService)),
+    ( __param(1, INotebookEditorService))
+], InlineChatNotebookContribution));
+
+export { InlineChatNotebookContribution };

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

@@ -0,0 +1,35 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+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._ctxHasProvider = CTX_INLINE_CHAT_HAS_PROVIDER.bindTo(contextKeyService);
+    }
+    addProvider(provider) {
+        const rm = this._entries.push(provider);
+        this._ctxHasProvider.set(true);
+        this._onDidChangeProviders.fire();
+        return toDisposable(() => {
+            rm();
+            this._ctxHasProvider.set(this._entries.size > 0);
+            this._onDidChangeProviders.fire();
+        });
+    }
+    getAllProvider() {
+        return [...this._entries].reverse();
+    }
+};
+InlineChatServiceImpl = ( __decorate([
+    ( __param(0, IContextKeyService))
+], InlineChatServiceImpl));
+
+export { InlineChatServiceImpl };