fazer-lang 2.2.1 → 2.3.0

package/README.md

@@ -1,62 +1,49 @@
 # Fazer
 
-**Fazer** is a powerful, concise scripting language designed for automation, security, and data processing. It features a unique syntax with pipe operators (`→>`), pattern matching (`case`), and a batteries-included standard library.
+**Fazer** — Le langage de script nouvelle génération par **L'EMPRISE**.
+
+Conçu pour l'automatisation, la sécurité et le traitement de données, Fazer combine une syntaxe concise avec une bibliothèque standard "batteries included".
 
 ## Installation
 
-Install Fazer globally using npm:
+Installez Fazer globalement via npm :
 
 ```bash
 npm install -g fazer-lang
 ```
 
-## Usage
-
-Run the REPL (interactive mode):
+## Utilisation Rapide
 
+Lancer le REPL (mode interactif) :
 ```bash
 fazer
 ```
 
-Run a script:
-
+Exécuter un script :
 ```bash
-fazer my_script.fz
+fazer mon_script.fz
 ```
 
-## Features
-
-- **Pipe Operator**: Chain functions easily: `readText("in.txt") →> encText(pass) →> writeText("out.enc")`
-- **Pattern Matching**: Expressive control flow with `case`
-- **Batteries Included**: Built-in modules for:
-  - File System (`readText`, `writeText`, `ls`, `exists`)
-  - Cryptography (`aes-256-gcm`, `sha256`)
-  - Networking (`fetch`, `server`, `discord`)
-  - JSON (`json`, `parseJson`)
-  - System (`exec`, `env`, `argv`)
-- **Single File**: The runtime is compact and efficient.
-
-## Example
-
-```fazer
-fn main() →
-  println(style("Welcome to Fazer", "cyan"))
-  
-  files := ls(".")
-  println("Found " + len(files) + " files.")
-  
-  case exists("secret.txt")
-    true →
-      content := readText("secret.txt")
-      println("Secret content: " + content)
-    end
-    else → end
-  end
-end
-
-main()
-```
+## Documentation
+
+La documentation complète est disponible dans le dossier [`docs/`](./docs/README.md).
+
+*   [Guide de Démarrage](./docs/getting-started.md)
+*   [Syntaxe du Langage](./docs/syntax.md)
+*   [Bibliothèque Standard (Stdlib)](./docs/stdlib.md)
+*   [Exemples](./docs/examples.md)
+
+## Fonctionnalités Clés
+
+*   **Pipe Operator (`->>`)** : Enchaînez les opérations proprement.
+*   **Pattern Matching (`case`)** : Contrôle de flux expressif.
+*   **Sécurité Intégrée** : Chiffrement AES-256-GCM et SHA256 natifs.
+*   **Réseau & Web** : Client HTTP `fetch`, serveur web `server`, et module `discord`.
+*   **Système de Fichiers** : Manipulation simple et puissante.
+*   **Automation** : Gestion du presse-papier (`clipboard`), menus interactifs, et persistance (`db`).
+*   **Extensible** : Système de modules `import`.
 
-## License
+## Copyright
 
-MIT
+© 2024 **L'EMPRISE**. Tous droits réservés.
+Distribué sous licence MIT.

package/docs/README.md

@@ -0,0 +1,26 @@
+# Documentation Fazer
+
+Bienvenue dans la documentation officielle du langage **Fazer**.
+
+## Table des Matières
+
+1.  **[Guide de Démarrage](./getting-started.md)**
+    *   Installation
+    *   Votre premier script
+    *   Mode interactif (REPL)
+
+2.  **[Syntaxe du Langage](./syntax.md)**
+    *   Variables et Types
+    *   Opérateur Pipe (`->>`)
+    *   Contrôle de Flux (`case`)
+    *   Fonctions
+
+3.  **[Bibliothèque Standard (Stdlib)](./stdlib.md)**
+    *   E/S Console (`println`, `ask`...)
+    *   Système de Fichiers (`readText`, `writeText`...)
+    *   Chiffrement (`encText`, `sha256`...)
+    *   Réseau & Web (`server`, `fetch`, `discord`...)
+    *   Utilitaires (`json`, `exec`...)
+
+4.  **[Exemples](./examples.md)**
+    *   Scripts complets pour apprendre par l'exemple.

package/docs/examples.md

