@codingame/monaco-vscode-api 32.0.1 → 33.0.3

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

@@ -0,0 +1,329 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../../../../base/common/cancellation.js';
+import { CancellationError } from '../../../../../../base/common/errors.js';
+import { Emitter } from '../../../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
+import { ResourceMap } from '../../../../../../base/common/map.js';
+import { IModelService } from '../../../../../../editor/common/services/model.service.js';
+import { ContextKeyExpr } from '../../../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../../../platform/contextkey/common/contextkey.service.js';
+import { IFileService } from '../../../../../../platform/files/common/files.service.js';
+import { ILogService } from '../../../../../../platform/log/common/log.service.js';
+import { IExtensionService } from '../../../../../services/extensions/common/extensions.service.js';
+import { IFilesConfigurationService } from '../../../../../services/filesConfiguration/common/filesConfigurationService.service.js';
+import { getSkillFolderName } from '../config/promptFileLocations.js';
+import { PromptFileParser } from '../promptFileParser.js';
+import { PromptsType, PromptFileSource } from '../promptTypes.js';
+import { PromptsStorage, SKILL_PROVIDER_ACTIVATION_EVENT, PROMPT_FILE_PROVIDER_ACTIVATION_EVENT, INSTRUCTIONS_PROVIDER_ACTIVATION_EVENT, CUSTOM_AGENT_PROVIDER_ACTIVATION_EVENT } from './promptsService.js';
+
+const ALL_PROMPT_TYPES = [
+    PromptsType.prompt,
+    PromptsType.instructions,
+    PromptsType.agent,
+    PromptsType.skill,
+    PromptsType.hook
+];
+let ExtensionPromptFileService = class ExtensionPromptFileService extends Disposable {
+    constructor(
+        logger,
+        fileService,
+        modelService,
+        extensionService,
+        filesConfigService,
+        contextKeyService
+    ) {
+        super();
+        this.logger = logger;
+        this.fileService = fileService;
+        this.modelService = modelService;
+        this.extensionService = extensionService;
+        this.filesConfigService = filesConfigService;
+        this.contextKeyService = contextKeyService;
+        this.contributedFiles = {
+            [PromptsType.prompt]: ( new ResourceMap()),
+            [PromptsType.instructions]: ( new ResourceMap()),
+            [PromptsType.agent]: ( new ResourceMap()),
+            [PromptsType.skill]: ( new ResourceMap()),
+            [PromptsType.hook]: ( new ResourceMap())
+        };
+        this._promptFileProviders = [];
+        this._contributedWhenKeys = ( new Set());
+        this._contributedWhenClauses = ( new Map());
+        this._providerWhenClauses = ( new Map());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._pendingReadonlyUris = [];
+        this._pendingReadonlyFlush = false;
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(this._contributedWhenKeys)) {
+                for (const type of ALL_PROMPT_TYPES) {
+                    this._onDidChange.fire({
+                        type
+                    });
+                }
+            }
+        }));
+    }
+    async getExtensionPromptFiles(type, token) {
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const settledResults = await Promise.allSettled(( this.contributedFiles[type].values()));
+        const contributedFiles = ( settledResults.filter(result => result.status === "fulfilled").map(result => result.value));
+        const activationEvent = this._getProviderActivationEvent(type);
+        const providerFiles = activationEvent ? await this._listFromProviders(type, activationEvent, token) : [];
+        return [...contributedFiles, ...providerFiles].filter(file => {
+            if (!file.when) {
+                return true;
+            }
+            const when = ContextKeyExpr.deserialize(file.when);
+            if (!when) {
+                this.logger.warn(
+                    `[getExtensionPromptFiles] Ignoring contributed prompt file with invalid when clause: ${file.when}`
+                );
+                return false;
+            }
+            return this.contextKeyService.contextMatchesRules(when);
+        });
+    }
+    registerContributedFile(type, uri, extension, name, description, when, sessionTypes) {
+        const bucket = this.contributedFiles[type];
+        if (( bucket.has(uri))) {
+            return Disposable.None;
+        }
+        const entryPromise = (async () => {
+            if (type === PromptsType.skill) {
+                try {
+                    const validated = await this._validateAndSanitizeSkillFile(uri, CancellationToken.None);
+                    name = validated.name;
+                    description = validated.description;
+                } catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    this.logger.error(
+                        `[registerContributedFile] Extension '${extension.identifier.value}' failed to validate skill file: ${uri}`,
+                        msg
+                    );
+                    throw e;
+                }
+            }
+            return {
+                uri,
+                name,
+                description,
+                when,
+                sessionTypes,
+                storage: PromptsStorage.extension,
+                type,
+                extension,
+                source: PromptFileSource.ExtensionContribution
+            };
+        })();
+        bucket.set(uri, entryPromise);
+        this._enqueueReadonlyUpdate(uri);
+        if (when) {
+            this._contributedWhenClauses.set(`${type}/${( uri.toString())}`, when);
+            this._updateContributedWhenKeys();
+        }
+        this._onDidChange.fire({
+            type
+        });
+        return {
+            dispose: () => {
+                bucket.delete(uri);
+                if (when) {
+                    this._contributedWhenClauses.delete(`${type}/${( uri.toString())}`);
+                    this._updateContributedWhenKeys();
+                }
+                this._onDidChange.fire({
+                    type
+                });
+            }
+        };
+    }
+    registerPromptFileProvider(extension, type, provider) {
+        const providerEntry = {
+            extension,
+            type,
+            ...provider
+        };
+        this._promptFileProviders.push(providerEntry);
+        const disposables = ( new DisposableStore());
+        if (provider.onDidChangePromptFiles) {
+            disposables.add(provider.onDidChangePromptFiles(() => {
+                this._onDidChange.fire({
+                    type
+                });
+            }));
+        }
+        this._onDidChange.fire({
+            type
+        });
+        disposables.add({
+            dispose: () => {
+                const index = this._promptFileProviders.findIndex(p => p === providerEntry);
+                if (index >= 0) {
+                    this._promptFileProviders.splice(index, 1);
+                    this._providerWhenClauses.delete(providerEntry);
+                    this._updateContributedWhenKeys();
+                    this._onDidChange.fire({
+                        type
+                    });
+                }
+            }
+        });
+        return disposables;
+    }
+    async _listFromProviders(type, activationEvent, token) {
+        const result = [];
+        const readonlyUris = [];
+        await this.extensionService.activateByEvent(activationEvent);
+        const providers = this._promptFileProviders.filter(p => p.type === type);
+        if (providers.length === 0) {
+            return result;
+        }
+        for (const providerEntry of providers) {
+            try {
+                const files = await providerEntry.providePromptFiles({}, token);
+                this._providerWhenClauses.set(providerEntry, files?.flatMap(file => file.when ? [file.when] : []) ?? []);
+                this._updateContributedWhenKeys();
+                if (!files || token.isCancellationRequested) {
+                    continue;
+                }
+                for (const file of files) {
+                    readonlyUris.push(file.uri);
+                    result.push({
+                        uri: file.uri,
+                        storage: PromptsStorage.extension,
+                        type,
+                        extension: providerEntry.extension,
+                        source: PromptFileSource.ExtensionAPI,
+                        name: file.name,
+                        description: file.description,
+                        when: file.when,
+                        sessionTypes: file.sessionTypes
+                    });
+                }
+            } catch (e) {
+                this.logger.error(
+                    `[listFromProviders] Failed to get ${type} files from provider`,
+                    e instanceof Error ? e.message : String(e)
+                );
+            }
+        }
+        void this.filesConfigService.updateReadonly(readonlyUris, true);
+        return result;
+    }
+    _getProviderActivationEvent(type) {
+        switch (type) {
+        case PromptsType.agent:
+            return CUSTOM_AGENT_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.instructions:
+            return INSTRUCTIONS_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.prompt:
+            return PROMPT_FILE_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.skill:
+            return SKILL_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.hook:
+            return undefined;
+        }
+    }
+    _enqueueReadonlyUpdate(uri) {
+        this._pendingReadonlyUris.push(uri);
+        if (!this._pendingReadonlyFlush) {
+            this._pendingReadonlyFlush = true;
+            queueMicrotask(() => {
+                const uris = this._pendingReadonlyUris;
+                this._pendingReadonlyUris = [];
+                this._pendingReadonlyFlush = false;
+                void this.filesConfigService.updateReadonly(uris, true);
+            });
+        }
+    }
+    _updateContributedWhenKeys() {
+        this._contributedWhenKeys.clear();
+        for (const whenClause of ( this._contributedWhenClauses.values())) {
+            const expr = ContextKeyExpr.deserialize(whenClause);
+            for (const key of expr?.keys() ?? []) {
+                this._contributedWhenKeys.add(key);
+            }
+        }
+        for (const whenClauses of ( this._providerWhenClauses.values())) {
+            for (const whenClause of whenClauses) {
+                const expr = ContextKeyExpr.deserialize(whenClause);
+                for (const key of expr?.keys() ?? []) {
+                    this._contributedWhenKeys.add(key);
+                }
+            }
+        }
+    }
+    async _validateAndSanitizeSkillFile(uri, token) {
+        const parsedFile = await this._parsePromptFile(uri, token);
+        const folderName = getSkillFolderName(uri);
+        let name = parsedFile.header?.name;
+        if (!name) {
+            this.logger.debug(
+                `[validateAndSanitizeSkillFile] Agent skill file missing name attribute, using folder name "${folderName}": ${uri}`
+            );
+            name = folderName;
+        }
+        const description = parsedFile.header?.description;
+        let sanitizedName = this._truncateAgentSkillName(name, uri);
+        if (sanitizedName !== folderName) {
+            this.logger.debug(
+                `[validateAndSanitizeSkillFile] Agent skill name "${sanitizedName}" does not match folder name "${folderName}", using folder name: ${uri}`
+            );
+            sanitizedName = folderName;
+        }
+        const sanitizedDescription = description ? this._truncateAgentSkillDescription(description, uri) : undefined;
+        return {
+            name: sanitizedName,
+            description: sanitizedDescription
+        };
+    }
+    async _parsePromptFile(uri, token) {
+        const model = this.modelService.getModel(uri);
+        if (model) {
+            return ( new PromptFileParser()).parse(uri, model.getValue());
+        }
+        const fileContent = await this.fileService.readFile(uri);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        return ( new PromptFileParser()).parse(uri, ( fileContent.value.toString()));
+    }
+    _sanitizeAgentSkillText(text) {
+        return text.replace(/<[^>]+>/g, "");
+    }
+    _truncateAgentSkillName(name, uri) {
+        const MAX_NAME_LENGTH = 64;
+        const sanitized = this._sanitizeAgentSkillText(name);
+        if (sanitized !== name) {
+            this.logger.debug(`[findAgentSkills] Agent skill name contains XML tags, removed: ${uri}`);
+        }
+        if (sanitized.length > MAX_NAME_LENGTH) {
+            this.logger.debug(
+                `[findAgentSkills] Agent skill name exceeds ${MAX_NAME_LENGTH} characters, truncated: ${uri}`
+            );
+            return sanitized.substring(0, MAX_NAME_LENGTH);
+        }
+        return sanitized;
+    }
+    _truncateAgentSkillDescription(description, uri) {
+        const MAX_DESCRIPTION_LENGTH = 1024;
+        const sanitized = this._sanitizeAgentSkillText(description);
+        if (sanitized !== description) {
+            this.logger.debug(
+                `[findAgentSkills] Agent skill description contains XML tags, removed: ${uri}`
+            );
+        }
+        if (sanitized.length > MAX_DESCRIPTION_LENGTH) {
+            this.logger.debug(
+                `[findAgentSkills] Agent skill description exceeds ${MAX_DESCRIPTION_LENGTH} characters, truncated: ${uri}`
+            );
+            return sanitized.substring(0, MAX_DESCRIPTION_LENGTH);
+        }
+        return sanitized;
+    }
+};
+ExtensionPromptFileService = ( __decorate([( __param(0, ILogService)), ( __param(1, IFileService)), ( __param(2, IModelService)), ( __param(3, IExtensionService)), ( __param(4, IFilesConfigurationService)), ( __param(5, IContextKeyService))], ExtensionPromptFileService));
+
+export { ExtensionPromptFileService };

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

