@codingame/monaco-vscode-xterm-addons-common 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/attachInstructionsAction.js

@@ -17,23 +17,23 @@ import { toPromptFileVariableEntry, PromptFileVariableKind } from '@codingame/mo
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 
-const ATTACH_INSTRUCTIONS_ACTION_ID = 'workbench.action.chat.attach.instructions';
-const CONFIGURE_INSTRUCTIONS_ACTION_ID = 'workbench.action.chat.configure.instructions';
+const ATTACH_INSTRUCTIONS_ACTION_ID = "workbench.action.chat.attach.instructions";
+const CONFIGURE_INSTRUCTIONS_ACTION_ID = "workbench.action.chat.configure.instructions";
 class ManageInstructionsFilesAction extends Action2 {
     constructor() {
         super({
             id: CONFIGURE_INSTRUCTIONS_ACTION_ID,
-            title: ( localize2(5452, "Configure Instructions...")),
-            shortTitle: ( localize2(5453, "Chat Instructions")),
+            title: ( localize2(5651, "Configure Instructions...")),
+            shortTitle: ( localize2(5652, "Chat Instructions")),
             icon: Codicon.bookmark,
             f1: true,
             precondition: ChatContextKeys.enabled,
             category: CHAT_CATEGORY,
             menu: {
                 id: CHAT_CONFIG_MENU_ID,
-                when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.equals('view', ChatViewId)))),
+                when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.equals("view", ChatViewId)))),
                 order: 10,
-                group: '1_level'
+                group: "1_level"
             }
         });
     }
@@ -41,8 +41,12 @@ class ManageInstructionsFilesAction extends Action2 {
         const openerService = accessor.get(IOpenerService);
         const instaService = accessor.get(IInstantiationService);
         const pickers = instaService.createInstance(PromptFilePickers);
-        const placeholder = ( localize(5454, 'Select the instructions file to open'));
-        const result = await pickers.selectPromptFile({ placeholder, type: PromptsType.instructions, optionEdit: false });
+        const placeholder = ( localize(5653, "Select the instructions file to open"));
+        const result = await pickers.selectPromptFile({
+            placeholder,
+            type: PromptsType.instructions,
+            optionEdit: false
+        });
         if (result !== undefined) {
             await openerService.open(result.promptFile);
         }
@@ -54,8 +58,8 @@ function registerAttachPromptActions() {
 let ChatInstructionsPickerPick = class ChatInstructionsPickerPick {
     constructor(promptsService) {
         this.promptsService = promptsService;
-        this.type = 'pickerPick';
-        this.label = ( localize(5455, 'Instructions...'));
+        this.type = "pickerPick";
+        this.label = ( localize(5654, "Instructions..."));
         this.icon = Codicon.bookmark;
         this.commandId = ATTACH_INSTRUCTIONS_ACTION_ID;
     }
@@ -71,7 +75,7 @@ let ChatInstructionsPickerPick = class ChatInstructionsPickerPick {
                 if (storageType !== promptsPath.storage) {
                     storageType = promptsPath.storage;
                     result.push({
-                        type: 'separator',
+                        type: "separator",
                         label: this.promptsService.getPromptLocationLabel(promptsPath)
                     });
                 }
@@ -85,17 +89,15 @@ let ChatInstructionsPickerPick = class ChatInstructionsPickerPick {
             return result;
         });
         return {
-            placeholder: ( localize(5456, 'Select instructions files to attach')),
+            placeholder: ( localize(5655, "Select instructions files to attach")),
             picks,
             configure: {
-                label: ( localize(5457, 'Configure Instructions...')),
+                label: ( localize(5656, "Configure Instructions...")),
                 commandId: CONFIGURE_INSTRUCTIONS_ACTION_ID
             }
         };
     }
 };
-ChatInstructionsPickerPick = ( __decorate([
-    ( __param(0, IPromptsService))
-], ChatInstructionsPickerPick));
+ChatInstructionsPickerPick = ( __decorate([( __param(0, IPromptsService))], ChatInstructionsPickerPick));
 
 export { ChatInstructionsPickerPick, registerAttachPromptActions };

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/newPromptFileActions.d.ts

@@ -1,4 +1,5 @@
 export declare const NEW_PROMPT_COMMAND_ID = "workbench.command.new.prompt";
 export declare const NEW_INSTRUCTIONS_COMMAND_ID = "workbench.command.new.instructions";
 export declare const NEW_AGENT_COMMAND_ID = "workbench.command.new.agent";
+export declare const NEW_SKILL_COMMAND_ID = "workbench.command.new.skill";
 export declare function registerNewPromptFileActions(): void;

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/newPromptFileActions.js

@@ -22,7 +22,8 @@ import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 import { askForPromptFileName } from './pickers/askForPromptName.js';
 import { askForPromptSourceFolder } from './pickers/askForPromptSourceFolder.js';
-import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { getCleanPromptName, SKILL_FILENAME } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 
 class AbstractNewPromptFileAction extends Action2 {
@@ -52,7 +53,6 @@ class AbstractNewPromptFileAction extends Action2 {
         const editorService = accessor.get(IEditorService);
         const fileService = accessor.get(IFileService);
         const instaService = accessor.get(IInstantiationService);
-        const chatModeService = accessor.get(IChatModeService);
         const selectedFolder = await instaService.invokeFunction(askForPromptSourceFolder, this.type);
         if (!selectedFolder) {
             return;
@@ -65,113 +65,193 @@ class AbstractNewPromptFileAction extends Action2 {
         const promptUri = URI.joinPath(selectedFolder.uri, fileName);
         await fileService.createFile(promptUri);
         await openerService.open(promptUri);
+        const cleanName = getCleanPromptName(promptUri);
         const editor = getCodeEditor(editorService.activeTextEditorControl);
         if (editor && editor.hasModel() && isEqual(editor.getModel().uri, promptUri)) {
             SnippetController2.get(editor)?.apply([{
-                    range: editor.getModel().getFullModelRange(),
-                    template: getDefaultContentSnippet(this.type, chatModeService),
-                }]);
+                range: editor.getModel().getFullModelRange(),
+                template: getDefaultContentSnippet(this.type, cleanName)
+            }]);
         }
-        if (selectedFolder.storage !== 'user') {
+        if (selectedFolder.storage !== "user") {
             return;
         }
-        const isConfigured = userDataSyncEnablementService
-            .isResourceEnablementConfigured(SyncResource.Prompts);
+        const isConfigured = userDataSyncEnablementService.isResourceEnablementConfigured(SyncResource.Prompts);
         const isSettingsSyncEnabled = userDataSyncEnablementService.isEnabled();
         if ((isConfigured === true) || (isSettingsSyncEnabled === false)) {
             return;
         }
         notificationService.prompt(Severity.Info, ( localize(
-            5463,
+            5662,
             "Do you want to backup and sync your user prompt, instruction and custom agent files with Setting Sync?'"
-        )), [
-            {
-                label: ( localize(5464, "Enable")),
-                run: () => {
-                    commandService.executeCommand(CONFIGURE_SYNC_COMMAND_ID)
-                        .catch((error) => {
-                        logService.error(`Failed to run '${CONFIGURE_SYNC_COMMAND_ID}' command: ${error}.`);
-                    });
-                },
-            },
-            {
-                label: ( localize(5465, "Learn More")),
-                run: () => {
-                    openerService.open(( URI.parse('https://aka.ms/vscode-settings-sync-help')));
-                },
-            },
-        ], {
+        )), [{
+            label: ( localize(5663, "Enable")),
+            run: () => {
+                commandService.executeCommand(CONFIGURE_SYNC_COMMAND_ID).catch(error => {
+                    logService.error(`Failed to run '${CONFIGURE_SYNC_COMMAND_ID}' command: ${error}.`);
+                });
+            }
+        }, {
+            label: ( localize(5664, "Learn More")),
+            run: () => {
+                openerService.open(( URI.parse("https://aka.ms/vscode-settings-sync-help")));
+            }
+        }], {
             neverShowAgain: {
-                id: 'workbench.command.prompts.create.user.enable-sync-notification',
-                scope: NeverShowAgainScope.PROFILE,
-            },
+                id: "workbench.command.prompts.create.user.enable-sync-notification",
+                scope: NeverShowAgainScope.PROFILE
+            }
         });
     }
 }
