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

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/frontMatterDecoder.js

@@ -0,0 +1,118 @@
+
+import '../simpleCodec/tokens/at.js';
+import '../simpleCodec/tokens/tab.js';
+import '../simpleCodec/tokens/dash.js';
+import '../simpleCodec/tokens/hash.js';
+import { Word } from '../simpleCodec/tokens/word.js';
+import '../simpleCodec/tokens/colon.js';
+import '../simpleCodec/tokens/quote.js';
+import '../simpleCodec/tokens/slash.js';
+import '../simpleCodec/tokens/space.js';
+import '../simpleCodec/tokens/comma.js';
+import '../simpleCodec/tokens/formFeed.js';
+import '../simpleCodec/tokens/dollarSign.js';
+import '../simpleCodec/tokens/verticalTab.js';
+import '../simpleCodec/tokens/doubleQuote.js';
+import '../simpleCodec/tokens/exclamationMark.js';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import '../simpleCodec/tokens/brackets.js';
+import '../simpleCodec/tokens/curlyBraces.js';
+import '../simpleCodec/tokens/parentheses.js';
+import '../simpleCodec/tokens/angleBrackets.js';
+import { VALID_INTER_RECORD_SPACING_TOKENS } from './constants.js';
+import { FrontMatterToken } from './tokens/frontMatterToken.js';
+import { FrontMatterRecord } from './tokens/frontMatterRecord.js';
+import { BaseDecoder } from '../baseDecoder.js';
+import { SimpleDecoder } from '../simpleCodec/simpleDecoder.js';
+import { ObjectStream } from '../utils/objectStream.js';
+import { PartialFrontMatterRecord } from './parsers/frontMatterRecord/frontMatterRecord.js';
+import { FrontMatterParserFactory } from './parsers/frontMatterParserFactory.js';
+
+class FrontMatterDecoder extends BaseDecoder {
+    constructor(stream) {
+        if (stream instanceof ObjectStream) {
+            super(stream);
+        }
+        else {
+            super(( new SimpleDecoder(stream)));
+        }
+        this.parserFactory = ( new FrontMatterParserFactory());
+    }
+    onStreamData(token) {
+        if (this.current !== undefined) {
+            const acceptResult = this.current.accept(token);
+            const { result, wasTokenConsumed } = acceptResult;
+            if (result === 'failure') {
+                this.reEmitCurrentTokens();
+                if (wasTokenConsumed === false) {
+                    this._onData.fire(token);
+                }
+                delete this.current;
+                return;
+            }
+            const { nextParser } = acceptResult;
+            if (nextParser instanceof FrontMatterToken) {
+                const trimmedTokens = (nextParser instanceof FrontMatterRecord)
+                    ? nextParser.trimValueEnd()
+                    : [];
+                this._onData.fire(nextParser);
+                for (const trimmedToken of trimmedTokens) {
+                    this._onData.fire(trimmedToken);
+                }
+                if (wasTokenConsumed === false) {
+                    this._onData.fire(token);
+                }
+                delete this.current;
+                return;
+            }
+            this.current = nextParser;
+            if (wasTokenConsumed === false) {
+                this._onData.fire(token);
+            }
+            return;
+        }
+        if (token instanceof Word) {
+            this.current = this.parserFactory.createRecordName(token);
+            return;
+        }
+        for (const ValidToken of VALID_INTER_RECORD_SPACING_TOKENS) {
+            if (token instanceof ValidToken) {
+                this._onData.fire(token);
+                return;
+            }
+        }
+        this.reEmitCurrentTokens();
+    }
+    onStreamEnd() {
+        try {
+            if (this.current === undefined) {
+                return;
+            }
+            assert(this.current instanceof PartialFrontMatterRecord, 'Only partial front matter records can be processed on stream end.');
+            const record = this.current.asRecordToken();
+            const trimmedTokens = record.trimValueEnd();
+            this._onData.fire(record);
+            for (const trimmedToken of trimmedTokens) {
+                this._onData.fire(trimmedToken);
+            }
+        }
+        catch (_error) {
+            this.reEmitCurrentTokens();
+        }
+        finally {
+            delete this.current;
+            super.onStreamEnd();
+        }
+    }
+    reEmitCurrentTokens() {
+        if (this.current === undefined) {
+            return;
+        }
+        for (const token of this.current.tokens) {
+            this._onData.fire(token);
+        }
+        delete this.current;
+    }
+}
+
+export { FrontMatterDecoder };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterArray.d.ts