@@ -8,11 +8,9 @@ import { IModelService } from "../../../../../../editor/common/services/model.se
 import { IConfigurationService } from "../../../../../../platform/configuration/common/configuration.service.js";
 import { IExtensionDescription } from "../../../../../../platform/extensions/common/extensions.js";
 import { IFileService } from "../../../../../../platform/files/common/files.service.js";
-import { IExtensionService } from "../../../../../services/extensions/common/extensions.service.js";
 import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
 import { ILabelService } from "../../../../../../platform/label/common/label.service.js";
 import { ILogService } from "../../../../../../platform/log/common/log.service.js";
-import { IFilesConfigurationService } from "../../../../../services/filesConfiguration/common/filesConfigurationService.service.js";
 import { IStorageService } from "../../../../../../platform/storage/common/storage.service.js";
 import { ITelemetryService } from "../../../../../../platform/telemetry/common/telemetry.service.js";
 import { IUserDataProfileService } from "../../../../../services/userDataProfile/common/userDataProfile.service.js";
@@ -26,7 +24,6 @@ import { ChatRequestHooks } from "../hookSchema.js";
 import { IWorkspaceContextService } from "../../../../../../platform/workspace/common/workspace.service.js";
 import { IWorkspaceTrustManagementService } from "../../../../../../platform/workspace/common/workspaceTrust.service.js";
 import { IPathService } from "../../../../../services/path/common/pathService.service.js";
