@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/promptsServiceCustomizationItemProvider.js

@@ -0,0 +1,331 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { AICustomizationSources, BUILTIN_STORAGE, applySourceFilter } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
+import { HookType, HOOK_METADATA } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
+import { formatHookCommandLabel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { matchesSessionType, PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagement';
+import { getFriendlyName, isChatExtensionItem } from './aiCustomizationItemSource.js';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+
+let PromptsServiceCustomizationItemProvider = class PromptsServiceCustomizationItemProvider {
+    constructor(getActiveDescriptor, promptsService, workspaceService, productService) {
+        this.getActiveDescriptor = getActiveDescriptor;
+        this.promptsService = promptsService;
+        this.workspaceService = workspaceService;
+        this.productService = productService;
+        this.onDidChange = Event.any(
+            this.promptsService.onDidChangeCustomAgents,
+            this.promptsService.onDidChangeSlashCommands,
+            this.promptsService.onDidChangeSkills,
+            this.promptsService.onDidChangeHooks,
+            this.promptsService.onDidChangeInstructions,
+            this.promptsService.onDidChangeAgentInstructions
+        );
+    }
+    async provideChatSessionCustomizations(_sessionResource, token) {
+        const itemSets = await Promise.all([
+            this.provideCustomizations(PromptsType.agent, token),
+            this.provideCustomizations(PromptsType.skill, token),
+            this.provideCustomizations(PromptsType.instructions, token),
+            this.provideCustomizations(PromptsType.hook, token),
+            this.provideCustomizations(PromptsType.prompt, token)
+        ]);
+        return itemSets.flat();
+    }
+    async provideCustomAgents(sessionResource, token) {
+        const sessionType = getChatSessionType(sessionResource);
+        const agents = await this.promptsService.getCustomAgents(token);
+        return agents.filter(agent => matchesSessionType(agent.sessionTypes, sessionType));
+    }
+    async provideSourceFolders(_sessionResource, type, _token) {
+        const folders = await this.promptsService.getSourceFolders(type);
+        return ( folders.map(folder => ({
+            uri: folder.uri,
+            label: this.promptsService.getPromptLocationLabel(folder)
+        })));
+    }
+    async provideCustomizations(promptType, token = CancellationToken.None) {
+        const items = [];
+        const disabledUris = this.promptsService.getDisabledPromptFiles(promptType);
+        const extensionInfoByUri = ( new ResourceMap());
+        if (promptType === PromptsType.agent) {
+            const agents = await this.promptsService.getCustomAgents(token);
+            const allAgentFiles = await this.promptsService.listPromptFiles(PromptsType.agent, token);
+            for (const file of allAgentFiles) {
+                if (file.extension) {
+                    extensionInfoByUri.set(file.uri, {
+                        id: file.extension.identifier,
+                        displayName: file.extension.displayName
+                    });
+                }
+            }
+            for (const agent of agents) {
+                items.push({
+                    uri: agent.uri,
+                    type: promptType,
+                    name: agent.name,
+                    description: agent.description,
+                    source: agent.source.storage,
+                    enabled: agent.enabled,
+                    extensionId: agent.source.storage === PromptsStorage.extension ? agent.source.extensionId.value : undefined,
+                    pluginUri: agent.source.storage === PromptsStorage.plugin ? agent.source.pluginUri : undefined,
+                    userInvocable: agent.visibility.userInvocable
+                });
+                if (agent.source.storage === PromptsStorage.extension && !( extensionInfoByUri.has(agent.uri))) {
+                    extensionInfoByUri.set(agent.uri, {
+                        id: agent.source.extensionId
+                    });
+                }
+            }
+        } else if (promptType === PromptsType.skill) {
+            const skills = await this.promptsService.findAgentSkills(token);
+            const allSkillFiles = await this.promptsService.listPromptFiles(PromptsType.skill, token);
+            for (const file of allSkillFiles) {
+                if (file.extension) {
+                    extensionInfoByUri.set(file.uri, {
+                        id: file.extension.identifier,
+                        displayName: file.extension.displayName
+                    });
+                }
+            }
+            const uiIntegrations = this.workspaceService.getSkillUIIntegrations();
+            const seenUris = ( new ResourceSet());
+            for (const skill of skills || []) {
+                const skillName = skill.name || basename(dirname(skill.uri)) || basename(skill.uri);
+                seenUris.add(skill.uri);
+                const skillFolderName = basename(dirname(skill.uri));
+                const uiTooltip = uiIntegrations.get(skillFolderName);
+                items.push({
+                    uri: skill.uri,
+                    type: promptType,
+                    name: skillName,
+                    description: skill.description,
+                    source: skill.storage,
+                    enabled: true,
+                    badge: uiTooltip ? ( localize(6124, "UI Integration")) : undefined,
+                    badgeTooltip: uiTooltip,
+                    extensionId: skill.extension?.identifier.value,
+                    pluginUri: skill.pluginUri,
+                    pluginLabel: skill.pluginLabel,
+                    userInvocable: skill.userInvocable
+                });
+            }
+            if (disabledUris.size > 0) {
+                for (const file of allSkillFiles) {
+                    if (!( seenUris.has(file.uri)) && ( disabledUris.has(file.uri))) {
+                        const disabledName = file.name || basename(dirname(file.uri)) || basename(file.uri);
+                        const disabledFolderName = basename(dirname(file.uri));
+                        const uiTooltip = uiIntegrations.get(disabledFolderName);
+                        items.push({
+                            uri: file.uri,
+                            type: promptType,
+                            name: disabledName,
+                            description: file.description,
+                            source: file.storage,
+                            enabled: false,
+                            badge: uiTooltip ? ( localize(6124, "UI Integration")) : undefined,
+                            badgeTooltip: uiTooltip,
+                            extensionId: file.extension?.identifier.value,
+                            pluginUri: file.pluginUri,
+                            pluginLabel: file.pluginLabel,
+                            userInvocable: false
+                        });
+                    }
+                }
+            }
+        } else if (promptType === PromptsType.prompt) {
+            const commands = await this.promptsService.getPromptSlashCommands(token);
+            for (const command of commands) {
+                if (command.type === PromptsType.skill) {
+                    continue;
+                }
+                items.push({
+                    uri: command.uri,
+                    type: promptType,
+                    name: command.name,
+                    description: command.description,
+                    source: command.storage,
+                    enabled: !( disabledUris.has(command.uri)),
+                    extensionId: command.extension?.identifier.value,
+                    pluginUri: command.pluginUri,
+                    pluginLabel: command.pluginLabel,
+                    userInvocable: command.userInvocable
+                });
+                if (command.extension) {
+                    extensionInfoByUri.set(command.uri, {
+                        id: command.extension.identifier,
+                        displayName: command.extension.displayName
+                    });
+                }
+            }
+        } else if (promptType === PromptsType.hook) {
+            await this.fetchPromptServiceHooks(items, disabledUris, promptType);
+        } else {
+            await this.fetchPromptServiceInstructions(items, extensionInfoByUri, disabledUris, promptType);
+        }
+        return this.applyLocalFilters(this.applyBuiltinGroupKeys(items, extensionInfoByUri), promptType);
+    }
+    async fetchPromptServiceHooks(items, disabledUris, promptType) {
+        const hookFiles = await this.promptsService.listPromptFiles(PromptsType.hook, CancellationToken.None);
+        for (const f of hookFiles) {
+            items.push({
+                uri: f.uri,
+                type: promptType,
+                name: f.name || getFriendlyName(basename(f.uri)),
+                source: f.storage,
+                enabled: !( disabledUris.has(f.uri)),
+                extensionId: f.extension?.identifier.value,
+                pluginUri: f.pluginUri,
+                userInvocable: undefined
+            });
+        }
+        const agents = !this.workspaceService.isSessionsWindow ? await this.promptsService.getCustomAgents(CancellationToken.None) : [];
+        for (const agent of agents) {
+            if (!agent.hooks || !agent.enabled) {
+                continue;
+            }
+            for (const hookType of ( Object.values(HookType))) {
+                const hookCommands = agent.hooks[hookType];
+                if (!hookCommands || hookCommands.length === 0) {
+                    continue;
+                }
+                const hookMeta = HOOK_METADATA[hookType];
+                for (let i = 0; i < hookCommands.length; i++) {
+                    const hook = hookCommands[i];
+                    const cmdLabel = formatHookCommandLabel(hook, OS);
+                    const truncatedCmd = cmdLabel.length > 60 ? cmdLabel.substring(0, 57) + "..." : cmdLabel;
+                    items.push({
+                        uri: agent.uri,
+                        type: promptType,
+                        name: hookMeta?.label ?? hookType,
+                        description: `${agent.name}: ${truncatedCmd || ( localize(6125, "(unset)"))}`,
+                        source: agent.source.storage,
+                        groupKey: "agents",
+                        enabled: !( disabledUris.has(agent.uri)),
+                        extensionId: agent.source.storage === PromptsStorage.extension ? agent.source.extensionId.value : undefined,
+                        pluginUri: agent.source.storage === PromptsStorage.plugin ? agent.source.pluginUri : undefined,
+                        userInvocable: undefined
+                    });
+                }
+            }
+        }
+    }
+    async fetchPromptServiceInstructions(items, extensionInfoByUri, disabledUris, promptType) {
+        const instructionFiles = await this.promptsService.getInstructionFiles(CancellationToken.None);
+        for (const file of instructionFiles) {
+            if (file.extension) {
+                extensionInfoByUri.set(file.uri, {
+                    id: file.extension.identifier,
+                    displayName: file.extension.displayName
+                });
+            }
+        }
+        const agentInstructionFiles = await this.promptsService.listAgentInstructions(CancellationToken.None, undefined);
+        const agentInstructionUris = ( new ResourceSet(( agentInstructionFiles.map(f => f.uri))));
+        for (const file of agentInstructionFiles) {
+            const storage = PromptsStorage.local;
+            const filename = basename(file.uri);
+            items.push({
+                uri: file.uri,
+                type: promptType,
+                name: filename,
+                source: storage,
+                groupKey: "agent-instructions",
+                enabled: !( disabledUris.has(file.uri)),
+                extensionId: undefined,
+                pluginUri: undefined,
+                userInvocable: undefined
+            });
+        }
+        for (const {
+            uri,
+            pattern,
+            name,
+            description,
+            storage,
+            extension,
+            pluginUri
+        } of instructionFiles) {
+            if (( agentInstructionUris.has(uri))) {
+                continue;
+            }
+            const friendlyName = getFriendlyName(name);
+            if (pattern !== undefined) {
+                const badge = pattern === "**" ? ( localize(6126, "always added")) : pattern;
+                const badgeTooltip = pattern === "**" ? ( localize(6127, "This instruction is automatically included in every interaction.")) : ( localize(
+                    6128,
+                    "This instruction is automatically included when files matching '{0}' are in context.",
+                    pattern
+                ));
+                items.push({
+                    uri,
+                    type: promptType,
+                    name: friendlyName,
+                    badge,
+                    badgeTooltip,
+                    description,
+                    source: storage,
+                    groupKey: "context-instructions",
+                    enabled: !( disabledUris.has(uri)),
+                    extensionId: extension?.identifier.value,
+                    pluginUri,
+                    userInvocable: undefined
+                });
+            } else {
+                items.push({
+                    uri,
+                    type: promptType,
+                    name: friendlyName,
+                    description,
+                    source: storage,
+                    groupKey: "on-demand-instructions",
+                    enabled: !( disabledUris.has(uri)),
+                    extensionId: extension?.identifier.value,
+                    pluginUri,
+                    userInvocable: undefined
+                });
+            }
+        }
+    }
+    applyBuiltinGroupKeys(items, extensionInfoByUri) {
+        return ( items.map(item => {
+            if (item.source !== AICustomizationSources.extension) {
+                return item;
+            }
+            const extInfo = extensionInfoByUri.get(item.uri);
+            if (!extInfo) {
+                return item;
+            }
+            if (isChatExtensionItem(extInfo.id, this.productService)) {
+                return {
+                    ...item,
+                    groupKey: item.groupKey ?? BUILTIN_STORAGE
+                };
+            }
+            return {
+                ...item,
+                extensionLabel: extInfo.displayName || extInfo.id.value
+            };
+        }));
+    }
+    applyLocalFilters(groupedItems, promptType) {
+        const descriptor = this.getActiveDescriptor();
+        const filter = descriptor.getStorageSourceFilter(promptType);
+        const items = applySourceFilter(groupedItems, filter);
+        return items;
+    }
+};
+PromptsServiceCustomizationItemProvider = ( __decorate([( __param(1, IPromptsService)), ( __param(2, IAICustomizationWorkspaceService)), ( __param(3, IProductService))], PromptsServiceCustomizationItemProvider));
+
+export { PromptsServiceCustomizationItemProvider };

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

@@ -0,0 +1,120 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IContextViewService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IExtensionManifestPropertiesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IExtension } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions";
+import { IExtensionsWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { IAgentHostToolSetEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.service";
+/**
+ * Chat Customizations → Tools: a searchable, collapsible tree of tool sets and their member
+ * tools. Enablement is read/written via {@link IAgentHostToolSetEnablementService}, scoped to
+ * `sessionType` (the agent host is the only target for Tools customizations).
+ */
+export declare class ToolsListWidget extends Disposable {
+    private readonly _sessionType;
+    private readonly _toolsService;
+    private readonly _enablementService;
+    private readonly _contextViewService;
+    private readonly _contextMenuService;
+    private readonly _dialogService;
+    private readonly _openerService;
+    private readonly _instantiationService;
+    private readonly _extensionsWorkbenchService;
+    private readonly _extensionManifestPropertiesService;
+    private readonly _environmentService;
+    readonly element: HTMLElement;
+    private readonly _onDidChangeItemCount;
+    readonly onDidChangeItemCount: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<number>;
+    private readonly _onDidSelectExtension;
+    readonly onDidSelectExtension: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<IExtension>;
+    private readonly _rowStore;
+    private readonly _searchQuery;
+    private readonly _expanded;
+    private readonly _delayedSearch;
+    private _searchInput;
+    private _header;
+    private _searchRow;
+    private _treeContainer;
+    private _treeScrollable;
+    private _browseButtonContainer;
+    private _backButtonContainer;
+    private _galleryContainer;
+    private _galleryEmpty;
+    private _galleryListContainer;
+    private _galleryList;
+    private _lastCount;
+    private _browseMode;
+    private _galleryCts;
+    private _lastHeight;
+    private _lastWidth;
+    private _activeRowId;
+    private _rows;
+    private readonly _rowByElement;
+    /** Read-only tool sets injected for the current session type (e.g. the Copilot CLI built-ins). */
+    private readonly _staticReadOnlySets;
+    constructor(_sessionType: string, _toolsService: ILanguageModelToolsService, _enablementService: IAgentHostToolSetEnablementService, _contextViewService: IContextViewService, _contextMenuService: IContextMenuService, _dialogService: IDialogService, _openerService: IOpenerService, _instantiationService: IInstantiationService, _extensionsWorkbenchService: IExtensionsWorkbenchService, _extensionManifestPropertiesService: IExtensionManifestPropertiesService, _environmentService: IWorkbenchEnvironmentService);
+    private _createHeader;
+    private _createSearchRow;
+    private _createGallery;
+    private _readState;
+    private _createStaticReadOnlySets;
+    private _createViewModel;
+    private _toViewModel;
+    layout(height: number, width: number): void;
+    /** Enters/leaves marketplace browse mode, swapping the tree for the gallery list. */
+    private _setBrowseMode;
+    /** Queries the Extensions gallery for tool-contributing extensions. */
+    private _queryGallery;
+    /**
+     * Keeps only extensions that contribute language model tools and, in the Agents window, can run there
+     * ({@link IExtensionManifestPropertiesService.canExecuteOnSessionsWindow}); the `executesCode` hint skips
+     * manifest fetches for extensions that can never run.
+     */
+    private _filterGalleryResults;
+    private _setGalleryMessage;
+    /** Move keyboard focus to the search box. */
+    focusSearch(): void;
+    /** Re-emit the current item count. Called once at startup to seed the section badge. */
+    fireItemCount(): void;
+    private _render;
+    private _addRow;
+    private _renderToolSet;
+    private _renderTool;
+    /**
+     * Subtitle for a tool-set row: the set's own `detail`, or for extension sets the extension's
+     * description (falling back to a generic "contributed by" label).
+     */
+    private _resolveSetDetail;
+    /** Mirror a row's enablement onto its `treeitem` so assistive tech announces it while navigating. */
+    private _updateRowAriaChecked;
+    private _toggleCollapsed;
+    private _setExpanded;
+    private _isExpanded;
+    /** Rows the user can currently land on: all set rows plus tool rows inside expanded sets, in tree order. */
+    private _visibleRows;
+    /** Keep a single roving `tabIndex=0` on the given row so the tree is one tab stop. */
+    private _setRovingRow;
+    private _focusRow;
+    /** Resolve the row owning a focus/keyboard target by walking up to a known row element. */
+    private _rowFromTarget;
+    /** After a (re)render, restore the roving tabIndex to the previously active row, else the first row. */
+    private _initRovingTabIndex;
+    private _onTreeKeyDown;
+    private _focusRelative;
+    private _focusEdge;
+    /** Right arrow: expand a collapsed set, or move into its first child when already expanded. */
+    private _onExpandKey;
+    /** Left arrow: collapse an expanded set, or move a tool row up to its parent set. */
+    private _onCollapseKey;
+    private _currentState;
+    /** Resolve the installed, non-builtin extension backing an extension-provided tool set. */
+    private _resolveExtensionForToolSet;
+    private _onGalleryContextMenu;
+    private _showExtensionContextMenu;
+    private _uninstallExtension;
+}