@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -3,12 +3,13 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { isAbsolute } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
-import { getPromptFileLocationsConfigKey, PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
-import { basename, dirname, joinPath, isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { PromptsConfig, getPromptFileLocationsConfigKey, isTildePath } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { joinPath, basename, dirname, isEqualOrParent } 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, AGENTS_SOURCE_FOLDER, getPromptFileExtension, COPILOT_CUSTOM_INSTRUCTIONS_FILENAME, LEGACY_MODE_FILE_EXTENSION, getCleanPromptName, AGENT_FILE_EXTENSION, DEFAULT_AGENT_SKILLS_WORKSPACE_FOLDERS, DEFAULT_AGENT_SKILLS_USER_HOME_FOLDERS } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { getPromptFileType, PromptFileSource, getPromptFileDefaultLocations, DEFAULT_AGENT_SOURCE_FOLDERS, getPromptFileExtension, COPILOT_CUSTOM_INSTRUCTIONS_FILENAME, LEGACY_MODE_FILE_EXTENSION, AGENTS_SOURCE_FOLDER, getCleanPromptName, AGENT_FILE_EXTENSION, SKILL_FILENAME } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
 import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
@@ -23,7 +24,16 @@ import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
 
 let PromptFilesLocator = class PromptFilesLocator {
-    constructor(fileService, configService, workspaceService, environmentService, searchService, userDataService, logService, pathService) {
+    constructor(
+        fileService,
+        configService,
+        workspaceService,
+        environmentService,
+        searchService,
+        userDataService,
+        logService,
+        pathService
+    ) {
         this.fileService = fileService;
         this.configService = configService;
         this.workspaceService = workspaceService;
@@ -36,15 +46,62 @@ let PromptFilesLocator = class PromptFilesLocator {
     async listFiles(type, storage, token) {
         if (storage === PromptsStorage.local) {
             return await this.listFilesInLocal(type, token);
-        }
-        else if (storage === PromptsStorage.user) {
+        } 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);
+        const userStorageFolders = await this.getUserStorageFolders(type);
+        const paths = ( new ResourceSet());
+        for (const {
+            uri
+        } of userStorageFolders) {
+            const files = await this.resolveFilesAtLocation(uri, type, token);
+            for (const file of files) {
+                if (getPromptFileType(file) === type) {
+                    paths.add(file);
+                }
+            }
+            if (token.isCancellationRequested) {
+                return [];
+            }
+        }
+        return [...paths];
+    }
+    async getUserStorageFolders(type) {
+        const userHome = await this.pathService.userHome();
+        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
+        const absoluteLocations = this.toAbsoluteLocations(type, configuredLocations, userHome);
+        const result = absoluteLocations.filter(loc => loc.storage === PromptsStorage.user);
+        if (type !== PromptsType.skill) {
+            const userDataPromptsHome = this.userDataService.currentProfile.promptsHome;
+            return [...result, {
+                uri: userDataPromptsHome,
+                source: PromptFileSource.CopilotPersonal,
+                storage: PromptsStorage.user,
+                displayPath: ( localize(6382, "User Data")),
+                isDefault: true
+            }];
+        }
+        return result;
+    }
+    getSourceFoldersSync(type, userHome) {
+        const result = [];
+        const {
+            folders
+        } = this.workspaceService.getWorkspace();
+        const defaultFolders = getPromptFileDefaultLocations(type);
+        for (const sourceFolder of defaultFolders) {
+            if (sourceFolder.storage === PromptsStorage.local) {
+                for (const workspaceFolder of folders) {
+                    result.push(joinPath(workspaceFolder.uri, sourceFolder.path));
+                }
+            } else if (sourceFolder.storage === PromptsStorage.user) {
+                result.push(joinPath(userHome, sourceFolder.path));
+            }
+        }
+        return result;
     }
     createFilesUpdatedEvent(type) {
         const disposables = ( new DisposableStore());
@@ -52,17 +109,32 @@ let PromptFilesLocator = class PromptFilesLocator {
         const userDataFolder = this.userDataService.currentProfile.promptsHome;
         const key = getPromptFileLocationsConfigKey(type);
         let parentFolders = this.getLocalParentFolders(type);
+        let allSourceFolders = [];
         const externalFolderWatchers = disposables.add(( new DisposableStore()));
         const updateExternalFolderWatchers = () => {
             externalFolderWatchers.clear();
             for (const folder of parentFolders) {
                 if (!this.workspaceService.getWorkspaceFolder(folder.parent)) {
                     const recursive = folder.filePattern !== undefined;
-                    externalFolderWatchers.add(this.fileService.watch(folder.parent, { recursive, excludes: [] }));
+                    externalFolderWatchers.add(this.fileService.watch(folder.parent, {
+                        recursive,
+                        excludes: []
+                    }));
+                }
+            }
+            for (const folder of allSourceFolders) {
+                if (!this.workspaceService.getWorkspaceFolder(folder)) {
+                    externalFolderWatchers.add(this.fileService.watch(folder, {
+                        recursive: true,
+                        excludes: []
+                    }));
                 }
             }
         };
-        updateExternalFolderWatchers();
+        this.pathService.userHome().then(userHome => {
+            allSourceFolders = [...this.getSourceFoldersSync(type, userHome)];
+            updateExternalFolderWatchers();
+        });
         disposables.add(this.configService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(key)) {
                 parentFolders = this.getLocalParentFolders(type);
@@ -79,27 +151,39 @@ let PromptFilesLocator = class PromptFilesLocator {
                 eventEmitter.fire();
                 return;
             }
+            if (( allSourceFolders.some(folder => e.affects(folder)))) {
+                eventEmitter.fire();
+                return;
+            }
         }));
         disposables.add(this.fileService.watch(userDataFolder));
-        return { event: eventEmitter.event, dispose: () => disposables.dispose() };
+        return {
+            event: eventEmitter.event,
+            dispose: () => disposables.dispose()
+        };
     }
-    getAgentSourceFolder() {
-        return this.toAbsoluteLocations([AGENTS_SOURCE_FOLDER]);
+    async getAgentSourceFolders() {
+        const userHome = await this.pathService.userHome();
+        return ( this.toAbsoluteLocations(PromptsType.agent, DEFAULT_AGENT_SOURCE_FOLDERS, userHome).map(l => l.uri));
     }
-    getConfigBasedSourceFolders(type) {
+    async getConfigBasedSourceFolders(type) {
+        const userHome = await this.pathService.userHome();
         const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
-        const absoluteLocations = this.toAbsoluteLocations(configuredLocations);
+        const absoluteLocations = ( this.toAbsoluteLocations(type, configuredLocations, userHome).map(l => l.uri));
+        if (type !== PromptsType.prompt && type !== PromptsType.instructions) {
+            return absoluteLocations;
+        }
         const result = ( new ResourceSet());
         for (let absoluteLocation of absoluteLocations) {
             const baseName = basename(absoluteLocation);
-            const filePatterns = ['*.md', `*${getPromptFileExtension(type)}`];
+            const filePatterns = ["*.md", `*${getPromptFileExtension(type)}`];
             for (const filePattern of filePatterns) {
                 if (baseName === filePattern) {
                     absoluteLocation = dirname(absoluteLocation);
                     continue;
                 }
             }
-            if (baseName === '*') {
+            if (baseName === "*") {
                 absoluteLocation = dirname(absoluteLocation);
             }
             if (isValidGlob(absoluteLocation.path) === true) {
@@ -109,12 +193,37 @@ let PromptFilesLocator = class PromptFilesLocator {
         }
         return [...result];
     }
+    async getResolvedSourceFolders(type) {
+        const localFolders = await this.getLocalStorageFolders(type);
+        const userFolders = await this.getUserStorageFolders(type);
+        return this.dedupeSourceFolders([...localFolders, ...userFolders]);
+    }
+    async getLocalStorageFolders(type) {
+        const userHome = await this.pathService.userHome();
+        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
+        const defaultFolders = getPromptFileDefaultLocations(type);
+        const allFolders = [...defaultFolders, ...configuredLocations.filter(loc => !( defaultFolders.some(df => df.path === loc.path)))];
+        return this.toAbsoluteLocations(type, allFolders, userHome, defaultFolders);
+    }
+    dedupeSourceFolders(folders) {
+        const seen = ( new ResourceSet());
+        const result = [];
+        for (const folder of folders) {
+            if (!( seen.has(folder.uri))) {
+                seen.add(folder.uri);
+                result.push(folder);
+            }
+        }
+        return result;
+    }
     async listFilesInLocal(type, token) {
         const paths = ( new ResourceSet());
-        for (const { parent, filePattern } of this.getLocalParentFolders(type)) {
-            const files = (filePattern === undefined)
-                ? await this.resolveFilesAtLocation(parent, token)
-                : await this.searchFilesInLocation(parent, filePattern, token);
+        for (const {
+            parent,
+            filePattern
+        } of this.getLocalParentFolders(type)) {
+            const files = (filePattern === undefined) ?
+            await this.resolveFilesAtLocation(parent, type, token) : await this.searchFilesInLocation(parent, filePattern, token);
             for (const file of files) {
                 if (getPromptFileType(file) === type) {
                     paths.add(file);
@@ -129,44 +238,112 @@ let PromptFilesLocator = class PromptFilesLocator {
     getLocalParentFolders(type) {
         const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
         if (type === PromptsType.agent) {
-            configuredLocations.push(AGENTS_SOURCE_FOLDER);
+            configuredLocations.push(...DEFAULT_AGENT_SOURCE_FOLDERS);
         }
-        const absoluteLocations = this.toAbsoluteLocations(configuredLocations);
-        return ( absoluteLocations.map(firstNonGlobParentAndPattern));
+        const absoluteLocations = this.toAbsoluteLocations(type, configuredLocations, undefined);
+        return ( absoluteLocations.map(location => firstNonGlobParentAndPattern(location.uri)));
     }
-    toAbsoluteLocations(configuredLocations) {
-        const result = ( new ResourceSet());
-        const { folders } = this.workspaceService.getWorkspace();
-        for (const configuredLocation of configuredLocations) {
+    toAbsoluteLocations(type, configuredLocations, userHome, defaultLocations) {
+        const result = [];
+        const seen = ( new ResourceSet());
+        const {
+            folders
+        } = this.workspaceService.getWorkspace();
+        const defaultPaths = ( new Set(defaultLocations?.map(loc => loc.path)));
+        const validLocations = configuredLocations.filter(sourceFolder => {
+            if (type === PromptsType.instructions || type === PromptsType.prompt) {
+                const path = sourceFolder.path;
+                if (hasGlobPattern(path)) {
+                    if (type === PromptsType.prompt) {
+                        this.logService.warn(
+                            `[Deprecated] Glob patterns (* and **) in prompt file locations are deprecated: "${path}". Consider using explicit paths instead.`
+                        );
+                    } else if (type === PromptsType.instructions) {
+                        this.logService.info(
+                            `Glob patterns (* and **) detected in instruction file location: "${path}". Consider using explicit paths for better performance.`
+                        );
+                    }
+                }
+                return true;
+            }
+            const configuredLocation = sourceFolder.path;
+            if (!isValidPromptFolderPath(configuredLocation)) {
+                this.logService.warn(
+                    `Skipping invalid path (glob patterns and absolute paths not supported): ${configuredLocation}`
+                );
+                return false;
+            }
+            return true;
+        });
+        for (const sourceFolder of validLocations) {
+            const configuredLocation = sourceFolder.path;
+            const isDefault = defaultPaths?.has(configuredLocation);
             try {
+                if (isTildePath(configuredLocation)) {
+                    if (userHome) {
+                        const uri = joinPath(userHome, configuredLocation.substring(2));
+                        if (!( seen.has(uri))) {
+                            seen.add(uri);
+                            result.push({
+                                uri,
+                                source: sourceFolder.source,
+                                storage: sourceFolder.storage,
+                                displayPath: configuredLocation,
+                                isDefault
+                            });
+                        }
+                    }
+                    continue;
+                }
                 if (isAbsolute(configuredLocation)) {
                     let uri = URI.file(configuredLocation);
                     const remoteAuthority = this.environmentService.remoteAuthority;
                     if (remoteAuthority) {
-                        uri = uri.with({ scheme: Schemas.vscodeRemote, authority: remoteAuthority });
+                        uri = uri.with({
+                            scheme: Schemas.vscodeRemote,
+                            authority: remoteAuthority
+                        });
                     }
-                    result.add(uri);
-                }
-                else {
+                    if (!( seen.has(uri))) {
+                        seen.add(uri);
+                        result.push({
+                            uri,
+                            source: sourceFolder.source,
+                            storage: sourceFolder.storage,
+                            displayPath: configuredLocation,
+                            isDefault
+                        });
+                    }
+                } else {
                     for (const workspaceFolder of folders) {
                         const absolutePath = joinPath(workspaceFolder.uri, configuredLocation);
-                        result.add(absolutePath);
+                        if (!( seen.has(absolutePath))) {
+                            seen.add(absolutePath);
+                            result.push({
+                                uri: absolutePath,
+                                source: sourceFolder.source,
+                                storage: sourceFolder.storage,
+                                displayPath: configuredLocation,
+                                isDefault
+                            });
+                        }
                     }
                 }
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(`Failed to resolve prompt file location: ${configuredLocation}`, error);
             }
         }
-        return [...result];
+        return result;
     }
-    async resolveFilesAtLocation(location, token) {
+    async resolveFilesAtLocation(location, type, token) {
+        if (type === PromptsType.skill) {
+            return this.findAgentSkillsInFolder(location, token);
+        }
         try {
             const info = await this.fileService.resolve(location);
             if (info.isFile) {
                 return [info.resource];
-            }
-            else if (info.isDirectory && info.children) {
+            } else if (info.isDirectory && info.children) {
                 const result = [];
                 for (const child of info.children) {
                     if (child.isFile) {
@@ -175,20 +352,30 @@ let PromptFilesLocator = class PromptFilesLocator {
                 }
                 return result;
             }
-        }
-        catch (error) {
-        }
+        } catch (error) {}
         return [];
     }
     async searchFilesInLocation(folder, filePattern, token) {
-        const disregardIgnoreFiles = this.configService.getValue('explorer.excludeGitIgnore');
+        if (!this.searchService.schemeHasFileSearchProvider(folder.scheme)) {
+            this.logService.warn(
+                `[PromptFilesLocator] No FileSearchProvider available for scheme '${folder.scheme}'. Cannot search for pattern '${filePattern}' in ${( folder.toString())}`
+            );
+            return [];
+        }
+        const disregardIgnoreFiles = this.configService.getValue("explorer.excludeGitIgnore");
         const workspaceRoot = this.workspaceService.getWorkspaceFolder(folder);
-        const getExcludePattern = (folder) => getExcludes(this.configService.getValue({ resource: folder })) || {};
+        const getExcludePattern = folder => getExcludes(this.configService.getValue({
+            resource: folder
+        })) || {};
         const searchOptions = {
-            folderQueries: [{ folder, disregardIgnoreFiles }],
+            folderQueries: [{
+                folder,
+                disregardIgnoreFiles
+            }],
             type: QueryType.File,
             shouldGlobMatchFilePattern: true,
             excludePattern: workspaceRoot ? getExcludePattern(workspaceRoot.uri) : undefined,
+            ignoreGlobCase: true,
             sortByScore: true,
             filePattern
         };
@@ -198,8 +385,7 @@ let PromptFilesLocator = class PromptFilesLocator {
                 return [];
             }
             return ( searchResult.results.map(r => r.resource));
-        }
-        catch (e) {
+        } catch (e) {
             if (!isCancellationError(e)) {
                 throw e;
             }
@@ -208,7 +394,9 @@ let PromptFilesLocator = class PromptFilesLocator {
     }
     async findCopilotInstructionsMDsInWorkspace(token) {
         const result = [];
-        const { folders } = this.workspaceService.getWorkspace();
+        const {
+            folders
+        } = this.workspaceService.getWorkspace();
         for (const folder of folders) {
             const file = joinPath(folder.uri, `.github/` + COPILOT_CUSTOM_INSTRUCTIONS_FILENAME);
             try {
@@ -216,8 +404,7 @@ let PromptFilesLocator = class PromptFilesLocator {
                 if (stat.isFile) {
                     result.push(file);
                 }
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.trace(`[PromptFilesLocator] Skipping copilot-instructions.md at ${( file.toString())}: ${error}`);
             }
         }
@@ -228,36 +415,72 @@ let PromptFilesLocator = class PromptFilesLocator {
         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 [];
+        if (this.searchService.schemeHasFileSearchProvider(folder.scheme)) {
+            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",
+                ignoreGlobCase: true
+            };
+            try {
+                const searchResult = await this.searchService.fileSearch(searchOptions, token);
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                return ( searchResult.results.map(r => r.resource));
+            } catch (e) {
+                if (!isCancellationError(e)) {
+                    throw e;
+                }
             }
-            return ( searchResult.results.map(r => r.resource));
+            return [];
+        } else {
+            return this.findAgentMDsUsingFileService(folder, token);
         }
-        catch (e) {
-            if (!isCancellationError(e)) {
-                throw e;
+    }
+    async findAgentMDsUsingFileService(folder, token) {
+        const result = [];
+        const agentsMdFileName = "agents.md";
+        const traverse = async uri => {
+            if (token.isCancellationRequested) {
+                return;
             }
-        }
-        return [];
+            try {
+                const stat = await this.fileService.resolve(uri);
+                if (stat.isFile && stat.name.toLowerCase() === agentsMdFileName) {
+                    result.push(stat.resource);
+                } else if (stat.isDirectory && stat.children) {
+                    for (const child of stat.children) {
+                        await traverse(child.resource);
+                    }
+                }
+            } catch (error) {
+                this.logService.trace(`[PromptFilesLocator] Error traversing ${( uri.toString())}: ${error}`);
+            }
+        };
+        await traverse(folder);
+        return result;
     }
     async findAgentMDsInWorkspaceRoots(token) {
         const result = [];
-        const { folders } = this.workspaceService.getWorkspace();
-        const resolvedRoots = await this.fileService.resolveAll(( folders.map(f => ({ resource: f.uri }))));
+        const {
+            folders
+        } = this.workspaceService.getWorkspace();
+        const resolvedRoots = await this.fileService.resolveAll(( folders.map(f => ({
+            resource: f.uri
+        }))));
         for (const root of resolvedRoots) {
             if (root.success && root.stat?.children) {
-                const agentMd = root.stat.children.find(c => c.isFile && c.name.toLowerCase() === 'agents.md');
+                const agentMd = root.stat.children.find(c => c.isFile && c.name.toLowerCase() === "agents.md");
                 if (agentMd) {
                     result.push(agentMd.resource);
                 }
@@ -270,69 +493,76 @@ let PromptFilesLocator = class PromptFilesLocator {
             let newLocation;
             const workspaceFolder = this.workspaceService.getWorkspaceFolder(oldURI);
             if (workspaceFolder) {
-                newLocation = joinPath(workspaceFolder.uri, AGENTS_SOURCE_FOLDER, getCleanPromptName(oldURI) + AGENT_FILE_EXTENSION);
-            }
-            else if (isEqualOrParent(oldURI, this.userDataService.currentProfile.promptsHome)) {
-                newLocation = joinPath(this.userDataService.currentProfile.promptsHome, getCleanPromptName(oldURI) + AGENT_FILE_EXTENSION);
+                newLocation = joinPath(
+                    workspaceFolder.uri,
+                    AGENTS_SOURCE_FOLDER,
+                    getCleanPromptName(oldURI) + AGENT_FILE_EXTENSION
+                );
+            } else if (isEqualOrParent(oldURI, this.userDataService.currentProfile.promptsHome)) {
+                newLocation = joinPath(
+                    this.userDataService.currentProfile.promptsHome,
+                    getCleanPromptName(oldURI) + AGENT_FILE_EXTENSION
+                );
             }
             return newLocation;
         }
         return undefined;
     }
-    async findAgentSkillsInFolder(uri, relativePath, token) {
-        const result = [];
+    async findAgentSkillsInFolder(uri, token) {
         try {
-            const stat = await this.fileService.resolve(joinPath(uri, relativePath));
-            if (token.isCancellationRequested) {
-                return [];
-            }
+            const result = [];
+            const stat = await this.fileService.resolve(uri);
             if (stat.isDirectory && stat.children) {
-                for (const skillDir of stat.children) {
-                    if (skillDir.isDirectory) {
-                        const skillFile = joinPath(skillDir.resource, 'SKILL.md');
-                        if (await this.fileService.exists(skillFile)) {
-                            result.push(skillFile);
+                for (const child of stat.children) {
+                    try {
+                        if (token.isCancellationRequested) {
+                            return [];
                         }
-                    }
+                        if (child.isDirectory) {
+                            const skillFile = joinPath(child.resource, SKILL_FILENAME);
+                            const skillStat = await this.fileService.resolve(skillFile);
+                            if (skillStat.isFile) {
+                                result.push(skillStat.resource);
+                            }
+                        }
+                    } catch (error) {}
                 }
             }
-        }
-        catch (error) {
-            return [];
-        }
-        return result;
-    }
-    async findAgentSkillsInWorkspace(token) {
-        const workspace = this.workspaceService.getWorkspace();
-        const allResults = [];
-        for (const folder of workspace.folders) {
-            for (const { path, type } of DEFAULT_AGENT_SKILLS_WORKSPACE_FOLDERS) {
-                const results = await this.findAgentSkillsInFolder(folder.uri, path, token);
-                allResults.push(...( results.map(uri => ({ uri, type }))));
+            return result;
+        } catch (e) {
+            if (!isCancellationError(e)) {
+                this.logService.trace(`[PromptFilesLocator] Error searching for skills in ${( uri.toString())}: ${e}`);
             }
+            return [];
         }
-        return allResults;
     }
-    async findAgentSkillsInUserHome(token) {
+    async findAgentSkills(token) {
         const userHome = await this.pathService.userHome();
+        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, PromptsType.skill);
+        const absoluteLocations = this.toAbsoluteLocations(PromptsType.skill, configuredLocations, userHome);
         const allResults = [];
-        for (const { path, type } of DEFAULT_AGENT_SKILLS_USER_HOME_FOLDERS) {
-            const results = await this.findAgentSkillsInFolder(userHome, path, token);
-            allResults.push(...( results.map(uri => ({ uri, type }))));
+        for (const {
+            uri,
+            source,
+            storage
+        } of absoluteLocations) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            const results = await this.findAgentSkillsInFolder(uri, token);
+            allResults.push(...( results.map(uri => ({
+                fileUri: uri,
+                source,
+                storage
+            }))));
         }
         return allResults;
     }
 };
-PromptFilesLocator = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IWorkbenchEnvironmentService)),
-    ( __param(4, ISearchService)),
-    ( __param(5, IUserDataProfileService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IPathService))
-], PromptFilesLocator));
+PromptFilesLocator = ( __decorate([( __param(0, IFileService)), ( __param(1, IConfigurationService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IWorkbenchEnvironmentService)), ( __param(4, ISearchService)), ( __param(5, IUserDataProfileService)), ( __param(6, ILogService)), ( __param(7, IPathService))], PromptFilesLocator));
+function hasGlobPattern(path) {
+    return path.includes("*");
+}
 function isValidGlob(pattern) {
     let squareBrackets = false;
     let squareBracketsCount = 0;
@@ -340,34 +570,34 @@ function isValidGlob(pattern) {
     let curlyBracketsCount = 0;
     let previousCharacter;
     for (const char of pattern) {
-        if (previousCharacter === '\\') {
+        if (previousCharacter === "\\") {
             previousCharacter = char;
             continue;
         }
-        if (char === '*') {
+        if (char === "*") {
             return true;
         }
-        if (char === '?') {
+        if (char === "?") {
             return true;
         }
-        if (char === '[') {
+        if (char === "[") {
             squareBrackets = true;
             squareBracketsCount++;
             previousCharacter = char;
             continue;
         }
-        if (char === ']') {
+        if (char === "]") {
             squareBrackets = true;
             squareBracketsCount--;
             previousCharacter = char;
             continue;
         }
-        if (char === '{') {
+        if (char === "{") {
             curlyBrackets = true;
             curlyBracketsCount++;
             continue;
         }
-        if (char === '}') {
+        if (char === "}") {
             curlyBrackets = true;
             curlyBracketsCount--;
             previousCharacter = char;
@@ -384,22 +614,33 @@ function isValidGlob(pattern) {
     return false;
 }
 function firstNonGlobParentAndPattern(location) {
-    const segments = location.path.split('/');
+    const segments = location.path.split("/");
     let i = 0;
     while (i < segments.length && isValidGlob(segments[i]) === false) {
         i++;
     }
     if (i === segments.length) {
-        return { parent: location };
+        return {
+            parent: location
+        };
     }
-    const parent = location.with({ path: segments.slice(0, i).join('/') });
-    if (i === segments.length - 1 && segments[i] === '*' || segments[i] === ``) {
-        return { parent };
+    const parent = location.with({
+        path: segments.slice(0, i).join("/")
+    });
+    if (i === segments.length - 1 && segments[i] === "*" || segments[i] === ``) {
+        return {
+            parent
+        };
     }
     return {
         parent,
-        filePattern: segments.slice(i).join('/')
+        filePattern: segments.slice(i).join("/")
     };
 }
+const VALID_PROMPT_FOLDER_PATTERN = "^(?![A-Za-z]:[\\\\/])(?!/)(?!~(?!/))(?!.*\\\\)(?!.*[*?\\[\\]{}]).*\\S.*$";
+const VALID_PROMPT_FOLDER_REGEX = ( new RegExp(VALID_PROMPT_FOLDER_PATTERN));
+function isValidPromptFolderPath(path) {
+    return VALID_PROMPT_FOLDER_REGEX.test(path);
+}
 
-export { PromptFilesLocator, isValidGlob };
+export { PromptFilesLocator, VALID_PROMPT_FOLDER_PATTERN, hasGlobPattern, isValidGlob, isValidPromptFolderPath };