@@ -0,0 +1,60 @@
+# Exemples Fazer
+
+## 1. Hello World
+
+```fazer
+"Hello World" ->> println
+```
+
+## 2. Demander le nom
+
+```fazer
+"Quel est votre nom ? " ->> ask ->> println
+```
+
+## 3. Chiffrement de Fichier (Logique simplifiée)
+
+Ce script montre comment on pourrait structurer un outil de chiffrement.
+
+```fazer
+fn main () {
+  "1. Chiffrer" ->> println
+  "2. Déchiffrer" ->> println
+  "Choix : " ->> ask ->> case {
+    "1" : {
+      "Fichier à chiffrer : " ->> ask ->> enc_flow
+    }
+    "2" : {
+      "Fichier à déchiffrer : " ->> ask ->> dec_flow
+    }
+    _ : {
+      "Choix invalide" ->> println
+    }
+  }
+}
+
+fn enc_flow (path) {
+  path ->> exists ->> case {
+    true : {
+      "Mot de passe : " ->> ask ->> pass
+      path ->> readText ->> encText(pass) ->> saveText(path)
+      "Fichier chiffré !" ->> println
+    }
+    _ : { "Fichier introuvable" ->> println }
+  }
+}
+
+// Lancer le main
+main()
+```
+
+## 4. Serveur Web Simple
+
+```fazer
+fn handle_request (req) {
+  "<h1>Bienvenue sur Fazer Web</h1>" // Retourne le HTML
+}
+
+"Démarrage du serveur sur 8080..." ->> println
+8080 ->> server("handle_request")
+```

package/docs/getting-started.md

@@ -0,0 +1,46 @@
+# Guide de Démarrage
+
+## Installation
+
+La façon la plus simple d'installer Fazer est via NPM (Node Package Manager).
+
+```bash
+npm install -g fazer-lang
+```
+
+Vérifiez l'installation :
+
+```bash
+fazer --version
+```
+
+## Votre Premier Script
+
+Créez un fichier nommé `hello.fz` avec le contenu suivant :
+
+```fazer
+"Hello World!" ->> println
+```
+
+Exécutez-le via la ligne de commande :
+
+```bash
+fazer hello.fz
+```
+
+Vous devriez voir `Hello World!` s'afficher.
+
+## Le Mode Interactif (REPL)
+
+Si vous lancez `fazer` sans arguments, vous entrez dans le mode interactif. C'est idéal pour tester des petites lignes de code.
+
+```bash
+$ fazer
+Welcome to Fazer v2.2.1
+> 10 ->> println
+10
+> "test" ->> sha256 ->> println
+9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
+```
+
+Tapez `exit` ou faites `Ctrl+C` pour quitter.

package/docs/stdlib.md

@@ -0,0 +1,139 @@
+# Bibliothèque Standard (Stdlib)
+
+Fazer inclut une bibliothèque standard riche pour interagir avec le système, les fichiers, le réseau et plus encore.
+
+## Entrées / Sorties
+
+### `print(valeur)` / `println(valeur)`
+Affiche une valeur sur la sortie standard (console).
+
+### `input(message)`
+Affiche un message et attend une entrée utilisateur (retourne une chaîne).
+
+### `box(titre, contenu)`
+Affiche une boîte stylisée avec un titre et du contenu (texte ou liste).
+
+### `menu(options)`
+Affiche un menu interactif dans la console et retourne l'option choisie.
+```fazer
+choix := menu(["Option A", "Option B"])
+```
+
+### `style(texte, couleur)`
+Applique une couleur ANSI au texte pour l'affichage console.
+Couleurs : "red", "green", "blue", "yellow", "cyan", "magenta", "white", "bold", "dim".
+```fazer
+println(style("Succès !", "green"))
+```
+
+## Fichiers (File System)
+
+### `read(path)`
+Lit un fichier texte entier.
+
+### `write(path, content)`
+Écrit du contenu dans un fichier (écrase le fichier).
+
+### `exists(path)`
+Retourne `true` si le fichier ou dossier existe.
+
+### `readBytes(path)` / `writeBytes(path, b64)`
+Lecture/Écriture binaire (encodé en Base64).
+
+### `import(chemin)`
+Charge et exécute un autre script Fazer.
+```fazer
+import("utils.fz")
+```
+
+## Système & Exécution
+
+### `exec(cmd)`
+Exécute une commande shell et retourne la sortie (stdout) sous forme de chaîne.
+```fazer
+files := exec("ls -la")
+```
+
+### `notify(titre, message)`
+Affiche une notification système (Windows Toast).
+```fazer
+notify("Fazer", "Tâche terminée avec succès !")
+```
+
+### `clipboard`
+Objet global pour interagir avec le presse-papier système.
+*   `clipboard.read()` : Retourne le contenu texte du presse-papier.
+*   `clipboard.write(texte)` : Écrit du texte dans le presse-papier.
+
+### `sleep(ms)`
+Met le script en pause pour `ms` millisecondes.
+
+### `env(nom_var)`
+Lit une variable d'environnement.
+
+### `cwd()`
+Retourne le dossier de travail actuel.
+
+### `argv()`
+Retourne les arguments de la ligne de commande.
+
+## Réseau & Web
+
+### `fetch(url, options)`
+Effectue une requête HTTP. `options` est un objet (method, headers, body).
+Retourne `{ status, body, headers }`.
+
+### `server(port, handler)`
+Démarre un serveur HTTP simple.
+`handler` peut être une fonction qui prend `req` et retourne `res`, ou un objet de routage simple.
+```fazer
+fn handler(req) ->
+  "Hello from Fazer!"
+end
+server(8080, handler)
+```
+
+### `discord(token)`
+Crée un client Discord (Bot).
+*   `.on("message", fn)`
+*   `.send(channelId, content)`
+
+## Cryptographie
+
+### `sha256(texte)`
+Retourne le hash SHA-256 (hex).
+
+### `encrypt(texte, mot_de_passe)`
+Chiffre le texte avec AES-256-GCM (retourne Base64).
+
+### `decrypt(b64, mot_de_passe)`
+Déchiffre le texte.
+
+## JSON & Données
+
+### `json(obj)`
+Convertit un objet en chaîne JSON.
+
+### `parseJson(str)`
+Parse une chaîne JSON en objet.
+
+### `int(valeur)`
+Convertit une valeur en entier.
+
+### `float(valeur)`
+Convertit une valeur en nombre flottant.
+
+### `db(chemin_json)`
+Crée ou charge une base de données JSON persistante.
+Retourne un objet avec `.get(k)`, `.set(k, v)`, `.save()` et `.data()`.
+```fazer
+mydb := db("data.json")
+mydb.set("score", 100)
+mydb.save()
+```
+
+### `keys(obj)`
+Retourne les clés d'un objet JSON.
+
+### `get(obj, clé)`
+Récupère une valeur dans un objet/map.

