@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

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

@@ -0,0 +1,943 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
+import { $ as $$1, append, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename, dirname, isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+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 { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { 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 { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { pluginIcon, extensionIcon, userIcon, workspaceIcon, promptIcon, hookIcon, instructionsIcon, skillIcon, agentIcon } from './aiCustomizationIcons.js';
+import { AICustomizationManagementItemMenuId } from './aiCustomizationManagement.js';
+import { InputBox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { defaultInputBoxStyles, defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IContextViewService, IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { HighlightedLabel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/highlightedlabel/highlightedLabel';
+import { matchesContiguousSubString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { Button, ButtonWithDropdown } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { getFlatContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { AICustomizationManagementSection, applyStorageSourceFilter } from '../../common/aiCustomizationWorkspaceService.js';
+import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
+import { Separator, Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { ISCMService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { generateCustomizationDebugReport } from './aiCustomizationDebugPanel.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(aiCustomizationManagement);
+const $ = $$1;
+const ITEM_HEIGHT = 44;
+const GROUP_HEADER_HEIGHT = 32;
+const GROUP_HEADER_HEIGHT_WITH_SEPARATOR = 40;
+class AICustomizationListDelegate {
+    getHeight(element) {
+        if (element.type === "group-header") {
+            return element.isFirst ? GROUP_HEADER_HEIGHT : GROUP_HEADER_HEIGHT_WITH_SEPARATOR;
+        }
+        return ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        return element.type === "group-header" ? "groupHeader" : "aiCustomizationItem";
+    }
+}
+class GroupHeaderRenderer {
+    constructor(hoverService) {
+        this.hoverService = hoverService;
+        this.templateId = "groupHeader";
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposables = ( new DisposableStore());
+        container.classList.add("ai-customization-group-header");
+        const chevron = append(container, $(".group-chevron"));
+        const icon = append(container, $(".group-icon"));
+        const labelGroup = append(container, $(".group-label-group"));
+        const label = append(labelGroup, $(".group-label"));
+        const infoIcon = append(labelGroup, $(".group-info"));
+        infoIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.info));
+        const count = append(container, $(".group-count"));
+        return {
+            container,
+            chevron,
+            icon,
+            label,
+            count,
+            infoIcon,
+            disposables,
+            elementDisposables
+        };
+    }
+    renderElement(element, _index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.chevron.className = "group-chevron";
+        templateData.chevron.classList.add(
+            ...ThemeIcon.asClassNameArray(element.collapsed ? Codicon.chevronRight : Codicon.chevronDown)
+        );
+        templateData.icon.className = "group-icon";
+        templateData.icon.classList.add(...ThemeIcon.asClassNameArray(element.icon));
+        templateData.label.textContent = element.label;
+        templateData.count.textContent = `${element.count}`;
+        templateData.elementDisposables.add(this.hoverService.setupDelayedHover(templateData.infoIcon, () => ({
+            content: element.description,
+            appearance: {
+                compact: true,
+                skipFadeInAnimation: true
+            }
+        })));
+        templateData.container.classList.toggle("collapsed", element.collapsed);
+        templateData.container.classList.toggle("has-previous-group", !element.isFirst);
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.disposables.dispose();
+    }
+}
+class AICustomizationItemRenderer {
+    constructor() {
+        this.templateId = "aiCustomizationItem";
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposables = ( new DisposableStore());
+        container.classList.add("ai-customization-list-item");
+        const leftSection = append(container, $(".item-left"));
+        const storageBadge = append(leftSection, $(".storage-badge"));
+        const textContainer = append(leftSection, $(".item-text"));
+        const nameLabel = disposables.add(( new HighlightedLabel(append(textContainer, $(".item-name")))));
+        const description = disposables.add(( new HighlightedLabel(append(textContainer, $(".item-description")))));
+        const gitStatusBadge = append(container, $(".git-status-badge"));
+        const actionsContainer = append(container, $(".item-right"));
+        return {
+            container,
+            actionsContainer,
+            nameLabel,
+            description,
+            storageBadge,
+            gitStatusBadge,
+            disposables,
+            elementDisposables
+        };
+    }
+    renderElement(entry, index, templateData) {
+        templateData.elementDisposables.clear();
+        const element = entry.item;
+        templateData.nameLabel.set(element.name, element.nameMatches);
+        const secondaryText = element.description || element.filename;
+        if (secondaryText) {
+            templateData.description.set(
+                secondaryText,
+                element.description ? element.descriptionMatches : undefined
+            );
+            templateData.description.element.style.display = "";
+            templateData.description.element.classList.toggle("is-filename", !element.description);
+        } else {
+            templateData.description.set("", undefined);
+            templateData.description.element.style.display = "none";
+        }
+        let storageBadgeIcon;
+        let storageBadgeLabel;
+        switch (element.storage) {
+        case PromptsStorage.local:
+            storageBadgeIcon = workspaceIcon;
+            storageBadgeLabel = ( localize(5206, "Workspace"));
+            break;
+        case PromptsStorage.user:
+            storageBadgeIcon = userIcon;
+            storageBadgeLabel = ( localize(5207, "User"));
+            break;
+        case PromptsStorage.extension:
+            storageBadgeIcon = extensionIcon;
+            storageBadgeLabel = ( localize(5208, "Extension"));
+            break;
+        case PromptsStorage.plugin:
+            storageBadgeIcon = pluginIcon;
+            storageBadgeLabel = ( localize(5209, "Plugin"));
+            break;
+        }
+        templateData.storageBadge.className = "storage-badge";
+        templateData.storageBadge.classList.add(...ThemeIcon.asClassNameArray(storageBadgeIcon));
+        templateData.storageBadge.title = storageBadgeLabel;
+        const gitBadge = templateData.gitStatusBadge;
+        gitBadge.className = "git-status-badge";
+        if (element.gitStatus === "committed") {
+            gitBadge.classList.add(...ThemeIcon.asClassNameArray(Codicon.check));
+            gitBadge.classList.add("committed");
+            gitBadge.textContent = "";
+            gitBadge.title = ( localize(5210, "Committed"));
+            gitBadge.style.display = "";
+        } else {
+            gitBadge.style.display = "none";
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.disposables.dispose();
+    }
+}
+function sectionToPromptType(section) {
+    switch (section) {
+    case AICustomizationManagementSection.Agents:
+        return PromptsType.agent;
+    case AICustomizationManagementSection.Skills:
+        return PromptsType.skill;
+    case AICustomizationManagementSection.Instructions:
+        return PromptsType.instructions;
+    case AICustomizationManagementSection.Hooks:
+        return PromptsType.hook;
+    case AICustomizationManagementSection.Prompts:
+    default:
+        return PromptsType.prompt;
+    }
+}
+let AICustomizationListWidget = class AICustomizationListWidget extends Disposable {
+    constructor(
+        instantiationService,
+        promptsService,
+        contextViewService,
+        openerService,
+        contextMenuService,
+        menuService,
+        contextKeyService,
+        workspaceContextService,
+        labelService,
+        workspaceService,
+        clipboardService,
+        scmService,
+        hoverService
+    ) {
+        super();
+        this.instantiationService = instantiationService;
+        this.promptsService = promptsService;
+        this.contextViewService = contextViewService;
+        this.openerService = openerService;
+        this.contextMenuService = contextMenuService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.workspaceContextService = workspaceContextService;
+        this.labelService = labelService;
+        this.workspaceService = workspaceService;
+        this.clipboardService = clipboardService;
+        this.scmService = scmService;
+        this.hoverService = hoverService;
+        this.currentSection = AICustomizationManagementSection.Agents;
+        this.allItems = [];
+        this.displayEntries = [];
+        this.searchQuery = "";
+        this.collapsedGroups = ( new Set());
+        this.dropdownActionDisposables = this._register(( new DisposableStore()));
+        this.delayedFilter = ( new Delayer(200));
+        this._onDidSelectItem = this._register(( new Emitter()));
+        this.onDidSelectItem = this._onDidSelectItem.event;
+        this._onDidChangeItemCount = this._register(( new Emitter()));
+        this.onDidChangeItemCount = this._onDidChangeItemCount.event;
+        this._onDidRequestCreate = this._register(( new Emitter()));
+        this.onDidRequestCreate = this._onDidRequestCreate.event;
+        this._onDidRequestCreateManual = this._register(( new Emitter()));
+        this.onDidRequestCreateManual = this._onDidRequestCreateManual.event;
+        this.element = $(".ai-customization-list-widget");
+        this.create();
+        this._register(
+            this.workspaceContextService.onDidChangeWorkspaceFolders(() => this.refresh())
+        );
+        this._register(autorun(reader => {
+            this.workspaceService.activeProjectRoot.read(reader);
+            this.updateAddButton();
+            this.refresh();
+        }));
+        const trackRepoChanges = repo => {
+            this._register(repo.provider.onDidChangeResources(() => {
+                this.updateGitStatus(this.allItems);
+                this.filterItems();
+            }));
+        };
+        for (const repo of [...this.scmService.repositories]) {
+            trackRepoChanges(repo);
+        }
+        this._register(this.scmService.onDidAddRepository(repo => trackRepoChanges(repo)));
+    }
+    create() {
+        this.searchAndButtonContainer = append(this.element, $(".list-search-and-button-container"));
+        this.searchContainer = append(this.searchAndButtonContainer, $(".list-search-container"));
+        this.searchInput = this._register(( new InputBox(this.searchContainer, this.contextViewService, {
+            placeholder: ( localize(5211, "Type to search...")),
+            inputBoxStyles: defaultInputBoxStyles
+        })));
+        this._register(this.searchInput.onDidChange(() => {
+            this.searchQuery = this.searchInput.value;
+            this.delayedFilter.trigger(() => this.filterItems());
+        }));
+        this.addButtonContainer = append(this.searchAndButtonContainer, $(".list-add-button-container"));
+        this.addButtonSimple = this._register(( new Button(this.addButtonContainer, {
+            ...defaultButtonStyles,
+            supportIcons: true
+        })));
+        this.addButtonSimple.element.classList.add("list-add-button");
+        this._register(this.addButtonSimple.onDidClick(() => this.executePrimaryCreateAction()));
+        this.addButton = this._register(( new ButtonWithDropdown(this.addButtonContainer, {
+            ...defaultButtonStyles,
+            supportIcons: true,
+            contextMenuProvider: this.contextMenuService,
+            addPrimaryActionToDropdown: false,
+            actions: {
+                getActions: () => this.getDropdownActions()
+            }
+        })));
+        this.addButton.element.classList.add("list-add-button");
+        this._register(this.addButton.onDidClick(() => this.executePrimaryCreateAction()));
+        this.updateAddButton();
+        this.listContainer = append(this.element, $(".list-container"));
+        this.emptyStateContainer = append(this.element, $(".list-empty-state"));
+        this.emptyStateIcon = append(this.emptyStateContainer, $(".empty-state-icon"));
+        this.emptyStateText = append(this.emptyStateContainer, $(".empty-state-text"));
+        this.emptyStateSubtext = append(this.emptyStateContainer, $(".empty-state-subtext"));
+        this.emptyStateContainer.style.display = "none";
+        this.list = this._register(this.instantiationService.createInstance(
+            WorkbenchList,
+            "AICustomizationManagementList",
+            this.listContainer,
+            ( new AICustomizationListDelegate()),
+            [( new GroupHeaderRenderer(this.hoverService)), this.instantiationService.createInstance(AICustomizationItemRenderer)],
+            {
+                identityProvider: {
+                    getId: entry => entry.type === "group-header" ? entry.id : entry.item.id
+                },
+                accessibilityProvider: {
+                    getAriaLabel: entry => {
+                        if (entry.type === "group-header") {
+                            return localize(
+                                5212,
+                                "{0}, {1} items, {2}",
+                                entry.label,
+                                entry.count,
+                                entry.collapsed ? ( localize(5213, "collapsed")) : ( localize(5214, "expanded"))
+                            );
+                        }
+                        return entry.item.description ? ( localize(5215, "{0}, {1}", entry.item.name, entry.item.description)) : entry.item.name;
+                    },
+                    getWidgetAriaLabel: () => ( localize(5216, "Chat Customizations"))
+                },
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: entry => entry.type === "group-header" ? entry.label : entry.item.name
+                },
+                multipleSelectionSupport: false,
+                openOnSingleClick: true
+            }
+        ));
+        this._register(this.list.onDidOpen(e => {
+            if (e.element) {
+                if (e.element.type === "group-header") {
+                    this.toggleGroup(e.element);
+                } else {
+                    this._onDidSelectItem.fire(e.element.item);
+                }
+            }
+        }));
+        this._register(this.list.onContextMenu(e => this.onContextMenu(e)));
+        this._register(this.promptsService.onDidChangeCustomAgents(() => this.refresh()));
+        this._register(this.promptsService.onDidChangeSlashCommands(() => this.refresh()));
+        this.sectionHeader = append(this.element, $(".section-footer"));
+        this.sectionDescription = append(this.sectionHeader, $("p.section-footer-description"));
+        this.sectionLink = append(this.sectionHeader, $("a.section-footer-link"));
+        this._register(addDisposableListener(this.sectionLink, "click", e => {
+            e.preventDefault();
+            const href = this.sectionLink.href;
+            if (href) {
+                this.openerService.open(( URI.parse(href)));
+            }
+        }));
+        this.updateSectionHeader();
+    }
+    onContextMenu(e) {
+        if (!e.element || e.element.type !== "file-item") {
+            return;
+        }
+        const item = e.element.item;
+        const context = {
+            uri: ( item.uri.toString()),
+            name: item.name,
+            promptType: item.promptType,
+            storage: item.storage
+        };
+        const actions = this.menuService.getMenuActions(AICustomizationManagementItemMenuId, this.contextKeyService, {
+            arg: context,
+            shouldForwardArgs: true
+        });
+        const flatActions = getFlatContextMenuActions(actions);
+        const copyActions = [( new Separator()), ( new Action("copyFullPath", ( localize(5217, "Copy Full Path")), undefined, true, async () => {
+            await this.clipboardService.writeText(item.uri.fsPath);
+        })), ( new Action("copyRelativePath", ( localize(5218, "Copy Relative Path")), undefined, true, async () => {
+            const basePath = this.workspaceService.getActiveProjectRoot();
+            if (basePath && item.uri.fsPath.startsWith(basePath.fsPath)) {
+                const relative = item.uri.fsPath.substring(basePath.fsPath.length + 1);
+                await this.clipboardService.writeText(relative);
+            } else {
+                const relativePath = this.labelService.getUriLabel(item.uri, {
+                    relative: true
+                });
+                await this.clipboardService.writeText(relativePath);
+            }
+        }))];
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => [...flatActions, ...copyActions]
+        });
+    }
+    async setSection(section) {
+        this.currentSection = section;
+        this.updateSectionHeader();
+        this.updateAddButton();
+        await this.loadItems();
+    }
+    updateSectionHeader() {
+        let description;
+        let docsUrl;
+        let learnMoreLabel;
+        switch (this.currentSection) {
+        case AICustomizationManagementSection.Agents:
+            description = ( localize(
+                5219,
+                "Configure the AI to adopt different personas tailored to specific development tasks. Each agent has its own instructions, tools, and behavior."
+            ));
+            docsUrl = "https://code.visualstudio.com/docs/copilot/customization/custom-agents";
+            learnMoreLabel = ( localize(5220, "Learn more about custom agents"));
+            break;
+        case AICustomizationManagementSection.Skills:
+            description = ( localize(
+                5221,
+                "Folders of instructions, scripts, and resources that Copilot loads when relevant to perform specialized tasks."
+            ));
+            docsUrl = "https://code.visualstudio.com/docs/copilot/customization/agent-skills";
+            learnMoreLabel = ( localize(5222, "Learn more about agent skills"));
+            break;
+        case AICustomizationManagementSection.Instructions:
+            description = ( localize(
+                5223,
+                "Define common guidelines and rules that automatically influence how AI generates code and handles development tasks."
+            ));
+            docsUrl = "https://code.visualstudio.com/docs/copilot/customization/custom-instructions";
+            learnMoreLabel = ( localize(5224, "Learn more about custom instructions"));
+            break;
+        case AICustomizationManagementSection.Hooks:
+            description = ( localize(5225, "Prompts executed at specific points during an agentic lifecycle."));
+            docsUrl = "https://code.visualstudio.com/docs/copilot/customization/hooks";
+            learnMoreLabel = ( localize(5226, "Learn more about hooks"));
+            break;
+        case AICustomizationManagementSection.Prompts:
+        default:
+            description = ( localize(
+                5227,
+                "Reusable prompts for common development tasks like generating code, performing reviews, or scaffolding components."
+            ));
+            docsUrl = "https://code.visualstudio.com/docs/copilot/customization/prompt-files";
+            learnMoreLabel = ( localize(5228, "Learn more about prompt files"));
+            break;
+        }
+        this.sectionDescription.textContent = description;
+        this.sectionLink.textContent = learnMoreLabel;
+        this.sectionLink.href = docsUrl;
+    }
+    updateAddButton() {
+        const typeLabel = this.getTypeLabel();
+        const dropdownActions = this.getDropdownActions();
+        const hasDropdown = dropdownActions.length > 0;
+        this.addButton.element.style.display = hasDropdown ? "" : "none";
+        this.addButtonSimple.element.style.display = hasDropdown ? "none" : "";
+        if (this.workspaceService.isSessionsWindow) {
+            const hasWorkspace = this.hasActiveWorkspace();
+            const label = `$(${Codicon.add.id}) New ${typeLabel} (Workspace)`;
+            if (hasDropdown) {
+                this.addButton.label = label;
+                this.addButton.enabled = hasWorkspace;
+                this.addButton.primaryButton.setTitle("");
+                this.addButton.dropdownButton.setTitle("");
+                if (!hasWorkspace) {
+                    const disabledTitle = ( localize(5229, "Open a workspace folder to create customizations."));
+                    this.addButton.primaryButton.setTitle(disabledTitle);
+                    this.addButton.dropdownButton.setTitle(disabledTitle);
+                }
+            } else {
+                this.addButtonSimple.label = label;
+                this.addButtonSimple.enabled = hasWorkspace;
+                if (!hasWorkspace) {
+                    this.addButtonSimple.setTitle(( localize(5229, "Open a workspace folder to create customizations.")));
+                } else {
+                    this.addButtonSimple.setTitle("");
+                }
+            }
+        } else {
+            const label = `$(${Codicon.sparkle.id}) Generate ${typeLabel}`;
+            if (hasDropdown) {
+                this.addButton.label = label;
+                this.addButton.enabled = true;
+                this.addButton.primaryButton.setTitle("");
+                this.addButton.dropdownButton.setTitle("");
+            } else {
+                this.addButtonSimple.label = label;
+                this.addButtonSimple.enabled = true;
+                this.addButtonSimple.setTitle("");
+            }
+        }
+    }
+    getDropdownActions() {
+        this.dropdownActionDisposables.clear();
+        const typeLabel = this.getTypeLabel();
+        const actions = [];
+        const promptType = sectionToPromptType(this.currentSection);
+        if (promptType === PromptsType.hook) {
+            if (this.workspaceService.isSessionsWindow)
+                ; else {
+                if (this.hasActiveWorkspace()) {
+                    actions.push(this.dropdownActionDisposables.add(( new Action(
+                        "configureHooks",
+                        `$(${Codicon.add.id}) Configure Hooks`,
+                        undefined,
+                        true,
+                        () => {
+                            this._onDidRequestCreateManual.fire({
+                                type: promptType,
+                                target: "workspace"
+                            });
+                        }
+                    ))));
+                }
+            }
+            return actions;
+        }
+        if (this.workspaceService.isSessionsWindow) {
+            actions.push(this.dropdownActionDisposables.add(( new Action(
+                "createUser",
+                `$(${Codicon.account.id}) New ${typeLabel} (User)`,
+                undefined,
+                true,
+                () => {
+                    this._onDidRequestCreateManual.fire({
+                        type: promptType,
+                        target: "user"
+                    });
+                }
+            ))));
+        } else {
+            if (this.hasActiveWorkspace()) {
+                actions.push(this.dropdownActionDisposables.add(( new Action(
+                    "createWorkspace",
+                    `$(${Codicon.folder.id}) New ${typeLabel} (Workspace)`,
+                    undefined,
+                    true,
+                    () => {
+                        this._onDidRequestCreateManual.fire({
+                            type: promptType,
+                            target: "workspace"
+                        });
+                    }
+                ))));
+            }
+            actions.push(this.dropdownActionDisposables.add(( new Action(
+                "createUser",
+                `$(${Codicon.account.id}) New ${typeLabel} (User)`,
+                undefined,
+                true,
+                () => {
+                    this._onDidRequestCreateManual.fire({
+                        type: promptType,
+                        target: "user"
+                    });
+                }
+            ))));
+        }
+        return actions;
+    }
+    hasActiveWorkspace() {
+        return !!this.workspaceService.getActiveProjectRoot();
+    }
+    executePrimaryCreateAction() {
+        const promptType = sectionToPromptType(this.currentSection);
+        if (this.workspaceService.isSessionsWindow) {
+            if (!this.hasActiveWorkspace()) {
+                return;
+            }
+            this._onDidRequestCreateManual.fire({
+                type: promptType,
+                target: "workspace"
+            });
+        } else {
+            this._onDidRequestCreate.fire(promptType);
+        }
+    }
+    getTypeLabel() {
+        switch (this.currentSection) {
+        case AICustomizationManagementSection.Agents:
+            return localize(5230, "Agent");
+        case AICustomizationManagementSection.Skills:
+            return localize(5231, "Skill");
+        case AICustomizationManagementSection.Instructions:
+            return localize(5232, "Instructions");
+        case AICustomizationManagementSection.Hooks:
+            return localize(5233, "Hook");
+        case AICustomizationManagementSection.Prompts:
+        default:
+            return localize(5234, "Prompt");
+        }
+    }
+    async refresh() {
+        this.updateAddButton();
+        await this.loadItems();
+    }
+    async loadItems() {
+        const promptType = sectionToPromptType(this.currentSection);
+        const items = [];
+        if (promptType === PromptsType.agent) {
+            const agents = await this.promptsService.getCustomAgents(CancellationToken.None);
+            for (const agent of agents) {
+                const filename = basename(agent.uri);
+                items.push({
+                    id: ( agent.uri.toString()),
+                    uri: agent.uri,
+                    name: agent.name,
+                    filename,
+                    description: agent.description,
+                    storage: agent.source.storage,
+                    promptType
+                });
+            }
+        } else if (promptType === PromptsType.skill) {
+            const skills = await this.promptsService.findAgentSkills(CancellationToken.None);
+            for (const skill of skills || []) {
+                const filename = basename(skill.uri);
+                const skillName = skill.name || basename(dirname(skill.uri)) || filename;
+                items.push({
+                    id: ( skill.uri.toString()),
+                    uri: skill.uri,
+                    name: skillName,
+                    filename,
+                    description: skill.description,
+                    storage: skill.storage,
+                    promptType
+                });
+            }
+        } else if (promptType === PromptsType.prompt) {
+            const commands = await this.promptsService.getPromptSlashCommands(CancellationToken.None);
+            for (const command of commands) {
+                if (command.promptPath.type === PromptsType.skill) {
+                    continue;
+                }
+                const filename = basename(command.promptPath.uri);
+                items.push({
+                    id: ( command.promptPath.uri.toString()),
+                    uri: command.promptPath.uri,
+                    name: command.name,
+                    filename,
+                    description: command.description,
+                    storage: command.promptPath.storage,
+                    promptType
+                });
+            }
+        } else if (promptType === PromptsType.hook) {
+            const hookFiles = await this.promptsService.listPromptFiles(PromptsType.hook, CancellationToken.None);
+            for (const hookFile of hookFiles) {
+                const filename = basename(hookFile.uri);
+                items.push({
+                    id: ( hookFile.uri.toString()),
+                    uri: hookFile.uri,
+                    name: this.getFriendlyName(filename),
+                    filename,
+                    storage: hookFile.storage,
+                    promptType
+                });
+            }
+        } else {
+            const promptFiles = await this.promptsService.listPromptFiles(promptType, CancellationToken.None);
+            const allItems = [...promptFiles];
+            if (promptType === PromptsType.instructions) {
+                const agentInstructions = await this.promptsService.listAgentInstructions(CancellationToken.None, undefined);
+                const workspaceFolderUris = ( this.workspaceContextService.getWorkspace().folders.map(f => f.uri));
+                const activeRoot = this.workspaceService.getActiveProjectRoot();
+                if (activeRoot) {
+                    workspaceFolderUris.push(activeRoot);
+                }
+                for (const file of agentInstructions) {
+                    const isWorkspaceFile = ( workspaceFolderUris.some(root => isEqualOrParent(file.uri, root)));
+                    allItems.push({
+                        uri: file.uri,
+                        storage: isWorkspaceFile ? PromptsStorage.local : PromptsStorage.user,
+                        type: PromptsType.instructions,
+                        name: basename(file.uri)
+                    });
+                }
+            }
+            const workspaceItems = allItems.filter(item => item.storage === PromptsStorage.local);
+            const userItems = allItems.filter(item => item.storage === PromptsStorage.user);
+            const extensionItems = allItems.filter(item => item.storage === PromptsStorage.extension);
+            const pluginItems = allItems.filter(item => item.storage === PromptsStorage.plugin);
+            const mapToListItem = item => {
+                const filename = basename(item.uri);
+                const friendlyName = item.name || this.getFriendlyName(filename);
+                return {
+                    id: ( item.uri.toString()),
+                    uri: item.uri,
+                    name: friendlyName,
+                    filename,
+                    description: item.description,
+                    storage: item.storage,
+                    promptType
+                };
+            };
+            items.push(...( workspaceItems.map(mapToListItem)));
+            items.push(...( userItems.map(mapToListItem)));
+            items.push(...( extensionItems.map(mapToListItem)));
+            items.push(...( pluginItems.map(mapToListItem)));
+        }
+        const filter = this.workspaceService.getStorageSourceFilter(promptType);
+        const filteredItems = applyStorageSourceFilter(items, filter);
+        items.length = 0;
+        items.push(...filteredItems);
+        items.sort((a, b) => a.name.localeCompare(b.name));
+        this.updateGitStatus(items);
+        this.allItems = items;
+        this.filterItems();
+        this._onDidChangeItemCount.fire(items.length);
+    }
+    updateGitStatus(items) {
+        const uncommittedUris = ( new Set());
+        for (const repo of [...this.scmService.repositories]) {
+            for (const group of repo.provider.groups) {
+                for (const resource of group.resources) {
+                    uncommittedUris.add(( resource.sourceUri.toString()));
+                }
+            }
+        }
+        for (const item of items) {
+            if (item.storage === PromptsStorage.local) {
+                item.gitStatus = ( uncommittedUris.has(( item.uri.toString()))) ? "uncommitted" : "committed";
+            }
+        }
+    }
+    getFriendlyName(filename) {
+        let name = filename.replace(/\.instructions\.md$/i, "").replace(/\.prompt\.md$/i, "").replace(/\.agent\.md$/i, "").replace(/\.md$/i, "");
+        name = name.replace(/[-_]/g, " ").replace(/\b\w/g, c => c.toUpperCase());
+        return name || filename;
+    }
+    filterItems() {
+        let matchedItems;
+        if (!this.searchQuery.trim()) {
+            matchedItems = ( this.allItems.map(item => ({
+                ...item,
+                nameMatches: undefined,
+                descriptionMatches: undefined
+            })));
+        } else {
+            const query = this.searchQuery.toLowerCase();
+            matchedItems = [];
+            for (const item of this.allItems) {
+                const nameMatches = matchesContiguousSubString(query, item.name);
+                const descriptionMatches = item.description ? matchesContiguousSubString(query, item.description) : null;
+                const filenameMatches = matchesContiguousSubString(query, item.filename);
+                if (nameMatches || descriptionMatches || filenameMatches) {
+                    matchedItems.push({
+                        ...item,
+                        nameMatches: nameMatches || undefined,
+                        descriptionMatches: descriptionMatches || undefined
+                    });
+                }
+            }
+        }
+        const promptType = sectionToPromptType(this.currentSection);
+        const visibleSources = ( new Set(this.workspaceService.getStorageSourceFilter(promptType).sources));
+        const groups = [{
+            storage: PromptsStorage.local,
+            label: ( localize(5235, "Workspace")),
+            icon: workspaceIcon,
+            description: ( localize(
+                5236,
+                "Customizations stored as files in your project folder and shared with your team via version control."
+            )),
+            items: []
+        }, {
+            storage: PromptsStorage.user,
+            label: ( localize(5237, "User")),
+            icon: userIcon,
+            description: ( localize(
+                5238,
+                "Customizations stored locally on your machine in a central location. Private to you and available across all projects."
+            )),
+            items: []
+        }, {
+            storage: PromptsStorage.extension,
+            label: ( localize(5239, "Extensions")),
+            icon: extensionIcon,
+            description: ( localize(5240, "Read-only customizations provided by installed extensions.")),
+            items: []
+        }, {
+            storage: PromptsStorage.plugin,
+            label: ( localize(5241, "Plugins")),
+            icon: pluginIcon,
+            description: ( localize(5242, "Read-only customizations provided by installed plugins.")),
+            items: []
+        }].filter(g => ( visibleSources.has(g.storage)));
+        for (const item of matchedItems) {
+            const group = groups.find(g => g.storage === item.storage);
+            if (group) {
+                group.items.push(item);
+            }
+        }
+        for (const group of groups) {
+            group.items.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        this.displayEntries = [];
+        let isFirstGroup = true;
+        for (const group of groups) {
+            if (group.items.length === 0) {
+                continue;
+            }
+            const collapsed = ( this.collapsedGroups.has(group.storage));
+            this.displayEntries.push({
+                type: "group-header",
+                id: `group-${group.storage}`,
+                storage: group.storage,
+                label: group.label,
+                icon: group.icon,
+                count: group.items.length,
+                isFirst: isFirstGroup,
+                description: group.description,
+                collapsed
+            });
+            isFirstGroup = false;
+            if (!collapsed) {
+                for (const item of group.items) {
+                    this.displayEntries.push({
+                        type: "file-item",
+                        item
+                    });
+                }
+            }
+        }
+        this.list.splice(0, this.list.length, this.displayEntries);
+        this.updateEmptyState();
+    }
+    toggleGroup(entry) {
+        if (( this.collapsedGroups.has(entry.storage))) {
+            this.collapsedGroups.delete(entry.storage);
+        } else {
+            this.collapsedGroups.add(entry.storage);
+        }
+        this.filterItems();
+    }
+    updateEmptyState() {
+        const hasItems = this.displayEntries.length > 0;
+        if (!hasItems) {
+            this.emptyStateContainer.style.display = "flex";
+            this.listContainer.style.display = "none";
+            this.emptyStateIcon.className = "empty-state-icon";
+            const sectionIcon = this.getSectionIcon();
+            this.emptyStateIcon.classList.add(...ThemeIcon.asClassNameArray(sectionIcon));
+            if (this.searchQuery.trim()) {
+                this.emptyStateText.textContent = ( localize(5243, "No items match '{0}'", this.searchQuery));
+                this.emptyStateSubtext.textContent = ( localize(5244, "Try a different search term"));
+            } else {
+                const emptyInfo = this.getEmptyStateInfo();
+                this.emptyStateText.textContent = emptyInfo.title;
+                this.emptyStateSubtext.textContent = emptyInfo.description;
+            }
+        } else {
+            this.emptyStateContainer.style.display = "none";
+            this.listContainer.style.display = "";
+        }
+    }
+    getSectionIcon() {
+        switch (this.currentSection) {
+        case AICustomizationManagementSection.Agents:
+            return agentIcon;
+        case AICustomizationManagementSection.Skills:
+            return skillIcon;
+        case AICustomizationManagementSection.Instructions:
+            return instructionsIcon;
+        case AICustomizationManagementSection.Hooks:
+            return hookIcon;
+        case AICustomizationManagementSection.Prompts:
+        default:
+            return promptIcon;
+        }
+    }
+    getEmptyStateInfo() {
+        switch (this.currentSection) {
+        case AICustomizationManagementSection.Agents:
+            return {
+                title: ( localize(5245, "No agents yet")),
+                description: ( localize(5246, "Create your first custom agent to get started"))
+            };
+        case AICustomizationManagementSection.Skills:
+            return {
+                title: ( localize(5247, "No skills yet")),
+                description: ( localize(5248, "Create your first skill to extend agent capabilities"))
+            };
+        case AICustomizationManagementSection.Instructions:
+            return {
+                title: ( localize(5249, "No instructions yet")),
+                description: ( localize(5250, "Add instructions to teach Copilot about your codebase"))
+            };
+        case AICustomizationManagementSection.Hooks:
+            return {
+                title: ( localize(5251, "No hooks yet")),
+                description: ( localize(5252, "Create hooks to execute commands at agent lifecycle events"))
+            };
+        case AICustomizationManagementSection.Prompts:
+        default:
+            return {
+                title: ( localize(5253, "No prompts yet")),
+                description: ( localize(5254, "Create reusable prompts for common tasks"))
+            };
+        }
+    }
+    setSearchQuery(query) {
+        this.searchInput.value = query;
+    }
+    clearSearch() {
+        this.searchInput.value = "";
+    }
+    focusSearch() {
+        this.searchInput.focus();
+    }
+    focusList() {
+        this.list.domFocus();
+        if (this.displayEntries.length > 0) {
+            this.list.setFocus([0]);
+        }
+    }
+    layout(height, width) {
+        const sectionFooterHeight = this.sectionHeader.offsetHeight || 100;
+        const searchBarHeight = this.searchAndButtonContainer.offsetHeight || 40;
+        const margins = 12;
+        const listHeight = height - sectionFooterHeight - searchBarHeight - margins;
+        this.searchInput.layout();
+        this.listContainer.style.height = `${Math.max(0, listHeight)}px`;
+        this.list.layout(Math.max(0, listHeight), width);
+    }
+    get itemCount() {
+        return this.allItems.length;
+    }
+    async generateDebugReport() {
+        return generateCustomizationDebugReport(this.currentSection, this.promptsService, this.workspaceService, {
+            allItems: this.allItems,
+            displayEntries: this.displayEntries
+        });
+    }
+};
+AICustomizationListWidget = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IPromptsService)), ( __param(2, IContextViewService)), ( __param(3, IOpenerService)), ( __param(4, IContextMenuService)), ( __param(5, IMenuService)), ( __param(6, IContextKeyService)), ( __param(7, IWorkspaceContextService)), ( __param(8, ILabelService)), ( __param(9, IAICustomizationWorkspaceService)), ( __param(10, IClipboardService)), ( __param(11, ISCMService)), ( __param(12, IHoverService))], AICustomizationListWidget));
+
+export { AICustomizationListWidget, sectionToPromptType };