@rong/agentscript 0.1.0

package/dist/parser/parser.js

@@ -0,0 +1,661 @@
+import { ParseError } from "./errors.js";
+import { SHAPE_TYPE_NAMES } from "../ast/constants.js";
+import { tokenize } from "./tokenizer.js";
+export function parse(source) {
+    return new Parser(tokenize(source)).parseProgram();
+}
+const IMPORT_RESOURCE_KINDS = new Set(["tool", "llm", "file", "agent", "memory"]);
+const CONFIG_KEYS = new Set(["model", "role", "description"]);
+const ANONYMOUS_MAIN_AGENT = "__main_agent";
+const ANONYMOUS_MAIN_FUNC = "__main";
+class Parser {
+    tokens;
+    current = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parseProgram() {
+        const start = this.peek().range.start;
+        const imports = [];
+        const agents = [];
+        while (!this.isAtEnd()) {
+            if (this.check("import")) {
+                imports.push(this.parseImport());
+            }
+            else if (this.check("agent") || this.check("main")) {
+                agents.push(this.parseAgent());
+            }
+            else {
+                throw this.error(`Expected 'import', 'agent', or 'main agent'`);
+            }
+        }
+        return {
+            kind: "Program",
+            imports,
+            agents,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseImport() {
+        const start = this.consume("import").range.start;
+        const resourceToken = this.consumeIdentifier("Expected import resource kind");
+        const resourceKind = resourceToken.value;
+        if (!isImportResourceKind(resourceKind)) {
+            throw new ParseError("Expected import resource kind 'tool', 'llm', 'file', 'agent', or 'memory'", resourceToken.range.start);
+        }
+        const name = this.consumeIdentifier(`Expected ${resourceKind} name`).value;
+        this.consume("from");
+        const uri = this.consumeKind("string", `Expected ${resourceKind} URI`).value;
+        return {
+            kind: "ImportDecl",
+            resourceKind,
+            name,
+            uri,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseAgent() {
+        const mainToken = this.match("main") ? this.previous() : undefined;
+        const start = (mainToken ?? this.peek()).range.start;
+        const isMain = Boolean(mainToken);
+        this.consume("agent");
+        const name = this.check("{") ? ANONYMOUS_MAIN_AGENT : this.consumeIdentifier("Expected agent name").value;
+        if (!isMain && name === ANONYMOUS_MAIN_AGENT) {
+            throw this.error("Only main agent can omit its name");
+        }
+        this.consume("{");
+        const config = [];
+        const functions = [];
+        while (!this.check("}") && !this.isAtEnd()) {
+            if (this.isConfigKey(this.peek().value)) {
+                config.push(this.parseConfigDecl());
+            }
+            else if (this.check("func") || this.check("main")) {
+                functions.push(this.parseFunc());
+            }
+            else {
+                throw this.error("Expected configuration declaration or function declaration");
+            }
+        }
+        this.consume("}");
+        return {
+            kind: "AgentDecl",
+            name,
+            isMain,
+            config,
+            functions,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseConfigDecl() {
+        const key = this.consumeConfigKey();
+        const value = this.parseConfigValue(key.value);
+        return {
+            kind: "ConfigDecl",
+            key: key.value,
+            value,
+            range: { start: key.range.start, end: value.range.end }
+        };
+    }
+    parseConfigStmt() {
+        const key = this.consumeConfigKey();
+        const value = this.parseConfigValue(key.value);
+        return {
+            kind: "ConfigStmt",
+            key: key.value,
+            value,
+            range: { start: key.range.start, end: value.range.end }
+        };
+    }
+    parseFunc() {
+        const mainToken = this.match("main") ? this.previous() : undefined;
+        const start = (mainToken ?? this.peek()).range.start;
+        const isMain = Boolean(mainToken);
+        this.consume("func");
+        const name = this.check("(") ? ANONYMOUS_MAIN_FUNC : this.consumeIdentifier("Expected function name").value;
+        if (!isMain && name === ANONYMOUS_MAIN_FUNC) {
+            throw this.error("Only main func can omit its name");
+        }
+        this.consume("(");
+        const params = this.parseCommaSeparatedUntil(")", () => this.parseFuncParam());
+        this.consume(")");
+        const body = this.parseBlock();
+        return {
+            kind: "FuncDecl",
+            name,
+            isMain,
+            params,
+            body,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseFuncParam() {
+        const token = this.consumeIdentifier("Expected parameter name");
+        const shape = this.check("{") ? this.parseShapeObject() : undefined;
+        return {
+            kind: "FuncParam",
+            name: token.value,
+            shape,
+            range: { start: token.range.start, end: (shape ?? token).range.end }
+        };
+    }
+    parseBlock() {
+        this.consume("{");
+        const statements = [];
+        while (!this.check("}") && !this.isAtEnd()) {
+            statements.push(this.parseStatement());
+        }
+        this.consume("}");
+        return statements;
+    }
+    parseStatement() {
+        if (this.isConfigKey(this.peek().value)) {
+            return this.parseConfigStmt();
+        }
+        if (this.check("use")) {
+            return this.parseUse();
+        }
+        if (this.check("return")) {
+            return this.parseReturn();
+        }
+        if (this.check("repeat")) {
+            return this.parseRepeat();
+        }
+        if (this.check("for")) {
+            return this.parseForIn();
+        }
+        if (this.check("loop")) {
+            return this.parseLoop();
+        }
+        if (this.check("if")) {
+            return this.parseIf();
+        }
+        return this.parseAssignmentOrExpressionStatement();
+    }
+    parseUse() {
+        const start = this.consume("use").range.start;
+        const value = this.parseLogicalOr();
+        const budget = this.match("<") ? this.parseBudget() : undefined;
+        return {
+            kind: "UseStmt",
+            value,
+            budget,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseConfigValue(key) {
+        if (key === "model") {
+            return this.parsePostfix();
+        }
+        return this.parseExpression();
+    }
+    parseReturn() {
+        const start = this.consume("return").range.start;
+        const value = this.parseExpression();
+        return {
+            kind: "ReturnStmt",
+            value,
+            range: { start, end: value.range.end }
+        };
+    }
+    parseRepeat() {
+        const start = this.consume("repeat").range.start;
+        this.consume("*");
+        const maxAttempts = this.parsePositiveInteger("Expected repeat count");
+        const body = this.parseBlock();
+        return {
+            kind: "RepeatStmt",
+            maxAttempts,
+            body,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseForIn() {
+        const start = this.consume("for").range.start;
+        const item = this.consumeIdentifier("Expected for item name");
+        this.consume("in");
+        const iterable = this.parseLogicalOr();
+        this.consume("<");
+        const maxIterations = this.parsePositiveInteger("Expected for iteration count");
+        const body = this.parseBlock();
+        return {
+            kind: "ForInStmt",
+            itemName: item.value,
+            itemRange: item.range,
+            iterable,
+            maxIterations,
+            body,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseLoop() {
+        const start = this.consume("loop").range.start;
+        this.consume("until");
+        const condition = this.parseLogicalOr();
+        this.consume("<");
+        const maxIterations = this.parsePositiveInteger("Expected loop iteration count");
+        const body = this.parseBlock();
+        return {
+            kind: "LoopUntilStmt",
+            condition,
+            maxIterations,
+            body,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseIf() {
+        const start = this.consume("if").range.start;
+        const condition = this.parseExpression();
+        const thenBody = this.parseBlock();
+        const elseBody = this.match("else") ? this.parseBlock() : undefined;
+        return {
+            kind: "IfStmt",
+            condition,
+            thenBody,
+            elseBody,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseAssignmentOrExpressionStatement() {
+        const expr = this.parseExpression();
+        if (this.match("=")) {
+            if (expr.kind !== "IdentifierExpr" && expr.kind !== "MemberExpr") {
+                throw new ParseError("Assignment target must be an identifier or member expression", expr.range.start);
+            }
+            const value = this.parseExpression();
+            return {
+                kind: "AssignStmt",
+                target: expr,
+                value,
+                range: { start: expr.range.start, end: value.range.end }
+            };
+        }
+        return {
+            kind: "ExprStmt",
+            expr,
+            range: expr.range
+        };
+    }
+    parseExpression() {
+        return this.parseLogicalOr();
+    }
+    parseLogicalOr() {
+        return this.parseBinaryExpression(() => this.parseLogicalAnd(), "or");
+    }
+    parseLogicalAnd() {
+        return this.parseBinaryExpression(() => this.parseEquality(), "and");
+    }
+    parseEquality() {
+        return this.parseBinaryExpression(() => this.parseUnary(), "==", "!=");
+    }
+    parseBinaryExpression(parseOperand, ...operators) {
+        let expr = parseOperand();
+        while (this.matchAny(operators)) {
+            const operator = this.previous().value;
+            const right = parseOperand();
+            expr = {
+                kind: "BinaryExpr",
+                operator,
+                left: expr,
+                right,
+                range: { start: expr.range.start, end: right.range.end }
+            };
+        }
+        return expr;
+    }
+    parseUnary() {
+        if (this.match("not")) {
+            const start = this.previous().range.start;
+            const value = this.parseUnary();
+            return {
+                kind: "UnaryExpr",
+                operator: "not",
+                value,
+                range: { start, end: value.range.end }
+            };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.match(".")) {
+                const property = this.consumeIdentifier("Expected property name").value;
+                expr = {
+                    kind: "MemberExpr",
+                    object: expr,
+                    property,
+                    range: { start: expr.range.start, end: this.previous().range.end }
+                };
+                continue;
+            }
+            if (this.match("(")) {
+                const args = this.parseCommaSeparatedUntil(")", () => this.parseExpression());
+                this.consume(")");
+                expr = {
+                    kind: "CallExpr",
+                    callee: expr,
+                    args,
+                    range: { start: expr.range.start, end: this.previous().range.end }
+                };
+                continue;
+            }
+            if (this.match("[")) {
+                const index = this.parseExpression();
+                this.consume("]");
+                expr = {
+                    kind: "IndexExpr",
+                    object: expr,
+                    index,
+                    range: { start: expr.range.start, end: this.previous().range.end }
+                };
+                continue;
+            }
+            break;
+        }
+        return expr;
+    }
+    parsePrimary() {
+        const token = this.peek();
+        if (this.check("generate")) {
+            return this.parseGenerate();
+        }
+        if (this.matchKind("string")) {
+            return {
+                kind: "StringExpr",
+                value: token.value,
+                range: token.range
+            };
+        }
+        if (this.matchKind("number")) {
+            return {
+                kind: "NumberExpr",
+                value: Number.parseFloat(token.value),
+                raw: token.value,
+                range: token.range
+            };
+        }
+        if (this.match("true") || this.match("false")) {
+            return {
+                kind: "BooleanExpr",
+                value: token.value === "true",
+                range: token.range
+            };
+        }
+        if (this.match("none")) {
+            return {
+                kind: "NullExpr",
+                range: token.range
+            };
+        }
+        if (this.check("{")) {
+            return this.parseObject();
+        }
+        if (this.check("[")) {
+            return this.parseList();
+        }
+        if (this.matchKind("identifier") || this.matchKind("keyword")) {
+            return {
+                kind: "IdentifierExpr",
+                name: token.value,
+                range: token.range
+            };
+        }
+        throw this.error("Expected expression");
+    }
+    parseGenerate() {
+        const start = this.consume("generate").range.start;
+        this.consume("(");
+        const options = this.parseGenerateOptions();
+        this.consume(")");
+        this.consume("{");
+        this.consume("return");
+        const returnShape = this.parseShapeObject();
+        this.consume("}");
+        return {
+            kind: "GenerateExpr",
+            options,
+            returnShape,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseGenerateOptions() {
+        const start = this.consume("{").range.start;
+        const properties = [];
+        let input;
+        let attempts;
+        let limit;
+        let debug;
+        while (!this.check("}") && !this.isAtEnd()) {
+            const propStart = this.peek().range.start;
+            const key = this.consumeObjectKey();
+            this.consume(":");
+            let value;
+            if (key === "limit") {
+                const token = this.consumeKind("number", "Expected generate limit");
+                limit = this.parseBudgetToken(token);
+                value = {
+                    kind: "NumberExpr",
+                    value: Number.parseFloat(token.value),
+                    raw: token.value,
+                    range: token.range
+                };
+            }
+            else {
+                value = this.parseExpression();
+            }
+            properties.push({
+                kind: "ObjectProperty",
+                key,
+                value,
+                range: { start: propStart, end: value.range.end }
+            });
+            if (key === "input") {
+                input = value;
+            }
+            else if (key === "attempts" && value.kind === "NumberExpr") {
+                attempts = value;
+            }
+            else if (key === "debug" && value.kind === "BooleanExpr") {
+                debug = value;
+            }
+            this.match(",");
+        }
+        this.consume("}");
+        return {
+            kind: "GenerateOptionsExpr",
+            properties,
+            input,
+            attempts,
+            limit,
+            debug,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseObject() {
+        const start = this.consume("{").range.start;
+        const properties = [];
+        while (!this.check("}") && !this.isAtEnd()) {
+            const propStart = this.peek().range.start;
+            const key = this.consumeObjectKey();
+            this.consume(":");
+            const value = this.parseExpression();
+            properties.push({
+                kind: "ObjectProperty",
+                key,
+                value,
+                range: { start: propStart, end: value.range.end }
+            });
+            this.match(",");
+        }
+        this.consume("}");
+        return {
+            kind: "ObjectExpr",
+            properties,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseList() {
+        const start = this.consume("[").range.start;
+        const items = this.parseCommaSeparatedUntil("]", () => this.parseExpression());
+        this.consume("]");
+        return {
+            kind: "ListExpr",
+            items,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseShapeObject() {
+        const start = this.consume("{").range.start;
+        const fields = this.parseCommaSeparatedUntil("}", () => this.parseShapeField());
+        this.consume("}");
+        return {
+            kind: "ShapeObjectExpr",
+            fields,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseShapeField() {
+        const start = this.peek().range.start;
+        const name = this.consumeIdentifier("Expected shape field name").value;
+        const type = this.parseShapeType();
+        return {
+            kind: "ShapeField",
+            name,
+            type,
+            range: { start, end: type.range.end }
+        };
+    }
+    parseShapeType() {
+        const start = this.peek().range.start;
+        const name = this.consumeIdentifier("Expected shape type").value;
+        if (name === "list" && this.match("[")) {
+            const itemType = this.parseShapeType();
+            this.consume("]");
+            return {
+                kind: "ListShapeType",
+                itemType,
+                range: { start, end: this.previous().range.end }
+            };
+        }
+        if (!SHAPE_TYPE_NAMES.has(name)) {
+            throw new ParseError(`Unsupported shape type '${name}'`, { ...start });
+        }
+        return {
+            kind: "NamedShapeType",
+            name: name,
+            range: { start, end: this.previous().range.end }
+        };
+    }
+    parseBudget() {
+        return this.parseBudgetToken(this.consumeKind("number", "Expected budget amount"));
+    }
+    parseBudgetToken(token) {
+        const raw = token.value;
+        const match = /^(\d+(?:\.\d+)?)([A-Za-z]+)?$/.exec(raw);
+        if (!match) {
+            throw this.error(`Invalid budget '${raw}'`);
+        }
+        return {
+            amount: Number.parseFloat(match[1] ?? raw),
+            unit: match[2]
+        };
+    }
+    parsePositiveInteger(message) {
+        const raw = this.consumeKind("number", message).value;
+        if (!/^\d+$/.test(raw)) {
+            throw this.error(message);
+        }
+        return Number.parseInt(raw, 10);
+    }
+    consumeObjectKey() {
+        if (this.matchKind("identifier") || this.matchKind("keyword") || this.matchKind("string")) {
+            return this.previous().value;
+        }
+        throw this.error("Expected object key");
+    }
+    consumeConfigKey() {
+        const token = this.consumeIdentifier("Expected configuration key");
+        if (!this.isConfigKey(token.value)) {
+            throw this.error("Expected configuration key");
+        }
+        return token;
+    }
+    consumeIdentifier(message) {
+        if (this.matchKind("identifier") || this.matchKind("keyword")) {
+            return this.previous();
+        }
+        throw this.error(message);
+    }
+    consumeKind(kind, message) {
+        if (this.matchKind(kind)) {
+            return this.previous();
+        }
+        throw this.error(message);
+    }
+    consume(value) {
+        if (this.match(value)) {
+            return this.previous();
+        }
+        throw this.error(`Expected '${value}'`);
+    }
+    match(value) {
+        if (!this.check(value)) {
+            return false;
+        }
+        this.advance();
+        return true;
+    }
+    matchAny(values) {
+        if (!values.some((value) => this.check(value))) {
+            return false;
+        }
+        this.advance();
+        return true;
+    }
+    matchKind(kind) {
+        if (!this.checkKind(kind)) {
+            return false;
+        }
+        this.advance();
+        return true;
+    }
+    check(value) {
+        return this.peek().value === value;
+    }
+    checkKind(kind) {
+        return this.peek().kind === kind;
+    }
+    parseCommaSeparatedUntil(terminator, parseItem) {
+        const items = [];
+        while (!this.check(terminator) && !this.isAtEnd()) {
+            items.push(parseItem());
+            this.match(",");
+        }
+        return items;
+    }
+    advance() {
+        if (!this.isAtEnd()) {
+            this.current += 1;
+        }
+        return this.previous();
+    }
+    isAtEnd() {
+        return this.peek().kind === "eof";
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    previous() {
+        return this.tokens[this.current - 1] ?? this.tokens[0];
+    }
+    error(message) {
+        return new ParseError(message, this.peek().range.start);
+    }
+    isConfigKey(value) {
+        return CONFIG_KEYS.has(value);
+    }
+}
+function isImportResourceKind(value) {
+    return IMPORT_RESOURCE_KINDS.has(value);
+}