@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -0,0 +1,306 @@
+
+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, isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { BUILTIN_STORAGE, applyStorageSourceFilter } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+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 { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { matchesWorkspaceSubpath, matchesInstructionFileFilter } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagement';
+import { getFriendlyName, isChatExtensionItem } from './aiCustomizationItemSource.js';
+
+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
+        );
+    }
+    async provideChatSessionCustomizations(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 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,
+                    storage: agent.source.storage,
+                    enabled: !( disabledUris.has(agent.uri))
+                });
+                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,
+                    storage: skill.storage,
+                    enabled: true,
+                    badge: uiTooltip ? ( localize(5570, "UI Integration")) : undefined,
+                    badgeTooltip: uiTooltip
+                });
+            }
+            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,
+                            storage: file.storage,
+                            enabled: false,
+                            badge: uiTooltip ? ( localize(5570, "UI Integration")) : undefined,
+                            badgeTooltip: uiTooltip
+                        });
+                    }
+                }
+            }
+        } 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,
+                    storage: command.storage,
+                    enabled: !( disabledUris.has(command.uri))
+                });
+                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)),
+                storage: f.storage,
+                enabled: !( disabledUris.has(f.uri))
+            });
+        }
+        const agents = !this.workspaceService.isSessionsWindow ? await this.promptsService.getCustomAgents(CancellationToken.None) : [];
+        for (const agent of agents) {
+            if (!agent.hooks) {
+                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(5571, "(unset)"))}`,
+                        storage: agent.source.storage,
+                        groupKey: "agents",
+                        enabled: !( disabledUris.has(agent.uri))
+                    });
+                }
+            }
+        }
+    }
+    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,
+                storage,
+                groupKey: "agent-instructions",
+                enabled: !( disabledUris.has(file.uri))
+            });
+        }
+        for (const {
+            uri,
+            pattern,
+            name,
+            description,
+            storage
+        } of instructionFiles) {
+            if (( agentInstructionUris.has(uri))) {
+                continue;
+            }
+            const friendlyName = getFriendlyName(name);
+            if (pattern !== undefined) {
+                const badge = pattern === "**" ? ( localize(5572, "always added")) : pattern;
+                const badgeTooltip = pattern === "**" ? ( localize(5573, "This instruction is automatically included in every interaction.")) : ( localize(
+                    5574,
+                    "This instruction is automatically included when files matching '{0}' are in context.",
+                    pattern
+                ));
+                items.push({
+                    uri,
+                    type: promptType,
+                    name: friendlyName,
+                    badge,
+                    badgeTooltip,
+                    description,
+                    storage,
+                    groupKey: "context-instructions",
+                    enabled: !( disabledUris.has(uri))
+                });
+            } else {
+                items.push({
+                    uri,
+                    type: promptType,
+                    name: friendlyName,
+                    description,
+                    storage,
+                    groupKey: "on-demand-instructions",
+                    enabled: !( disabledUris.has(uri))
+                });
+            }
+        }
+    }
+    applyBuiltinGroupKeys(items, extensionInfoByUri) {
+        return ( items.map(item => {
+            if (item.storage !== PromptsStorage.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 filter = this.workspaceService.getStorageSourceFilter(promptType);
+        const withStorage = groupedItems.filter(item => item.storage !== undefined);
+        const withoutStorage = groupedItems.filter(item => item.storage === undefined);
+        let items = [...applyStorageSourceFilter(withStorage, filter), ...withoutStorage];
+        const descriptor = this.getActiveDescriptor();
+        const subpaths = descriptor.workspaceSubpaths;
+        const instrFilter = descriptor.instructionFileFilter;
+        if (subpaths) {
+            const projectRoot = this.workspaceService.getActiveProjectRoot();
+            items = items.filter(item => {
+                if (item.storage !== PromptsStorage.local || !projectRoot || !isEqualOrParent(item.uri, projectRoot)) {
+                    return true;
+                }
+                if (matchesWorkspaceSubpath(item.uri.path, subpaths)) {
+                    return true;
+                }
+                if (instrFilter && promptType === PromptsType.instructions && matchesInstructionFileFilter(item.uri.path, instrFilter)) {
+                    return true;
+                }
+                if (item.groupKey === "agent-instructions") {
+                    return true;
+                }
+                return false;
+            });
+        }
+        if (instrFilter && promptType === PromptsType.instructions) {
+            items = items.filter(item => matchesInstructionFileFilter(item.uri.path, instrFilter));
+        }
+        return items;
+    }
+}
+
+export { PromptsServiceCustomizationItemProvider };

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatAttachmentResolveService.js

@@ -106,7 +106,7 @@ let ChatAttachmentResolveService = class ChatAttachmentResolveService {
             }
             const readFile = await this.fileService.readFile(resource);
             if (stat.size > 30 * 1024 * 1024) {
-                this.dialogService.error(( localize(5508, "Image is too large")), ( localize(5509, "The image {0} is too large to be attached.", fileName)));
+                this.dialogService.error(( localize(5575, "Image is too large")), ( localize(5576, "The image {0} is too large to be attached.", fileName)));
                 throw ( new Error("Image is too large"));
             }
             dataBuffer = readFile.value;