sf-agentpmd 0.1.0

package/vendor/agentscript-parser-javascript/dist/parse-templates.js

@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2026, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * For full license text, see the LICENSE file in the repo root or https://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Template-parsing functions extracted from Parser class.
+ *
+ * Each function takes a ParserContext as its first parameter, following
+ * the same free-function pattern as parse-statements.ts and expressions.ts.
+ *
+ * Template indentation state (templateOuterIndent) is computed locally in
+ * parseTemplate and passed as an explicit parameter to templateContinues.
+ */
+import { TokenKind } from './token.js';
+import { CSTNode } from './cst-node.js';
+import { makeEmptyError, makeMissing, synchronize, isAtEnd, } from './recovery.js';
+import { parseExpression, wrapExpression } from './expressions.js';
+// ---------------------------------------------------------------------------
+// Exported template parsers
+// ---------------------------------------------------------------------------
+/**
+ * Parse a template starting with `|`.
+ * Consumes tokens from the lexer stream, treating everything as template content
+ * except `{!...}` breaks which are parsed as template expressions.
+ */
+export function parseTemplate(ctx) {
+    const startTok = ctx.peek();
+    const node = ctx.startNode('template');
+    // Compute the indent level of the line containing `|`.
+    // Tree-sitter uses *array_back(&scanner->indents) — the top of the indent
+    // stack, which equals the line indent. We scan backward in the source to
+    // measure the leading whitespace on this line.
+    const pipeOffset = ctx.peekOffset();
+    let lineStart = pipeOffset;
+    while (lineStart > 0 &&
+        ctx.source.charCodeAt(lineStart - 1) !== 10 /* \n */) {
+        lineStart--;
+    }
+    let templateOuterIndent = 0;
+    for (let i = lineStart; i < pipeOffset; i++) {
+        const ch = ctx.source.charCodeAt(i);
+        if (ch === 32 /* space */)
+            templateOuterIndent += 1;
+        else if (ch === 9 /* tab */)
+            templateOuterIndent += 3;
+        else
+            break;
+    }
+    // Consume the | token and track position right after it
+    const pipeToken = ctx.consume();
+    ctx.addAnonymousChild(node, pipeToken);
+    // If there are tokens on the same line after |, pass afterPipeOffset
+    // so whitespace between | and {! is captured as template_content.
+    // If the line is empty after |, don't pass it (avoids phantom content).
+    const hasContentOnSameLine = !isAtEnd(ctx) &&
+        ctx.peekKind() !== TokenKind.NEWLINE &&
+        ctx.peekKind() !== TokenKind.INDENT &&
+        ctx.peekKind() !== TokenKind.DEDENT;
+    if (hasContentOnSameLine) {
+        const afterPipeOffset = pipeToken.startOffset + 1;
+        gatherTemplateContentLine(ctx, node, afterPipeOffset);
+    }
+    // Consume NEWLINE if present
+    if (ctx.peekKind() === TokenKind.NEWLINE) {
+        ctx.consume();
+    }
+    // If there's an INDENT, the template continues on indented lines.
+    // Templates consume ALL indented content until we fully return to the
+    // base indent. We track indent depth: each INDENT increments, each
+    // DEDENT decrements. When depth reaches 0, a final DEDENT exits.
+    // Mid-template DEDENTs (under-indented continuation lines) are consumed
+    // as content.
+    if (ctx.peekKind() === TokenKind.INDENT) {
+        ctx.consume(); // outer INDENT
+        let indentDepth = 1;
+        while (!isAtEnd(ctx)) {
+            const tok = ctx.peek();
+            if (tok.kind === TokenKind.DEDENT) {
+                indentDepth--;
+                ctx.consume();
+                if (indentDepth <= 0) {
+                    // Check if template continues with under-indented content.
+                    // If the next meaningful token is content (not EOF/DEDENT),
+                    // the template has under-indented continuation lines.
+                    if (templateContinues(ctx, templateOuterIndent)) {
+                        // Re-enter: consume content at the new (lower) indent
+                        indentDepth = 0; // will re-increment on next INDENT
+                        continue;
+                    }
+                    break;
+                }
+            }
+            else if (tok.kind === TokenKind.INDENT) {
+                indentDepth++;
+                ctx.consume();
+            }
+            else if (tok.kind === TokenKind.NEWLINE) {
+                ctx.consume();
+            }
+            else {
+                // When at the template's base indent depth, check if the next
+                // token should continue the template (e.g. comments at the base
+                // level should not be absorbed as template content).
+                if (indentDepth <= 0 && !templateContinues(ctx, templateOuterIndent)) {
+                    break;
+                }
+                // For continuation lines, start the content from the end of the
+                // last template child so that newlines + indentation between a
+                // template_expression and the next template_content are preserved
+                // in the source text.  (mergeTemplateContent handles this for
+                // consecutive template_content nodes, but not across expressions.)
+                const lastChild = node.children.length > 0
+                    ? node.children[node.children.length - 1]
+                    : null;
+                const gapOffset = lastChild && lastChild.endOffset < ctx.peekOffset()
+                    ? lastChild.endOffset
+                    : undefined;
+                const gapPos = gapOffset !== undefined ? lastChild.endPosition : undefined;
+                gatherTemplateContentLine(ctx, node, gapOffset, gapPos);
+            }
+        }
+    }
+    // Merge consecutive template_content children into single nodes.
+    // Tree-sitter produces one template_content per contiguous text span;
+    // our line-by-line parsing creates one per line.
+    mergeTemplateContent(ctx, node);
+    ctx.finishNode(node, startTok);
+    return node;
+}
+/**
+ * Parse a template in colinear position (after a colon on the same line).
+ * Currently identical to parseTemplate; kept as a separate entry point
+ * for semantic clarity and potential future divergence.
+ */
+export function parseTemplateAsColinear(ctx) {
+    return parseTemplate(ctx);
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Check if the template continues with under-indented content.
+ * After a DEDENT brings us to depth 0, if the next meaningful token
+ * is content (not EOF, not DEDENT, not a mapping key pattern), the
+ * template has continuation lines.
+ */
+function templateContinues(ctx, templateOuterIndent) {
+    let i = 0;
+    while (ctx.peekAt(i).kind === TokenKind.NEWLINE)
+        i++;
+    const tok = ctx.peekAt(i);
+    // If we see content (ID, etc.) that's NOT a mapping key pattern, continue
+    if (tok.kind === TokenKind.EOF || tok.kind === TokenKind.DEDENT)
+        return false;
+    // Content deeper than the template's base indent is always template content,
+    // regardless of keywords. Matches tree-sitter scanner behavior where
+    // indent_length > out_of_template_indent_length keeps content in the template.
+    if (tok.start.column > templateOuterIndent)
+        return true;
+    // Another pipe starts a new template — don't absorb it
+    if (tok.kind === TokenKind.PIPE)
+        return false;
+    // If it looks like a mapping key (ID followed by COLON), template is done
+    if (tok.kind === TokenKind.ID || tok.kind === TokenKind.STRING) {
+        const after = ctx.peekAt(i + 1);
+        if (after.kind === TokenKind.COLON)
+            return false;
+        // Two-word key check
+        if (after.kind === TokenKind.ID) {
+            const afterAfter = ctx.peekAt(i + 2);
+            if (afterAfter.kind === TokenKind.COLON)
+                return false;
+        }
+    }
+    // Statement keywords terminate template continuation — they're
+    // sibling statements, not template content
+    if (tok.kind === TokenKind.ID) {
+        switch (tok.text) {
+            case 'if':
+            case 'elif':
+            case 'else':
+            case 'run':
+            case 'set':
+            case 'transition':
+                return false;
+            case 'with':
+                // "with" not followed by colon is a statement
+                if (ctx.peekAt(i + 1).kind !== TokenKind.COLON)
+                    return false;
+                break;
+            case 'available':
+                if (ctx.peekAt(i + 1).kind === TokenKind.ID &&
+                    ctx.peekAt(i + 1).text === 'when')
+                    return false;
+                break;
+        }
+    }
+    // If it looks like a dash (sequence), template is done
+    if (tok.kind === TokenKind.DASH_SPACE)
+        return false;
+    // Comments at the template's base indent level are not template content
+    if (tok.kind === TokenKind.COMMENT)
+        return false;
+    // Otherwise, assume it's template continuation
+    return true;
+}
+/** Merge consecutive template_content children into single nodes. */
+function mergeTemplateContent(ctx, template) {
+    const merged = [];
+    let i = 0;
+    while (i < template.children.length) {
+        const child = template.children[i];
+        if (child.type === 'template_content') {
+            // Find the run of consecutive template_content nodes
+            let end = i + 1;
+            while (end < template.children.length &&
+                template.children[end].type === 'template_content') {
+                end++;
+            }
+            if (end > i + 1) {
+                // Merge into one node
+                const first = template.children[i];
+                const last = template.children[end - 1];
+                const mergedNode = new CSTNode('template_content', ctx.source, first.startOffset, last.endOffset, first.startPosition, last.endPosition);
+                mergedNode.parent = template;
+                merged.push(mergedNode);
+                i = end;
+            }
+            else {
+                merged.push(child);
+                i++;
+            }
+        }
+        else {
+            merged.push(child);
+            i++;
+        }
+    }
+    template.children = merged;
+}
+/**
+ * Gather tokens on the current line as template content.
+ * Recognizes {! ... } as template expression breaks.
+ * Everything else (including inter-token whitespace) becomes template_content.
+ * Uses source-level offsets so whitespace between tokens is preserved.
+ */
+function gatherTemplateContentLine(ctx, parent, initialOffset, initialPos) {
+    // Track the source range of content before/after template expressions.
+    // If initialOffset is provided, use it (captures whitespace after |).
+    // Otherwise start from the current token position.
+    let contentStartOffset = initialOffset ?? ctx.peekOffset();
+    let contentStartPos = initialPos ?? ctx.peek().start;
+    let lastConsumedEndOffset = contentStartOffset;
+    let lastConsumedEndPos = contentStartPos;
+    while (!isAtEnd(ctx)) {
+        const tok = ctx.peek();
+        if (tok.kind === TokenKind.NEWLINE ||
+            tok.kind === TokenKind.DEDENT ||
+            tok.kind === TokenKind.INDENT ||
+            tok.kind === TokenKind.EOF) {
+            break;
+        }
+        // Template expression start
+        if (tok.kind === TokenKind.TEMPLATE_EXPR_START) {
+            // Flush accumulated content up to the {!
+            const exprOffset = ctx.peekOffset();
+            if (exprOffset > contentStartOffset) {
+                parent.appendChild(new CSTNode('template_content', ctx.source, contentStartOffset, exprOffset, contentStartPos, tok.start));
+            }
+            // Parse template expression
+            const exprNode = parseTemplateExpression(ctx);
+            parent.appendChild(exprNode);
+            // Content after } continues from the end of the expression node
+            // (not from the next token — that would skip whitespace between } and next content)
+            contentStartOffset = exprNode.endOffset;
+            contentStartPos = exprNode.endPosition;
+            lastConsumedEndOffset = exprNode.endOffset;
+            lastConsumedEndPos = exprNode.endPosition;
+            continue;
+        }
+        // Track end of this token for accurate content span
+        const tokOffset = ctx.peekOffset();
+        lastConsumedEndOffset = tokOffset + tok.text.length;
+        lastConsumedEndPos = tok.end;
+        ctx.consume();
+    }
+    // Flush remaining content — use end of last consumed token (not next token offset,
+    // which would include blank lines between this content and the next line)
+    if (lastConsumedEndOffset > contentStartOffset) {
+        parent.appendChild(new CSTNode('template_content', ctx.source, contentStartOffset, lastConsumedEndOffset, contentStartPos, lastConsumedEndPos));
+    }
+}
+function parseTemplateExpression(ctx) {
+    const startTok = ctx.peek();
+    const node = ctx.startNode('template_expression');
+    ctx.addAnonymousChild(node, ctx.consume()); // {!
+    const expr = parseExpression(ctx, 0);
+    if (expr) {
+        node.appendChild(wrapExpression(ctx, expr), 'expression');
+    }
+    else {
+        // Empty template expression {!} → ERROR for missing expression
+        node.appendChild(makeEmptyError(ctx));
+    }
+    // Consume any extra tokens before } (e.g., unclosed {!@var.name world)
+    if (ctx.peekKind() !== TokenKind.RBRACE && !ctx.isAtSyncPoint()) {
+        const err = synchronize(ctx);
+        if (err)
+            node.appendChild(err);
+    }
+    if (ctx.peekKind() === TokenKind.RBRACE) {
+        ctx.addAnonymousChild(node, ctx.consume()); // }
+    }
+    else {
+        // Unclosed template expression → MISSING }
+        node.appendChild(makeMissing(ctx, '}'));
+    }
+    ctx.finishNode(node, startTok);
+    return node;
+}
+//# sourceMappingURL=parse-templates.js.map

package/vendor/agentscript-parser-javascript/dist/parser.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Recursive descent parser for AgentScript.
+ *
+ * Core invariant: NEWLINE and DEDENT are unconditional synchronization points.
+ * Every parse function that encounters an unexpected token calls synchronize()
+ * which skips to the next NEWLINE/DEDENT/EOF.
+ */
+import { TokenKind, type Token } from './token.js';
+import { CSTNode } from './cst-node.js';
+/**
+ * Token consumption — peek, advance, and query the token stream.
+ */
+export interface TokenStream {
+    source: string;
+    peek(): Token;
+    peekAt(offset: number): Token;
+    peekAtIndex(idx: number): Token;
+    peekKind(): TokenKind;
+    consume(): Token;
+    consumeKind<K extends TokenKind>(kind: K): Token<K>;
+    currentOffset(): number;
+    peekOffset(): number;
+    isAtSyncPoint(): boolean;
+}
+/**
+ * CST node construction — create, populate, and finalize nodes.
+ */
+export interface NodeBuilder {
+    consumeNamed(type: string): CSTNode;
+    startNode(type: string): CSTNode;
+    startNodeAt(type: string, existingChild: CSTNode): CSTNode;
+    finishNode(node: CSTNode, startTok: Token): void;
+    addAnonymousChild(parent: CSTNode, token: Token): void;
+}
+/**
+ * Combined interface used by expression parser to access parser state.
+ * Avoids circular dependency between parser.ts and expressions.ts.
+ */
+export interface ParserContext extends TokenStream, NodeBuilder {
+}
+export declare class Parser implements ParserContext {
+    source: string;
+    private tokens;
+    private pos;
+    private _eof;
+    constructor(source: string);
+    parse(): CSTNode;
+    peek(): Token;
+    peekAt(offset: number): Token;
+    peekAtIndex(idx: number): Token;
+    peekKind(): TokenKind;
+    consume(): Token;
+    consumeKind<K extends TokenKind>(kind: K): Token<K>;
+    consumeNamed(type: string): CSTNode;
+    currentOffset(): number;
+    peekOffset(): number;
+    isAtSyncPoint(): boolean;
+    startNode(type: string): CSTNode;
+    startNodeAt(type: string, existingChild: CSTNode): CSTNode;
+    finishNode(_node: CSTNode, _startTok: Token): void;
+    addAnonymousChild(parent: CSTNode, token: Token): void;
+    private parseSourceFile;
+    private eofToken;
+}
+//# sourceMappingURL=parser.d.ts.map

package/vendor/agentscript-parser-javascript/dist/parser.js

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2026, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * For full license text, see the LICENSE file in the repo root or https://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Recursive descent parser for AgentScript.
+ *
+ * Core invariant: NEWLINE and DEDENT are unconditional synchronization points.
+ * Every parse function that encounters an unexpected token calls synchronize()
+ * which skips to the next NEWLINE/DEDENT/EOF.
+ */
+import { isTokenKind, TokenKind } from './token.js';
+import { Lexer } from './lexer.js';
+import { CSTNode } from './cst-node.js';
+import { isSyncPoint } from './errors.js';
+import { synchronize, skipNewlines, consumeCommentsAndSkipNewlines, isAtEnd, } from './recovery.js';
+import { parseMappingOrExpression } from './parse-mapping.js';
+import { parseSequence } from './parse-sequence.js';
+import invariant from 'tiny-invariant';
+export class Parser {
+    source;
+    tokens;
+    pos = 0;
+    _eof;
+    constructor(source) {
+        this.source = source;
+        const lexer = new Lexer(source);
+        this.tokens = lexer.tokenize();
+    }
+    parse() {
+        const root = this.parseSourceFile();
+        return root;
+    }
+    // --- ParserContext implementation ---
+    peek() {
+        return this.peekAt(0);
+    }
+    peekAt(offset) {
+        // n.b. (Allen): Because this is called so frequently, these invariants cause significant runtime overhead.
+        // invariant(this.pos + offset >= 0, 'peekAt too small');
+        // invariant(this.pos + offset <= this.tokens.length, 'peekAt too large');
+        return this.peekAtIndex(this.pos + offset);
+    }
+    peekAtIndex(idx) {
+        return this.tokens[idx] ?? this.eofToken();
+    }
+    peekKind() {
+        return this.peek().kind;
+    }
+    consume() {
+        const tok = this.peek();
+        this.pos++;
+        return tok;
+    }
+    consumeKind(kind) {
+        const tok = this.peek();
+        invariant(isTokenKind(tok, kind), `Expected token kind ${kind} but got ${tok.kind}`);
+        this.pos++;
+        return tok;
+    }
+    consumeNamed(type) {
+        const tok = this.consume();
+        const offset = tok.startOffset;
+        return new CSTNode(type, this.source, offset, offset + tok.text.length, tok.start, tok.end);
+    }
+    currentOffset() {
+        const idx = this.pos > 0 ? this.pos - 1 : 0;
+        return this.peekAtIndex(idx).startOffset;
+    }
+    peekOffset() {
+        return this.peek().startOffset;
+    }
+    isAtSyncPoint() {
+        return isSyncPoint(this.peekKind());
+    }
+    startNode(type) {
+        const tok = this.peek();
+        const offset = tok.startOffset;
+        return new CSTNode(type, this.source, offset, offset, tok.start, tok.end);
+    }
+    startNodeAt(type, existingChild) {
+        return new CSTNode(type, this.source, existingChild.startOffset, existingChild.endOffset, existingChild.startPosition, existingChild.endPosition);
+    }
+    finishNode(_node, _startTok) {
+        // No-op: appendChild() tracks end position incrementally.
+    }
+    addAnonymousChild(parent, token) {
+        const offset = token.startOffset;
+        const child = new CSTNode(token.text, this.source, offset, offset + token.text.length, token.start, token.end, false);
+        parent.appendChild(child);
+    }
+    // --- Top-level parsing ---
+    parseSourceFile() {
+        const node = this.startNode('source_file');
+        // Skip leading newlines and indentation (handles template literals with leading whitespace)
+        skipNewlines(this);
+        if (this.peekKind() === TokenKind.INDENT) {
+            this.consume();
+        }
+        // Consume leading comments at source_file level (tree-sitter treats them as extras)
+        consumeCommentsAndSkipNewlines(this, node);
+        // Determine what kind of source file this is
+        if (this.peekKind() === TokenKind.DASH_SPACE) {
+            // Sequence
+            node.appendChild(parseSequence(this));
+        }
+        else {
+            // Mapping or expression
+            // n.b. (Allen): Originally we didn't permit expressions at the top level, but
+            // we did that to make testing easier in tree-sitter so I suppose
+            // we can just make this a feature of the language.
+            const content = parseMappingOrExpression(this, _ctx => parseSequence(_ctx));
+            if (content)
+                node.appendChild(content);
+        }
+        // Consume trailing comments at source_file level
+        consumeCommentsAndSkipNewlines(this, node);
+        // Catch-all: if there are unconsumed tokens, wrap them in ERROR nodes.
+        // This ensures every byte of source is represented in the CST.
+        while (!isAtEnd(this)) {
+            if (this.peekKind() === TokenKind.NEWLINE ||
+                this.peekKind() === TokenKind.DEDENT) {
+                this.consume();
+                continue;
+            }
+            if (this.peekKind() === TokenKind.COMMENT) {
+                node.appendChild(this.consumeNamed('comment'));
+                continue;
+            }
+            const err = synchronize(this);
+            if (err) {
+                node.appendChild(err);
+            }
+            else {
+                // Consume one token to guarantee progress
+                this.consume();
+            }
+        }
+        // Root node must span entire source (matches tree-sitter invariant)
+        node.startOffset = 0;
+        node.startPosition = { row: 0, column: 0 };
+        node.endOffset = this.source.length;
+        node.endPosition = this.eofToken().end;
+        return node;
+    }
+    eofToken() {
+        if (!this._eof) {
+            const lastToken = this.tokens[this.tokens.length - 1];
+            const pos = lastToken ? lastToken.end : { row: 0, column: 0 };
+            this._eof = {
+                kind: TokenKind.EOF,
+                text: '',
+                start: pos,
+                end: pos,
+                startOffset: this.source.length,
+            };
+        }
+        return this._eof;
+    }
+}
+//# sourceMappingURL=parser.js.map

package/vendor/agentscript-parser-javascript/dist/recovery.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Recovery and utility functions extracted from parser.ts.
+ *
+ * All functions take a ParserContext as their first argument,
+ * following the free-function pattern established by expressions.ts.
+ */
+import { TokenKind } from './token.js';
+import { CSTNode } from './cst-node.js';
+import type { ParserContext } from './parser.js';
+/** Create an empty ERROR node at the current position. */
+export declare function makeEmptyError(ctx: ParserContext): CSTNode;
+/** Insert a missing target: `target: (expression (atom (ERROR)))` */
+export declare function addMissingTarget(ctx: ParserContext, node: CSTNode): void;
+/** Create a MISSING node — an expected token/node that wasn't found in source. */
+export declare function makeMissing(ctx: ParserContext, type: string): CSTNode;
+/**
+ * Parse a standalone else/elif/for (without a preceding if, or unsupported).
+ * Wraps the entire block in an ERROR node, preserving parsed statements inside.
+ *
+ * @param parseProcedure - callback to parse procedure bodies, avoiding circular
+ *   dependency with parse-statements.ts
+ */
+export declare function parseOrphanBlock(ctx: ParserContext, parseProcedure: (ctx: ParserContext) => CSTNode): CSTNode;
+/**
+ * Consume any leftover tokens in an indented block (before DEDENT) as ERROR
+ * nodes. Prevents cascading failures when parseBlockValue() only partially
+ * consumes the block content (e.g., unquoted multi-word text).
+ */
+export declare function recoverToBlockEnd(ctx: ParserContext, parent: CSTNode): void;
+/**
+ * Synchronize: skip tokens until a stopping condition is met.
+ * Returns an ERROR node wrapping the skipped content, or null if
+ * nothing was consumed.
+ *
+ * @param extraStop - optional predicate for additional stop conditions
+ *   beyond the default sync points (NEWLINE/DEDENT/EOF)
+ */
+export declare function synchronizeUntil(ctx: ParserContext, extraStop?: (kind: TokenKind, row: number) => boolean): CSTNode | null;
+/** Skip tokens on the given row until a sync point, INDENT, or COLON. */
+export declare function synchronizeRowUntilColon(ctx: ParserContext, row: number): CSTNode | null;
+/** Skip tokens on the given row until a sync point or INDENT. */
+export declare function synchronizeRow(ctx: ParserContext, row: number): CSTNode | null;
+/** Skip tokens until the next sync point (NEWLINE/DEDENT/EOF). */
+export declare function synchronize(ctx: ParserContext): CSTNode | null;
+export declare function skipNewlines(ctx: ParserContext): void;
+/** Consume comment and newline tokens and attach to parent node. */
+export declare function consumeCommentsAndSkipNewlines(ctx: ParserContext, parent: CSTNode): void;
+export declare function isAtEnd(ctx: ParserContext): boolean;
+/** Check if from current position, there are only comments, newlines, and then EOF/DEDENT. */
+export declare function isTrailingCommentOnly(ctx: ParserContext): boolean;
+//# sourceMappingURL=recovery.d.ts.map