@codingame/monaco-vscode-api 27.0.0 → 28.0.1

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

@@ -5,58 +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 COPILOT_CLI_HOOK_TYPE_MAP = {
-    "sessionStart": HookType.SessionStart,
-    "userPromptSubmitted": HookType.UserPromptSubmit,
-    "preToolUse": HookType.PreToolUse,
-    "postToolUse": HookType.PostToolUse
+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 HOOK_TYPES = [{
-    id: HookType.SessionStart,
-    label: ( localize(6930, "Session Start")),
-    description: ( localize(6931, "Executed when a new agent session begins."))
-}, {
-    id: HookType.UserPromptSubmit,
-    label: ( localize(6932, "User Prompt Submit")),
-    description: ( localize(6933, "Executed when the user submits a prompt to the agent."))
-}, {
-    id: HookType.PreToolUse,
-    label: ( localize(6934, "Pre-Tool Use")),
-    description: ( localize(6935, "Executed before the agent uses any tool."))
-}, {
-    id: HookType.PostToolUse,
-    label: ( localize(6936, "Post-Tool Use")),
-    description: ( localize(6937, "Executed after a tool completes execution successfully."))
-}, {
-    id: HookType.PreCompact,
-    label: ( localize(6938, "Pre-Compact")),
-    description: ( localize(6939, "Executed before the agent compacts the conversation context."))
-}, {
-    id: HookType.SubagentStart,
-    label: ( localize(6940, "Subagent Start")),
-    description: ( localize(6941, "Executed when a subagent is started."))
-}, {
-    id: HookType.SubagentStop,
-    label: ( localize(6942, "Subagent Stop")),
-    description: ( localize(6943, "Executed when a subagent stops."))
-}, {
-    id: HookType.Stop,
-    label: ( localize(6944, "Stop")),
-    description: ( localize(6945, "Executed when the agent stops."))
-}];
-const hookCommandSchema = {
+const vscodeHookCommandSchema = {
     type: "object",
     additionalProperties: true,
     required: ["type"],
@@ -74,126 +70,60 @@ const hookCommandSchema = {
         required: ["powershell"]
     }],
     errorMessage: ( localize(
-        6946,
+        7060,
         "At least one of \"command\", \"windows\", \"linux\", or \"osx\" must be specified."
     )),
     properties: {
         type: {
             type: "string",
             enum: ["command"],
-            description: ( localize(6947, "Must be \"command\"."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.type
         },
         command: {
             type: "string",
-            description: ( localize(
-                6948,
-                "The command to execute. This is the default cross-platform command."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.command
         },
         windows: {
             type: "string",
-            description: ( localize(
-                6949,
-                "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(
-                6950,
-                "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(
-                6951,
-                "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(6952, "Working directory for the script (relative to repository root)."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.cwd
         },
         env: {
             type: "object",
             additionalProperties: {
                 type: "string"
             },
-            description: ( localize(
-                6953,
-                "Additional environment variables that are merged with the existing environment."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.env
         },
         timeout: {
             type: "number",
             default: 30,
-            description: ( localize(6954, "Maximum execution time in seconds (default: 30)."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.timeout
         }
     }
 };
 const hookArraySchema = {
     type: "array",
-    items: hookCommandSchema
-};
-const vscodeHookProperties = {
-    SessionStart: {
-        ...hookArraySchema,
-        description: ( localize(
-            6955,
-            "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(
-            6956,
-            "Executed when the user submits a prompt to the agent. Use to log user requests for auditing and usage analysis."
-        ))
-    },
-    PreToolUse: {
-        ...hookArraySchema,
-        description: ( localize(
-            6957,
-            "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(
-            6958,
-            "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(
-            6959,
-            "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(
-            6960,
-            "Executed when a subagent is started. Use to log subagent spawning, track nested agent usage, or initialize subagent-specific resources."
-        ))
-    },
-    SubagentStop: {
-        ...hookArraySchema,
-        description: ( localize(
-            6961,
-            "Executed when a subagent stops. Use to log subagent completion, cleanup subagent resources, or aggregate subagent results."
-        ))
-    },
-    Stop: {
-        ...hookArraySchema,
-        description: ( localize(
-            6962,
-            "Executed when the agent session stops. Use to cleanup resources, generate final reports, or send completion notifications."
-        ))
-    }
+    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,
@@ -203,39 +133,36 @@ const copilotCliHookCommandSchema = {
     }, {
         required: ["powershell"]
     }],
-    errorMessage: ( localize(6963, "At least one of \"bash\" or \"powershell\" must be specified.")),
+    errorMessage: ( localize(7061, "At least one of \"bash\" or \"powershell\" must be specified.")),
     properties: {
         type: {
             type: "string",
             enum: ["command"],
-            description: ( localize(6947, "Must be \"command\"."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.type
         },
         bash: {
             type: "string",
-            description: ( localize(6964, "Bash command for Linux and macOS."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.bash
         },
         powershell: {
             type: "string",
-            description: ( localize(6965, "PowerShell command for Windows."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.powershell
         },
         cwd: {
             type: "string",
-            description: ( localize(6952, "Working directory for the script (relative to repository root)."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.cwd
         },
         env: {
             type: "object",
             additionalProperties: {
                 type: "string"
             },
-            description: ( localize(
-                6953,
-                "Additional environment variables that are merged with the existing environment."
-            ))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.env
         },
         timeoutSec: {
             type: "number",
             default: 10,
-            description: ( localize(6966, "Maximum execution time in seconds (default: 10)."))
+            description: HOOK_COMMAND_FIELD_DESCRIPTIONS.timeoutSec
         }
     }
 };
@@ -243,32 +170,12 @@ const copilotCliHookArraySchema = {
     type: "array",
     items: copilotCliHookCommandSchema
 };
-const copilotCliHookProperties = {
-    sessionStart: {
-        ...copilotCliHookArraySchema,
-        description: ( localize(6967, "Executed when a new agent session begins."))
-    },
-    userPromptSubmitted: {
-        ...copilotCliHookArraySchema,
-        description: ( localize(6968, "Executed when the user submits a prompt to the agent."))
-    },
-    preToolUse: {
-        ...copilotCliHookArraySchema,
-        description: ( localize(
-            6969,
-            "Executed before the agent uses any tool. Can approve or deny tool executions."
-        ))
-    },
-    postToolUse: {
-        ...copilotCliHookArraySchema,
-        description: ( localize(6970, "Executed after a tool completes execution successfully."))
-    }
-};
+const copilotCliHookProperties = buildHookProperties(Target.GitHubCopilot, copilotCliHookArraySchema);
 const hookFileSchema = {
     $schema: "http://json-schema.org/draft-07/schema#",
     type: "object",
     description: ( localize(
-        6971,
+        7062,
         "GitHub Copilot hook configuration file. Hooks enable executing custom shell commands at strategic points in an agent's workflow."
     )),
     additionalProperties: true,
@@ -276,7 +183,7 @@ const hookFileSchema = {
     properties: {
         hooks: {
             type: "object",
-            description: ( localize(6972, "Hook definitions organized by type.")),
+            description: ( localize(7063, "Hook definitions organized by type.")),
             additionalProperties: true
         }
     },
@@ -292,7 +199,7 @@ const hookFileSchema = {
         properties: {
             version: {
                 type: "number",
-                description: ( localize(6973, "Hook configuration format version."))
+                description: ( localize(7064, "Hook configuration format version."))
             },
             hooks: {
                 properties: copilotCliHookProperties
@@ -307,8 +214,8 @@ const hookFileSchema = {
         }
     },
     defaultSnippets: [{
-        label: ( localize(6974, "Basic hook configuration")),
-        description: ( localize(6975, "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: [{
@@ -383,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;
@@ -403,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";
@@ -428,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) {
@@ -484,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 { COPILOT_CLI_HOOK_TYPE_MAP, 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;
+};

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

@@ -0,0 +1,94 @@
+
+import { localize } from '../../../../../nls.js';
+import { Target } from './promptTypes.js';
+
+var HookType;
+(function(HookType) {
+    HookType["SessionStart"] = "SessionStart";
+    HookType["SessionEnd"] = "SessionEnd";
+    HookType["UserPromptSubmit"] = "UserPromptSubmit";
+    HookType["PreToolUse"] = "PreToolUse";
+    HookType["PostToolUse"] = "PostToolUse";
+    HookType["PreCompact"] = "PreCompact";
+    HookType["SubagentStart"] = "SubagentStart";
+    HookType["SubagentStop"] = "SubagentStop";
+    HookType["Stop"] = "Stop";
+    HookType["ErrorOccurred"] = "ErrorOccurred";
+})(HookType || (HookType = {}));
+const HOOKS_BY_TARGET = {
+    [Target.VSCode]: {
+        "SessionStart": HookType.SessionStart,
+        "UserPromptSubmit": HookType.UserPromptSubmit,
+        "PreToolUse": HookType.PreToolUse,
+        "PostToolUse": HookType.PostToolUse,
+        "PreCompact": HookType.PreCompact,
+        "SubagentStart": HookType.SubagentStart,
+        "SubagentStop": HookType.SubagentStop,
+        "Stop": HookType.Stop
+    },
+    [Target.GitHubCopilot]: {
+        "sessionStart": HookType.SessionStart,
+        "sessionEnd": HookType.SessionEnd,
+        "userPromptSubmitted": HookType.UserPromptSubmit,
+        "preToolUse": HookType.PreToolUse,
+        "postToolUse": HookType.PostToolUse,
+        "agentStop": HookType.Stop,
+        "subagentStop": HookType.SubagentStop,
+        "errorOccurred": HookType.ErrorOccurred
+    },
+    [Target.Claude]: {
+        "SessionStart": HookType.SessionStart,
+        "UserPromptSubmit": HookType.UserPromptSubmit,
+        "PreToolUse": HookType.PreToolUse,
+        "PostToolUse": HookType.PostToolUse,
+        "PreCompact": HookType.PreCompact,
+        "SubagentStart": HookType.SubagentStart,
+        "SubagentStop": HookType.SubagentStop,
+        "Stop": HookType.Stop
+    },
+    [Target.Undefined]: Object.fromEntries(( ( Object.values(HookType)).map(h => [h, h])))
+};
+const HOOK_METADATA = {
+    [HookType.SessionStart]: {
+        label: ( localize(7067, "Session Start")),
+        description: ( localize(7068, "Executed when a new agent session begins."))
+    },
+    [HookType.UserPromptSubmit]: {
+        label: ( localize(7069, "User Prompt Submit")),
+        description: ( localize(7070, "Executed when the user submits a prompt to the agent."))
+    },
+    [HookType.PreToolUse]: {
+        label: ( localize(7071, "Pre-Tool Use")),
+        description: ( localize(7072, "Executed before the agent uses any tool."))
+    },
+    [HookType.PostToolUse]: {
+        label: ( localize(7073, "Post-Tool Use")),
+        description: ( localize(7074, "Executed after a tool completes execution successfully."))
+    },
+    [HookType.PreCompact]: {
+        label: ( localize(7075, "Pre-Compact")),
+        description: ( localize(7076, "Executed before the agent compacts the conversation context."))
+    },
+    [HookType.SubagentStart]: {
+        label: ( localize(7077, "Subagent Start")),
+        description: ( localize(7078, "Executed when a subagent is started."))
+    },
+    [HookType.SubagentStop]: {
+        label: ( localize(7079, "Subagent Stop")),
+        description: ( localize(7080, "Executed when a subagent stops."))
+    },
+    [HookType.Stop]: {
+        label: ( localize(7081, "Stop")),
+        description: ( localize(7082, "Executed when the agent stops."))
+    },
+    [HookType.SessionEnd]: {
+        label: ( localize(7083, "Session End")),
+        description: ( localize(7084, "Executed when an agent session ends."))
+    },
+    [HookType.ErrorOccurred]: {
+        label: ( localize(7085, "Error Occurred")),
+        description: ( localize(7086, "Executed when an error occurs during the agent session."))
+    }
+};
+
+export { HOOKS_BY_TARGET, HOOK_METADATA, HookType };

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

@@ -0,0 +1,67 @@
+import { URI } from "../../../../../../base/common/uri.js";
+import { PromptHeader } from "../promptFileParser.js";
+import { PromptsType, Target } from "../promptTypes.js";
+export declare namespace GithubPromptHeaderAttributes {
+    const mcpServers = "mcp-servers";
+    const github = "github";
+}
+export declare namespace ClaudeHeaderAttributes {
+    const disallowedTools = "disallowedTools";
+}
+export declare function isTarget(value: unknown): value is Target;
+interface IAttributeDefinition {
+    readonly type: string;
+    readonly description: string;
+    readonly defaults?: readonly string[];
+    readonly items?: readonly {
+        name: string;
+        description?: string;
+    }[];
+    readonly enums?: readonly {
+        name: string;
+        description?: string;
+    }[];
+}
+export declare const promptFileAttributes: Record<string, IAttributeDefinition>;
+export declare const instructionAttributes: Record<string, IAttributeDefinition>;
+export declare const customAgentAttributes: Record<string, IAttributeDefinition>;
+export declare const skillAttributes: Record<string, IAttributeDefinition>;
+export declare function getValidAttributeNames(promptType: PromptsType, includeNonRecommended: boolean, target: Target): string[];
+export declare function isNonRecommendedAttribute(attributeName: string): boolean;
+export declare function getAttributeDefinition(attributeName: string, promptType: PromptsType, target: Target): IAttributeDefinition | 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, IAttributeDefinition>;
+/**
+ * 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, IAttributeDefinition>;
+export declare function isVSCodeOrDefaultTarget(target: Target): boolean;
+export declare function getTarget(promptType: PromptsType, header: PromptHeader | URI): Target;
+export {};