@codingame/monaco-vscode-chat-service-override 3.2.3 → 4.1.0

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

@@ -1,580 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
-import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { getWordAtText } from 'vscode/vscode/vs/editor/common/core/wordHelper';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { inputPlaceholderForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { SubmitAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatExecuteActions';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { ChatInputPart } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatInputPart';
-import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import { SelectAndInsertFileAction, dynamicVariableDecorationType } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
-import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { chatSlashCommandForeground, chatSlashCommandBackground } from '../../common/chatColors.js';
-import { getHistoryEntriesFromModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
-import { chatVariableLeader, ChatRequestVariablePart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, ChatRequestTextPart, chatAgentLeader, chatSubcommandLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
-import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands';
-import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
-
-var BuiltinDynamicCompletions_1, VariableCompletions_1;
-const decorationDescription = 'chat';
-const placeholderDecorationType = 'chat-session-detail';
-const slashCommandTextDecorationType = 'chat-session-text';
-const variableTextDecorationType = 'chat-variable-text';
-function agentAndCommandToKey(agent, subcommand) {
-    return subcommand ? `${agent}__${subcommand}` : agent;
-}
-let InputEditorDecorations = class InputEditorDecorations extends Disposable {
-    constructor(widget, codeEditorService, themeService, chatAgentService) {
-        super();
-        this.widget = widget;
-        this.codeEditorService = codeEditorService;
-        this.themeService = themeService;
-        this.chatAgentService = chatAgentService;
-        this.id = 'inputEditorDecorations';
-        this.previouslyUsedAgents = ( new Set());
-        this.viewModelDisposables = this._register(( new MutableDisposable()));
-        this.codeEditorService.registerDecorationType(decorationDescription, placeholderDecorationType, {});
-        this._register(this.themeService.onDidColorThemeChange(() => this.updateRegisteredDecorationTypes()));
-        this.updateRegisteredDecorationTypes();
-        this.updateInputEditorDecorations();
-        this._register(this.widget.inputEditor.onDidChangeModelContent(() => this.updateInputEditorDecorations()));
-        this._register(this.widget.onDidChangeViewModel(() => {
-            this.registerViewModelListeners();
-            this.previouslyUsedAgents.clear();
-            this.updateInputEditorDecorations();
-        }));
-        this._register(this.widget.onDidSubmitAgent((e) => {
-            this.previouslyUsedAgents.add(agentAndCommandToKey(e.agent.id, e.slashCommand?.name));
-        }));
-        this._register(this.chatAgentService.onDidChangeAgents(() => this.updateInputEditorDecorations()));
-        this.registerViewModelListeners();
-    }
-    registerViewModelListeners() {
-        this.viewModelDisposables.value = this.widget.viewModel?.onDidChange(e => {
-            if (e?.kind === 'changePlaceholder' || e?.kind === 'initialize') {
-                this.updateInputEditorDecorations();
-            }
-        });
-    }
-    updateRegisteredDecorationTypes() {
-        this.codeEditorService.removeDecorationType(variableTextDecorationType);
-        this.codeEditorService.removeDecorationType(dynamicVariableDecorationType);
-        this.codeEditorService.removeDecorationType(slashCommandTextDecorationType);
-        const theme = this.themeService.getColorTheme();
-        this.codeEditorService.registerDecorationType(decorationDescription, slashCommandTextDecorationType, {
-            color: theme.getColor(chatSlashCommandForeground)?.toString(),
-            backgroundColor: theme.getColor(chatSlashCommandBackground)?.toString(),
-            borderRadius: '3px'
-        });
-        this.codeEditorService.registerDecorationType(decorationDescription, variableTextDecorationType, {
-            color: theme.getColor(chatSlashCommandForeground)?.toString(),
-            backgroundColor: theme.getColor(chatSlashCommandBackground)?.toString(),
-            borderRadius: '3px'
-        });
-        this.codeEditorService.registerDecorationType(decorationDescription, dynamicVariableDecorationType, {
-            color: theme.getColor(chatSlashCommandForeground)?.toString(),
-            backgroundColor: theme.getColor(chatSlashCommandBackground)?.toString(),
-            borderRadius: '3px'
-        });
-        this.updateInputEditorDecorations();
-    }
-    getPlaceholderColor() {
-        const theme = this.themeService.getColorTheme();
-        const transparentForeground = theme.getColor(inputPlaceholderForeground);
-        return transparentForeground?.toString();
-    }
-    async updateInputEditorDecorations() {
-        const inputValue = this.widget.inputEditor.getValue();
-        const viewModel = this.widget.viewModel;
-        if (!viewModel) {
-            return;
-        }
-        if (!inputValue) {
-            const viewModelPlaceholder = this.widget.viewModel?.inputPlaceholder;
-            const placeholder = viewModelPlaceholder ?? '';
-            const decoration = [
-                {
-                    range: {
-                        startLineNumber: 1,
-                        endLineNumber: 1,
-                        startColumn: 1,
-                        endColumn: 1000
-                    },
-                    renderOptions: {
-                        after: {
-                            contentText: placeholder,
-                            color: this.getPlaceholderColor()
-                        }
-                    }
-                }
-            ];
-            this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, decoration);
-            return;
-        }
-        const parsedRequest = this.widget.parsedInput.parts;
-        let placeholderDecoration;
-        const agentPart = parsedRequest.find((p) => p instanceof ChatRequestAgentPart);
-        const agentSubcommandPart = parsedRequest.find((p) => p instanceof ChatRequestAgentSubcommandPart);
-        const slashCommandPart = parsedRequest.find((p) => p instanceof ChatRequestSlashCommandPart);
-        const exactlyOneSpaceAfterPart = (part) => {
-            const partIdx = parsedRequest.indexOf(part);
-            if (parsedRequest.length > partIdx + 2) {
-                return false;
-            }
-            const nextPart = parsedRequest[partIdx + 1];
-            return nextPart && nextPart instanceof ChatRequestTextPart && nextPart.text === ' ';
-        };
-        const getRangeForPlaceholder = (part) => ({
-            startLineNumber: part.editorRange.startLineNumber,
-            endLineNumber: part.editorRange.endLineNumber,
-            startColumn: part.editorRange.endColumn + 1,
-            endColumn: 1000
-        });
-        const onlyAgentAndWhitespace = agentPart && parsedRequest.every(p => p instanceof ChatRequestTextPart && !p.text.trim().length || p instanceof ChatRequestAgentPart);
-        if (onlyAgentAndWhitespace) {
-            const isFollowupSlashCommand = ( this.previouslyUsedAgents.has(agentAndCommandToKey(agentPart.agent.id, undefined)));
-            const shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentPart.agent.metadata.followupPlaceholder;
-            if (agentPart.agent.metadata.description && exactlyOneSpaceAfterPart(agentPart)) {
-                placeholderDecoration = [{
-                        range: getRangeForPlaceholder(agentPart),
-                        renderOptions: {
-                            after: {
-                                contentText: shouldRenderFollowupPlaceholder ? agentPart.agent.metadata.followupPlaceholder : agentPart.agent.metadata.description,
-                                color: this.getPlaceholderColor(),
-                            }
-                        }
-                    }];
-            }
-        }
-        const onlyAgentCommandAndWhitespace = agentPart && agentSubcommandPart && parsedRequest.every(p => p instanceof ChatRequestTextPart && !p.text.trim().length || p instanceof ChatRequestAgentPart || p instanceof ChatRequestAgentSubcommandPart);
-        if (onlyAgentCommandAndWhitespace) {
-            const isFollowupSlashCommand = ( this.previouslyUsedAgents.has(agentAndCommandToKey(agentPart.agent.id, agentSubcommandPart.command.name)));
-            const shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentSubcommandPart.command.followupPlaceholder;
-            if (agentSubcommandPart?.command.description && exactlyOneSpaceAfterPart(agentSubcommandPart)) {
-                placeholderDecoration = [{
-                        range: getRangeForPlaceholder(agentSubcommandPart),
-                        renderOptions: {
-                            after: {
-                                contentText: shouldRenderFollowupPlaceholder ? agentSubcommandPart.command.followupPlaceholder : agentSubcommandPart.command.description,
-                                color: this.getPlaceholderColor(),
-                            }
-                        }
-                    }];
-            }
-        }
-        this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, placeholderDecoration ?? []);
-        const textDecorations = [];
-        if (agentPart) {
-            textDecorations.push({ range: agentPart.editorRange });
-            if (agentSubcommandPart) {
-                textDecorations.push({ range: agentSubcommandPart.editorRange });
-            }
-        }
-        if (slashCommandPart) {
-            textDecorations.push({ range: slashCommandPart.editorRange });
-        }
-        this.widget.inputEditor.setDecorationsByType(decorationDescription, slashCommandTextDecorationType, textDecorations);
-        const varDecorations = [];
-        const variableParts = parsedRequest.filter((p) => p instanceof ChatRequestVariablePart);
-        for (const variable of variableParts) {
-            varDecorations.push({ range: variable.editorRange });
-        }
-        this.widget.inputEditor.setDecorationsByType(decorationDescription, variableTextDecorationType, varDecorations);
-    }
-};
-InputEditorDecorations = ( __decorate([
-    ( __param(1, ICodeEditorService)),
-    ( __param(2, IThemeService)),
-    ( __param(3, IChatAgentService))
-], InputEditorDecorations));
-class InputEditorSlashCommandMode extends Disposable {
-    constructor(widget) {
-        super();
-        this.widget = widget;
-        this.id = 'InputEditorSlashCommandMode';
-        this._register(this.widget.onDidSubmitAgent(e => {
-            this.repopulateAgentCommand(e.agent, e.slashCommand);
-        }));
-    }
-    async repopulateAgentCommand(agent, slashCommand) {
-        let value;
-        if (slashCommand && slashCommand.isSticky) {
-            value = `${chatAgentLeader}${agent.id} ${chatSubcommandLeader}${slashCommand.name} `;
-        }
-        else if (agent.metadata.isSticky) {
-            value = `${chatAgentLeader}${agent.id} `;
-        }
-        if (value) {
-            this.widget.inputEditor.setValue(value);
-            this.widget.inputEditor.setPosition({ lineNumber: 1, column: value.length + 1 });
-        }
-    }
-}
-ChatWidget.CONTRIBS.push(InputEditorDecorations, InputEditorSlashCommandMode);
-let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
-    constructor(languageFeaturesService, chatWidgetService, chatSlashCommandService) {
-        super();
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this.chatSlashCommandService = chatSlashCommandService;
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'globalSlashCommands',
-            triggerCharacters: ['/'],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /\/\w*/g);
-                if (!range) {
-                    return null;
-                }
-                const parsedRequest = widget.parsedInput.parts;
-                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
-                if (usedAgent) {
-                    return;
-                }
-                const slashCommands = this.chatSlashCommandService.getCommands();
-                if (!slashCommands) {
-                    return null;
-                }
-                return {
-                    suggestions: ( slashCommands.map((c, i) => {
-                        const withSlash = `/${c.command}`;
-                        return {
-                            label: withSlash,
-                            insertText: c.executeImmediately ? '' : `${withSlash} `,
-                            detail: c.detail,
-                            range: ( new Range(1, 1, 1, 1)),
-                            sortText: c.sortText ?? 'a'.repeat(i + 1),
-                            kind: 18 ,
-                            command: c.executeImmediately ? { id: SubmitAction.ID, title: withSlash, arguments: [{ widget, inputValue: `${withSlash} ` }] } : undefined,
-                        };
-                    }))
-                };
-            }
-        }));
-    }
-};
-SlashCommandCompletions = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatSlashCommandService))
-], SlashCommandCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SlashCommandCompletions, 4 );
-let AgentCompletions = class AgentCompletions extends Disposable {
-    constructor(languageFeaturesService, chatWidgetService, chatAgentService) {
-        super();
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this.chatAgentService = chatAgentService;
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatAgent',
-            triggerCharacters: ['@'],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return null;
-                }
-                const parsedRequest = widget.parsedInput.parts;
-                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
-                if (usedAgent && !Range.containsPosition(usedAgent.editorRange, position)) {
-                    return;
-                }
-                const range = computeCompletionRanges(model, position, /@\w*/g);
-                if (!range) {
-                    return null;
-                }
-                const agents = this.chatAgentService.getAgents()
-                    .filter(a => !a.metadata.isDefault);
-                return {
-                    suggestions: ( agents.map((c, i) => {
-                        const withAt = `@${c.id}`;
-                        return {
-                            label: withAt,
-                            insertText: `${withAt} `,
-                            detail: c.metadata.description,
-                            range: ( new Range(1, 1, 1, 1)),
-                            kind: 18 ,
-                        };
-                    }))
-                };
-            }
-        }));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatAgentSubcommand',
-            triggerCharacters: ['/'],
-            provideCompletionItems: async (model, position, _context, token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return;
-                }
-                const range = computeCompletionRanges(model, position, /\/\w*/g);
-                if (!range) {
-                    return null;
-                }
-                const parsedRequest = widget.parsedInput.parts;
-                const usedAgentIdx = parsedRequest.findIndex((p) => p instanceof ChatRequestAgentPart);
-                if (usedAgentIdx < 0) {
-                    return;
-                }
-                const usedSubcommand = parsedRequest.find(p => p instanceof ChatRequestAgentSubcommandPart);
-                if (usedSubcommand) {
-                    return;
-                }
-                for (const partAfterAgent of parsedRequest.slice(usedAgentIdx + 1)) {
-                    if (!(partAfterAgent instanceof ChatRequestTextPart) || !partAfterAgent.text.trim().match(/^(\/\w*)?$/)) {
-                        return;
-                    }
-                }
-                const usedAgent = parsedRequest[usedAgentIdx];
-                const commands = await usedAgent.agent.provideSlashCommands(widget.viewModel.model, getHistoryEntriesFromModel(widget.viewModel.model), token);
-                return {
-                    suggestions: ( commands.map((c, i) => {
-                        const withSlash = `/${c.name}`;
-                        return {
-                            label: withSlash,
-                            insertText: `${withSlash} `,
-                            detail: c.description,
-                            range,
-                            kind: 18 ,
-                        };
-                    }))
-                };
-            }
-        }));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatAgentAndSubcommand',
-            triggerCharacters: ['/'],
-            provideCompletionItems: async (model, position, _context, token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                const viewModel = widget?.viewModel;
-                if (!widget || !viewModel) {
-                    return;
-                }
-                const range = computeCompletionRanges(model, position, /\/\w*/g);
-                if (!range) {
-                    return null;
-                }
-                const agents = this.chatAgentService.getAgents();
-                const all = ( agents.map(
-                    agent => agent.provideSlashCommands(viewModel.model, getHistoryEntriesFromModel(viewModel.model), token)
-                ));
-                const commands = await raceCancellation(Promise.all(all), token);
-                if (!commands) {
-                    return;
-                }
-                const justAgents = ( agents
-                    .filter(a => !a.metadata.isDefault)
-                    .map(agent => {
-                    const agentLabel = `${chatAgentLeader}${agent.id}`;
-                    return {
-                        label: { label: agentLabel, description: agent.metadata.description },
-                        filterText: `${chatSubcommandLeader}${agent.id}`,
-                        insertText: `${agentLabel} `,
-                        range: ( new Range(1, 1, 1, 1)),
-                        kind: 18 ,
-                        sortText: `${chatSubcommandLeader}${agent.id}`,
-                    };
-                }));
-                return {
-                    suggestions: justAgents.concat(agents.flatMap((agent, i) => ( commands[i].map((c, i) => {
-                        const agentLabel = `${chatAgentLeader}${agent.id}`;
-                        const withSlash = `${chatSubcommandLeader}${c.name}`;
-                        return {
-                            label: { label: withSlash, description: agentLabel },
-                            filterText: `${chatSubcommandLeader}${agent.id}${c.name}`,
-                            commitCharacters: [' '],
-                            insertText: `${agentLabel} ${withSlash} `,
-                            detail: `(${agentLabel}) ${c.description}`,
-                            range: ( new Range(1, 1, 1, 1)),
-                            kind: 18 ,
-                            sortText: `${chatSubcommandLeader}${agent.id}${c.name}`,
-                        };
-                    }))))
-                };
-            }
-        }));
-    }
-};
-AgentCompletions = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatAgentService))
-], AgentCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AgentCompletions, 4 );
-let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposable {
-    static { BuiltinDynamicCompletions_1 = this; }
-    static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}\\w*`, 'g')); }
-    constructor(languageFeaturesService, chatWidgetService) {
-        super();
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatDynamicCompletions',
-            triggerCharacters: [chatVariableLeader],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.supportsFileReferences) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, BuiltinDynamicCompletions_1.VariableNameDef);
-                if (!range) {
-                    return null;
-                }
-                const afterRange = ( new Range(
-                    position.lineNumber,
-                    range.replace.startColumn,
-                    position.lineNumber,
-                    range.replace.startColumn + '#file:'.length
-                ));
-                return {
-                    suggestions: [
-                        {
-                            label: `${chatVariableLeader}file`,
-                            insertText: `${chatVariableLeader}file:`,
-                            detail: ( localizeWithPath(
-                                'vs/workbench/contrib/chat/browser/contrib/chatInputEditorContrib',
-                                'pickFileLabel',
-                                "Pick a file"
-                            )),
-                            range,
-                            kind: 18 ,
-                            command: { id: SelectAndInsertFileAction.ID, title: SelectAndInsertFileAction.ID, arguments: [{ widget, range: afterRange }] },
-                            sortText: 'z'
-                        }
-                    ]
-                };
-            }
-        }));
-    }
-};
-BuiltinDynamicCompletions = BuiltinDynamicCompletions_1 = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, IChatWidgetService))
-], BuiltinDynamicCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BuiltinDynamicCompletions, 4 );
-function computeCompletionRanges(model, position, reg) {
-    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
-    if (!varWord && model.getWordUntilPosition(position).word) {
-        return;
-    }
-    let insert;
-    let replace;
-    if (!varWord) {
-        insert = replace = Range.fromPositions(position);
-    }
-    else {
-        insert = ( new Range(
-            position.lineNumber,
-            varWord.startColumn,
-            position.lineNumber,
-            position.column
-        ));
-        replace = ( new Range(
-            position.lineNumber,
-            varWord.startColumn,
-            position.lineNumber,
-            varWord.endColumn
-        ));
-    }
-    return { insert, replace, varWord };
-}
-let VariableCompletions = class VariableCompletions extends Disposable {
-    static { VariableCompletions_1 = this; }
-    static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}\\w*`, 'g')); }
-    constructor(languageFeaturesService, chatWidgetService, chatVariablesService) {
-        super();
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this.chatVariablesService = chatVariablesService;
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatVariables',
-            triggerCharacters: [chatVariableLeader],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, VariableCompletions_1.VariableNameDef);
-                if (!range) {
-                    return null;
-                }
-                const usedVariables = widget.parsedInput.parts.filter((p) => p instanceof ChatRequestVariablePart);
-                const variableItems = ( Array.from(this.chatVariablesService.getVariables())
-                    .filter(v => !( usedVariables.some(usedVar => usedVar.variableName === v.name)))
-                    .map(v => {
-                    const withLeader = `${chatVariableLeader}${v.name}`;
-                    return {
-                        label: withLeader,
-                        range,
-                        insertText: withLeader + ' ',
-                        detail: v.description,
-                        kind: 18 ,
-                        sortText: 'z'
-                    };
-                }));
-                return {
-                    suggestions: variableItems
-                };
-            }
-        }));
-    }
-};
-VariableCompletions = VariableCompletions_1 = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatVariablesService))
-], VariableCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(VariableCompletions, 4 );
-let ChatTokenDeleter = class ChatTokenDeleter extends Disposable {
-    constructor(widget, instantiationService) {
-        super();
-        this.widget = widget;
-        this.instantiationService = instantiationService;
-        this.id = 'chatTokenDeleter';
-        const parser = this.instantiationService.createInstance(ChatRequestParser);
-        const inputValue = this.widget.inputEditor.getValue();
-        let previousInputValue;
-        this.widget.inputEditor.onDidChangeModelContent(e => {
-            if (!previousInputValue) {
-                previousInputValue = inputValue;
-            }
-            const change = e.changes[0];
-            if (!change.text && this.widget.viewModel) {
-                const previousParsedValue = parser.parseChatRequest(this.widget.viewModel.sessionId, previousInputValue);
-                const deletableTokens = previousParsedValue.parts.filter(p => p instanceof ChatRequestAgentPart || p instanceof ChatRequestAgentSubcommandPart || p instanceof ChatRequestSlashCommandPart || p instanceof ChatRequestVariablePart);
-                deletableTokens.forEach(token => {
-                    const deletedRangeOfToken = Range.intersectRanges(token.editorRange, change.range);
-                    if (deletedRangeOfToken && Range.compareRangesUsingStarts(token.editorRange, change.range) < 0) {
-                        const length = deletedRangeOfToken.endColumn - deletedRangeOfToken.startColumn;
-                        const rangeToDelete = ( new Range(
-                            token.editorRange.startLineNumber,
-                            token.editorRange.startColumn,
-                            token.editorRange.endLineNumber,
-                            token.editorRange.endColumn - length
-                        ));
-                        this.widget.inputEditor.executeEdits(this.id, [{
-                                range: rangeToDelete,
-                                text: '',
-                            }]);
-                    }
-                });
-            }
-            previousInputValue = this.widget.inputEditor.getValue();
-        });
-    }
-};
-ChatTokenDeleter = ( __decorate([
-    ( __param(1, IInstantiationService))
-], ChatTokenDeleter));
-ChatWidget.CONTRIBS.push(ChatTokenDeleter);

