fazer-lang 2.1.1 → 2.2.1

package/fazer.js

@@ -22,8 +22,8 @@ const Comment = createToken({ name: "Comment", pattern: /#[^\n]*/, group: Lexer.
 
 const Assign = createToken({ name: "Assign", pattern: /:=/ });
 
-const Arrow = createToken({ name: "Arrow", pattern: /→/ });
-const DoublePipe = createToken({ name: "DoublePipe", pattern: /→>/ });
+const Arrow = createToken({ name: "Arrow", pattern: /->|→/ });
+const DoublePipe = createToken({ name: "DoublePipe", pattern: /\|>|→>/ });
 
 const Case = createToken({ name: "Case", pattern: /case\b/ });
 const Else = createToken({ name: "Else", pattern: /else\b/ });
@@ -593,6 +593,8 @@ class FazerRuntime {
 
   _installStdlib(argv) {
     const { execFileSync } = require("child_process");
+    let WebSocket = null;
+    try { WebSocket = require("ws"); } catch (e) {}
 
     const ANSI = {
       reset: "\x1b[0m",
@@ -710,6 +712,7 @@ class FazerRuntime {
     const cwdFn = () => process.cwd();
 
     const http = require("http");
+    const https = require("https");
     const child_process = require("child_process");
 
     // register builtins in global scope
@@ -723,7 +726,10 @@ class FazerRuntime {
         try {
           while (true) {
             const n = fs.readSync(0, buf, 0, 1, null);
-            if (n === 0) break;
+            if (n === 0) {
+              if (str === "") return null;
+              break;
+            }
             const c = buf.toString();
             if (c === "\r") continue;
             if (c === "\n") break;
@@ -784,7 +790,7 @@ class FazerRuntime {
       },
       
       server: (port, handlerName) => {
-        const srv = http.createServer((req, res) => {
+        const srv = http.createServer(async (req, res) => {
            // We need to call the Fazer function `handlerName`
            // But `this._call` requires scope context.
            // This is tricky in a sync interpreter loop.
@@ -811,7 +817,7 @@ class FazerRuntime {
            try {
              const inner = new Scope(fn.closure);
              inner.set(fn.params[0], reqObj, true); 
-             const result = this._execBlock(fn.body, inner);
+             const result = await this._execBlock(fn.body, inner);
              const out = (result instanceof ReturnSignal) ? result.value : result;
              
              const status = (out && out.status) || 200;
@@ -830,6 +836,70 @@ class FazerRuntime {
         console.log(`Server listening on port ${port}`);
       },
 
+      sleep: (ms) => new Promise((resolve) => setTimeout(resolve, Number(ms))),
+      
+      fetch: async (url, opts = {}) => {
+        return new Promise((resolve, reject) => {
+           const req = https.request(url, { method: opts.method || "GET", headers: opts.headers || {} }, (res) => {
+             let data = "";
+             res.on("data", (chunk) => data += chunk);
+             res.on("end", () => resolve({ status: res.statusCode, body: data, headers: res.headers }));
+           });
+           req.on("error", reject);
+           if (opts.body) req.write(String(opts.body));
+           req.end();
+        });
+      },
+
+      discord: (token) => {
+        if (!WebSocket) throw new FazerError("WebSocket module (ws) not found. Install it to use discord.");
+        const listeners = {};
+        const ws = new WebSocket("wss://gateway.discord.gg/?v=10&encoding=json");
+        
+        ws.on("open", () => {
+          ws.send(JSON.stringify({
+            op: 2,
+            d: { token: String(token), intents: 33280, properties: { os: "fazer", browser: "fazer", device: "fazer" } }
+          }));
+        });
+        
+        ws.on("message", async (data) => {
+           const p = JSON.parse(data);
+           if (p.op === 10) {
+             setInterval(() => ws.send(JSON.stringify({ op: 1, d: null })), p.d.heartbeat_interval);
+           }
+           if (p.t === "MESSAGE_CREATE") {
+             const handlers = listeners["message"];
+             if (handlers) {
+               for (const fn of handlers) {
+                 try {
+                   await this._call(fn, [p.d], this.global);
+                 } catch (e) { console.error("Discord handler error:", e); }
+               }
+             }
+           }
+        });
+        
+        return {
+          on: (ev, fn) => { listeners[ev] = listeners[ev] || []; listeners[ev].push(fn); },
+          send: async (chanId, content) => {
+             const body = JSON.stringify({ content: String(content) });
+             return new Promise((resolve) => {
+                const req = https.request(`https://discord.com/api/v10/channels/${chanId}/messages`, {
+                  method: "POST",
+                  headers: { "Authorization": `Bot ${token}`, "Content-Type": "application/json" }
+                }, (res) => {
+                  let d = "";
+                  res.on("data", c => d += c);
+                  res.on("end", () => resolve(JSON.parse(d)));
+                });
+                req.write(body);
+                req.end();
+             });
+          }
+        };
+      },
+
       argv: argvFn,
       env: envFn,
       cwd: cwdFn,
@@ -840,28 +910,28 @@ class FazerRuntime {
     for (const [k, v] of Object.entries(builtins)) this.global.set(k, v, false);
   }
 
-  run(ast) {
+  async run(ast) {
     try {
-      return this._execBlock(ast, this.global);
+      return await this._execBlock(ast, this.global);
     } catch (e) {
       throw e;
     }
   }
 
-  _execBlock(stmts, scope) {
+  async _execBlock(stmts, scope) {
     let last = null;
     for (const s of stmts) {
-      const v = this._execStmt(s, scope);
+      const v = await this._execStmt(s, scope);
       if (v instanceof ReturnSignal) return v;
       last = v;
     }
     return last;
   }
 
-  _execStmt(stmt, scope) {
+  async _execStmt(stmt, scope) {
     switch (stmt.type) {
       case "assign": {
-        const val = this._eval(stmt.value, scope);
+        const val = await this._eval(stmt.value, scope);
         if (scope.hasHere(stmt.name)) {
           scope.assign(stmt.name, val);
         } else {
@@ -870,7 +940,7 @@ class FazerRuntime {
         return val;
       }
       case "exprstmt":
-        return this._eval(stmt.expr, scope);
+        return await this._eval(stmt.expr, scope);
 
       case "fn": {
         this.fns.set(stmt.name, { params: stmt.params, body: stmt.body, closure: scope });
@@ -879,18 +949,18 @@ class FazerRuntime {
       }
 
       case "return": {
-        const v = stmt.value ? this._eval(stmt.value, scope) : null;
+        const v = stmt.value ? await this._eval(stmt.value, scope) : null;
         return new ReturnSignal(v);
       }
 
       case "case": {
-        const val = this._eval(stmt.expr, scope);
+        const val = await this._eval(stmt.expr, scope);
         for (const arm of stmt.arms) {
-          const { matched, bindings } = this._matchPattern(val, arm.pat, scope);
+          const { matched, bindings } = await this._matchPattern(val, arm.pat, scope);
           if (matched) {
             const inner = new Scope(scope);
             for (const [k, v] of Object.entries(bindings)) inner.set(k, v, true);
-            const out = this._execBlock(arm.body, inner);
+            const out = await this._execBlock(arm.body, inner);
             if (out instanceof ReturnSignal) return out;
             return out;
           }
@@ -903,7 +973,7 @@ class FazerRuntime {
     }
   }
 
-  _eval(expr, scope) {
+  async _eval(expr, scope) {
     if (!expr) return null;
 
     switch (expr.type) {
@@ -915,14 +985,17 @@ class FazerRuntime {
       case "null":
         return null;
 
-      case "list":
-        return expr.items.map((it) => this._eval(it, scope));
+      case "list": {
+        const items = [];
+        for (const it of expr.items) items.push(await this._eval(it, scope));
+        return items;
+      }
 
       case "map": {
         const o = {};
         for (const ent of expr.entries) {
-          const k = this._eval(ent.key, scope);
-          o[String(k)] = this._eval(ent.value, scope);
+          const k = await this._eval(ent.key, scope);
+          o[String(k)] = await this._eval(ent.value, scope);
         }
         return o;
       }
@@ -931,33 +1004,31 @@ class FazerRuntime {
         const cell = scope.get(expr.name);
         if (!cell) throw new FazerError(`Undefined variable '${expr.name}'`);
         const v = cell.value;
-        // fnref is stored as {__fnref__: name} to avoid collisions with user objects
         if (v && typeof v === "object" && v.__fnref__) return v;
         return v;
       }
 
       case "un": {
-        const v = this._eval(expr.expr, scope);
+        const v = await this._eval(expr.expr, scope);
         if (expr.op === "not") return !truthy(v);
         if (expr.op === "-") return -Number(v);
         throw new FazerError(`Unknown unary op ${expr.op}`);
       }
 
       case "bin": {
-        // short-circuit for and/or
         if (expr.op === "and") {
-          const l = this._eval(expr.left, scope);
+          const l = await this._eval(expr.left, scope);
           if (!truthy(l)) return l;
-          return this._eval(expr.right, scope);
+          return await this._eval(expr.right, scope);
         }
         if (expr.op === "or") {
-          const l = this._eval(expr.left, scope);
+          const l = await this._eval(expr.left, scope);
           if (truthy(l)) return l;
-          return this._eval(expr.right, scope);
+          return await this._eval(expr.right, scope);
         }
 
-        const l = this._eval(expr.left, scope);
-        const r = this._eval(expr.right, scope);
+        const l = await this._eval(expr.left, scope);
+        const r = await this._eval(expr.right, scope);
 
         switch (expr.op) {
           case "+": return (typeof l === "string" || typeof r === "string") ? String(l) + String(r) : Number(l) + Number(r);
@@ -978,46 +1049,44 @@ class FazerRuntime {
       }
 
       case "get": {
-        const obj = this._eval(expr.obj, scope);
-        const key = this._eval(expr.key, scope);
+        const obj = await this._eval(expr.obj, scope);
+        const key = await this._eval(expr.key, scope);
         return (obj == null) ? null : obj[String(key)];
       }
 
       case "idx": {
-        const obj = this._eval(expr.obj, scope);
-        const idx = this._eval(expr.idx, scope);
+        const obj = await this._eval(expr.obj, scope);
+        const idx = await this._eval(expr.idx, scope);
         if (obj == null) return null;
         if (Array.isArray(obj)) return obj[Number(idx)];
         return obj[String(idx)];
       }
 
       case "call": {
-        const callee = this._eval(expr.callee, scope);
-        const args = expr.args.map((a) => this._eval(a, scope));
-        return this._call(callee, args, scope);
+        const callee = await this._eval(expr.callee, scope);
+        const args = [];
+        for (const a of expr.args) args.push(await this._eval(a, scope));
+        return await this._call(callee, args, scope);
       }
 
       case "pipe": {
-        // left →> right
-        // If right is a call: pass left as first arg
-        // If right is an identifier: treat as function name, call with left
-        // Otherwise: if right evaluates to function, call it with left
-        const leftVal = this._eval(expr.left, scope);
+        const leftVal = await this._eval(expr.left, scope);
         const rightNode = expr.right;
 
         if (rightNode.type === "call") {
-          const callee = this._eval(rightNode.callee, scope);
-          const args = [leftVal, ...rightNode.args.map((a) => this._eval(a, scope))];
-          return this._call(callee, args, scope);
+          const callee = await this._eval(rightNode.callee, scope);
+          const args = [leftVal];
+          for (const a of rightNode.args) args.push(await this._eval(a, scope));
+          return await this._call(callee, args, scope);
         }
 
         if (rightNode.type === "ident") {
-          const fn = this._eval(rightNode, scope);
-          return this._call(fn, [leftVal], scope);
+          const fn = await this._eval(rightNode, scope);
+          return await this._call(fn, [leftVal], scope);
         }
 
-        const fn = this._eval(rightNode, scope);
-        return this._call(fn, [leftVal], scope);
+        const fn = await this._eval(rightNode, scope);
+        return await this._call(fn, [leftVal], scope);
       }
 
       default:
@@ -1025,11 +1094,22 @@ class FazerRuntime {
     }
   }
 
-  _call(callee, args, scope) {
-    // builtin JS function
-    if (typeof callee === "function") return callee(...args);
+  async _call(callee, args, scope) {
+    if (typeof callee === "function") return await callee(...args);
+
+    // Support calling by string name (e.g. from callbacks stored as strings)
+    if (typeof callee === "string") {
+      if (this.fns.has(callee)) {
+        callee = { __fnref__: callee };
+      } else {
+        // Try to look up variable in scope, maybe it's a function ref
+        const cell = scope.get(callee);
+        if (cell && cell.value && cell.value.__fnref__) {
+            callee = cell.value;
+        }
+      }
+    }
 
-    // function reference stored as {__fnref__: "name"}
     if (callee && typeof callee === "object" && callee.__fnref__) {
       const name = callee.__fnref__;
       const fn = this.fns.get(name);
@@ -1039,7 +1119,7 @@ class FazerRuntime {
       }
       const inner = new Scope(fn.closure);
       for (let i = 0; i < fn.params.length; i++) inner.set(fn.params[i], args[i], true);
-      const out = this._execBlock(fn.body, inner);
+      const out = await this._execBlock(fn.body, inner);
       if (out instanceof ReturnSignal) return out.value;
       return out;
     }
@@ -1047,8 +1127,7 @@ class FazerRuntime {
     throw new FazerError(`Value is not callable`);
   }
 
-  _matchPattern(value, pat, scope) {
-    // returns { matched, bindings }
+  async _matchPattern(value, pat, scope) {
     if (!pat) return { matched: false, bindings: {} };
 
     if (pat.type === "else") return { matched: true, bindings: {} };
@@ -1059,24 +1138,25 @@ class FazerRuntime {
     }
 
     if (pat.type === "cmpPat") {
-      const rhs = this._eval(pat.rhs, scope);
-      const l = value;
-      const r = rhs;
-      switch (pat.op) {
-        case "==": return { matched: deepEqual(l, r), bindings: {} };
-        case "!=": return { matched: !deepEqual(l, r), bindings: {} };
-        case ">": return { matched: Number(l) > Number(r), bindings: {} };
-        case "<": return { matched: Number(l) < Number(r), bindings: {} };
-        case ">=": return { matched: Number(l) >= Number(r), bindings: {} };
-        case "<=": return { matched: Number(l) <= Number(r), bindings: {} };
-        default: return { matched: false, bindings: {} };
-      }
+      const rhs = await this._eval(pat.rhs, scope);
+      const op = pat.op;
+      let m = false;
+      if (op === "==") m = deepEqual(value, rhs);
+      else if (op === "!=") m = !deepEqual(value, rhs);
+      else if (op === ">") m = (value > rhs);
+      else if (op === "<") m = (value < rhs);
+      else if (op === ">=") m = (value >= rhs);
+      else if (op === "<=") m = (value <= rhs);
+      
+      return { matched: m, bindings: {} };
     }
 
-    // literal patterns
-    if (pat.type === "num" || pat.type === "str" || pat.type === "bool" || pat.type === "null") {
-      const p = pat.type === "null" ? null : pat.value;
-      return { matched: deepEqual(value, p), bindings: {} };
+    if (pat.type === "num" || pat.type === "str" || pat.type === "bool") {
+        return { matched: deepEqual(value, pat.value), bindings: {} };
+    }
+
+    if (pat.type === "null") {
+        return { matched: value === null, bindings: {} };
     }
 
     return { matched: false, bindings: {} };
@@ -1151,29 +1231,176 @@ function prettyError(err, filename, code) {
   ].join("\n");
 }
 
+/* ────────────────────────────────────────────────────────────────────────── */
+/* REPL                                                                         */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+async function repl() {
+  const readline = require("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "\x1b[36mfz>\x1b[0m "
+  });
+
+  const version = require("./package.json").version;
+  const arch = process.arch;
+  const platform = process.platform;
+  
+  process.title = `Fazer v${version}`;
+  
+  console.log(`Fazer v${version} (${platform}-${arch})`);
+  console.log(`Type "help", "copyright" or "license" for more information.`);
+  console.log(`Type "load('file.fz')" to execute a script.`);
+
+  const rt = new FazerRuntime({ filename: "<repl>", args: [] });
+
+  // Add a helper to run files
+  rt.global.set("load", (p) => {
+    const pAbs = path.resolve(String(p));
+    if (!fs.existsSync(pAbs)) throw new FazerError("File not found: " + p);
+    const code = fs.readFileSync(pAbs, "utf8");
+    const lex = lexer.tokenize(code);
+    if (lex.errors.length) throw new FazerError("Lexer error: " + lex.errors[0].message);
+    const parser = new FazerParser();
+    parser.input = lex.tokens;
+    const ast = parser.program();
+    if (parser.errors.length) throw new FazerError("Parser error: " + parser.errors[0].message);
+    return rt.run(ast);
+  }, false);
+
+  rl.prompt();
+
+  for await (const line of rl) {
+    const code = line.trim();
+    if (code === "exit") break;
+    if (code === "") {
+      rl.prompt();
+      continue;
+    }
+
+    try {
+      const lex = lexer.tokenize(code);
+      if (lex.errors.length) {
+        console.error("Syntax Error: " + lex.errors[0].message);
+      } else {
+        const parser = new FazerParser();
+        parser.input = lex.tokens;
+        const ast = parser.program();
+        
+        if (parser.errors.length) {
+           console.error("Parse Error: " + parser.errors[0].message);
+        } else {
+           // Execute with existing global scope
+           const res = await rt.run(ast);
+           if (res !== null && res !== undefined) {
+             const builtins = rt.global.get("__builtins__");
+             if (builtins && builtins.style) {
+                console.log(builtins.style(res, "green"));
+             } else {
+                console.log("\x1b[32m" + String(res) + "\x1b[0m");
+             }
+           }
+        }
+      }
+    } catch (e) {
+      console.error("\x1b[31mError: " + (e.message || e) + "\x1b[0m");
+    }
+    rl.prompt();
+  }
+}
+
 /* ────────────────────────────────────────────────────────────────────────── */
 /* CLI                                                                          */
 /* ────────────────────────────────────────────────────────────────────────── */
 
 function usage() {
-  console.log("Usage:");
-  console.log("  fazer run <file.fz> [-- args...]");
-  process.exit(1);
+  console.log(`
+Fazer v${require("./package.json").version} — The next-gen pipe-based language.
+
+Usage:
+  fazer                     Start interactive shell (REPL)
+  fazer <file.fz> [args...] Run a Fazer script
+  fazer run <file.fz>       Run a Fazer script (explicit)
+  
+Flags:
+  --help, -h                Show this help message
+  --version, -v             Show version
+  --license                 Show license information
+`);
+  process.exit(0);
+}
+
+function printLicense() {
+  console.log(`
+Fazer Language
+Copyright (c) 2026 L'EMPRISE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`);
+  process.exit(0);
 }
 
-function main() {
+async function main() {
   const argv = process.argv.slice(2);
-  if (argv.length === 0) usage();
+
+  if (argv.length === 0) {
+    await repl();
+    return;
+  }
 
   const cmd = argv[0];
 
-  if (cmd !== "run") usage();
-  const fileArg = argv[1];
-  if (!fileArg) usage();
+  if (cmd === "--help" || cmd === "-h") {
+    usage();
+  }
+  if (cmd === "--version" || cmd === "-v") {
+    console.log(`Fazer v${require("./package.json").version}`);
+    process.exit(0);
+  }
+  if (cmd === "--license") {
+    printLicense();
+  }
 
-  // forward args after "--" to the script
-  const sep = argv.indexOf("--");
-  const forwarded = sep >= 0 ? argv.slice(sep + 1) : [];
+  let fileArg = null;
+  let forwarded = [];
+
+  // Logic:
+  // 1. fazer run file.fz ...
+  // 2. fazer file.fz ...
+  
+  if (cmd === "run") {
+    fileArg = argv[1];
+    if (!fileArg) usage();
+    const sep = argv.indexOf("--");
+    forwarded = sep >= 0 ? argv.slice(sep + 1) : [];
+  } else {
+    // Check if cmd looks like a file or we treat it as one
+    if (cmd.endsWith(".fz") || fs.existsSync(cmd)) {
+      fileArg = cmd;
+      // All subsequent args are passed to script
+      forwarded = argv.slice(1);
+    } else {
+      console.error(`Unknown command or file not found: '${cmd}'\n`);
+      usage();
+    }
+  }
 
   const filePath = path.resolve(fileArg);
   if (!fs.existsSync(filePath)) {
@@ -1203,7 +1430,7 @@ function main() {
 
   const rt = new FazerRuntime({ argv: forwarded, filename: filePath, code });
   try {
-    rt.run(ast);
+    await rt.run(ast);
   } catch (err) {
     if (err instanceof FazerError) {
       console.error(prettyError(err, filePath, code));
@@ -1225,4 +1452,4 @@ module.exports = {
   locOf
 };
 
-if (require.main === module) main();
+if (require.main === module) main().catch(e => { console.error(e); process.exit(1); });

package/package.json

@@ -1,23 +1,25 @@
 {
   "name": "fazer-lang",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "description": "Fazer — A unique, high-performance scripting language with powerful pipe operators (→>) and batteries-included stdlib (crypto, http, fs, json).",
   "main": "fazer.js",
   "bin": {
     "fazer": "fazer.js"
   },
+  "files": [
+    "fazer.js",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
   "dependencies": {
-    "chevrotain": "^11.0.3"
-  },
-  "devDependencies": {
-    "esbuild": "^0.27.2",
-    "pkg": "^5.8.1",
-    "rcedit": "^5.0.2"
+    "chevrotain": "^11.0.3",
+    "ws": "^8.18.0"
   },
+  "devDependencies": {},
   "scripts": {
     "start": "node fazer.js",
-    "test": "node fazer.js run test.fz",
-    "build": "pkg fazer.js --targets node18-win-x64,node18-linux-x64 --output dist/fazer"
+    "test": "node fazer.js --version"
   },
   "keywords": [
     "fazer",

package/apply_icon.js

@@ -1,28 +0,0 @@
-const { rcedit } = require('rcedit');
-const path = require('path');
-
-async function main() {
-  const exePath = path.resolve(__dirname, '../FzEncrypt.exe');
-  const iconPath = path.resolve(__dirname, '../fazer.ico');
-
-  console.log(`Applying icon to: ${exePath}`);
-  console.log(`Using icon: ${iconPath}`);
-
-  try {
-    await rcedit(exePath, {
-      icon: iconPath,
-      'version-string': {
-        'CompanyName': 'Fazer Corp',
-        'FileDescription': 'Fz Encrypt',
-        'ProductName': 'Fz Encrypt',
-        'LegalCopyright': 'Copyright (c) 2026'
-      }
-    });
-    console.log('Icon applied successfully!');
-  } catch (error) {
-    console.error('Error applying icon:', error);
-    process.exit(1);
-  }
-}
-
-main();