@@ -0,0 +1,14 @@
+import { FrontMatterArray } from "../tokens/frontMatterArray.js";
+import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
+import { LeftBracket } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
+import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+import { type FrontMatterParserFactory } from "./frontMatterParserFactory.js";
+export declare class PartialFrontMatterArray extends ParserBase<TSimpleDecoderToken, PartialFrontMatterArray | FrontMatterArray> {
+    private readonly factory;
+    private readonly startToken;
+    private currentValueParser?;
+    private arrayItemAllowed;
+    constructor(factory: FrontMatterParserFactory, startToken: LeftBracket);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialFrontMatterArray | FrontMatterArray>;
+    asArrayToken(): FrontMatterArray;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterArray.js

@@ -0,0 +1,134 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { FrontMatterArray } from '../tokens/frontMatterArray.js';
+import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { VALID_INTER_RECORD_SPACING_TOKENS } from '../constants.js';
+import { FrontMatterValueToken } from '../tokens/frontMatterToken.js';
+import { FrontMatterSequence } from '../tokens/frontMatterSequence.js';
+import '../../simpleCodec/tokens/at.js';
+import '../../simpleCodec/tokens/tab.js';
+import '../../simpleCodec/tokens/dash.js';
+import '../../simpleCodec/tokens/hash.js';
+import '../../simpleCodec/tokens/colon.js';
+import '../../simpleCodec/tokens/quote.js';
+import '../../simpleCodec/tokens/slash.js';
+import '../../simpleCodec/tokens/space.js';
+import { Comma } from '../../simpleCodec/tokens/comma.js';
+import '../../simpleCodec/tokens/formFeed.js';
+import '../../simpleCodec/tokens/dollarSign.js';
+import '../../simpleCodec/tokens/verticalTab.js';
+import '../../simpleCodec/tokens/doubleQuote.js';
+import '../../simpleCodec/tokens/exclamationMark.js';
+import { RightBracket } from '../../simpleCodec/tokens/brackets.js';
+import '../../simpleCodec/tokens/curlyBraces.js';
+import '../../simpleCodec/tokens/parentheses.js';
+import '../../simpleCodec/tokens/angleBrackets.js';
+import { ParserBase, assertNotConsumed } from '../../simpleCodec/parserBase.js';
+
+const VALID_DELIMITER_TOKENS = ( Object.freeze([
+    ...VALID_INTER_RECORD_SPACING_TOKENS,
+    Comma,
+]));
+class PartialFrontMatterArray extends ParserBase {
+    constructor(factory, startToken) {
+        super([startToken]);
+        this.factory = factory;
+        this.startToken = startToken;
+        this.arrayItemAllowed = true;
+    }
+    accept(token) {
+        if (this.currentValueParser !== undefined) {
+            const acceptResult = this.currentValueParser.accept(token);
+            const { result, wasTokenConsumed } = acceptResult;
+            if (result === 'failure') {
+                this.isConsumed = true;
+                return {
+                    result: 'failure',
+                    wasTokenConsumed,
+                };
+            }
+            const { nextParser } = acceptResult;
+            if (nextParser instanceof FrontMatterValueToken) {
+                this.currentTokens.push(nextParser);
+                delete this.currentValueParser;
+                if (wasTokenConsumed === false) {
+                    return this.accept(token);
+                }
+                return {
+                    result: 'success',
+                    nextParser: this,
+                    wasTokenConsumed,
+                };
+            }
+            this.currentValueParser = nextParser;
+            return {
+                result: 'success',
+                nextParser: this,
+                wasTokenConsumed,
+            };
+        }
+        if (token instanceof RightBracket) {
+            assert(this.currentValueParser === undefined, `Unexpected end of array. Last value is not finished.`);
+            this.currentTokens.push(token);
+            this.isConsumed = true;
+            return {
+                result: 'success',
+                nextParser: this.asArrayToken(),
+                wasTokenConsumed: true,
+            };
+        }
+        for (const ValidToken of VALID_DELIMITER_TOKENS) {
+            if (token instanceof ValidToken) {
+                this.currentTokens.push(token);
+                if ((this.arrayItemAllowed === false) && token instanceof Comma) {
+                    this.arrayItemAllowed = true;
+                }
+                return {
+                    result: 'success',
+                    nextParser: this,
+                    wasTokenConsumed: true,
+                };
+            }
+        }
+        if (this.arrayItemAllowed === true) {
+            this.currentValueParser = this.factory.createValue((currentToken) => {
+                return ((currentToken instanceof RightBracket)
+                    || (currentToken instanceof Comma));
+            });
+            this.arrayItemAllowed = false;
+            return this.accept(token);
+        }
+        this.isConsumed = true;
+        return {
+            result: 'failure',
+            wasTokenConsumed: false,
+        };
+    }
+    asArrayToken() {
+        const endToken = this.currentTokens[this.currentTokens.length - 1];
+        assertDefined(endToken, 'No tokens found.');
+        assert(endToken instanceof RightBracket, 'Cannot find a closing bracket of the array.');
+        const valueTokens = [];
+        for (const currentToken of this.currentTokens) {
+            if ((currentToken instanceof FrontMatterValueToken) === false) {
+                continue;
+            }
+            if (currentToken instanceof FrontMatterSequence) {
+                currentToken.trimEnd();
+            }
+            valueTokens.push(currentToken);
+        }
+        this.isConsumed = true;
+        return ( new FrontMatterArray([
+            this.startToken,
+            ...valueTokens,
+            endToken,
+        ]));
+    }
+}
+PartialFrontMatterArray.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialFrontMatterArray.prototype, "accept", null));
+
+export { PartialFrontMatterArray };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterParserFactory.d.ts