-function getDefaultContentSnippet(promptType, chatModeService) {
-    const agents = chatModeService.getModes();
-    const agentNames = ( agents.builtin.map(agent => agent.name.get())).join(',') + (agents.custom.length ? (',' + ( agents.custom.map(agent => agent.name.get())).join(',')) : '');
+function getDefaultContentSnippet(promptType, name) {
     switch (promptType) {
-        case PromptsType.prompt:
-            return [
-                `---`,
-                `agent: \${1|${agentNames}|}`,
-                `---`,
-                `\${2:Define the task to achieve, including specific requirements, constraints, and success criteria.}`,
-            ].join('\n');
-        case PromptsType.instructions:
-            return [
-                `---`,
-                `applyTo: '\${1|**,**/*.ts|}'`,
-                `---`,
-                `\${2:Provide project context and coding guidelines that AI should follow when generating code, answering questions, or reviewing changes.}`,
-            ].join('\n');
-        case PromptsType.agent:
-            return [
-                `---`,
-                `description: '\${1:Describe what this custom agent does and when to use it.}'`,
-                `tools: []`,
-                `---`,
-                `\${2:Define what this custom agent accomplishes for the user, when to use it, and the edges it won't cross. Specify its ideal inputs/outputs, the tools it may call, and how it reports progress or asks for help.}`,
-            ].join('\n');
-        default:
-            throw ( new Error(`Unknown prompt type: ${promptType}`));
+    case PromptsType.prompt:
+        return [
+            `---`,
+            `name: ${name ?? "${1:prompt-name}"}`,
+            `description: \${2:Describe when to use this prompt}`,
+            `---`,
+            `\${3:Define the prompt content here. You can include instructions, examples, and any other relevant information to guide the AI's responses.}`
+        ].join("\n");
+    case PromptsType.instructions:
+        return [
+            `---`,
+            `description: \${1:Describe when these instructions should be loaded}`,
+            `# applyTo: '\${1|**,**/*.ts|}' # when provided, instructions will automatically be added to the request context when the pattern matches an attached file`,
+            `---`,
+            `\${2:Provide project context and coding guidelines that AI should follow when generating code, answering questions, or reviewing changes.}`
+        ].join("\n");
+    case PromptsType.agent:
+        return [
+            `---`,
+            `name: ${name ?? "${1:agent-name}"}`,
+            `description: \${2:Describe what this custom agent does and when to use it.}`,
+            `argument-hint: \${3:The inputs this agent expects, e.g., "a task to implement" or "a question to answer".}`,
+            `# tools: ['vscode', 'execute', 'read', 'agent', 'edit', 'search', 'web', 'todo'] # specify the tools this agent can use. If not set, all enabled tools are allowed.`,
+            `---`,
+            `\${4:Define what this custom agent does, including its behavior, capabilities, and any specific instructions for its operation.}`
+        ].join("\n");
+    case PromptsType.skill:
+        return [
+            `---`,
+            `name: ${name ?? "${1:skill-name}"}`,
+            `description: \${2:Describe what this skill does and when to use it. Include keywords that help agents identify relevant tasks.}`,
+            `---`,
+            `\${3:Define the functionality provided by this skill, including detailed instructions and examples}`
+        ].join("\n");
+    default:
+        throw ( new Error(`Unsupported prompt type: ${promptType}`));
     }
 }
-const NEW_PROMPT_COMMAND_ID = 'workbench.command.new.prompt';
-const NEW_INSTRUCTIONS_COMMAND_ID = 'workbench.command.new.instructions';
-const NEW_AGENT_COMMAND_ID = 'workbench.command.new.agent';
+const NEW_PROMPT_COMMAND_ID = "workbench.command.new.prompt";
+const NEW_INSTRUCTIONS_COMMAND_ID = "workbench.command.new.instructions";
+const NEW_AGENT_COMMAND_ID = "workbench.command.new.agent";
+const NEW_SKILL_COMMAND_ID = "workbench.command.new.skill";
 class NewPromptFileAction extends AbstractNewPromptFileAction {
     constructor() {
-        super(NEW_PROMPT_COMMAND_ID, ( localize(5466, "New Prompt File...")), PromptsType.prompt);
+        super(NEW_PROMPT_COMMAND_ID, ( localize(5665, "New Prompt File...")), PromptsType.prompt);
     }
 }
 class NewInstructionsFileAction extends AbstractNewPromptFileAction {
     constructor() {
-        super(NEW_INSTRUCTIONS_COMMAND_ID, ( localize(5467, "New Instructions File...")), PromptsType.instructions);
+        super(NEW_INSTRUCTIONS_COMMAND_ID, ( localize(5666, "New Instructions File...")), PromptsType.instructions);
     }
 }
 class NewAgentFileAction extends AbstractNewPromptFileAction {
     constructor() {
-        super(NEW_AGENT_COMMAND_ID, ( localize(5468, "New Custom Agent...")), PromptsType.agent);
+        super(NEW_AGENT_COMMAND_ID, ( localize(5667, "New Custom Agent...")), PromptsType.agent);
+    }
+}
+class NewSkillFileAction extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SKILL_COMMAND_ID,
+            title: ( localize(5668, "New Skill File...")),
+            f1: false,
+            precondition: ChatContextKeys.enabled,
+            category: CHAT_CATEGORY,
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ChatContextKeys.enabled
+            }
+        });
+    }
+    async run(accessor) {
+        const openerService = accessor.get(IOpenerService);
+        const editorService = accessor.get(IEditorService);
+        const fileService = accessor.get(IFileService);
+        const instaService = accessor.get(IInstantiationService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const selectedFolder = await instaService.invokeFunction(askForPromptSourceFolder, PromptsType.skill);
+        if (!selectedFolder) {
+            return;
+        }
+        const skillName = await quickInputService.input({
+            prompt: ( localize(
+                5669,
+                "Enter a name for the skill (lowercase letters, numbers, and hyphens only)"
+            )),
+            placeHolder: ( localize(5670, "e.g., pdf-processing, data-analysis")),
+            validateInput: async value => {
+                if (!value || !value.trim()) {
+                    return localize(5671, "Skill name is required");
+                }
+                const name = value.trim();
+                if (name.length > 64) {
+                    return localize(5672, "Skill name must be 64 characters or less");
+                }
+                if (!/^[a-z0-9-]+$/.test(name)) {
+                    return localize(
+                        5673,
+                        "Skill name may only contain lowercase letters, numbers, and hyphens"
+                    );
+                }
+                if (name.startsWith("-") || name.endsWith("-")) {
+                    return localize(5674, "Skill name must not start or end with a hyphen");
+                }
+                if (name.includes("--")) {
+                    return localize(5675, "Skill name must not contain consecutive hyphens");
+                }
+                return undefined;
+            }
+        });
+        if (!skillName) {
+            return;
+        }
+        const trimmedName = skillName.trim();
+        const skillFolder = URI.joinPath(selectedFolder.uri, trimmedName);
+        await fileService.createFolder(skillFolder);
+        const skillFileUri = URI.joinPath(skillFolder, SKILL_FILENAME);
+        await fileService.createFile(skillFileUri);
+        await openerService.open(skillFileUri);
+        const editor = getCodeEditor(editorService.activeTextEditorControl);
+        if (editor && editor.hasModel() && isEqual(editor.getModel().uri, skillFileUri)) {
+            SnippetController2.get(editor)?.apply([{
+                range: editor.getModel().getFullModelRange(),
+                template: getDefaultContentSnippet(PromptsType.skill, trimmedName)
+            }]);
+        }
     }
 }
 class NewUntitledPromptFileAction extends Action2 {
     constructor() {
         super({
-            id: 'workbench.command.new.untitled.prompt',
-            title: ( localize2(5469, "New Untitled Prompt File")),
+            id: "workbench.command.new.untitled.prompt",
+            title: ( localize2(5676, "New Untitled Prompt File")),
             f1: true,
             precondition: ChatContextKeys.enabled,
             category: CHAT_CATEGORY,
             keybinding: {
                 weight: KeybindingWeight.WorkbenchContrib
-            },
+            }
         });
     }
     async run(accessor) {
         const editorService = accessor.get(IEditorService);
-        const chatModeService = accessor.get(IChatModeService);
         const languageId = getLanguageIdForPromptsType(PromptsType.prompt);
         const input = await editorService.openEditor({
             resource: undefined,
@@ -184,9 +264,9 @@ class NewUntitledPromptFileAction extends Action2 {
         const editor = getCodeEditor(editorService.activeTextEditorControl);
         if (editor && editor.hasModel()) {
             SnippetController2.get(editor)?.apply([{
-                    range: editor.getModel().getFullModelRange(),
-                    template: getDefaultContentSnippet(type, chatModeService),
-                }]);
+                range: editor.getModel().getFullModelRange(),
+                template: getDefaultContentSnippet(type, undefined)
+            }]);
         }
         return input;
     }
