fazer-lang 2.1.2 → 2.3.0

package/fazer.js

@@ -18,12 +18,12 @@ const { Lexer, createToken, EmbeddedActionsParser } = require("chevrotain");
 /* ────────────────────────────────────────────────────────────────────────── */
 
 const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /[ \t\r\n]+/, group: Lexer.SKIPPED });
-const Comment = createToken({ name: "Comment", pattern: /#[^\n]*/, group: Lexer.SKIPPED });
+const Comment = createToken({ name: "Comment", pattern: /(#|\/\/)[^\n]*/, group: Lexer.SKIPPED });
 
 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;
@@ -774,6 +780,8 @@ class FazerRuntime {
       
       json: (x) => JSON.stringify(x, null, 2),
       parseJson: (s) => JSON.parse(s),
+      int: (x) => parseInt(String(x)) || 0,
+      float: (x) => parseFloat(String(x)) || 0.0,
       
       exec: (cmd) => {
         try {
@@ -784,7 +792,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 +819,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 +838,230 @@ 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();
+             });
+          }
+        };
+      },
+
+      import: async (p) => {
+        const pAbs = path.resolve(String(p));
+        if (!fs.existsSync(pAbs)) throw new FazerError("Module not found: " + p);
+        const code = fs.readFileSync(pAbs, "utf8");
+        const lex = lexer.tokenize(code);
+        if (lex.errors.length) throw new FazerError("Lexer error in module: " + 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 in module: " + parser.errors[0].message);
+        return await this._execBlock(ast, this.global);
+      },
+
+      db: (dbPath) => {
+        const absPath = path.resolve(String(dbPath));
+        let data = {};
+        if (fs.existsSync(absPath)) {
+            try { data = JSON.parse(fs.readFileSync(absPath, "utf8")); } catch(e) {}
+        }
+        return {
+            get: (k) => data[String(k)],
+            set: (k, v) => { data[String(k)] = v; return null; },
+            save: () => { fs.writeFileSync(absPath, JSON.stringify(data, null, 2), "utf8"); return null; },
+            data: () => data
+        };
+      },
+
+      clipboard: {
+         read: () => {
+             try {
+                 if (process.platform === "win32") {
+                     return require("child_process").execSync("powershell -command \"Get-Clipboard\"", {encoding: "utf8"}).trim();
+                 }
+                 return "";
+             } catch (e) { return ""; }
+         },
+         write: (s) => {
+             try {
+                 const str = String(s);
+                 if (process.platform === "win32") {
+                     require("child_process").execSync("powershell -command \"Set-Clipboard -Value '" + str.replace(/'/g, "''") + "'\"");
+                 }
+             } catch (e) {}
+             return null;
+         }
+      },
+      
+      menu: async (options) => {
+         if (!Array.isArray(options)) throw new FazerError("menu expects a list of options");
+         options.forEach((o, i) => console.log(`[${i+1}] ${o}`));
+         const readline = require("readline");
+         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+         return new Promise(resolve => {
+             rl.question("Choice > ", (ans) => {
+                 rl.close();
+                 const n = Number(ans);
+                 if (isNaN(n) || n < 1 || n > options.length) resolve(null);
+                 else resolve(options[n-1]);
+             });
+         });
+      },
+
+      notify: (title, message) => {
+         try {
+             if (process.platform === "win32") {
+                 const psScript = `
+                 [void] [System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
+                 $obj = New-Object System.Windows.Forms.NotifyIcon
+                 $obj.Icon = [System.Drawing.SystemIcons]::Information
+                 $obj.Visible = $true
+                 $obj.ShowBalloonTip(3000, "${String(title).replace(/"/g, '`"')}", "${String(message).replace(/"/g, '`"')}", [System.Windows.Forms.ToolTipIcon]::Info)
+                 Start-Sleep -s 3
+                 $obj.Visible = $false
+                 `;
+                 require("child_process").execSync("powershell -command \"" + psScript.replace(/\n/g, ";") + "\"");
+             }
+         } catch(e) {}
+         return null;
+      },
+
+      exec: (cmd) => {
+          try {
+              return require("child_process").execSync(String(cmd), { encoding: "utf8" }).trim();
+          } catch (e) {
+              throw new FazerError("exec failed: " + e.message);
+          }
+      },
+      
+      style: (text, color) => {
+         const codes = {
+             reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+             red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m",
+             blue: "\x1b[34m", magenta: "\x1b[35m", cyan: "\x1b[36m", white: "\x1b[37m"
+         };
+         return (codes[String(color)] || "") + String(text) + codes.reset;
+      },
+
+      server: async (port, handler) => {
+         const http = require("http");
+         const srv = http.createServer(async (req, res) => {
+             const bodyParts = [];
+             for await (const chunk of req) bodyParts.push(chunk);
+             const bodyStr = Buffer.concat(bodyParts).toString();
+             
+             const reqObj = {
+                 method: req.method,
+                 url: req.url,
+                 headers: req.headers,
+                 body: bodyStr
+             };
+             
+             try {
+                 let result = null;
+                 if (typeof handler === "object" && handler !== null && !handler.__fnref__) {
+                     const url = req.url.split("?")[0];
+                     if (handler[url]) {
+                         const h = handler[url];
+                         if (typeof h === "function" || (typeof h === "object" && h.__fnref__)) {
+                              result = await this._call(h, [reqObj], this.global);
+                         } else {
+                              result = h;
+                         }
+                     } else {
+                         result = { status: 404, body: "Not Found" };
+                     }
+                 } else {
+                     result = await this._call(handler, [reqObj], this.global);
+                 }
+                 
+                 let status = 200;
+                 let headers = { "Content-Type": "text/plain" };
+                 let resBody = "";
+                 
+                 if (typeof result === "object" && result !== null) {
+                     if (result.status) status = Number(result.status);
+                     if (result.headers) headers = { ...headers, ...result.headers };
+                     if (result.body) resBody = String(result.body);
+                     else if (result.status === undefined) resBody = JSON.stringify(result);
+                 } else {
+                     resBody = String(result);
+                 }
+                 
+                 res.writeHead(status, headers);
+                 res.end(resBody);
+             } catch (e) {
+                 res.writeHead(500);
+                 res.end("Internal Server Error: " + e.message);
+             }
+         });
+         
+         return new Promise((resolve) => {
+             srv.listen(Number(port), () => {
+                 console.log(`Server listening on port ${port}`);
+                 resolve({
+                     close: () => { srv.close(); return null; }
+                 });
+             });
+         });
+      },
+
       argv: argvFn,
       env: envFn,
       cwd: cwdFn,
@@ -840,28 +1072,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 +1102,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 +1111,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 +1135,7 @@ class FazerRuntime {
     }
   }
 
-  _eval(expr, scope) {
+  async _eval(expr, scope) {
     if (!expr) return null;
 
     switch (expr.type) {
@@ -915,14 +1147,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 +1166,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 +1211,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 +1256,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 +1281,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 +1289,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 +1300,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: {} };
+    }
+
+    if (pat.type === "num" || pat.type === "str" || pat.type === "bool") {
+        return { matched: deepEqual(value, pat.value), 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 === "null") {
+        return { matched: value === null, bindings: {} };
     }
 
     return { matched: false, bindings: {} };
@@ -1151,29 +1393,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 +1592,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 +1614,4 @@ module.exports = {
   locOf
 };
 
-if (require.main === module) main();
+if (require.main === module) main().catch(e => { console.error(e); process.exit(1); });