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

package/vscode/src/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.js

@@ -0,0 +1,478 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { isEqualOrParent, joinPath, normalizePath, relativePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IAgentPluginRepositoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service';
+
+var MarketplaceType;
+(function(MarketplaceType) {
+    MarketplaceType["Copilot"] = "copilot";
+    MarketplaceType["Claude"] = "claude";
+})(MarketplaceType || (MarketplaceType = {}));
+var MarketplaceReferenceKind;
+(function(MarketplaceReferenceKind) {
+    MarketplaceReferenceKind["GitHubShorthand"] = "githubShorthand";
+    MarketplaceReferenceKind["GitUri"] = "gitUri";
+    MarketplaceReferenceKind["LocalFileUri"] = "localFileUri";
+})(MarketplaceReferenceKind || (MarketplaceReferenceKind = {}));
+const MARKETPLACE_DEFINITIONS = [{
+    type: MarketplaceType.Copilot,
+    path: ".github/plugin/marketplace.json"
+}, {
+    type: MarketplaceType.Claude,
+    path: ".claude-plugin/marketplace.json"
+}];
+const GITHUB_MARKETPLACE_CACHE_TTL_MS = 8 * 60 * 60 * 1000;
+const GITHUB_MARKETPLACE_CACHE_STORAGE_KEY = "chat.plugins.marketplaces.githubCache.v1";
+let PluginMarketplaceService = class PluginMarketplaceService {
+    constructor(
+        _configurationService,
+        _requestService,
+        _fileService,
+        _pluginRepositoryService,
+        _logService,
+        _storageService
+    ) {
+        this._configurationService = _configurationService;
+        this._requestService = _requestService;
+        this._fileService = _fileService;
+        this._pluginRepositoryService = _pluginRepositoryService;
+        this._logService = _logService;
+        this._storageService = _storageService;
+        this._gitHubMarketplaceCache = ( new Lazy(() => this._loadPersistedGitHubMarketplaceCache()));
+        this.onDidChangeMarketplaces = Event.filter(
+            _configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration(ChatConfiguration.PluginsEnabled) || e.affectsConfiguration(ChatConfiguration.PluginMarketplaces)
+        );
+    }
+    async fetchMarketplacePlugins(token) {
+        if (!this._configurationService.getValue(ChatConfiguration.PluginsEnabled)) {
+            return [];
+        }
+        const configuredRefs = this._configurationService.getValue(ChatConfiguration.PluginMarketplaces) ?? [];
+        const refs = parseMarketplaceReferences(configuredRefs);
+        for (const value of configuredRefs) {
+            if (typeof value !== "string" || !parseMarketplaceReference(value)) {
+                this._logService.debug(
+                    `[PluginMarketplaceService] Ignoring invalid marketplace entry: ${String(value)}`
+                );
+            }
+        }
+        const results = await Promise.all(( refs.map(ref => {
+            if (ref.kind === MarketplaceReferenceKind.GitHubShorthand && ref.githubRepo) {
+                return this._fetchFromGitHubRepo(ref, ref.githubRepo, token);
+            }
+            return this._fetchFromClonedRepo(ref, token);
+        })));
+        return results.flat();
+    }
+    async _fetchFromGitHubRepo(reference, repo, token) {
+        const cache = this._gitHubMarketplaceCache.value;
+        const cached = this._getCachedGitHubMarketplacePlugins(cache, reference.canonicalId);
+        if (cached) {
+            return cached;
+        }
+        let repoMayBePrivate = true;
+        for (const def of MARKETPLACE_DEFINITIONS) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            const url = `https://raw.githubusercontent.com/${repo}/main/${def.path}`;
+            try {
+                const context = await this._requestService.request({
+                    type: "GET",
+                    url
+                }, token);
+                const statusCode = context.res.statusCode;
+                if (statusCode !== 200) {
+                    repoMayBePrivate &&= statusCode !== undefined && statusCode >= 400 && statusCode < 500;
+                    this._logService.debug(
+                        `[PluginMarketplaceService] ${url} returned status ${statusCode}, skipping`
+                    );
+                    continue;
+                }
+                const json = await asJson(context);
+                if (!json?.plugins || !Array.isArray(json.plugins)) {
+                    this._logService.debug(
+                        `[PluginMarketplaceService] ${url} did not contain a valid plugins array, skipping`
+                    );
+                    continue;
+                }
+                const plugins = json.plugins.filter(p => typeof p.name === "string" && !!p.name).flatMap(p => {
+                    const source = resolvePluginSource(json.metadata?.pluginRoot, p.source ?? "");
+                    if (source === undefined) {
+                        this._logService.warn(
+                            `[PluginMarketplaceService] Skipping plugin '${p.name}' in ${repo}: invalid source path '${p.source ?? ""}' with pluginRoot '${json.metadata?.pluginRoot ?? ""}'`
+                        );
+                        return [];
+                    }
+                    return [{
+                        name: p.name,
+                        description: p.description ?? "",
+                        version: p.version ?? "",
+                        source,
+                        marketplace: reference.displayLabel,
+                        marketplaceReference: reference,
+                        marketplaceType: def.type,
+                        readmeUri: getMarketplaceReadmeUri(repo, source)
+                    }];
+                });
+                cache.set(reference.canonicalId, {
+                    plugins,
+                    expiresAt: Date.now() + GITHUB_MARKETPLACE_CACHE_TTL_MS,
+                    referenceRawValue: reference.rawValue
+                });
+                this._savePersistedGitHubMarketplaceCache(cache);
+                return plugins;
+            } catch (err) {
+                this._logService.debug(
+                    `[PluginMarketplaceService] Failed to fetch marketplace.json from ${url}:`,
+                    err
+                );
+                continue;
+            }
+        }
+        if (repoMayBePrivate) {
+            this._logService.debug(
+                `[PluginMarketplaceService] ${repo} may be private, attempting clone-based marketplace discovery`
+            );
+            return this._fetchFromClonedRepo(reference, token);
+        }
+        this._logService.debug(`[PluginMarketplaceService] No marketplace.json found in ${repo}`);
+        return [];
+    }
+    _getCachedGitHubMarketplacePlugins(cache, cacheKey) {
+        const cached = cache.get(cacheKey);
+        if (!cached) {
+            return undefined;
+        }
+        if (cached.expiresAt <= Date.now()) {
+            cache.delete(cacheKey);
+            this._savePersistedGitHubMarketplaceCache(cache);
+            return undefined;
+        }
+        return [...cached.plugins];
+    }
+    _loadPersistedGitHubMarketplaceCache() {
+        const cache = ( new Map());
+        const now = Date.now();
+        const stored = this._storageService.getObject(GITHUB_MARKETPLACE_CACHE_STORAGE_KEY, StorageScope.APPLICATION);
+        if (!stored) {
+            return cache;
+        }
+        const revived = revive(stored);
+        for (const [cacheKey, entry] of Object.entries(revived)) {
+            if (!entry || !Array.isArray(entry.plugins) || typeof entry.expiresAt !== "number" || entry.expiresAt <= now || typeof entry.referenceRawValue !== "string") {
+                continue;
+            }
+            const reference = parseMarketplaceReference(entry.referenceRawValue);
+            if (!reference) {
+                continue;
+            }
+            const plugins = ( entry.plugins.map(plugin => ({
+                ...plugin,
+                marketplace: reference.displayLabel,
+                marketplaceReference: reference
+            })));
+            cache.set(cacheKey, {
+                plugins,
+                expiresAt: entry.expiresAt,
+                referenceRawValue: entry.referenceRawValue
+            });
+        }
+        return cache;
+    }
+    _savePersistedGitHubMarketplaceCache(cache) {
+        const serialized = {};
+        for (const [cacheKey, entry] of cache) {
+            if (!entry.plugins.length || entry.expiresAt <= Date.now()) {
+                continue;
+            }
+            serialized[cacheKey] = {
+                expiresAt: entry.expiresAt,
+                referenceRawValue: entry.referenceRawValue,
+                plugins: entry.plugins
+            };
+        }
+        if (( Object.keys(serialized)).length === 0) {
+            this._storageService.remove(GITHUB_MARKETPLACE_CACHE_STORAGE_KEY, StorageScope.APPLICATION);
+            return;
+        }
+        this._storageService.store(
+            GITHUB_MARKETPLACE_CACHE_STORAGE_KEY,
+            JSON.stringify(serialized),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+    async getMarketplacePluginMetadata(pluginUri) {
+        const configuredRefs = this._configurationService.getValue(ChatConfiguration.PluginMarketplaces) ?? [];
+        const refs = parseMarketplaceReferences(configuredRefs);
+        for (const ref of refs) {
+            let repoDir;
+            try {
+                repoDir = this._pluginRepositoryService.getRepositoryUri(ref);
+            } catch {
+                continue;
+            }
+            if (!isEqualOrParent(pluginUri, repoDir)) {
+                continue;
+            }
+            for (const def of MARKETPLACE_DEFINITIONS) {
+                const definitionUri = joinPath(repoDir, def.path);
+                let json;
+                try {
+                    const contents = await this._fileService.readFile(definitionUri);
+                    json = parse(( contents.value.toString()));
+                } catch {
+                    continue;
+                }
+                if (!json?.plugins || !Array.isArray(json.plugins)) {
+                    continue;
+                }
+                for (const p of json.plugins) {
+                    if (typeof p.name !== "string" || !p.name) {
+                        continue;
+                    }
+                    const source = resolvePluginSource(json.metadata?.pluginRoot, p.source ?? "");
+                    if (source === undefined) {
+                        continue;
+                    }
+                    const pluginSourceUri = normalizePath(joinPath(repoDir, source));
+                    if (isEqualOrParent(pluginUri, pluginSourceUri)) {
+                        return {
+                            name: p.name,
+                            description: p.description ?? "",
+                            version: p.version ?? "",
+                            source,
+                            marketplace: ref.displayLabel,
+                            marketplaceReference: ref,
+                            marketplaceType: def.type,
+                            readmeUri: getMarketplaceReadmeFileUri(repoDir, source)
+                        };
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    async _fetchFromClonedRepo(reference, token) {
+        let repoDir;
+        try {
+            repoDir = await this._pluginRepositoryService.ensureRepository(reference);
+        } catch (err) {
+            this._logService.debug(
+                `[PluginMarketplaceService] Failed to prepare marketplace repository ${reference.rawValue}:`,
+                err
+            );
+            return [];
+        }
+        for (const def of MARKETPLACE_DEFINITIONS) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            const definitionUri = joinPath(repoDir, def.path);
+            let json;
+            try {
+                const contents = await this._fileService.readFile(definitionUri);
+                json = parse(( contents.value.toString()));
+            } catch {
+                continue;
+            }
+            if (!json?.plugins || !Array.isArray(json.plugins)) {
+                this._logService.debug(`[PluginMarketplaceService] ${( definitionUri.toString())} did not contain a valid plugins array, skipping`);
+                continue;
+            }
+            return json.plugins.filter(p => typeof p.name === "string" && !!p.name).flatMap(p => {
+                const source = resolvePluginSource(json.metadata?.pluginRoot, p.source ?? "");
+                if (source === undefined) {
+                    this._logService.warn(
+                        `[PluginMarketplaceService] Skipping plugin '${p.name}' in ${reference.rawValue}: invalid source path '${p.source ?? ""}' with pluginRoot '${json.metadata?.pluginRoot ?? ""}'`
+                    );
+                    return [];
+                }
+                return [{
+                    name: p.name,
+                    description: p.description ?? "",
+                    version: p.version ?? "",
+                    source,
+                    marketplace: reference.displayLabel,
+                    marketplaceReference: reference,
+                    marketplaceType: def.type,
+                    readmeUri: getMarketplaceReadmeFileUri(repoDir, source)
+                }];
+            });
+        }
+        this._logService.debug(
+            `[PluginMarketplaceService] No marketplace.json found in ${reference.rawValue}`
+        );
+        return [];
+    }
+};
+PluginMarketplaceService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IRequestService)), ( __param(2, IFileService)), ( __param(3, IAgentPluginRepositoryService)), ( __param(4, ILogService)), ( __param(5, IStorageService))], PluginMarketplaceService));
+function parseMarketplaceReferences(values) {
+    const byCanonicalId = ( new Map());
+    for (const value of values) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const parsed = parseMarketplaceReference(value);
+        if (!parsed) {
+            continue;
+        }
+        if (!( byCanonicalId.has(parsed.canonicalId))) {
+            byCanonicalId.set(parsed.canonicalId, parsed);
+        }
+    }
+    return [...( byCanonicalId.values())];
+}
+function parseMarketplaceReference(value) {
+    const rawValue = value.trim();
+    if (!rawValue) {
+        return undefined;
+    }
+    const uriReference = parseUriMarketplaceReference(rawValue);
+    if (uriReference) {
+        return uriReference;
+    }
+    const scpReference = parseScpMarketplaceReference(rawValue);
+    if (scpReference) {
+        return scpReference;
+    }
+    const shorthandMatch = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(rawValue);
+    if (shorthandMatch) {
+        const owner = shorthandMatch[1];
+        const repo = shorthandMatch[2];
+        return {
+            rawValue,
+            displayLabel: `${owner}/${repo}`,
+            cloneUrl: `https://github.com/${owner}/${repo}.git`,
+            canonicalId: getGitHubCanonicalId(owner, repo),
+            cacheSegments: ["github.com", owner, repo],
+            kind: MarketplaceReferenceKind.GitHubShorthand,
+            githubRepo: `${owner}/${repo}`
+        };
+    }
+    return undefined;
+}
+function parseUriMarketplaceReference(rawValue) {
+    let uri;
+    try {
+        uri = ( URI.parse(rawValue));
+    } catch {
+        return undefined;
+    }
+    const scheme = uri.scheme.toLowerCase();
+    if (scheme === "file" && /^file:\/\//i.test(rawValue)) {
+        const localRepositoryUri = URI.file(uri.fsPath);
+        return {
+            rawValue,
+            displayLabel: localRepositoryUri.fsPath,
+            cloneUrl: rawValue,
+            canonicalId: `file:${( localRepositoryUri.toString()).toLowerCase()}`,
+            cacheSegments: [],
+            kind: MarketplaceReferenceKind.LocalFileUri,
+            localRepositoryUri
+        };
+    }
+    if (scheme !== "http" && scheme !== "https" && scheme !== "ssh") {
+        return undefined;
+    }
+    if (!uri.authority) {
+        return undefined;
+    }
+    const normalizedPath = normalizeGitRepoPath(uri.path);
+    if (!normalizedPath) {
+        return undefined;
+    }
+    const sanitizedAuthority = sanitizePathSegment(uri.authority.toLowerCase());
+    const pathSegments = ( normalizedPath.slice(1, -4).split("/").map(sanitizePathSegment));
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: rawValue,
+        canonicalId: `git:${uri.authority.toLowerCase()}/${normalizedPath.slice(1).toLowerCase()}`,
+        cacheSegments: [sanitizedAuthority, ...pathSegments],
+        kind: MarketplaceReferenceKind.GitUri
+    };
+}
+function parseScpMarketplaceReference(rawValue) {
+    const match = /^([^@\s]+)@([^:\s]+):(.+\.git)$/i.exec(rawValue);
+    if (!match) {
+        return undefined;
+    }
+    const authority = match[2];
+    const pathWithGit = match[3].replace(/^\/+/, "");
+    if (!pathWithGit.toLowerCase().endsWith(".git")) {
+        return undefined;
+    }
+    const pathSegments = ( pathWithGit.slice(0, -4).split("/").map(sanitizePathSegment));
+    return {
+        rawValue,
+        displayLabel: rawValue,
+        cloneUrl: rawValue,
+        canonicalId: `git:${authority.toLowerCase()}/${pathWithGit.toLowerCase()}`,
+        cacheSegments: [sanitizePathSegment(authority.toLowerCase()), ...pathSegments],
+        kind: MarketplaceReferenceKind.GitUri
+    };
+}
+function normalizeGitRepoPath(path) {
+    const trimmed = path.replace(/\/+/g, "/").replace(/\/+$/g, "");
+    if (!trimmed.toLowerCase().endsWith(".git")) {
+        return undefined;
+    }
+    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    const pathWithoutGit = withLeadingSlash.slice(1, -4);
+    if (!pathWithoutGit || !pathWithoutGit.includes("/")) {
+        return undefined;
+    }
+    return withLeadingSlash;
+}
+function getGitHubCanonicalId(owner, repo) {
+    return `github:${owner.toLowerCase()}/${repo.toLowerCase()}`;
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[\\/:*?"<>|]/g, "_");
+}
+function normalizeMarketplacePath(value) {
+    let normalized = value.trim().replace(/\\/g, "/");
+    normalized = normalized.replace(/^\.?\/+/, "").replace(/\/+$/g, "");
+    return normalized;
+}
+function resolvePluginSource(pluginRoot, source) {
+    const normalizedRoot = pluginRoot ? normalizeMarketplacePath(pluginRoot) : "";
+    const normalizedSource = normalizeMarketplacePath(source);
+    const repoRoot = URI.file("/");
+    const pluginRootUri = normalizedRoot ? normalizePath(joinPath(repoRoot, normalizedRoot)) : repoRoot;
+    if (!normalizedSource) {
+        return normalizedRoot || undefined;
+    }
+    if (normalizedRoot && (normalizedSource === normalizedRoot || normalizedSource.startsWith(`${normalizedRoot}/`))) {
+        return normalizedSource;
+    }
+    const resolvedUri = normalizePath(joinPath(pluginRootUri, normalizedSource));
+    return relativePath(repoRoot, resolvedUri) ?? undefined;
+}
+function getMarketplaceReadmeUri(repo, source) {
+    const normalizedSource = source.trim().replace(/^\.?\/+|\/+$/g, "");
+    const readmePath = normalizedSource ? `${normalizedSource}/README.md` : "README.md";
+    return ( URI.parse(`https://github.com/${repo}/blob/main/${readmePath}`));
+}
+function getMarketplaceReadmeFileUri(repoDir, source) {
+    const normalizedSource = source.trim().replace(/^\.?\/+|\/+$/g, "");
+    return normalizedSource ? joinPath(repoDir, normalizedSource, "README.md") : joinPath(repoDir, "README.md");
+}
+
+export { MarketplaceReferenceKind, MarketplaceType, PluginMarketplaceService, parseMarketplaceReference, parseMarketplaceReferences };

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

@@ -12,6 +12,7 @@ import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 
 var ChatContributionPoint;
 (function(ChatContributionPoint) {
@@ -24,30 +25,37 @@ function registerChatFilesExtensionPoint(point) {
     return ExtensionsRegistry.registerExtensionPoint({
         extensionPoint: point,
         jsonSchema: {
-            description: ( localize(6354, "Contributes {0} for chat prompts.", point)),
+            description: ( localize(6906, "Contributes {0} for chat prompts.", point)),
             type: "array",
             items: {
                 additionalProperties: false,
                 type: "object",
                 defaultSnippets: [{
                     body: {
-                        path: "./relative/path/to/file.md"
+                        path: point === ChatContributionPoint.chatSkills ? "./relative/path/to/skill-name/SKILL.md" : "./relative/path/to/file.md"
                     }
                 }],
                 required: ["path"],
                 properties: {
                     path: {
-                        description: ( localize(6355, "Path to the file relative to the extension root.")),
+                        description: point === ChatContributionPoint.chatSkills ? ( localize(
+                            6907,
+                            "Path to the SKILL.md file relative to the extension root. The folder name must match the \"name\" property in SKILL.md."
+                        )) : ( localize(6908, "Path to the file relative to the extension root.")),
                         type: "string"
                     },
                     name: {
-                        description: ( localize(6356, "(Optional) Name for this entry.")),
-                        deprecationMessage: ( localize(6357, "Specify \"name\" in the prompt file itself instead.")),
+                        description: ( localize(6909, "(Optional) Name for this entry.")),
+                        deprecationMessage: ( localize(6910, "Specify \"name\" in the prompt file itself instead.")),
                         type: "string"
                     },
                     description: {
-                        description: ( localize(6358, "(Optional) Description of the entry.")),
-                        deprecationMessage: ( localize(6359, "Specify \"description\" in the prompt file itself instead.")),
+                        description: ( localize(6911, "(Optional) Description of the entry.")),
+                        deprecationMessage: ( localize(6912, "Specify \"description\" in the prompt file itself instead.")),
+                        type: "string"
+                    },
+                    when: {
+                        description: ( localize(6913, "(Optional) A condition which must be true to enable this entry.")),
                         type: "string"
                     }
                 }
@@ -98,7 +106,7 @@ let ChatPromptFilesExtensionPointHandler = class ChatPromptFilesExtensionPointHa
                 for (const raw of ext.value) {
                     if (!raw.path) {
                         ext.collector.error(( localize(
-                            6360,
+                            6914,
                             "Extension '{0}' cannot register {1} entry without path.",
                             ext.description.identifier.value,
                             contributionPoint
@@ -108,7 +116,7 @@ let ChatPromptFilesExtensionPointHandler = class ChatPromptFilesExtensionPointHa
                     const fileUri = joinPath(ext.description.extensionLocation, raw.path);
                     if (!isEqualOrParent(fileUri, ext.description.extensionLocation)) {
                         ext.collector.error(( localize(
-                            6361,
+                            6915,
                             "Extension '{0}' {1} entry '{2}' resolves outside the extension.",
                             ext.description.identifier.value,
                             contributionPoint,
@@ -116,13 +124,24 @@ let ChatPromptFilesExtensionPointHandler = class ChatPromptFilesExtensionPointHa
                         )));
                         continue;
                     }
+                    if (raw.when && !ContextKeyExpr.deserialize(raw.when)) {
+                        ext.collector.error(( localize(
+                            6916,
+                            "Extension '{0}' {1} entry '{2}' has an invalid when clause: '{3}'.",
+                            ext.description.identifier.value,
+                            contributionPoint,
+                            raw.path,
+                            raw.when
+                        )));
+                        continue;
+                    }
                     try {
-                        const d = this.promptsService.registerContributedFile(type, fileUri, ext.description, raw.name, raw.description);
+                        const d = this.promptsService.registerContributedFile(type, fileUri, ext.description, raw.name, raw.description, raw.when);
                         this.registrations.set(key(ext.description.identifier, type, raw.path), d);
                     } catch (e) {
                         const msg = e instanceof Error ? e.message : String(e);
                         ext.collector.error(( localize(
-                            6362,
+                            6917,
                             "Extension '{0}' {1}. Failed to register {2}: {3}",
                             ext.description.identifier.value,
                             contributionPoint,
@@ -182,7 +201,7 @@ class ChatPromptFilesDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(6363, "Name")), ( localize(6364, "Description")), ( localize(6365, "Path"))];
+        const headers = [( localize(6918, "Name")), ( localize(6919, "Description")), ( localize(6920, "Path"))];
         const rows = ( contributions.map(d => {
             return [d.name ?? "-", d.description ?? "-", d.path];
         }));
@@ -197,7 +216,7 @@ class ChatPromptFilesDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: ChatContributionPoint.chatPromptFiles,
-    label: ( localize(6366, "Chat Prompt Files")),
+    label: ( localize(6921, "Chat Prompt Files")),
     access: {
         canToggle: false
     },
@@ -205,7 +224,7 @@ class ChatPromptFilesDataRenderer extends Disposable {
 });
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: ChatContributionPoint.chatInstructions,
-    label: ( localize(6367, "Chat Instructions")),
+    label: ( localize(6922, "Chat Instructions")),
     access: {
         canToggle: false
     },
@@ -213,7 +232,7 @@ class ChatPromptFilesDataRenderer extends Disposable {
 });
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: ChatContributionPoint.chatAgents,
-    label: ( localize(6368, "Chat Agents")),
+    label: ( localize(6923, "Chat Agents")),
     access: {
         canToggle: false
     },
@@ -221,7 +240,7 @@ class ChatPromptFilesDataRenderer extends Disposable {
 });
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: ChatContributionPoint.chatSkills,
-    label: ( localize(6369, "Chat Skills")),
+    label: ( localize(6924, "Chat Skills")),
     access: {
         canToggle: false
     },

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

@@ -74,35 +74,6 @@ function parseHooksFromFile(fileUri, json, workspaceRootUri, userHome) {
         disabledAllHooks
     };
 }
-function parseHooksIgnoringDisableAll(fileUri, json, workspaceRootUri, userHome) {
-    const format = getHookSourceFormat(fileUri);
-    let hooks;
-    switch (format) {
-    case HookSourceFormat.Claude:
-        {
-            if (json && typeof json === "object") {
-                const {
-                    disableAllHooks: _,
-                    ...rest
-                } = json;
-                const result = parseClaudeHooks(rest, workspaceRootUri, userHome);
-                hooks = result.hooks;
-            } else {
-                hooks = ( new Map());
-            }
-            break;
-        }
-    case HookSourceFormat.Copilot:
-    default:
-        hooks = parseCopilotHooks(json, workspaceRootUri, userHome);
-        break;
-    }
-    return {
-        format,
-        hooks,
-        disabledAllHooks: true
-    };
-}
 function buildNewHookEntry(format) {
     const commandEntry = {
         type: "command",
@@ -117,4 +88,4 @@ function buildNewHookEntry(format) {
     return commandEntry;
 }
 
-export { HookSourceFormat, buildNewHookEntry, getHookSourceFormat, parseCopilotHooks, parseHooksFromFile, parseHooksIgnoringDisableAll };
+export { HookSourceFormat, buildNewHookEntry, getHookSourceFormat, parseCopilotHooks, parseHooksFromFile };

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

@@ -1,9 +1,4 @@
 import { HookType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema";
-/**
- * Maps Copilot CLI hook type names to our abstract HookType.
- * Copilot CLI uses camelCase names.
- */
-export declare const COPILOT_CLI_HOOK_TYPE_MAP: Record<string, HookType>;
 /**
  * Resolves a Copilot CLI hook type name to our abstract HookType.
  */