@codingame/monaco-vscode-chat-service-override 5.2.0 → 6.0.0

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

@@ -0,0 +1,370 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { getWordAtText } from 'vscode/vscode/vs/editor/common/core/wordHelper';
+import { CompletionItemKind } from 'vscode/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Action2, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+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.service';
+import { ChatInputPart } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatInputPart';
+import { SelectAndInsertFileAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
+import { ChatAgentLocation, getFullyQualifiedId } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentService, IChatAgentNameService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestTextPart, chatSubcommandLeader, chatVariableLeader, ChatRequestVariablePart, chatAgentLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
+import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+
+var BuiltinDynamicCompletions_1, VariableCompletions_1;
+const _moduleId = "vs/workbench/contrib/chat/browser/contrib/chatInputCompletions";
+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 || (widget.location !== ChatAgentLocation.Panel && widget.location !== ChatAgentLocation.Notebook) ) {
+                    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: CompletionItemKind.Text,
+                            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, LifecyclePhase.Eventually);
+let AgentCompletions = class AgentCompletions extends Disposable {
+    constructor(languageFeaturesService, chatWidgetService, chatAgentService, chatAgentNameService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatAgentService = chatAgentService;
+        this.chatAgentNameService = chatAgentNameService;
+        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 || (widget.location !== ChatAgentLocation.Panel && widget.location !== ChatAgentLocation.Notebook) ) {
+                    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.isDefault)
+                    .filter(a => a.locations.includes(widget.location));
+                return {
+                    suggestions: ( (agents.map((agent, i) => {
+                        const { label: agentLabel, isDupe } = getAgentCompletionDetails(agent, agents, this.chatAgentNameService);
+                        return {
+                            label: isDupe ?
+                                { label: agentLabel, description: agent.description, detail: ` (${agent.publisherDisplayName})` } :
+                                agentLabel,
+                            insertText: `${agentLabel} `,
+                            detail: agent.description,
+                            range: ( (new Range(1, 1, 1, 1))),
+                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent: agent, widget }] },
+                            kind: CompletionItemKind.Text,
+                        };
+                    })))
+                };
+            }
+        }));
+        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 || widget.location !== ChatAgentLocation.Panel ) {
+                    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];
+                return {
+                    suggestions: ( (usedAgent.agent.slashCommands.map((c, i) => {
+                        const withSlash = `/${c.name}`;
+                        return {
+                            label: withSlash,
+                            insertText: `${withSlash} `,
+                            detail: c.description,
+                            range,
+                            kind: CompletionItemKind.Text,
+                        };
+                    })))
+                };
+            }
+        }));
+        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 || widget.location !== ChatAgentLocation.Panel ) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, /\/\w*/g);
+                if (!range) {
+                    return null;
+                }
+                const agents = this.chatAgentService.getAgents()
+                    .filter(a => a.locations.includes(widget.location));
+                const getFilterText = (agent, command) => {
+                    const dummyPrefix = agent.id === 'github.copilot.terminal' ? `0000` : ``;
+                    return `${chatSubcommandLeader}${dummyPrefix}${agent.name}.${command}`;
+                };
+                const justAgents = ( (agents
+                    .filter(a => !a.isDefault)
+                    .map(agent => {
+                    const { label: agentLabel, isDupe } = getAgentCompletionDetails(agent, agents, this.chatAgentNameService);
+                    const detail = agent.description;
+                    return {
+                        label: isDupe ?
+                            { label: agentLabel, description: agent.description, detail: ` (${agent.publisherDisplayName})` } :
+                            agentLabel,
+                        detail,
+                        filterText: `${chatSubcommandLeader}${agent.name}`,
+                        insertText: `${agentLabel} `,
+                        range: ( (new Range(1, 1, 1, 1))),
+                        kind: CompletionItemKind.Text,
+                        sortText: `${chatSubcommandLeader}${agent.name}`,
+                        command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
+                    };
+                })));
+                return {
+                    suggestions: justAgents.concat(agents.flatMap(agent => ( (agent.slashCommands.map((c, i) => {
+                        const { label: agentLabel, isDupe } = getAgentCompletionDetails(agent, agents, this.chatAgentNameService);
+                        const withSlash = `${chatSubcommandLeader}${c.name}`;
+                        return {
+                            label: { label: withSlash, description: agentLabel, detail: isDupe ? ` (${agent.publisherDisplayName})` : undefined },
+                            filterText: getFilterText(agent, c.name),
+                            commitCharacters: [' '],
+                            insertText: `${agentLabel} ${withSlash} `,
+                            detail: `(${agentLabel}) ${c.description ?? ''}`,
+                            range: ( (new Range(1, 1, 1, 1))),
+                            kind: CompletionItemKind.Text,
+                            sortText: `${chatSubcommandLeader}${agent.name}${c.name}`,
+                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
+                        };
+                    })))))
+                };
+            }
+        }));
+    }
+};
+AgentCompletions = ( (__decorate([
+    ( (__param(0, ILanguageFeaturesService))),
+    ( (__param(1, IChatWidgetService))),
+    ( (__param(2, IChatAgentService))),
+    ( (__param(3, IChatAgentNameService)))
+], AgentCompletions)));
+( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(AgentCompletions, LifecyclePhase.Eventually);
+class AssignSelectedAgentAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.assignSelectedAgent'; }
+    constructor() {
+        super({
+            id: AssignSelectedAgentAction.ID,
+            title: ''
+        });
+    }
+    async run(accessor, ...args) {
+        const arg = args[0];
+        if (!arg || !arg.widget || !arg.agent) {
+            return;
+        }
+        arg.widget.lastSelectedAgent = arg.agent;
+    }
+}
+registerAction2(AssignSelectedAgentAction);
+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 || widget.location !== ChatAgentLocation.Panel ) {
+                    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(_moduleId, 0, "Pick a file")),
+                            range,
+                            kind: CompletionItemKind.Text,
+                            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, LifecyclePhase.Eventually);
+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 || widget.location !== ChatAgentLocation.Panel ) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, VariableCompletions_1.VariableNameDef);
+                if (!range) {
+                    return null;
+                }
+                const usedAgent = widget.parsedInput.parts.find(p => p instanceof ChatRequestAgentPart);
+                const slowSupported = usedAgent ? usedAgent.agent.metadata.supportsSlowVariables : true;
+                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))))
+                    .filter(v => !v.isSlow || slowSupported)
+                    .map((v) => {
+                    const withLeader = `${chatVariableLeader}${v.name}`;
+                    return {
+                        label: withLeader,
+                        range,
+                        insertText: withLeader + ' ',
+                        detail: v.description,
+                        kind: CompletionItemKind.Text,
+                        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, LifecyclePhase.Eventually);
+function getAgentCompletionDetails(agent, otherAgents, chatAgentNameService) {
+    const isAllowed = chatAgentNameService.getAgentNameRestriction(agent);
+    const agentLabel = `${chatAgentLeader}${isAllowed ? agent.name : getFullyQualifiedId(agent)}`;
+    const isDupe = isAllowed && !!otherAgents.find(other => other.name === agent.name && other.id !== agent.id);
+    return { label: agentLabel, isDupe };
+}