@@ -0,0 +1,27 @@
+import { BaseToken } from "../../baseToken.js";
+import { LeftBracket } from "../../simpleCodec/tokens/brackets.js";
+import { Word } from "../../simpleCodec/tokens/word.js";
+import { FrontMatterRecordDelimiter, FrontMatterRecordName } from "../tokens/frontMatterRecord.js";
+import { TQuoteToken } from "../tokens/frontMatterString.js";
+import { PartialFrontMatterArray } from "./frontMatterArray.js";
+import { PartialFrontMatterRecord } from "./frontMatterRecord/frontMatterRecord.js";
+import { PartialFrontMatterRecordName } from "./frontMatterRecord/frontMatterRecordName.js";
+import { PartialFrontMatterRecordNameWithDelimiter, TNameStopToken } from "./frontMatterRecord/frontMatterRecordNameWithDelimiter.js";
+import { PartialFrontMatterSequence } from "./frontMatterSequence.js";
+import { PartialFrontMatterString } from "./frontMatterString.js";
+import { PartialFrontMatterValue } from "./frontMatterValue.js";
+export declare class FrontMatterParserFactory {
+    createRecord(tokens: [
+        FrontMatterRecordName,
+        FrontMatterRecordDelimiter
+    ]): PartialFrontMatterRecord;
+    createRecordName(startToken: Word): PartialFrontMatterRecordName;
+    createRecordNameWithDelimiter(tokens: readonly [
+        FrontMatterRecordName,
+        TNameStopToken
+    ]): PartialFrontMatterRecordNameWithDelimiter;
+    createArray(startToken: LeftBracket): PartialFrontMatterArray;
+    createValue(shouldStop: (token: BaseToken) => boolean): PartialFrontMatterValue;
+    createString(startToken: TQuoteToken): PartialFrontMatterString;
+    createSequence(shouldStop: (token: BaseToken) => boolean): PartialFrontMatterSequence;
+}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterParserFactory.js

