fazer-lang 2.2.1 → 2.4.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 DoublePipe = createToken({ name: "DoublePipe", pattern: /->>|\|>|→>/ });
 
 const Case = createToken({ name: "Case", pattern: /case\b/ });
 const Else = createToken({ name: "Else", pattern: /else\b/ });
@@ -158,7 +158,15 @@ class FazerParser extends EmbeddedActionsParser {
       $.OR([
         { ALT: () => $.SUBRULE($.fnDef) },
         { ALT: () => $.SUBRULE($.returnStmt) },
-        { ALT: () => $.SUBRULE($.assignStmt) },
+        {
+          GATE: () => {
+            const t1 = $.LA(1).tokenType;
+            if (t1 === Mut) return true;
+            const t2 = $.LA(2).tokenType;
+            return t1 === Identifier && t2 === Assign;
+          },
+          ALT: () => $.SUBRULE($.assignStmt)
+        },
         { ALT: () => $.SUBRULE($.caseBlock) },
         { ALT: () => $.SUBRULE($.exprStmt) },
       ])
@@ -203,7 +211,8 @@ class FazerParser extends EmbeddedActionsParser {
 
     $.RULE("caseBlock", () => {
       const caseTok = $.CONSUME(Case);
-      const expr = $.SUBRULE($.expression);
+      // Use addExpr to avoid consuming comparison operators (==, >, etc.) which start patterns
+      const expr = $.SUBRULE($.addExpr);
       const arms = [];
       $.AT_LEAST_ONE(() => {
         const pat = $.OR([
@@ -588,6 +597,7 @@ class FazerRuntime {
     this.code = code;
     this.global = new Scope(null);
     this.fns = new Map(); // name -> {params, body, closure}
+    this.native_ui_state = { widgets: [], updates: {} };
     this._installStdlib(argv);
   }
 
@@ -748,6 +758,111 @@ class FazerRuntime {
       writeText,
       saveText: (s, p) => { fs.writeFileSync(path.resolve(String(p)), String(s), "utf8"); return null; },
       exists: (p) => fs.existsSync(path.resolve(String(p))),
+      
+      // Core Utils (Standard Library)
+      fs_read: (p) => { try { return fs.readFileSync(path.resolve(String(p)), "utf8"); } catch(e) { return null; } },
+      fs_write: (p, c) => { try { fs.writeFileSync(path.resolve(String(p)), String(c)); return true; } catch(e) { return false; } },
+      fs_exists: (p) => fs.existsSync(path.resolve(String(p))),
+      
+          // Module System
+      import: async (p) => {
+          const pAbs = path.resolve(String(p));
+          if (!fs.existsSync(pAbs)) return null;
+          const code = fs.readFileSync(pAbs, "utf8");
+          const lex = lexer.tokenize(code);
+          if (lex.errors.length) throw new FazerError("Import 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("Import Parser Error: " + parser.errors[0].message);
+          
+          const rt = new FazerRuntime({ filename: pAbs, code });
+          await rt.run(ast);
+          
+          const exports = {};
+          console.log("Exporting vars from module...");
+          for (const [k, v] of rt.global.vars) {
+              console.log("Exporting:", k, v);
+              if (k === "__builtins__" || builtins[k]) continue; 
+              
+              let value = v.value;
+              // Handle functions: migrate definition to current runtime
+              if (value && typeof value === "object" && value.__fnref__) {
+                  const fnName = value.__fnref__;
+                  const fnDef = rt.fns.get(fnName);
+                  if (fnDef) {
+                      const uniqueName = `__import_${Math.floor(Math.random()*1000000)}_${fnName}`;
+                      // console.log("Importing function:", fnName, "->", uniqueName);
+                      this.fns.set(uniqueName, fnDef);
+                      value = { __fnref__: uniqueName };
+                  } else {
+                      // Debug log
+                      console.log("Warning: Function definition not found for", fnName);
+                  }
+              }
+              
+              exports[k] = value;
+          }
+          return exports;
+      },
+      
+      // Persistence (Simple JSON DB)
+      db_load: (p) => { try { return JSON.parse(fs.readFileSync(path.resolve(String(p)), "utf8")); } catch(e) { return {}; } },
+      db_save: (p, data) => { try { fs.writeFileSync(path.resolve(String(p)), JSON.stringify(data, null, 2)); return true; } catch(e) { return false; } },
+      
+      // System Automation
+      clipboard_set: (text) => {
+          if (process.platform === "win32") {
+              try {
+                  const script = `Set-Clipboard -Value '${String(text).replace(/'/g, "''")}'`;
+                  const b64 = Buffer.from(script, 'utf16le').toString('base64');
+                  child_process.execSync(`powershell -EncodedCommand ${b64}`);
+                  return true;
+              } catch(e) { return false; }
+          }
+          return false;
+      },
+      clipboard_get: () => {
+          if (process.platform === "win32") {
+              try { return child_process.execSync(`powershell -command "Get-Clipboard"`).toString().trim(); } catch(e) { return ""; }
+          }
+          return "";
+      },
+      notify: (title, msg) => {
+          if (process.platform === "win32") {
+              const cmd = `
+              [reflection.assembly]::loadwithpartialname("System.Windows.Forms");
+              [reflection.assembly]::loadwithpartialname("System.Drawing");
+              $n = new-object system.windows.forms.notifyicon;
+              $n.icon = [system.drawing.systemicons]::information;
+              $n.visible = $true;
+              $n.showballoontip(10, "${String(title).replace(/"/g, '`"')}", "${String(msg).replace(/"/g, '`"')}", [system.windows.forms.tooltipicon]::none);
+              Start-Sleep -s 3;
+              $n.Visible = $false;
+              `;
+              try {
+                  const b64 = Buffer.from(cmd, 'utf16le').toString('base64');
+                  child_process.execSync(`powershell -EncodedCommand ${b64}`);
+                  return true;
+              } catch(e) { return false; }
+          }
+          return false;
+      },
+      
+      json_parse: (s) => { try { return JSON.parse(String(s)); } catch(e) { return null; } },
+      json_stringify: (x) => JSON.stringify(x, null, 2),
+      
+      str_split: (s, d) => String(s).split(String(d)),
+      str_replace: (s, a, b) => String(s).split(String(a)).join(String(b)), // simple replace all
+      str_trim: (s) => String(s).trim(),
+      str_upper: (s) => String(s).toUpperCase(),
+      str_lower: (s) => String(s).toLowerCase(),
+      
+      random: () => Math.random(),
+      round: (x) => Math.round(Number(x)),
+      floor: (x) => Math.floor(Number(x)),
+      ceil: (x) => Math.ceil(Number(x)),
+      
       ls: (p) => { try { return fs.readdirSync(path.resolve(String(p || "."))); } catch(e) { return []; } },
       rm: (p) => { try { fs.rmSync(path.resolve(String(p)), { recursive: true, force: true }); return true; } catch(e) { return false; } },
       mkdir: (p) => { try { fs.mkdirSync(path.resolve(String(p)), { recursive: true }); return true; } catch(e) { return false; } },
@@ -780,6 +895,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 {
@@ -900,9 +1017,395 @@ class FazerRuntime {
         };
       },
 
+
+      
+      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]);
+             });
+         });
+      },
+
+
+
+      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; }
+                 });
+             });
+             srv.on('error', (e) => {
+                 if (e.code === 'EADDRINUSE') {
+                     console.error(`Error: Port ${port} is already in use.`);
+                 } else {
+                     console.error(`Server error: ${e.message}`);
+                 }
+                 resolve(null); // Resolve with null to avoid crashing
+             });
+         });
+      },
+
+      // --- NATIVE UI (WinForms) ---
+      
+      window: (title, w, h, icon) => {
+          this.native_ui_state.widgets = [{ type: 'window', title, w, h, icon }];
+          return "window";
+      },
+      
+      button: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'Button', id, text, x, y, w, h });
+          return id;
+      },
+      
+      label: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'Label', id, text, x, y, w, h });
+          return id;
+      },
+      
+      entry: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'TextBox', id, text, x, y, w, h });
+          return id;
+      },
+      
+      set_text: (id, val) => {
+          if (!this.native_ui_state.updates.set_text) this.native_ui_state.updates.set_text = {};
+          this.native_ui_state.updates.set_text[id] = val;
+          return val;
+      },
+      
+      msgbox: (msg) => {
+           this.native_ui_state.updates.msgbox = String(msg);
+           return true;
+      },
+
+      gui: async (handler) => {
+         if (process.platform !== 'win32') throw new FazerError("Native GUI is Windows only.");
+         
+         const http = require("http");
+         const port = await new Promise(r => {
+             const s = http.createServer();
+             s.listen(0, () => {
+                 const p = s.address().port;
+                 s.close(() => r(p));
+             });
+         });
+     
+         const srv = http.createServer(async (req, res) => {
+              if (req.method === "POST" && req.url === "/event") {
+                  let body = "";
+                  for await (const chunk of req) body += chunk;
+                  try {
+                      const event = JSON.parse(body);
+                      this.native_ui_state.updates = {}; // Reset
+                      
+                      if (handler) {
+                          await this._call(handler, [event], this.global);
+                      }
+                      
+                      res.writeHead(200, { "Content-Type": "application/json" });
+                      res.end(JSON.stringify(this.native_ui_state.updates));
+                  } catch(e) {
+                      console.error(e);
+                      res.writeHead(500); res.end("{}");
+                  }
+              }
+         });
+         
+         srv.listen(port);
+     
+         // Generate PowerShell Script
+         let ps = `
+         Add-Type -AssemblyName System.Windows.Forms
+         Add-Type -AssemblyName System.Drawing
+         $url = "http://localhost:${port}/event"
+         
+         function Send-Event($id, $type, $val) {
+             $body = @{id=$id; type=$type; value=$val} | ConvertTo-Json -Compress
+             try {
+                 $res = Invoke-RestMethod -Uri $url -Method POST -Body $body -ContentType "application/json"
+                 if ($res.set_text) {
+                     foreach($k in $res.set_text.PSObject.Properties) {
+                         $c = $form.Controls.Find($k.Name, $true)
+                         if ($c) { $c[0].Text = $k.Value }
+                     }
+                 }
+                 if ($res.msgbox) { [System.Windows.Forms.MessageBox]::Show($res.msgbox) }
+             } catch {}
+         }
+         `;
+     
+         const widgets = this.native_ui_state.widgets;
+         const win = widgets.find(w => w.type === 'window');
+         if (!win) throw new FazerError("No window defined. Use window().");
+         
+         let iconCmd = "";
+         if (win.icon) {
+             const iconAbs = require('path').resolve(String(win.icon));
+             const iconPath = iconAbs.replace(/\\/g, '\\\\'); 
+             if (require('fs').existsSync(iconAbs)) {
+                 if (String(win.icon).endsWith(".ico")) {
+                    iconCmd = `$form.Icon = New-Object System.Drawing.Icon("${iconPath}")`;
+                 } else {
+                    iconCmd = `$form.Icon = [System.Drawing.Icon]::ExtractAssociatedIcon("${iconPath}")`;
+                 }
+             }
+         }
+     
+         ps += `
+         $form = New-Object System.Windows.Forms.Form
+         $form.Text = "${win.title}"
+         ${iconCmd}
+         $form.Width = ${win.w}
+         $form.Height = ${win.h}
+         $form.StartPosition = "CenterScreen"
+         $form.BackColor = [System.Drawing.Color]::FromArgb(30, 30, 30)
+         $form.ForeColor = [System.Drawing.Color]::White
+         `;
+     
+         for (const w of widgets) {
+             if (w.type === 'window') continue;
+             ps += `
+             $${w.id} = New-Object System.Windows.Forms.${w.cls}
+             $${w.id}.Name = "${w.id}"
+             $${w.id}.Text = "${w.text}"
+             $${w.id}.Left = ${w.x}
+             $${w.id}.Top = ${w.y}
+             $${w.id}.Width = ${w.w}
+             $${w.id}.Height = ${w.h}
+             $${w.id}.Font = New-Object System.Drawing.Font("Segoe UI", 10)
+             `;
+             
+             if (w.cls === 'Button') {
+                ps += `
+                $${w.id}.FlatStyle = "Flat"
+                $${w.id}.BackColor = [System.Drawing.Color]::FromArgb(60, 60, 60)
+                $${w.id}.FlatAppearance.BorderSize = 0
+                $${w.id}.Add_Click({ Send-Event "${w.id}" "click" "" })
+                `;
+            } else if (w.cls === 'TextBox') {
+                 ps += `
+                 $${w.id}.BorderStyle = "FixedSingle"
+                 $${w.id}.BackColor = [System.Drawing.Color]::FromArgb(50, 50, 50)
+                 $${w.id}.ForeColor = [System.Drawing.Color]::White
+                 $${w.id}.Add_TextChanged({ Send-Event "${w.id}" "change" $this.Text })
+                 `;
+            }
+             
+             ps += `$form.Controls.Add($${w.id})\n`;
+         }
+     
+         ps += `
+         [void]$form.ShowDialog()
+         `;
+     
+         // Run PS
+         const b64 = Buffer.from(ps, 'utf16le').toString('base64');
+         require('child_process').spawn('powershell', ['-EncodedCommand', b64], { stdio: 'inherit' });
+         
+         return new Promise(r => {}); 
+      },
+
       argv: argvFn,
       env: envFn,
       cwd: cwdFn,
+      input: (p) => builtins.ask(p),
+      nowMs: () => Date.now(),
+      
+      // --- EXTENDED FEATURES (Automation, State, DB) ---
+      
+      set: (obj, key, val) => {
+          if (obj && typeof obj === 'object') {
+              obj[key] = val;
+              return val;
+          }
+          return null;
+      },
+
+      clipboard_set: (text) => {
+          try {
+              if (process.platform === 'win32') {
+                  require('child_process').execSync(`echo ${String(text).replace(/[&|<>^]/g, '^$&')} | clip`);
+              } else {
+                  // TODO: Linux/Mac support
+              }
+              return true;
+          } catch(e) { return false; }
+      },
+
+      notify: (title, msg) => {
+          try {
+              if (process.platform === 'win32') {
+                  const script = `
+                  [void] [System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms");
+                  $objNotifyIcon = New-Object System.Windows.Forms.NotifyIcon;
+                  $objNotifyIcon.Icon = [System.Drawing.SystemIcons]::Information;
+                  $objNotifyIcon.Visible = $True;
+                  $objNotifyIcon.BalloonTipTitle = "${String(title).replace(/"/g, '`"')}";
+                  $objNotifyIcon.BalloonTipText = "${String(msg).replace(/"/g, '`"')}";
+                  $objNotifyIcon.ShowBalloonTip(5000);
+                  Start-Sleep -s 5;
+                  $objNotifyIcon.Dispose();
+                  `;
+                  require('child_process').exec(`powershell -Command "${script.replace(/\n/g, ' ')}"`);
+              }
+              return true;
+          } catch(e) { return false; }
+      },
+
+      db: (p) => {
+          const dbPath = path.resolve(String(p));
+          let data = {};
+          if (fs.existsSync(dbPath)) {
+              try { data = JSON.parse(fs.readFileSync(dbPath, "utf8")); } catch(e){}
+          }
+          
+          return {
+              get: (k) => data[k],
+              set: (k, v) => { 
+                  data[k] = v; 
+                  fs.writeFileSync(dbPath, JSON.stringify(data, null, 2)); 
+                  return v; 
+              },
+              all: () => data
+          };
+       },
+
+      import: async (p) => {
+         const fullPath = path.resolve(String(p));
+         if (!fs.existsSync(fullPath)) throw new FazerError(`Module not found: ${p}`);
+         const code = fs.readFileSync(fullPath, "utf8");
+         
+         const lexResult = lexer.tokenize(code);
+         if (lexResult.errors.length > 0) throw new FazerError(`Lexer error in ${p}: ${lexResult.errors[0].message}`);
+         
+         const parser = new FazerParser();
+         parser.input = lexResult.tokens;
+         const ast = parser.program();
+         if (parser.errors.length > 0) throw new FazerError(`Parser error in ${p}: ${parser.errors[0].message}`);
+         
+         const moduleScope = new Scope(this.global);
+         await this._execBlock(ast, moduleScope);
+         
+         const exports = {};
+         for(const [k, v] of moduleScope.vars) {
+             exports[k] = v.value;
+         }
+         return exports;
+      },
+
+      // File System
+      fs_read: (p) => {
+          try { return require("fs").readFileSync(String(p), "utf8"); } catch(e) { return null; }
+      },
+      fs_write: (p, c) => {
+          try { require("fs").writeFileSync(String(p), String(c)); return true; } catch(e) { return false; }
+      },
+      fs_append: (p, c) => {
+          try { require("fs").appendFileSync(String(p), String(c)); return true; } catch(e) { return false; }
+      },
+      fs_exists: (p) => {
+          try { return require("fs").existsSync(String(p)); } catch(e) { return false; }
+      },
+      
+      // JSON
+      json_parse: (s) => {
+          try { return JSON.parse(String(s)); } catch(e) { return null; }
+      },
+      json_stringify: (o) => {
+          try { return JSON.stringify(o, null, 2); } catch(e) { return null; }
+      },
+      
+      // String Utils
+      str_split: (s, d) => String(s).split(String(d)),
+      str_replace: (s, old, n) => String(s).split(String(old)).join(String(n)),
+      str_trim: (s) => String(s).trim(),
+      str_upper: (s) => String(s).toUpperCase(),
+      str_lower: (s) => String(s).toLowerCase(),
+      
+      // Math
+      random: () => Math.random(),
+      round: (n) => Math.round(Number(n)),
+      floor: (n) => Math.floor(Number(n)),
+      ceil: (n) => Math.ceil(Number(n)),
     };
 
     this.global.set("__builtins__", builtins, false);
@@ -1051,15 +1554,16 @@ class FazerRuntime {
       case "get": {
         const obj = await this._eval(expr.obj, scope);
         const key = await this._eval(expr.key, scope);
-        return (obj == null) ? null : obj[String(key)];
+        const v = (obj == null) ? null : obj[String(key)];
+        return v === undefined ? null : v;
       }
 
       case "idx": {
         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)];
+        if (Array.isArray(obj)) return obj[Number(idx)] === undefined ? null : obj[Number(idx)];
+        return obj[String(idx)] === undefined ? null : obj[String(idx)];
       }
 
       case "call": {
@@ -1385,6 +1889,16 @@ async function main() {
   // 1. fazer run file.fz ...
   // 2. fazer file.fz ...
   
+  if (cmd === "build") {
+    try {
+        const builder = require("./tools/builder.js");
+        await builder(argv[1], argv.slice(2));
+    } catch (e) {
+        console.error(e);
+    }
+    return;
+  }
+
   if (cmd === "run") {
     fileArg = argv[1];
     if (!fileArg) usage();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fazer-lang",
-  "version": "2.2.1",
-  "description": "Fazer — A unique, high-performance scripting language with powerful pipe operators (→>) and batteries-included stdlib (crypto, http, fs, json).",
+  "version": "2.4.0",
+  "description": "Fazer — The ultimate automation language. Batteries-included: Native EXE Build, Icons, HTTP Server, System Exec, Clipboard, Discord, Crypto, and Pipe Operators (->).",
   "main": "fazer.js",
   "bin": {
     "fazer": "fazer.js"
@@ -10,7 +10,8 @@
     "fazer.js",
     "README.md",
     "LICENSE",
-    "package.json"
+    "docs/",
+    "tools/"
   ],
   "dependencies": {
     "chevrotain": "^11.0.3",
@@ -29,12 +30,19 @@
     "pipe-operator",
     "functional",
     "secure",
-    "automation"
+    "automation",
+    "discord-bot",
+    "http-server",
+    "system-automation"
   ],
   "author": "Fazer Corp",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/viced/fazer-lang.git"
-  }
+  },
+  "bugs": {
+    "url": "https://github.com/viced/fazer-lang/issues"
+  },
+  "homepage": "https://github.com/viced/fazer-lang#readme"
 }

package/tools/announce.fz

@@ -0,0 +1,48 @@
+// tools/announce.fz
+webhook := "https://canary.discord.com/api/webhooks/1463728147202838652/vEd4MqqtYmAFg15GKX3FBxLYS1XImycormdOMwTa3Dbwcm6r8lYI3dfIWlZiLH2Dxq9e"
+
+fn send(title, desc, color) ->
+  payload := {
+    "embeds": [{
+      "title": title,
+      "description": desc,
+      "color": int(color),
+      "footer": { "text": "Fazer Automation System" }
+    }]
+  }
+
+  println("Envoi vers Discord...")
+  res := fetch(webhook, {
+    "method": "POST",
+    "headers": { "Content-Type": "application/json" },
+    "body": json(payload)
+  })
+  
+  case res.status >= 200 and res.status < 300
+    true -> println("Succès !") end
+    else -> println("Erreur " + res.status + ": " + res.body) end
+  end
+end
+
+a := argv()
+start := 1
+
+case len(a) <= start
+  true -> println("Usage: fazer tools/announce.fz \"Titre\" \"Description\" [color]") end
+  else ->
+    title := a[start]
+    desc := ""
+    case len(a) > start + 1
+      true -> desc := a[start + 1] end
+      else -> end
+    end
+    
+    color := 5763719
+    case len(a) > start + 2
+      true -> color := a[start + 2] end
+      else -> end
+    end
+    
+    send(title, desc, color)
+  end
+end