starlight-cli 1.0.47 → 1.0.49

package/package.json

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

package/src/evaluator.js

@@ -10,14 +10,29 @@ class ReturnValue {
 class BreakSignal {}
 class ContinueSignal {}
 class RuntimeError extends Error {
-  constructor(message, node) {
-    const line = node?.line ?? '?';
-    const column = node?.column ?? '?';
-    super(`RuntimeError: ${message} at line ${line}, column ${column}`);
-    this.name = 'RuntimeError';
-  }
+    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) {
     this.store = Object.create(null);
@@ -30,11 +45,12 @@ 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 RuntimeError(`Undefined variable: ${name}`);
-  }
+  get(name, node, source) {
+  if (name in this.store) return this.store[name];
+  if (this.parent) return this.parent.get(name, node, source);
+  throw new RuntimeError(`Undefined variable: ${name}`, node, source);
+}
+
 
   set(name, value) {
     if (name in this.store) { this.store[name] = value; return value; }
@@ -50,7 +66,8 @@ class Environment {
 }
 
 class Evaluator {
-  constructor() {
+  constructor(source = '') {
+    this.source = source;
     this.global = new Environment();
     this.setupBuiltins();
   }
@@ -137,11 +154,11 @@ this.global.define('range', (...args) => {
     end = Number(args[1]);
     step = Number(args[2]);
   } else {
-    throw new RuntimeError('range() expects 1 to 3 arguments');
+    throw new RuntimeError('range() expects 1 to 3 arguments', null, this.source);
   }
 
   if (step === 0) {
-    throw new RuntimeError('range() step cannot be 0');
+    throw new RuntimeError('range() step cannot be 0', null, this.source);
   }
 
   const result = [];
@@ -165,7 +182,7 @@ this.global.define('range', (...args) => {
     this.global.define('num', arg => {
     const n = Number(arg);
     if (Number.isNaN(n)) {
-        throw new RuntimeError('Cannot convert value to number');
+        throw new RuntimeError('Cannot convert value to number', null, this.source);
     }
     return n;
 });
@@ -218,7 +235,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, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
     case 'WhileStatement': return await this.evalWhile(node, env);
     case 'ForStatement':
@@ -241,14 +258,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);
@@ -276,7 +287,7 @@ case 'DoTrackStatement':
   }
 
   if (typeof callee !== 'function') {
-    throw new RuntimeError('NewExpression callee is not a function', node);
+    throw new RuntimeError('NewExpression callee is not a function', node, this.source);
   }
 
   const args = [];
@@ -285,7 +296,7 @@ case 'DoTrackStatement':
 }
 
     default:
-       throw new RuntimeError(`Unknown node type in evaluator: ${node.type}`, node);
+       throw new RuntimeError(`Unknown node type in evaluator: ${node.type}`, node, this.source);
 
   }
 }
@@ -293,11 +304,19 @@ case 'DoTrackStatement':
 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);
@@ -305,7 +324,7 @@ async evalDoTrack(node, env) {
     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);
+      throw new RuntimeError(err.message || 'Error in doTrack body', node.body, this.source);
     }
 
     const trackEnv = new Environment(env);
@@ -316,7 +335,7 @@ async evalDoTrack(node, env) {
     } catch (handlerErr) {
       // Wrap handler errors as well
       if (handlerErr instanceof RuntimeError) throw handlerErr;
-      throw new RuntimeError(handlerErr.message || 'Error in doTrack handler', node.handler);
+      throw new RuntimeError(handlerErr.message || 'Error in doTrack handler', node.handler, this.source);
     }
   }
 }
@@ -337,7 +356,7 @@ async evalImport(node, env) {
       : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
 
     if (!fs.existsSync(fullPath)) {
-      throw new RuntimeError(`Import not found: ${spec}`, node);
+      throw new RuntimeError(`Import not found: ${spec}`, node, this.source);
     }
 
     const code = fs.readFileSync(fullPath, 'utf-8');
@@ -364,7 +383,7 @@ async evalImport(node, env) {
     }
     if (imp.type === 'NamedImport') {
       if (!(imp.imported in lib)) {
-        throw new RuntimeError(`Module '${spec}' has no export '${imp.imported}'`, node);
+        throw new RuntimeError(`Module '${spec}' has no export '${imp.imported}'`, node, this.source);
       }
       env.define(imp.local, lib[imp.imported]);
     }
@@ -381,7 +400,7 @@ async evalBlock(node, env) {
     } catch (e) {
       if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
       // Wrap any other error in RuntimeError with the current block node
-      throw new RuntimeError(e.message || 'Error in block', stmt);
+      throw new RuntimeError(e.message || 'Error in block', stmt, this.source);
     }
   }
   return result;
