@codingame/monaco-vscode-chat-service-override 21.6.0 → 22.0.0

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

@@ -1,27 +1,34 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { PromptsType, getPromptsTypeForLanguageId, PROMPT_LANGUAGE_ID, MODE_LANGUAGE_ID, getLanguageIdForPromptsType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
-import { PromptParser } from '../parsers/promptParser.js';
-import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { PromptsType, getPromptsTypeForLanguageId, PROMPT_LANGUAGE_ID, MODE_LANGUAGE_ID } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { PromptFilesLocator } from '../utils/promptFilesLocator.js';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ObjectCache } from '../utils/objectCache.js';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { TextModelPromptParser } from '../parsers/textModelPromptParser.js';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { PromptsStorage } from './promptsService.js';
 import { getCleanPromptName, PROMPT_FILE_EXTENSION } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
 import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
 import { PromptsConfig } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { NewPromptsParser } from './newPromptsParser.js';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { OffsetRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange';
+import { isEqual, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
 
+var ChatModeUpdateTracker_1;
 let PromptsService = class PromptsService extends Disposable {
-    constructor(logger, labelService, modelService, instantiationService, userDataService, languageService, configurationService) {
+    constructor(logger, labelService, modelService, instantiationService, userDataService, languageService, configurationService, fileService, filesConfigService) {
         super();
         this.logger = logger;
         this.labelService = labelService;
@@ -30,43 +37,74 @@ let PromptsService = class PromptsService extends Disposable {
         this.userDataService = userDataService;
         this.languageService = languageService;
         this.configurationService = configurationService;
+        this.fileService = fileService;
+        this.filesConfigService = filesConfigService;
+        this.parsedPromptFileCache = ( new ResourceMap());
+        this.contributedFiles = {
+            [PromptsType.prompt]: ( new ResourceMap()),
+            [PromptsType.instructions]: ( new ResourceMap()),
+            [PromptsType.mode]: ( new ResourceMap()),
+        };
         this.fileLocator = this._register(this.instantiationService.createInstance(PromptFilesLocator));
-        this.cache = this._register(( new ObjectCache((model) => {
-            assert(model.isDisposed() === false, 'Text model must not be disposed.');
-            const parser = instantiationService.createInstance(TextModelPromptParser, model, { allowNonPromptFiles: true, languageId: undefined, updateOnChange: true }).start();
-            parser.assertNotDisposed('Created prompt parser must not be disposed.');
-            return parser;
-        })));
+        this._register(this.modelService.onModelRemoved((model) => {
+            this.parsedPromptFileCache.delete(model.uri);
+        }));
     }
     get onDidChangeCustomChatModes() {
-        if (!this.onDidChangeCustomChatModesEvent) {
-            this.onDidChangeCustomChatModesEvent = this._register(this.fileLocator.createFilesUpdatedEvent(PromptsType.mode)).event;
-            this._register(this.onDidChangeCustomChatModesEvent(() => {
+        if (!this.onDidChangeCustomChatModesEmitter) {
+            const emitter = this.onDidChangeCustomChatModesEmitter = this._register(( new Emitter()));
+            const chatModelTracker = this._register(( new ChatModeUpdateTracker(this.fileLocator, this.modelService)));
+            this._register(chatModelTracker.onDidChangeContent(() => {
                 this.cachedCustomChatModes = undefined;
+                emitter.fire();
             }));
         }
-        return this.onDidChangeCustomChatModesEvent;
+        return this.onDidChangeCustomChatModesEmitter.event;
     }
     getPromptFileType(uri) {
         const model = this.modelService.getModel(uri);
         const languageId = model ? model.getLanguageId() : this.languageService.guessLanguageIdByFilepathOrFirstLine(uri);
         return languageId ? getPromptsTypeForLanguageId(languageId) : undefined;
     }
-    getSyntaxParserFor(model) {
-        assert(model.isDisposed() === false, 'Cannot create a prompt syntax parser for a disposed model.');
-        return this.cache.get(model);
+    getParsedPromptFile(textModel) {
+        const cached = this.parsedPromptFileCache.get(textModel.uri);
+        if (cached && cached[0] === textModel.getVersionId()) {
+            return cached[1];
+        }
+        const ast = ( new NewPromptsParser()).parse(textModel.uri, textModel.getValue());
+        if (!cached || cached[0] < textModel.getVersionId()) {
+            this.parsedPromptFileCache.set(textModel.uri, [textModel.getVersionId(), ast]);
+        }
+        return ast;
     }
     async listPromptFiles(type, token) {
         if (!PromptsConfig.enabled(this.configurationService)) {
             return [];
         }
         const prompts = await Promise.all([
-            this.fileLocator.listFiles(type, 'user', token)
-                .then(withType('user', type)),
-            this.fileLocator.listFiles(type, 'local', token)
-                .then(withType('local', type)),
+            this.fileLocator.listFiles(type, PromptsStorage.user, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.user, type })))),
+            this.fileLocator.listFiles(type, PromptsStorage.local, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.local, type })))),
+            this.getExtensionContributions(type)
         ]);
-        return prompts.flat();
+        return [...prompts.flat()];
+    }
+    async listPromptFilesForStorage(type, storage, token) {
+        if (!PromptsConfig.enabled(this.configurationService)) {
+            return [];
+        }
+        switch (storage) {
+            case PromptsStorage.extension:
+                return this.getExtensionContributions(type);
+            case PromptsStorage.local:
+                return this.fileLocator.listFiles(type, PromptsStorage.local, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.local, type }))));
+            case PromptsStorage.user:
+                return this.fileLocator.listFiles(type, PromptsStorage.user, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.user, type }))));
+            default:
+                throw ( new Error(`[listPromptFilesForStorage] Unsupported prompt storage type: ${storage}`));
+        }
+    }
+    async getExtensionContributions(type) {
+        return Promise.all(( this.contributedFiles[type].values()));
     }
     getSourceFolders(type) {
         if (!PromptsConfig.enabled(this.configurationService)) {
@@ -74,15 +112,15 @@ let PromptsService = class PromptsService extends Disposable {
         }
         const result = [];
         for (const uri of this.fileLocator.getConfigBasedSourceFolders(type)) {
-            result.push({ uri, storage: 'local', type });
+            result.push({ uri, storage: PromptsStorage.local, type });
         }
         const userHome = this.userDataService.currentProfile.promptsHome;
-        result.push({ uri: userHome, storage: 'user', type });
+        result.push({ uri: userHome, storage: PromptsStorage.user, type });
         return result;
     }
     asPromptSlashCommand(command) {
         if (command.match(/^[\p{L}\d_\-\.]+$/u)) {
-            return { command, detail: ( localize(5613, 'Prompt file: {0}', command)) };
+            return { command, detail: ( localize(5681, 'Prompt file: {0}', command)) };
         }
         return undefined;
     }
@@ -92,7 +130,7 @@ let PromptsService = class PromptsService extends Disposable {
             return undefined;
         }
         try {
-            return await this.parse(promptUri, PromptsType.prompt, token);
+            return await this.parseNew(promptUri, token);
         }
         catch (error) {
             this.logger.error(`[resolvePromptSlashCommand] Failed to parse prompt file: ${promptUri}`, error);
@@ -103,26 +141,34 @@ let PromptsService = class PromptsService extends Disposable {
         if (data.promptPath) {
             return data.promptPath.uri;
         }
-        const files = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
+        const promptPaths = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
         const command = data.command;
-        const result = files.find(file => getPromptCommandName(file.uri.path) === command);
+        const result = promptPaths.find(promptPath => getCommandNameFromPromptPath(promptPath) === command);
         if (result) {
             return result.uri;
         }
-        const textModel = this.modelService.getModels().find(model => model.getLanguageId() === PROMPT_LANGUAGE_ID && getPromptCommandName(model.uri.path) === command);
+        const textModel = this.modelService.getModels().find(model => model.getLanguageId() === PROMPT_LANGUAGE_ID && getCommandNameFromURI(model.uri) === command);
         if (textModel) {
             return textModel.uri;
         }
         return undefined;
     }
+    async getPromptCommandName(uri) {
+        const promptPaths = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
+        const promptPath = promptPaths.find(promptPath => isEqual(promptPath.uri, uri));
+        if (!promptPath) {
+            return getCommandNameFromURI(uri);
+        }
+        return getCommandNameFromPromptPath(promptPath);
+    }
     async findPromptSlashCommands() {
         const promptFiles = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
         return (promptFiles.map(promptPath => {
-            const command = getPromptCommandName(promptPath.uri.path);
+            const command = getCommandNameFromPromptPath(promptPath);
             return {
                 command,
                 detail: ( localize(
-                    5613,
+                    5681,
                     'Prompt file: {0}',
                     this.labelService.getUriLabel(promptPath.uri, { relative: true })
                 )),
@@ -133,7 +179,7 @@ let PromptsService = class PromptsService extends Disposable {
     async getCustomChatModes(token) {
         if (!this.cachedCustomChatModes) {
             const customChatModes = this.computeCustomChatModes(token);
-            if (!this.onDidChangeCustomChatModesEvent) {
+            if (!this.onDidChangeCustomChatModesEmitter) {
                 return customChatModes;
             }
             this.cachedCustomChatModes = customChatModes;
@@ -142,48 +188,101 @@ let PromptsService = class PromptsService extends Disposable {
     }
     async computeCustomChatModes(token) {
         const modeFiles = await this.listPromptFiles(PromptsType.mode, token);
-        const metadataList = await Promise.all(( modeFiles.map(async ({ uri }) => {
-            let parser;
-            try {
-                parser = this.instantiationService.createInstance(PromptParser, uri, { allowNonPromptFiles: true, languageId: MODE_LANGUAGE_ID, updateOnChange: false }).start(token);
-                const completed = await parser.settled();
-                if (!completed) {
-                    throw ( new Error(( localize(5614, "Prompt parser for {0} did not complete.", (uri.toString())))));
+        const customChatModes = await Promise.all(( modeFiles.map(async ({ uri, name: modeName }) => {
+            const ast = await this.parseNew(uri, token);
+            let metadata;
+            if (ast.header) {
+                const advanced = ast.header.getAttribute('advancedOptions');
+                if (advanced && advanced.value.type === 'object') {
+                    metadata = {};
+                    for (const [key, value] of Object.entries(advanced.value)) {
+                        if (['string', 'number', 'boolean'].includes(value.type)) {
+                            metadata[key] = value;
+                        }
+                    }
                 }
-                const body = await parser.getBody();
-                const name = getCleanPromptName(uri);
-                const metadata = parser.metadata;
-                if (metadata?.promptType !== PromptsType.mode) {
-                    return { uri, name, body };
+            }
+            const toolReferences = [];
+            if (ast.body) {
+                const bodyOffset = ast.body.offset;
+                const bodyVarRefs = ast.body.variableReferences;
+                for (let i = bodyVarRefs.length - 1; i >= 0; i--) {
+                    const { name, offset } = bodyVarRefs[i];
+                    const range = ( new OffsetRange(offset - bodyOffset, offset - bodyOffset + name.length + 1));
+                    toolReferences.push({ name, range });
                 }
-                const { description, model, tools } = metadata;
-                return { uri, name, description, model, tools, body };
             }
-            finally {
-                parser?.dispose();
+            const modeInstructions = {
+                content: ast.body?.getContent() ?? '',
+                toolReferences,
+                metadata,
+            };
+            const name = modeName ?? getCleanPromptName(uri);
+            if (!ast.header) {
+                return { uri, name, modeInstructions };
             }
+            const { description, model, tools } = ast.header;
+            return { uri, name, description, model, tools, modeInstructions };
         })));
-        return metadataList;
+        return customChatModes;
     }
-    async parse(uri, type, token) {
-        let parser;
-        try {
-            const languageId = getLanguageIdForPromptsType(type);
-            parser = this.instantiationService.createInstance(PromptParser, uri, { allowNonPromptFiles: true, languageId, updateOnChange: false }).start(token);
-            const completed = await parser.settled();
-            if (!completed) {
-                throw ( new Error(( localize(5614, "Prompt parser for {0} did not complete.", (uri.toString())))));
-            }
-            return {
-                uri: parser.uri,
-                metadata: parser.metadata,
-                topError: parser.topError,
-                references: ( parser.references.map(ref => ref.uri))
-            };
+    async parseNew(uri, token) {
+        const model = this.modelService.getModel(uri);
+        if (model) {
+            return this.getParsedPromptFile(model);
         }
-        finally {
-            parser?.dispose();
+        const fileContent = await this.fileService.readFile(uri);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
         }
+        return ( new NewPromptsParser()).parse(uri, ( fileContent.value.toString()));
+    }
+    registerContributedFile(type, name, description, uri, extension) {
+        const bucket = this.contributedFiles[type];
+        if (( bucket.has(uri))) {
+            return Disposable.None;
+        }
+        const entryPromise = (async () => {
+            try {
+                await this.filesConfigService.updateReadonly(uri, true);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                this.logger.error(`[registerContributedFile] Failed to make prompt file readonly: ${uri}`, msg);
+            }
+            return { uri, name, description, storage: PromptsStorage.extension, type, extension };
+        })();
+        bucket.set(uri, entryPromise);
+        const updateModesIfRequired = () => {
+            if (type === PromptsType.mode) {
+                this.cachedCustomChatModes = undefined;
+                this.onDidChangeCustomChatModesEmitter?.fire();
+            }
+        };
+        updateModesIfRequired();
+        return {
+            dispose: () => {
+                bucket.delete(uri);
+                updateModesIfRequired();
+            }
+        };
+    }
+    getPromptLocationLabel(promptPath) {
+        switch (promptPath.storage) {
+            case PromptsStorage.local: return this.labelService.getUriLabel(dirname(promptPath.uri), { relative: true });
+            case PromptsStorage.user: return localize(5682, 'User Data');
+            case PromptsStorage.extension: {
+                return localize(
+                    5683,
+                    'Extension: {0}',
+                    promptPath.extension.displayName ?? promptPath.extension.id
+                );
+            }
+            default: throw ( new Error('Unknown prompt storage type'));
+        }
+    }
+    findAgentMDsInWorkspace(token) {
+        return this.fileLocator.findAgentMDsInWorkspace(token);
     }
 };
 PromptsService = ( __decorate([
@@ -193,22 +292,57 @@ PromptsService = ( __decorate([
     ( __param(3, IInstantiationService)),
     ( __param(4, IUserDataProfileService)),
     ( __param(5, ILanguageService)),
-    ( __param(6, IConfigurationService))
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IFileService)),
+    ( __param(8, IFilesConfigurationService))
 ], PromptsService));
-function getPromptCommandName(path) {
-    const name = basename(path, PROMPT_FILE_EXTENSION);
-    return name;
-}
-function addType(storage, type) {
-    return (uri) => {
-        return { uri, storage, type };
-    };
+function getCommandNameFromPromptPath(promptPath) {
+    return promptPath.name ?? getCommandNameFromURI(promptPath.uri);
 }
-function withType(storage, type) {
-    return (uris) => {
-        return ( uris
-            .map(addType(storage, type)));
-    };
+function getCommandNameFromURI(uri) {
+    return basename(uri.fsPath, PROMPT_FILE_EXTENSION);
 }
+let ChatModeUpdateTracker = class ChatModeUpdateTracker extends Disposable {
+    static { ChatModeUpdateTracker_1 = this; }
+    static { this.CHAT_MODE_UPDATE_DELAY_MS = 200; }
+    get onDidChangeContent() {
+        return this.onDidChatModeModelChange.event;
+    }
+    constructor(fileLocator, modelService) {
+        super();
+        this.listeners = ( new ResourceMap());
+        this.onDidChatModeModelChange = this._register(( new Emitter()));
+        const delayer = this._register(( new Delayer(ChatModeUpdateTracker_1.CHAT_MODE_UPDATE_DELAY_MS)));
+        const trigger = () => delayer.trigger(() => this.onDidChatModeModelChange.fire());
+        const filesUpdatedEventRegistration = this._register(fileLocator.createFilesUpdatedEvent(PromptsType.mode));
+        this._register(filesUpdatedEventRegistration.event(() => trigger()));
+        const onAdd = (model) => {
+            if (model.getLanguageId() === MODE_LANGUAGE_ID) {
+                this.listeners.set(model.uri, model.onDidChangeContent(() => trigger()));
+            }
+        };
+        const onRemove = (languageId, uri) => {
+            if (languageId === MODE_LANGUAGE_ID) {
+                this.listeners.get(uri)?.dispose();
+                this.listeners.delete(uri);
+                trigger();
+            }
+        };
+        this._register(modelService.onModelAdded(model => onAdd(model)));
+        this._register(modelService.onModelLanguageChanged(e => {
+            onRemove(e.oldLanguageId, e.model.uri);
+            onAdd(e.model);
+        }));
+        this._register(modelService.onModelRemoved(model => onRemove(model.getLanguageId(), model.uri)));
+    }
+    dispose() {
+        super.dispose();
+        this.listeners.forEach(listener => listener.dispose());
+        this.listeners.clear();
+    }
+};
+ChatModeUpdateTracker = ChatModeUpdateTracker_1 = ( __decorate([
+    ( __param(1, IModelService))
+], ChatModeUpdateTracker));
 
-export { PromptsService, getPromptCommandName };
+export { ChatModeUpdateTracker, PromptsService };

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

@@ -6,7 +6,7 @@ import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02
 import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
 import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { TPromptsStorage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { PromptsStorage } from "../service/promptsService.js";
 import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
@@ -28,9 +28,8 @@ export declare class PromptFilesLocator extends Disposable {
      *
      * @returns List of prompt files found in the workspace.
      */
-    listFiles(type: PromptsType, storage: TPromptsStorage, token: CancellationToken): Promise<readonly URI[]>;
+    listFiles(type: PromptsType, storage: PromptsStorage, token: CancellationToken): Promise<readonly URI[]>;
     private listFilesInUserData;
-    getCopilotInstructionsFiles(instructionFilePaths: Iterable<string>): Promise<URI[]>;
     createFilesUpdatedEvent(type: PromptsType): {
         readonly event: Event<void>;
         dispose: () => void;
@@ -69,6 +68,8 @@ export declare class PromptFilesLocator extends Disposable {
      * Uses the search service to find all files at the provided location
      */
     private searchFilesInLocation;
+    findAgentMDsInWorkspace(token: CancellationToken): Promise<URI[]>;
+    private findAgentMDsInFolder;
 }
 /**
  * Checks if the provided `pattern` could be a valid glob pattern.

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

@@ -5,7 +5,7 @@ import { isAbsolute } from '@codingame/monaco-vscode-api/vscode/vs/base/common/p
 import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { getPromptFileLocationsConfigKey, PromptsConfig } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
-import { joinPath, basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { basename, dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { getPromptFileType, getPromptFileExtension } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
@@ -14,6 +14,7 @@ import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/netw
 import { getExcludes, QueryType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search';
 import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service';
 import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { PromptsStorage } from '../service/promptsService.js';
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
@@ -31,30 +32,18 @@ let PromptFilesLocator = class PromptFilesLocator extends Disposable {
         this.logService = logService;
     }
     async listFiles(type, storage, token) {
-        if (storage === 'local') {
+        if (storage === PromptsStorage.local) {
             return await this.listFilesInLocal(type, token);
         }
-        else {
+        else if (storage === PromptsStorage.user) {
             return await this.listFilesInUserData(type, token);
         }
+        throw ( new Error(`Unsupported prompt file storage: ${storage}`));
     }
     async listFilesInUserData(type, token) {
         const files = await this.resolveFilesAtLocation(this.userDataService.currentProfile.promptsHome, token);
         return files.filter(file => getPromptFileType(file) === type);
     }
-    async getCopilotInstructionsFiles(instructionFilePaths) {
-        const { folders } = this.workspaceService.getWorkspace();
-        const result = [];
-        for (const folder of folders) {
-            for (const instructionFilePath of instructionFilePaths) {
-                const file = joinPath(folder.uri, instructionFilePath);
-                if (await this.fileService.exists(file)) {
-                    result.push(file);
-                }
-            }
-        }
-        return result;
-    }
     createFilesUpdatedEvent(type) {
         const disposables = ( new DisposableStore());
         const eventEmitter = disposables.add(( new Emitter()));
@@ -197,7 +186,35 @@ let PromptFilesLocator = class PromptFilesLocator extends Disposable {
         };
         try {
             const searchResult = await this.searchService.fileSearch(searchOptions, token);
-            if (token?.isCancellationRequested) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            return ( searchResult.results.map(r => r.resource));
+        }
+        catch (e) {
+            if (!isCancellationError(e)) {
+                throw e;
+            }
+        }
+        return [];
+    }
+    async findAgentMDsInWorkspace(token) {
+        const result = await Promise.all(( this.workspaceService.getWorkspace().folders.map(folder => this.findAgentMDsInFolder(folder.uri, token))));
+        return result.flat(1);
+    }
+    async findAgentMDsInFolder(folder, token) {
+        const disregardIgnoreFiles = this.configService.getValue('explorer.excludeGitIgnore');
+        const getExcludePattern = (folder) => getExcludes(this.configService.getValue({ resource: folder })) || {};
+        const searchOptions = {
+            folderQueries: [{ folder, disregardIgnoreFiles }],
+            type: QueryType.File,
+            shouldGlobMatchFilePattern: true,
+            excludePattern: getExcludePattern(folder),
+            filePattern: '**/AGENTS.md',
+        };
+        try {
+            const searchResult = await this.searchService.fileSearch(searchOptions, token);
+            if (token.isCancellationRequested) {
                 return [];
             }
             return ( searchResult.results.map(r => r.resource));