sf-agentpmd 0.1.0 → 0.1.1

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

@@ -1,260 +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
- */
-/**
- * Walk the CST and produce highlight captures matching highlights.scm.
- *
- * Tree-sitter query priority: later patterns override earlier ones.
- * We replicate this by first assigning generic captures, then overriding
- * with contextual ones (e.g., id → variable, then key > id → property).
- */
-export function highlight(root) {
-    const captures = [];
-    walkNode(root, captures);
-    return captures;
-}
-function capture(node, name, captures) {
-    captures.push({
-        name,
-        text: node.text,
-        startRow: node.startRow,
-        startCol: node.startCol,
-        endRow: node.endRow,
-        endCol: node.endCol,
-    });
-}
-function walkNode(node, captures) {
-    // --- Named node type-based captures ---
-    switch (node.type) {
-        case 'comment':
-            capture(node, 'comment', captures);
-            return; // Don't recurse into comments
-        case 'number':
-            capture(node, 'number', captures);
-            return;
-        case 'string':
-            capture(node, 'string', captures);
-            // Recurse to get escape_sequence captures
-            for (const child of node.children) {
-                if (child.type === 'escape_sequence') {
-                    capture(child, 'string.escape', captures);
-                }
-            }
-            return;
-        case 'string_content':
-            capture(node, 'string', captures);
-            return;
-        case 'escape_sequence':
-            capture(node, 'string.escape', captures);
-            return;
-        case 'template_content':
-            capture(node, 'string', captures);
-            return;
-        case 'ellipsis':
-            capture(node, 'constant.builtin', captures);
-            return;
-        case 'id':
-            captureId(node, captures);
-            return;
-        case 'at_id':
-            captureAtId(node, captures);
-            return;
-        case 'template_expression':
-            captureTemplateExpression(node, captures);
-            return;
-        case 'variable_declaration':
-            captureVariableDeclaration(node, captures);
-            return;
-    }
-    // --- Anonymous node captures (punctuation, keywords, operators) ---
-    if (!node.isNamed && node.children.length === 0) {
-        captureAnonymous(node, captures);
-        return;
-    }
-    // Recurse into children
-    for (const child of node.children) {
-        walkNode(child, captures);
-    }
-}
-/** Check if a key node belongs to a root-level mapping element (source_file > mapping > mapping_element > key). */
-function isRootLevelKey(keyNode) {
-    const mappingElement = keyNode.parent;
-    if (mappingElement?.type !== 'mapping_element')
-        return false;
-    const mapping = mappingElement.parent;
-    if (mapping?.type !== 'mapping')
-        return false;
-    return mapping.parent?.type === 'source_file';
-}
-/** Capture an identifier based on its parent context. */
-function captureId(node, captures) {
-    const parent = node.parent;
-    // Constants: True, False, None
-    if (node.text === 'True' || node.text === 'False' || node.text === 'None') {
-        capture(node, 'constant.builtin', captures);
-        return;
-    }
-    // Inside at_id: @identifier → module (namespace)
-    if (parent?.type === 'at_id') {
-        capture(node, 'module', captures);
-        return;
-    }
-    // Mapping key: (key (id)) → property, or block keyword/name at root level
-    if (parent?.type === 'key') {
-        if (isRootLevelKey(parent)) {
-            const namedSiblings = parent.namedChildren;
-            if (namedSiblings.length > 0 && namedSiblings[0] === node) {
-                capture(node, 'keyword.block', captures);
-            }
-            else {
-                capture(node, 'keyword.block.name', captures);
-            }
-        }
-        else {
-            capture(node, 'key', captures);
-        }
-        return;
-    }
-    // Member expression: expr.id → variable (the property after dot)
-    if (parent?.type === 'member_expression') {
-        // Only the trailing id (not the expression part)
-        const parentChildren = parent.namedChildren;
-        if (parentChildren.length > 0 &&
-            parentChildren[parentChildren.length - 1] === node) {
-            capture(node, 'variable', captures);
-            return;
-        }
-    }
-    // With-statement param: with param=value → variable
-    if (parent?.type === 'with_statement') {
-        const fieldName = parent.fieldNameForChild(node._childIndex);
-        if (fieldName === 'param') {
-            capture(node, 'variable', captures);
-            return;
-        }
-    }
-    // Default: variable
-    capture(node, 'variable', captures);
-}
-/** Capture @identifier — the @ and the id inside. */
-function captureAtId(node, captures) {
-    for (const child of node.children) {
-        if (child.type === '@' || child.text === '@') {
-            capture(child, 'decorator', captures);
-        }
-        else if (child.type === 'id') {
-            capture(child, 'module', captures);
-        }
-    }
-}
-/** Capture template expression delimiters {! and }. */
-function captureTemplateExpression(node, captures) {
-    for (const child of node.children) {
-        if (child.text === '{!') {
-            capture(child, 'punctuation.template', captures);
-        }
-        else if (child.text === '}') {
-            capture(child, 'punctuation.template', captures);
-        }
-        else {
-            walkNode(child, captures);
-        }
-    }
-}
-/** Capture variable declaration modifiers (mutable/linked). */
-function captureVariableDeclaration(node, captures) {
-    for (const child of node.children) {
-        if (!child.isNamed &&
-            (child.text === 'mutable' || child.text === 'linked')) {
-            capture(child, 'keyword.modifier', captures);
-        }
-        else {
-            walkNode(child, captures);
-        }
-    }
-}
-/** Capture anonymous nodes: keywords, operators, punctuation. */
-function captureAnonymous(node, captures) {
-    const text = node.text;
-    // Keywords
-    switch (text) {
-        case 'if':
-        case 'elif':
-        case 'else':
-        case 'run':
-        case 'with':
-        case 'set':
-        case 'transition':
-        case 'available':
-        case 'when':
-        case 'and':
-        case 'or':
-        case 'not':
-        case 'is':
-        case 'to':
-            capture(node, 'keyword', captures);
-            return;
-        case 'mutable':
-        case 'linked':
-            capture(node, 'keyword.modifier', captures);
-            return;
-        case 'True':
-        case 'False':
-        case 'None':
-            capture(node, 'constant.builtin', captures);
-            return;
-    }
-    // Operators
-    switch (text) {
-        case '==':
-        case '!=':
-        case '<':
-        case '>':
-        case '<=':
-        case '>=':
-        case '+':
-        case '*':
-        case '/':
-        case '=':
-            capture(node, 'operator', captures);
-            return;
-        case '-':
-            // '-' in sequence dash is punctuation.special, otherwise operator
-            if (node.parent?.type === 'sequence_element') {
-                capture(node, 'punctuation.special', captures);
-            }
-            else {
-                capture(node, 'operator', captures);
-            }
-            return;
-    }
-    // Punctuation
-    switch (text) {
-        case ':':
-        case '.':
-        case ',':
-            capture(node, 'punctuation.delimiter', captures);
-            return;
-        case '[':
-        case ']':
-        case '{':
-        case '}':
-            capture(node, 'punctuation.bracket', captures);
-            return;
-        case '|':
-        case '->':
-        case '- ':
-            capture(node, 'punctuation.special', captures);
-            return;
-        case '@':
-            capture(node, 'decorator', captures);
-            return;
-        case '"':
-            capture(node, 'string', captures);
-            return;
-    }
-}
-//# sourceMappingURL=highlighter.js.map

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

