@codingame/monaco-vscode-chat-service-override 37.0.0 → 37.2.0

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

@@ -0,0 +1,872 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 { FileOperation, FileOperationError, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { PromptsConfig, getPromptFileLocationsConfigKey, isTildePath } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { joinPath, dirname, isEqual, isEqualOrParent, basename } 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 { getPromptFileDefaultLocations, getPromptFileType, CLAUDE_CONFIG_FOLDER, GITHUB_CONFIG_FOLDER, COPILOT_CONFIG_FOLDER, getPromptFileExtension, 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 { PromptFileSource, 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';
+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 { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { PromptsStorage, AgentInstructionFileType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { equalsIgnoreCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+
+const MAX_INSTRUCTIONS_RECURSION_DEPTH = 5;
+let PromptFilesLocator = class PromptFilesLocator {
+    constructor(
+        fileService,
+        configService,
+        workspaceService,
+        environmentService,
+        searchService,
+        userDataService,
+        logService,
+        pathService,
+        workspaceTrustManagementService
+    ) {
+        this.fileService = fileService;
+        this.configService = configService;
+        this.workspaceService = workspaceService;
+        this.environmentService = environmentService;
+        this.searchService = searchService;
+        this.userDataService = userDataService;
+        this.logService = logService;
+        this.pathService = pathService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        const userDataPromptsHome = this.userDataService.currentProfile.promptsHome;
+        this.userDataFolder = {
+            uri: userDataPromptsHome,
+            searchRoot: userDataPromptsHome,
+            filePattern: undefined,
+            source: PromptFileSource.UserData,
+            storage: PromptsStorage.user,
+            displayPath: ( localize(10857, "User Data")),
+            isDefault: true
+        };
+    }
+    getWorkspaceFolders() {
+        return this.workspaceService.getWorkspace().folders.filter(f => f.uri.scheme !== AGENT_HOST_SCHEME);
+    }
+    getWorkspaceFolder(resource) {
+        return this.workspaceService.getWorkspaceFolder(resource) ?? undefined;
+    }
+    onDidChangeWorkspaceFolders() {
+        return ( Event.map(this.workspaceService.onDidChangeWorkspaceFolders, () => undefined));
+    }
+    getPromptSourceFolders(type) {
+        return PromptsConfig.promptSourceFolders(this.configService, type);
+    }
+    getDefaultSourceFolders(type) {
+        return getPromptFileDefaultLocations(type);
+    }
+    async getWorkspaceFolderRoots(includeParents, logger, root) {
+        const workspaceFolders = root ? root.scheme === AGENT_HOST_SCHEME ? [] : [{
+            uri: root
+        }] : this.getWorkspaceFolders();
+        if (includeParents) {
+            const roots = ( new ResourceSet());
+            const userHome = await this.pathService.userHome();
+            for (const workspaceFolder of workspaceFolders) {
+                roots.add(workspaceFolder.uri);
+                const parents = await this.findParentRepoFolders(workspaceFolder.uri, userHome, roots, logger);
+                for (const parent of parents) {
+                    roots.add(parent);
+                }
+            }
+            return [...roots];
+        }
+        return ( workspaceFolders.map(f => f.uri));
+    }
+    async findParentRepoFolders(folderUri, userHome, seen, logger) {
+        const candidates = [];
+        let current = folderUri;
+        while (true) {
+            try {
+                const gitStat = await this.fileService.stat(joinPath(current, ".git")).then(stat => stat, () => undefined);
+                const isRepoRoot = gitStat?.isDirectory === true;
+                if (isRepoRoot) {
+                    if ((await this.workspaceTrustManagementService.getUriTrustInfo(current)).trusted) {
+                        candidates.push(current);
+                        return candidates;
+                    }
+                    logger?.logInfo(`Repository root found at ${( current.toString())}, but it is not trusted. Skipping parent folder inclusion for this workspace folder.`);
+                    return [];
+                }
+            } catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                logger?.logInfo(`No repository root found for folder ${( folderUri.toString())}. Error accessing ${joinPath(current, ".git")}: ${msg}.`);
+                return [];
+            }
+            candidates.push(current);
+            const parent = dirname(current);
+            if (isEqual(current, parent) || current.path === "/" || isEqual(userHome, parent) || ( seen.has(parent))) {
+                break;
+            }
+            current = parent;
+        }
+        logger?.logInfo(`No repository root found for folder ${( folderUri.toString())}.`);
+        return [];
+    }
+    async listFiles(type, storage, token, root) {
+        const files = await this.listFilesWithSource(type, storage, token, root);
+        return ( files.map(file => file.uri));
+    }
+    async listFilesWithSource(type, storage, token, root) {
+        if (storage !== PromptsStorage.user && storage !== PromptsStorage.local) {
+            throw ( new Error(`Unsupported prompt file storage: ${storage}`));
+        }
+        const configuredLocations = this.getPromptSourceFolders(type);
+        const localRoot = storage === PromptsStorage.local ? root : undefined;
+        const absoluteLocations = await this.toAbsoluteLocations(
+            type,
+            configuredLocations.filter(location => location.storage === storage),
+            undefined,
+            localRoot
+        );
+        if (storage === PromptsStorage.user && this.isUserDataPromptType(type)) {
+            const localLocations = await this.toAbsoluteLocations(
+                type,
+                configuredLocations.filter(location => location.storage === PromptsStorage.local)
+            );
+            absoluteLocations.push(
+                ...localLocations.filter(location => this.sourceFolderOverlapsUserData(type, location.searchRoot))
+            );
+            absoluteLocations.push(this.userDataFolder);
+        }
+        const paths = ( new ResourceSet());
+        const result = [];
+        for (const {
+            searchRoot,
+            filePattern,
+            source,
+            storage: sourceStorage
+        } of absoluteLocations) {
+            const files = (filePattern === undefined) ?
+            await this.resolveFilesAtLocation(searchRoot, type, token, 0, localRoot) : await this.searchFilesInLocation(searchRoot, filePattern, token);
+            for (const file of files) {
+                if (getPromptFileType(file) !== type || ( paths.has(file))) {
+                    continue;
+                }
+                const isUserDataFile = this.isUserDataPromptFile(type, file);
+                if ((isUserDataFile && storage !== PromptsStorage.user) || (!isUserDataFile && sourceStorage !== storage)) {
+                    continue;
+                }
+                paths.add(file);
+                result.push({
+                    uri: file,
+                    source: isUserDataFile ? PromptFileSource.UserData : source
+                });
+            }
+            if (token.isCancellationRequested) {
+                return [];
+            }
+        }
+        return result;
+    }
+    isUserDataPromptType(type) {
+        return type === PromptsType.agent || type === PromptsType.instructions || type === PromptsType.prompt;
+    }
+    isUserDataPromptFile(type, resource) {
+        return this.isUserDataPromptType(type) && isEqualOrParent(resource, this.userDataFolder.uri);
+    }
+    sourceFolderOverlapsUserData(type, searchRoot) {
+        return this.isUserDataPromptType(type) && (isEqualOrParent(searchRoot, this.userDataFolder.uri) || isEqualOrParent(this.userDataFolder.uri, searchRoot));
+    }
+    createFilesUpdatedEvent(type) {
+        const disposables = ( new DisposableStore());
+        const eventEmitter = disposables.add(( new Emitter()));
+        const token = disposables.add(( new CancellationTokenSource())).token;
+        const externalFolderWatchers = disposables.add(( new DisposableStore()));
+        const key = getPromptFileLocationsConfigKey(type);
+        const userDataFolder = this.userDataService.currentProfile.promptsHome;
+        let parentFolders = [];
+        const updateExternalFolderWatchers = () => {
+            externalFolderWatchers.clear();
+            for (const folder of parentFolders) {
+                if (!this.getWorkspaceFolder(folder.searchRoot)) {
+                    const recursive = folder.filePattern !== undefined || type === PromptsType.instructions;
+                    externalFolderWatchers.add(this.fileService.watch(folder.searchRoot, {
+                        recursive,
+                        excludes: []
+                    }));
+                }
+            }
+        };
+        const update = async () => {
+            try {
+                const configuredLocations = this.getPromptSourceFolders(type);
+                parentFolders = await this.toAbsoluteLocations(type, configuredLocations, undefined);
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                updateExternalFolderWatchers();
+            } catch (err) {
+                this.logService.error(`Error updating prompt file watchers after config change:`, err);
+            }
+        };
+        disposables.add(this.configService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(key) || e.affectsConfiguration(PromptsConfig.USE_CUSTOMIZATIONS_IN_PARENT_REPOS)) {
+                void update();
+                eventEmitter.fire();
+            }
+        }));
+        disposables.add(this.onDidChangeWorkspaceFolders()(() => {
+            void update();
+            eventEmitter.fire();
+        }));
+        disposables.add(this.workspaceTrustManagementService.onDidChangeTrustedFolders(() => {
+            void update();
+            eventEmitter.fire();
+        }));
+        disposables.add(this.fileService.onDidFilesChange(e => {
+            if (e.affects(userDataFolder)) {
+                eventEmitter.fire();
+                return;
+            }
+            if (( parentFolders.some(folder => e.affects(folder.searchRoot)))) {
+                eventEmitter.fire();
+                return;
+            }
+        }));
+        disposables.add(this.fileService.watch(userDataFolder));
+        void update();
+        return {
+            event: eventEmitter.event,
+            dispose: () => disposables.dispose()
+        };
+    }
+    createAgentInstructionsUpdatedEvent() {
+        const disposables = ( new DisposableStore());
+        const eventEmitter = disposables.add(( new Emitter()));
+        const cts = ( new CancellationTokenSource());
+        disposables.add(toDisposable(() => cts.dispose(true)));
+        const token = cts.token;
+        const watchers = disposables.add(( new DisposableStore()));
+        const watchedRoots = ( new ResourceSet());
+        const addWatch = resource => {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            if (( watchedRoots.has(resource))) {
+                return;
+            }
+            watchedRoots.add(resource);
+            watchers.add(this.fileService.watch(resource));
+        };
+        const updateWatchers = async () => {
+            watchers.clear();
+            watchedRoots.clear();
+            const watchWorkspaceRoots = this.configService.getValue(PromptsConfig.USE_AGENT_MD) || this.configService.getValue(PromptsConfig.USE_CLAUDE_MD);
+            const watchClaudeFolders = this.configService.getValue(PromptsConfig.USE_CLAUDE_MD);
+            const watchCopilotFolders = this.configService.getValue(PromptsConfig.USE_COPILOT_INSTRUCTION_FILES);
+            const includeParents = this.configService.getValue(PromptsConfig.USE_CUSTOMIZATIONS_IN_PARENT_REPOS) === true;
+            const workspaceRoots = await this.getWorkspaceFolderRoots(includeParents);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const userHome = await this.pathService.userHome();
+            if (token.isCancellationRequested) {
+                return;
+            }
+            for (const workspaceRoot of workspaceRoots) {
+                if (watchWorkspaceRoots) {
+                    addWatch(workspaceRoot);
+                }
+                if (watchClaudeFolders) {
+                    addWatch(joinPath(workspaceRoot, CLAUDE_CONFIG_FOLDER));
+                }
+                if (watchCopilotFolders) {
+                    addWatch(joinPath(workspaceRoot, GITHUB_CONFIG_FOLDER));
+                }
+            }
+            if (watchClaudeFolders) {
+                addWatch(joinPath(userHome, CLAUDE_CONFIG_FOLDER));
+            }
+            if (watchCopilotFolders) {
+                addWatch(joinPath(userHome, COPILOT_CONFIG_FOLDER));
+            }
+        };
+        const refresh = () => {
+            void updateWatchers();
+            eventEmitter.fire();
+        };
+        disposables.add(this.configService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(PromptsConfig.USE_AGENT_MD) || e.affectsConfiguration(PromptsConfig.USE_CLAUDE_MD) || e.affectsConfiguration(PromptsConfig.USE_COPILOT_INSTRUCTION_FILES) || e.affectsConfiguration(PromptsConfig.USE_CUSTOMIZATIONS_IN_PARENT_REPOS)) {
+                refresh();
+            }
+        }));
+        disposables.add(this.onDidChangeWorkspaceFolders()(() => {
+            refresh();
+        }));
+        disposables.add(this.workspaceTrustManagementService.onDidChangeTrustedFolders(() => {
+            refresh();
+        }));
+        disposables.add(this.fileService.onDidFilesChange(e => {
+            for (const watchedRoot of watchedRoots) {
+                if (e.affects(watchedRoot)) {
+                    eventEmitter.fire();
+                    return;
+                }
+            }
+        }));
+        disposables.add(this.fileService.onDidRunOperation(e => {
+            for (const watchedRoot of watchedRoots) {
+                if (isEqualOrParent(e.resource, watchedRoot)) {
+                    eventEmitter.fire();
+                    return;
+                }
+                if (e.isOperation(FileOperation.CREATE) || e.isOperation(FileOperation.MOVE) || e.isOperation(FileOperation.COPY)) {
+                    if (isEqualOrParent(e.target.resource, watchedRoot)) {
+                        eventEmitter.fire();
+                        return;
+                    }
+                }
+            }
+        }));
+        void updateWatchers();
+        return {
+            event: eventEmitter.event,
+            dispose: () => disposables.dispose()
+        };
+    }
+    async getHookSourceFolders() {
+        const configuredLocations = this.getPromptSourceFolders(PromptsType.hook);
+        const allowedHookFolders = configuredLocations.filter(loc => !loc.path.startsWith(".claude/") && !loc.path.includes("/.claude/"));
+        const absoluteLocations = await this.toAbsoluteLocations(PromptsType.hook, allowedHookFolders);
+        const seen = ( new ResourceSet());
+        const result = [];
+        for (const location of absoluteLocations) {
+            if (!( seen.has(location.searchRoot))) {
+                seen.add(location.searchRoot);
+                result.push({
+                    ...location,
+                    uri: location.searchRoot,
+                    filePattern: undefined
+                });
+            }
+        }
+        return result;
+    }
+    async getConfigBasedSourceFolders(type) {
+        const configuredLocations = this.getPromptSourceFolders(type);
+        const absoluteLocations = await this.toAbsoluteLocations(type, configuredLocations);
+        if (type !== PromptsType.prompt && type !== PromptsType.instructions) {
+            return ( absoluteLocations.map(l => l.uri));
+        }
+        const result = ( new ResourceSet());
+        for (const absoluteLocation of absoluteLocations) {
+            let location = absoluteLocation.uri;
+            const baseName = basename(location);
+            const filePatterns = ["*.md", `*${getPromptFileExtension(type)}`];
+            for (const filePattern of filePatterns) {
+                if (baseName === filePattern) {
+                    location = dirname(location);
+                    continue;
+                }
+            }
+            if (baseName === "*") {
+                location = dirname(location);
+            }
+            if (isValidGlob(location.path) === true) {
+                continue;
+            }
+            result.add(location);
+        }
+        return [...result];
+    }
+    async getResolvedSourceFolders(type) {
+        const absoluteLocations = await this.getLocalStorageFolders(type);
+        const localFolders = absoluteLocations.filter(loc => loc.storage === PromptsStorage.local);
+        const userFolders = absoluteLocations.filter(loc => loc.storage === PromptsStorage.user);
+        return this.dedupeSourceFolders([...localFolders, ...userFolders]);
+    }
+    async getSourceFoldersInDiscoveryOrder(type) {
+        const absoluteLocations = await this.getLocalStorageFolders(type);
+        const userFolders = absoluteLocations.filter(loc => loc.storage === PromptsStorage.user);
+        const localFolders = absoluteLocations.filter(loc => loc.storage === PromptsStorage.local);
+        return this.dedupeSourceFolders([...userFolders, ...localFolders]);
+    }
+    async getLocalStorageFolders(type) {
+        const configuredLocations = this.getPromptSourceFolders(type);
+        const defaultFolders = this.getDefaultSourceFolders(type);
+        const isConfigured = PromptsConfig.getLocationsValue(this.configService, type) !== undefined;
+        const allFolders = isConfigured ? configuredLocations : defaultFolders;
+        const absoluteLocations = await this.toAbsoluteLocations(type, allFolders, defaultFolders);
+        if (type === PromptsType.agent || type === PromptsType.instructions || type === PromptsType.prompt) {
+            absoluteLocations.push(this.userDataFolder);
+        }
+        return absoluteLocations;
+    }
+    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 toAbsoluteLocations(type, configuredLocations, defaultLocations, root) {
+        const result = [];
+        const seen = ( new ResourceSet());
+        const userHome = await this.pathService.userHome();
+        const rootFolders = await this.getWorkspaceFolderRoots(
+            this.configService.getValue(PromptsConfig.USE_CUSTOMIZATIONS_IN_PARENT_REPOS) === true,
+            undefined,
+            root
+        );
+        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)) {
+                    const uri = joinPath(userHome, configuredLocation.substring(2));
+                    if (!( seen.has(uri))) {
+                        seen.add(uri);
+                        const {
+                            searchRoot,
+                            filePattern
+                        } = resolveSearchLocation(type, uri);
+                        result.push({
+                            uri,
+                            searchRoot: searchRoot,
+                            filePattern,
+                            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
+                        });
+                    }
+                    if (!( seen.has(uri))) {
+                        seen.add(uri);
+                        const {
+                            searchRoot,
+                            filePattern
+                        } = resolveSearchLocation(type, uri);
+                        result.push({
+                            uri,
+                            searchRoot: searchRoot,
+                            filePattern,
+                            source: sourceFolder.source,
+                            storage: sourceFolder.storage,
+                            displayPath: configuredLocation,
+                            isDefault
+                        });
+                    }
+                } else {
+                    for (const folder of rootFolders) {
+                        const absolutePath = joinPath(folder, configuredLocation);
+                        if (!( seen.has(absolutePath))) {
+                            seen.add(absolutePath);
+                            const {
+                                searchRoot,
+                                filePattern
+                            } = resolveSearchLocation(type, absolutePath);
+                            result.push({
+                                uri: absolutePath,
+                                searchRoot: searchRoot,
+                                filePattern,
+                                source: sourceFolder.source,
+                                storage: sourceFolder.storage,
+                                displayPath: configuredLocation,
+                                isDefault
+                            });
+                        }
+                    }
+                }
+            } catch (error) {
+                this.logService.error(`Failed to resolve prompt file location: ${configuredLocation}`, error);
+            }
+        }
+        return result;
+    }
+    async resolveFilesAtLocation(location, type, token, depth = 0, root) {
+        if (type === PromptsType.skill) {
+            return this.findAgentSkillsInFolder(location, token);
+        }
+        const isWorkspaceRoot = depth === 0 && (root ? isEqual(root, location) : ( this.getWorkspaceFolders().some(f => isEqual(f.uri, location))));
+        const recursive = type === PromptsType.instructions && !isWorkspaceRoot && !hasGlobPattern(location.path) && depth < MAX_INSTRUCTIONS_RECURSION_DEPTH;
+        try {
+            const info = await this.fileService.resolve(location);
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            if (info.isFile) {
+                return [info.resource];
+            } else if (info.isDirectory && info.children) {
+                const result = [];
+                for (const child of info.children) {
+                    if (child.isFile) {
+                        result.push(child.resource);
+                    } else if (recursive && child.isDirectory) {
+                        const subFiles = await this.resolveFilesAtLocation(child.resource, type, token, depth + 1, root);
+                        result.push(...subFiles);
+                    }
+                }
+                return result;
+            }
+        } catch (e) {
+            if (e instanceof FileOperationError && e.fileOperationResult === FileOperationResult.FILE_NOT_FOUND)
+                ; else {
+                this.logService.error(`Failed to resolve files at location: ${( location.toString())}`, e);
+            }
+        }
+        return [];
+    }
+    async searchFilesInLocation(folder, filePattern, token) {
+        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.getWorkspaceFolder(folder);
+        const getExcludePattern = folder => getExcludes(this.configService.getValue({
+            resource: folder
+        })) || {};
+        const searchOptions = {
+            folderQueries: [{
+                folder,
+                disregardIgnoreFiles
+            }],
+            type: QueryType.File,
+            shouldGlobMatchFilePattern: true,
+            excludePattern: workspaceRoot ? getExcludePattern(workspaceRoot.uri) : undefined,
+            ignoreGlobCase: true,
+            sortByScore: true,
+            filePattern
+        };
+        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 [];
+    }
+    async findAgentMDsInWorkspace(token) {
+        const result = await Promise.all(( this.getWorkspaceFolders().map(folder => this.findAgentMDsInFolder(folder.uri, token))));
+        return result.flat(1);
+    }
+    async findAgentMDsInFolder(folder, token) {
+        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 [];
+                }
+                const results = [];
+                for (const r of searchResult.results) {
+                    const realPath = undefined;
+                    results.push({
+                        uri: r.resource,
+                        realPath,
+                        type: AgentInstructionFileType.agentsMd
+                    });
+                }
+                return results;
+            } catch (e) {
+                if (!isCancellationError(e)) {
+                    throw e;
+                }
+            }
+            return [];
+        } else {
+            return this.findAgentMDsUsingFileService(folder, token);
+        }
+    }
+    async findAgentMDsUsingFileService(folder, token) {
+        const result = [];
+        const agentsMdFileName = "agents.md";
+        const traverse = async uri => {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            try {
+                const stat = await this.fileService.resolve(uri);
+                if (stat.isFile && stat.name.toLowerCase() === agentsMdFileName) {
+                    const realPath = stat.isSymbolicLink ? await this.fileService.realpath(stat.resource) : undefined;
+                    result.push({
+                        uri: stat.resource,
+                        realPath,
+                        type: AgentInstructionFileType.agentsMd
+                    });
+                } 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 findFilesInRoots(roots, folder, paths, token, result = []) {
+        const toResolve = ( roots.map(root => ({
+            resource: folder !== undefined ? joinPath(root, folder) : root
+        })));
+        const resolvedRoots = await this.fileService.resolveAll(toResolve);
+        if (token.isCancellationRequested) {
+            return result;
+        }
+        for (const root of resolvedRoots) {
+            if (root.success && root.stat?.children) {
+                for (const child of root.stat.children) {
+                    if (child.isFile) {
+                        const matchingPath = paths.find(p => equalsIgnoreCase(p.fileName, child.name));
+                        if (matchingPath) {
+                            const realPath = child.isSymbolicLink ? await this.fileService.realpath(child.resource) : undefined;
+                            result.push({
+                                uri: child.resource,
+                                realPath,
+                                type: matchingPath.type
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    getAgentFileURIFromModeFile(oldURI) {
+        if (oldURI.path.endsWith(LEGACY_MODE_FILE_EXTENSION)) {
+            let newLocation;
+            const workspaceFolder = this.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
+                );
+            }
+            return newLocation;
+        }
+        return undefined;
+    }
+    async findAgentSkillsInFolder(uri, token) {
+        try {
+            const result = [];
+            const stat = await this.fileService.resolve(uri);
+            if (stat.isDirectory && stat.children) {
+                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) {}
+                }
+            }
+            return result;
+        } catch (e) {
+            if (!isCancellationError(e)) {
+                this.logService.trace(`[PromptFilesLocator] Error searching for skills in ${( uri.toString())}: ${e}`);
+            }
+            return [];
+        }
+    }
+    async findAgentSkills(token) {
+        const configuredLocations = this.getPromptSourceFolders(PromptsType.skill);
+        const absoluteLocations = await this.toAbsoluteLocations(PromptsType.skill, configuredLocations);
+        const allResults = [];
+        for (const {
+            uri,
+            source,
+            storage
+        } of absoluteLocations) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            const results = await this.findAgentSkillsInFolder(uri, token);
+            for (const skillUri of results) {
+                allResults.push({
+                    uri: skillUri,
+                    source,
+                    storage,
+                    type: PromptsType.skill
+                });
+            }
+        }
+        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)), ( __param(8, IWorkspaceTrustManagementService))], PromptFilesLocator));
+function hasGlobPattern(path) {
+    return path.includes("*");
+}
+function isValidGlob(pattern) {
+    let squareBrackets = false;
+    let squareBracketsCount = 0;
+    let curlyBrackets = false;
+    let curlyBracketsCount = 0;
+    let previousCharacter;
+    for (const char of pattern) {
+        if (previousCharacter === "\\") {
+            previousCharacter = char;
+            continue;
+        }
+        if (char === "*") {
+            return true;
+        }
+        if (char === "?") {
+            return true;
+        }
+        if (char === "[") {
+            squareBrackets = true;
+            squareBracketsCount++;
+            previousCharacter = char;
+            continue;
+        }
+        if (char === "]") {
+            squareBrackets = true;
+            squareBracketsCount--;
+            previousCharacter = char;
+            continue;
+        }
+        if (char === "{") {
+            curlyBrackets = true;
+            curlyBracketsCount++;
+            continue;
+        }
+        if (char === "}") {
+            curlyBrackets = true;
+            curlyBracketsCount--;
+            previousCharacter = char;
+            continue;
+        }
+        previousCharacter = char;
+    }
+    if (squareBrackets && (squareBracketsCount === 0)) {
+        return true;
+    }
+    if (curlyBrackets && (curlyBracketsCount === 0)) {
+        return true;
+    }
+    return false;
+}
+function resolveSearchLocation(type, location) {
+    if (type !== PromptsType.instructions && type !== PromptsType.prompt) {
+        return {
+            searchRoot: location
+        };
+    }
+    const segments = location.path.split("/");
+    let i = 0;
+    while (i < segments.length && isValidGlob(segments[i]) === false) {
+        i++;
+    }
+    if (i === segments.length) {
+        return {
+            searchRoot: location
+        };
+    }
+    const parent = location.with({
+        path: segments.slice(0, i).join("/")
+    });
+    if (i === segments.length - 1 && segments[i] === "*" || segments[i] === ``) {
+        return {
+            searchRoot: parent
+        };
+    }
+    return {
+        searchRoot: parent,
+        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, VALID_PROMPT_FOLDER_PATTERN, hasGlobPattern, isValidGlob, isValidPromptFolderPath };