@codingame/monaco-vscode-chat-service-override 18.3.1 → 19.0.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/basePromptParser.js

@@ -0,0 +1,333 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { TopError } from './topError.js';
+import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ModeHeader } from './promptHeader/modeHeader.js';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { PromptToken } from '../codecs/tokens/promptToken.js';
+import { isAbsolute } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { ChatPromptCodec } from '../codecs/chatPromptCodec.js';
+import { FileReference } from '../codecs/tokens/fileReference.js';
+import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { InstructionsHeader } from './promptHeader/instructionsHeader.js';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { PromptVariableWithData } from '../codecs/tokens/promptVariable.js';
+import { assert, assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { basename, joinPath, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { BaseToken } from '../codecs/base/baseToken.js';
+import { PromptHeader } from './promptHeader/promptHeader.js';
+import { ObservableDisposable } from '../utils/observableDisposable.js';
+import { PROMPT_LANGUAGE_ID, INSTRUCTIONS_LANGUAGE_ID, MODE_LANGUAGE_ID } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { LinesDecoder } from '../codecs/base/linesCodec/linesDecoder.js';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MarkdownLink } from '../codecs/base/markdownCodec/tokens/markdownLink.js';
+import { MarkdownToken } from '../codecs/base/markdownCodec/tokens/markdownToken.js';
+import { FrontMatterHeader } from '../codecs/base/markdownExtensionsCodec/tokens/frontMatterHeader.js';
+import { ResolveError } from '../../promptFileReferenceErrors.js';
+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';
+
+let BasePromptParser = class BasePromptParser extends ObservableDisposable {
+    get tokens() {
+        return [...this.receivedTokens];
+    }
+    get header() {
+        return this.promptHeader;
+    }
+    async getBody() {
+        const startLineNumber = (this.header !== undefined)
+            ? this.header.range.endLineNumber + 1
+            : 1;
+        const decoder = ( new LinesDecoder(await this.promptContentsProvider.contents));
+        const tokens = (await decoder.consumeAll())
+            .filter(({ range }) => {
+            return (range.startLineNumber >= startLineNumber);
+        });
+        return BaseToken.render(tokens);
+    }
+    onSettled(callback) {
+        const disposable = this._onSettled.event(callback);
+        const streamEnded = (this.stream?.ended && (this.stream.isDisposed === false));
+        if (streamEnded || this.errorCondition) {
+            setTimeout(callback.bind(undefined, this.errorCondition));
+            return disposable;
+        }
+        return disposable;
+    }
+    get errorCondition() {
+        return this._errorCondition;
+    }
+    get resolveFailed() {
+        if (!this.firstParseResult.gotFirstResult) {
+            return undefined;
+        }
+        return !!this._errorCondition;
+    }
+    async settled() {
+        assert(this.started, 'Cannot wait on the parser that did not start yet.');
+        await this.firstParseResult.promise;
+        if (this.errorCondition) {
+            return false;
+        }
+        if (this.isDisposed) {
+            return false;
+        }
+        assertDefined(this.stream, 'No stream reference found.');
+        const completed = await this.stream.settled;
+        if (this.promptHeader) {
+            const headerCompleted = await this.promptHeader.settled;
+            if (!headerCompleted) {
+                return false;
+            }
+        }
+        return completed;
+    }
+    constructor(promptContentsProvider, options, instantiationService, envService, logService) {
+        super();
+        this.promptContentsProvider = promptContentsProvider;
+        this.instantiationService = instantiationService;
+        this.envService = envService;
+        this.logService = logService;
+        this.receivedTokens = [];
+        this._references = [];
+        this._onUpdate = this._register(( new Emitter()));
+        this.onUpdate = this._onUpdate.event;
+        this._onSettled = this._register(( new Emitter()));
+        this.firstParseResult = ( new FirstParseResult());
+        this.started = false;
+        this.options = options;
+        this._register(this.promptContentsProvider.onContentChanged((streamOrError) => {
+            this.onContentsChanged(streamOrError);
+            this.firstParseResult.end();
+        }));
+        this._register(this.promptContentsProvider.onDispose(this.dispose.bind(this)));
+    }
+    onContentsChanged(streamOrError) {
+        this.stream?.dispose();
+        delete this.stream;
+        delete this._errorCondition;
+        this.receivedTokens = [];
+        this.promptHeader?.dispose();
+        delete this.promptHeader;
+        this.disposeReferences();
+        if (streamOrError instanceof ResolveError) {
+            this._errorCondition = streamOrError;
+            this._onUpdate.fire();
+            this._onSettled.fire(streamOrError);
+            return;
+        }
+        this.stream = ChatPromptCodec.decode(streamOrError);
+        this.stream.on('error', this.onStreamEnd.bind(this, this.stream));
+        this.stream.on('end', this.onStreamEnd.bind(this, this.stream));
+        this.stream.on('data', (token) => {
+            if ((token instanceof MarkdownToken) || (token instanceof PromptToken)) {
+                this.receivedTokens.push(token);
+            }
+            if (token instanceof FrontMatterHeader) {
+                return this.createHeader(token);
+            }
+            if (token instanceof PromptVariableWithData) {
+                try {
+                    this.handleLinkToken(FileReference.from(token));
+                }
+                catch (error) {
+                }
+            }
+            if (token instanceof MarkdownLink && !token.isURL) {
+                this.handleLinkToken(token);
+            }
+        });
+        if (this.stream.isDisposed) {
+            this.logService.warn(`[prompt parser][${basename(this.uri)}] cannot start stream that has been already disposed, aborting`);
+            return;
+        }
+        this.stream.start();
+    }
+    createHeader(headerToken) {
+        const { languageId } = this.promptContentsProvider;
+        if (languageId === PROMPT_LANGUAGE_ID) {
+            this.promptHeader = ( new PromptHeader(headerToken, languageId));
+        }
+        if (languageId === INSTRUCTIONS_LANGUAGE_ID) {
+            this.promptHeader = ( new InstructionsHeader(headerToken, languageId));
+        }
+        if (languageId === MODE_LANGUAGE_ID) {
+            this.promptHeader = ( new ModeHeader(headerToken, languageId));
+        }
+        this.promptHeader?.start();
+    }
+    handleLinkToken(token) {
+        let referenceUri;
+        if (isAbsolute(token.path)) {
+            referenceUri = URI.file(token.path);
+            if (this.envService.remoteAuthority) {
+                referenceUri = referenceUri.with({
+                    scheme: Schemas.vscodeRemote,
+                    authority: this.envService.remoteAuthority,
+                });
+            }
+        }
+        else {
+            referenceUri = joinPath(dirname(this.uri), token.path);
+        }
+        this._references.push(( new PromptReference(referenceUri, token)));
+        this._onUpdate.fire();
+        return this;
+    }
+    onStreamEnd(stream, error) {
+        if (stream.isDisposed === true) {
+            return this;
+        }
+        if (error) {
+            this.logService.warn(`[prompt parser][${basename(this.uri)}] received an error on the chat prompt decoder stream: ${error}`);
+        }
+        this._onUpdate.fire();
+        this._onSettled.fire(error);
+        return this;
+    }
+    disposeReferences() {
+        this._references.length = 0;
+    }
+    start(token) {
+        if (this.started) {
+            return this;
+        }
+        this.started = true;
+        if (this.errorCondition) {
+            return this;
+        }
+        this.promptContentsProvider.start(token);
+        return this;
+    }
+    get uri() {
+        return this.promptContentsProvider.uri;
+    }
+    get references() {
+        return [...this._references];
+    }
+    get metadata() {
+        const { promptType } = this.promptContentsProvider;
+        if (promptType === 'non-prompt') {
+            return null;
+        }
+        if (this.header === undefined) {
+            return { promptType };
+        }
+        if (this.header instanceof InstructionsHeader || this.header instanceof ModeHeader) {
+            return { promptType, ...this.header.metadata };
+        }
+        const { tools, mode, description, model } = this.header.metadata;
+        const result = {};
+        if (description !== undefined) {
+            result.description = description;
+        }
+        if (tools !== undefined && mode !== ChatModeKind.Ask && mode !== ChatModeKind.Edit) {
+            result.tools = tools;
+            result.mode = ChatModeKind.Agent;
+        }
+        else if (mode !== undefined) {
+            result.mode = mode;
+        }
+        if (model !== undefined) {
+            result.model = model;
+        }
+        return { promptType, ...result };
+    }
+    get topError() {
+        if (this.errorCondition) {
+            return ( new TopError({
+                errorSubject: 'root',
+                errorsCount: 1,
+                originalError: this.errorCondition,
+            }));
+        }
+        return undefined;
+    }
+    toString() {
+        return `prompt:${this.uri.path}`;
+    }
+    dispose() {
+        if (this.isDisposed) {
+            return;
+        }
+        this.disposeReferences();
+        this.stream?.dispose();
+        delete this.stream;
+        this.promptHeader?.dispose();
+        delete this.promptHeader;
+        super.dispose();
+    }
+};
+BasePromptParser = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, ILogService))
+], BasePromptParser));
+class PromptReference {
+    constructor(uri, token) {
+        this.uri = uri;
+        this.token = token;
+    }
+    get linkRange() {
+        if (this.token instanceof FileReference) {
+            return this.token.dataRange;
+        }
+        if (this.token instanceof MarkdownLink) {
+            return this.token.linkRange;
+        }
+        return undefined;
+    }
+    get type() {
+        if (this.token instanceof FileReference) {
+            return 'file';
+        }
+        if (this.token instanceof MarkdownLink) {
+            return 'file';
+        }
+        assertNever(this.token, `Unknown token type '${this.token}'.`);
+    }
+    get subtype() {
+        if (this.token instanceof FileReference) {
+            return 'prompt';
+        }
+        if (this.token instanceof MarkdownLink) {
+            return 'markdown';
+        }
+        assertNever(this.token, `Unknown token type '${this.token}'.`);
+    }
+    get range() {
+        return this.token.range;
+    }
+    get path() {
+        return this.token.path;
+    }
+    get text() {
+        return this.token.text;
+    }
+    toString() {
+        return `prompt-reference/${this.type}:${this.subtype}/${this.token}`;
+    }
+}
+class FirstParseResult extends DeferredPromise {
+    constructor() {
+        super(...arguments);
+        this._gotResult = false;
+    }
+    get gotFirstResult() {
+        return this._gotResult;
+    }
+    get promise() {
+        return this.p;
+    }
+    end() {
+        this._gotResult = true;
+        super.complete(void 0)
+            .catch(() => {
+        });
+        return;
+    }
+}
+
+export { BasePromptParser, PromptReference };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/diagnostics.d.ts

