starlight-cli 1.0.3 → 1.0.5

package/src/parser.js

@@ -0,0 +1,441 @@
+class Parser {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.pos = 0;
+    this.current = this.tokens[this.pos];
+  }
+
+  advance() {
+    this.pos++;
+    this.current = this.pos < this.tokens.length ? this.tokens[this.pos] : { type: 'EOF' };
+  }
+
+  eat(type) {
+    if (this.current.type === type) this.advance();
+    else throw new Error(`Expected ${type}, got ${this.current.type}`);
+  }
+
+  peekType(offset = 1) {
+    return (this.tokens[this.pos + offset] || { type: 'EOF' }).type;
+  }
+
+  parse() {
+    const body = [];
+    while (this.current.type !== 'EOF') {
+      body.push(this.statement());
+    }
+    return { type: 'Program', body };
+  }
+
+  statement() {
+    switch (this.current.type) {
+      case 'LET': return this.varDeclaration();
+      case 'SLDEPLOY': return this.sldeployStatement();
+      case 'DEFINE': return this.defineStatement();
+      case 'IF': return this.ifStatement();
+      case 'WHILE': return this.whileStatement();
+      case 'FOR': return this.forStatement();
+      case 'BREAK': return this.breakStatement();
+      case 'CONTINUE': return this.continueStatement();
+      case 'FUNC': return this.funcDeclaration();
+      case 'RETURN': return this.returnStatement();
+      case 'IMPORT': return this.importStatement();
+      case 'LBRACE': return this.block();
+      default:
+        return this.expressionStatement();
+    }
+  }
+
+  varDeclaration() {
+    this.eat('LET');
+    const id = this.current.value;
+    this.eat('IDENTIFIER');
+    this.eat('EQUAL');
+    const expr = this.expression();
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+    return { type: 'VarDeclaration', id, expr };
+  }
+
+  sldeployStatement() {
+    this.eat('SLDEPLOY');
+    const expr = this.expression();
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+    return { type: 'SldeployStatement', expr };
+  }
+
+  defineStatement() {
+    this.eat('DEFINE');
+    const id = this.current.value;
+    this.eat('IDENTIFIER');
+    let expr = null;
+    if (this.current.type === 'EQUAL') {
+      this.eat('EQUAL');
+      expr = this.expression();
+    }
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+    return { type: 'DefineStatement', id, expr };
+  }
+
+  ifStatement() {
+    this.eat('IF');
+    this.eat('LPAREN');
+    const test = this.expression();
+    this.eat('RPAREN');
+    const consequent = this.block();
+    let alternate = null;
+    if (this.current.type === 'ELSE') {
+      this.eat('ELSE');
+      if (this.current.type === 'IF') alternate = this.ifStatement();
+      else alternate = this.block();
+    }
+    return { type: 'IfStatement', test, consequent, alternate };
+  }
+
+  whileStatement() {
+    this.eat('WHILE');
+    this.eat('LPAREN');
+    const test = this.expression();
+    this.eat('RPAREN');
+    const body = this.block();
+    return { type: 'WhileStatement', test, body };
+  }
+  importStatement() {
+    this.eat('IMPORT');
+
+    let specifiers = [];
+
+    if (this.current.type === 'STAR') {
+        this.eat('STAR');
+        this.eat('AS');
+        const name = this.current.value;
+        this.eat('IDENTIFIER');
+        specifiers.push({ type: 'NamespaceImport', local: name });
+    }
+    else if (this.current.type === 'LBRACE') {
+        this.eat('LBRACE');
+        while (this.current.type !== 'RBRACE') {
+            const importedName = this.current.value;
+            this.eat('IDENTIFIER');
+            let localName = importedName;
+            if (this.current.type === 'AS') {
+                this.eat('AS');
+                localName = this.current.value;
+                this.eat('IDENTIFIER');
+            }
+            specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
+            if (this.current.type === 'COMMA') this.eat('COMMA');
+        }
+        this.eat('RBRACE');
+    }
+    else if (this.current.type === 'IDENTIFIER') {
+        const localName = this.current.value;
+        this.eat('IDENTIFIER');
+        specifiers.push({ type: 'DefaultImport', local: localName });
+    } else {
+        throw new Error('Unexpected token in import statement');
+    }
+
+    this.eat('FROM');
+    const pathToken = this.current;
+    if (pathToken.type !== 'STRING') throw new Error('Expected string literal after from in import');
+    this.eat('STRING');
+
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+
+    return { type: 'ImportStatement', path: pathToken.value, specifiers };
+}
+
+
+  forStatement() {
+    this.eat('FOR');
+    this.eat('LPAREN');
+
+    let init = null;
+    if (this.current.type !== 'SEMICOLON') {
+      init = this.current.type === 'LET' ? this.varDeclaration() : this.expressionStatement();
+    } else {
+      this.eat('SEMICOLON');
+    }
+
+    let test = null;
+    if (this.current.type !== 'SEMICOLON') test = this.expression();
+    this.eat('SEMICOLON');
+
+    let update = null;
+    if (this.current.type !== 'RPAREN') update = this.expression();
+    this.eat('RPAREN');
+
+    const body = this.block();
+    return { type: 'ForStatement', init, test, update, body };
+  }
+
+  breakStatement() {
+    this.eat('BREAK');
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+    return { type: 'BreakStatement' };
+  }
+
+  continueStatement() {
+    this.eat('CONTINUE');
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+    return { type: 'ContinueStatement' };
+  }
+
+  funcDeclaration() {
+    this.eat('FUNC');
+    const name = this.current.value;
+    this.eat('IDENTIFIER');
+    this.eat('LPAREN');
+    const params = [];
+    if (this.current.type !== 'RPAREN') {
+      params.push(this.current.value);
+      this.eat('IDENTIFIER');
+      while (this.current.type === 'COMMA') {
+        this.eat('COMMA');
+        params.push(this.current.value);
+        this.eat('IDENTIFIER');
+      }
+    }
+    this.eat('RPAREN');
+    const body = this.block();
+    return { type: 'FunctionDeclaration', name, params, body };
+  }
+
+  returnStatement() {
+    this.eat('RETURN');
+    let argument = null;
+    if (this.current.type !== 'SEMICOLON') argument = this.expression();
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+    return { type: 'ReturnStatement', argument };
+  }
+
+  block() {
+    this.eat('LBRACE');
+    const body = [];
+    while (this.current.type !== 'RBRACE') {
+      body.push(this.statement());
+    }
+    this.eat('RBRACE');
+    return { type: 'BlockStatement', body };
+  }
+
+  expressionStatement() {
+    const expr = this.expression();
+    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+    return { type: 'ExpressionStatement', expression: expr };
+  }
+
+  expression() {
+    return this.assignment();
+  }
+
+  assignment() {
+    const node = this.logicalOr();
+    const compoundOps = ['PLUSEQ', 'MINUSEQ', 'STAREQ', 'SLASHEQ', 'MODEQ'];
+    if (compoundOps.includes(this.current.type)) {
+      const op = this.current.type;
+      this.eat(op);
+      const right = this.assignment();
+      return { type: 'CompoundAssignment', operator: op, left: node, right };
+    }
+
+    if (this.current.type === 'EQUAL') {
+      this.eat('EQUAL');
+      const right = this.assignment();
+      return { type: 'AssignmentExpression', left: node, right };
+    }
+
+    return node;
+  }
+
+  logicalOr() {
+    let node = this.logicalAnd();
+    while (this.current.type === 'OR') {
+      const op = this.current.type;
+      this.eat(op);
+      node = { type: 'LogicalExpression', operator: op, left: node, right: this.logicalAnd() };
+    }
+    return node;
+  }
+
+  logicalAnd() {
+    let node = this.equality();
+    while (this.current.type === 'AND') {
+      const op = this.current.type;
+      this.eat(op);
+      node = { type: 'LogicalExpression', operator: op, left: node, right: this.equality() };
+    }
+    return node;
+  }
+
+  equality() {
+    let node = this.comparison();
+    while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
+      const op = this.current.type;
+      this.eat(op);
+      node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
+    }
+    return node;
+  }
+
+  comparison() {
+    let node = this.term();
+    while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
+      const op = this.current.type;
+      this.eat(op);
+      node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
+    }
+    return node;
+  }
+
+  term() {
+    let node = this.factor();
+    while (['PLUS', 'MINUS'].includes(this.current.type)) {
+      const op = this.current.type;
+      this.eat(op);
+      node = { type: 'BinaryExpression', operator: op, left: node, right: this.factor() };
+    }
+    return node;
+  }
+
+  factor() {
+    let node = this.unary();
+    while (['STAR', 'SLASH', 'MOD'].includes(this.current.type)) {
+      const op = this.current.type;
+      this.eat(op);
+      node = { type: 'BinaryExpression', operator: op, left: node, right: this.unary() };
+    }
+    return node;
+  }
+
+  unary() {
+    if (['NOT', 'MINUS', 'PLUS'].includes(this.current.type)) {
+      const op = this.current.type;
+      this.eat(op);
+      return { type: 'UnaryExpression', operator: op, argument: this.unary() };
+    }
+    if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
+      const op = this.current.type;
+      this.eat(op);
+      const argument = this.unary();
+      return { type: 'UpdateExpression', operator: op, argument, prefix: true };
+    }
+    return this.postfix();
+  }
+
+  postfix() {
+    let node = this.primary();
+    while (true) {
+      if (this.current.type === 'LBRACKET') {
+        this.eat('LBRACKET');
+        const index = this.expression();
+        this.eat('RBRACKET');
+        node = { type: 'IndexExpression', object: node, indexer: index };
+        continue;
+      }
+      if (this.current.type === 'LPAREN') {
+        this.eat('LPAREN');
+        const args = [];
+        if (this.current.type !== 'RPAREN') {
+          args.push(this.expression());
+          while (this.current.type === 'COMMA') {
+            this.eat('COMMA');
+            args.push(this.expression());
+          }
+        }
+        this.eat('RPAREN');
+        node = { type: 'CallExpression', callee: node, arguments: args };
+        continue;
+      }
+      if (this.current.type === 'DOT') {
+        this.eat('DOT');
+        if (this.current.type !== 'IDENTIFIER') throw new Error('Expected property name after dot');
+        const property = this.current.value;
+        this.eat('IDENTIFIER');
+        node = { type: 'MemberExpression', object: node, property };
+        continue;
+      }
+      if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
+        const op = this.current.type;
+        this.eat(op);
+        node = { type: 'UpdateExpression', operator: op, argument: node, prefix: false };
+        continue;
+      }
+      break;
+    }
+    return node;
+  }
+
+  primary() {
+    const t = this.current;
+
+    if (t.type === 'NUMBER') { this.eat('NUMBER'); return { type: 'Literal', value: t.value }; }
+    if (t.type === 'STRING') { this.eat('STRING'); return { type: 'Literal', value: t.value }; }
+    if (t.type === 'TRUE') { this.eat('TRUE'); return { type: 'Literal', value: true }; }
+    if (t.type === 'FALSE') { this.eat('FALSE'); return { type: 'Literal', value: false }; }
+    if (t.type === 'NULL') { this.eat('NULL'); return { type: 'Literal', value: null }; }
+
+    if (t.type === 'ASK') {
+      this.eat('ASK');
+      this.eat('LPAREN');
+      const args = [];
+      if (this.current.type !== 'RPAREN') {
+        args.push(this.expression());
+        while (this.current.type === 'COMMA') {
+          this.eat('COMMA');
+          args.push(this.expression());
+        }
+      }
+      this.eat('RPAREN');
+      return { type: 'CallExpression', callee: { type: 'Identifier', name: 'ask' }, arguments: args };
+    }
+
+    if (t.type === 'IDENTIFIER') {
+      const name = t.value;
+      this.eat('IDENTIFIER');
+      return { type: 'Identifier', name };
+    }
+
+    if (t.type === 'LPAREN') {
+      this.eat('LPAREN');
+      const expr = this.expression();
+      this.eat('RPAREN');
+      return expr;
+    }
+
+    if (t.type === 'LBRACKET') {
+      this.eat('LBRACKET');
+      const elements = [];
+      if (this.current.type !== 'RBRACKET') {
+        elements.push(this.expression());
+        while (this.current.type === 'COMMA') {
+          this.eat('COMMA');
+          elements.push(this.expression());
+        }
+      }
+      this.eat('RBRACKET');
+      return { type: 'ArrayExpression', elements };
+    }
+
+    if (t.type === 'LBRACE') {
+      this.eat('LBRACE');
+      const props = [];
+      while (this.current.type !== 'RBRACE') {
+        let key;
+        if (this.current.type === 'STRING') { key = this.current.value; this.eat('STRING'); }
+        else if (this.current.type === 'IDENTIFIER') { key = this.current.value; this.eat('IDENTIFIER'); }
+        else throw new Error('Invalid object key');
+        this.eat('COLON');
+        const value = this.expression();
+        props.push({ key, value });
+        if (this.current.type === 'COMMA') this.eat('COMMA');
+      }
+      this.eat('RBRACE');
+      return { type: 'ObjectExpression', props };
+    }
+
+    throw new Error(`Unexpected token in primary: ${t.type}`);
+  }
+}
+
+module.exports = Parser; 