@@ -195,7 +275,8 @@ function registerNewPromptFileActions() {
     registerAction2(NewPromptFileAction);
     registerAction2(NewInstructionsFileAction);
     registerAction2(NewAgentFileAction);
+    registerAction2(NewSkillFileAction);
     registerAction2(NewUntitledPromptFileAction);
 }
 
-export { NEW_AGENT_COMMAND_ID, NEW_INSTRUCTIONS_COMMAND_ID, NEW_PROMPT_COMMAND_ID, registerNewPromptFileActions };
+export { NEW_AGENT_COMMAND_ID, NEW_INSTRUCTIONS_COMMAND_ID, NEW_PROMPT_COMMAND_ID, NEW_SKILL_COMMAND_ID, registerNewPromptFileActions };

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/pickers/askForPromptName.js

@@ -11,41 +11,43 @@ import { isValidBasename } from '@codingame/monaco-vscode-api/vscode/vs/base/com
 async function askForPromptFileName(accessor, type, selectedFolder, existingFileName) {
     const quickInputService = accessor.get(IQuickInputService);
     const fileService = accessor.get(IFileService);
-    const sanitizeInput = (input) => {
+    const sanitizeInput = input => {
         const trimmedName = input.trim();
         if (!trimmedName) {
             return undefined;
         }
         const fileExtension = getPromptFileExtension(type);
-        return (trimmedName.endsWith(fileExtension))
-            ? trimmedName
-            : `${trimmedName}${fileExtension}`;
+        return (trimmedName.endsWith(fileExtension)) ? trimmedName : `${trimmedName}${fileExtension}`;
     };
-    const validateInput = async (value) => {
+    const validateInput = async value => {
         const fileName = sanitizeInput(value);
         if (!fileName) {
             return {
-                content: ( localize(5470, "Please enter a name.")),
+                content: ( localize(5677, "Please enter a name.")),
                 severity: Severity.Warning
             };
         }
         if (!isValidBasename(fileName)) {
             return {
-                content: ( localize(5471, "The name contains invalid characters.")),
+                content: ( localize(5678, "The name contains invalid characters.")),
                 severity: Severity.Error
             };
         }
         const fileUri = URI.joinPath(selectedFolder, fileName);
         if (await fileService.exists(fileUri)) {
             return {
-                content: ( localize(5472, "A file for the given name already exists.")),
+                content: ( localize(5679, "A file for the given name already exists.")),
                 severity: Severity.Error
             };
         }
         return undefined;
     };
     const placeHolder = existingFileName ? getPlaceholderStringForRename(type) : getPlaceholderStringForNew(type);
-    const result = await quickInputService.input({ placeHolder, validateInput, value: existingFileName });
+    const result = await quickInputService.input({
+        placeHolder,
+        validateInput,
+        value: existingFileName
+    });
     if (!result) {
         return undefined;
     }
@@ -53,26 +55,26 @@ async function askForPromptFileName(accessor, type, selectedFolder, existingFile
 }
 function getPlaceholderStringForNew(type) {
     switch (type) {
-        case PromptsType.instructions:
-            return localize(5473, "Enter the name of the instructions file");
-        case PromptsType.prompt:
-            return localize(5474, "Enter the name of the prompt file");
-        case PromptsType.agent:
-            return localize(5475, "Enter the name of the agent file");
-        default:
-            throw ( new Error('Unknown prompt type'));
+    case PromptsType.instructions:
+        return localize(5680, "Enter the name of the instructions file");
+    case PromptsType.prompt:
+        return localize(5681, "Enter the name of the prompt file");
+    case PromptsType.agent:
+        return localize(5682, "Enter the name of the agent file");
+    default:
+        throw ( new Error("Unknown prompt type"));
     }
 }
 function getPlaceholderStringForRename(type) {
     switch (type) {
-        case PromptsType.instructions:
-            return localize(5476, "Enter a new name of the instructions file");
-        case PromptsType.prompt:
-            return localize(5477, "Enter a new name of the prompt file");
-        case PromptsType.agent:
-            return localize(5478, "Enter a new name of the agent file");
-        default:
-            throw ( new Error('Unknown prompt type'));
+    case PromptsType.instructions:
+        return localize(5683, "Enter a new name of the instructions file");
+    case PromptsType.prompt:
+        return localize(5684, "Enter a new name of the prompt file");
+    case PromptsType.agent:
+        return localize(5685, "Enter a new name of the agent file");
+    default:
+        throw ( new Error("Unknown prompt type"));
     }
 }