starlight-cli 1.1.2 → 1.1.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;
     }
@@ -114,39 +111,31 @@ suggest(name, env) {
 formatValue(value, seen = new Set()) {
   const color = require('starlight-color');
 
-  // Handle circular references
   if (typeof value === 'object' && value !== null) {
     if (seen.has(value)) return color.red('[Circular]');
     seen.add(value);
   }
 
-  // Python-style null / 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 color.cyan(value);
 
-  // Numbers
   if (t === 'number') return color.green(String(value));
 
-  // Booleans
   if (t === 'boolean') return color.yellow(value ? 'true' : 'false');
 
-  // Native JS functions
   if (t === 'function') {
     return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
   }
 
-  // Arrays
   if (Array.isArray(value)) {
     const items = value.map(v => this.formatValue(v, seen));
     return color.white('[ ' + items.join(', ') + ' ]');
   }
 
-  // Objects (including user-defined functions)
   if (t === 'object') {
     if (value.params && value.body) {
       return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
@@ -158,7 +147,6 @@ formatValue(value, seen = new Set()) {
     return color.magenta('{ ') + entries.join(color.magenta(', ')) + color.magenta(' }');
   }
 
-  // Fallback
   try {
     return String(value);
   } catch {
@@ -238,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();
@@ -285,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();
@@ -313,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 = [];
@@ -358,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);
     }
@@ -375,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);
     }
@@ -475,16 +531,33 @@ 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,
-    env: env,
-    arrow: true,
-    async: node.async || false
+  const evaluator = this;
+
+  return async function (...args) {
+    const localEnv = new Environment(env);
+
+    node.params.forEach((p, i) => {
+      localEnv.define(p.name, args[i]);
+    });
+
+    try {
+      if (node.isBlock) {
+        const result = await evaluator.evaluate(node.body, localEnv);
+        return result ?? null;
+      } else {
+        return await evaluator.evaluate(node.body, localEnv);
+      }
+    } catch (err) {
+      if (err instanceof ReturnValue) {
+        return err.value; 
+      }
+      throw err;
+    }
   };
 }
 
@@ -659,7 +732,6 @@ 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);
 
