starlight-cli 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"
@@ -13,7 +13,8 @@
   "license": "MIT",
   "dependencies": {
     "blessed": "^0.1.81",
-    "readline-sync": "^1.4.10"
+    "readline-sync": "^1.4.10",
+    "starlight-color": "^1.0.4"
   },
   "devDependencies": {
     "@vercel/ncc": "^0.38.4"

package/src/evaluator.js

@@ -49,7 +49,6 @@ class Environment {
   if (name in this.store) return this.store[name];
   if (this.parent) return this.parent.get(name, node, source);
 
-  // Only suggest for top-level variable/function names
   let suggestion = null;
   if (node && source) {
     suggestion = this.suggest?.(name, this) || null;
@@ -84,7 +83,6 @@ class Evaluator {
     this.setupBuiltins();
   }
 suggest(name, env) {
-  // Collect all variable/function names from the environment chain
   const names = new Set();
   let current = env;
   while (current) {
@@ -98,11 +96,10 @@ suggest(name, env) {
   let bestScore = Infinity;
 
   for (const item of names) {
-    // simple edit distance approximation
     const dist = Math.abs(item.length - name.length) +
       [...name].filter((c, i) => c !== item[i]).length;
 
-    if (dist < bestScore && dist <= 2) { // max distance 2
+    if (dist < bestScore && dist <= 2) { 
       bestScore = dist;
       best = item;
     }
@@ -111,58 +108,50 @@ suggest(name, env) {
   return best;
 }
 
-
 formatValue(value, seen = new Set()) {
-  // Circular reference handling
+  const color = require('starlight-color');
+
   if (typeof value === 'object' && value !== null) {
-    if (seen.has(value)) return '[Circular]';
+    if (seen.has(value)) return color.red('[Circular]');
     seen.add(value);
   }
 
-  // Python-style null / undefined
-  if (value === null) return 'None';
-  if (value === undefined) return 'undefined';
+  if (value === null) return color.yellow('None');
+  if (value === undefined) return color.yellow('undefined');
 
   const t = typeof value;
 
-  // Strings (no quotes)
-  if (t === 'string') return value;
+  if (t === 'string') return color.cyan(value);
 
-  // Numbers
-  if (t === 'number') return String(value);
+  if (t === 'number') return color.green(String(value));
 
-  // Booleans (Python-style)
-  if (t === 'boolean') return value ? 'True' : 'False';
+  if (t === 'boolean') return color.yellow(value ? 'true' : 'false');
 
-  // Native JS functions
   if (t === 'function') {
-    return value.name
-      ? `<function ${value.name}>`
-      : '<function>';
+    return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
   }
 
-  // Arrays
   if (Array.isArray(value)) {
-    return '[' + value.map(v => this.formatValue(v, seen)).join(', ') + ']';
+    const items = value.map(v => this.formatValue(v, seen));
+    return color.white('[ ' + items.join(', ') + ' ]');
   }
 
-  // Objects (including user-defined functions)
   if (t === 'object') {
-    // Detect user-defined functions (AST-based)
     if (value.params && value.body) {
-      return value.name
-        ? `<function ${value.name}>`
-        : '<function>';
+      return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
     }
 
     const entries = Object.entries(value).map(
-      ([k, v]) => `${k}: ${this.formatValue(v, seen)}`
+      ([k, v]) => color.magenta(`${k}: `) + this.formatValue(v, seen)
     );
-    return '{ ' + entries.join(', ') + ' }';
+    return color.magenta('{ ') + entries.join(color.magenta(', ')) + color.magenta(' }');
   }
 
-  // Fallback
-  return String(value);
+  try {
+    return String(value);
+  } catch {
+    return color.red('[Unprintable]');
+  }
 }
 
 
@@ -237,7 +226,6 @@ this.global.define('fetch', async (url, options = {}) => {
   };
 });
 
-// GET request
 this.global.define('get', async (url) => {
   const res = await fetch(url);
   return await res.json();
@@ -284,6 +272,11 @@ case 'ForInStatement':
   return await this.evalFor(node, env);
 case 'DoTrackStatement':
   return await this.evalDoTrack(node, env);
+case 'StartStatement':
+  return await this.evalStartStatement(node, env);
+
+case 'RaceClause':
+  return await this.evalRaceClause(node, env);
 
     case 'BreakStatement': throw new BreakSignal();
     case 'ContinueStatement': throw new ContinueSignal();
@@ -312,14 +305,14 @@ case 'DoTrackStatement':
   const callee = await this.evaluate(node.callee, env);
 
   if (typeof callee === 'object' && callee.body) {
-    const evaluator = this; // <- capture the current evaluator
+    const evaluator = this; 
     const Constructor = function(...args) {
       const newEnv = new Environment(callee.env);
       newEnv.define('this', this);
       for (let i = 0; i < callee.params.length; i++) {
         newEnv.define(callee.params[i], args[i]);
       }
-      return evaluator.evaluate(callee.body, newEnv); // use captured evaluator
+      return evaluator.evaluate(callee.body, newEnv);
     };
 
     const args = [];
@@ -357,13 +350,78 @@ async evalProgram(node, env) {
   return result;
 }
 
+async evalStartStatement(node, env) {
+  try {
+    const value = await this.evaluate(node.discriminant, env);
+    let executing = false;
+    for (const c of node.cases) {
+      try {
+        if (!executing) {
+          const testValue = await this.evaluate(c.test, env);
+          if (testValue === value) executing = true;
+        }
+
+        if (executing) {
+          await this.evaluate(c.consequent, new Environment(env));
+        }
+      } catch (caseErr) {
+        if (caseErr instanceof BreakSignal) break;
+        if (caseErr instanceof RuntimeError ||
+            caseErr instanceof ReturnValue ||
+            caseErr instanceof ContinueSignal) {
+          throw caseErr; // propagate signals
+        }
+
+        throw new RuntimeError(
+          caseErr.message || 'Error evaluating case in start statement',
+          c,
+          this.source
+        );
+      }
+    }
+
+    return null;
+  } catch (err) {
+    if (err instanceof RuntimeError ||
+        err instanceof ReturnValue ||
+        err instanceof BreakSignal ||
+        err instanceof ContinueSignal) {
+      throw err;
+    }
+    throw new RuntimeError(
+      err.message || 'Error evaluating start statement',
+      node,
+      this.source
+    );
+  }
+}
+
+
+async evalRaceClause(node, env) {
+  try {
+    const testValue = await this.evaluate(node.test, env);
+    const result = await this.evaluate(node.consequent, new Environment(env));
+    return { testValue, result };
+  } catch (err) {
+    if (err instanceof RuntimeError ||
+        err instanceof ReturnValue ||
+        err instanceof BreakSignal ||
+        err instanceof ContinueSignal) {
+      throw err; 
+    }
+    throw new RuntimeError(
+      err.message || 'Error evaluating race clause',
+      node,
+      this.source
+    );
+  }
+}
 
 async evalDoTrack(node, env) {
   try {
     return await this.evaluate(node.body, env);
   } catch (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);
     }
@@ -374,7 +432,6 @@ async evalDoTrack(node, env) {
     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);
     }
@@ -493,23 +550,23 @@ async evalAssignment(node, 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);
-  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;
-}
 
+  if (left.type === 'MemberExpression') {
+    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; // dynamic creation of new properties allowed
+    return rightVal;
+  }
 
- throw new RuntimeError('Invalid assignment target', node, this.source);
+  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; // dynamic creation allowed
+    return rightVal;
+  }
 
+  throw new RuntimeError('Invalid assignment target', node, this.source);
 }
 
 async evalCompoundAssignment(node, env) {
@@ -517,13 +574,13 @@ async evalCompoundAssignment(node, env) {
   let current;
 
   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 if (left.type === 'MemberExpression') current = await this.evalMember(left, env) ?? 0;
+  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env) ?? 0;
   else throw new RuntimeError('Invalid compound assignment target', node, this.source);
 
-
   const rhs = await this.evaluate(node.right, env);
   let computed;
+
   switch (node.operator) {
     case 'PLUSEQ': computed = current + rhs; break;
     case 'MINUSEQ': computed = current - rhs; break;
@@ -531,16 +588,18 @@ async evalCompoundAssignment(node, env) {
     case 'SLASHEQ': computed = current / rhs; break;
     case 'MODEQ': computed = current % rhs; break;
     default: throw new RuntimeError(`Unknown compound operator: ${node.operator}`, node, this.source);
-
   }
 
   if (left.type === 'Identifier') env.set(left.name, computed);
-  else if (left.type === 'MemberExpression') await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
-  else await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+  else if (left.type === 'MemberExpression') 
+    await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+  else 
+    await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
 
   return computed;
 }
 
+
 async evalSldeploy(node, env) {
   const val = await this.evaluate(node.expr, env);
   console.log(this.formatValue(val));
@@ -548,6 +607,7 @@ async evalSldeploy(node, env) {
 }
 
 
+
 async evalAsk(node, env) {
   const prompt = await this.evaluate(node.prompt, env);
 
@@ -654,11 +714,7 @@ async evalWhile(node, env) {
   }
   return null;
 }
-
 async evalFor(node, env) {
-  // -------------------------------
-  // Python-style: for x in iterable (with optional 'let')
-  // -------------------------------
   if (node.type === 'ForInStatement') {
     const iterable = await this.evaluate(node.iterable, env);
 
@@ -666,11 +722,8 @@ async evalFor(node, env) {
       throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
     }
 
-    const loopVar = node.variable; // STRING from parser
-
+    const loopVar = node.variable; // string name of the loop variable
     const createLoopEnv = () => node.letKeyword ? new Environment(env) : env;
-
-    // Arrays
     if (Array.isArray(iterable)) {
       for (const value of iterable) {
         const loopEnv = createLoopEnv();
@@ -685,7 +738,6 @@ async evalFor(node, env) {
         }
       }
     }
-    // Objects (keys)
     else {
       for (const key of Object.keys(iterable)) {
         const loopEnv = createLoopEnv();
@@ -704,9 +756,6 @@ async evalFor(node, env) {
     return null;
   }
 
-  // -------------------------------
-  // C-style for loop
-  // -------------------------------
   const local = new Environment(env);
 
   if (node.init) await this.evaluate(node.init, local);
@@ -728,6 +777,7 @@ async evalFor(node, env) {
 
   return null;
 }
+
 evalFunctionDeclaration(node, env) {
   if (!node.name || typeof node.name !== 'string') {
     throw new RuntimeError('Function declaration requires a valid name', node, this.source);
@@ -790,18 +840,17 @@ 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, this.source);
-
-  if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-    throw new RuntimeError('Array index out of bounds', node, this.source);
+  if (obj == null) throw new RuntimeError('Cannot index null or undefined', node, this.source);
+  if (Array.isArray(obj)) {
+    if (idx < 0 || idx >= obj.length) return undefined;
+    return obj[idx];
   }
-  if (typeof obj === 'object' && !(idx in obj)) {
-    throw new RuntimeError(`Property '${idx}' does not exist`, node, this.source);
+  if (typeof obj === 'object') {
+    return obj[idx]; // undefined if missing
   }
 
-  return obj[idx];
+  return undefined;
 }
-
 async evalObject(node, env) {
   const out = {};
   for (const p of node.props) {
@@ -810,19 +859,22 @@ async evalObject(node, env) {
     }
     const key = await this.evaluate(p.key, env);
     const value = await this.evaluate(p.value, env);
-    out[key] = value;
+    out[key] = value; // dynamic property assignment
   }
   return out;
 }
 
 
+
 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, this.source);
-if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node, this.source);
+
+  if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+
   return obj[node.property];
 }
 
+
 async evalUpdate(node, env) {
   const arg = node.argument;
   const getCurrent = async () => {

package/src/lexer.js

@@ -28,7 +28,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race'
     ];
 }