sf-agentpmd 0.1.0

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

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

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

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

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