@@ -1,29 +0,0 @@
-/**
- * @agentscript/parser-javascript — Hand-written TypeScript parser for AgentScript.
- *
- * Error-tolerant: NEWLINE and DEDENT are unconditional recovery points.
- */
-export { CSTNode } from './cst-node.js';
-export type { SyntaxNode } from '@agentscript/types';
-export { TokenKind } from './token.js';
-export type { Token, Position } from './token.js';
-export type { TokenStream, NodeBuilder, ParserContext } from './parser.js';
-export { highlight } from './highlighter.js';
-export type { HighlightCapture } from './highlighter.js';
-import type { CSTNode } from './cst-node.js';
-import type { HighlightCapture } from './highlighter.js';
-/**
- * Parse AgentScript source code and return a CST.
- * The returned rootNode implements the SyntaxNode interface
- * used by all consumers (dialect, LSP, monaco, agentforce).
- */
-export declare function parse(source: string): {
-    rootNode: CSTNode;
-};
-/**
- * Parse and highlight source code in one call.
- * Returns captures compatible with the QueryCapture format
- * used by LSP semantic tokens.
- */
-export declare function parseAndHighlight(source: string): HighlightCapture[];
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,35 +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
- */
-/**
- * @agentscript/parser-javascript — Hand-written TypeScript parser for AgentScript.
- *
- * Error-tolerant: NEWLINE and DEDENT are unconditional recovery points.
- */
-export { CSTNode } from './cst-node.js';
-export { TokenKind } from './token.js';
-export { highlight } from './highlighter.js';
-import { Parser } from './parser.js';
-import { highlight } from './highlighter.js';
-/**
- * Parse AgentScript source code and return a CST.
- * The returned rootNode implements the SyntaxNode interface
- * used by all consumers (dialect, LSP, monaco, agentforce).
- */
-export function parse(source) {
-    const parser = new Parser(source);
-    return { rootNode: parser.parse() };
-}
-/**
- * Parse and highlight source code in one call.
- * Returns captures compatible with the QueryCapture format
- * used by LSP semantic tokens.
- */
-export function parseAndHighlight(source) {
-    const { rootNode } = parse(source);
-    return highlight(rootNode);
-}
-//# sourceMappingURL=index.js.map

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