package/src/starlight.js

@@ -0,0 +1,117 @@
+const fs = require('fs');
+const path = require('path');
+
+const Lexer = require('./lexer');
+const Parser = require('./parser');
+const Evaluator = require('./evaluator');
+
+const COLOR = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    green: '\x1b[32m'
+};
+
+function waitAndExit(code = 1) {
+    console.error(COLOR.gray + '\nPress any key to exit...' + COLOR.reset);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.once('data', () => process.exit(code));
+}
+
+function fatal(msg) {
+    console.error(COLOR.red + msg + COLOR.reset);
+    return waitAndExit(1);
+}
+
+function printSourceContext(code, line, column) {
+    const lines = code.split('\n');
+    const srcLine = lines[line - 1];
+    if (!srcLine) return;
+
+    console.error(
+        COLOR.gray + `\n ${line} | ` + COLOR.reset + srcLine
+    );
+    console.error(
+        COLOR.gray + '    | ' +
+        COLOR.red + ' '.repeat(Math.max(0, column - 1)) + '^' +
+        COLOR.reset
+    );
+}
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+    return fatal('Usage: starlight <file.sl>');
+}
+
+const filePath = path.resolve(args[0]);
+
+if (!fs.existsSync(filePath)) {
+    return fatal(`File not found: ${filePath}`);
+}
+
+let code;
+try {
+    code = fs.readFileSync(filePath, 'utf-8');
+} catch (err) {
+    return fatal(`Failed to read file: ${err.message}`);
+}
+
+let tokens;
+try {
+    const lexer = new Lexer(code);
+    tokens = lexer.getTokens();
+} catch (err) {
+    console.error(COLOR.red + COLOR.bold + 'Starlight Lexer Error' + COLOR.reset);
+    console.error(COLOR.cyan + `File: ${filePath}` + COLOR.reset);
+    console.error(COLOR.yellow + `Message: ${err.message}` + COLOR.reset);
+
+    if (err.line && err.column) {
+        printSourceContext(code, err.line, err.column);
+    }
+
+    return waitAndExit(1);
+}
+
+let ast;
+try {
+    const parser = new Parser(tokens);
+    ast = parser.parse();
+} catch (err) {
+    console.error(COLOR.red + COLOR.bold + 'Starlight Parser Error' + COLOR.reset);
+    console.error(COLOR.cyan + `File: ${filePath}` + COLOR.reset);
+    console.error(COLOR.yellow + `Message: ${err.message}` + COLOR.reset);
+
+    if (err.token && err.token.line && err.token.column) {
+        printSourceContext(code, err.token.line, err.token.column);
+    }
+
+    return waitAndExit(1);
+}
+
+try {
+    const evaluator = new Evaluator();
+    evaluator.evaluate(ast);
+} catch (err) {
+    console.error(COLOR.red + COLOR.bold + 'Starlight Runtime Error' + COLOR.reset);
+    console.error(COLOR.cyan + `File: ${filePath}` + COLOR.reset);
+    console.error(COLOR.yellow + `Message: ${err.message}` + COLOR.reset);
+
+    if (err.line && err.column) {
+        printSourceContext(code, err.line, err.column);
+    }
+
+    return waitAndExit(1);
+}
+
+console.log(
+    COLOR.green +
+    '\nProgram finished successfully.' +
+    COLOR.reset
+);
+waitAndExit(0);