-import { IContextKeyService } from "../../../../../../platform/contextkey/common/contextkey.service.js";
 import { IAgentPluginService } from "../../plugins/agentPluginService.service.js";
 /**
  * Provides prompt services.
@@ -39,13 +36,10 @@ export declare class PromptsService extends Disposable implements IPromptsServic
     private readonly userDataService;
     private readonly configurationService;
     protected readonly fileService: IFileService;
-    private readonly filesConfigService;
     private readonly storageService;
-    private readonly extensionService;
     private readonly telemetryService;
     private readonly workspaceService;
     protected readonly pathService: IPathService;
-    private readonly contextKeyService;
     private readonly agentPluginService;
     private readonly workspaceTrustService;
     readonly _serviceBrand: undefined;
@@ -89,29 +83,14 @@ export declare class PromptsService extends Disposable implements IPromptsServic
      */
     private readonly fileLocatorEvents;
     /**
-     * Contributed files from extensions keyed by prompt type then name.
+     * Owns the registry of extension-contributed prompt files (both via
+     * contribution points and via provider API).
      */
-    private readonly contributedFiles;
-    /**
-     * Context keys referenced by contributed and provider-supplied `when` clauses.
-     */
-    private readonly _contributedWhenKeys;
-    private readonly _contributedWhenClauses;
-    private readonly _providerWhenClauses;
-    private readonly _onDidContributedWhenChange;
-    private readonly _onDidChangeInstructions;
+    private readonly extensionPromptFiles;
     private readonly _onDidPluginPromptFilesChange;
     private readonly _onDidPluginHooksChange;
     private _pluginPromptFilesByType;
