sf-agentpmd 0.1.0 → 0.1.2

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

@@ -1,15 +0,0 @@
-import { CSTNode } from './cst-node.js';
-import type { ParserContext } from './parser.js';
-export declare function isStatementStart(ctx: ParserContext): boolean;
-export declare function parseProcedure(ctx: ParserContext, parseTemplate?: (ctx: ParserContext) => CSTNode): CSTNode;
-export declare function parseStatement(ctx: ParserContext, parseTemplate?: (ctx: ParserContext) => CSTNode): CSTNode | null;
-export declare function parseIfStatement(ctx: ParserContext, parseTemplate?: (ctx: ParserContext) => CSTNode): CSTNode;
-export declare function parseRunStatement(ctx: ParserContext, parseTemplate?: (ctx: ParserContext) => CSTNode): CSTNode;
-export declare function parseSetStatement(ctx: ParserContext): CSTNode;
-export declare function parseTransitionStatement(ctx: ParserContext): CSTNode;
-export declare function parseWithStatement(ctx: ParserContext): CSTNode;
-export declare function parseAvailableWhenStatement(ctx: ParserContext): CSTNode;
-export declare function tryParseWithToStatementList(ctx: ParserContext): CSTNode | null;
-export declare function parseInlineWithStatement(ctx: ParserContext): CSTNode;
-export declare function parseToStatement(ctx: ParserContext): CSTNode;
-//# sourceMappingURL=parse-statements.d.ts.map

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