@@ -0,0 +1,14 @@
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export type TDiagnostic = PromptMetadataWarning | PromptMetadataError;
+export declare abstract class PromptMetadataDiagnostic {
+    readonly range: Range;
+    readonly message: string;
+    constructor(range: Range, message: string);
+    abstract toString(): string;
+}
+export declare class PromptMetadataWarning extends PromptMetadataDiagnostic {
+    toString(): string;
+}
+export declare class PromptMetadataError extends PromptMetadataDiagnostic {
+    toString(): string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/diagnostics.js

@@ -0,0 +1,20 @@
+
+
+class PromptMetadataDiagnostic {
+    constructor(range, message) {
+        this.range = range;
+        this.message = message;
+    }
+}
+class PromptMetadataWarning extends PromptMetadataDiagnostic {
+    toString() {
+        return `warning(${this.message})${this.range}`;
+    }
+}
+class PromptMetadataError extends PromptMetadataDiagnostic {
+    toString() {
+        return `error(${this.message})${this.range}`;
+    }
+}
+
+export { PromptMetadataDiagnostic, PromptMetadataError, PromptMetadataWarning };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/headerBase.d.ts

@@ -0,0 +1,36 @@
+import { type TModeMetadata } from "./modeHeader.js";
+import { type TPromptMetadata } from "./promptHeader.js";
+import { type IMetadataRecord } from "./metadata/base/record.js";
+import { type TInstructionsMetadata } from "./instructionsHeader.js";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type TDiagnostic } from "./diagnostics.js";
+import { FrontMatterRecord } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+import { FrontMatterHeader } from "../../codecs/base/markdownExtensionsCodec/tokens/frontMatterHeader.js";
+import { PromptDescriptionMetadata } from "./metadata/description.js";
+export type TDehydrated<T extends IHeaderMetadata> = {
+    [K in keyof T]: T[K] extends IMetadataRecord<infer U> ? (U extends undefined ? undefined : NonNullable<U>) : undefined;
+};
+export interface IHeaderMetadata {
+    description: PromptDescriptionMetadata;
+}
+export type THeaderMetadata = Partial<TDehydrated<IHeaderMetadata>>;
+export type TMetadata = TPromptMetadata | TModeMetadata | TInstructionsMetadata;
+export declare abstract class HeaderBase<TMetadata extends IHeaderMetadata> extends Disposable {
+    readonly token: FrontMatterHeader;
+    readonly languageId: string;
+    private readonly stream;
+    protected readonly meta: Partial<TMetadata>;
+    get metadata(): Partial<TDehydrated<TMetadata>>;
+    get metadataUtility(): Partial<TMetadata>;
+    private readonly recordNames;
+    protected readonly issues: TDiagnostic[];
+    get diagnostics(): readonly TDiagnostic[];
+    get range(): Range;
+    constructor(token: FrontMatterHeader, languageId: string);
+    protected abstract handleToken(token: FrontMatterRecord): boolean;
+    private onData;
+    private onError;
+    get settled(): Promise<boolean>;
+    start(): this;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/headerBase.js

@@ -0,0 +1,101 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ObjectStream } from '../../codecs/base/utils/objectStream.js';
+import { PromptMetadataError, PromptMetadataWarning } from './diagnostics.js';
+import '../../codecs/base/simpleCodec/tokens/at.js';
+import '../../codecs/base/simpleCodec/tokens/tab.js';
+import '../../codecs/base/simpleCodec/tokens/dash.js';
+import '../../codecs/base/simpleCodec/tokens/hash.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '../../codecs/base/simpleCodec/tokens/colon.js';
+import '../../codecs/base/simpleCodec/tokens/quote.js';
+import '../../codecs/base/simpleCodec/tokens/slash.js';
+import '../../codecs/base/simpleCodec/tokens/space.js';
+import '../../codecs/base/simpleCodec/tokens/comma.js';
+import '../../codecs/base/simpleCodec/tokens/formFeed.js';
+import '../../codecs/base/simpleCodec/tokens/dollarSign.js';
+import '../../codecs/base/simpleCodec/tokens/verticalTab.js';
+import '../../codecs/base/simpleCodec/tokens/doubleQuote.js';
+import '../../codecs/base/simpleCodec/tokens/exclamationMark.js';
+import { SimpleToken } from '../../codecs/base/simpleCodec/tokens/simpleToken.js';
+import '../../codecs/base/simpleCodec/tokens/brackets.js';
+import '../../codecs/base/simpleCodec/tokens/curlyBraces.js';
+import '../../codecs/base/simpleCodec/tokens/parentheses.js';
+import '../../codecs/base/simpleCodec/tokens/angleBrackets.js';
+import { FrontMatterRecord } from '../../codecs/base/frontMatterCodec/tokens/frontMatterRecord.js';
+import { FrontMatterDecoder } from '../../codecs/base/frontMatterCodec/frontMatterDecoder.js';
+import { PromptDescriptionMetadata } from './metadata/description.js';
+
+class HeaderBase extends Disposable {
+    get metadata() {
+        const result = {};
+        for (const [entryName, entryValue] of Object.entries(this.meta)) {
+            if (entryValue?.value === undefined) {
+                continue;
+            }
+            Object.assign(result, {
+                [entryName]: entryValue.value,
+            });
+        }
+        return result;
+    }
+    get metadataUtility() {
+        return { ...this.meta };
+    }
+    get diagnostics() {
+        return this.issues;
+    }
+    get range() {
+        return this.token.range;
+    }
+    constructor(token, languageId) {
+        super();
+        this.token = token;
+        this.languageId = languageId;
+        this.issues = [];
+        this.meta = {};
+        this.recordNames = ( new Set());
+        this.stream = this._register(( new FrontMatterDecoder(ObjectStream.fromArray([...token.contentToken.children]))));
+        this.stream.onData(this.onData.bind(this));
+        this.stream.onError(this.onError.bind(this));
+    }
+    onData(token) {
+        if ((token instanceof FrontMatterRecord) === false) {
+            if (token instanceof SimpleToken) {
+                return;
+            }
+            this.issues.push(( new PromptMetadataError(token.range, ( localize(5339, "Unexpected token '{0}'.", token.text)))));
+            return;
+        }
+        const recordName = token.nameToken.text;
+        if (( this.recordNames.has(recordName))) {
+            this.issues.push(( new PromptMetadataWarning(token.range, ( localize(5340, "Duplicate property '{0}' will be ignored.", recordName)))));
+            return;
+        }
+        this.recordNames.add(recordName);
+        if (PromptDescriptionMetadata.isDescriptionRecord(token)) {
+            const metadata = ( new PromptDescriptionMetadata(token, this.languageId));
+            this.issues.push(...metadata.validate());
+            this.meta.description = metadata;
+            this.recordNames.add(recordName);
+            return;
+        }
+        if (this.handleToken(token)) {
+            return;
+        }
+        this.issues.push(( new PromptMetadataWarning(token.range, ( localize(5341, "Unknown property '{0}' will be ignored.", recordName)))));
+    }
+    onError(error) {
+        this.issues.push(( new PromptMetadataError(this.token.range, ( localize(5342, "Failed to parse prompt header: {0}", error.message)))));
+    }
+    get settled() {
+        return this.stream.settled;
+    }
+    start() {
+        this.stream.start();
+        return this;
+    }
+}
+
+export { HeaderBase };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/instructionsHeader.d.ts

