@misterscan/sesi 1.1.1

package/dist/parser.js

@@ -0,0 +1,1022 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+class Parser {
+    constructor(tokens) {
+        this.current = 0;
+        this.tokens = tokens;
+    }
+    parse() {
+        const statements = [];
+        while (!this.isAtEnd()) {
+            const stmt = this.statement();
+            if (stmt)
+                statements.push(stmt);
+        }
+        return {
+            type: 'Program',
+            statements,
+        };
+    }
+    statement() {
+        this.skipNewlines();
+        if (this.isAtEnd())
+            return null;
+        try {
+            if (this.match('LET'))
+                return this.letStatement();
+            if (this.match('CONST'))
+                return this.constStatement();
+            if (this.match('FN'))
+                return this.functionStatement();
+            if (this.match('IF'))
+                return this.ifStatement();
+            if (this.match('WHILE'))
+                return this.whileStatement();
+            if (this.match('FOR'))
+                return this.forStatement();
+            if (this.match('RETURN'))
+                return this.returnStatement();
+            if (this.match('BREAK'))
+                return this.breakStatement();
+            if (this.match('CONTINUE'))
+                return this.continueStatement();
+            if (this.match('TRY'))
+                return this.tryStatement();
+            if (this.match('IMPORT'))
+                return this.importStatement();
+            if (this.match('EXPORT'))
+                return this.exportStatement();
+            if (this.match('MEMORY'))
+                return this.memoryStatement();
+            if (this.check('LEFT_BRACE'))
+                return this.blockStatement();
+            return this.expressionStatement();
+        }
+        catch (error) {
+            console.error(error.message);
+            this.synchronize();
+            return null;
+        }
+    }
+    letStatement() {
+        const line = this.previous().line;
+        const name = this.consume('IDENTIFIER', 'Expected variable name').lexeme;
+        let typeAnnotation;
+        if (this.match('COLON')) {
+            typeAnnotation = this.typeAnnotation();
+        }
+        let value;
+        if (this.match('EQUAL')) {
+            value = this.expression();
+        }
+        this.consumeStatementEnd();
+        return {
+            type: 'LetStatement',
+            name,
+            typeAnnotation,
+            value,
+            line,
+        };
+    }
+    constStatement() {
+        const line = this.previous().line;
+        const name = this.consume('IDENTIFIER', 'Expected variable name').lexeme;
+        let typeAnnotation;
+        if (this.match('COLON')) {
+            typeAnnotation = this.typeAnnotation();
+        }
+        this.consume('EQUAL', 'Expected = in const declaration');
+        const value = this.expression();
+        this.consumeStatementEnd();
+        return {
+            type: 'ConstStatement',
+            name,
+            typeAnnotation,
+            value,
+            line,
+        };
+    }
+    functionStatement() {
+        const line = this.previous().line;
+        const name = this.consume('IDENTIFIER', 'Expected function name').lexeme;
+        this.consume('LEFT_PAREN', 'Expected ( after function name');
+        const parameters = [];
+        if (!this.check('RIGHT_PAREN')) {
+            do {
+                const paramName = this.consume('IDENTIFIER', 'Expected parameter name').lexeme;
+                let paramType;
+                if (this.match('COLON')) {
+                    paramType = this.typeAnnotation();
+                }
+                let defaultValue;
+                if (this.match('EQUAL')) {
+                    defaultValue = this.assignment();
+                }
+                parameters.push({ name: paramName, type: paramType, defaultValue });
+            } while (this.match('COMMA'));
+        }
+        this.consume('RIGHT_PAREN', 'Expected ) after parameters');
+        let returnType;
+        if (this.match('ARROW')) {
+            returnType = this.typeAnnotation();
+        }
+        this.skipNewlines();
+        const body = this.blockStatement();
+        return {
+            type: 'FunctionStatement',
+            name,
+            parameters,
+            returnType,
+            body,
+            line,
+        };
+    }
+    ifStatement() {
+        const line = this.previous().line;
+        const condition = this.expression();
+        this.skipNewlines();
+        const thenBranch = this.blockStatement();
+        let elseBranch;
+        if (this.match('ELSE')) {
+            if (this.match('IF')) {
+                elseBranch = this.ifStatement();
+            }
+            else {
+                this.skipNewlines();
+                elseBranch = this.blockStatement();
+            }
+        }
+        return {
+            type: 'IfStatement',
+            condition,
+            thenBranch,
+            elseBranch,
+            line,
+        };
+    }
+    whileStatement() {
+        const line = this.previous().line;
+        const condition = this.expression();
+        this.skipNewlines();
+        const body = this.blockStatement();
+        return {
+            type: 'WhileStatement',
+            condition,
+            body,
+            line,
+        };
+    }
+    forStatement() {
+        const line = this.previous().line;
+        const variable = this.consume('IDENTIFIER', 'Expected variable in for loop').lexeme;
+        let iterable;
+        let start;
+        let end;
+        if (this.match('IN')) {
+            iterable = this.expression();
+        }
+        else if (this.match('EQUAL')) {
+            start = this.expression();
+            this.consume('TO', 'Expected "to" in for loop (use: for i = 0 to 10)');
+            end = this.expression();
+        }
+        this.skipNewlines();
+        const body = this.blockStatement();
+        return {
+            type: 'ForStatement',
+            variable,
+            iterable,
+            start,
+            end,
+            body,
+            line,
+        };
+    }
+    returnStatement() {
+        const line = this.previous().line;
+        let value;
+        if (!this.check('SEMICOLON') && !this.check('NEWLINE') && !this.check('RIGHT_BRACE') && !this.isAtEnd()) {
+            value = this.expression();
+        }
+        this.consumeStatementEnd();
+        return {
+            type: 'ReturnStatement',
+            value,
+            line,
+        };
+    }
+    breakStatement() {
+        const line = this.previous().line;
+        this.consumeStatementEnd();
+        return {
+            type: 'BreakStatement',
+            line,
+        };
+    }
+    continueStatement() {
+        const line = this.previous().line;
+        this.consumeStatementEnd();
+        return {
+            type: 'ContinueStatement',
+            line,
+        };
+    }
+    tryStatement() {
+        const line = this.previous().line;
+        this.skipNewlines();
+        const tryBlock = this.blockStatement();
+        this.skipNewlines();
+        this.consume('CATCH', 'Expected "catch" after try block');
+        this.skipNewlines();
+        let catchParameter = 'e';
+        if (this.match('LEFT_PAREN')) {
+            catchParameter = this.consume('IDENTIFIER', 'Expected error variable name').lexeme;
+            this.consume('RIGHT_PAREN', 'Expected ")" after catch parameter');
+        }
+        this.skipNewlines();
+        const catchBlock = this.blockStatement();
+        return {
+            type: 'TryStatement',
+            tryBlock,
+            catchParameter,
+            catchBlock,
+            line,
+        };
+    }
+    importStatement() {
+        const line = this.previous().line;
+        const names = [];
+        if (this.match('LEFT_BRACE')) {
+            do {
+                names.push(this.consume('IDENTIFIER', 'Expected import name').lexeme);
+            } while (this.match('COMMA'));
+            this.consume('RIGHT_BRACE', 'Expected } after imports');
+        }
+        else {
+            names.push(this.consume('IDENTIFIER', 'Expected import name').lexeme);
+        }
+        this.consume('FROM', 'Expected "from" in import statement');
+        const source = this.consume('STRING', 'Expected module path').literal;
+        this.consumeStatementEnd();
+        return {
+            type: 'ImportStatement',
+            names,
+            source: source,
+            line,
+        };
+    }
+    exportStatement() {
+        const line = this.previous().line;
+        let statement;
+        if (this.match('FN')) {
+            statement = this.functionStatement();
+        }
+        else if (this.match('LET')) {
+            statement = this.letStatement();
+        }
+        else if (this.match('CONST')) {
+            statement = this.constStatement();
+        }
+        else {
+            throw new Error('Expected function or variable declaration after export');
+        }
+        return {
+            type: 'ExportStatement',
+            statement,
+            line,
+        };
+    }
+    memoryStatement() {
+        const line = this.previous().line;
+        const name = this.consume('IDENTIFIER', 'Expected memory name').lexeme;
+        let initialValue;
+        if (this.match('LEFT_BRACE')) {
+            const content = [];
+            while (!this.check('RIGHT_BRACE') && !this.isAtEnd()) {
+                content.push(this.expression());
+            }
+            this.consume('RIGHT_BRACE', 'Expected }');
+            if (content.length === 1) {
+                initialValue = content[0];
+            }
+            else if (content.length > 1) {
+                // Concatenate strings
+                let result = content[0];
+                for (let i = 1; i < content.length; i++) {
+                    result = {
+                        type: 'BinaryOp',
+                        left: result,
+                        operator: '+',
+                        right: content[i],
+                        line,
+                    };
+                }
+                initialValue = result;
+            }
+        }
+        this.consumeStatementEnd();
+        return {
+            type: 'MemoryStatement',
+            name,
+            initialValue,
+            line,
+        };
+    }
+    blockStatement() {
+        this.consume('LEFT_BRACE', 'Expected { to start block');
+        const line = this.previous().line;
+        const statements = [];
+        this.skipNewlines();
+        while (!this.check('RIGHT_BRACE') && !this.isAtEnd()) {
+            const stmt = this.statement();
+            if (stmt)
+                statements.push(stmt);
+            this.skipNewlines();
+        }
+        this.consume('RIGHT_BRACE', 'Expected } to end block');
+        return {
+            type: 'BlockStatement',
+            statements,
+            line,
+        };
+    }
+    expressionStatement() {
+        const line = this.peek().line;
+        const expr = this.expression();
+        this.consumeStatementEnd();
+        return {
+            type: 'ExpressionStatement',
+            expression: expr,
+            line,
+        };
+    }
+    expression() {
+        return this.assignment();
+    }
+    assignment() {
+        const expr = this.logicalOr();
+        if (this.match('EQUAL')) {
+            const value = this.assignment();
+            return {
+                type: 'Assignment',
+                left: expr,
+                right: value,
+                line: this.previous().line,
+            };
+        }
+        return expr;
+    }
+    logicalOr() {
+        let expr = this.logicalAnd();
+        while (this.match('PIPE_PIPE')) {
+            const operator = this.previous().lexeme;
+            const right = this.logicalAnd();
+            expr = {
+                type: 'LogicalOp',
+                left: expr,
+                operator: '||',
+                right,
+                line: this.previous().line,
+            };
+        }
+        return expr;
+    }
+    logicalAnd() {
+        let expr = this.equality();
+        while (this.match('AMPERSAND_AMPERSAND')) {
+            const right = this.equality();
+            expr = {
+                type: 'LogicalOp',
+                left: expr,
+                operator: '&&',
+                right,
+                line: this.previous().line,
+            };
+        }
+        return expr;
+    }
+    equality() {
+        let expr = this.comparison();
+        while (this.match('BANG_EQUAL', 'EQUAL_EQUAL')) {
+            const operator = this.previous().lexeme;
+            const right = this.comparison();
+            expr = {
+                type: 'BinaryOp',
+                left: expr,
+                operator,
+                right,
+                line: this.previous().line,
+            };
+        }
+        return expr;
+    }
+    comparison() {
+        let expr = this.addition();
+        while (this.match('GREATER', 'GREATER_EQUAL', 'LESS', 'LESS_EQUAL')) {
+            const operator = this.previous().lexeme;
+            const right = this.addition();
+            expr = {
+                type: 'BinaryOp',
+                left: expr,
+                operator,
+                right,
+                line: this.previous().line,
+            };
+        }
+        return expr;
+    }
+    addition() {
+        let expr = this.multiplication();
+        while (this.match('MINUS', 'PLUS')) {
+            const operator = this.previous().lexeme;
+            const right = this.multiplication();
+            expr = {
+                type: 'BinaryOp',
+                left: expr,
+                operator,
+                right,
+                line: this.previous().line,
+            };
+        }
+        return expr;
+    }
+    multiplication() {
+        let expr = this.unary();
+        while (this.match('SLASH', 'STAR', 'PERCENT')) {
+            const operator = this.previous().lexeme;
+            const right = this.unary();
+            expr = {
+                type: 'BinaryOp',
+                left: expr,
+                operator,
+                right,
+                line: this.previous().line,
+            };
+        }
+        return expr;
+    }
+    unary() {
+        if (this.match('BANG', 'MINUS')) {
+            const operator = this.previous().lexeme;
+            const operand = this.unary();
+            return {
+                type: 'UnaryOp',
+                operator,
+                operand,
+                line: this.previous().line,
+            };
+        }
+        return this.postfix();
+    }
+    postfix() {
+        let expr = this.primary();
+        while (true) {
+            if (this.match('LEFT_PAREN')) {
+                expr = this.finishCall(expr);
+            }
+            else if (this.match('LEFT_BRACKET')) {
+                const index = this.expression();
+                this.consume('RIGHT_BRACKET', 'Expected ] after index');
+                expr = {
+                    type: 'IndexExpression',
+                    object: expr,
+                    index,
+                    line: this.previous().line,
+                };
+            }
+            else if (this.match('DOT')) {
+                const property = this.consume('IDENTIFIER', 'Expected property name').lexeme;
+                expr = {
+                    type: 'MemberExpression',
+                    object: expr,
+                    property,
+                    line: this.previous().line,
+                };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    finishCall(callee) {
+        const args = [];
+        if (!this.check('RIGHT_PAREN')) {
+            do {
+                this.skipNewlines();
+                args.push(this.assignment());
+                this.skipNewlines();
+                this.match('COMMA');
+                this.skipNewlines();
+            } while (!this.check('RIGHT_PAREN') && !this.isAtEnd());
+        }
+        this.consume('RIGHT_PAREN', 'Expected ) after arguments');
+        return {
+            type: 'CallExpression',
+            callee,
+            arguments: args,
+            line: this.previous().line,
+        };
+    }
+    primary() {
+        if (this.match('TRUE')) {
+            return {
+                type: 'Literal',
+                value: true,
+                rawType: 'bool',
+                line: this.previous().line,
+            };
+        }
+        if (this.match('FALSE')) {
+            return {
+                type: 'Literal',
+                value: false,
+                rawType: 'bool',
+                line: this.previous().line,
+            };
+        }
+        if (this.match('NULL')) {
+            return {
+                type: 'Literal',
+                value: null,
+                rawType: 'null',
+                line: this.previous().line,
+            };
+        }
+        if (this.match('NUMBER')) {
+            return {
+                type: 'Literal',
+                value: this.previous().literal,
+                rawType: 'number',
+                line: this.previous().line,
+            };
+        }
+        if (this.match('STRING')) {
+            return {
+                type: 'Literal',
+                value: this.previous().literal,
+                rawType: 'string',
+                line: this.previous().line,
+            };
+        }
+        if (this.match('LEFT_BRACKET')) {
+            return this.arrayLiteral();
+        }
+        if (this.match('LEFT_BRACE')) {
+            return this.objectLiteral();
+        }
+        if (this.match('PRINT')) {
+            const args = [];
+            let hasParens = false;
+            if (this.match('LEFT_PAREN')) {
+                hasParens = true;
+            }
+            if (hasParens) {
+                if (!this.check('RIGHT_PAREN')) {
+                    do {
+                        args.push(this.assignment());
+                    } while (this.match('COMMA'));
+                }
+                this.consume('RIGHT_PAREN', 'Expected ) after print arguments');
+            }
+            else {
+                // Without parens, allow multiple expressions separated by commas or spaces (on the same line)
+                do {
+                    args.push(this.assignment());
+                    // Optional comma
+                    this.match('COMMA');
+                } while (!this.check('SEMICOLON') && !this.check('NEWLINE') && !this.check('RIGHT_BRACE') && !this.isAtEnd());
+            }
+            return {
+                type: 'CallExpression',
+                callee: {
+                    type: 'Identifier',
+                    name: 'print',
+                    line: this.previous().line,
+                },
+                arguments: args,
+                line: this.previous().line,
+            };
+        }
+        if (this.match('PROMPT')) {
+            return this.promptExpression();
+        }
+        if (this.match('MODEL')) {
+            return this.modelCall();
+        }
+        if (this.match('IMAGE')) {
+            return this.imageCall();
+        }
+        if (this.match('STRUCTURED_OUTPUT')) {
+            return this.structuredOutput();
+        }
+        if (this.match('TOOL_CALL')) {
+            return this.toolCall();
+        }
+        if (this.match('IDENTIFIER')) {
+            return {
+                type: 'Identifier',
+                name: this.previous().lexeme,
+                line: this.previous().line,
+            };
+        }
+        if (this.match('LEFT_PAREN')) {
+            const expr = this.expression();
+            this.consume('RIGHT_PAREN', 'Expected ) after expression');
+            return expr;
+        }
+        throw new Error(`Unexpected token: ${this.peek().lexeme} at line ${this.peek().line}`);
+    }
+    arrayLiteral() {
+        const line = this.previous().line;
+        const elements = [];
+        if (!this.check('RIGHT_BRACKET')) {
+            do {
+                elements.push(this.assignment());
+            } while (this.match('COMMA'));
+        }
+        this.consume('RIGHT_BRACKET', 'Expected ] after array elements');
+        return {
+            type: 'ArrayLiteral',
+            elements,
+            line,
+        };
+    }
+    objectLiteral() {
+        const line = this.previous().line;
+        const properties = [];
+        if (!this.check('RIGHT_BRACE')) {
+            do {
+                const key = this.consume('STRING', 'Expected string key').literal;
+                this.consume('COLON', 'Expected : after object key');
+                const value = this.assignment();
+                properties.push({ key: key, value });
+            } while (this.match('COMMA'));
+        }
+        this.consume('RIGHT_BRACE', 'Expected } after object properties');
+        return {
+            type: 'ObjectLiteral',
+            properties,
+            line,
+        };
+    }
+    promptExpression() {
+        const line = this.previous().line;
+        const name = this.consume('IDENTIFIER', 'Expected prompt name').lexeme;
+        this.consume('LEFT_BRACE', 'Expected { after prompt name');
+        const content = [];
+        while (!this.check('RIGHT_BRACE') && !this.isAtEnd()) {
+            if (this.check('STRING')) {
+                this.advance();
+                content.push({
+                    type: 'Literal',
+                    value: this.previous().literal,
+                    rawType: 'string',
+                    line: this.previous().line,
+                });
+            }
+            else {
+                content.push(this.expression());
+            }
+        }
+        this.consume('RIGHT_BRACE', 'Expected } after prompt content');
+        return {
+            type: 'PromptExpression',
+            name,
+            content,
+            line,
+        };
+    }
+    imageCall() {
+        const line = this.previous().line;
+        this.consume('LEFT_PAREN', 'Expected ( after image');
+        const modelName = this.consume('STRING', 'Expected image model name').literal;
+        this.consume('RIGHT_PAREN', 'Expected ) after image model name');
+        let config;
+        this.skipNewlines();
+        let hasConfig = false;
+        if (this.check('LEFT_BRACE')) {
+            const insideToken = this.tokens[this.current + 1];
+            if (insideToken.type === 'RIGHT_BRACE' && this.current + 2 < this.tokens.length && this.tokens[this.current + 2].type === 'LEFT_BRACE') {
+                hasConfig = true;
+            }
+            else if (insideToken.type === 'STRING' || insideToken.type === 'IDENTIFIER') {
+                if (this.current + 2 < this.tokens.length && this.tokens[this.current + 2].type === 'COLON') {
+                    hasConfig = true;
+                }
+            }
+        }
+        if (hasConfig) {
+            this.advance(); // consume LEFT_BRACE
+            config = {};
+            if (!this.check('RIGHT_BRACE')) {
+                do {
+                    let key;
+                    if (this.check('STRING')) {
+                        key = this.consume('STRING', '').literal;
+                    }
+                    else {
+                        key = this.consume('IDENTIFIER', 'Expected config key').lexeme;
+                    }
+                    this.consume('COLON', 'Expected : after config key');
+                    config[key] = this.assignment();
+                } while (this.match('COMMA'));
+            }
+            this.consume('RIGHT_BRACE', 'Expected } after config');
+        }
+        this.skipNewlines();
+        // Prompt or block
+        let prompt;
+        this.skipNewlines();
+        if (this.check('LEFT_BRACE')) {
+            this.advance();
+            const content = [];
+            while (!this.check('RIGHT_BRACE') && !this.isAtEnd()) {
+                if (this.check('STRING')) {
+                    this.advance();
+                    content.push({
+                        type: 'Literal',
+                        value: this.previous().literal,
+                        rawType: 'string',
+                        line: this.previous().line,
+                    });
+                }
+                else {
+                    content.push(this.expression());
+                }
+            }
+            this.consume('RIGHT_BRACE', 'Expected }');
+            if (content.length === 1) {
+                prompt = content[0];
+            }
+            else {
+                let result = content[0];
+                for (let i = 1; i < content.length; i++) {
+                    result = {
+                        type: 'BinaryOp',
+                        left: result,
+                        operator: '+',
+                        right: content[i],
+                        line,
+                    };
+                }
+                prompt = result;
+            }
+        }
+        else {
+            throw new Error('Expected prompt block after image call');
+        }
+        return {
+            type: 'ImageCallExpression',
+            modelName: modelName,
+            config,
+            prompt,
+            line,
+        };
+    }
+    modelCall() {
+        const line = this.previous().line;
+        this.consume('LEFT_PAREN', 'Expected ( after model');
+        const modelName = this.consume('STRING', 'Expected model name').literal;
+        this.consume('RIGHT_PAREN', 'Expected ) after model name');
+        let config;
+        this.skipNewlines();
+        let hasConfig = false;
+        if (this.check('LEFT_BRACE')) {
+            const insideToken = this.tokens[this.current + 1];
+            if (insideToken.type === 'RIGHT_BRACE' && this.current + 2 < this.tokens.length && this.tokens[this.current + 2].type === 'LEFT_BRACE') {
+                hasConfig = true;
+            }
+            else if (insideToken.type === 'STRING' || insideToken.type === 'IDENTIFIER') {
+                if (this.current + 2 < this.tokens.length && this.tokens[this.current + 2].type === 'COLON') {
+                    hasConfig = true;
+                }
+            }
+        }
+        if (hasConfig) {
+            this.advance(); // consume LEFT_BRACE
+            config = {};
+            if (!this.check('RIGHT_BRACE')) {
+                do {
+                    let key;
+                    if (this.check('STRING')) {
+                        key = this.consume('STRING', '').literal;
+                    }
+                    else {
+                        key = this.consume('IDENTIFIER', 'Expected config key').lexeme;
+                    }
+                    this.consume('COLON', 'Expected : after config key');
+                    config[key] = this.assignment();
+                } while (this.match('COMMA'));
+            }
+            this.consume('RIGHT_BRACE', 'Expected } after config');
+        }
+        this.skipNewlines();
+        // Prompt or block
+        let prompt;
+        this.skipNewlines();
+        if (this.check('LEFT_BRACE')) {
+            this.advance();
+            const content = [];
+            while (!this.check('RIGHT_BRACE') && !this.isAtEnd()) {
+                if (this.check('STRING')) {
+                    this.advance();
+                    content.push({
+                        type: 'Literal',
+                        value: this.previous().literal,
+                        rawType: 'string',
+                        line: this.previous().line,
+                    });
+                }
+                else {
+                    content.push(this.expression());
+                }
+            }
+            this.consume('RIGHT_BRACE', 'Expected }');
+            if (content.length === 1) {
+                prompt = content[0];
+            }
+            else {
+                let result = content[0];
+                for (let i = 1; i < content.length; i++) {
+                    result = {
+                        type: 'BinaryOp',
+                        left: result,
+                        operator: '+',
+                        right: content[i],
+                        line,
+                    };
+                }
+                prompt = result;
+            }
+        }
+        else {
+            throw new Error('Expected prompt block after model call');
+        }
+        return {
+            type: 'ModelCallExpression',
+            modelName: modelName,
+            config,
+            prompt,
+            line,
+        };
+    }
+    structuredOutput() {
+        const line = this.previous().line;
+        this.consume('LEFT_PAREN', 'Expected ( after structured_output');
+        this.consume('LEFT_BRACE', 'Expected { for schema');
+        const schema = {};
+        if (!this.check('RIGHT_BRACE')) {
+            do {
+                const key = this.consume('IDENTIFIER', 'Expected field name').lexeme;
+                this.consume('COLON', 'Expected : after field name');
+                schema[key] = this.typeAnnotation();
+            } while (this.match('COMMA'));
+        }
+        this.consume('RIGHT_BRACE', 'Expected } after schema');
+        this.consume('RIGHT_PAREN', 'Expected ) after schema');
+        this.skipNewlines();
+        this.consume('LEFT_PAREN', 'Expected ( for model call');
+        this.skipNewlines();
+        this.consume('MODEL', 'Expected model expression in structured_output');
+        const modelCall = this.modelCall();
+        this.consume('RIGHT_PAREN', 'Expected ) after model call');
+        return {
+            type: 'StructuredOutputExpression',
+            schema,
+            modelCall,
+            line,
+        };
+    }
+    toolCall() {
+        const line = this.previous().line;
+        this.consume('LEFT_PAREN', 'Expected ( after tool_call');
+        const functionName = this.consume('IDENTIFIER', 'Expected function name').lexeme;
+        this.consume('RIGHT_PAREN', 'Expected ) after function name');
+        this.consume('LEFT_PAREN', 'Expected ( for arguments');
+        const args = [];
+        if (!this.check('RIGHT_PAREN')) {
+            do {
+                args.push(this.assignment());
+            } while (this.match('COMMA'));
+        }
+        this.consume('RIGHT_PAREN', 'Expected ) after arguments');
+        return {
+            type: 'ToolCallExpression',
+            functionName,
+            arguments: args,
+            line,
+        };
+    }
+    typeAnnotation() {
+        if (this.check('IDENTIFIER')) {
+            const name = this.advance().lexeme;
+            switch (name) {
+                case 'number':
+                case 'string':
+                case 'bool':
+                case 'null': {
+                    let type = {
+                        type: 'PrimitiveType',
+                        name: name,
+                    };
+                    if (this.match('QUESTION')) {
+                        type = {
+                            type: 'OptionalType',
+                            baseType: type,
+                        };
+                    }
+                    return type;
+                }
+                case 'array':
+                    if (this.match('LESS')) {
+                        const elementType = this.typeAnnotation();
+                        this.consume('GREATER', 'Expected > in array type');
+                        return {
+                            type: 'ArrayType',
+                            elementType,
+                        };
+                    }
+                    return { type: 'PrimitiveType', name: 'any' };
+                case 'object':
+                    if (this.match('LESS')) {
+                        const valueType = this.typeAnnotation();
+                        this.consume('GREATER', 'Expected > in object type');
+                        return {
+                            type: 'ObjectType',
+                            valueType,
+                        };
+                    }
+                    return { type: 'PrimitiveType', name: 'any' };
+                default:
+                    throw new Error(`Unknown type: ${name}`);
+            }
+        }
+        throw new Error('Expected type annotation');
+    }
+    skipNewlines() {
+        while (this.match('NEWLINE'))
+            ;
+    }
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
+    }
+    isAtEnd() {
+        return this.peek().type === 'EOF';
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    consume(type, message) {
+        if (this.check(type))
+            return this.advance();
+        throw new Error(`${message} at line ${this.peek().line}, got ${this.peek().type}`);
+    }
+    consumeStatementEnd() {
+        if (this.match('SEMICOLON') || this.match('NEWLINE'))
+            return;
+        if (this.check('RIGHT_BRACE') || this.isAtEnd())
+            return;
+        // Allow implicit end of statement after a block-ending expression
+        if (this.previous().type === 'RIGHT_BRACE')
+            return;
+        throw new Error(`Expected end of statement, got ${this.peek().lexeme}`);
+    }
+    synchronize() {
+        this.advance();
+        const syncTokens = ['FN', 'LET', 'CONST', 'FOR', 'IF', 'WHILE', 'RETURN'];
+        while (!this.isAtEnd()) {
+            if (syncTokens.includes(this.peek().type)) {
+                return;
+            }
+            this.advance();
+        }
+    }
+    checkNext(type) {
+        if (this.current + 1 >= this.tokens.length)
+            return false;
+        return this.tokens[this.current + 1].type === type;
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=parser.js.map