@codingame/monaco-vscode-api 26.2.2 → 28.0.0

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

@@ -1,68 +1,9 @@
 import { IJSONSchema } from "../../../../../base/common/jsonSchema.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { OperatingSystem } from "../../../../../base/common/platform.js";
-/**
- * Enum of available hook types that can be configured in hooks .json
- */
-export declare enum HookType {
-    SessionStart = "SessionStart",
-    UserPromptSubmit = "UserPromptSubmit",
-    PreToolUse = "PreToolUse",
-    PostToolUse = "PostToolUse",
-    PreCompact = "PreCompact",
-    SubagentStart = "SubagentStart",
-    SubagentStop = "SubagentStop",
-    Stop = "Stop"
-}
-/**
- * String literal type derived from HookType enum values.
- */
-export type HookTypeValue = `${HookType}`;
-/**
- * Metadata for hook types including localized labels and descriptions
- */
-export declare const HOOK_TYPES: readonly [
-    {
-        readonly id: HookType.SessionStart;
-        readonly label: string;
-        readonly description: string;
-    },
-    {
-        readonly id: HookType.UserPromptSubmit;
-        readonly label: string;
-        readonly description: string;
-    },
-    {
-        readonly id: HookType.PreToolUse;
-        readonly label: string;
-        readonly description: string;
-    },
-    {
-        readonly id: HookType.PostToolUse;
-        readonly label: string;
-        readonly description: string;
-    },
-    {
-        readonly id: HookType.PreCompact;
-        readonly label: string;
-        readonly description: string;
-    },
-    {
-        readonly id: HookType.SubagentStart;
-        readonly label: string;
-        readonly description: string;
-    },
-    {
-        readonly id: HookType.SubagentStop;
-        readonly label: string;
-        readonly description: string;
-    },
-    {
-        readonly id: HookType.Stop;
-        readonly label: string;
-        readonly description: string;
-    }
-];
+import { HookType } from "./hookTypes.js";
+import { Target } from "./promptTypes.js";
+import { IMapValue } from "./promptFileParser.js";
 /**
  * A single hook command configuration.
  */
