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

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptHovers.js

@@ -7,23 +7,28 @@ import { isToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/cont
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { isBuiltinChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
 import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
-import { getPromptsTypeForLanguageId, PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
-import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { getPromptsTypeForLanguageId, Target, PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
-import { PromptHeaderAttributes, ClaudeHeaderAttributes, parseCommaSeparatedList } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
-import { getTarget, getAttributeDescription, knownClaudeTools, knownClaudeModels, isVSCodeOrDefaultTarget } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptValidator';
+import { PromptHeaderAttributes, parseCommaSeparatedList } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
+import { getTarget, getAttributeDefinition, ClaudeHeaderAttributes, knownClaudeTools, knownClaudeModels, isVSCodeOrDefaultTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptFileAttributes';
+import { HOOKS_BY_TARGET, HOOK_METADATA } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
+import { HOOK_COMMAND_FIELD_DESCRIPTIONS } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
 
 let PromptHoverProvider = class PromptHoverProvider {
     constructor(
         promptsService,
         languageModelToolsService,
         languageModelsService,
-        chatModeService
+        chatModeService,
+        configurationService
     ) {
         this.promptsService = promptsService;
         this.languageModelToolsService = languageModelToolsService;
         this.languageModelsService = languageModelsService;
         this.chatModeService = chatModeService;
+        this.configurationService = configurationService;
         this._debugDisplayName = "PromptHoverProvider";
     }
     createHover(contents, range) {
@@ -59,7 +64,7 @@ let PromptHoverProvider = class PromptHoverProvider {
     async provideHeaderHover(position, promptType, header, target) {
         for (const attribute of header.attributes) {
             if (attribute.range.containsPosition(position)) {
-                const description = getAttributeDescription(attribute.key, promptType, target);
+                const description = getAttributeDefinition(attribute.key, promptType, target)?.description;
                 if (description) {
                     switch (attribute.key) {
                     case PromptHeaderAttributes.model:
@@ -72,10 +77,15 @@ let PromptHoverProvider = class PromptHoverProvider {
                         return this.getAgentHover(attribute, position, description);
                     case PromptHeaderAttributes.handOffs:
                         return this.getHandsOffHover(attribute, position, target);
+                    case PromptHeaderAttributes.hooks:
+                        if (!this.configurationService.getValue(PromptsConfig.USE_CUSTOM_AGENT_HOOKS)) {
+                            return undefined;
+                        }
+                        return this.getHooksHover(attribute, position, description, target);
                     case PromptHeaderAttributes.infer:
                         return this.createHover(description + "\n\n" + ( localize(
-                            6419,
-                            "Deprecated: Use `user-invokable` and `disable-model-invocation` instead."
+                            7175,
+                            "Deprecated: Use `user-invocable` and `disable-model-invocation` instead."
                         )), attribute.range);
                     default:
                         return this.createHover(description, attribute.range);
@@ -87,12 +97,12 @@ let PromptHoverProvider = class PromptHoverProvider {
     }
     getToolHover(node, position, baseMessage, target) {
         let value = node.value;
-        if (value.type === "string") {
+        if (value.type === "scalar") {
             value = parseCommaSeparatedList(value);
         }
-        if (value.type === "array") {
+        if (value.type === "sequence") {
             for (const toolName of value.items) {
-                if (toolName.type === "string" && toolName.range.containsPosition(position)) {
+                if (toolName.type === "scalar" && toolName.range.containsPosition(position)) {
                     const description = this.getToolHoverByName(toolName.value, toolName.range, target);
                     if (description) {
                         return description;
@@ -122,7 +132,7 @@ let PromptHoverProvider = class PromptHoverProvider {
     }
     getToolsetHover(toolSet, range) {
         const lines = [];
-        lines.push(( localize(6420, "ToolSet: {0}\n\n", toolSet.referenceName)));
+        lines.push(( localize(7176, "ToolSet: {0}\n\n", toolSet.referenceName)));
         if (toolSet.description) {
             lines.push(toolSet.description);
         }
@@ -133,7 +143,7 @@ let PromptHoverProvider = class PromptHoverProvider {
     }
     getModelHover(node, position, baseMessage, target) {
         if (target === Target.GitHubCopilot) {
-            return this.createHover(baseMessage + "\n\n" + ( localize(6421, "Note: This attribute is not used when target is github-copilot.")), node.range);
+            return this.createHover(baseMessage + "\n\n" + ( localize(7177, "Note: This attribute is not used when target is github-copilot.")), node.range);
         }
         const modelHoverContent = modelName => {
             const lines = [];
@@ -144,18 +154,19 @@ let PromptHoverProvider = class PromptHoverProvider {
                     return this.createHover(lines.join("\n"), node.range);
                 }
                 if (claudeModel.modelEquivalent) {
-                    lines.push(( localize(6422, "Claude model `{0}` maps to the following model:\n", modelName)));
+                    lines.push(( localize(7178, "Claude model `{0}` maps to the following model:\n", modelName)));
                     modelName = claudeModel.modelEquivalent;
                 } else {
                     lines.push(claudeModel.description);
                     return this.createHover(lines.join("\n"), node.range);
                 }
             }
-            const meta = this.languageModelsService.lookupLanguageModelByQualifiedName(modelName);
-            if (meta) {
-                lines.push(( localize(6423, "- Name: {0}", meta.name)));
-                lines.push(( localize(6424, "- Family: {0}", meta.family)));
-                lines.push(( localize(6425, "- Vendor: {0}", meta.vendor)));
+            const result = this.languageModelsService.lookupLanguageModelByQualifiedName(modelName);
+            if (result) {
+                const meta = result.metadata;
+                lines.push(( localize(7179, "- Name: {0}", meta.name)));
+                lines.push(( localize(7180, "- Family: {0}", meta.family)));
+                lines.push(( localize(7181, "- Vendor: {0}", meta.vendor)));
                 if (meta.tooltip) {
                     lines.push("", "", meta.tooltip);
                 }
@@ -163,14 +174,14 @@ let PromptHoverProvider = class PromptHoverProvider {
             }
             return undefined;
         };
-        if (node.value.type === "string") {
+        if (node.value.type === "scalar") {
             const hover = modelHoverContent(node.value.value);
             if (hover) {
                 return hover;
             }
-        } else if (node.value.type === "array") {
+        } else if (node.value.type === "sequence") {
             for (const item of node.value.items) {
-                if (item.type === "string" && item.range.containsPosition(position)) {
+                if (item.type === "scalar" && item.range.containsPosition(position)) {
                     const hover = modelHoverContent(item.value);
                     if (hover) {
                         return hover;
@@ -183,17 +194,17 @@ let PromptHoverProvider = class PromptHoverProvider {
     getAgentHover(agentAttribute, position, baseMessage) {
         const lines = [];
         const value = agentAttribute.value;
-        if (value.type === "string" && value.range.containsPosition(position)) {
+        if (value.type === "scalar" && value.range.containsPosition(position)) {
             const agent = this.chatModeService.findModeByName(value.value);
             if (agent) {
-                const description = agent.description.get() || (isBuiltinChatMode(agent) ? ( localize(6426, "Built-in agent")) : ( localize(6427, "Custom agent")));
+                const description = agent.description.get() || (isBuiltinChatMode(agent) ? ( localize(7182, "Built-in agent")) : ( localize(7183, "Custom agent")));
                 lines.push(`\`${agent.name.get()}\`: ${description}`);
             }
         } else {
             const agents = this.chatModeService.getModes();
             lines.push(baseMessage);
             lines.push("");
-            lines.push(( localize(6428, "**Built-in agents:**")));
+            lines.push(( localize(7184, "**Built-in agents:**")));
             for (const agent of agents.builtin) {
                 lines.push(
                     `- \`${agent.name.get()}\`: ${agent.description.get() || agent.label.get()}`
@@ -201,26 +212,71 @@ let PromptHoverProvider = class PromptHoverProvider {
             }
             if (agents.custom.length > 0) {
                 lines.push("");
-                lines.push(( localize(6429, "**Custom agents:**")));
+                lines.push(( localize(7185, "**Custom agents:**")));
                 for (const agent of agents.custom) {
                     const description = agent.description.get();
-                    lines.push(`- \`${agent.name.get()}\`: ${description || ( localize(6427, "Custom agent"))}`);
+                    lines.push(`- \`${agent.name.get()}\`: ${description || ( localize(7183, "Custom agent"))}`);
                 }
             }
         }
         return this.createHover(lines.join("\n"), agentAttribute.range);
     }
+    getHooksHover(attribute, position, baseMessage, target) {
+        const value = attribute.value;
+        if (value.type === "map") {
+            const hooksByTarget = HOOKS_BY_TARGET[target] ?? HOOKS_BY_TARGET[Target.Undefined];
+            for (const prop of value.properties) {
+                if (prop.key.range.containsPosition(position)) {
+                    const hookType = hooksByTarget[prop.key.value];
+                    if (hookType) {
+                        const meta = HOOK_METADATA[hookType];
+                        return this.createHover(`**${meta.label}**\n\n${meta.description}`, prop.key.range);
+                    }
+                }
+                if (prop.value.type === "sequence") {
+                    const hover = this.getHookCommandItemHover(prop.value, position);
+                    if (hover) {
+                        return hover;
+                    }
+                }
+            }
+        }
+        return this.createHover(baseMessage, attribute.range);
+    }
+    getHookCommandItemHover(sequence, position) {
+        for (const item of sequence.items) {
+            if (item.type !== "map" || !item.range.containsPosition(position)) {
+                continue;
+            }
+            const nestedHooks = item.properties.find(p => p.key.value === "hooks");
+            if (nestedHooks && nestedHooks.value.type === "sequence") {
+                const hover = this.getHookCommandItemHover(nestedHooks.value, position);
+                if (hover) {
+                    return hover;
+                }
+            }
+            for (const field of item.properties) {
+                if (field.key.range.containsPosition(position) || field.value.range.containsPosition(position)) {
+                    const desc = HOOK_COMMAND_FIELD_DESCRIPTIONS[field.key.value];
+                    if (desc) {
+                        return this.createHover(desc, field.key.range);
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
     getHandsOffHover(attribute, position, target) {
-        const handoffsBaseMessage = getAttributeDescription(PromptHeaderAttributes.handOffs, PromptsType.agent, target);
+        const handoffsBaseMessage = getAttributeDefinition(PromptHeaderAttributes.handOffs, PromptsType.agent, target)?.description;
         if (!isVSCodeOrDefaultTarget(target)) {
             return this.createHover(handoffsBaseMessage + "\n\n" + ( localize(
-                6430,
+                7186,
                 "Note: This attribute is not used in GitHub Copilot or Claude targets."
             )), attribute.range);
         }
         return this.createHover(handoffsBaseMessage, attribute.range);
     }
 };
-PromptHoverProvider = ( __decorate([( __param(0, IPromptsService)), ( __param(1, ILanguageModelToolsService)), ( __param(2, ILanguageModelsService)), ( __param(3, IChatModeService))], PromptHoverProvider));
+PromptHoverProvider = ( __decorate([( __param(0, IPromptsService)), ( __param(1, ILanguageModelToolsService)), ( __param(2, ILanguageModelsService)), ( __param(3, IChatModeService)), ( __param(4, IConfigurationService))], PromptHoverProvider));
 
 export { PromptHoverProvider };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptValidator.d.ts

@@ -0,0 +1,121 @@
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMarkerData } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers";
+import { IMarkerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service";
+import { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { PromptsType, Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { ParsedPromptFile, PromptHeader } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export declare const MARKERS_OWNER_ID = "prompts-diagnostics-provider";
+export declare class PromptValidator {
+    private readonly languageModelsService;
+    private readonly languageModelToolsService;
+    private readonly chatModeService;
+    private readonly fileService;
+    private readonly labelService;
+    private readonly promptsService;
+    private readonly configurationService;
+    constructor(languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService, chatModeService: IChatModeService, fileService: IFileService, labelService: ILabelService, promptsService: IPromptsService, configurationService: IConfigurationService);
+    validate(promptAST: ParsedPromptFile, promptType: PromptsType, report: (markers: IMarkerData) => void): Promise<void>;
+    private validateFileName;
+    private validateSkillFolderName;
+    private validateBody;
+    private validateHeader;
+    private checkForInvalidArguments;
+    private validateName;
+    private validateDescription;
+    private validateArgumentHint;
+    private validateModel;
+    private validateClaudeAttributes;
+    private findModelByName;
+    private validateAgent;
+    private validateAgentValue;
+    private validateTools;
+    private validateVSCodeTools;
+    private validateApplyTo;
+    private validatePaths;
+    private validateExcludeAgent;
+    private validateHooks;
+    private validateHookCommand;
+    private validateHandoffs;
+    private validateInfer;
+    private validateTarget;
+    private validateUserInvocable;
+    private validateUserInvokable;
+    private validateDisableModelInvocation;
+    private validateAgentsAttribute;
+    private validateGithubPermissions;
+}
+export declare const githubPermissionScopes: Record<string, {
+    allowedValues: string[];
+    description: string;
+}>;
+export declare function getValidAttributeNames(promptType: PromptsType, includeNonRecommended: boolean, target: Target): string[];
+export declare function isNonRecommendedAttribute(attributeName: string): boolean;
+export declare function getAttributeDescription(attributeName: string, promptType: PromptsType, target: Target): string | undefined;
+export declare const knownGithubCopilotTools: {
+    name: string;
+    description: string;
+}[];
+export interface IValueEntry {
+    readonly name: string;
+    readonly description?: string;
+}
+export declare const knownClaudeTools: {
+    name: string;
+    description: string;
+    toolEquivalent: string[];
+}[];
+export declare const knownClaudeModels: ({
+    name: string;
+    description: string;
+    modelEquivalent: string;
+} | {
+    name: string;
+    description: string;
+    modelEquivalent: undefined;
+})[];
+export declare function mapClaudeModels(claudeModelNames: readonly string[]): readonly string[];
+/**
+ * Maps Claude tool names to their VS Code tool equivalents.
+ */
+export declare function mapClaudeTools(claudeToolNames: readonly string[]): string[];
+export declare const claudeAgentAttributes: Record<string, {
+    type: string;
+    description: string;
+    defaults?: string[];
+    items?: IValueEntry[];
+    enums?: IValueEntry[];
+}>;
+/**
+ * Attributes supported in Claude rules files (`.claude/rules/*.md`).
+ * Claude rules use `paths` instead of `applyTo` for glob patterns.
+ */
+export declare const claudeRulesAttributes: Record<string, {
+    type: string;
+    description: string;
+    defaults?: string[];
+    items?: IValueEntry[];
+    enums?: IValueEntry[];
+}>;
+export declare function isVSCodeOrDefaultTarget(target: Target): boolean;
+export declare function getTarget(promptType: PromptsType, header: PromptHeader | URI): Target;
+export declare class PromptValidatorContribution extends Disposable {
+    private modelService;
+    private readonly markerService;
+    private readonly promptsService;
+    private readonly languageModelsService;
+    private readonly languageModelToolsService;
+    private readonly chatModeService;
+    private readonly validator;
+    private readonly localDisposables;
+    constructor(modelService: IModelService, instantiationService: IInstantiationService, markerService: IMarkerService, promptsService: IPromptsService, languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService, chatModeService: IChatModeService);
+    updateRegistration(): void;
+}