@@ -0,0 +1,14 @@
+import { PromptApplyToMetadata } from "./metadata/applyTo.js";
+import { HeaderBase, IHeaderMetadata, type TDehydrated } from "./headerBase.js";
+import { PromptsType } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { FrontMatterRecord } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+interface IInstructionsMetadata extends IHeaderMetadata {
+    applyTo: PromptApplyToMetadata;
+}
+export type TInstructionsMetadata = Partial<TDehydrated<IInstructionsMetadata>> & {
+    promptType: PromptsType.instructions;
+};
+export declare class InstructionsHeader extends HeaderBase<IInstructionsMetadata> {
+    protected handleToken(token: FrontMatterRecord): boolean;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/instructionsHeader.js

@@ -0,0 +1,17 @@
+
+import { PromptApplyToMetadata } from './metadata/applyTo.js';
+import { HeaderBase } from './headerBase.js';
+
+class InstructionsHeader extends HeaderBase {
+    handleToken(token) {
+        if (PromptApplyToMetadata.isApplyToRecord(token)) {
+            const metadata = ( new PromptApplyToMetadata(token, this.languageId));
+            this.issues.push(...metadata.validate());
+            this.meta.applyTo = metadata;
+            return true;
+        }
+        return false;
+    }
+}
+
+export { InstructionsHeader };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/metadata/applyTo.d.ts

@@ -0,0 +1,10 @@
+import { PromptStringMetadata } from "./base/string.js";
+import { PromptMetadataDiagnostic } from "../diagnostics.js";
+import { FrontMatterRecord, FrontMatterToken } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+export declare class PromptApplyToMetadata extends PromptStringMetadata {
+    constructor(recordToken: FrontMatterRecord, languageId: string);
+    get recordName(): string;
+    validate(): readonly PromptMetadataDiagnostic[];
+    private isValidGlob;
+    static isApplyToRecord(token: FrontMatterToken): boolean;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/metadata/applyTo.js

@@ -0,0 +1,87 @@
+
+import { PromptStringMetadata } from './base/string.js';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { INSTRUCTIONS_LANGUAGE_ID } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { splitGlobAware, parse, isEmptyPattern } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
+import { PromptMetadataError, PromptMetadataWarning } from '../diagnostics.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '../../../codecs/base/simpleCodec/tokens/at.js';
+import '../../../codecs/base/simpleCodec/tokens/tab.js';
+import '../../../codecs/base/simpleCodec/tokens/dash.js';
+import '../../../codecs/base/simpleCodec/tokens/hash.js';
+import '../../../codecs/base/simpleCodec/tokens/colon.js';
+import '../../../codecs/base/simpleCodec/tokens/quote.js';
+import '../../../codecs/base/simpleCodec/tokens/slash.js';
+import '../../../codecs/base/simpleCodec/tokens/space.js';
+import '../../../codecs/base/simpleCodec/tokens/comma.js';
+import '../../../codecs/base/simpleCodec/tokens/formFeed.js';
+import '../../../codecs/base/simpleCodec/tokens/dollarSign.js';
+import '../../../codecs/base/simpleCodec/tokens/verticalTab.js';
+import '../../../codecs/base/simpleCodec/tokens/doubleQuote.js';
+import '../../../codecs/base/simpleCodec/tokens/exclamationMark.js';
+import '../../../codecs/base/simpleCodec/tokens/brackets.js';
+import '../../../codecs/base/simpleCodec/tokens/curlyBraces.js';
+import '../../../codecs/base/simpleCodec/tokens/parentheses.js';
+import '../../../codecs/base/simpleCodec/tokens/angleBrackets.js';
+import { FrontMatterRecord } from '../../../codecs/base/frontMatterCodec/tokens/frontMatterRecord.js';
+
+const RECORD_NAME = 'applyTo';
+class PromptApplyToMetadata extends PromptStringMetadata {
+    constructor(recordToken, languageId) {
+        super(RECORD_NAME, recordToken, languageId);
+    }
+    get recordName() {
+        return RECORD_NAME;
+    }
+    validate() {
+        super.validate();
+        if (this.valueToken === undefined) {
+            return this.issues;
+        }
+        if (this.languageId !== INSTRUCTIONS_LANGUAGE_ID) {
+            this.issues.push(( new PromptMetadataError(this.range, ( localize(
+                5343,
+                "The '{0}' header property is only valid in instruction files.",
+                this.recordName
+            )))));
+            delete this.valueToken;
+            return this.issues;
+        }
+        const { cleanText } = this.valueToken;
+        if (this.isValidGlob(cleanText) === false) {
+            this.issues.push(( new PromptMetadataWarning(this.valueToken.range, ( localize(5344, "Invalid glob pattern '{0}'.", cleanText)))));
+            delete this.valueToken;
+            return this.issues;
+        }
+        return this.issues;
+    }
+    isValidGlob(pattern) {
+        try {
+            const patterns = splitGlobAware(pattern, ',');
+            if (patterns.length === 0) {
+                return false;
+            }
+            for (const pattern of patterns) {
+                const globPattern = parse(pattern);
+                if (isEmptyPattern(globPattern)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (_error) {
+            return false;
+        }
+    }
+    static isApplyToRecord(token) {
+        if ((token instanceof FrontMatterRecord) === false) {
+            return false;
+        }
+        if (token.nameToken.text === RECORD_NAME) {
+            return true;
+        }
+        return false;
+    }
+}
+
+export { PromptApplyToMetadata };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptHeader/metadata/base/enum.d.ts

@@ -0,0 +1,10 @@
+import { PromptStringMetadata } from "./string.js";
+import { PromptMetadataDiagnostic } from "../../diagnostics.js";
+import { FrontMatterRecord } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+export declare abstract class PromptEnumMetadata<TValidValues extends string = string> extends PromptStringMetadata {
+    private readonly validValues;
+    constructor(validValues: readonly TValidValues[], expectedRecordName: string, recordToken: FrontMatterRecord, languageId: string);
+    private enumValue;
+    get value(): TValidValues | undefined;
+    validate(): readonly PromptMetadataDiagnostic[];
+}