@@ -1,519 +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
- */
-/**
- * Statement-parsing functions extracted from Parser class.
- *
- * Each function takes a ParserContext as its first parameter, following
- * the same free-function pattern as recovery.ts and expressions.ts.
- *
- * Functions that call parseProcedure (which in turn calls parseStatement,
- * which may delegate to parseTemplate) accept an optional parseTemplate
- * callback to avoid circular dependency with parser.ts.
- */
-import { isTokenKind, TokenKind } from './token.js';
-import { CSTNode } from './cst-node.js';
-import { makeErrorNode, tokenToAutoLeaf } from './errors.js';
-import { makeEmptyError, addMissingTarget, makeMissing, synchronize, synchronizeRow, synchronizeRowUntilColon, consumeCommentsAndSkipNewlines, skipNewlines, isAtEnd, isTrailingCommentOnly, parseOrphanBlock, } from './recovery.js';
-import { parseExpression, wrapExpression, parseString } from './expressions.js';
-// ---------------------------------------------------------------------------
-// Statement detection
-// ---------------------------------------------------------------------------
-export function isStatementStart(ctx) {
-    const tok = ctx.peek();
-    if (tok.kind !== TokenKind.ID)
-        return false;
-    switch (tok.text) {
-        case 'if':
-        case 'run':
-        case 'set':
-        case 'transition':
-            return true;
-        case 'with':
-            // "with" is a statement only if not followed by colon (which would make it a key)
-            return ctx.peekAt(1).kind !== TokenKind.COLON;
-        case 'available':
-            return (ctx.peekAt(1).kind === TokenKind.ID && ctx.peekAt(1).text === 'when');
-        default:
-            return false;
-    }
-}
-// ---------------------------------------------------------------------------
-// Procedure & statement dispatch
-// ---------------------------------------------------------------------------
-export function parseProcedure(ctx, parseTemplate) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('procedure');
-    while (!isAtEnd(ctx) && ctx.peekKind() !== TokenKind.DEDENT) {
-        skipNewlines(ctx);
-        if (isAtEnd(ctx) || ctx.peekKind() === TokenKind.DEDENT)
-            break;
-        // Don't consume trailing comments that belong to the parent scope
-        // (tree-sitter parity: extras at block boundaries attach to the parent).
-        if (ctx.peekKind() === TokenKind.COMMENT && isTrailingCommentOnly(ctx)) {
-            break;
-        }
-        const stmt = parseStatement(ctx, parseTemplate);
-        if (stmt) {
-            node.appendChild(stmt);
-        }
-        else {
-            const err = synchronize(ctx);
-            if (err) {
-                node.appendChild(err);
-            }
-            else if (!isAtEnd(ctx) && ctx.peekKind() !== TokenKind.DEDENT) {
-                ctx.consume();
-            }
-        }
-    }
-    // If the procedure is empty, add an ERROR node (Error 07, 34)
-    if (node.namedChildren.length === 0) {
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseStatement(ctx, parseTemplate) {
-    const tok = ctx.peek();
-    if (tok.kind === TokenKind.ID) {
-        switch (tok.text) {
-            case 'if':
-                return parseIfStatement(ctx, parseTemplate);
-            case 'run':
-                return parseRunStatement(ctx, parseTemplate);
-            case 'set':
-                return parseSetStatement(ctx);
-            case 'transition':
-                return parseTransitionStatement(ctx);
-            case 'with':
-                return parseWithStatement(ctx);
-            case 'available': {
-                if (ctx.peekAt(1).kind === TokenKind.ID &&
-                    ctx.peekAt(1).text === 'when') {
-                    return parseAvailableWhenStatement(ctx);
-                }
-                break;
-            }
-            case 'else':
-            case 'elif':
-            case 'for':
-                // Orphan else/elif (without if) or unsupported for → wrap in ERROR
-                return parseOrphanBlock(ctx, c => parseProcedure(c, parseTemplate));
-        }
-    }
-    if (tok.kind === TokenKind.PIPE && parseTemplate) {
-        return parseTemplate(ctx);
-    }
-    if (tok.kind === TokenKind.COMMENT) {
-        const comment = ctx.consumeNamed('comment');
-        if (ctx.peekKind() === TokenKind.NEWLINE)
-            ctx.consume();
-        return comment;
-    }
-    // Fallback: try parsing as a bare expression (e.g., `...` inside a procedure)
-    // This keeps expressions as proper expression nodes instead of ERROR-wrapped tokens.
-    const expr = parseExpression(ctx, 0);
-    if (expr) {
-        const wrapped = wrapExpression(ctx, expr);
-        if (ctx.peekKind() === TokenKind.NEWLINE)
-            ctx.consume();
-        return wrapped;
-    }
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Shared colon → procedure body
-// ---------------------------------------------------------------------------
-/**
- * Shared colon → procedure body sequence for if/elif/else.
- * Consumes colon (with recovery), inline comment, extra inline tokens,
- * then INDENT → procedure → DEDENT, and trailing NEWLINE.
- *
- * @param errorOnMissingBody - if true, insert ERROR when colon has no
- *   indented body (used by `if`; elif/else silently accept missing body).
- */
-function parseColonAndProcedureBody(ctx, node, row, errorOnMissingBody, parseTemplate) {
-    // Colon (or recovery)
-    if (ctx.peekKind() === TokenKind.COLON) {
-        ctx.addAnonymousChild(node, ctx.consume());
-    }
-    else if (errorOnMissingBody) {
-        node.appendChild(makeEmptyError(ctx));
-    }
-    // Inline comment after colon
-    if (ctx.peekKind() === TokenKind.COMMENT) {
-        node.appendChild(ctx.consumeNamed('comment'));
-    }
-    // Absorb extra inline tokens after colon on the same row
-    const inlineErr = synchronizeRow(ctx, row);
-    if (inlineErr)
-        node.appendChild(inlineErr);
-    // Consequence block
-    if (ctx.peekKind() === TokenKind.INDENT) {
-        ctx.consume();
-        const proc = parseProcedure(ctx, parseTemplate);
-        if (proc)
-            node.appendChild(proc, 'consequence');
-        consumeCommentsAndSkipNewlines(ctx, node);
-        if (ctx.peekKind() === TokenKind.DEDENT)
-            ctx.consume();
-    }
-    else if (errorOnMissingBody &&
-        (ctx.peekKind() === TokenKind.NEWLINE || ctx.isAtSyncPoint())) {
-        node.appendChild(makeEmptyError(ctx));
-    }
-    if (ctx.peekKind() === TokenKind.NEWLINE)
-        ctx.consume();
-}
-// ---------------------------------------------------------------------------
-// Individual statement parsers
-// ---------------------------------------------------------------------------
-export function parseIfStatement(ctx, parseTemplate) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('if_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // if
-    // Condition
-    let condition = parseExpression(ctx, 0);
-    // Handle single `=` typo (should be `==`): wrap `=` in ERROR,
-    // build comparison_expression, then continue parsing normally
-    if (condition && ctx.peekKind() === TokenKind.EQ) {
-        const eqTok = ctx.consume(); // =
-        const right = parseExpression(ctx, 5); // parse right side above comparison
-        if (right) {
-            // Build: (comparison_expression (expr left) (ERROR =) (expr right))
-            const cmp = ctx.startNodeAt('comparison_expression', condition);
-            cmp.appendChild(wrapExpression(ctx, condition));
-            // Wrap `=` in ERROR
-            const eqChild = new CSTNode('=', ctx.source, eqTok.startOffset, eqTok.startOffset + 1, eqTok.start, eqTok.end, false);
-            const eqErr = makeErrorNode(ctx.source, [eqChild], eqTok.startOffset, eqTok.startOffset + 1, eqTok.start, eqTok.end);
-            cmp.appendChild(eqErr);
-            cmp.appendChild(wrapExpression(ctx, right));
-            cmp.finalize();
-            condition = cmp;
-        }
-    }
-    if (condition)
-        node.appendChild(wrapExpression(ctx, condition), 'condition');
-    // Absorb extra tokens between condition and colon on the same row.
-    if (condition &&
-        ctx.peekKind() !== TokenKind.COLON &&
-        !ctx.isAtSyncPoint() &&
-        ctx.peekKind() !== TokenKind.INDENT) {
-        const condRow = startTok.start.row;
-        const err = synchronizeRowUntilColon(ctx, condRow);
-        if (err)
-            node.appendChild(err);
-    }
-    parseColonAndProcedureBody(ctx, node, startTok.start.row, true, parseTemplate);
-    // elif clauses (including misspelled 'elseif')
-    while (ctx.peekKind() === TokenKind.ID &&
-        (ctx.peek().text === 'elif' || ctx.peek().text === 'elseif')) {
-        const elif = parseElifClause(ctx, parseTemplate);
-        if (elif)
-            node.appendChild(elif, 'alternative');
-    }
-    // else clause
-    if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === 'else') {
-        const elseClause = parseElseClause(ctx, parseTemplate);
-        if (elseClause)
-            node.appendChild(elseClause, 'alternative');
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseElifClause(ctx, parseTemplate) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('elif_clause');
-    const kw = ctx.consume(); // elif or elseif
-    if (kw.text === 'elseif') {
-        // Wrap misspelled keyword in ERROR
-        const kwEnd = kw.startOffset + kw.text.length;
-        const leaf = tokenToAutoLeaf(kw, ctx.source, kw.startOffset);
-        const errNode = makeErrorNode(ctx.source, [leaf], kw.startOffset, kwEnd, kw.start, kw.end);
-        node.appendChild(errNode);
-    }
-    else {
-        ctx.addAnonymousChild(node, kw);
-    }
-    const condition = parseExpression(ctx, 0);
-    if (condition)
-        node.appendChild(wrapExpression(ctx, condition), 'condition');
-    // Absorb extra tokens between condition and colon (same as if)
-    if (condition &&
-        ctx.peekKind() !== TokenKind.COLON &&
-        !ctx.isAtSyncPoint() &&
-        ctx.peekKind() !== TokenKind.INDENT) {
-        const condRow = startTok.start.row;
-        const err = synchronizeRowUntilColon(ctx, condRow);
-        if (err)
-            node.appendChild(err);
-    }
-    parseColonAndProcedureBody(ctx, node, startTok.start.row, false, parseTemplate);
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseElseClause(ctx, parseTemplate) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('else_clause');
-    ctx.addAnonymousChild(node, ctx.consume()); // else
-    parseColonAndProcedureBody(ctx, node, startTok.start.row, false, parseTemplate);
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseRunStatement(ctx, parseTemplate) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('run_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // run
-    // Target expression
-    if (!ctx.isAtSyncPoint()) {
-        const target = parseExpression(ctx, 0);
-        if (target) {
-            node.appendChild(wrapExpression(ctx, target), 'target');
-        }
-        else {
-            addMissingTarget(ctx, node);
-        }
-    }
-    else {
-        // `run` with no target at all → insert ERROR placeholder
-        addMissingTarget(ctx, node);
-    }
-    // Optional indented block (procedure)
-    if (ctx.peekKind() === TokenKind.INDENT) {
-        ctx.consume();
-        // Comments before procedure body attach to run_statement
-        consumeCommentsAndSkipNewlines(ctx, node);
-        const proc = parseProcedure(ctx, parseTemplate);
-        if (proc) {
-            // If procedure contains an ERROR with `with` keyword (invalid with clause),
-            // attach children directly to run_statement so the dialect's
-            // error recovery can find them (it looks at run_statement.children).
-            const hasWithError = proc.namedChildren.some(c => c.isError && c.children.some(cc => cc.type === 'with'));
-            if (hasWithError) {
-                for (const child of proc.namedChildren) {
-                    node.appendChild(child);
-                }
-            }
-            else {
-                node.appendChild(proc, 'block_value');
-            }
-        }
-        consumeCommentsAndSkipNewlines(ctx, node);
-        if (ctx.peekKind() === TokenKind.DEDENT)
-            ctx.consume();
-    }
-    if (ctx.peekKind() === TokenKind.NEWLINE)
-        ctx.consume();
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseSetStatement(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('set_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // set
-    // Parse target at precedence 5 (above comparison/=) so = and == aren't consumed
-    const target = parseExpression(ctx, 5);
-    if (ctx.peekKind() === TokenKind.EQEQ) {
-        // set @var == "value" → ERROR: == instead of =
-        // Build comparison_expression(target, ==, rhs) and wrap in ERROR
-        // Don't add target to node — we're returning an ERROR node instead
-        const eqTok = ctx.consume(); // ==
-        const rhs = parseExpression(ctx, 0);
-        if (target && rhs) {
-            const cmp = ctx.startNodeAt('comparison_expression', wrapExpression(ctx, target));
-            cmp.appendChild(wrapExpression(ctx, target));
-            cmp.appendChild(new CSTNode(eqTok.text, ctx.source, eqTok.startOffset, eqTok.startOffset + 2, eqTok.start, eqTok.end, false));
-            cmp.appendChild(wrapExpression(ctx, rhs));
-            cmp.finalize();
-            const wrappedCmp = wrapExpression(ctx, cmp);
-            if (ctx.peekKind() === TokenKind.NEWLINE)
-                ctx.consume();
-            // Return ERROR instead of set_statement
-            return makeErrorNode(ctx.source, [wrappedCmp], wrappedCmp.startOffset, wrappedCmp.endOffset, wrappedCmp.startPosition, wrappedCmp.endPosition);
-        }
-    }
-    // Add target to node only after ruling out the == error case
-    if (target)
-        node.appendChild(wrapExpression(ctx, target), 'target');
-    if (ctx.peekKind() === TokenKind.EQ) {
-        ctx.addAnonymousChild(node, ctx.consume()); // =
-        const value = parseExpression(ctx, 0);
-        if (value)
-            node.appendChild(wrapExpression(ctx, value), 'value');
-    }
-    if (ctx.peekKind() === TokenKind.NEWLINE)
-        ctx.consume();
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseTransitionStatement(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('transition_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // transition
-    // Optional with/to statement list
-    const withToList = tryParseWithToStatementList(ctx);
-    if (withToList) {
-        node.appendChild(withToList, 'with_to_statement_list');
-    }
-    else if (!ctx.isAtSyncPoint() &&
-        ctx.peekKind() !== TokenKind.NEWLINE &&
-        ctx.peekKind() !== TokenKind.EOF) {
-        // No with/to list found but there are tokens remaining on the same line —
-        // likely a missing 'to' keyword (e.g. "transition @topic.greeting").
-        // Insert a synthetic with_to_statement_list containing a to_statement
-        // with a MISSING 'to' node.
-        const listNode = ctx.startNode('with_to_statement_list');
-        const toNode = ctx.startNode('to_statement');
-        toNode.appendChild(makeMissing(ctx, 'to'));
-        const target = parseExpression(ctx, 0);
-        if (target)
-            toNode.appendChild(wrapExpression(ctx, target), 'target');
-        toNode.finalize();
-        listNode.appendChild(toNode);
-        listNode.finalize();
-        node.appendChild(listNode, 'with_to_statement_list');
-    }
-    if (ctx.peekKind() === TokenKind.NEWLINE)
-        ctx.consume();
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseWithStatement(ctx) {
-    const startTok = ctx.peek();
-    // Check if `with` is followed by a valid param (ID/STRING).
-    // If not (e.g., `with ...`), create ERROR containing `with` keyword.
-    // The remaining tokens (e.g. `...`) stay unconsumed for the caller.
-    if (ctx.peekAt(1).kind !== TokenKind.ID &&
-        ctx.peekAt(1).kind !== TokenKind.STRING) {
-        const withTok = ctx.consume();
-        const kwOffset = ctx.currentOffset();
-        const withChild = new CSTNode('with', ctx.source, kwOffset, kwOffset + 4, withTok.start, withTok.end, false);
-        return makeErrorNode(ctx.source, [withChild], kwOffset, kwOffset + 4, withTok.start, withTok.end);
-    }
-    const node = ctx.startNode('with_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // with
-    // Parse param=value pairs
-    parseWithParams(ctx, node);
-    // Inline comment on the with line (e.g. `with city=x # comment`)
-    if (ctx.peekKind() === TokenKind.COMMENT) {
-        node.appendChild(ctx.consumeNamed('comment'));
-    }
-    if (ctx.peekKind() === TokenKind.NEWLINE)
-        ctx.consume();
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseWithParams(ctx, node) {
-    while (!ctx.isAtSyncPoint()) {
-        // param
-        if (ctx.peekKind() === TokenKind.ID ||
-            ctx.peekKind() === TokenKind.STRING) {
-            if (ctx.peekKind() === TokenKind.STRING) {
-                node.appendChild(parseString(ctx), 'param');
-            }
-            else {
-                node.appendChild(ctx.consumeNamed('id'), 'param');
-            }
-        }
-        else {
-            // Not a valid param — wrap remaining tokens in ERROR inside with_statement
-            const err = synchronize(ctx);
-            if (err)
-                node.appendChild(err);
-            return;
-        }
-        // =
-        if (ctx.peekKind() === TokenKind.EQ) {
-            ctx.addAnonymousChild(node, ctx.consume());
-        }
-        else {
-            // Missing = → insert MISSING
-            node.appendChild(makeMissing(ctx, '='));
-        }
-        // value
-        const value = parseExpression(ctx, 0);
-        if (value)
-            node.appendChild(wrapExpression(ctx, value), 'value');
-        // comma
-        if (ctx.peekKind() === TokenKind.COMMA) {
-            ctx.addAnonymousChild(node, ctx.consume());
-        }
-        else {
-            break;
-        }
-    }
-}
-export function parseAvailableWhenStatement(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('available_when_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // available
-    ctx.addAnonymousChild(node, ctx.consume()); // when
-    const condition = parseExpression(ctx, 0);
-    if (condition)
-        node.appendChild(wrapExpression(ctx, condition), 'condition');
-    if (ctx.peekKind() === TokenKind.NEWLINE)
-        ctx.consume();
-    ctx.finishNode(node, startTok);
-    return node;
-}
-// ---------------------------------------------------------------------------
-// With/To statement list
-// ---------------------------------------------------------------------------
-export function tryParseWithToStatementList(ctx) {
-    const tok = ctx.peek();
-    if (!isTokenKind(tok, TokenKind.ID))
-        return null;
-    if (!['with', 'to'].includes(tok.text))
-        return null;
-    const startTok = tok;
-    const node = ctx.startNode('with_to_statement_list');
-    while (!ctx.isAtSyncPoint()) {
-        if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === 'with') {
-            node.appendChild(parseInlineWithStatement(ctx));
-        }
-        else if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === 'to') {
-            node.appendChild(parseToStatement(ctx));
-        }
-        else {
-            break;
-        }
-        if (ctx.peekKind() === TokenKind.COMMA) {
-            ctx.addAnonymousChild(node, ctx.consume());
-        }
-        else {
-            break;
-        }
-    }
-    if (node.children.length === 0)
-        return null;
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseInlineWithStatement(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('with_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // with
-    parseWithParams(ctx, node);
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseToStatement(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('to_statement');
-    ctx.addAnonymousChild(node, ctx.consume()); // to
-    const target = parseExpression(ctx, 0);
-    if (target) {
-        node.appendChild(wrapExpression(ctx, target), 'target');
-    }
-    else {
-        // Missing target → ERROR
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-//# sourceMappingURL=parse-statements.js.map

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

@@ -1,15 +0,0 @@
-import { CSTNode } from './cst-node.js';
-import type { ParserContext } from './parser.js';
-/**
- * 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 declare function parseTemplate(ctx: ParserContext): CSTNode;
-/**
- * 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 declare function parseTemplateAsColinear(ctx: ParserContext): CSTNode;
-//# sourceMappingURL=parse-templates.d.ts.map