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

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

@@ -9,26 +9,34 @@ import { ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/
 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 { 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, PromptsType, Target } 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 { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { PromptHeaderAttributes, ClaudeHeaderAttributes, parseCommaSeparatedList } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
-import { getTarget, getValidAttributeNames, getAttributeDescription, knownClaudeTools, knownGithubCopilotTools, claudeRulesAttributes, claudeAgentAttributes } 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, getValidAttributeNames, getAttributeDefinition, knownClaudeTools, ClaudeHeaderAttributes, knownGithubCopilotTools } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptFileAttributes';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { getQuotePreference, formatArrayValue } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/utils/promptEditHelper';
+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 { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+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 PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
     constructor(
         promptsService,
         languageModelsService,
         languageModelToolsService,
-        chatModeService
+        chatModeService,
+        environmentService,
+        configurationService
     ) {
         this.promptsService = promptsService;
         this.languageModelsService = languageModelsService;
         this.languageModelToolsService = languageModelToolsService;
         this.chatModeService = chatModeService;
+        this.environmentService = environmentService;
+        this.configurationService = configurationService;
         this._debugDisplayName = "PromptHeaderAutocompletion";
         this.triggerCharacters = [":"];
     }
@@ -40,7 +48,7 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
         if (/^\s*$/.test(model.getValue())) {
             return {
                 suggestions: [{
-                    label: ( localize(6981, "Add Prompt Header")),
+                    label: ( localize(7170, "Add Prompt Header")),
                     kind: CompletionItemKind.Snippet,
                     insertText: [`---`, `description: $1`, `---`, `$0`].join("\n"),
                     insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
@@ -61,6 +69,31 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
         const colonIndex = lineText.indexOf(":");
         const colonPosition = colonIndex !== -1 ? ( new Position(position.lineNumber, colonIndex + 1)) : undefined;
         if (!colonPosition || position.isBeforeOrEqual(colonPosition)) {
+            let containingAttribute = header.attributes.find((
+                {
+                    range
+                }
+            ) => range.startLineNumber < position.lineNumber && position.lineNumber <= range.endLineNumber);
+            if (!containingAttribute) {
+                for (let i = header.attributes.length - 1; i >= 0; i--) {
+                    const attr = header.attributes[i];
+                    if (attr.range.endLineNumber < position.lineNumber && attr.value.type === "map") {
+                        const nextAttr = header.attributes[i + 1];
+                        const nextStartLine = nextAttr ? nextAttr.range.startLineNumber : headerRange.endLineNumber;
+                        if (position.lineNumber < nextStartLine) {
+                            containingAttribute = attr;
+                        }
+                        break;
+                    }
+                }
+            }
+            if (containingAttribute) {
+                const attrLineText = model.getLineContent(containingAttribute.range.startLineNumber);
+                const attrColonIndex = attrLineText.indexOf(":");
+                if (attrColonIndex !== -1) {
+                    return this.provideValueCompletions(model, position, header, ( new Position(containingAttribute.range.startLineNumber, attrColonIndex + 1)), promptType, containingAttribute);
+                }
+            }
             return this.provideAttributeNameCompletions(model, position, header, colonPosition, promptType);
         } else if (colonPosition && colonPosition.isBefore(position)) {
             return this.provideValueCompletions(model, position, header, colonPosition, promptType);
@@ -71,6 +104,9 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
         const suggestions = [];
         const target = getTarget(promptType, header);
         const attributesToPropose = ( new Set(getValidAttributeNames(promptType, false, target)));
+        if (!this.configurationService.getValue(PromptsConfig.USE_CUSTOM_AGENT_HOOKS)) {
+            attributesToPropose.delete(PromptHeaderAttributes.hooks);
+        }
         for (const attr of header.attributes) {
             attributesToPropose.delete(attr.key);
         }
@@ -78,6 +114,10 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
             if (colonPosition) {
                 return key;
             }
+            if (key === PromptHeaderAttributes.hooks && promptType === PromptsType.agent && target !== Target.Claude) {
+                const hookNames = ( Object.keys(HOOKS_BY_TARGET[target] ?? HOOKS_BY_TARGET[Target.Undefined]));
+                return `${key}:\n  \${1|${hookNames.join(",")}|}:\n    - type: command\n      command: "$2"`;
+            }
             const valueSuggestions = this.getValueSuggestions(promptType, key, target);
             if (valueSuggestions.length > 0) {
                 return `${key}: \${0:${valueSuggestions[0].name}}`;
@@ -88,7 +128,7 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
         for (const attribute of attributesToPropose) {
             const item = {
                 label: attribute,
-                documentation: getAttributeDescription(attribute, promptType, target),
+                documentation: getAttributeDefinition(attribute, promptType, target)?.description,
                 kind: CompletionItemKind.Property,
                 insertText: getInsertText(attribute),
                 insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
@@ -105,10 +145,10 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
             suggestions
         };
     }
-    async provideValueCompletions(model, position, header, colonPosition, promptType) {
+    async provideValueCompletions(model, position, header, colonPosition, promptType, preFoundAttribute) {
         const suggestions = [];
         const posLineNumber = position.lineNumber;
-        const attribute = header.attributes.find((
+        const attribute = preFoundAttribute ?? header.attributes.find((
             {
                 range
             }
@@ -140,7 +180,7 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
                 }
                 if (value.type === "sequence") {
                     const getValues = async () => {
-                        if (target === Target.GitHubCopilot) {
+                        if (target === Target.GitHubCopilot || this.environmentService.isSessionsWindow) {
                             return knownGithubCopilotTools;
                         } else if (target === Target.Claude) {
                             return knownClaudeTools;
@@ -161,6 +201,19 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
                 });
             }
         }
+        if (attribute.key === PromptHeaderAttributes.hooks) {
+            if (attribute.value.type === "map") {
+                return this.provideHookEventCompletions(model, position, attribute.value, target);
+            }
+            if (position.lineNumber !== attribute.range.startLineNumber) {
+                const emptyMap = {
+                    type: "map",
+                    properties: [],
+                    range: attribute.value.range
+                };
+                return this.provideHookEventCompletions(model, position, emptyMap, target);
+            }
+        }
         const lineContent = model.getLineContent(attribute.range.startLineNumber);
         const whilespaceAfterColon = (lineContent.substring(colonPosition.column).match(/^\s*/)?.[0].length) ?? 0;
         const entries = this.getValueSuggestions(promptType, attribute.key, target);
@@ -188,7 +241,7 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
                 "    send: true"
             ].join("\n");
             const item = {
-                label: ( localize(6982, "Handoff Example")),
+                label: ( localize(7171, "Handoff Example")),
                 kind: CompletionItemKind.Value,
                 insertText: whilespaceAfterColon === 0 ? ` ${value}` : value,
                 range: ( new Range(
@@ -200,38 +253,236 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
             };
             suggestions.push(item);
         }
+        if (attribute.key === PromptHeaderAttributes.hooks && promptType === PromptsType.agent) {
+            const hookSnippet = ["", "  ${1|" + ( Object.keys(HOOKS_BY_TARGET[target] ?? HOOKS_BY_TARGET[Target.Undefined])).join(",") + "|}:", "    - type: command", "      command: \"$2\""].join("\n");
+            const item = {
+                label: ( localize(7172, "New Hook")),
+                kind: CompletionItemKind.Snippet,
+                insertText: whilespaceAfterColon === 0 ? ` ${hookSnippet}` : hookSnippet,
+                insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
+                range: ( new Range(
+                    position.lineNumber,
+                    colonPosition.column + whilespaceAfterColon + 1,
+                    position.lineNumber,
+                    model.getLineMaxColumn(position.lineNumber)
+                ))
+            };
+            suggestions.push(item);
+        }
         return {
             suggestions
         };
     }
-    getValueSuggestions(promptType, attribute, target) {
-        if (target === Target.Claude) {
-            const attributeDesc = promptType === PromptsType.instructions ? claudeRulesAttributes[attribute] : claudeAgentAttributes[attribute];
-            if (attributeDesc) {
-                if (attributeDesc.enums) {
-                    return attributeDesc.enums;
-                } else if (attributeDesc.defaults) {
-                    return ( attributeDesc.defaults.map(value => ({
-                        name: value
-                    })));
+    provideHookEventCompletions(model, position, hooksMap, target) {
+        const hookEventOnLine = hooksMap.properties.find(p => p.key.range.startLineNumber === position.lineNumber);
+        if (hookEventOnLine) {
+            const lineText = model.getLineContent(position.lineNumber);
+            const colonIdx = lineText.indexOf(":");
+            if (colonIdx !== -1 && position.column > colonIdx + 1) {
+                const whilespaceAfterColon = (lineText.substring(colonIdx + 1).match(/^\s*/)?.[0].length) ?? 0;
+                const commandSnippet = ["", "  - type: command", "    command: \"$1\""].join("\n");
+                return {
+                    suggestions: [{
+                        label: ( localize(7173, "New Command")),
+                        documentation: ( localize(7174, "Add a new command entry to this hook.")),
+                        kind: CompletionItemKind.Snippet,
+                        insertText: whilespaceAfterColon === 0 ? ` ${commandSnippet}` : commandSnippet,
+                        insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
+                        range: ( new Range(
+                            position.lineNumber,
+                            colonIdx + 1 + whilespaceAfterColon + 1,
+                            position.lineNumber,
+                            model.getLineMaxColumn(position.lineNumber)
+                        ))
+                    }]
+                };
+            }
+        }
+        const commandFieldCompletions = this.provideHookCommandFieldCompletions(model, position, hooksMap, target);
+        if (commandFieldCompletions) {
+            return commandFieldCompletions;
+        }
+        const suggestions = [];
+        const hooksByTarget = HOOKS_BY_TARGET[target] ?? HOOKS_BY_TARGET[Target.Undefined];
+        const lineText = model.getLineContent(position.lineNumber);
+        const firstNonWhitespace = lineText.search(/\S/);
+        const isEmptyLine = firstNonWhitespace === -1;
+        const rangeStartColumn = isEmptyLine ? position.column : firstNonWhitespace + 1;
+        const existingKeys = ( new Set(( hooksMap.properties.filter(p => p.key.range.startLineNumber !== position.lineNumber).map(p => p.key.value))));
+        const expectedIndent = hooksMap.properties.length > 0 ? hooksMap.properties[0].key.range.startColumn - 1 : -1;
+        if (expectedIndent >= 0) {
+            const scanEnd = model.getLineCount();
+            for (let lineNum = hooksMap.range.endLineNumber + 1; lineNum <= scanEnd; lineNum++) {
+                if (lineNum === position.lineNumber) {
+                    continue;
+                }
+                const lt = model.getLineContent(lineNum);
+                const lineIndent = lt.search(/\S/);
+                if (lineIndent === -1) {
+                    continue;
+                }
+                if (lineIndent < expectedIndent) {
+                    break;
+                }
+                if (lineIndent === expectedIndent) {
+                    const match = lt.match(/^\s+(\S+)\s*:/);
+                    if (match) {
+                        existingKeys.add(match[1]);
+                    }
                 }
             }
-            return [];
         }
-        switch (attribute) {
-        case PromptHeaderAttributes.applyTo:
-            if (promptType === PromptsType.instructions) {
-                return [{
-                    name: `'**'`
-                }, {
-                    name: `'**/*.ts, **/*.js'`
-                }, {
-                    name: `'**/*.php'`
-                }, {
-                    name: `'**/*.py'`
-                }];
+        const lineHasColon = lineText.indexOf(":") !== -1;
+        for (const [hookName, hookType] of Object.entries(hooksByTarget)) {
+            if (( existingKeys.has(hookName))) {
+                continue;
             }
-            break;
+            const meta = HOOK_METADATA[hookType];
+            let insertText;
+            if (isEmptyLine) {
+                insertText = [`${hookName}:`, `  - type: command`, `    command: "$1"`].join("\n");
+            } else if (lineHasColon) {
+                insertText = `${hookName}:`;
+            } else {
+                insertText = hookName;
+            }
+            suggestions.push({
+                label: hookName,
+                documentation: meta?.description,
+                kind: CompletionItemKind.Property,
+                insertText,
+                insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
+                range: ( new Range(
+                    position.lineNumber,
+                    rangeStartColumn,
+                    position.lineNumber,
+                    model.getLineMaxColumn(position.lineNumber)
+                ))
+            });
+        }
+        return {
+            suggestions
+        };
+    }
+    provideHookCommandFieldCompletions(model, position, hooksMap, target) {
+        const containingCommandMap = this.findContainingCommandMap(model, position, hooksMap);
+        if (!containingCommandMap) {
+            return undefined;
+        }
+        const isCopilotCli = target === Target.GitHubCopilot;
+        const validFields = isCopilotCli ? ["type", "bash", "powershell", "cwd", "env", "timeoutSec"] : [
+            "type",
+            "command",
+            "windows",
+            "linux",
+            "osx",
+            "bash",
+            "powershell",
+            "cwd",
+            "env",
+            "timeout"
+        ];
+        const existingFields = ( new Set(( containingCommandMap.properties.filter(p => p.key.range.startLineNumber !== position.lineNumber).map(p => p.key.value))));
+        const lineText = model.getLineContent(position.lineNumber);
+        const firstNonWhitespace = lineText.search(/\S/);
+        const isEmptyLine = firstNonWhitespace === -1;
+        const dashPrefixMatch = lineText.match(/^(\s*-\s+)/);
+        const fieldStart = dashPrefixMatch ? dashPrefixMatch[1].length : firstNonWhitespace;
+        const rangeStartColumn = isEmptyLine ? position.column : fieldStart + 1;
+        const colonIndex = lineText.indexOf(":");
+        const suggestions = [];
+        for (const fieldName of validFields) {
+            if (( existingFields.has(fieldName))) {
+                continue;
+            }
+            const desc = HOOK_COMMAND_FIELD_DESCRIPTIONS[fieldName];
+            const insertText = colonIndex !== -1 ? fieldName : `${fieldName}: $0`;
+            suggestions.push({
+                label: fieldName,
+                documentation: desc,
+                kind: CompletionItemKind.Property,
+                insertText,
+                insertTextRules: CompletionItemInsertTextRule.InsertAsSnippet,
+                range: ( new Range(
+                    position.lineNumber,
+                    rangeStartColumn,
+                    position.lineNumber,
+                    colonIndex !== -1 ? colonIndex + 1 : model.getLineMaxColumn(position.lineNumber)
+                ))
+            });
+        }
+        return suggestions.length > 0 ? {
+            suggestions
+        } : undefined;
+    }
+    findContainingCommandMap(model, position, hooksMap) {
+        for (let i = 0; i < hooksMap.properties.length; i++) {
+            const prop = hooksMap.properties[i];
+            if (prop.value.type !== "sequence") {
+                continue;
+            }
+            const seqRange = prop.value.range;
+            const nextProp = hooksMap.properties[i + 1];
+            const isInSeq = seqRange.containsPosition(position);
+            const isTrailingSeq = !isInSeq && seqRange.endLineNumber < position.lineNumber && (!nextProp || nextProp.key.range.startLineNumber > position.lineNumber);
+            if (isInSeq || isTrailingSeq) {
+                if (isTrailingSeq) {
+                    const lineText = model.getLineContent(position.lineNumber);
+                    const firstNonWs = lineText.search(/\S/);
+                    const effectiveIndent = firstNonWs === -1 ? position.column - 1 : firstNonWs;
+                    const hookKeyIndent = prop.key.range.startColumn - 1;
+                    if (effectiveIndent <= hookKeyIndent) {
+                        continue;
+                    }
+                }
+                const result = this.findCommandMapInSequence(position, prop.value);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return undefined;
+    }
+    findCommandMapInSequence(position, sequence) {
+        for (let i = 0; i < sequence.items.length; i++) {
+            const item = sequence.items[i];
+            if (item.type !== "map") {
+                if (item.type === "scalar" && item.range.startLineNumber === position.lineNumber) {
+                    return {
+                        type: "map",
+                        properties: [],
+                        range: item.range
+                    };
+                }
+                continue;
+            }
+            const isInRange = item.range.containsPosition(position);
+            const isTrailing = !isInRange && item.range.endLineNumber < position.lineNumber && (i + 1 >= sequence.items.length || sequence.items[i + 1].range.startLineNumber > position.lineNumber);
+            if (!isInRange && !isTrailing) {
+                continue;
+            }
+            const nestedHooks = item.properties.find(p => p.key.value === "hooks");
+            if (nestedHooks?.value.type === "sequence") {
+                const result = this.findCommandMapInSequence(position, nestedHooks.value);
+                if (result) {
+                    return result;
+                }
+            }
+            return item;
+        }
+        return undefined;
+    }
+    getValueSuggestions(promptType, attribute, target) {
+        const attributeDesc = getAttributeDefinition(attribute, promptType, target);
+        if (attributeDesc?.enums) {
+            return attributeDesc.enums;
+        }
+        if (attributeDesc?.defaults) {
+            return ( attributeDesc.defaults.map(value => ({
+                name: value
+            })));
+        }
+        switch (attribute) {
         case PromptHeaderAttributes.agent:
         case PromptHeaderAttributes.mode:
             if (promptType === PromptsType.prompt) {
@@ -246,63 +497,11 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
                 return suggestions;
             }
             break;
-        case PromptHeaderAttributes.target:
-            if (promptType === PromptsType.agent) {
-                return [{
-                    name: "vscode"
-                }, {
-                    name: "github-copilot"
-                }];
-            }
-            break;
-        case PromptHeaderAttributes.tools:
-            if (promptType === PromptsType.prompt || promptType === PromptsType.agent) {
-                return [{
-                    name: "[]"
-                }, {
-                    name: `['search', 'edit', 'web']`
-                }];
-            }
-            break;
         case PromptHeaderAttributes.model:
             if (promptType === PromptsType.prompt || promptType === PromptsType.agent) {
                 return this.getModelNames(promptType === PromptsType.agent);
             }
             break;
-        case PromptHeaderAttributes.infer:
-            if (promptType === PromptsType.agent) {
-                return [{
-                    name: "true"
-                }, {
-                    name: "false"
-                }];
-            }
-            break;
-        case PromptHeaderAttributes.agents:
-            if (promptType === PromptsType.agent) {
-                return [{
-                    name: "[\"*\"]"
-                }];
-            }
-            break;
-        case PromptHeaderAttributes.userInvocable:
-            if (promptType === PromptsType.agent || promptType === PromptsType.skill) {
-                return [{
-                    name: "true"
-                }, {
-                    name: "false"
-                }];
-            }
-            break;
-        case PromptHeaderAttributes.disableModelInvocation:
-            if (promptType === PromptsType.agent || promptType === PromptsType.skill) {
-                return [{
-                    name: "true"
-                }, {
-                    name: "false"
-                }];
-            }
-            break;
         }
         return [];
     }
@@ -364,6 +563,6 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
         return undefined;
     }
 };
-PromptHeaderAutocompletion = ( __decorate([( __param(0, IPromptsService)), ( __param(1, ILanguageModelsService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, IChatModeService))], PromptHeaderAutocompletion));
+PromptHeaderAutocompletion = ( __decorate([( __param(0, IPromptsService)), ( __param(1, ILanguageModelsService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, IChatModeService)), ( __param(4, IWorkbenchEnvironmentService)), ( __param(5, IConfigurationService))], PromptHeaderAutocompletion));
 
 export { PromptHeaderAutocompletion };

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

@@ -6,16 +6,18 @@ import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/w
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
 import { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 export declare class PromptHoverProvider implements HoverProvider {
     private readonly promptsService;
     private readonly languageModelToolsService;
     private readonly languageModelsService;
     private readonly chatModeService;
+    private readonly configurationService;
     /**
      * Debug display name for this provider.
      */
     readonly _debugDisplayName: string;
-    constructor(promptsService: IPromptsService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, chatModeService: IChatModeService);
+    constructor(promptsService: IPromptsService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, chatModeService: IChatModeService, configurationService: IConfigurationService);
     private createHover;
     provideHover(model: ITextModel, position: Position, token: CancellationToken, _context?: HoverContext): Promise<Hover | undefined>;
     private provideBodyHover;
@@ -25,5 +27,12 @@ export declare class PromptHoverProvider implements HoverProvider {
     private getToolsetHover;
     private getModelHover;
     private getAgentHover;
+    private getHooksHover;
+    /**
+     * Recursively searches hook command items for hover information.
+     * Handles both direct command objects and nested matcher format
+     * (e.g., `{ matcher: "...", hooks: [{ type: command, ... }] }`).
+     */
+    private getHookCommandItemHover;
     private getHandsOffHover;
 }