@@ -1,60 +0,0 @@
-import { type Token } from './token.js';
-export declare class Lexer {
-    private source;
-    private offset;
-    private row;
-    private col;
-    private tokens;
-    private indentStack;
-    /** True when the current line started with `|` (template line). */
-    private onTemplateLine;
-    /** Indent level of the line containing `|`. Content deeper than this is template content. */
-    private templateBaseIndent;
-    /** Nested brace depth inside a template expression (for `{` inside `{!...}`). -1 means not inside a template expression. */
-    private templateExprBraceDepth;
-    private get inTemplateExpr();
-    /** Parenthesis depth — suppresses INDENT/DEDENT/NEWLINE when > 0 to support multi-line call expressions. */
-    private bracketDepth;
-    constructor(source: string);
-    tokenize(): Token[];
-    private tokenizeLine;
-    private emitIndentation;
-    private tokenizeToken;
-    private tokenizeId;
-    private tokenizeNumber;
-    private tryDatetime;
-    private tokenizeString;
-    private tokenizeComment;
-    private consumeIndentation;
-    /**
-     * Scan ahead (without advancing) past comment/blank lines to find the indent
-     * of the next line with real (non-comment) content. Returns -1 if only
-     * comments, blanks, or EOF remain. Matches tree-sitter scanner behavior which
-     * skips past comment-only lines when computing INDENT/DEDENT.
-     */
-    private peekNextContentIndent;
-    private peekCharCode;
-    private get hasMore();
-    /**
-     * Attempt to advance n characters.
-     * @returns how many characters were advanced.
-     */
-    private advance;
-    /**
-     * Attempt to consume a newline.
-     * @returns whether a newline was consumed.
-     */
-    private consumeNewline;
-    /**
-     * Checks if the current position is at a newline.
-     * @param additiveOffset
-     * @returns 0 if not at a newline, 1 if at an LF newline, 2 if at a CR LF newline.
-     */
-    private atNewline;
-    private get position();
-    private emitSpan;
-    private emit;
-    private emitVirtual;
-    private makeToken;
-}
-//# sourceMappingURL=lexer.d.ts.map