@@ -389,11 +408,23 @@ async evalBlock(node, env) {
 
 
 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,
@@ -403,24 +434,28 @@ 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);
+ throw new RuntimeError('Invalid assignment target', node, this.source);
 
 }
 
@@ -428,10 +463,10 @@ async evalCompoundAssignment(node, env) {
   const left = node.left;
   let current;
 
-  if (left.type === 'Identifier') current = env.get(left.name);
+  if (left.type === 'Identifier') current = env.get(left.name, left, this.source);
   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 RuntimeError('Invalid compound assignment target', node);
+  else throw new RuntimeError('Invalid compound assignment target', node, this.source);
 
 
   const rhs = await this.evaluate(node.right, env);
@@ -442,7 +477,7 @@ 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 RuntimeError(`Unknown compound operator: ${node.operator}`, node);
+    default: throw new RuntimeError(`Unknown compound operator: ${node.operator}`, node, this.source);
 
   }
 
@@ -462,21 +497,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 RuntimeError('Division by zero', node);
+    throw new RuntimeError('Division by zero', node, this.source);
   }
 
   switch (node.operator) {
@@ -491,7 +538,7 @@ async evalBinary(node, env) {
     case 'LTE': return l <= r;
     case 'GT': return l > r;
     case 'GTE': return l >= r;
-    default: throw new RuntimeError(`Unknown binary operator: ${node.operator}`, node);
+    default: throw new RuntimeError(`Unknown binary operator: ${node.operator}`, node, this.source);
 
   }
 }
@@ -500,7 +547,7 @@ 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 RuntimeError(`Unknown logical operator: ${node.operator}`, node);
+  throw new RuntimeError(`Unknown logical operator: ${node.operator}`, node, this.source);
 
 }
 
@@ -510,22 +557,43 @@ async evalUnary(node, env) {
     case 'NOT': return !val;
     case 'MINUS': return -val;
     case 'PLUS': return +val;
-    default: throw new RuntimeError(`Unknown unary operator: ${node.operator}`, node);
+    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;
@@ -533,6 +601,7 @@ async evalWhile(node, env) {
   }
   return null;
 }
+
 async evalFor(node, env) {
   // -------------------------------
   // Python-style: for x in iterable (with optional 'let')
@@ -541,7 +610,7 @@ async evalFor(node, env) {
     const iterable = await this.evaluate(node.iterable, env);
 
     if (iterable == null || typeof iterable !== 'object') {
-      throw new RuntimeError('Cannot iterate over non-iterable', node);
+      throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
     }
 
     const loopVar = node.variable; // STRING from parser
@@ -606,9 +675,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;
 }
@@ -618,10 +704,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 RuntimeError('Call to non-function', node);
+    throw new RuntimeError('Call to non-function', node, this.source);
   }
 
   const fn = calleeEvaluated;
@@ -634,7 +720,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;
@@ -645,13 +731,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 RuntimeError('Indexing null or undefined', node);
+  if (obj == null) throw new RuntimeError('Indexing null or undefined', node, this.source);
 
   if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-    throw new RuntimeError('Array index out of bounds', node);
+    throw new RuntimeError('Array index out of bounds', node, this.source);
   }
   if (typeof obj === 'object' && !(idx in obj)) {
-    throw new RuntimeError(`Property '${idx}' does not exist`, node);
+    throw new RuntimeError(`Property '${idx}' does not exist`, node, this.source);
   }
 
   return obj[idx];
@@ -661,7 +747,7 @@ async evalObject(node, env) {
   const out = {};
   for (const p of node.props) {
     if (!p.key || !p.value) {
-      throw new RuntimeError('Invalid object property', node);
+      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);
@@ -673,18 +759,18 @@ async evalObject(node, env) {
 
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
- if (obj == null) throw new RuntimeError('Member access of null or undefined', node);
-if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node);
+ 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];
 }
 
 async evalUpdate(node, env) {
   const arg = node.argument;
   const getCurrent = async () => {
-    if (arg.type === 'Identifier') return env.get(arg.name);
+    if (arg.type === 'Identifier') return env.get(arg.name, arg, this.source);
     if (arg.type === 'MemberExpression') return await this.evalMember(arg, env);
     if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
-    throw new RuntimeError('Invalid update target', node);
+    throw new RuntimeError('Invalid update target', node, this.source);
 
   };
   const setValue = async (v) => {