-    /**
-     * Pending URIs to mark as readonly, flushed on the next microtask.
-     * This batches multiple `registerContributedFile` calls (which happen
-     * synchronously in the extension point handler) into a single
-     * `updateReadonly` call to avoid firing `onDidChangeReadonly` per file.
-     */
-    private _pendingReadonlyUris;
-    private _pendingReadonlyFlush;
-    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService, configurationService: IConfigurationService, fileService: IFileService, filesConfigService: IFilesConfigurationService, storageService: IStorageService, extensionService: IExtensionService, telemetryService: ITelemetryService, workspaceService: IWorkspaceContextService, pathService: IPathService, contextKeyService: IContextKeyService, agentPluginService: IAgentPluginService, workspaceTrustService: IWorkspaceTrustManagementService);
+    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService, configurationService: IConfigurationService, fileService: IFileService, storageService: IStorageService, telemetryService: ITelemetryService, workspaceService: IWorkspaceContextService, pathService: IPathService, agentPluginService: IAgentPluginService, workspaceTrustService: IWorkspaceTrustManagementService);
     private watchPluginPromptFilesForType;
     protected createPromptFilesLocator(): PromptFilesLocator;
     private getFileLocatorEvent;
@@ -122,11 +101,6 @@ export declare class PromptsService extends Disposable implements IPromptsServic
      * Collects diagnostic information about which source folders were searched for display in the debug panel.
      */
     private _collectSourceFolderDiagnostics;
