@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,54 @@
+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 { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
+import { Location } 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 { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatRequestImplicitVariableEntry, IChatRequestVariableEntry, StringChatContextValue } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries";
+import { ILanguageModelIgnoredFilesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/ignoredFiles.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatContextService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextService.service";
+export declare class ChatImplicitContextContribution extends Disposable implements IWorkbenchContribution {
+    private readonly codeEditorService;
+    private readonly editorService;
+    private readonly chatWidgetService;
+    private readonly chatService;
+    private readonly chatEditingService;
+    private readonly configurationService;
+    private readonly ignoredFilesService;
+    private readonly chatContextService;
+    static readonly ID = "chat.implicitContext";
+    private readonly _currentCancelTokenSource;
+    private _implicitContextEnablement;
+    constructor(codeEditorService: ICodeEditorService, editorService: IEditorService, chatWidgetService: IChatWidgetService, chatService: IChatService, chatEditingService: IChatEditingService, configurationService: IConfigurationService, ignoredFilesService: ILanguageModelIgnoredFilesService, chatContextService: IChatContextService);
+    private findActiveCodeEditor;
+    private findActiveWebviewEditor;
+    private findActiveNotebookEditor;
+    private updateImplicitContext;
+}
+export declare class ChatImplicitContext extends Disposable implements IChatRequestImplicitVariableEntry {
+    get id(): "vscode.implicit.selection" | "vscode.implicit.file" | "vscode.implicit.string" | "vscode.implicit.viewport" | "vscode.implicit";
+    get name(): string;
+    readonly kind = "implicit";
+    get modelDescription(): string;
+    readonly isFile = true;
+    private _isSelection;
+    get isSelection(): boolean;
+    private _onDidChangeValue;
+    readonly onDidChangeValue: Event<void>;
+    private _value;
+    get value(): URI | Location | StringChatContextValue | undefined;
+    private _enabled;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    private _uri;
+    get uri(): URI | undefined;
+    get icon(): ThemeIcon | undefined;
+    setValue(value: Location | URI | StringChatContextValue | undefined, isSelection: boolean, languageId?: string): void;
+    toBaseEntries(): IChatRequestVariableEntry[];
+}

package/vscode/src/vs/workbench/contrib/chat/browser/contrib/chatImplicitContext.js

@@ -0,0 +1,345 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { getCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { EditorsOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { WebviewInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { isStringImplicitContextValue } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelIgnoredFilesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/ignoredFiles.service';
+import { getPromptsTypeForLanguageId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatContextService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let ChatImplicitContextContribution = class ChatImplicitContextContribution extends Disposable {
+    static { this.ID = 'chat.implicitContext'; }
+    constructor(codeEditorService, editorService, chatWidgetService, chatService, chatEditingService, configurationService, ignoredFilesService, chatContextService) {
+        super();
+        this.codeEditorService = codeEditorService;
+        this.editorService = editorService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatService = chatService;
+        this.chatEditingService = chatEditingService;
+        this.configurationService = configurationService;
+        this.ignoredFilesService = ignoredFilesService;
+        this.chatContextService = chatContextService;
+        this._currentCancelTokenSource = this._register(( new MutableDisposable()));
+        this._implicitContextEnablement = this.configurationService.getValue('chat.implicitContext.enabled');
+        const activeEditorDisposables = this._register(( new DisposableStore()));
+        this._register(Event.runAndSubscribe(editorService.onDidActiveEditorChange, (() => {
+            activeEditorDisposables.clear();
+            const codeEditor = this.findActiveCodeEditor();
+            if (codeEditor) {
+                activeEditorDisposables.add(Event.debounce(Event.any(codeEditor.onDidChangeModel, codeEditor.onDidChangeModelLanguage, codeEditor.onDidChangeCursorSelection, codeEditor.onDidScrollChange), () => undefined, 500)(() => this.updateImplicitContext()));
+            }
+            const notebookEditor = this.findActiveNotebookEditor();
+            if (notebookEditor) {
+                const activeCellDisposables = activeEditorDisposables.add(( new DisposableStore()));
+                activeEditorDisposables.add(notebookEditor.onDidChangeActiveCell(() => {
+                    activeCellDisposables.clear();
+                    const codeEditor = this.codeEditorService.getActiveCodeEditor();
+                    if (codeEditor && codeEditor.getModel()?.uri.scheme === Schemas.vscodeNotebookCell) {
+                        activeCellDisposables.add(Event.debounce(Event.any(codeEditor.onDidChangeModel, codeEditor.onDidChangeCursorSelection, codeEditor.onDidScrollChange), () => undefined, 500)(() => this.updateImplicitContext()));
+                    }
+                }));
+                activeEditorDisposables.add(Event.debounce(Event.any(notebookEditor.onDidChangeModel, notebookEditor.onDidChangeActiveCell), () => undefined, 500)(() => this.updateImplicitContext()));
+            }
+            const webviewEditor = this.findActiveWebviewEditor();
+            if (webviewEditor) {
+                activeEditorDisposables.add(Event.debounce(webviewEditor.input.webview.onMessage, () => undefined, 500)(() => {
+                    this.updateImplicitContext();
+                }));
+            }
+            this.updateImplicitContext();
+        })));
+        this._register(autorun((reader) => {
+            this.chatEditingService.editingSessionsObs.read(reader);
+            this.updateImplicitContext();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('chat.implicitContext.enabled')) {
+                this._implicitContextEnablement = this.configurationService.getValue('chat.implicitContext.enabled');
+                this.updateImplicitContext();
+            }
+        }));
+        this._register(this.chatService.onDidSubmitRequest(({ chatSessionResource }) => {
+            const widget = this.chatWidgetService.getWidgetBySessionResource(chatSessionResource);
+            if (!widget?.input.implicitContext) {
+                return;
+            }
+            if (this._implicitContextEnablement[widget.location] === 'first' && widget.viewModel?.getItems().length !== 0) {
+                widget.input.implicitContext.setValue(undefined, false, undefined);
+            }
+        }));
+        this._register(this.chatWidgetService.onDidAddWidget(async (widget) => {
+            await this.updateImplicitContext(widget);
+        }));
+    }
+    findActiveCodeEditor() {
+        const codeEditor = this.codeEditorService.getActiveCodeEditor();
+        if (codeEditor) {
+            const model = codeEditor.getModel();
+            if (model?.uri.scheme === Schemas.vscodeNotebookCell) {
+                return undefined;
+            }
+            if (model) {
+                return codeEditor;
+            }
+        }
+        for (const codeOrDiffEditor of this.editorService.getVisibleTextEditorControls(EditorsOrder.MOST_RECENTLY_ACTIVE)) {
+            const codeEditor = getCodeEditor(codeOrDiffEditor);
+            if (!codeEditor) {
+                continue;
+            }
+            const model = codeEditor.getModel();
+            if (model) {
+                return codeEditor;
+            }
+        }
+        return undefined;
+    }
+    findActiveWebviewEditor() {
+        const activeEditorPane = this.editorService.activeEditorPane;
+        if (activeEditorPane?.input instanceof WebviewInput) {
+            return activeEditorPane;
+        }
+        return undefined;
+    }
+    findActiveNotebookEditor() {
+        return getNotebookEditorFromEditorPane(this.editorService.activeEditorPane);
+    }
+    async updateImplicitContext(updateWidget) {
+        const cancelTokenSource = this._currentCancelTokenSource.value = ( new CancellationTokenSource());
+        const codeEditor = this.findActiveCodeEditor();
+        const model = codeEditor?.getModel();
+        const selection = codeEditor?.getSelection();
+        let newValue;
+        let isSelection = false;
+        let languageId;
+        if (model) {
+            languageId = model.getLanguageId();
+            if (selection && !selection.isEmpty()) {
+                newValue = { uri: model.uri, range: selection };
+                isSelection = true;
+            }
+            else {
+                if (this.configurationService.getValue('chat.implicitContext.suggestedContext')) {
+                    newValue = model.uri;
+                }
+                else {
+                    const visibleRanges = codeEditor?.getVisibleRanges();
+                    if (visibleRanges && visibleRanges.length > 0) {
+                        let range = visibleRanges[0];
+                        visibleRanges.slice(1).forEach(r => {
+                            range = range.plusRange(r);
+                        });
+                        newValue = { uri: model.uri, range };
+                    }
+                    else {
+                        newValue = model.uri;
+                    }
+                }
+            }
+        }
+        const notebookEditor = this.findActiveNotebookEditor();
+        if (notebookEditor) {
+            const activeCell = notebookEditor.getActiveCell();
+            if (activeCell) {
+                const codeEditor = this.codeEditorService.getActiveCodeEditor();
+                const selection = codeEditor?.getSelection();
+                const visibleRanges = codeEditor?.getVisibleRanges() || [];
+                newValue = activeCell.uri;
+                if (isEqual(codeEditor?.getModel()?.uri, activeCell.uri)) {
+                    if (selection && !selection.isEmpty()) {
+                        newValue = { uri: activeCell.uri, range: selection };
+                        isSelection = true;
+                    }
+                    else if (visibleRanges.length > 0) {
+                        let range = visibleRanges[0];
+                        visibleRanges.slice(1).forEach(r => {
+                            range = range.plusRange(r);
+                        });
+                        newValue = { uri: activeCell.uri, range };
+                    }
+                }
+            }
+            else {
+                newValue = notebookEditor.textModel?.uri;
+            }
+        }
+        const webviewEditor = this.findActiveWebviewEditor();
+        if (webviewEditor?.input?.resource) {
+            const webviewContext = await this.chatContextService.contextForResource(webviewEditor.input.resource);
+            if (webviewContext) {
+                newValue = webviewContext;
+            }
+        }
+        const uri = newValue instanceof URI ? newValue : (isStringImplicitContextValue(newValue) ? undefined : newValue?.uri);
+        if (uri && ((await this.ignoredFilesService.fileIsIgnored(uri, cancelTokenSource.token)) ||
+            uri.path.endsWith('.copilotmd'))) {
+            newValue = undefined;
+        }
+        if (cancelTokenSource.token.isCancellationRequested) {
+            return;
+        }
+        const isPromptFile = languageId && getPromptsTypeForLanguageId(languageId) !== undefined;
+        const widgets = updateWidget ? [updateWidget] : [...this.chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat), ...this.chatWidgetService.getWidgetsByLocations(ChatAgentLocation.EditorInline)];
+        for (const widget of widgets) {
+            if (!widget.input.implicitContext) {
+                continue;
+            }
+            const setting = this._implicitContextEnablement[widget.location];
+            const isFirstInteraction = widget.viewModel?.getItems().length === 0;
+            if ((setting === 'always' || setting === 'first' && isFirstInteraction) && !isPromptFile) {
+                widget.input.implicitContext.setValue(newValue, isSelection, languageId);
+            }
+            else {
+                widget.input.implicitContext.setValue(undefined, false, undefined);
+            }
+        }
+    }
+};
+ChatImplicitContextContribution = ( __decorate([
+    ( __param(0, ICodeEditorService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IChatWidgetService)),
+    ( __param(3, IChatService)),
+    ( __param(4, IChatEditingService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ILanguageModelIgnoredFilesService)),
+    ( __param(7, IChatContextService))
+], ChatImplicitContextContribution));
+class ChatImplicitContext extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.kind = 'implicit';
+        this.isFile = true;
+        this._isSelection = false;
+        this._onDidChangeValue = this._register(( new Emitter()));
+        this.onDidChangeValue = this._onDidChangeValue.event;
+        this._enabled = true;
+    }
+    get id() {
+        if (URI.isUri(this.value)) {
+            return 'vscode.implicit.file';
+        }
+        else if (isStringImplicitContextValue(this.value)) {
+            return 'vscode.implicit.string';
+        }
+        else if (this.value) {
+            if (this._isSelection) {
+                return 'vscode.implicit.selection';
+            }
+            else {
+                return 'vscode.implicit.viewport';
+            }
+        }
+        else {
+            return 'vscode.implicit';
+        }
+    }
+    get name() {
+        if (URI.isUri(this.value)) {
+            return `file:${basename(this.value)}`;
+        }
+        else if (isStringImplicitContextValue(this.value)) {
+            return this.value.name;
+        }
+        else if (this.value) {
+            return `file:${basename(this.value.uri)}`;
+        }
+        else {
+            return 'implicit';
+        }
+    }
+    get modelDescription() {
+        if (URI.isUri(this.value)) {
+            return `User's active file`;
+        }
+        else if (isStringImplicitContextValue(this.value)) {
+            return this.value.modelDescription ?? `User's active context from ${this.value.name}`;
+        }
+        else if (this._isSelection) {
+            return `User's active selection`;
+        }
+        else {
+            return `User's current visible code`;
+        }
+    }
+    get isSelection() {
+        return this._isSelection;
+    }
+    get value() {
+        return this._value;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = value;
+        this._onDidChangeValue.fire();
+    }
+    get uri() {
+        if (isStringImplicitContextValue(this.value)) {
+            return this.value.uri;
+        }
+        return this._uri;
+    }
+    get icon() {
+        if (isStringImplicitContextValue(this.value)) {
+            return this.value.icon;
+        }
+        return undefined;
+    }
+    setValue(value, isSelection, languageId) {
+        if (isStringImplicitContextValue(value)) {
+            this._value = value;
+        }
+        else {
+            this._value = value;
+            this._uri = URI.isUri(value) ? value : value?.uri;
+        }
+        this._isSelection = isSelection;
+        this._onDidChangeValue.fire();
+    }
+    toBaseEntries() {
+        if (!this.value) {
+            return [];
+        }
+        if (isStringImplicitContextValue(this.value)) {
+            return [
+                {
+                    kind: 'string',
+                    id: this.id,
+                    name: this.name,
+                    value: this.value.value ?? this.name,
+                    modelDescription: this.modelDescription,
+                    icon: this.value.icon,
+                    uri: this.value.uri
+                }
+            ];
+        }
+        return [{
+                kind: 'file',
+                id: this.id,
+                name: this.name,
+                value: this.value,
+                modelDescription: this.modelDescription,
+            }];
+    }
+}
+
+export { ChatImplicitContext, ChatImplicitContextContribution };

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

@@ -0,0 +1,10 @@
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { IWordAtPosition } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/wordHelper";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+export interface IChatCompletionRangeResult {
+    insert: Range;
+    replace: Range;
+    varWord: IWordAtPosition | null;
+}
+export declare function computeCompletionRanges(model: ITextModel, position: Position, reg: RegExp, onlyOnWordStart?: boolean): IChatCompletionRangeResult | undefined;