starlight-cli 1.0.24 → 1.0.26

package/package.json

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

package/src/evaluator.js

@@ -73,63 +73,100 @@ class Evaluator {
     }
     return n;
 });
+this.global.define('fetch', async (url, options = {}) => {
+  const res = await fetch(url, options);
+  return {
+    status: res.status,
+    ok: res.ok,
+    text: async () => await res.text(),
+    json: async () => await res.json()
+  };
+});
+
+// GET request
+this.global.define('get', async (url) => {
+  const res = await fetch(url);
+  return await res.json();
+});
 
+this.global.define('post', async (url, data) => {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data)
+  });
+  return await res.json();
+});
+
+this.global.define('sleep', async (ms) => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+});
 this.global.define('str', arg => {
     return String(arg);
 });
 
 }
 
-
-  evaluate(node, env = this.global) {
-    switch (node.type) {
-      case 'Program': return this.evalProgram(node, env);
-      case 'BlockStatement': return this.evalBlock(node, new Environment(env));
-      case 'VarDeclaration': return this.evalVarDeclaration(node, env);
-      case 'AssignmentExpression': return this.evalAssignment(node, env);
-      case 'CompoundAssignment': return this.evalCompoundAssignment(node, env);
-      case 'SldeployStatement': return this.evalSldeploy(node, env);
-      case 'AskStatement': return this.evalAsk(node, env);
-      case 'DefineStatement': return this.evalDefine(node, env);
-      case 'ExpressionStatement': return this.evaluate(node.expression, env);
-      case 'BinaryExpression': return this.evalBinary(node, env);
-      case 'LogicalExpression': return this.evalLogical(node, env);
-      case 'UnaryExpression': return this.evalUnary(node, env);
-      case 'Literal': return node.value;
-      case 'Identifier': return env.get(node.name);
-      case 'IfStatement': return this.evalIf(node, env);
-      case 'WhileStatement': return this.evalWhile(node, env);
-      case 'ForStatement': return this.evalFor(node, env);
-      case 'BreakStatement': throw new BreakSignal();
-      case 'ContinueStatement': throw new ContinueSignal();
-      case 'ImportStatement': return this.evalImport(node, env);
-      case 'FunctionDeclaration': return this.evalFunctionDeclaration(node, env);
-      case 'CallExpression': return this.evalCall(node, env);
-      case 'ArrowFunctionExpression':
-  return this.evalArrowFunction(node, env);
-
-      case 'ReturnStatement': {
-        const val = node.argument ? this.evaluate(node.argument, env) : null;
-        throw new ReturnValue(val);
+async evaluate(node, env = this.global) {
+  switch (node.type) {
+    case 'Program': return await this.evalProgram(node, env);
+    case 'BlockStatement': return await this.evalBlock(node, new Environment(env));
+    case 'VarDeclaration': return await this.evalVarDeclaration(node, env);
+    case 'AssignmentExpression': return await this.evalAssignment(node, env);
+    case 'CompoundAssignment': return await this.evalCompoundAssignment(node, env);
+    case 'SldeployStatement': return await this.evalSldeploy(node, env);
+    case 'AskStatement': return await this.evalAsk(node, env);
+    case 'DefineStatement': return await this.evalDefine(node, env);
+    case 'ExpressionStatement': return await this.evaluate(node.expression, env);
+    case 'BinaryExpression': return await this.evalBinary(node, env);
+    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 'IfStatement': return await this.evalIf(node, env);
+    case 'WhileStatement': return await this.evalWhile(node, env);
+    case 'ForStatement': return await this.evalFor(node, env);
+    case 'BreakStatement': throw new BreakSignal();
+    case 'ContinueStatement': throw new ContinueSignal();
+    case 'ImportStatement': return await this.evalImport(node, env);
+    case 'FunctionDeclaration': return this.evalFunctionDeclaration(node, env);
+    case 'CallExpression': return await this.evalCall(node, env);
+    case 'ArrowFunctionExpression': return this.evalArrowFunction(node, env);
+    case 'ReturnStatement': {
+      const val = node.argument ? await this.evaluate(node.argument, env) : null;
+      throw new ReturnValue(val);
+    }
+   
+    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) {
+        out[p.key] = await this.evaluate(p.value, env);
       }
-      case 'ArrayExpression': return node.elements.map(el => this.evaluate(el, env));
-      case 'IndexExpression': return this.evalIndex(node, env);
-      case 'ObjectExpression': return this.evalObject(node, env);
-      case 'MemberExpression': return this.evalMember(node, env);
-      case 'UpdateExpression': return this.evalUpdate(node, env);
-      default:
-        throw new Error(`Unknown node type in evaluator: ${node.type}`);
+      return out;
     }
+    case 'MemberExpression': return await this.evalMember(node, env);
+    case 'UpdateExpression': return await this.evalUpdate(node, env);
+    case 'AwaitExpression': {
+      const val = await this.evaluate(node.argument, env);
+      return val;
+    }
+    default:
+      throw new Error(`Unknown node type in evaluator: ${node.type}`);
   }
+}
 
-  evalProgram(node, env) {
-    let result = null;
-    for (const stmt of node.body) {
-      result = this.evaluate(stmt, env);
-    }
-    return result;
+async evalProgram(node, env) {
+  let result = null;
+  for (const stmt of node.body) {
+    result = await this.evaluate(stmt, env);
   }
-evalImport(node, env) {
+  return result;
+}
+
+async evalImport(node, env) {
   const spec = node.path;
   let lib;
 
@@ -152,7 +189,7 @@ evalImport(node, env) {
     const ast = new Parser(tokens).parse();
 
     const moduleEnv = new Environment(env);
-    this.evaluate(ast, moduleEnv);
+    await this.evaluate(ast, moduleEnv);
 
     lib = {};
     for (const key of Object.keys(moduleEnv.store)) {
@@ -180,259 +217,265 @@ evalImport(node, env) {
   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;
-        throw e;
-      }
+async evalBlock(node, env) {
+  let result = null;
+  for (const stmt of node.body) {
+    try {
+      result = await this.evaluate(stmt, env);
+    } catch (e) {
+      if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
+      throw e;
     }
-    return result;
   }
+  return result;
+}
+
+async evalVarDeclaration(node, env) {
+  const val = await this.evaluate(node.expr, env);
+  return env.define(node.id, val);
+}
 
-  evalVarDeclaration(node, env) {
-    const val = this.evaluate(node.expr, env);
-    return env.define(node.id, val);
-  }
 evalArrowFunction(node, env) {
   return {
     params: node.params,
     body: node.body,
     env: env,
-    arrow: true
+    arrow: true,
+    async: node.async || false
   };
 }
 
-  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;
-    }
+async evalAssignment(node, env) {
+  const rightVal = await this.evaluate(node.right, env);
+  const left = node.left;
 
-    throw new Error('Invalid assignment target');
+  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;
   }
-
-  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);
-    else throw new Error('Invalid compound assignment target');
-
-    const rhs = this.evaluate(node.right, env);
-    let computed;
-    switch (node.operator) {
-      case 'PLUSEQ': computed = current + rhs; break;
-      case 'MINUSEQ': computed = current - rhs; break;
-      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');
-    }
-
-    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;
+  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;
   }
 
-  evalSldeploy(node, env) {
-    const val = this.evaluate(node.expr, env);
-    console.log(val);
-    return val;
-  }
+  throw new Error('Invalid assignment target');
+}
 
-  evalAsk(node, env) {
-    const prompt = this.evaluate(node.prompt, env);
-    const input = readlineSync.question(prompt + ' ');
-    return input;
+async evalCompoundAssignment(node, env) {
+  const left = node.left;
+  let current;
+
+  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');
+
+  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;
+    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');
   }
 
-  evalDefine(node, env) {
-    const val = node.expr ? this.evaluate(node.expr, env) : null;
-    return this.global.define(node.id, val);
-  }
+  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);
 
-  evalBinary(node, env) {
-    const l = this.evaluate(node.left, env);
-    const r = this.evaluate(node.right, env);
+  return computed;
+}
 
-    if (node.operator === 'SLASH' && r === 0) {
-        throw new Error('Division by zero');
-    }
+async evalSldeploy(node, env) {
+  const val = await this.evaluate(node.expr, env);
+  console.log(val);
+  return val;
+}
 
-    switch (node.operator) {
-        case 'PLUS': return l + r;
-        case 'MINUS': return l - r;
-        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 'LT': return l < r;
-        case 'LTE': return l <= r;
-        case 'GT': return l > r;
-        case 'GTE': return l >= r;
-        default: throw new Error(`Unknown binary operator ${node.operator}`);
-    }
+async evalAsk(node, env) {
+  const prompt = await this.evaluate(node.prompt, env);
+  const input = readlineSync.question(prompt + ' ');
+  return input;
+}
+
+async evalDefine(node, env) {
+  const val = node.expr ? await this.evaluate(node.expr, env) : null;
+  return this.global.define(node.id, val);
 }
 
+async evalBinary(node, env) {
+  const l = await this.evaluate(node.left, env);
+  const r = await this.evaluate(node.right, env);
 
-  evalLogical(node, env) {
-    const l = this.evaluate(node.left, env);
-    if (node.operator === 'AND') return l && this.evaluate(node.right, env);
-    if (node.operator === 'OR') return l || this.evaluate(node.right, env);
-    throw new Error(`Unknown logical operator ${node.operator}`);
+  if (node.operator === 'SLASH' && r === 0) {
+    throw new Error('Division by zero');
   }
 
-  evalUnary(node, env) {
-    const val = this.evaluate(node.argument, env);
-    switch (node.operator) {
-      case 'NOT': return !val;
-      case 'MINUS': return -val;
-      case 'PLUS': return +val;
-      default: throw new Error(`Unknown unary operator ${node.operator}`);
-    }
+  switch (node.operator) {
+    case 'PLUS': return l + r;
+    case 'MINUS': return l - r;
+    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 'LT': return l < r;
+    case 'LTE': return l <= r;
+    case 'GT': return l > r;
+    case 'GTE': return l >= r;
+    default: throw new Error(`Unknown binary operator ${node.operator}`);
   }
+}
 
-  evalIf(node, env) {
-    const test = this.evaluate(node.test, env);
-    if (test) return this.evaluate(node.consequent, env);
-    if (node.alternate) return this.evaluate(node.alternate, env);
-    return null;
+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}`);
+}
+
+async evalUnary(node, env) {
+  const val = await this.evaluate(node.argument, env);
+  switch (node.operator) {
+    case 'NOT': return !val;
+    case 'MINUS': return -val;
+    case 'PLUS': return +val;
+    default: throw new Error(`Unknown unary operator ${node.operator}`);
   }
+}
 
-  evalWhile(node, env) {
-    while (this.evaluate(node.test, env)) {
-      try { this.evaluate(node.body, env); }
-      catch (e) {
-        if (e instanceof BreakSignal) break;
-        if (e instanceof ContinueSignal) continue;
-        throw e;
-      }
+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);
+  return null;
+}
+
+async evalWhile(node, env) {
+  while (await this.evaluate(node.test, env)) {
+    try { await this.evaluate(node.body, env); }
+    catch (e) {
+      if (e instanceof BreakSignal) break;
+      if (e instanceof ContinueSignal) continue;
+      throw e;
     }
-    return null;
   }
+  return null;
+}
 
-  evalFor(node, env) {
-    const local = new Environment(env);
-    if (node.init) this.evaluate(node.init, local);
-    while (!node.test || this.evaluate(node.test, local)) {
-      try { this.evaluate(node.body, local); }
-      catch (e) {
-        if (e instanceof BreakSignal) break;
-        if (e instanceof ContinueSignal) { if (node.update) this.evaluate(node.update, local); continue; }
-        throw e;
+async evalFor(node, env) {
+  const local = new Environment(env);
+  if (node.init) await this.evaluate(node.init, local);
+  while (!node.test || await this.evaluate(node.test, local)) {
+    try { await this.evaluate(node.body, local); }
+    catch (e) {
+      if (e instanceof BreakSignal) break;
+      if (e instanceof ContinueSignal) {
+        if (node.update) await this.evaluate(node.update, local);
+        continue;
       }
-      if (node.update) this.evaluate(node.update, local);
+      throw e;
     }
-    return null;
-  }
-
-  evalFunctionDeclaration(node, env) {
-    const fn = { params: node.params, body: node.body, env };
-    env.define(node.name, fn);
-    return null;
+    if (node.update) await this.evaluate(node.update, local);
   }
+  return null;
+}
 
-  evalCall(node, env) {
-    const calleeEvaluated = this.evaluate(node.callee, env);
-    if (typeof calleeEvaluated === 'function') {
-      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');
-    }
-    const fn = calleeEvaluated;
-    const callEnv = new Environment(fn.env);
-    fn.params.forEach((p, i) => {
-      const argVal = node.arguments[i] ? this.evaluate(node.arguments[i], env) : null;
-      callEnv.define(p, argVal);
-    });
-    try {
-  const result = this.evaluate(fn.body, callEnv);
-  return fn.arrow ? result : result;
-} catch (e) {
-  if (e instanceof ReturnValue) return e.value;
-  throw e;
+evalFunctionDeclaration(node, env) {
+  const fn = { params: node.params, body: node.body, env, async: node.async || false };
+  env.define(node.name, fn);
+  return null;
 }
 
+async evalCall(node, env) {
+  const calleeEvaluated = await this.evaluate(node.callee, env);
+  if (typeof calleeEvaluated === 'function') {
+    const args = [];
+    for (const a of node.arguments) args.push(await this.evaluate(a, env));
+    return calleeEvaluated(...args);
+  }
+  if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
+    throw new Error('Call to non-function');
   }
 
-  evalIndex(node, env) {
-    const obj = this.evaluate(node.object, env);
-    const idx = this.evaluate(node.indexer, env);
+  const fn = calleeEvaluated;
+  const callEnv = new Environment(fn.env);
 
-    if (obj == null) throw new Error('Indexing null or undefined');
-    if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-        throw new Error('Array index out of bounds');
-    }
-    if (typeof obj === 'object' && !(idx in obj)) {
-        throw new Error(`Property '${idx}' does not exist`);
-    }
+  for (let i = 0; i < fn.params.length; i++) {
+    const argVal = node.arguments[i] ? await this.evaluate(node.arguments[i], env) : null;
+    callEnv.define(fn.params[i], argVal);
+  }
 
-    return obj[idx];
+  try {
+    const result = await this.evaluate(fn.body, callEnv);
+    return fn.arrow ? result : result;
+  } catch (e) {
+    if (e instanceof ReturnValue) return e.value;
+    throw e;
+  }
 }
 
+async evalIndex(node, env) {
+  const obj = await this.evaluate(node.object, env);
+  const idx = await this.evaluate(node.indexer, env);
 
-  evalObject(node, env) {
-    const out = {};
-    for (const p of node.props) out[p.key] = this.evaluate(p.value, env);
-    return out;
+  if (obj == null) throw new Error('Indexing null or undefined');
+  if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
+    throw new Error('Array index out of bounds');
+  }
+  if (typeof obj === 'object' && !(idx in obj)) {
+    throw new Error(`Property '${idx}' does not exist`);
   }
 
-  evalMember(node, env) {
-    const obj = 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`);
-    return obj[node.property];
+  return obj[idx];
 }
 
+async evalObject(node, env) {
+  const out = {};
+  for (const p of node.props) out[p.key] = await this.evaluate(p.value, env);
+  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`);
+  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 === 'MemberExpression') return await this.evalMember(arg, env);
+    if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
+    throw new Error('Invalid update target');
+  };
+  const setValue = async (v) => {
+    if (arg.type === 'Identifier') env.set(arg.name, v);
+    else if (arg.type === 'MemberExpression') {
+      const obj = await this.evaluate(arg.object, env);
+      obj[arg.property] = v;
+    } else if (arg.type === 'IndexExpression') {
+      const obj = await this.evaluate(arg.object, env);
+      const idx = await this.evaluate(arg.indexer, env);
+      obj[idx] = v;
+    }
+  };
+
+  const current = await getCurrent();
+  const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
+
+  if (node.prefix) { await setValue(newVal); return newVal; }
+  else { await setValue(newVal); return current; }
+}
 
-  evalUpdate(node, env) {
-    const arg = node.argument;
-    const getCurrent = () => {
-      if (arg.type === 'Identifier') return env.get(arg.name);
-      if (arg.type === 'MemberExpression') return this.evalMember(arg, env);
-      if (arg.type === 'IndexExpression') return this.evalIndex(arg, env);
-      throw new Error('Invalid update target');
-    };
-    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;
-      }
-    };
-    const current = getCurrent();
-    const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
-    if (node.prefix) { setValue(newVal); return newVal; }
-    else { setValue(newVal); return current; }
-  }
 }
 
-module.exports = Evaluator; 
+module.exports = Evaluator;  

package/src/lexer.js

@@ -79,10 +79,13 @@ class Lexer {
     }
 
     const keywords = [
-      'let', 'sldeploy', 'if', 'else', 'while', 'for',
-      'break', 'continue', 'func', 'return', 'true', 'false', 'null',
-      'ask', 'define', 'import', 'from', 'as'
-    ];
+  'let', 'sldeploy', 'if', 'else', 'while', 'for',
+  'break', 'continue', 'func', 'return',
+  'true', 'false', 'null',
+  'ask', 'define', 'import', 'from', 'as',
+  'async', 'await'
+];
+
 
     if (keywords.includes(result)) {
       return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };