sf-agentpmd 0.1.0 → 0.1.1

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

@@ -1,323 +0,0 @@
-/*
- * 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

@@ -1,65 +0,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 { 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

@@ -1,163 +0,0 @@
-/*
- * 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

@@ -1,51 +0,0 @@
-/**
- * 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