@@ -669,8 +741,6 @@ async evalFor(node, env) {
 
     const loopVar = node.variable; // string name of the loop variable
     const createLoopEnv = () => node.letKeyword ? new Environment(env) : env;
-
-    // Arrays: iterate over elements
     if (Array.isArray(iterable)) {
       for (const value of iterable) {
         const loopEnv = createLoopEnv();
@@ -685,7 +755,6 @@ async evalFor(node, env) {
         }
       }
     }
-    // Objects: iterate over keys
     else {
       for (const key of Object.keys(iterable)) {
         const loopEnv = createLoopEnv();
@@ -704,7 +773,6 @@ async evalFor(node, env) {
     return null;
   }
 
-  // C-style for loop (classic JS style)
   const local = new Environment(env);
 
   if (node.init) await this.evaluate(node.init, local);
@@ -790,19 +858,14 @@ async evalIndex(node, env) {
   const idx = await this.evaluate(node.indexer, env);
 
   if (obj == null) throw new RuntimeError('Cannot index null or undefined', node, this.source);
-
-  // Array access: return undefined if out of bounds
   if (Array.isArray(obj)) {
     if (idx < 0 || idx >= obj.length) return undefined;
     return obj[idx];
   }
-
-  // Object access: return undefined if property missing
   if (typeof obj === 'object') {
     return obj[idx]; // undefined if missing
   }
 
-  // Fallback for non-object non-array
   return undefined;
 }
 async evalObject(node, env) {

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'
     ];
 }
 

package/src/parser.js

@@ -73,6 +73,7 @@ class Parser {
       case 'WHILE': return this.whileStatement();
       case 'FOR': return this.forStatement();
       case 'DO': return this.doTrackStatement();
+      case 'START': return this.startStatement();
       case 'BREAK': return this.breakStatement();
       case 'CONTINUE': return this.continueStatement();
       case 'FUNC': return this.funcDeclaration();
@@ -84,9 +85,9 @@ class Parser {
     }
   }
 varDeclaration() {
-  const t = this.current; // LET token
+  const t = this.current; 
   this.eat('LET');
-  const idToken = this.current; // identifier token
+  const idToken = this.current; 
   const id = idToken.value;
   this.eat('IDENTIFIER');
 
@@ -96,7 +97,6 @@ varDeclaration() {
     expr = this.expression();
   }
 
-  // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
   return { 
@@ -107,9 +107,49 @@ varDeclaration() {
     column: t.column 
   };
 }
+startStatement() {
+  const t = this.current; 
+  this.eat('START');
+
+  const discriminant = this.expression();
+
+  this.eat('LBRACE');
+
+  const cases = [];
+
+  while (this.current.type === 'RACE') {
+    cases.push(this.raceClause());
+  }
+
+  this.eat('RBRACE');
+
+  return {
+    type: 'StartStatement',
+    discriminant,
+    cases,
+    line: t.line,
+    column: t.column
+  };
+}
+raceClause() {
+  const t = this.current; 
+  this.eat('RACE');
+
+  const test = this.expression();
+
+  const consequent = this.block();
+
+  return {
+    type: 'RaceClause',
+    test,
+    consequent,
+    line: t.line,
+    column: t.column
+  };
+}
 
 sldeployStatement() {
-  const t = this.current; // SLDEPLOY token
+  const t = this.current; 
   this.eat('SLDEPLOY');
   const expr = this.expression();
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
@@ -122,7 +162,7 @@ sldeployStatement() {
 }
 
 doTrackStatement() {
-  const t = this.current; // DO token
+  const t = this.current;
   this.eat('DO');
 
   const body = this.block();
@@ -143,9 +183,9 @@ doTrackStatement() {
 }
 
 defineStatement() {
-  const t = this.current; // DEFINE token
+  const t = this.current; 
   this.eat('DEFINE');
-  const idToken = this.current; // identifier token
+  const idToken = this.current; 
   const id = idToken.value;
   this.eat('IDENTIFIER');
 
@@ -167,7 +207,7 @@ defineStatement() {
 }
 
 asyncFuncDeclaration() {
-  const t = this.current; // first token of function (identifier)
+  const t = this.current;
   const name = this.current.value;
   this.eat('IDENTIFIER');
 
@@ -185,7 +225,6 @@ asyncFuncDeclaration() {
     }
     this.eat('RPAREN');
   } else {
-    // no parentheses: single param as Python style
     if (this.current.type === 'IDENTIFIER') {
       params.push(this.current.value);
       this.eat('IDENTIFIER');
@@ -205,7 +244,7 @@ asyncFuncDeclaration() {
 }
 
 ifStatement() {
-  const t = this.current; // IF token
+  const t = this.current;
   this.eat('IF');
 
   let test;
@@ -214,7 +253,6 @@ ifStatement() {
     test = this.expression();
     this.eat('RPAREN');
   } else {
-    // Python style: no parentheses
     test = this.expression();
   }
 
@@ -238,7 +276,7 @@ ifStatement() {
 }
 
 whileStatement() {
-  const t = this.current; // WHILE token
+  const t = this.current; 
   this.eat('WHILE');
 
   let test;
@@ -261,7 +299,7 @@ whileStatement() {
 }
 
 importStatement() {
-  const t = this.current; // IMPORT token
+  const t = this.current; 
   this.eat('IMPORT');
 
   let specifiers = [];
@@ -320,7 +358,6 @@ forStatement() {
   const t = this.current; // FOR token
   this.eat('FOR');
 
-  // --- Python-style: for variable in iterable (supports optional 'let') ---
   if ((this.current.type === 'LET' && this.peekType() === 'IDENTIFIER' && this.peekType(2) === 'IN') ||
       (this.current.type === 'IDENTIFIER' && this.peekType() === 'IN')) {
 
@@ -361,7 +398,6 @@ forStatement() {
     };
   }
 
-  // --- C-style: for(init; test; update) ---
   let init = null;
   let test = null;
   let update = null;
@@ -369,22 +405,18 @@ forStatement() {
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
 
-    // init
     if (this.current.type !== 'SEMICOLON') {
       init = this.current.type === 'LET' ? this.varDeclaration() : this.expressionStatement();
     } else {
       this.eat('SEMICOLON');
     }
 
-    // test
     if (this.current.type !== 'SEMICOLON') test = this.expression();
     this.eat('SEMICOLON');
 
-    // update
     if (this.current.type !== 'RPAREN') update = this.expression();
     this.eat('RPAREN');
   } else {
-    // fallback: single expression (rare, mostly handled above)
     init = this.expression();
     if (this.current.type === 'IN') {
       this.eat('IN');
@@ -407,21 +439,19 @@ forStatement() {
 breakStatement() {
   const t = this.current; // BREAK token
   this.eat('BREAK');
-  // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
   return { type: 'BreakStatement', line: t.line, column: t.column };
 }
 
 continueStatement() {
-  const t = this.current; // CONTINUE token
+  const t = this.current; 
   this.eat('CONTINUE');
-  // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
   return { type: 'ContinueStatement', line: t.line, column: t.column };
 }
 
 funcDeclaration() {
-  const t = this.current; // FUNC token
+  const t = this.current; 
   this.eat('FUNC');
   const nameToken = this.current;
   const name = nameToken.value;
@@ -443,7 +473,6 @@ funcDeclaration() {
     }
     this.eat('RPAREN');
   } else {
-    // Python-style: single param without parentheses
     if (this.current.type === 'IDENTIFIER') {
       const paramToken = this.current;
       params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
@@ -464,7 +493,6 @@ returnStatement() {
     argument = this.expression();
   }
 
-  // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
   return { type: 'ReturnStatement', argument, line: t.line, column: t.column };
@@ -482,9 +510,8 @@ block() {
 }
 
 expressionStatement() {
-  const exprToken = this.current; // first token of the expression
+  const exprToken = this.current;
   const expr = this.expression();
-  // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
   return { type: 'ExpressionStatement', expression: expr, line: exprToken.line, column: exprToken.column };
 }
@@ -597,7 +624,6 @@ unary() {
     };
   }
 
-  // Python-like: ignore ++ and -- if not used
   if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
     const op = t.type;
     this.eat(op);
@@ -637,7 +663,7 @@ postfix() {
       const args = [];
       while (this.current.type !== 'RPAREN' && this.current.type !== 'EOF') {
         args.push(this.expression());
-        if (this.current.type === 'COMMA') this.eat('COMMA'); // optional comma
+        if (this.current.type === 'COMMA') this.eat('COMMA');
       }
       if (this.current.type === 'RPAREN') this.eat('RPAREN');
       node = { type: 'CallExpression', callee: node, arguments: args, line: startLine, column: startCol };
@@ -674,15 +700,26 @@ postfix() {
 
 arrowFunction(params) {
   const t = this.current;
-  if (t.type === 'ARROW') this.eat('ARROW');
-  const body = this.expression();
+  this.eat('ARROW');
+
+  let body;
+  let isBlock = false;
+
+  if (this.current.type === 'LBRACE') {
+    body = this.block();      
+    isBlock = true;
+  } else {
+    body = this.expression(); 
+  }
+
   const startLine = params.length > 0 ? params[0].line : t.line;
-  const startCol = params.length > 0 ? params[0].column : t.column;
+  const startCol  = params.length > 0 ? params[0].column : t.column;
 
   return {
     type: 'ArrowFunctionExpression',
     params,
     body,
+    isBlock,
     line: startLine,
     column: startCol
   };
@@ -814,11 +851,11 @@ arrowFunction(params) {
     this.eat('LBRACE');
     const props = [];
     while (this.current.type !== 'RBRACE') {
-      const key = this.expression(); // Flexible key: can be any expression
+      const key = this.expression(); 
       this.eat('COLON');
       const value = this.expression();
       props.push({ key, value });
-      if (this.current.type === 'COMMA') this.eat('COMMA'); // optional trailing comma
+      if (this.current.type === 'COMMA') this.eat('COMMA');
     }
     this.eat('RBRACE');
     return { type: 'ObjectExpression', props, line: startLine, column: startCol };

package/src/starlight.js

@@ -9,7 +9,7 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const Evaluator = require('./evaluator');
 
-const VERSION = '1.1.2';
+const VERSION = '1.1.4';
 
 const COLOR = {
     reset: '\x1b[0m',