@@ -0,0 +1,34 @@
+
+import { PartialFrontMatterArray } from './frontMatterArray.js';
+import { PartialFrontMatterRecord } from './frontMatterRecord/frontMatterRecord.js';
+import { PartialFrontMatterRecordName } from './frontMatterRecord/frontMatterRecordName.js';
+import { PartialFrontMatterRecordNameWithDelimiter } from './frontMatterRecord/frontMatterRecordNameWithDelimiter.js';
+import { PartialFrontMatterSequence } from './frontMatterSequence.js';
+import { PartialFrontMatterString } from './frontMatterString.js';
+import { PartialFrontMatterValue } from './frontMatterValue.js';
+
+class FrontMatterParserFactory {
+    createRecord(tokens) {
+        return ( new PartialFrontMatterRecord(this, tokens));
+    }
+    createRecordName(startToken) {
+        return ( new PartialFrontMatterRecordName(this, startToken));
+    }
+    createRecordNameWithDelimiter(tokens) {
+        return ( new PartialFrontMatterRecordNameWithDelimiter(this, tokens));
+    }
+    createArray(startToken) {
+        return ( new PartialFrontMatterArray(this, startToken));
+    }
+    createValue(shouldStop) {
+        return ( new PartialFrontMatterValue(this, shouldStop));
+    }
+    createString(startToken) {
+        return ( new PartialFrontMatterString(startToken));
+    }
+    createSequence(shouldStop) {
+        return ( new PartialFrontMatterSequence(shouldStop));
+    }
+}
+
+export { FrontMatterParserFactory };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterRecord/frontMatterRecord.d.ts

