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

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

@@ -0,0 +1,247 @@
+
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { splitLinesIncludeSeparators } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { parse } from '../../../../../../base/common/yaml.js';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { chatVariableLeader } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+
+class NewPromptsParser {
+    constructor() {
+    }
+    parse(uri, content) {
+        const linesWithEOL = splitLinesIncludeSeparators(content);
+        if (linesWithEOL.length === 0) {
+            return ( new ParsedPromptFile(uri, undefined, undefined));
+        }
+        let header = undefined;
+        let body = undefined;
+        let bodyStartLine = 0;
+        if (linesWithEOL[0].match(/^---[\s\r\n]*$/)) {
+            let headerEndLine = linesWithEOL.findIndex((line, index) => index > 0 && line.match(/^---[\s\r\n]*$/));
+            if (headerEndLine === -1) {
+                headerEndLine = linesWithEOL.length;
+                bodyStartLine = linesWithEOL.length;
+            }
+            else {
+                bodyStartLine = headerEndLine + 1;
+            }
+            const range = ( new Range(2, 1, headerEndLine + 1, 1));
+            header = ( new PromptHeader(range, linesWithEOL));
+        }
+        if (bodyStartLine < linesWithEOL.length) {
+            const range = ( new Range(bodyStartLine + 1, 1, linesWithEOL.length + 1, 1));
+            body = ( new PromptBody(range, linesWithEOL, uri));
+        }
+        return ( new ParsedPromptFile(uri, header, body));
+    }
+}
+class ParsedPromptFile {
+    constructor(uri, header, body) {
+        this.uri = uri;
+        this.header = header;
+        this.body = body;
+    }
+}
+class PromptHeader {
+    constructor(range, linesWithEOL) {
+        this.range = range;
+        this.linesWithEOL = linesWithEOL;
+    }
+    get _parsedHeader() {
+        if (this._parsed === undefined) {
+            const yamlErrors = [];
+            const lines = this.linesWithEOL.slice(this.range.startLineNumber - 1, this.range.endLineNumber - 1).join('');
+            const node = parse(lines, yamlErrors);
+            const attributes = [];
+            const errors = ( yamlErrors.map(
+                err => ({ message: err.message, range: this.asRange(err), code: err.code })
+            ));
+            if (node) {
+                if (node.type !== 'object') {
+                    errors.push({ message: 'Invalid header, expecting <key: value> pairs', range: this.range, code: 'INVALID_YAML' });
+                }
+                else {
+                    for (const property of node.properties) {
+                        attributes.push({
+                            key: property.key.value,
+                            range: this.asRange({ start: property.key.start, end: property.value.end }),
+                            value: this.asValue(property.value)
+                        });
+                    }
+                }
+            }
+            this._parsed = { node, attributes, errors };
+        }
+        return this._parsed;
+    }
+    asRange({ start, end }) {
+        return ( new Range(
+            this.range.startLineNumber + start.line,
+            start.character + 1,
+            this.range.startLineNumber + end.line,
+            end.character + 1
+        ));
+    }
+    asValue(node) {
+        switch (node.type) {
+            case 'string':
+                return { type: 'string', value: node.value, range: this.asRange(node) };
+            case 'number':
+                return { type: 'number', value: node.value, range: this.asRange(node) };
+            case 'boolean':
+                return { type: 'boolean', value: node.value, range: this.asRange(node) };
+            case 'null':
+                return { type: 'null', value: node.value, range: this.asRange(node) };
+            case 'array':
+                return { type: 'array', items: ( node.items.map(item => this.asValue(item))), range: this.asRange(node) };
+            case 'object': {
+                const properties = ( node.properties.map(
+                    property => ({ key: this.asValue(property.key), value: this.asValue(property.value) })
+                ));
+                return { type: 'object', properties, range: this.asRange(node) };
+            }
+        }
+    }
+    get attributes() {
+        return this._parsedHeader.attributes;
+    }
+    getAttribute(key) {
+        return this._parsedHeader.attributes.find(attr => attr.key === key);
+    }
+    get errors() {
+        return this._parsedHeader.errors;
+    }
+    getStringAttribute(key) {
+        const attribute = this._parsedHeader.attributes.find(attr => attr.key === key);
+        if (attribute?.value.type === 'string') {
+            return attribute.value.value;
+        }
+        return undefined;
+    }
+    get description() {
+        return this.getStringAttribute('description');
+    }
+    get mode() {
+        return this.getStringAttribute('mode');
+    }
+    get model() {
+        return this.getStringAttribute('model');
+    }
+    get applyTo() {
+        return this.getStringAttribute('applyTo');
+    }
+    get tools() {
+        const toolsAttribute = this._parsedHeader.attributes.find(attr => attr.key === 'tools');
+        if (!toolsAttribute) {
+            return undefined;
+        }
+        if (toolsAttribute.value.type === 'array') {
+            const tools = [];
+            for (const item of toolsAttribute.value.items) {
+                if (item.type === 'string' && item.value) {
+                    tools.push(item.value);
+                }
+            }
+            return tools;
+        }
+        else if (toolsAttribute.value.type === 'object') {
+            const tools = [];
+            const collectLeafs = ({ key, value }) => {
+                if (value.type === 'boolean') {
+                    tools.push(key.value);
+                }
+                else if (value.type === 'object') {
+                    value.properties.forEach(collectLeafs);
+                }
+            };
+            toolsAttribute.value.properties.forEach(collectLeafs);
+            return tools;
+        }
+        return undefined;
+    }
+}
+class PromptBody {
+    constructor(range, linesWithEOL, uri) {
+        this.range = range;
+        this.linesWithEOL = linesWithEOL;
+        this.uri = uri;
+    }
+    get fileReferences() {
+        return this.getParsedBody().fileReferences;
+    }
+    get variableReferences() {
+        return this.getParsedBody().variableReferences;
+    }
+    get offset() {
+        return this.getParsedBody().bodyOffset;
+    }
+    getParsedBody() {
+        if (this._parsed === undefined) {
+            const markdownLinkRanges = [];
+            const fileReferences = [];
+            const variableReferences = [];
+            const bodyOffset = Iterable.reduce(Iterable.slice(this.linesWithEOL, 0, this.range.startLineNumber - 1), (len, line) => line.length + len, 0);
+            for (let i = this.range.startLineNumber - 1, lineStartOffset = bodyOffset; i < this.range.endLineNumber - 1; i++) {
+                const line = this.linesWithEOL[i];
+                const linkMatch = line.matchAll(/\[(.*?)\]\((.+?)\)/g);
+                for (const match of linkMatch) {
+                    const linkEndOffset = match.index + match[0].length - 1;
+                    const linkStartOffset = match.index + match[0].length - match[2].length - 1;
+                    const range = ( new Range(i + 1, linkStartOffset + 1, i + 1, linkEndOffset + 1));
+                    fileReferences.push({ content: match[2], range, isMarkdownLink: true });
+                    markdownLinkRanges.push(( new Range(i + 1, match.index + 1, i + 1, match.index + match[0].length + 1)));
+                }
+                const reg = ( new RegExp(`${chatVariableLeader}([\\w]+:)?([^\\s#]+)`, 'g'));
+                const matches = line.matchAll(reg);
+                for (const match of matches) {
+                    const fullRange = ( new Range(i + 1, match.index + 1, i + 1, match.index + match[0].length + 1));
+                    if (( markdownLinkRanges.some(mdRange => Range.areIntersectingOrTouching(mdRange, fullRange)))) {
+                        continue;
+                    }
+                    const varType = match[1];
+                    if (varType) {
+                        if (varType === 'file:') {
+                            const linkStartOffset = match.index + match[0].length - match[2].length;
+                            const linkEndOffset = match.index + match[0].length;
+                            const range = ( new Range(i + 1, linkStartOffset + 1, i + 1, linkEndOffset + 1));
+                            fileReferences.push({ content: match[2], range, isMarkdownLink: false });
+                        }
+                    }
+                    else {
+                        const contentStartOffset = match.index + 1;
+                        const contentEndOffset = match.index + match[0].length;
+                        const range = ( new Range(i + 1, contentStartOffset + 1, i + 1, contentEndOffset + 1));
+                        variableReferences.push({ name: match[2], range, offset: lineStartOffset + match.index });
+                    }
+                }
+                lineStartOffset += line.length;
+            }
+            this._parsed = { fileReferences: fileReferences.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range)), variableReferences, bodyOffset };
+        }
+        return this._parsed;
+    }
+    getContent() {
+        return this.linesWithEOL.slice(this.range.startLineNumber - 1, this.range.endLineNumber - 1).join('');
+    }
+    resolveFilePath(path) {
+        try {
+            if (path.startsWith('/')) {
+                return this.uri.with({ path });
+            }
+            else if (path.match(/^[a-zA-Z]:\\/)) {
+                return ( URI.parse(path));
+            }
+            else {
+                const dirName = dirname(this.uri);
+                return joinPath(dirName, path);
+            }
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+
+export { NewPromptsParser, ParsedPromptFile, PromptBody, PromptHeader };

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

@@ -0,0 +1,118 @@
+import { ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { IChatModeInstructions } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModes";
+import { IExtensionDescription } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+/**
+ * Where the prompt is stored.
+ */
+export declare enum PromptsStorage {
+    local = "local",
+    user = "user",
+    extension = "extension"
+}
+/**
+ * Represents a prompt path with its type.
+ * This is used for both prompt files and prompt source folders.
+ */
+export type IPromptPath = IExtensionPromptPath | ILocalPromptPath | IUserPromptPath;
+export interface IPromptPathBase {
+    /**
+     * URI of the prompt.
+     */
+    readonly uri: URI;
+    /**
+     * Storage of the prompt.
+     */
+    readonly storage: PromptsStorage;
+    /**
+     * Type of the prompt (e.g. 'prompt' or 'instructions').
+     */
+    readonly type: PromptsType;
+    /**
+     * Identifier of the contributing extension (only when storage === PromptsStorage.extension).
+     */
+    readonly extension?: IExtensionDescription;
+    readonly name?: string;
+    readonly description?: string;
+}
+export interface IExtensionPromptPath extends IPromptPathBase {
+    readonly storage: PromptsStorage.extension;
+    readonly extension: IExtensionDescription;
+    readonly name: string;
+    readonly description: string;
+}
+export interface ILocalPromptPath extends IPromptPathBase {
+    readonly storage: PromptsStorage.local;
+}
+export interface IUserPromptPath extends IPromptPathBase {
+    readonly storage: PromptsStorage.user;
+}
+export interface ICustomChatMode {
+    /**
+     * URI of a custom chat mode file.
+     */
+    readonly uri: URI;
+    /**
+     * Name of the custom chat mode as used in prompt files or contexts
+     */
+    readonly name: string;
+    /**
+     * Description of the mode
+     */
+    readonly description?: string;
+    /**
+     * Tools metadata in the prompt header.
+     */
+    readonly tools?: readonly string[];
+    /**
+     * Model metadata in the prompt header.
+     */
+    readonly model?: string;
+    /**
+     * Contents of the custom chat mode file body and other mode instructions.
+     */
+    readonly modeInstructions: IChatModeInstructions;
+}
+/**
+ * Type of combined tools metadata for the case
+ * when the prompt is in the agent mode.
+ */
+interface ICombinedAgentToolsMetadata {
+    /**
+     * List of combined tools metadata for
+     * the entire tree of prompt references.
+     */
+    readonly tools: readonly string[] | undefined;
+    /**
+     * Resulting chat mode of a prompt, based on modes
+     * used in the entire tree of prompt references.
+     */
+    readonly mode: ChatModeKind.Agent;
+}
+/**
+ * Type of combined tools metadata for the case
+ * when the prompt is in non-agent mode.
+ */
+interface ICombinedNonAgentToolsMetadata {
+    /**
+     * List of combined tools metadata is empty
+     * when the prompt is in non-agent mode.
+     */
+    readonly tools: undefined;
+    /**
+     * Resulting chat mode of a prompt, based on modes
+     * used in the entire tree of prompt references.
+     */
+    readonly mode?: ChatModeKind.Ask | ChatModeKind.Edit;
+}
+/**
+ * General type of the combined tools metadata.
+ */
+export type TCombinedToolsMetadata = ICombinedAgentToolsMetadata | ICombinedNonAgentToolsMetadata;
+export interface IChatPromptSlashCommand {
+    readonly command: string;
+    readonly detail: string;
+    readonly promptPath?: IPromptPath;
+}
+export {};

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

@@ -0,0 +1,10 @@
+
+
+var PromptsStorage;
+(function (PromptsStorage) {
+    PromptsStorage["local"] = "local";
+    PromptsStorage["user"] = "user";
+    PromptsStorage["extension"] = "extension";
+})(PromptsStorage || (PromptsStorage = {}));
+
+export { PromptsStorage };

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

@@ -1,19 +1,23 @@
 import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { type URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { PromptFilesLocator } from "../utils/promptFilesLocator.js";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { type ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { TextModelPromptParser } from "../parsers/textModelPromptParser.js";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
-import type { IChatPromptSlashCommand, ICustomChatMode, IPromptParserResult, IPromptPath } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { IChatPromptSlashCommand, ICustomChatMode, IPromptPath, PromptsStorage } from "./promptsService.js";
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
 import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ParsedPromptFile } from "./newPromptsParser.js";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IExtensionDescription } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+import { IFilesConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
 /**
  * Provides prompt services.
  */
@@ -25,11 +29,9 @@ export declare class PromptsService extends Disposable implements IPromptsServic
     private readonly userDataService;
     private readonly languageService;
     private readonly configurationService;
+    private readonly fileService;
+    private readonly filesConfigService;
     readonly _serviceBrand: undefined;
-    /**
-     * Cache of text model content prompt parsers.
-     */
-    private readonly cache;
     /**
      * Prompt files locator utility.
      */
@@ -38,33 +40,43 @@ export declare class PromptsService extends Disposable implements IPromptsServic
      * Cached custom modes. Caching only happens if the `onDidChangeCustomChatModes` event is used.
      */
     private cachedCustomChatModes;
+    private parsedPromptFileCache;
+    /**
+     * Contributed files from extensions keyed by prompt type then name.
+     */
+    private readonly contributedFiles;
     /**
      * Lazily created event that is fired when the custom chat modes change.
      */
-    private onDidChangeCustomChatModesEvent;
-    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService, languageService: ILanguageService, configurationService: IConfigurationService);
+    private onDidChangeCustomChatModesEmitter;
+    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService, languageService: ILanguageService, configurationService: IConfigurationService, fileService: IFileService, filesConfigService: IFilesConfigurationService);
     /**
      * Emitter for the custom chat modes change event.
      */
     get onDidChangeCustomChatModes(): Event<void>;
     getPromptFileType(uri: URI): PromptsType | undefined;
-    /**
-     * @throws {Error} if:
-     * 	- the provided model is disposed
-     * 	- newly created parser is disposed immediately on initialization.
-     * 	  See factory function in the {@link constructor} for more info.
-     */
-    getSyntaxParserFor(model: ITextModel): TextModelPromptParser & {
-        isDisposed: false;
-    };
+    getParsedPromptFile(textModel: ITextModel): ParsedPromptFile;
     listPromptFiles(type: PromptsType, token: CancellationToken): Promise<readonly IPromptPath[]>;
+    listPromptFilesForStorage(type: PromptsType, storage: PromptsStorage, token: CancellationToken): Promise<readonly IPromptPath[]>;
+    private getExtensionContributions;
     getSourceFolders(type: PromptsType): readonly IPromptPath[];
     asPromptSlashCommand(command: string): IChatPromptSlashCommand | undefined;
-    resolvePromptSlashCommand(data: IChatPromptSlashCommand, token: CancellationToken): Promise<IPromptParserResult | undefined>;
+    resolvePromptSlashCommand(data: IChatPromptSlashCommand, token: CancellationToken): Promise<ParsedPromptFile | undefined>;
     private getPromptPath;
+    getPromptCommandName(uri: URI): Promise<string>;
     findPromptSlashCommands(): Promise<IChatPromptSlashCommand[]>;
     getCustomChatModes(token: CancellationToken): Promise<readonly ICustomChatMode[]>;
     private computeCustomChatModes;
-    parse(uri: URI, type: PromptsType, token: CancellationToken): Promise<IPromptParserResult>;
+    parseNew(uri: URI, token: CancellationToken): Promise<ParsedPromptFile>;
+    registerContributedFile(type: PromptsType, name: string, description: string, uri: URI, extension: IExtensionDescription): Readonly<IDisposable>;
+    getPromptLocationLabel(promptPath: IPromptPath): string;
+    findAgentMDsInWorkspace(token: CancellationToken): Promise<URI[]>;
+}
+export declare class ChatModeUpdateTracker extends Disposable {
+    private static readonly CHAT_MODE_UPDATE_DELAY_MS;
+    private readonly listeners;
+    private readonly onDidChatModeModelChange;
+    get onDidChangeContent(): Event<void>;
+    constructor(fileLocator: PromptFilesLocator, modelService: IModelService);
+    dispose(): void;
 }
-export declare function getPromptCommandName(path: string): string;