package/vscode/src/vs/workbench/contrib/chat/common/chatColors.js

@@ -1,36 +0,0 @@
-import { Color, RGBA } from 'vscode/vscode/vs/base/common/color';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { registerColor, contrastBorder, transparent, editorBackground, editorWidgetBackground, badgeBackground, badgeForeground, foreground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-
-registerColor('chat.requestBorder', { dark: ( new Color(( new RGBA(255, 255, 255, 0.10)))), light: ( new Color(( new RGBA(0, 0, 0, 0.10)))), hcDark: contrastBorder, hcLight: contrastBorder, }, ( localizeWithPath(
- 'vs/workbench/contrib/chat/common/chatColors',
- 'chat.requestBorder',
- 'The border color of a chat request.'
-)));
-registerColor('chat.requestBackground', { dark: ( transparent(editorBackground, 0.62)), light: ( transparent(editorBackground, 0.62)), hcDark: editorWidgetBackground, hcLight: null }, ( localizeWithPath(
- 'vs/workbench/contrib/chat/common/chatColors',
- 'chat.requestBackground',
- 'The background color of a chat request.'
-)));
-const chatSlashCommandBackground = registerColor('chat.slashCommandBackground', { dark: '#34414B', light: '#D2ECFF', hcDark: Color.white, hcLight: badgeBackground }, ( localizeWithPath(
- 'vs/workbench/contrib/chat/common/chatColors',
- 'chat.slashCommandBackground',
- 'The background color of a chat slash command.'
-)));
-const chatSlashCommandForeground = registerColor('chat.slashCommandForeground', { dark: '#40A6FF', light: '#306CA2', hcDark: Color.black, hcLight: badgeForeground }, ( localizeWithPath(
- 'vs/workbench/contrib/chat/common/chatColors',
- 'chat.slashCommandForeground',
- 'The foreground color of a chat slash command.'
-)));
-registerColor('chat.avatarBackground', { dark: '#1f1f1f', light: '#f2f2f2', hcDark: Color.black, hcLight: Color.white, }, ( localizeWithPath(
- 'vs/workbench/contrib/chat/common/chatColors',
- 'chat.avatarBackground',
- 'The background color of a chat avatar.'
-)));
-registerColor('chat.avatarForeground', { dark: foreground, light: foreground, hcDark: foreground, hcLight: foreground, }, ( localizeWithPath(
- 'vs/workbench/contrib/chat/common/chatColors',
- 'chat.avatarForeground',
- 'The foreground color of a chat avatar.'
-)));
-
-export { chatSlashCommandBackground, chatSlashCommandForeground };