@@ -0,0 +1,18 @@
+import { type TSimpleDecoderToken } from "../../../simpleCodec/simpleDecoder.js";
+import { ParserBase, type TAcceptTokenResult } from "../../../simpleCodec/parserBase.js";
+import { FrontMatterRecordName, FrontMatterRecordDelimiter, FrontMatterRecord } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+import { type FrontMatterParserFactory } from "../frontMatterParserFactory.js";
+type TNextParser = PartialFrontMatterRecord | FrontMatterRecord;
+export declare class PartialFrontMatterRecord extends ParserBase<TSimpleDecoderToken, TNextParser> {
+    private readonly factory;
+    private readonly recordNameToken;
+    private readonly recordDelimiterToken;
+    constructor(factory: FrontMatterParserFactory, tokens: [
+        FrontMatterRecordName,
+        FrontMatterRecordDelimiter
+    ]);
+    private valueParser?;
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<TNextParser>;
+    asRecordToken(): FrontMatterRecord;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterRecord/frontMatterRecord.js

@@ -0,0 +1,134 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { NewLine } from '../../../linesCodec/tokens/newLine.js';
+import { PartialFrontMatterValue } from '../frontMatterValue.js';
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { PartialFrontMatterSequence } from '../frontMatterSequence.js';
+import { CarriageReturn } from '../../../linesCodec/tokens/carriageReturn.js';
+import '../../../simpleCodec/tokens/at.js';
+import '../../../simpleCodec/tokens/tab.js';
+import '../../../simpleCodec/tokens/dash.js';
+import '../../../simpleCodec/tokens/hash.js';
+import { Word } from '../../../simpleCodec/tokens/word.js';
+import '../../../simpleCodec/tokens/colon.js';
+import '../../../simpleCodec/tokens/quote.js';
+import '../../../simpleCodec/tokens/slash.js';
+import '../../../simpleCodec/tokens/space.js';
+import '../../../simpleCodec/tokens/comma.js';
+import { FormFeed } from '../../../simpleCodec/tokens/formFeed.js';
+import '../../../simpleCodec/tokens/dollarSign.js';
+import '../../../simpleCodec/tokens/verticalTab.js';
+import '../../../simpleCodec/tokens/doubleQuote.js';
+import '../../../simpleCodec/tokens/exclamationMark.js';
+import { SpacingToken } from '../../../simpleCodec/tokens/simpleToken.js';
+import '../../../simpleCodec/tokens/brackets.js';
+import '../../../simpleCodec/tokens/curlyBraces.js';
+import '../../../simpleCodec/tokens/parentheses.js';
+import '../../../simpleCodec/tokens/angleBrackets.js';
+import { ParserBase, assertNotConsumed } from '../../../simpleCodec/parserBase.js';
+import { FrontMatterValueToken } from '../../tokens/frontMatterToken.js';
+import { FrontMatterRecord } from '../../tokens/frontMatterRecord.js';
+
+class PartialFrontMatterRecord extends ParserBase {
+    constructor(factory, tokens) {
+        super(tokens);
+        this.factory = factory;
+        this.recordNameToken = tokens[0];
+        this.recordDelimiterToken = tokens[1];
+    }
+    accept(token) {
+        if (this.valueParser !== undefined) {
+            const acceptResult = this.valueParser.accept(token);
+            const { result, wasTokenConsumed } = acceptResult;
+            if (result === 'failure') {
+                this.isConsumed = true;
+                return {
+                    result: 'failure',
+                    wasTokenConsumed,
+                };
+            }
+            const { nextParser } = acceptResult;
+            if (nextParser instanceof FrontMatterValueToken) {
+                this.currentTokens.push(nextParser);
+                delete this.valueParser;
+                this.isConsumed = true;
+                try {
+                    return {
+                        result: 'success',
+                        nextParser: ( new FrontMatterRecord([
+                            this.recordNameToken,
+                            this.recordDelimiterToken,
+                            nextParser,
+                        ])),
+                        wasTokenConsumed,
+                    };
+                }
+                catch (_error) {
+                    return {
+                        result: 'failure',
+                        wasTokenConsumed,
+                    };
+                }
+            }
+            this.valueParser = nextParser;
+            return {
+                result: 'success',
+                nextParser: this,
+                wasTokenConsumed,
+            };
+        }
+        if (token instanceof SpacingToken) {
+            this.currentTokens.push(token);
+            return {
+                result: 'success',
+                nextParser: this,
+                wasTokenConsumed: true,
+            };
+        }
+        if (PartialFrontMatterValue.isValueStartToken(token)) {
+            this.valueParser = this.factory.createValue(shouldEndTokenSequence);
+            return this.accept(token);
+        }
+        this.valueParser = this.factory.createSequence(shouldEndTokenSequence);
+        if (shouldEndTokenSequence(token)) {
+            const spaceTokens = this.currentTokens
+                .slice(this.startTokensCount);
+            if (spaceTokens.length === 0) {
+                spaceTokens.push(Word.newOnLine('', token.range.startLineNumber, token.range.startColumn));
+            }
+            this.valueParser.addTokens(spaceTokens);
+            return {
+                result: 'success',
+                nextParser: this.asRecordToken(),
+                wasTokenConsumed: false,
+            };
+        }
+        return this.accept(token);
+    }
+    asRecordToken() {
+        assertDefined(this.valueParser, 'Current value parser must be defined.');
+        if ((this.valueParser instanceof PartialFrontMatterValue)
+            || (this.valueParser instanceof PartialFrontMatterSequence)) {
+            const valueToken = this.valueParser.asSequenceToken();
+            this.currentTokens.push(valueToken);
+            this.isConsumed = true;
+            return ( new FrontMatterRecord([
+                this.recordNameToken,
+                this.recordDelimiterToken,
+                valueToken,
+            ]));
+        }
+        assertNever(this.valueParser, `Unexpected value parser '${this.valueParser}'.`);
+    }
+}
+PartialFrontMatterRecord.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialFrontMatterRecord.prototype, "accept", null));
+function shouldEndTokenSequence(token) {
+    return ((token instanceof NewLine)
+        || (token instanceof CarriageReturn)
+        || (token instanceof FormFeed));
+}
+
+export { PartialFrontMatterRecord };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterRecord/frontMatterRecordName.d.ts

