starlight-cli 1.0.46 → 1.0.48

package/package.json

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

package/src/evaluator.js

@@ -9,6 +9,29 @@ class ReturnValue {
 }
 class BreakSignal {}
 class ContinueSignal {}
+class RuntimeError extends Error {
+    constructor(message, node, source) {
+        const line = node?.line ?? '?';
+        const column = node?.column ?? '?';
+
+        let output = ` ${message} at line ${line}, column ${column}\n`;
+
+        if (source && node?.line != null) {
+            const lines = source.split('\n');
+            const srcLine = lines[node.line - 1] || '';
+            output += `  ${srcLine}\n`;
+            output += `  ${' '.repeat(column - 1)}^\n`;
+        }
+
+        super(output);
+
+        this.name = 'RuntimeError';
+        this.line = line;
+        this.column = column;
+    }
+}
+
+
 
 class Environment {
   constructor(parent = null) {
@@ -22,11 +45,11 @@ class Environment {
     return false;
   }
 
-  get(name) {
-    if (name in this.store) return this.store[name];
-    if (this.parent) return this.parent.get(name);
-    throw new Error(`Undefined variable: ${name}`);
-  }
+  get(name, node) {
+  if (name in this.store) return this.store[name];
+  if (this.parent) return this.parent.get(name, node);
+  throw new RuntimeError(`Undefined variable: ${name}`, node);
+}
 
   set(name, value) {
     if (name in this.store) { this.store[name] = value; return value; }
@@ -42,7 +65,8 @@ class Environment {
 }
 
 class Evaluator {
-  constructor() {
+  constructor(source = '') {
+    this.source = source;
     this.global = new Environment();
     this.setupBuiltins();
   }
@@ -129,11 +153,11 @@ this.global.define('range', (...args) => {
     end = Number(args[1]);
     step = Number(args[2]);
   } else {
-    throw new Error('range() expects 1 to 3 arguments');
+    throw new RuntimeError('range() expects 1 to 3 arguments', null, this.source);
   }
 
   if (step === 0) {
-    throw new Error('range() step cannot be 0');
+    throw new RuntimeError('range() step cannot be 0', null, this.source);
   }
 
   const result = [];
@@ -157,7 +181,7 @@ this.global.define('range', (...args) => {
     this.global.define('num', arg => {
     const n = Number(arg);
     if (Number.isNaN(n)) {
-        throw new Error('Cannot convert value to number');
+        throw new RuntimeError('Cannot convert value to number', null, this.source);
     }
     return n;
 });
@@ -210,7 +234,7 @@ async evaluate(node, env = this.global) {
     case 'LogicalExpression': return await this.evalLogical(node, env);
     case 'UnaryExpression': return await this.evalUnary(node, env);
     case 'Literal': return node.value;
-    case 'Identifier': return env.get(node.name);
+    case 'Identifier': return env.get(node.name, node);
     case 'IfStatement': return await this.evalIf(node, env);
     case 'WhileStatement': return await this.evalWhile(node, env);
     case 'ForStatement':
@@ -233,14 +257,8 @@ case 'DoTrackStatement':
     case 'ArrayExpression':
       return await Promise.all(node.elements.map(el => this.evaluate(el, env)));
     case 'IndexExpression': return await this.evalIndex(node, env);
-    case 'ObjectExpression': {
-  const out = {};
-  for (const p of node.props) {
-    const key = await this.evaluate(p.key, env);
-    out[key] = await this.evaluate(p.value, env);
-  }
-  return out;
-}
+    case 'ObjectExpression': return await this.evalObject(node, env);
+
 
     case 'MemberExpression': return await this.evalMember(node, env);
     case 'UpdateExpression': return await this.evalUpdate(node, env);
@@ -268,7 +286,7 @@ case 'DoTrackStatement':
   }
 
   if (typeof callee !== 'function') {
-    throw new Error('NewExpression callee is not a function');
+    throw new RuntimeError('NewExpression callee is not a function', node, this.source);
   }
 
   const args = [];
@@ -277,31 +295,51 @@ case 'DoTrackStatement':
 }
 
     default:
-      throw new Error(`Unknown node type in evaluator: ${node.type}`);
+       throw new RuntimeError(`Unknown node type in evaluator: ${node.type}`, node, this.source);
+
   }
 }
 
 async evalProgram(node, env) {
   let result = null;
   for (const stmt of node.body) {
-    result = await this.evaluate(stmt, env);
+    try {
+      result = await this.evaluate(stmt, env);
+    } catch (e) {
+      if (e instanceof RuntimeError || e instanceof BreakSignal || e instanceof ContinueSignal || e instanceof ReturnValue) {
+        throw e;
+      }
+      throw new RuntimeError(e.message || 'Error in program', stmt, this.source);
+    }
   }
   return result;
 }
 
+
 async evalDoTrack(node, env) {
   try {
     return await this.evaluate(node.body, env);
   } catch (err) {
-    if (!node.handler) throw err;
+    if (!node.handler) {
+      // Wrap any raw error into RuntimeError with line info
+      if (err instanceof RuntimeError) throw err;
+      throw new RuntimeError(err.message || 'Error in doTrack body', node.body, this.source);
+    }
 
     const trackEnv = new Environment(env);
     trackEnv.define('error', err);
 
-    return await this.evaluate(node.handler, trackEnv);
+    try {
+      return await this.evaluate(node.handler, trackEnv);
+    } catch (handlerErr) {
+      // Wrap handler errors as well
+      if (handlerErr instanceof RuntimeError) throw handlerErr;
+      throw new RuntimeError(handlerErr.message || 'Error in doTrack handler', node.handler, this.source);
+    }
   }
 }
 
+
 async evalImport(node, env) {
   const spec = node.path;
   let lib;
@@ -317,7 +355,7 @@ async evalImport(node, env) {
       : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
 
     if (!fs.existsSync(fullPath)) {
-      throw new Error(`Import not found: ${spec}`);
+      throw new RuntimeError(`Import not found: ${spec}`, node, this.source);
     }
 
     const code = fs.readFileSync(fullPath, 'utf-8');
@@ -344,7 +382,7 @@ async evalImport(node, env) {
     }
     if (imp.type === 'NamedImport') {
       if (!(imp.imported in lib)) {
-        throw new Error(`Module '${spec}' has no export '${imp.imported}'`);
+        throw new RuntimeError(`Module '${spec}' has no export '${imp.imported}'`, node, this.source);
       }
       env.define(imp.local, lib[imp.imported]);
     }
@@ -360,18 +398,32 @@ async evalBlock(node, env) {
       result = await this.evaluate(stmt, env);
     } catch (e) {
       if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
-      throw e;
+      // Wrap any other error in RuntimeError with the current block node
+      throw new RuntimeError(e.message || 'Error in block', stmt, this.source);
     }
   }
   return result;
 }
 
+
 async evalVarDeclaration(node, env) {
+  if (!node.expr) {
+    throw new RuntimeError('Variable declaration requires an initializer', node, this.source);
+  }
+
   const val = await this.evaluate(node.expr, env);
   return env.define(node.id, val);
 }
 
+
 evalArrowFunction(node, env) {
+  if (!node.body) {
+    throw new RuntimeError('Arrow function missing body', node, this.source);
+  }
+  if (!Array.isArray(node.params)) {
+    throw new RuntimeError('Invalid arrow function parameters', node, this.source);
+  }
+
   return {
     params: node.params,
     body: node.body,
@@ -381,24 +433,29 @@ evalArrowFunction(node, env) {
   };
 }
 
+
 async evalAssignment(node, env) {
   const rightVal = await 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 = await this.evaluate(left.object, env);
-    obj[left.property] = rightVal;
-    return rightVal;
-  }
-  if (left.type === 'IndexExpression') {
-    const obj = await this.evaluate(left.object, env);
-    const idx = await this.evaluate(left.indexer, env);
-    obj[idx] = rightVal;
-    return rightVal;
-  }
+  const obj = await this.evaluate(left.object, env);
+  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
+  obj[left.property] = rightVal;
+  return rightVal;
+}
+if (left.type === 'IndexExpression') {
+  const obj = await this.evaluate(left.object, env);
+  const idx = await this.evaluate(left.indexer, env);
+  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
+  obj[idx] = rightVal;
+  return rightVal;
+}
+
+
+ throw new RuntimeError('Invalid assignment target', node, this.source);
 
-  throw new Error('Invalid assignment target');
 }
 
 async evalCompoundAssignment(node, env) {
@@ -408,7 +465,8 @@ async evalCompoundAssignment(node, env) {
   if (left.type === 'Identifier') current = env.get(left.name);
   else if (left.type === 'MemberExpression') current = await this.evalMember(left, env);
   else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env);
-  else throw new Error('Invalid compound assignment target');
+  else throw new RuntimeError('Invalid compound assignment target', node, this.source);
+
 
   const rhs = await this.evaluate(node.right, env);
   let computed;
@@ -418,7 +476,8 @@ async evalCompoundAssignment(node, env) {
     case 'STAREQ': computed = current * rhs; break;
     case 'SLASHEQ': computed = current / rhs; break;
     case 'MODEQ': computed = current % rhs; break;
-    default: throw new Error('Unknown compound operator');
+    default: throw new RuntimeError(`Unknown compound operator: ${node.operator}`, node, this.source);
+
   }
 
   if (left.type === 'Identifier') env.set(left.name, computed);
@@ -437,21 +496,33 @@ async evalSldeploy(node, env) {
 
 async evalAsk(node, env) {
   const prompt = await this.evaluate(node.prompt, env);
+
+  if (typeof prompt !== 'string') {
+    throw new RuntimeError('ask() prompt must be a string', node, this.source);
+  }
+
   const input = readlineSync.question(prompt + ' ');
   return input;
 }
 
+
 async evalDefine(node, env) {
+  if (!node.id || typeof node.id !== 'string') {
+    throw new RuntimeError('Invalid identifier in define statement', node, this.source);
+  }
+
   const val = node.expr ? await this.evaluate(node.expr, env) : null;
-  return this.global.define(node.id, val);
+  return env.define(node.id, val);
+
 }
 
+
 async evalBinary(node, env) {
   const l = await this.evaluate(node.left, env);
   const r = await this.evaluate(node.right, env);
 
   if (node.operator === 'SLASH' && r === 0) {
-    throw new Error('Division by zero');
+    throw new RuntimeError('Division by zero', node, this.source);
   }
 
   switch (node.operator) {
@@ -466,7 +537,8 @@ async evalBinary(node, env) {
     case 'LTE': return l <= r;
     case 'GT': return l > r;
     case 'GTE': return l >= r;
-    default: throw new Error(`Unknown binary operator ${node.operator}`);
+    default: throw new RuntimeError(`Unknown binary operator: ${node.operator}`, node, this.source);
+
   }
 }
 
@@ -474,7 +546,8 @@ async evalLogical(node, env) {
   const l = await this.evaluate(node.left, env);
   if (node.operator === 'AND') return l && await this.evaluate(node.right, env);
   if (node.operator === 'OR') return l || await this.evaluate(node.right, env);
-  throw new Error(`Unknown logical operator ${node.operator}`);
+  throw new RuntimeError(`Unknown logical operator: ${node.operator}`, node, this.source);
+
 }
 
 async evalUnary(node, env) {
@@ -483,21 +556,43 @@ async evalUnary(node, env) {
     case 'NOT': return !val;
     case 'MINUS': return -val;
     case 'PLUS': return +val;
-    default: throw new Error(`Unknown unary operator ${node.operator}`);
+    default: throw new RuntimeError(`Unknown unary operator: ${node.operator}`, node, this.source);
+
   }
 }
 
 async evalIf(node, env) {
   const test = await this.evaluate(node.test, env);
-  if (test) return await this.evaluate(node.consequent, env);
-  if (node.alternate) return await this.evaluate(node.alternate, env);
+
+  if (typeof test !== 'boolean') {
+    throw new RuntimeError('If condition must evaluate to a boolean', node.test, this.source);
+  }
+
+  if (test) {
+    return await this.evaluate(node.consequent, env);
+  }
+
+  if (node.alternate) {
+    return await this.evaluate(node.alternate, env);
+  }
+
   return null;
 }
 
+
 async evalWhile(node, env) {
-  while (await this.evaluate(node.test, env)) {
-    try { await this.evaluate(node.body, env); }
-    catch (e) {
+  while (true) {
+    const test = await this.evaluate(node.test, env);
+
+    if (typeof test !== 'boolean') {
+      throw new RuntimeError('While condition must evaluate to a boolean', node.test, this.source);
+    }
+
+    if (!test) break;
+
+    try {
+      await this.evaluate(node.body, env);
+    } catch (e) {
       if (e instanceof BreakSignal) break;
       if (e instanceof ContinueSignal) continue;
       throw e;
@@ -505,6 +600,7 @@ async evalWhile(node, env) {
   }
   return null;
 }
+
 async evalFor(node, env) {
   // -------------------------------
   // Python-style: for x in iterable (with optional 'let')
@@ -513,7 +609,7 @@ async evalFor(node, env) {
     const iterable = await this.evaluate(node.iterable, env);
 
     if (iterable == null || typeof iterable !== 'object') {
-      throw new Error('Cannot iterate over non-iterable');
+      throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
     }
 
     const loopVar = node.variable; // STRING from parser
@@ -578,9 +674,26 @@ async evalFor(node, env) {
 
   return null;
 }
-
 evalFunctionDeclaration(node, env) {
-  const fn = { params: node.params, body: node.body, env, async: node.async || false };
+  if (!node.name || typeof node.name !== 'string') {
+    throw new RuntimeError('Function declaration requires a valid name', node, this.source);
+  }
+
+  if (!Array.isArray(node.params)) {
+    throw new RuntimeError(`Invalid parameter list in function '${node.name}'`, node, this.source);
+  }
+
+  if (!node.body) {
+    throw new RuntimeError(`Function '${node.name}' has no body`, node, this.source);
+  }
+
+  const fn = {
+    params: node.params,
+    body: node.body,
+    env,
+    async: node.async || false
+  };
+
   env.define(node.name, fn);
   return null;
 }
@@ -590,10 +703,10 @@ async evalCall(node, env) {
   if (typeof calleeEvaluated === 'function') {
     const args = [];
     for (const a of node.arguments) args.push(await this.evaluate(a, env));
-    return calleeEvaluated(...args);
+    return await calleeEvaluated(...args);
   }
   if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
-    throw new Error('Call to non-function');
+    throw new RuntimeError('Call to non-function', node, this.source);
   }
 
   const fn = calleeEvaluated;
@@ -606,7 +719,7 @@ async evalCall(node, env) {
 
   try {
     const result = await this.evaluate(fn.body, callEnv);
-    return fn.arrow ? result : result;
+    return result;
   } catch (e) {
     if (e instanceof ReturnValue) return e.value;
     throw e;
@@ -617,12 +730,13 @@ async evalIndex(node, env) {
   const obj = await this.evaluate(node.object, env);
   const idx = await this.evaluate(node.indexer, env);
 
-  if (obj == null) throw new Error('Indexing null or undefined');
+  if (obj == null) throw new RuntimeError('Indexing null or undefined', node, this.source);
+
   if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-    throw new Error('Array index out of bounds');
+    throw new RuntimeError('Array index out of bounds', node, this.source);
   }
   if (typeof obj === 'object' && !(idx in obj)) {
-    throw new Error(`Property '${idx}' does not exist`);
+    throw new RuntimeError(`Property '${idx}' does not exist`, node, this.source);
   }
 
   return obj[idx];
@@ -630,14 +744,22 @@ async evalIndex(node, env) {
 
 async evalObject(node, env) {
   const out = {};
-  for (const p of node.props) out[p.key] = await this.evaluate(p.value, env);
+  for (const p of node.props) {
+    if (!p.key || !p.value) {
+      throw new RuntimeError('Invalid object property', node, this.source);
+    }
+    const key = await this.evaluate(p.key, env);
+    const value = await this.evaluate(p.value, env);
+    out[key] = value;
+  }
   return out;
 }
 
+
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
-  if (obj == null) throw new Error('Member access of null or undefined');
-  if (!(node.property in obj)) throw new Error(`Property '${node.property}' does not exist`);
+ if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node, this.source);
   return obj[node.property];
 }
 
@@ -647,7 +769,8 @@ async evalUpdate(node, env) {
     if (arg.type === 'Identifier') return env.get(arg.name);
     if (arg.type === 'MemberExpression') return await this.evalMember(arg, env);
     if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
-    throw new Error('Invalid update target');
+    throw new RuntimeError('Invalid update target', node, this.source);
+
   };
   const setValue = async (v) => {
     if (arg.type === 'Identifier') env.set(arg.name, v);

package/src/lexer.js

@@ -1,11 +1,30 @@
+class LexerError extends Error {
+  constructor(message, line, column, source = '') {
+    let output = `SyntaxError: ${message}\n`;
+    output += `  at line ${line}, column ${column}\n`;
+
+    if (source && line != null) {
+      const lines = source.split('\n');
+      const srcLine = lines[line - 1] || '';
+      output += `    ${srcLine}\n`;
+      output += `    ${' '.repeat(column - 1)}^\n`;
+    }
+
+    super(output);
+    this.name = 'SyntaxError';
+  }
+}
+
 class Lexer {
   constructor(input) {
-    this.input = input;
-    this.pos = 0;
-    this.currentChar = input[0] || null;
-    this.line = 1;     // current line
-    this.column = 1;   // current column
-  }
+  this.input = input;
+  this.source = input;
+  this.pos = 0;
+  this.currentChar = input[0] || null;
+  this.line = 1;
+  this.column = 1;
+}
+
 
   advance() {
     if (this.currentChar === '\n') {
@@ -23,8 +42,14 @@ class Lexer {
   }
 
   error(msg) {
-    throw new Error(`${msg} at line ${this.line}, column ${this.column}`);
-  }
+  throw new LexerError(
+    msg,
+    this.line,
+    this.column,
+    this.source
+  );
+}
+
 
   skipWhitespace() {
     while (this.currentChar && /\s/.test(this.currentChar)) this.advance();