starlight-cli 1.0.20 → 1.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"

package/src/evaluator.js

@@ -4,7 +4,9 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const path = require('path');
 
-class ReturnValue { constructor(value) { this.value = value; } }
+class ReturnValue {
+  constructor(value) { this.value = value; }
+}
 class BreakSignal {}
 class ContinueSignal {}
 
@@ -47,27 +49,37 @@ class Evaluator {
 
   setupBuiltins() {
     this.global.define('len', arg => {
-      if (Array.isArray(arg) || typeof arg === 'string') return arg.length;
-      if (arg && typeof arg === 'object') return Object.keys(arg).length;
-      return 0;
+        if (Array.isArray(arg) || typeof arg === 'string') return arg.length;
+        if (arg && typeof arg === 'object') return Object.keys(arg).length;
+        return 0;
     });
 
     this.global.define('print', arg => { console.log(arg); return null; });
     this.global.define('type', arg => {
-      if (Array.isArray(arg)) return 'array';
-      return typeof arg;
+        if (Array.isArray(arg)) return 'array';
+        return typeof arg;
     });
     this.global.define('keys', arg => arg && typeof arg === 'object' ? Object.keys(arg) : []);
     this.global.define('values', arg => arg && typeof arg === 'object' ? Object.values(arg) : []);
 
-    this.global.define('ask', prompt => readlineSync.question(prompt + ' '));
-    this.global.define('num', arg => {
-      const n = Number(arg);
-      if (Number.isNaN(n)) throw new Error('Cannot convert value to number');
-      return n;
+    this.global.define('ask', prompt => {
+        const readlineSync = require('readline-sync');
+        return readlineSync.question(prompt + ' ');
     });
-    this.global.define('str', arg => String(arg));
-  }
+    this.global.define('num', arg => {
+    const n = Number(arg);
+    if (Number.isNaN(n)) {
+        throw new Error('Cannot convert value to number');
+    }
+    return n;
+});
+
+this.global.define('str', arg => {
+    return String(arg);
+});
+
+}
+
 
   evaluate(node, env = this.global) {
     switch (node.type) {
@@ -84,7 +96,6 @@ class Evaluator {
       case 'LogicalExpression': return this.evalLogical(node, env);
       case 'UnaryExpression': return this.evalUnary(node, env);
       case 'Literal': return node.value;
-      case 'TemplateLiteral': return this.evalTemplateLiteral(node, env);
       case 'Identifier': return env.get(node.name);
       case 'IfStatement': return this.evalIf(node, env);
       case 'WhileStatement': return this.evalWhile(node, env);
@@ -110,65 +121,72 @@ class Evaluator {
 
   evalProgram(node, env) {
     let result = null;
-    for (const stmt of node.body) result = this.evaluate(stmt, env);
+    for (const stmt of node.body) {
+      result = this.evaluate(stmt, env);
+    }
     return result;
   }
+evalImport(node, env) {
+  const spec = node.path;
+  let lib;
 
- evalTemplateLiteral(node, env) {
-  // node.parts is an array from parser: Literal or expression nodes
-  let result = '';
-  for (const part of node.parts) {
-    if (part.type === 'Literal') {
-      result += part.value;
-    } else {
-      const val = this.evaluate(part, env);
-      result += val != null ? val.toString() : '';
+  try {
+    const resolved = require.resolve(spec, {
+      paths: [process.cwd()]
+    });
+    lib = require(resolved);
+  } catch (e) {
+    const fullPath = path.isAbsolute(spec)
+      ? spec
+      : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Import not found: ${spec}`);
     }
-  }
-  return result;
-}
 
+    const code = fs.readFileSync(fullPath, 'utf-8');
+    const tokens = new Lexer(code).getTokens();
+    const ast = new Parser(tokens).parse();
+
+    const moduleEnv = new Environment(env);
+    this.evaluate(ast, moduleEnv);
 
-  evalImport(node, env) {
-    const spec = node.path;
-    let lib;
-    try {
-      const resolved = require.resolve(spec, { paths: [process.cwd()] });
-      lib = require(resolved);
-    } catch (e) {
-      const fullPath = path.isAbsolute(spec)
-        ? spec
-        : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
-
-      if (!fs.existsSync(fullPath)) throw new Error(`Import not found: ${spec}`);
-
-      const code = fs.readFileSync(fullPath, 'utf-8');
-      const tokens = new Lexer(code).getTokens();
-      const ast = new Parser(tokens).parse();
-      const moduleEnv = new Environment(env);
-      this.evaluate(ast, moduleEnv);
-
-      lib = {};
-      for (const key of Object.keys(moduleEnv.store)) lib[key] = moduleEnv.store[key];
-      lib.default = lib;
+    lib = {};
+    for (const key of Object.keys(moduleEnv.store)) {
+      lib[key] = moduleEnv.store[key];
     }
 
-    for (const imp of node.specifiers) {
-      if (imp.type === 'DefaultImport') env.define(imp.local, lib.default ?? lib);
-      if (imp.type === 'NamespaceImport') env.define(imp.local, lib);
-      if (imp.type === 'NamedImport') {
-        if (!(imp.imported in lib)) throw new Error(`Module '${spec}' has no export '${imp.imported}'`);
-        env.define(imp.local, lib[imp.imported]);
+    lib.default = lib;
+  }
+
+  for (const imp of node.specifiers) {
+    if (imp.type === 'DefaultImport') {
+      env.define(imp.local, lib.default ?? lib);
+    }
+    if (imp.type === 'NamespaceImport') {
+      env.define(imp.local, lib);
+    }
+    if (imp.type === 'NamedImport') {
+      if (!(imp.imported in lib)) {
+        throw new Error(`Module '${spec}' has no export '${imp.imported}'`);
       }
+      env.define(imp.local, lib[imp.imported]);
     }
-    return null;
   }
 
+  return null;
+}
+
+
   evalBlock(node, env) {
     let result = null;
     for (const stmt of node.body) {
-      try { result = this.evaluate(stmt, env); }
-      catch (e) { if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e; else throw e; }
+      try {
+        result = this.evaluate(stmt, env);
+      } catch (e) {
+        if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
+        throw e;
+      }
     }
     return result;
   }
@@ -181,15 +199,27 @@ class Evaluator {
   evalAssignment(node, env) {
     const rightVal = this.evaluate(node.right, env);
     const left = node.left;
+
     if (left.type === 'Identifier') return env.set(left.name, rightVal);
-    if (left.type === 'MemberExpression') { const obj = this.evaluate(left.object, env); obj[left.property] = rightVal; return rightVal; }
-    if (left.type === 'IndexExpression') { const obj = this.evaluate(left.object, env); const idx = this.evaluate(left.indexer, env); obj[idx] = rightVal; return rightVal; }
+    if (left.type === 'MemberExpression') {
+      const obj = this.evaluate(left.object, env);
+      obj[left.property] = rightVal;
+      return rightVal;
+    }
+    if (left.type === 'IndexExpression') {
+      const obj = this.evaluate(left.object, env);
+      const idx = this.evaluate(left.indexer, env);
+      obj[idx] = rightVal;
+      return rightVal;
+    }
+
     throw new Error('Invalid assignment target');
   }
 
   evalCompoundAssignment(node, env) {
     const left = node.left;
     let current;
+
     if (left.type === 'Identifier') current = env.get(left.name);
     else if (left.type === 'MemberExpression') current = this.evalMember(left, env);
     else if (left.type === 'IndexExpression') current = this.evalIndex(left, env);
@@ -207,7 +237,9 @@ class Evaluator {
     }
 
     if (left.type === 'Identifier') env.set(left.name, computed);
+    else if (left.type === 'MemberExpression') this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
     else this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+
     return computed;
   }
 
@@ -219,7 +251,8 @@ class Evaluator {
 
   evalAsk(node, env) {
     const prompt = this.evaluate(node.prompt, env);
-    return readlineSync.question(prompt + ' ');
+    const input = readlineSync.question(prompt + ' ');
+    return input;
   }
 
   evalDefine(node, env) {
@@ -236,16 +269,12 @@ class Evaluator {
       case 'STAR': return l * r;
       case 'SLASH': return l / r;
       case 'MOD': return l % r;
-      case 'EQEQ': return l == r;
-      case 'NOTEQ': return l != r;
-      case 'STRICT_EQ': return l === r;
-      case 'STRICT_NOTEQ': return l !== r;
+      case 'EQEQ': return l === r;
+      case 'NOTEQ': return l !== r;
       case 'LT': return l < r;
       case 'LTE': return l <= r;
       case 'GT': return l > r;
       case 'GTE': return l >= r;
-      case 'LSHIFT': return l << r;
-      case 'RSHIFT': return l >> r;
       default: throw new Error(`Unknown binary operator ${node.operator}`);
     }
   }
@@ -313,7 +342,9 @@ class Evaluator {
       const args = node.arguments.map(a => this.evaluate(a, env));
       return calleeEvaluated(...args);
     }
-    if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) throw new Error('Call to non-function');
+    if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
+      throw new Error('Call to non-function');
+    }
     const fn = calleeEvaluated;
     const callEnv = new Environment(fn.env);
     fn.params.forEach((p, i) => {
@@ -353,8 +384,15 @@ class Evaluator {
     };
     const setValue = (v) => {
       if (arg.type === 'Identifier') env.set(arg.name, v);
-      else if (arg.type === 'MemberExpression') { const obj = this.evaluate(arg.object, env); obj[arg.property] = v; }
-      else if (arg.type === 'IndexExpression') { const obj = this.evaluate(arg.object, env); const idx = this.evaluate(arg.indexer, env); obj[idx] = v; }
+      else if (arg.type === 'MemberExpression') {
+        const obj = this.evaluate(arg.object, env);
+        obj[arg.property] = v;
+      }
+      else if (arg.type === 'IndexExpression') {
+        const obj = this.evaluate(arg.object, env);
+        const idx = this.evaluate(arg.indexer, env);
+        obj[idx] = v;
+      }
     };
     const current = getCurrent();
     const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
@@ -363,4 +401,4 @@ class Evaluator {
   }
 }
 
-module.exports = Evaluator;
+module.exports = Evaluator; 

package/src/lexer.js

@@ -3,19 +3,27 @@ class Lexer {
     this.input = input;
     this.pos = 0;
     this.currentChar = input[0] || null;
+    this.line = 1;     // current line
+    this.column = 1;   // current column
   }
 
   advance() {
+    if (this.currentChar === '\n') {
+      this.line++;
+      this.column = 0;
+    } else {
+      this.column++;
+    }
     this.pos++;
     this.currentChar = this.pos < this.input.length ? this.input[this.pos] : null;
   }
 
-  peek(n = 1) {
-    return this.pos + n < this.input.length ? this.input[this.pos + n] : null;
+  peek() {
+    return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
   }
 
   error(msg) {
-    throw new Error(`LEXER ERROR: ${msg} at position ${this.pos}`);
+    throw new Error(`${msg} at line ${this.line}, column ${this.column}`);
   }
 
   skipWhitespace() {
@@ -25,7 +33,7 @@ class Lexer {
   skipComment() {
     if (this.currentChar === '#') {
       if (this.peek() === '*') {
-        this.advance(); this.advance(); // #*
+        this.advance(); this.advance(); // skip #*
         while (this.currentChar !== null) {
           if (this.currentChar === '*' && this.peek() === '#') {
             this.advance(); this.advance();
@@ -33,7 +41,7 @@ class Lexer {
           }
           this.advance();
         }
-        this.error('Unterminated multi-line comment (#* ... *#)');
+        this.error("Unterminated multi-line comment (#* ... *#)");
       } else {
         while (this.currentChar && this.currentChar !== '\n') this.advance();
       }
@@ -41,6 +49,8 @@ class Lexer {
   }
 
   number() {
+    const startLine = this.line;
+    const startCol = this.column;
     let result = '';
     while (this.currentChar && /[0-9]/.test(this.currentChar)) {
       result += this.currentChar;
@@ -48,32 +58,20 @@ class Lexer {
     }
 
     if (this.currentChar === '.' && /[0-9]/.test(this.peek())) {
-      result += '.';
-      this.advance();
+      result += '.'; this.advance();
       while (this.currentChar && /[0-9]/.test(this.currentChar)) {
         result += this.currentChar;
         this.advance();
       }
+      return { type: 'NUMBER', value: parseFloat(result), line: startLine, column: startCol };
     }
 
-    if (this.currentChar && /[eE]/.test(this.currentChar)) {
-      result += this.currentChar;
-      this.advance();
-      if (this.currentChar === '+' || this.currentChar === '-') {
-        result += this.currentChar;
-        this.advance();
-      }
-      if (!/[0-9]/.test(this.currentChar)) this.error('Invalid exponent in number');
-      while (this.currentChar && /[0-9]/.test(this.currentChar)) {
-        result += this.currentChar;
-        this.advance();
-      }
-    }
-
-    return { type: 'NUMBER', value: parseFloat(result) };
+    return { type: 'NUMBER', value: parseInt(result), line: startLine, column: startCol };
   }
 
   identifier() {
+    const startLine = this.line;
+    const startCol = this.column;
     let result = '';
     while (this.currentChar && /[A-Za-z0-9_]/.test(this.currentChar)) {
       result += this.currentChar;
@@ -82,19 +80,20 @@ class Lexer {
 
     const keywords = [
       'let', 'sldeploy', 'if', 'else', 'while', 'for',
-      'break', 'continue', 'func', 'return',
-      'true', 'false', 'null', 'undefined',
+      'break', 'continue', 'func', 'return', 'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as'
     ];
 
     if (keywords.includes(result)) {
-      return { type: result.toUpperCase(), value: result };
+      return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };
     }
 
-    return { type: 'IDENTIFIER', value: result };
+    return { type: 'IDENTIFIER', value: result, line: startLine, column: startCol };
   }
 
   string() {
+    const startLine = this.line;
+    const startCol = this.column;
     const quote = this.currentChar;
     this.advance();
     let result = '';
@@ -102,58 +101,26 @@ class Lexer {
     while (this.currentChar && this.currentChar !== quote) {
       if (this.currentChar === '\\') {
         this.advance();
-        const map = { n: '\n', t: '\t', '"': '"', "'": "'", '\\': '\\' };
-        result += map[this.currentChar] ?? this.currentChar;
+        switch (this.currentChar) {
+          case 'n': result += '\n'; break;
+          case 't': result += '\t'; break;
+          case '"': result += '"'; break;
+          case "'": result += "'"; break;
+          case '\\': result += '\\'; break;
+          default: result += this.currentChar;
+        }
       } else {
         result += this.currentChar;
       }
       this.advance();
     }
 
-    if (this.currentChar !== quote) this.error('Unterminated string literal');
-
-    this.advance();
-    return { type: 'STRING', value: result };
-  }
-
-
-  templateString(tokens) {
-    this.advance(); // skip opening `
-
-    let buffer = '';
-
-    while (this.currentChar !== null) {
-      if (this.currentChar === '`') {
-        if (buffer.length > 0) {
-          tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
-        }
-        this.advance();
-        return;
-      }
-
-      if (this.currentChar === '$' && this.peek() === '{') {
-        if (buffer.length > 0) {
-          tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
-          buffer = '';
-        }
-        this.advance(); // $
-        this.advance(); // {
-        tokens.push({ type: 'DOLLAR_LBRACE' });
-        return;
-      }
-
-      if (this.currentChar === '\\') {
-        this.advance();
-        buffer += this.currentChar;
-        this.advance();
-        continue;
-      }
-
-      buffer += this.currentChar;
-      this.advance();
+    if (this.currentChar !== quote) {
+      this.error('Unterminated string literal');
     }
 
-    this.error('Unterminated template string');
+    this.advance();
+    return { type: 'STRING', value: result, line: startLine, column: startCol };
   }
 
   getTokens() {
@@ -166,56 +133,38 @@ class Lexer {
       if (/[A-Za-z_]/.test(this.currentChar)) { tokens.push(this.identifier()); continue; }
       if (this.currentChar === '"' || this.currentChar === "'") { tokens.push(this.string()); continue; }
 
-      if (this.currentChar === '`') {
-        this.templateString(tokens);
-        continue;
-      }
-
       const char = this.currentChar;
       const next = this.peek();
-      const next2 = this.peek(2);
-
-      if (char === '=' && next === '=' && next2 === '=') { tokens.push({ type: 'STRICT_EQ' }); this.advance(); this.advance(); this.advance(); continue; }
-      if (char === '!' && next === '=' && next2 === '=') { tokens.push({ type: 'STRICT_NOTEQ' }); this.advance(); this.advance(); this.advance(); continue; }
-      if (char === '=' && next === '=') { tokens.push({ type: 'EQEQ' }); this.advance(); this.advance(); continue; }
-      if (char === '=' && next === '>') { tokens.push({ type: 'ARROW' }); this.advance(); this.advance(); continue; }
-      if (char === '!' && next === '=') { tokens.push({ type: 'NOTEQ' }); this.advance(); this.advance(); continue; }
-      if (char === '<' && next === '=') { tokens.push({ type: 'LTE' }); this.advance(); this.advance(); continue; }
-      if (char === '>' && next === '=') { tokens.push({ type: 'GTE' }); this.advance(); this.advance(); continue; }
-      if (char === '<' && next === '<') { tokens.push({ type: 'LSHIFT' }); this.advance(); this.advance(); continue; }
-      if (char === '>' && next === '>') { tokens.push({ type: 'RSHIFT' }); this.advance(); this.advance(); continue; }
-      if (char === '&' && next === '&') { tokens.push({ type: 'AND' }); this.advance(); this.advance(); continue; }
-      if (char === '|' && next === '|') { tokens.push({ type: 'OR' }); this.advance(); this.advance(); continue; }
-      if (char === '+' && next === '+') { tokens.push({ type: 'PLUSPLUS' }); this.advance(); this.advance(); continue; }
-      if (char === '-' && next === '-') { tokens.push({ type: 'MINUSMINUS' }); this.advance(); this.advance(); continue; }
-
-      const compound = { '+': 'PLUSEQ', '-': 'MINUSEQ', '*': 'STAREQ', '/': 'SLASHEQ', '%': 'MODEQ' };
-      if (next === '=' && compound[char]) {
-        tokens.push({ type: compound[char] });
-        this.advance(); this.advance();
-        continue;
-      }
+      const startLine = this.line;
+      const startCol = this.column;
+
+      if (char === '=' && next === '=') { tokens.push({ type: 'EQEQ', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '=' && next === '>') { tokens.push({ type: 'ARROW', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '!' && next === '=') { tokens.push({ type: 'NOTEQ', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '<' && next === '=') { tokens.push({ type: 'LTE', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '>' && next === '=') { tokens.push({ type: 'GTE', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '&' && next === '&') { tokens.push({ type: 'AND', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '|' && next === '|') { tokens.push({ type: 'OR', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '+' && next === '+') { tokens.push({ type: 'PLUSPLUS', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '-' && next === '-') { tokens.push({ type: 'MINUSMINUS', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+
+      const map = { '+': 'PLUSEQ', '-': 'MINUSEQ', '*': 'STAREQ', '/': 'SLASHEQ', '%': 'MODEQ' };
+      if (next === '=' && map[char]) { tokens.push({ type: map[char], line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
 
       const singles = {
         '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'MOD',
         '=': 'EQUAL', '<': 'LT', '>': 'GT', '!': 'NOT',
-        '(': 'LPAREN', ')': 'RPAREN',
-        '{': 'LBRACE', '}': 'RBRACE',
-        '[': 'LBRACKET', ']': 'RBRACKET',
-        ';': 'SEMICOLON', ',': 'COMMA',
+        '(': 'LPAREN', ')': 'RPAREN', '{': 'LBRACE', '}': 'RBRACE',
+        ';': 'SEMICOLON', ',': 'COMMA', '[': 'LBRACKET', ']': 'RBRACKET',
         ':': 'COLON', '.': 'DOT'
       };
 
-      if (singles[char]) {
-        tokens.push({ type: singles[char] });
-        this.advance();
-        continue;
-      }
+      if (singles[char]) { tokens.push({ type: singles[char], line: startLine, column: startCol }); this.advance(); continue; }
 
-      this.error(`Unexpected character: ${char}`);
+      this.error("Unexpected character: " + char);
     }
 
-    tokens.push({ type: 'EOF' });
+    tokens.push({ type: 'EOF', line: this.line, column: this.column });
     return tokens;
   }
 }