@@ -0,0 +1,13 @@
+import { type TSimpleDecoderToken } from "../../../simpleCodec/simpleDecoder.js";
+import { type TRecordNameToken } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+import { Word } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
+import { type PartialFrontMatterRecordNameWithDelimiter } from "./frontMatterRecordNameWithDelimiter.js";
+import { ParserBase, type TAcceptTokenResult } from "../../../simpleCodec/parserBase.js";
+import { type FrontMatterParserFactory } from "../frontMatterParserFactory.js";
+type TNextParser = PartialFrontMatterRecordName | PartialFrontMatterRecordNameWithDelimiter;
+export declare class PartialFrontMatterRecordName extends ParserBase<TRecordNameToken, TNextParser> {
+    private readonly factory;
+    constructor(factory: FrontMatterParserFactory, startToken: Word);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<TNextParser>;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterRecord/frontMatterRecordName.js

@@ -0,0 +1,64 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '../../../simpleCodec/tokens/at.js';
+import '../../../simpleCodec/tokens/tab.js';
+import { Dash } from '../../../simpleCodec/tokens/dash.js';
+import '../../../simpleCodec/tokens/hash.js';
+import { Word } from '../../../simpleCodec/tokens/word.js';
+import { Colon } from '../../../simpleCodec/tokens/colon.js';
+import '../../../simpleCodec/tokens/quote.js';
+import '../../../simpleCodec/tokens/slash.js';
+import '../../../simpleCodec/tokens/space.js';
+import '../../../simpleCodec/tokens/comma.js';
+import '../../../simpleCodec/tokens/formFeed.js';
+import '../../../simpleCodec/tokens/dollarSign.js';
+import '../../../simpleCodec/tokens/verticalTab.js';
+import '../../../simpleCodec/tokens/doubleQuote.js';
+import '../../../simpleCodec/tokens/exclamationMark.js';
+import { SpacingToken } from '../../../simpleCodec/tokens/simpleToken.js';
+import '../../../simpleCodec/tokens/brackets.js';
+import '../../../simpleCodec/tokens/curlyBraces.js';
+import '../../../simpleCodec/tokens/parentheses.js';
+import '../../../simpleCodec/tokens/angleBrackets.js';
+import { FrontMatterRecordName } from '../../tokens/frontMatterRecord.js';
+import { ParserBase, assertNotConsumed } from '../../../simpleCodec/parserBase.js';
+
+const VALID_NAME_TOKENS = [Word, Dash];
+class PartialFrontMatterRecordName extends ParserBase {
+    constructor(factory, startToken) {
+        super([startToken]);
+        this.factory = factory;
+    }
+    accept(token) {
+        for (const ValidToken of VALID_NAME_TOKENS) {
+            if (token instanceof ValidToken) {
+                this.currentTokens.push(token);
+                return {
+                    result: 'success',
+                    nextParser: this,
+                    wasTokenConsumed: true,
+                };
+            }
+        }
+        if ((token instanceof Colon) || (token instanceof SpacingToken)) {
+            const recordName = ( new FrontMatterRecordName(this.currentTokens));
+            this.isConsumed = true;
+            return {
+                result: 'success',
+                nextParser: this.factory.createRecordNameWithDelimiter([recordName, token]),
+                wasTokenConsumed: true,
+            };
+        }
+        this.isConsumed = true;
+        return {
+            result: 'failure',
+            wasTokenConsumed: false,
+        };
+    }
+}
+PartialFrontMatterRecordName.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialFrontMatterRecordName.prototype, "accept", null));
+
+export { PartialFrontMatterRecordName };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterRecord/frontMatterRecordNameWithDelimiter.d.ts