package/docs/syntax.md

@@ -0,0 +1,86 @@
+# Syntaxe du Langage Fazer
+
+Fazer est un langage orienté flux. La plupart des opérations se font de gauche à droite via l'opérateur pipe.
+
+## Commentaires
+
+```fazer
+// Ceci est un commentaire sur une ligne
+```
+
+## Variables
+
+Il n'y a pas de mot-clé de déclaration explicite comme `var` ou `let` pour l'assignation simple dans le flux, mais vous pouvez nommer des valeurs dans des arguments de fonctions.
+
+Cependant, Fazer utilise principalement le passage de valeurs. Pour stocker des états globaux ou complexes, on utilise souvent des objets JSON ou la mémoire interne via `set`/`get`.
+
+```fazer
+// Exemple d'utilisation de set/get (mémoire clé-valeur)
+"ma_valeur" "cle" ->> set
+"cle" ->> get ->> println // Affiche "ma_valeur"
+```
+
+## Opérateur Pipe (`->>`)
+
+L'opérateur `->>` passe le résultat de l'expression de gauche comme **premier argument** de la fonction de droite.
+
+```fazer
+"Bonjour" ->> println
+// Équivalent à println("Bonjour") dans d'autres langages
+```
+
+Chaînage :
+
+```fazer
+"mot_de_passe" ->> sha256 ->> println
+```
+
+## Chaînes de Caractères et Nombres
+
+```fazer
+"Ceci est une chaîne"
+123
+12.34
+```
+
+## Fonctions (Définition)
+
+Fazer supporte la définition de fonctions nommées.
+
+```fazer
+fn ma_fonction (arg1) {
+  arg1 ->> println
+}
+
+"test" ->> ma_fonction
+```
+
+## Contrôle de Flux : `case`
+
+Fazer n'a pas de `if/else` traditionnel. Tout se fait via `case` (pattern matching).
+
+```fazer
+valeur ->> case {
+  "option1" : {
+    "C'est l'option 1" ->> println
+  }
+  "option2" : {
+    "C'est l'option 2" ->> println
+  }
+  _ : {
+    "Cas par défaut (wildcard)" ->> println
+  }
+}
+```
+
+### Conditionnelle (If-Else simulé)
+
+Pour faire un `if`, on matche souvent sur un booléen ou une valeur spécifique. Notez que Fazer évalue l'égalité stricte.
+
+```fazer
+// Exemple conceptuel
+variable ->> case {
+  "vrai" : { ... }
+  _ : { ... }
+}
+```

package/fazer.js

@@ -18,7 +18,7 @@ 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: /:=/ });
 
@@ -780,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 {
@@ -900,6 +902,166 @@ class FazerRuntime {
         };
       },
 
+      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,

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.3.0",
+  "description": "Fazer — The ultimate automation language. Batteries-included: 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