package/install.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const DOWNLOAD_URL =
-  'https://github.com/developerdominex/dominexmacedon/releases/download/programming/starlight.exe';
-
-const INSTALL_DIR = 'C:\\Starlight\\bin';
-const EXE_PATH = path.join(INSTALL_DIR, 'starlight.exe');
-
-// Ensure install directory exists
-fs.mkdirSync(INSTALL_DIR, { recursive: true });
-
-console.log('Downloading Starlight...');
-
-function download(url, dest) {
-  return new Promise((resolve, reject) => {
-    https.get(url, res => {
-      if ([301, 302].includes(res.statusCode)) {
-        return download(res.headers.location, dest).then(resolve).catch(reject);
-      }
-      if (res.statusCode !== 200) {
-        reject(new Error(`HTTP ${res.statusCode}`));
-        return;
-      }
-
-      const file = fs.createWriteStream(dest);
-      res.pipe(file);
-
-      file.on('finish', () => file.close(resolve));
-      file.on('error', err => {
-        fs.unlinkSync(dest);
-        reject(err);
-      });
-    }).on('error', reject);
-  });
-}
-
-(async () => {
-  try {
-    await download(DOWNLOAD_URL, EXE_PATH);
-    console.log(`Downloaded to: ${EXE_PATH}`);
-
-    // Add to PATH permanently
-    try {
-      execSync(`setx PATH "%PATH%;${INSTALL_DIR}"`, { stdio: 'ignore' });
-      console.log('PATH updated for future sessions.');
-    } catch {
-      console.warn('Could not update PATH permanently (may already exist or too long).');
-    }
-
-    // Add to PATH for current session
-    process.env.PATH = `${INSTALL_DIR};${process.env.PATH}`;
-    console.log('PATH updated for current session.');
-
-    console.log('Starlight installation completed successfully!');
-    process.exit(0);
-  } catch (err) {
-    console.error('Download or installation failed:', err.message);
-    process.exit(1);
-  }
-})();