@@ -0,0 +1,17 @@
+import { type PartialFrontMatterRecord } from "./frontMatterRecord.js";
+import { Colon, SpacingToken } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
+import { type TSimpleDecoderToken } from "../../../simpleCodec/simpleDecoder.js";
+import { FrontMatterRecordName } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
+import { ParserBase, type TAcceptTokenResult } from "../../../simpleCodec/parserBase.js";
+import { type FrontMatterParserFactory } from "../frontMatterParserFactory.js";
+export type TNameStopToken = Colon | SpacingToken;
+type TNextParser = PartialFrontMatterRecordNameWithDelimiter | PartialFrontMatterRecord;
+export declare class PartialFrontMatterRecordNameWithDelimiter extends ParserBase<FrontMatterRecordName | TNameStopToken, TNextParser> {
+    private readonly factory;
+    constructor(factory: FrontMatterParserFactory, tokens: readonly [
+        FrontMatterRecordName,
+        TNameStopToken
+    ]);
+    accept(token: TSimpleDecoderToken): TAcceptTokenResult<TNextParser>;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/parsers/frontMatterRecord/frontMatterRecordNameWithDelimiter.js

@@ -0,0 +1,75 @@
+
+import { __decorate } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import '../../../simpleCodec/tokens/at.js';
+import '../../../simpleCodec/tokens/tab.js';
+import '../../../simpleCodec/tokens/dash.js';
+import '../../../simpleCodec/tokens/hash.js';
+import { Colon } from '../../../simpleCodec/tokens/colon.js';
+import '../../../simpleCodec/tokens/quote.js';
+import '../../../simpleCodec/tokens/slash.js';
+import '../../../simpleCodec/tokens/space.js';
+import '../../../simpleCodec/tokens/comma.js';
+import '../../../simpleCodec/tokens/formFeed.js';
+import '../../../simpleCodec/tokens/dollarSign.js';
+import '../../../simpleCodec/tokens/verticalTab.js';
+import '../../../simpleCodec/tokens/doubleQuote.js';
+import '../../../simpleCodec/tokens/exclamationMark.js';
+import { SpacingToken } from '../../../simpleCodec/tokens/simpleToken.js';
+import '../../../simpleCodec/tokens/brackets.js';
+import '../../../simpleCodec/tokens/curlyBraces.js';
+import '../../../simpleCodec/tokens/parentheses.js';
+import '../../../simpleCodec/tokens/angleBrackets.js';
+import { FrontMatterRecordDelimiter, FrontMatterRecordName } from '../../tokens/frontMatterRecord.js';
+import { ParserBase, assertNotConsumed } from '../../../simpleCodec/parserBase.js';
+
+class PartialFrontMatterRecordNameWithDelimiter extends ParserBase {
+    constructor(factory, tokens) {
+        super([...tokens]);
+        this.factory = factory;
+    }
+    accept(token) {
+        const previousToken = this.currentTokens[this.currentTokens.length - 1];
+        const isSpacingToken = (token instanceof SpacingToken);
+        if (isSpacingToken && (previousToken instanceof Colon)) {
+            const recordDelimiter = ( new FrontMatterRecordDelimiter([
+                previousToken,
+                token,
+            ]));
+            const recordName = this.currentTokens[0];
+            assert(recordName instanceof FrontMatterRecordName, `Expected a front matter record name, got '${recordName}'.`);
+            this.isConsumed = true;
+            return {
+                result: 'success',
+                nextParser: this.factory.createRecord([recordName, recordDelimiter]),
+                wasTokenConsumed: true,
+            };
+        }
+        if (token instanceof SpacingToken) {
+            this.currentTokens.push(token);
+            return {
+                result: 'success',
+                nextParser: this,
+                wasTokenConsumed: true,
+            };
+        }
+        if (token instanceof Colon) {
+            this.currentTokens.push(token);
+            return {
+                result: 'success',
+                nextParser: this,
+                wasTokenConsumed: true,
+            };
+        }
+        this.isConsumed = true;
+        return {
+            result: 'failure',
+            wasTokenConsumed: false,
+        };
+    }
+}
+PartialFrontMatterRecordNameWithDelimiter.__decorator = ( __decorate([
+    assertNotConsumed
+], PartialFrontMatterRecordNameWithDelimiter.prototype, "accept", null));
+
+export { PartialFrontMatterRecordNameWithDelimiter };