code-the-jewels 0.1.0

package/dist/lexer.d.ts

@@ -0,0 +1,18 @@
+import { Token } from './token';
+export declare class Lexer {
+    private source;
+    private pos;
+    private line;
+    private col;
+    constructor(source: string);
+    tokenize(): Token[];
+    private advance;
+    private peek;
+    private makeToken;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+    private readString;
+    private readNumber;
+    private readIdentifier;
+}

package/dist/lexer.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = void 0;
+const token_1 = require("./token");
+const diagnostics_1 = require("./diagnostics");
+class Lexer {
+    constructor(source) {
+        this.pos = 0;
+        this.line = 1;
+        this.col = 1;
+        this.source = source;
+    }
+    tokenize() {
+        const tokens = [];
+        while (this.pos < this.source.length) {
+            const ch = this.source[this.pos];
+            // Skip whitespace (not newlines)
+            if (ch === ' ' || ch === '\t' || ch === '\r') {
+                this.advance();
+                continue;
+            }
+            // Newlines
+            if (ch === '\n') {
+                this.advance();
+                this.line++;
+                this.col = 1;
+                continue;
+            }
+            // Line comments
+            if (ch === '/' && this.peek(1) === '/') {
+                while (this.pos < this.source.length && this.source[this.pos] !== '\n') {
+                    this.advance();
+                }
+                continue;
+            }
+            // Block comments
+            if (ch === '/' && this.peek(1) === '*') {
+                this.advance();
+                this.advance();
+                while (this.pos < this.source.length) {
+                    if (this.source[this.pos] === '*' && this.peek(1) === '/') {
+                        this.advance();
+                        this.advance();
+                        break;
+                    }
+                    if (this.source[this.pos] === '\n') {
+                        this.line++;
+                        this.col = 0;
+                    }
+                    this.advance();
+                }
+                continue;
+            }
+            // Strings
+            if (ch === '"' || ch === "'") {
+                tokens.push(this.readString(ch));
+                continue;
+            }
+            // Numbers
+            if (this.isDigit(ch)) {
+                tokens.push(this.readNumber());
+                continue;
+            }
+            // Identifiers / keywords
+            if (this.isAlpha(ch)) {
+                tokens.push(this.readIdentifier());
+                continue;
+            }
+            // Pipe operator |>
+            if (ch === '|' && this.peek(1) === '>') {
+                tokens.push(this.makeToken(token_1.TokenType.PIPE, '|>', 2));
+                continue;
+            }
+            // Two-char operators
+            if (ch === '=' && this.peek(1) === '=') {
+                tokens.push(this.makeToken(token_1.TokenType.EQ_EQ, '==', 2));
+                continue;
+            }
+            if (ch === '!' && this.peek(1) === '=') {
+                tokens.push(this.makeToken(token_1.TokenType.BANG_EQ, '!=', 2));
+                continue;
+            }
+            if (ch === '>' && this.peek(1) === '=') {
+                tokens.push(this.makeToken(token_1.TokenType.GT_EQ, '>=', 2));
+                continue;
+            }
+            if (ch === '<' && this.peek(1) === '=') {
+                tokens.push(this.makeToken(token_1.TokenType.LT_EQ, '<=', 2));
+                continue;
+            }
+            if (ch === '&' && this.peek(1) === '&') {
+                tokens.push(this.makeToken(token_1.TokenType.AND_AND, '&&', 2));
+                continue;
+            }
+            if (ch === '|' && this.peek(1) === '|') {
+                tokens.push(this.makeToken(token_1.TokenType.OR_OR, '||', 2));
+                continue;
+            }
+            // Single-char tokens
+            const singles = {
+                '+': token_1.TokenType.PLUS,
+                '-': token_1.TokenType.MINUS,
+                '*': token_1.TokenType.STAR,
+                '/': token_1.TokenType.SLASH,
+                '%': token_1.TokenType.PERCENT,
+                '>': token_1.TokenType.GT,
+                '<': token_1.TokenType.LT,
+                '!': token_1.TokenType.BANG,
+                '=': token_1.TokenType.ASSIGN,
+                '{': token_1.TokenType.LBRACE,
+                '}': token_1.TokenType.RBRACE,
+                '(': token_1.TokenType.LPAREN,
+                ')': token_1.TokenType.RPAREN,
+                '[': token_1.TokenType.LBRACKET,
+                ']': token_1.TokenType.RBRACKET,
+                ',': token_1.TokenType.COMMA,
+                ':': token_1.TokenType.COLON,
+                '.': token_1.TokenType.DOT,
+                ';': token_1.TokenType.SEMICOLON,
+            };
+            if (singles[ch]) {
+                tokens.push(this.makeToken(singles[ch], ch, 1));
+                continue;
+            }
+            throw new diagnostics_1.RTJError('SyntaxError', `unexpected character '${ch}'`, this.line, this.col);
+        }
+        tokens.push({ type: token_1.TokenType.EOF, value: '', line: this.line, column: this.col });
+        return tokens;
+    }
+    advance() {
+        this.pos++;
+        this.col++;
+    }
+    peek(offset) {
+        return this.source[this.pos + offset];
+    }
+    makeToken(type, value, length) {
+        const token = { type, value, line: this.line, column: this.col };
+        for (let i = 0; i < length; i++)
+            this.advance();
+        return token;
+    }
+    isDigit(ch) {
+        return ch >= '0' && ch <= '9';
+    }
+    isAlpha(ch) {
+        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
+    }
+    isAlphaNumeric(ch) {
+        return this.isAlpha(ch) || this.isDigit(ch);
+    }
+    readString(quote) {
+        const startCol = this.col;
+        this.advance(); // skip opening quote
+        let value = '';
+        while (this.pos < this.source.length && this.source[this.pos] !== quote) {
+            if (this.source[this.pos] === '\\') {
+                this.advance();
+                const esc = this.source[this.pos];
+                if (esc === 'n')
+                    value += '\n';
+                else if (esc === 't')
+                    value += '\t';
+                else if (esc === '\\')
+                    value += '\\';
+                else if (esc === quote)
+                    value += quote;
+                else
+                    value += '\\' + esc;
+            }
+            else {
+                value += this.source[this.pos];
+            }
+            this.advance();
+        }
+        if (this.pos >= this.source.length) {
+            throw new diagnostics_1.RTJError('SyntaxError', 'unterminated string', this.line, startCol);
+        }
+        this.advance(); // skip closing quote
+        return { type: token_1.TokenType.STRING, value, line: this.line, column: startCol };
+    }
+    readNumber() {
+        const startCol = this.col;
+        let value = '';
+        while (this.pos < this.source.length && this.isDigit(this.source[this.pos])) {
+            value += this.source[this.pos];
+            this.advance();
+        }
+        if (this.pos < this.source.length && this.source[this.pos] === '.' && this.peek(1) && this.isDigit(this.peek(1))) {
+            value += '.';
+            this.advance();
+            while (this.pos < this.source.length && this.isDigit(this.source[this.pos])) {
+                value += this.source[this.pos];
+                this.advance();
+            }
+        }
+        return { type: token_1.TokenType.NUMBER, value, line: this.line, column: startCol };
+    }
+    readIdentifier() {
+        const startCol = this.col;
+        let value = '';
+        while (this.pos < this.source.length && this.isAlphaNumeric(this.source[this.pos])) {
+            value += this.source[this.pos];
+            this.advance();
+        }
+        const type = token_1.KEYWORDS[value] || token_1.TokenType.IDENTIFIER;
+        return { type, value, line: this.line, column: startCol };
+    }
+}
+exports.Lexer = Lexer;

