@codingame/monaco-vscode-chat-service-override 17.2.1 → 18.0.0

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

@@ -1,82 +1,193 @@
 
 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 { match } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
 import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 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 { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
-import { PromptsConfig } from '@codingame/monaco-vscode-51fed910-d648-5620-9b80-9232cd79d116-common/vscode/vs/platform/prompts/common/config';
-import { basename, dirname, extUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { PromptsConfig } from '@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/config';
+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 { PROMPT_FILE_EXTENSION, getPromptFileType } from '@codingame/monaco-vscode-51fed910-d648-5620-9b80-9232cd79d116-common/vscode/vs/platform/prompts/common/constants';
+import { getPromptFileType, getPromptFileLocationsConfigKey, getPromptFileExtension } from '@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/prompts';
+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 { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+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 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 
-let PromptFilesLocator = class PromptFilesLocator {
-    constructor(fileService, configService, workspaceService) {
+let PromptFilesLocator = class PromptFilesLocator extends Disposable {
+    constructor(fileService, configService, workspaceService, environmentService, searchService, userDataService) {
+        super();
         this.fileService = fileService;
         this.configService = configService;
         this.workspaceService = workspaceService;
+        this.environmentService = environmentService;
+        this.searchService = searchService;
+        this.userDataService = userDataService;
     }
-    async listFiles(type) {
-        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
-        const absoluteLocations = toAbsoluteLocations(configuredLocations, this.workspaceService);
-        return await this.listFilesIn(absoluteLocations, type);
+    async listFiles(type, storage, token) {
+        if (storage === 'local') {
+            return await this.listFilesInLocal(type, token);
+        }
+        else {
+            return await this.listFilesInUserData(type, token);
+        }
+    }
+    async listFilesInUserData(type, token) {
+        const files = await this.resolveFilesAtLocation(this.userDataService.currentProfile.promptsHome, token);
+        return files.filter(file => getPromptFileType(file) === type);
     }
-    async listFilesIn(folders, type) {
-        return await this.findFilesInLocations(folders, type);
+    getFilesUpdatedEvent(type) {
+        const eventEmitter = this._register(( new Emitter()));
+        const key = getPromptFileLocationsConfigKey(type);
+        let parentFolders = ( this.getLocalParentFolders(type).map(folder => folder.parent));
+        this._register(this.configService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(key)) {
+                parentFolders = ( this.getLocalParentFolders(type).map(folder => folder.parent));
+                eventEmitter.fire();
+            }
+        }));
+        this._register(this.fileService.onDidFilesChange(e => {
+            if (e.affects(this.userDataService.currentProfile.promptsHome)) {
+                eventEmitter.fire();
+                return;
+            }
+            if (( parentFolders.some(folder => e.affects(folder)))) {
+                eventEmitter.fire();
+                return;
+            }
+        }));
+        this._register(this.fileService.watch(this.userDataService.currentProfile.promptsHome));
+        return eventEmitter.event;
     }
     getConfigBasedSourceFolders(type) {
         const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
-        const absoluteLocations = toAbsoluteLocations(configuredLocations, this.workspaceService);
+        const absoluteLocations = this.toAbsoluteLocations(configuredLocations);
         const result = ( new ResourceSet());
-        for (const absoluteLocation of absoluteLocations) {
-            let { path } = absoluteLocation;
+        for (let absoluteLocation of absoluteLocations) {
             const baseName = basename(absoluteLocation);
-            const filePatterns = ['*.md', `*${PROMPT_FILE_EXTENSION}`];
+            const filePatterns = ['*.md', `*${getPromptFileExtension(type)}`];
             for (const filePattern of filePatterns) {
                 if (baseName === filePattern) {
-                    path = URI.joinPath(absoluteLocation, '..').path;
+                    absoluteLocation = dirname(absoluteLocation);
                     continue;
                 }
             }
             if (baseName === '*') {
-                path = URI.joinPath(absoluteLocation, '..').path;
+                absoluteLocation = dirname(absoluteLocation);
             }
-            if (isValidGlob(path) === true) {
+            if (isValidGlob(absoluteLocation.path) === true) {
                 continue;
             }
-            result.add(absoluteLocation.with({ path }));
+            result.add(absoluteLocation);
         }
         return [...result];
     }
-    async findFilesInLocations(absoluteLocations, type) {
+    async listFilesInLocal(type, token) {
         const paths = ( new ResourceSet());
-        for (const absoluteLocation of absoluteLocations) {
-            assert(isAbsolute(absoluteLocation.path), `Provided location must be an absolute path, got '${absoluteLocation.path}'.`);
-            const nonGlobParent = firstNonGlobParent(absoluteLocation);
-            if (nonGlobParent === absoluteLocation) {
-                const promptFiles = await findFilesInLocation(absoluteLocation, type, this.fileService);
-                for (const file of promptFiles) {
+        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 file of files) {
+                if (getPromptFileType(file) === type) {
                     paths.add(file);
                 }
             }
+            if (token.isCancellationRequested) {
+                return [];
+            }
+        }
+        return [...paths];
+    }
+    getLocalParentFolders(type) {
+        const configuredLocations = PromptsConfig.promptSourceFolders(this.configService, type);
+        const absoluteLocations = this.toAbsoluteLocations(configuredLocations);
+        return ( absoluteLocations.map(firstNonGlobParentAndPattern));
+    }
+    toAbsoluteLocations(configuredLocations) {
+        const result = ( new ResourceSet());
+        const { folders } = this.workspaceService.getWorkspace();
+        for (const configuredLocation of configuredLocations) {
+            if (isAbsolute(configuredLocation)) {
+                const remoteAuthority = this.environmentService.remoteAuthority;
+                if (remoteAuthority) {
+                    result.add(( URI.from(
+                        { scheme: Schemas.vscodeRemote, authority: remoteAuthority, path: configuredLocation }
+                    )));
+                }
+                else {
+                    result.add(URI.file(configuredLocation));
+                }
+            }
             else {
-                const promptFiles = await findFilesInLocation(nonGlobParent, type, this.fileService);
-                for (const file of promptFiles) {
-                    if (match(absoluteLocation.path, file.path)) {
-                        paths.add(file);
+                for (const workspaceFolder of folders) {
+                    const absolutePath = joinPath(workspaceFolder.uri, configuredLocation);
+                    assert(isAbsolute(absolutePath.path), `Provided location must be an absolute path, got '${absolutePath.path}'.`);
+                    result.add(absolutePath);
+                }
+            }
+        }
+        return [...result];
+    }
+    async resolveFilesAtLocation(location, token) {
+        try {
+            const info = await this.fileService.resolve(location);
+            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);
                     }
                 }
+                return result;
             }
         }
-        return [...paths];
+        catch (error) {
+        }
+        return [];
+    }
+    async searchFilesInLocation(folder, filePattern, token) {
+        const disregardIgnoreFiles = this.configService.getValue('explorer.excludeGitIgnore');
+        const workspaceRoot = this.workspaceService.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,
+            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 [];
     }
 };
 PromptFilesLocator = ( __decorate([
     ( __param(0, IFileService)),
     ( __param(1, IConfigurationService)),
-    ( __param(2, IWorkspaceContextService))
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, ISearchService)),
+    ( __param(5, IUserDataProfileService))
 ], PromptFilesLocator));
 const isValidGlob = (pattern) => {
     let squareBrackets = false;
@@ -128,72 +239,23 @@ const isValidGlob = (pattern) => {
     }
     return false;
 };
-const firstNonGlobParent = (location) => {
-    assert(isAbsolute(location.path), `Provided location must be an absolute path, got '${location.path}'.`);
-    if (isValidGlob(location.path) === false) {
-        return location;
-    }
-    const parent = dirname(location);
-    if (extUri.isEqual(parent, location)) {
-        return location;
-    }
-    return firstNonGlobParent(parent);
-};
-const findFilesInLocation = async (location, type, fileService) => {
-    const result = [];
-    try {
-        const info = await fileService.resolve(location);
-        if (info.isFile && getPromptFileType(info.resource) === type) {
-            result.push(info.resource);
-            return result;
-        }
-        if (info.isDirectory && info.children) {
-            for (const child of info.children) {
-                if (child.isFile && getPromptFileType(child.resource) === type) {
-                    result.push(child.resource);
-                    continue;
-                }
-                if (child.isDirectory) {
-                    const promptFiles = await findFilesInLocation(child.resource, type, fileService);
-                    result.push(...promptFiles);
-                    continue;
-                }
-            }
-            return result;
-        }
+const firstNonGlobParentAndPattern = (location) => {
+    const segments = location.path.split('/');
+    let i = 0;
+    while (i < segments.length && isValidGlob(segments[i]) === false) {
+        i++;
     }
-    catch (error) {
+    if (i === segments.length) {
+        return { parent: location };
     }
-    return result;
-};
-const toAbsoluteLocations = (configuredLocations, workspaceService) => {
-    const result = ( new ResourceSet());
-    const { folders } = workspaceService.getWorkspace();
-    for (const configuredLocation of configuredLocations) {
-        if (isAbsolute(configuredLocation)) {
-            result.add(URI.file(configuredLocation));
-            continue;
-        }
-        for (const workspaceFolder of folders) {
-            const absolutePath = extUri.resolvePath(workspaceFolder.uri, configuredLocation);
-            assert(isAbsolute(absolutePath.path), `Provided location must be an absolute path, got '${absolutePath.path}'.`);
-            if (( result.has(absolutePath)) === false) {
-                result.add(absolutePath);
-            }
-            if (folders.length <= 1) {
-                continue;
-            }
-            const workspaceRootUri = dirname(workspaceFolder.uri);
-            const workspaceFolderUri = extUri.resolvePath(workspaceRootUri, configuredLocation);
-            if (( result.has(workspaceFolderUri)) === true) {
-                continue;
-            }
-            if (workspaceFolderUri.fsPath.startsWith(workspaceFolder.uri.fsPath)) {
-                result.add(workspaceFolderUri);
-            }
-        }
+    const parent = location.with({ path: segments.slice(0, i).join('/') });
+    if (i === segments.length - 1 && segments[i] === '*' || segments[i] === ``) {
+        return { parent };
     }
-    return [...result];
+    return {
+        parent,
+        filePattern: segments.slice(i).join('/')
+    };
 };
 
-export { PromptFilesLocator, firstNonGlobParent, isValidGlob };
+export { PromptFilesLocator, isValidGlob };

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

@@ -1,10 +1,22 @@
 export type TTree<TTreenNode> = {
     children?: readonly TTree<TTreenNode>[];
 } & TTreenNode;
-export declare const flatten: <TTreeNode>(treeRoot: TTree<TTreeNode>) => Omit<TTreeNode, "children">[];
+export declare const flatten: <TTreeNode>(treeRoot: TTree<TTreeNode>) => TTreeNode[];
 export declare const forEach: <TTreeNode>(callback: (node: TTreeNode) => boolean, treeRoot: TTree<TTreeNode>) => ReturnType<typeof callback>;
 export declare const map: <TTreeNode extends object, TNewTreeNode extends object>(callback: (originalNode: Readonly<TTree<TTreeNode>>, newChildren: Readonly<TNewTreeNode>[] | undefined) => TTree<TNewTreeNode>, treeRoot: TTree<TTreeNode>) => TTree<TNewTreeNode>;
-type TRestParameters<T extends (...args: any[]) => any> = T extends (first: any, ...rest: infer R) => any ? R : never;
-type TCurriedFunction<T extends (...args: any[]) => any> = ((...args: TRestParameters<T>) => ReturnType<T>);
+type TComparable<T> = T & {
+    equals: (other: T) => boolean;
+};
+type TDiff<TObject1, TObject2> = {
+    readonly object1: TObject1;
+    readonly object2: TObject2;
+};
+type TDifference<T> = TDiff<T, T | null> | TDiff<T | null, T>;
+type TDiffTree<T> = TTree<TDifference<T> & {
+    readonly index: number;
+}>;
+export declare function difference<T extends NonNullable<unknown>>(tree1: TTree<TComparable<T>>, tree2: TTree<TComparable<T>>): TDiffTree<T> | null;
+type TRestParameters<T extends (...args: any[]) => unknown> = T extends (first: Parameters<T>[0], ...rest: infer R) => unknown ? R : never;
+type TCurriedFunction<T extends (...args: any[]) => unknown> = ((...args: TRestParameters<T>) => ReturnType<T>);
 export declare const curry: <T, K>(callback: (arg1: T, ...args: any[]) => K, arg1: T) => TCurriedFunction<typeof callback>;
 export {};

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

@@ -1,4 +1,5 @@
 
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 
 const flatten = (treeRoot) => {
     const result = [];
@@ -8,18 +9,5 @@ const flatten = (treeRoot) => {
     }
     return result;
 };
-const forEach = (callback, treeRoot) => {
-    const shouldStop = callback(treeRoot);
-    if (shouldStop === true) {
-        return true;
-    }
-    for (const child of treeRoot.children ?? []) {
-        const shouldStop = forEach(callback, child);
-        if (shouldStop === true) {
-            return true;
-        }
-    }
-    return false;
-};
 
-export { flatten, forEach };
+export { flatten };

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution.d.ts

@@ -1,5 +1,4 @@
 import { IJSONSchema } from "@codingame/monaco-vscode-api/vscode/vs/base/common/jsonSchema";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
@@ -18,8 +17,15 @@ export interface IRawToolContribution {
     inputSchema?: IJSONSchema;
     canBeReferencedInPrompt?: boolean;
 }
+export interface IRawToolSetContribution {
+    name: string;
+    referenceName?: string;
+    description: string;
+    icon?: string;
+    tools: string[];
+}
 export declare class LanguageModelToolsExtensionPointHandler implements IWorkbenchContribution {
     static readonly ID = "workbench.contrib.toolsExtensionPointHandler";
     private _registrationDisposables;
-    constructor(languageModelToolsService: ILanguageModelToolsService, logService: ILogService, productService: IProductService);
+    constructor(productService: IProductService, languageModelToolsService: ILanguageModelToolsService);
 }