@@ -91,25 +32,23 @@ export interface IHookCommand {
  * Collected hooks for a chat request, organized by hook type.
  * This is passed to the extension host so it knows what hooks are available.
  */
-export interface IChatRequestHooks {
-    readonly [HookType.SessionStart]?: readonly IHookCommand[];
-    readonly [HookType.UserPromptSubmit]?: readonly IHookCommand[];
-    readonly [HookType.PreToolUse]?: readonly IHookCommand[];
-    readonly [HookType.PostToolUse]?: readonly IHookCommand[];
-    readonly [HookType.PreCompact]?: readonly IHookCommand[];
-    readonly [HookType.SubagentStart]?: readonly IHookCommand[];
-    readonly [HookType.SubagentStop]?: readonly IHookCommand[];
-    readonly [HookType.Stop]?: readonly IHookCommand[];
-}
+export type ChatRequestHooks = {
+    readonly [K in HookType]?: readonly IHookCommand[];
+};
+/**
+ * Merges two sets of hooks by concatenating the command arrays for each hook type.
+ * Additional hooks are appended after the base hooks.
+ */
+export declare function mergeHooks(base: ChatRequestHooks | undefined, additional: ChatRequestHooks): ChatRequestHooks;
+/**
+ * Descriptions for hook command fields, used by both the JSON schema and the hover provider.
+ */
+export declare const HOOK_COMMAND_FIELD_DESCRIPTIONS: Record<string, string>;
 export declare const hookFileSchema: IJSONSchema;
 /**
  * URI for the hook schema registration.
  */
 export declare const HOOK_SCHEMA_URI = "vscode://schemas/hooks";
-/**
- * Glob pattern for hook files.
- */
-export declare const HOOK_FILE_GLOB = ".github/hooks/*.json";
 /**
  * Normalizes a raw hook type identifier to the canonical HookType enum value.
  * Only matches exact enum values. For tool-specific naming conventions (e.g., Claude, Copilot CLI),
@@ -157,3 +96,42 @@ export declare function formatHookCommandLabel(hook: IHookCommand, os: Operating
  * @param userHome The user's home directory path for tilde expansion
  */
 export declare function resolveHookCommand(raw: Record<string, unknown>, workspaceRootUri: URI | undefined, userHome: string): IHookCommand | undefined;
+/**
+ * Helper to extract hook commands from an item that could be:
+ * 1. A direct command object: { type: 'command', command: '...' }
+ * 2. A nested structure with matcher (Claude style): { matcher: '...', hooks: [{ type: 'command', command: '...' }] }
+ *
+ * This allows Copilot format to handle Claude-style entries if pasted.
+ * Also handles Claude's leniency where 'type' field can be omitted.
+ */
+export declare function extractHookCommandsFromItem(item: unknown, workspaceRootUri: URI | undefined, userHome: string): IHookCommand[];
+/**
+ * Parses hooks from a subagent's YAML frontmatter `hooks` attribute.
+ *
+ * Supports two formats for hook entries:
+ *
+ * 1. **Direct command** (our format, without matcher):
+ * ```yaml
+ * hooks:
+ *   PreToolUse:
+ *     - type: command
+ *       command: "./scripts/validate.sh"
+ * ```
+ *
+ * 2. **Nested with matcher** (Claude Code format):
+ * ```yaml
+ * hooks:
+ *   PreToolUse:
+ *     - matcher: "Bash"
+ *       hooks:
+ *         - type: command
+ *           command: "./scripts/validate.sh"
+ * ```
+ *
+ * @param hooksMap The raw YAML map value from the `hooks` frontmatter attribute.
+ * @param workspaceRootUri Workspace root for resolving relative `cwd` paths.
+ * @param userHome User home directory path for tilde expansion.
+ * @param target The agent's target, used to resolve hook type names correctly.
+ * @returns Resolved hooks organized by hook type, ready for use in {@link ChatRequestHooks}.
+ */
+export declare function parseSubagentHooksFromYaml(hooksMap: IMapValue, workspaceRootUri: URI | undefined, userHome: string, target?: Target): ChatRequestHooks;

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

@@ -5,52 +5,54 @@ import { joinPath } from '../../../../../base/common/resources.js';
 import { isAbsolute } from '../../../../../base/common/path.js';
 import { untildify } from '../../../../../base/common/labels.js';
 import { OperatingSystem } from '../../../../../base/common/platform.js';
+import { HookType, HOOKS_BY_TARGET, HOOK_METADATA } from './hookTypes.js';
+import { Target } from './promptTypes.js';
 
-var HookType;
-(function(HookType) {
-    HookType["SessionStart"] = "SessionStart";
-    HookType["UserPromptSubmit"] = "UserPromptSubmit";
-    HookType["PreToolUse"] = "PreToolUse";
-    HookType["PostToolUse"] = "PostToolUse";
-    HookType["PreCompact"] = "PreCompact";
-    HookType["SubagentStart"] = "SubagentStart";
-    HookType["SubagentStop"] = "SubagentStop";
-    HookType["Stop"] = "Stop";
-})(HookType || (HookType = {}));
-const HOOK_TYPES = [{
-    id: HookType.SessionStart,
-    label: ( localize(6375, "Session Start")),
-    description: ( localize(6376, "Executed when a new agent session begins."))
-}, {
-    id: HookType.UserPromptSubmit,
-    label: ( localize(6377, "User Prompt Submit")),
-    description: ( localize(6378, "Executed when the user submits a prompt to the agent."))
-}, {
-    id: HookType.PreToolUse,
-    label: ( localize(6379, "Pre-Tool Use")),
-    description: ( localize(6380, "Executed before the agent uses any tool."))
-}, {
-    id: HookType.PostToolUse,
-    label: ( localize(6381, "Post-Tool Use")),
-    description: ( localize(6382, "Executed after a tool completes execution successfully."))
-}, {
-    id: HookType.PreCompact,
-    label: ( localize(6383, "Pre-Compact")),
-    description: ( localize(6384, "Executed before the agent compacts the conversation context."))
-}, {
-    id: HookType.SubagentStart,
-    label: ( localize(6385, "Subagent Start")),
-    description: ( localize(6386, "Executed when a subagent is started."))
-}, {
-    id: HookType.SubagentStop,
-    label: ( localize(6387, "Subagent Stop")),
-    description: ( localize(6388, "Executed when a subagent stops."))
-}, {
-    id: HookType.Stop,
-    label: ( localize(6389, "Stop")),
-    description: ( localize(6390, "Executed when the agent stops."))
-}];
-const hookCommandSchema = {
+function mergeHooks(base, additional) {
+    if (!base) {
+        return additional;
+    }
+    const result = {
+        ...base
+    };
+    for (const hookType of ( Object.values(HookType))) {
+        const baseArr = base[hookType];
+        const additionalArr = additional[hookType];
+        if (additionalArr && additionalArr.length > 0) {
+            result[hookType] = baseArr ? [...baseArr, ...additionalArr] : additionalArr;
+        }
+    }
+    return result;
+}
+const HOOK_COMMAND_FIELD_DESCRIPTIONS = {
+    type: ( localize(7049, "Must be \"command\".")),
+    command: ( localize(
+        7050,
+        "The command to execute. This is the default cross-platform command."
+    )),
+    windows: ( localize(
+        7051,
+        "Windows-specific command. If specified and running on Windows, this overrides the \"command\" field."
+    )),
+    linux: ( localize(
+        7052,
+        "Linux-specific command. If specified and running on Linux, this overrides the \"command\" field."
+    )),
+    osx: ( localize(
+        7053,
+        "macOS-specific command. If specified and running on macOS, this overrides the \"command\" field."
+    )),
+    bash: ( localize(7054, "Bash command for Linux and macOS.")),
+    powershell: ( localize(7055, "PowerShell command for Windows.")),
+    cwd: ( localize(7056, "Working directory for the script (relative to repository root).")),
+    env: ( localize(
+        7057,
+        "Additional environment variables that are merged with the existing environment."
+    )),
+    timeout: ( localize(7058, "Maximum execution time in seconds (default: 30).")),
+    timeoutSec: ( localize(7059, "Maximum execution time in seconds (default: 10)."))
+};
+const vscodeHookCommandSchema = {
     type: "object",
     additionalProperties: true,
     required: ["type"],
@@ -68,73 +70,112 @@ const hookCommandSchema = {
         required: ["powershell"]
     }],
     errorMessage: ( localize(
-        6391,
+        7060,
         "At least one of \"command\", \"windows\", \"linux\", or \"osx\" must be specified."
     )),
     properties: {
         type: {
             type: "string",
             enum: ["command"],
-            description: ( localize(6392, "Must be \"command\"."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.type
         },
         command: {
             type: "string",
-            description: ( localize(
-                6393,
-                "The command to execute. This is the default cross-platform command."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.command
         },
         windows: {
             type: "string",
-            description: ( localize(
-                6394,
-                "Windows-specific command. If specified and running on Windows, this overrides the \"command\" field."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.windows
         },
         linux: {
             type: "string",
-            description: ( localize(
-                6395,
-                "Linux-specific command. If specified and running on Linux, this overrides the \"command\" field."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.linux
         },
         osx: {
             type: "string",
-            description: ( localize(
-                6396,
-                "macOS-specific command. If specified and running on macOS, this overrides the \"command\" field."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.osx
         },
         cwd: {
             type: "string",
-            description: ( localize(6397, "Working directory for the script (relative to repository root)."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.cwd
         },
         env: {
             type: "object",
             additionalProperties: {
                 type: "string"
             },
-            description: ( localize(
-                6398,
-                "Additional environment variables that are merged with the existing environment."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.env
         },
         timeout: {
             type: "number",
             default: 30,
-            description: ( localize(6399, "Maximum execution time in seconds (default: 30)."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.timeout
         }
     }
 };
 const hookArraySchema = {
     type: "array",
-    items: hookCommandSchema
+    items: vscodeHookCommandSchema
+};
+function buildHookProperties(target, arraySchema) {
+    return Object.fromEntries(( Object.entries(HOOKS_BY_TARGET[target]).map(([key, hookType]) => [key, {
+        ...arraySchema,
+        description: HOOK_METADATA[hookType]?.description
+    }])));
+}
+const vscodeHookProperties = buildHookProperties(Target.VSCode, hookArraySchema);
+const copilotCliHookCommandSchema = {
+    type: "object",
+    additionalProperties: true,
+    required: ["type"],
+    anyOf: [{
+        required: ["bash"]
+    }, {
+        required: ["powershell"]
+    }],
+    errorMessage: ( localize(7061, "At least one of \"bash\" or \"powershell\" must be specified.")),
+    properties: {
+        type: {
+            type: "string",
+            enum: ["command"],
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.type
+        },
+        bash: {
+            type: "string",
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.bash
+        },
+        powershell: {
+            type: "string",
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.powershell
+        },
+        cwd: {
+            type: "string",
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.cwd
+        },
+        env: {
+            type: "object",
+            additionalProperties: {
+                type: "string"
+            },
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.env
+        },
+        timeoutSec: {
+            type: "number",
+            default: 10,
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.timeoutSec
+        }
+    }
+};
+const copilotCliHookArraySchema = {
+    type: "array",
+    items: copilotCliHookCommandSchema
 };
+const copilotCliHookProperties = buildHookProperties(Target.GitHubCopilot, copilotCliHookArraySchema);
 const hookFileSchema = {
     $schema: "http://json-schema.org/draft-07/schema#",
     type: "object",
     description: ( localize(
-        6400,
+        7062,
         "GitHub Copilot hook configuration file. Hooks enable executing custom shell commands at strategic points in an agent's workflow."
     )),
     additionalProperties: true,
@@ -142,71 +183,39 @@ const hookFileSchema = {
     properties: {
         hooks: {
             type: "object",
-            description: ( localize(6401, "Hook definitions organized by type.")),
-            additionalProperties: true,
-            properties: {
-                SessionStart: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6402,
-                        "Executed when a new agent session begins. Use to initialize environments, log session starts, validate project state, or set up temporary resources."
-                    ))
-                },
-                UserPromptSubmit: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6403,
-                        "Executed when the user submits a prompt to the agent. Use to log user requests for auditing and usage analysis."
-                    ))
-                },
-                PreToolUse: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6404,
-                        "Executed before the agent uses any tool. This is the most powerful hook as it can approve or deny tool executions. Use to block dangerous commands, enforce security policies, require approval for sensitive operations, or log tool usage."
-                    ))
-                },
-                PostToolUse: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6405,
-                        "Executed after a tool completes execution successfully. Use to log execution results, track usage statistics, generate audit trails, or monitor performance."
-                    ))
-                },
-                PreCompact: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6406,
-                        "Executed before the agent compacts the conversation context. Use to save conversation state, export important information, or prepare for context reduction."
-                    ))
-                },
-                SubagentStart: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6407,
-                        "Executed when a subagent is started. Use to log subagent spawning, track nested agent usage, or initialize subagent-specific resources."
-                    ))
-                },
-                SubagentStop: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6408,
-                        "Executed when a subagent stops. Use to log subagent completion, cleanup subagent resources, or aggregate subagent results."
-                    ))
-                },
-                Stop: {
-                    ...hookArraySchema,
-                    description: ( localize(
-                        6409,
-                        "Executed when the agent session stops. Use to cleanup resources, generate final reports, or send completion notifications."
-                    ))
-                }
+            description: ( localize(7063, "Hook definitions organized by type.")),
+            additionalProperties: true
+        }
+    },
+    if: {
+        required: ["version"],
+        properties: {
+            version: {
+                type: "number"
+            }
+        }
+    },
+    then: {
+        properties: {
+            version: {
+                type: "number",
+                description: ( localize(7064, "Hook configuration format version."))
+            },
+            hooks: {
+                properties: copilotCliHookProperties
+            }
+        }
+    },
+    else: {
+        properties: {
+            hooks: {
+                properties: vscodeHookProperties
             }
         }
     },
     defaultSnippets: [{
-        label: ( localize(6410, "Basic hook configuration")),
-        description: ( localize(6411, "A basic hook configuration with common hooks")),
+        label: ( localize(7065, "Basic hook configuration")),
+        description: ( localize(7066, "A basic hook configuration with common hooks")),
         body: {
             hooks: {
                 SessionStart: [{
@@ -223,7 +232,6 @@ const hookFileSchema = {
     }]
 };
 const HOOK_SCHEMA_URI = "vscode://schemas/hooks";
-const HOOK_FILE_GLOB = ".github/hooks/*.json";
 function toHookType(rawHookTypeId) {
     if (( Object.values(HookType)).includes(rawHookTypeId)) {
         return rawHookTypeId;
@@ -282,16 +290,6 @@ function normalizeHookCommand(raw) {
         })
     };
 }
-function getPlatformLabel(os) {
-    if (os === OperatingSystem.Windows) {
-        return "Windows";
-    } else if (os === OperatingSystem.Macintosh) {
-        return "macOS";
-    } else if (os === OperatingSystem.Linux) {
-        return "Linux";
-    }
-    return "";
-}
 function resolveEffectiveCommand(hook, os) {
     if (os === OperatingSystem.Windows && hook.windows) {
         return hook.windows;
@@ -302,16 +300,6 @@ function resolveEffectiveCommand(hook, os) {
     }
     return hook.command;
 }
-function isUsingPlatformOverride(hook, os) {
-    if (os === OperatingSystem.Windows && hook.windows) {
-        return true;
-    } else if (os === OperatingSystem.Macintosh && hook.osx) {
-        return true;
-    } else if (os === OperatingSystem.Linux && hook.linux) {
-        return true;
-    }
-    return false;
-}
 function getEffectiveCommandFieldKey(hook, os) {
     if (os === OperatingSystem.Windows && hook.windows) {
         return hook.windowsSource ?? "windows";
@@ -327,10 +315,6 @@ function formatHookCommandLabel(hook, os) {
     if (!command) {
         return "";
     }
-    if (isUsingPlatformOverride(hook, os)) {
-        const platformLabel = getPlatformLabel(os);
-        return `[${platformLabel}] ${command}`;
-    }
     return command;
 }
 function resolveHookCommand(raw, workspaceRootUri, userHome) {
@@ -383,5 +367,84 @@ function resolveHookCommand(raw, workspaceRootUri, userHome) {
         })
     };
 }
+function extractHookCommandsFromItem(item, workspaceRootUri, userHome) {
+    if (!item || typeof item !== "object") {
+        return [];
+    }
+    const itemObj = item;
+    const commands = [];
+    const nestedHooks = itemObj.hooks;
+    if (nestedHooks !== undefined && Array.isArray(nestedHooks)) {
+        for (const nestedHook of nestedHooks) {
+            if (!nestedHook || typeof nestedHook !== "object") {
+                continue;
+            }
+            const normalized = normalizeForResolve(nestedHook);
+            const resolved = resolveHookCommand(normalized, workspaceRootUri, userHome);
+            if (resolved) {
+                commands.push(resolved);
+            }
+        }
+    } else {
+        const normalized = normalizeForResolve(itemObj);
+        const resolved = resolveHookCommand(normalized, workspaceRootUri, userHome);
+        if (resolved) {
+            commands.push(resolved);
+        }
+    }
+    return commands;
+}
+function normalizeForResolve(raw) {
+    if (raw.type === undefined || raw.type === "command") {
+        return {
+            ...raw,
+            type: "command"
+        };
+    }
+    return raw;
+}
+function yamlValueToPlain(value) {
+    switch (value.type) {
+    case "scalar":
+        return value.value;
+    case "sequence":
+        return ( value.items.map(yamlValueToPlain));
+    case "map":
+        {
+            const obj = {};
+            for (const prop of value.properties) {
+                obj[prop.key.value] = yamlValueToPlain(prop.value);
+            }
+            return obj;
+        }
+    }
+}
+function parseSubagentHooksFromYaml(hooksMap, workspaceRootUri, userHome, target = Target.Undefined) {
+    const result = {};
+    const targetHookMap = HOOKS_BY_TARGET[target] ?? HOOKS_BY_TARGET[Target.Undefined];
+    for (const prop of hooksMap.properties) {
+        const hookTypeName = prop.key.value;
+        const hookType = targetHookMap[hookTypeName] ?? toHookType(hookTypeName);
+        if (!hookType) {
+            continue;
+        }
+        if (prop.value.type !== "sequence") {
+            continue;
+        }
+        const commands = [];
+        for (const item of prop.value.items) {
+            const plainItem = yamlValueToPlain(item);
+            const extracted = extractHookCommandsFromItem(plainItem, workspaceRootUri, userHome);
+            commands.push(...extracted);
+        }
+        if (commands.length > 0) {
+            if (!result[hookType]) {
+                result[hookType] = [];
+            }
+            result[hookType].push(...commands);
+        }
+    }
+    return result;
+}
 
-export { HOOK_FILE_GLOB, HOOK_SCHEMA_URI, HOOK_TYPES, HookType, formatHookCommandLabel, getEffectiveCommandFieldKey, getPlatformLabel, hookFileSchema, isUsingPlatformOverride, resolveEffectiveCommand, resolveHookCommand, toHookType };
+export { HOOK_COMMAND_FIELD_DESCRIPTIONS, HOOK_SCHEMA_URI, extractHookCommandsFromItem, formatHookCommandLabel, getEffectiveCommandFieldKey, hookFileSchema, mergeHooks, parseSubagentHooksFromYaml, resolveEffectiveCommand, resolveHookCommand, toHookType };

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

@@ -0,0 +1,34 @@
+import { Target } from "./promptTypes.js";
+/**
+ * Enum of hook types across all targets. For the set of supported hooks per target, see HOOKS_BY_TARGET.
+ */
+export declare enum HookType {
+    SessionStart = "SessionStart",
+    SessionEnd = "SessionEnd",
+    UserPromptSubmit = "UserPromptSubmit",
+    PreToolUse = "PreToolUse",
+    PostToolUse = "PostToolUse",
+    PreCompact = "PreCompact",
+    SubagentStart = "SubagentStart",
+    SubagentStop = "SubagentStop",
+    Stop = "Stop",
+    ErrorOccurred = "ErrorOccurred"
+}
+/**
+ * String literal type derived from HookType enum values.
+ */
+export type HookTypeValue = `${HookType}`;
+export declare const HOOKS_BY_TARGET: Record<Target, Record<string, HookType>>;
+/**
+ * Metadata for a hook type including localized label and description.
+ */
+export interface IHookTypeMeta {
+    readonly label: string;
+    readonly description: string;
+}
+/**
+ * Metadata for hook types including localized labels and descriptions
+ */
+export declare const HOOK_METADATA: {
+    [key in HookType]: IHookTypeMeta;
+};