package/dist/parser.d.ts

@@ -0,0 +1,40 @@
+import { Token } from './token';
+import { Program } from './ast';
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    parse(): Program;
+    private parseStatement;
+    private parseVarDecl;
+    private parseFunctionDecl;
+    private parseReturnStmt;
+    private parseTalkStmt;
+    private parseIfStmt;
+    private parseLoopStmt;
+    private parseImportStmt;
+    private parseThrowStmt;
+    private parseBlock;
+    private parseExpressionStmt;
+    private parseExpression;
+    private parsePipeExpr;
+    private parseOr;
+    private parseAnd;
+    private parseEquality;
+    private parseComparison;
+    private parseAddition;
+    private parseMultiplication;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseDuoExpr;
+    private parsePipelineList;
+    private parseArrayLiteral;
+    private current;
+    private advance;
+    private expect;
+    private isKeywordUsableAsIdentifier;
+    private expectIdentifierOrKeyword;
+    private isAtEnd;
+    private skipSemicolons;
+}

package/dist/parser.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const token_1 = require("./token");
+const diagnostics_1 = require("./diagnostics");
+class Parser {
+    constructor(tokens) {
+        this.pos = 0;
+        this.tokens = tokens;
+    }
+    parse() {
+        const body = [];
+        while (!this.isAtEnd()) {
+            this.skipSemicolons();
+            if (!this.isAtEnd()) {
+                body.push(this.parseStatement());
+            }
+        }
+        return { type: 'Program', body };
+    }
+    parseStatement() {
+        const tok = this.current();
+        switch (tok.type) {
+            case token_1.TokenType.JEWEL: return this.parseVarDecl();
+            case token_1.TokenType.VERSE: return this.parseFunctionDecl();
+            case token_1.TokenType.SEND: return this.parseReturnStmt();
+            case token_1.TokenType.TALK: return this.parseTalkStmt();
+            case token_1.TokenType.IFWILD: return this.parseIfStmt();
+            case token_1.TokenType.RUN: return this.parseLoopStmt();
+            case token_1.TokenType.FEATURE: return this.parseImportStmt();
+            case token_1.TokenType.YANK: return this.parseThrowStmt();
+            case token_1.TokenType.LBRACE: return this.parseBlock();
+            default: return this.parseExpressionStmt();
+        }
+    }
+    parseVarDecl() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.JEWEL);
+        const name = this.expectIdentifierOrKeyword().value;
+        this.expect(token_1.TokenType.ASSIGN);
+        const init = this.parseExpression();
+        this.skipSemicolons();
+        return { type: 'VarDecl', name, init, loc };
+    }
+    parseFunctionDecl() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.VERSE);
+        const name = this.expect(token_1.TokenType.IDENTIFIER).value;
+        this.expect(token_1.TokenType.LPAREN);
+        const params = [];
+        if (this.current().type !== token_1.TokenType.RPAREN) {
+            params.push(this.expect(token_1.TokenType.IDENTIFIER).value);
+            while (this.current().type === token_1.TokenType.COMMA) {
+                this.advance();
+                params.push(this.expect(token_1.TokenType.IDENTIFIER).value);
+            }
+        }
+        this.expect(token_1.TokenType.RPAREN);
+        const body = this.parseBlock();
+        return { type: 'FunctionDecl', name, params, body, loc };
+    }
+    parseReturnStmt() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.SEND);
+        let value;
+        if (!this.isAtEnd() && this.current().type !== token_1.TokenType.RBRACE && this.current().type !== token_1.TokenType.SEMICOLON) {
+            value = this.parseExpression();
+        }
+        this.skipSemicolons();
+        return { type: 'ReturnStmt', value, loc };
+    }
+    parseTalkStmt() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.TALK);
+        const value = this.parseExpression();
+        this.skipSemicolons();
+        return { type: 'TalkStmt', value, loc };
+    }
+    parseIfStmt() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.IFWILD);
+        const condition = this.parseExpression();
+        const consequent = this.parseBlock();
+        let alternate;
+        if (this.current().type === token_1.TokenType.ELSEWILD) {
+            this.advance();
+            alternate = this.parseBlock();
+        }
+        return { type: 'IfStmt', condition, consequent, alternate, loc };
+    }
+    parseLoopStmt() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.RUN);
+        const variable = this.expect(token_1.TokenType.IDENTIFIER).value;
+        this.expect(token_1.TokenType.IN);
+        const iterable = this.parseExpression();
+        const body = this.parseBlock();
+        return { type: 'LoopStmt', variable, iterable, body, loc };
+    }
+    parseImportStmt() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.FEATURE);
+        const names = [];
+        names.push(this.expect(token_1.TokenType.IDENTIFIER).value);
+        while (this.current().type === token_1.TokenType.COMMA) {
+            this.advance();
+            names.push(this.expect(token_1.TokenType.IDENTIFIER).value);
+        }
+        this.expect(token_1.TokenType.FROM);
+        const source = this.expect(token_1.TokenType.STRING).value;
+        this.skipSemicolons();
+        return { type: 'ImportStmt', names, source, loc };
+    }
+    parseThrowStmt() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.YANK);
+        const value = this.parseExpression();
+        this.skipSemicolons();
+        return { type: 'ThrowStmt', value, loc };
+    }
+    parseBlock() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.LBRACE);
+        const body = [];
+        while (this.current().type !== token_1.TokenType.RBRACE && !this.isAtEnd()) {
+            this.skipSemicolons();
+            if (this.current().type !== token_1.TokenType.RBRACE) {
+                body.push(this.parseStatement());
+            }
+        }
+        this.expect(token_1.TokenType.RBRACE);
+        return { type: 'BlockStmt', body, loc };
+    }
+    parseExpressionStmt() {
+        const loc = { line: this.current().line, column: this.current().column };
+        const expr = this.parseExpression();
+        this.skipSemicolons();
+        return { type: 'ExpressionStmt', expr, loc };
+    }
+    parseExpression() {
+        return this.parsePipeExpr();
+    }
+    parsePipeExpr() {
+        let left = this.parseOr();
+        if (this.current().type === token_1.TokenType.PIPE) {
+            const loc = { line: this.current().line, column: this.current().column };
+            const steps = [left];
+            while (this.current().type === token_1.TokenType.PIPE) {
+                this.advance();
+                steps.push(this.parseOr());
+            }
+            return { type: 'PipeExpr', steps, loc };
+        }
+        return left;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.current().type === token_1.TokenType.OR_OR) {
+            const op = this.advance().value;
+            const right = this.parseAnd();
+            left = { type: 'BinaryExpr', op, left, right, loc: left.loc };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseEquality();
+        while (this.current().type === token_1.TokenType.AND_AND) {
+            const op = this.advance().value;
+            const right = this.parseEquality();
+            left = { type: 'BinaryExpr', op, left, right, loc: left.loc };
+        }
+        return left;
+    }
+    parseEquality() {
+        let left = this.parseComparison();
+        while (this.current().type === token_1.TokenType.EQ_EQ || this.current().type === token_1.TokenType.BANG_EQ) {
+            const op = this.advance().value;
+            const right = this.parseComparison();
+            left = { type: 'BinaryExpr', op, left, right, loc: left.loc };
+        }
+        return left;
+    }
+    parseComparison() {
+        let left = this.parseAddition();
+        while (this.current().type === token_1.TokenType.GT ||
+            this.current().type === token_1.TokenType.LT ||
+            this.current().type === token_1.TokenType.GT_EQ ||
+            this.current().type === token_1.TokenType.LT_EQ) {
+            const op = this.advance().value;
+            const right = this.parseAddition();
+            left = { type: 'BinaryExpr', op, left, right, loc: left.loc };
+        }
+        return left;
+    }
+    parseAddition() {
+        let left = this.parseMultiplication();
+        while (this.current().type === token_1.TokenType.PLUS || this.current().type === token_1.TokenType.MINUS) {
+            const op = this.advance().value;
+            const right = this.parseMultiplication();
+            left = { type: 'BinaryExpr', op, left, right, loc: left.loc };
+        }
+        return left;
+    }
+    parseMultiplication() {
+        let left = this.parseUnary();
+        while (this.current().type === token_1.TokenType.STAR ||
+            this.current().type === token_1.TokenType.SLASH ||
+            this.current().type === token_1.TokenType.PERCENT) {
+            const op = this.advance().value;
+            const right = this.parseUnary();
+            left = { type: 'BinaryExpr', op, left, right, loc: left.loc };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.current().type === token_1.TokenType.BANG || this.current().type === token_1.TokenType.MINUS) {
+            const loc = { line: this.current().line, column: this.current().column };
+            const op = this.advance().value;
+            const operand = this.parseUnary();
+            return { type: 'UnaryExpr', op, operand, loc };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.current().type === token_1.TokenType.LPAREN) {
+                this.advance();
+                const args = [];
+                if (this.current().type !== token_1.TokenType.RPAREN) {
+                    args.push(this.parseExpression());
+                    while (this.current().type === token_1.TokenType.COMMA) {
+                        this.advance();
+                        args.push(this.parseExpression());
+                    }
+                }
+                this.expect(token_1.TokenType.RPAREN);
+                expr = { type: 'CallExpr', callee: expr, args, loc: expr.loc };
+            }
+            else if (this.current().type === token_1.TokenType.DOT) {
+                this.advance();
+                const prop = this.expect(token_1.TokenType.IDENTIFIER);
+                expr = {
+                    type: 'MemberExpr',
+                    object: expr,
+                    property: { type: 'Identifier', name: prop.value, loc: { line: prop.line, column: prop.column } },
+                    computed: false,
+                    loc: expr.loc,
+                };
+            }
+            else if (this.current().type === token_1.TokenType.LBRACKET) {
+                this.advance();
+                const index = this.parseExpression();
+                this.expect(token_1.TokenType.RBRACKET);
+                expr = {
+                    type: 'MemberExpr',
+                    object: expr,
+                    property: index,
+                    computed: true,
+                    loc: expr.loc,
+                };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    parsePrimary() {
+        const tok = this.current();
+        // duo expression
+        if (tok.type === token_1.TokenType.DUO) {
+            return this.parseDuoExpr();
+        }
+        // Grouped expression
+        if (tok.type === token_1.TokenType.LPAREN) {
+            this.advance();
+            const expr = this.parseExpression();
+            this.expect(token_1.TokenType.RPAREN);
+            return expr;
+        }
+        // Array literal
+        if (tok.type === token_1.TokenType.LBRACKET) {
+            return this.parseArrayLiteral();
+        }
+        // Object literal (only when not ambiguous with block)
+        // Objects are parsed in specific contexts (e.g., after =)
+        // String
+        if (tok.type === token_1.TokenType.STRING) {
+            this.advance();
+            return { type: 'StringLiteral', value: tok.value, loc: { line: tok.line, column: tok.column } };
+        }
+        // Number
+        if (tok.type === token_1.TokenType.NUMBER) {
+            this.advance();
+            return { type: 'NumberLiteral', value: Number(tok.value), loc: { line: tok.line, column: tok.column } };
+        }
+        // Boolean
+        if (tok.type === token_1.TokenType.BOOLEAN) {
+            this.advance();
+            return { type: 'BooleanLiteral', value: tok.value === 'true', loc: { line: tok.line, column: tok.column } };
+        }
+        // Null
+        if (tok.type === token_1.TokenType.NULL) {
+            this.advance();
+            return { type: 'NullLiteral', loc: { line: tok.line, column: tok.column } };
+        }
+        // Identifier (including keywords used as variable names in expression context)
+        if (tok.type === token_1.TokenType.IDENTIFIER || this.isKeywordUsableAsIdentifier(tok.type)) {
+            this.advance();
+            return { type: 'Identifier', name: tok.value, loc: { line: tok.line, column: tok.column } };
+        }
+        throw new diagnostics_1.RTJError('SyntaxError', `unexpected token '${tok.value}'`, tok.line, tok.column);
+    }
+    parseDuoExpr() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.DUO);
+        this.expect(token_1.TokenType.LPAREN);
+        const input = this.parseExpression();
+        this.expect(token_1.TokenType.RPAREN);
+        this.expect(token_1.TokenType.LBRACE);
+        this.expect(token_1.TokenType.MIKE);
+        this.expect(token_1.TokenType.COLON);
+        const mikePipeline = this.parsePipelineList();
+        this.expect(token_1.TokenType.EL);
+        this.expect(token_1.TokenType.COLON);
+        const elPipeline = this.parsePipelineList();
+        this.expect(token_1.TokenType.RBRACE);
+        return { type: 'DuoExpr', input, mikePipeline, elPipeline, loc };
+    }
+    parsePipelineList() {
+        const steps = [];
+        steps.push(this.parsePostfix());
+        while (this.current().type === token_1.TokenType.PIPE) {
+            this.advance();
+            steps.push(this.parsePostfix());
+        }
+        return steps;
+    }
+    parseArrayLiteral() {
+        const loc = { line: this.current().line, column: this.current().column };
+        this.expect(token_1.TokenType.LBRACKET);
+        const elements = [];
+        if (this.current().type !== token_1.TokenType.RBRACKET) {
+            elements.push(this.parseExpression());
+            while (this.current().type === token_1.TokenType.COMMA) {
+                this.advance();
+                elements.push(this.parseExpression());
+            }
+        }
+        this.expect(token_1.TokenType.RBRACKET);
+        return { type: 'ArrayLiteral', elements, loc };
+    }
+    current() {
+        return this.tokens[this.pos] || { type: token_1.TokenType.EOF, value: '', line: 0, column: 0 };
+    }
+    advance() {
+        const tok = this.current();
+        this.pos++;
+        return tok;
+    }
+    expect(type) {
+        const tok = this.current();
+        if (tok.type !== type) {
+            throw new diagnostics_1.RTJError('SyntaxError', `beat slipped near line ${tok.line}, expected '${type}' but got '${tok.type}'`, tok.line, tok.column);
+        }
+        return this.advance();
+    }
+    isKeywordUsableAsIdentifier(type) {
+        // Keywords that can appear as variable names in expression contexts
+        return type === token_1.TokenType.VERSE || type === token_1.TokenType.JEWEL ||
+            type === token_1.TokenType.SEND || type === token_1.TokenType.TALK ||
+            type === token_1.TokenType.RUN || type === token_1.TokenType.IN ||
+            type === token_1.TokenType.FEATURE || type === token_1.TokenType.FROM ||
+            type === token_1.TokenType.YANK || type === token_1.TokenType.MIKE ||
+            type === token_1.TokenType.EL;
+    }
+    expectIdentifierOrKeyword() {
+        const tok = this.current();
+        if (tok.type === token_1.TokenType.IDENTIFIER || this.isKeywordUsableAsIdentifier(tok.type)) {
+            return this.advance();
+        }
+        throw new diagnostics_1.RTJError('SyntaxError', `beat slipped near line ${tok.line}, expected identifier but got '${tok.type}'`, tok.line, tok.column);
+    }
+    isAtEnd() {
+        return this.current().type === token_1.TokenType.EOF;
+    }
+    skipSemicolons() {
+        while (this.current().type === token_1.TokenType.SEMICOLON) {
+            this.advance();
+        }
+    }
+}
+exports.Parser = Parser;

package/dist/repl.d.ts

@@ -0,0 +1 @@
+export declare function startRepl(): void;