-    /**
-     * Registry of prompt file provider instances (custom agents, instructions, prompt files).
-     * Extensions can register providers via the proposed API.
-     */
-    private readonly promptFileProviders;
     /**
      * Registers a prompt file provider (CustomAgentProvider, InstructionsProvider, or PromptFileProvider).
      * This will be called by the extension host bridge when
@@ -137,14 +111,8 @@ export declare class PromptsService extends Disposable implements IPromptsServic
         onDidChangePromptFiles?: Event<void>;
         providePromptFiles: (context: IPromptFileContext, token: CancellationToken) => Promise<IPromptFileResource[] | undefined>;
     }): IDisposable;
-    private invalidatePromptFileCache;
-    /**
-     * Shared helper to list prompt files from registered providers for a given type.
-     */
-    private listFromProviders;
     listPromptFilesForStorage(type: PromptsType, storage: PromptsStorage, token: CancellationToken): Promise<readonly IPromptPath[]>;
     private getExtensionPromptFiles;
-    private getProviderActivationEvent;
     getSourceFolders(type: PromptsType): Promise<readonly IPromptPath[]>;
     getResolvedSourceFolders(type: PromptsType): Promise<readonly IResolvedPromptSourceFolder[]>;
     /**
@@ -176,9 +144,7 @@ export declare class PromptsService extends Disposable implements IPromptsServic
     private agentsFromDiscoveryInfo;
     private computeAgentDiscoveryInfo;
     parseNew(uri: URI, token: CancellationToken): Promise<ParsedPromptFile>;
-    registerContributedFile(type: PromptsType, uri: URI, extension: IExtensionDescription, name?: string, description?: string, when?: string, sessionTypes?: readonly string[]): Readonly<IDisposable>;
-    private _enqueueReadonlyUpdate;
-    private _updateContributedWhenKeys;
+    registerContributedFile(type: PromptsType, uri: URI, extension: IExtensionDescription, name?: string, description?: string, when?: string, sessionTypes?: readonly string[]): IDisposable;
     getPromptLocationLabel(promptPath: IPromptPath): string;
     listNestedAgentMDs(token: CancellationToken): Promise<IAgentInstructionFile[]>;
     listAgentInstructions(token: CancellationToken, logger: Logger | undefined): Promise<IAgentInstructionFile[]>;
@@ -187,11 +153,6 @@ export declare class PromptsService extends Disposable implements IPromptsServic
     getDisabledPromptFiles(type: PromptsType): ResourceSet;
     setDisabledPromptFiles(type: PromptsType, uris: ResourceSet): void;
     private sanitizeAgentSkillText;
-    /**
-     * Validates and sanitizes a skill file. Throws an error if validation fails.
-     * @returns The sanitized name and description
-     */
-    private validateAndSanitizeSkillFile;
     private truncateAgentSkillName;
     private truncateAgentSkillDescription;
     get onDidChangeSkills(): Event<void>;