fazer-lang 0.1.0 → 2.1.0

package/fazer.js

@@ -1,175 +1,1228 @@
-const fs = require('fs');
-const path = require('path');
-const { Client, IntentsBitField } = require('discord.js'); // Pour Discord
-const { Lexer, Parser, createToken } = require('chevrotain'); // Pour vrai parser
-
-// Parser Chevrotain pour remplacer regex (plus robuste, évite fragilités)
-const Stash = createToken({ name: 'Stash', pattern: /stash/ });
-const Broadcast = createToken({ name: 'Broadcast', pattern: /broadcast/ });
-const Intersect = createToken({ name: 'Intersect', pattern: /intersect/ });
-const Detour = createToken({ name: 'Detour', pattern: /detour/ });
-const EndIntersect = createToken({ name: 'EndIntersect', pattern: /endintersect/ });
-const Flow = createToken({ name: 'Flow', pattern: /flow/ });
-const EndFlow = createToken({ name: 'EndFlow', pattern: /endflow/ });
-const Trigger = createToken({ name: 'Trigger', pattern: /trigger/ });
-const Risk = createToken({ name: 'Risk', pattern: /risk/ });
-const Patrol = createToken({ name: 'Patrol', pattern: /patrol/ });
-const EndPatrol = createToken({ name: 'EndPatrol', pattern: /endpatrol/ });
-const Parallel = createToken({ name: 'Parallel', pattern: /parallel streets/ });
-const EndParallel = createToken({ name: 'EndParallel', pattern: /endparallel/ });
-const Uhquali = createToken({ name: 'Uhquali', pattern: /uhquali/ });
-const Cooldown = createToken({ name: 'Cooldown', pattern: /cooldown/ });
-const Wait = createToken({ name: 'Wait', pattern: /wait/ });
-const Save = createToken({ name: 'Save', pattern: /save/ });
-const Load = createToken({ name: 'Load', pattern: /load/ });
-const Territory = createToken({ name: 'Territory', pattern: /territory/ });
-const Whitespace = createToken({ name: 'Whitespace', pattern: /\s+/, group: Lexer.SKIPPED });
-const Identifier = createToken({ name: 'Identifier', pattern: /\w+/ });
-const NumberLiteral = createToken({ name: 'NumberLiteral', pattern: /\d+/ });
-const StringLiteral = createToken({ name: 'StringLiteral', pattern: /"[^"]*"/ });
-const Comment = createToken({ name: 'Comment', pattern: /#.*/, group: Lexer.SKIPPED });
-
-// Lexer
-const fazerLexer = new Lexer([
-  Whitespace, Comment, Stash, Broadcast, Intersect, Detour, EndIntersect, Flow, EndFlow, Trigger, Risk,
-  Patrol, EndPatrol, Parallel, EndParallel, Uhquali, Cooldown, Wait, Save, Load, Territory,
-  Identifier, NumberLiteral, StringLiteral
-]);
-
-// Parser basique (extendable)
-class FazerParser extends Parser {
+#!/usr/bin/env node
+"use strict";
+
+/*
+  Fazer v2 — interpreter "batteries included"
+  - Chevrotain lexer/parser → AST
+  - Runtime with scopes, functions, pipes, lists/maps, property/index access
+  - Stdlib: fs/path/crypto/encoding/ui
+*/
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { Lexer, createToken, EmbeddedActionsParser } = require("chevrotain");
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Tokens                                                                     */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /[ \t\r\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 Case = createToken({ name: "Case", pattern: /case\b/ });
+const Else = createToken({ name: "Else", pattern: /else\b/ });
+const End = createToken({ name: "End", pattern: /end\b/ });
+
+const Fn = createToken({ name: "Fn", pattern: /fn\b/ });
+const Return = createToken({ name: "Return", pattern: /return\b/ });
+const Mut = createToken({ name: "Mut", pattern: /mut\b/ });
+
+const True = createToken({ name: "True", pattern: /true\b/ });
+const False = createToken({ name: "False", pattern: /false\b/ });
+const Null = createToken({ name: "Null", pattern: /null\b/ });
+
+const And = createToken({ name: "And", pattern: /and\b/ });
+const Or = createToken({ name: "Or", pattern: /or\b/ });
+const Not = createToken({ name: "Not", pattern: /not\b/ });
+
+const GreaterEq = createToken({ name: "GreaterEq", pattern: />=/ });
+const LessEq = createToken({ name: "LessEq", pattern: /<=/ });
+const Eq = createToken({ name: "Eq", pattern: /==/ });
+const NotEq = createToken({ name: "NotEq", pattern: /!=/ });
+const Greater = createToken({ name: "Greater", pattern: />/ });
+const Less = createToken({ name: "Less", pattern: /</ });
+
+const LParen = createToken({ name: "LParen", pattern: /\(/ });
+const RParen = createToken({ name: "RParen", pattern: /\)/ });
+const LBracket = createToken({ name: "LBracket", pattern: /\[/ });
+const RBracket = createToken({ name: "RBracket", pattern: /\]/ });
+const LBrace = createToken({ name: "LBrace", pattern: /{/ });
+const RBrace = createToken({ name: "RBrace", pattern: /}/ });
+
+const Colon = createToken({ name: "Colon", pattern: /:/ });
+const Comma = createToken({ name: "Comma", pattern: /,/ });
+const Dot = createToken({ name: "Dot", pattern: /\./ });
+
+const Plus = createToken({ name: "Plus", pattern: /\+/ });
+const Minus = createToken({ name: "Minus", pattern: /-/ });
+const Star = createToken({ name: "Star", pattern: /\*/ });
+const Slash = createToken({ name: "Slash", pattern: /\// });
+const Percent = createToken({ name: "Percent", pattern: /%/ });
+
+const Float = createToken({ name: "Float", pattern: /-?\d+\.\d+/ });
+const Integer = createToken({ name: "Integer", pattern: /-?\d+/ });
+const StringLiteral = createToken({
+  name: "StringLiteral",
+  pattern: /"([^"\\]|\\.)*"/,
+});
+
+const Identifier = createToken({
+  name: "Identifier",
+  pattern: /[a-zA-Z_][a-zA-Z0-9_]*/,
+});
+
+const allTokens = [
+  WhiteSpace,
+  Comment,
+
+  Assign,
+
+  DoublePipe,
+  Arrow,
+
+  Case,
+  Else,
+  End,
+
+  Fn,
+  Return,
+  Mut,
+
+  True,
+  False,
+  Null,
+
+  And,
+  Or,
+  Not,
+
+  GreaterEq,
+  LessEq,
+  Eq,
+  NotEq,
+  Greater,
+  Less,
+
+  LParen,
+  RParen,
+  LBracket,
+  RBracket,
+  LBrace,
+  RBrace,
+
+  Colon,
+  Comma,
+  Dot,
+
+  Plus,
+  Minus,
+  Star,
+  Slash,
+  Percent,
+
+  Float,
+  Integer,
+  StringLiteral,
+  Identifier,
+];
+
+const lexer = new Lexer(allTokens, { positionTracking: "full" });
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Parser → AST                                                               */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+class FazerParser extends EmbeddedActionsParser {
   constructor() {
-    super(fazerLexer.allTokens);
+    super(allTokens, { recoveryEnabled: true });
     const $ = this;
-    $.RULE('statement', () => {
+
+    const node = (type, props) => ({ type, ...props });
+
+    $.RULE("program", () => {
+      const stmts = [];
+      $.MANY(() => {
+        const s = $.SUBRULE($.statement);
+        if (s) stmts.push(s);
+      });
+      return stmts;
+    });
+
+    $.RULE("statement", () =>
+      $.OR([
+        { ALT: () => $.SUBRULE($.fnDef) },
+        { ALT: () => $.SUBRULE($.returnStmt) },
+        { ALT: () => $.SUBRULE($.assignStmt) },
+        { ALT: () => $.SUBRULE($.caseBlock) },
+        { ALT: () => $.SUBRULE($.exprStmt) },
+      ])
+    );
+
+    $.RULE("fnDef", () => {
+      $.CONSUME(Fn);
+      const nameTok = $.CONSUME(Identifier);
+      $.CONSUME(LParen);
+      const params = [];
+      $.OPTION(() => {
+        params.push($.CONSUME2(Identifier).image);
+        $.MANY(() => {
+          $.CONSUME(Comma);
+          params.push($.CONSUME3(Identifier).image);
+        });
+      });
+      $.CONSUME(RParen);
+      $.CONSUME(Arrow);
+      const body = $.SUBRULE($.block);
+      return node("fn", { name: nameTok.image, params, body, loc: locOf(nameTok) });
+    });
+
+    $.RULE("returnStmt", () => {
+      const tok = $.CONSUME(Return);
+      const value = $.OPTION(() => $.SUBRULE($.expression));
+      return node("return", { value: value ?? node("null", {}), loc: locOf(tok) });
+    });
+
+    $.RULE("assignStmt", () => {
+      const mutTok = $.OPTION(() => $.CONSUME(Mut));
+      const idTok = $.CONSUME(Identifier);
+      $.CONSUME(Assign);
+      const value = $.SUBRULE($.expression);
+      return node("assign", {
+        name: idTok.image,
+        mut: !!mutTok,
+        value,
+        loc: locOf(idTok),
+      });
+    });
+
+    $.RULE("caseBlock", () => {
+      const caseTok = $.CONSUME(Case);
+      const expr = $.SUBRULE($.expression);
+      const arms = [];
+      $.AT_LEAST_ONE(() => {
+        const pat = $.OR([
+          { ALT: () => $.SUBRULE($.pattern) },
+          { ALT: () => ( $.CONSUME(Else), node("else", {}) ) },
+        ]);
+        $.CONSUME(Arrow);
+        const body = $.SUBRULE($.block);
+        arms.push({ pat, body });
+      });
+      $.CONSUME(End);
+      return node("case", { expr, arms, loc: locOf(caseTok) });
+    });
+
+    $.RULE("block", () => {
+      const stmts = [];
+      $.MANY(() => {
+        const s = $.SUBRULE($.statement);
+        if (s) stmts.push(s);
+      });
+      $.CONSUME(End);
+      return stmts;
+    });
+
+    $.RULE("exprStmt", () => {
+      const expr = $.SUBRULE($.expression);
+      if (!expr) return node("noop", {});
+      return node("exprstmt", { expr, loc: expr.loc ?? null });
+    });
+
+    $.RULE("pattern", () =>
+      $.OR([
+        { ALT: () => $.SUBRULE($.patternCompare) },
+        { ALT: () => $.SUBRULE($.literal) },
+        { ALT: () => node("identPat", { name: $.CONSUME(Identifier).image }) }, // binds
+      ])
+    );
+
+    $.RULE("patternCompare", () => {
+      // Examples:
+      //   > 10
+      //   <= 3
+      const op = $.OR([
+        { ALT: () => $.CONSUME(GreaterEq).image },
+        { ALT: () => $.CONSUME(LessEq).image },
+        { ALT: () => $.CONSUME(Greater).image },
+        { ALT: () => $.CONSUME(Less).image },
+        { ALT: () => $.CONSUME(Eq).image },
+        { ALT: () => $.CONSUME(NotEq).image },
+      ]);
+      const rhs = $.SUBRULE($.expression);
+      return node("cmpPat", { op, rhs });
+    });
+
+    /* Expression precedence:
+      pipe →>   (lowest)
+      or
+      and
+      equality
+      relational
+      additive
+      multiplicative
+      unary
+      postfix (calls, dot, index)
+      primary
+    */
+
+    $.RULE("expression", () => $.SUBRULE($.pipeExpr));
+
+    $.RULE("pipeExpr", () => {
+      let left = $.SUBRULE($.orExpr);
+      $.MANY(() => {
+        $.CONSUME(DoublePipe);
+        const right = $.SUBRULE2($.orExpr);
+        left = node("pipe", { left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("orExpr", () => {
+      let left = $.SUBRULE($.andExpr);
+      $.MANY(() => {
+        $.CONSUME(Or);
+        const right = $.SUBRULE2($.andExpr);
+        left = node("bin", { op: "or", left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("andExpr", () => {
+      let left = $.SUBRULE($.eqExpr);
+      $.MANY(() => {
+        $.CONSUME(And);
+        const right = $.SUBRULE2($.eqExpr);
+        left = node("bin", { op: "and", left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("eqExpr", () => {
+      let left = $.SUBRULE($.relExpr);
+      $.MANY(() => {
+        const op = $.OR([
+          { ALT: () => $.CONSUME(Eq).image },
+          { ALT: () => $.CONSUME(NotEq).image },
+        ]);
+        const right = $.SUBRULE2($.relExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("relExpr", () => {
+      let left = $.SUBRULE($.addExpr);
+      $.MANY(() => {
+        const op = $.OR([
+          { ALT: () => $.CONSUME(GreaterEq).image },
+          { ALT: () => $.CONSUME(LessEq).image },
+          { ALT: () => $.CONSUME(Greater).image },
+          { ALT: () => $.CONSUME(Less).image },
+        ]);
+        const right = $.SUBRULE2($.addExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("addExpr", () => {
+      let left = $.SUBRULE($.mulExpr);
+      $.MANY(() => {
+        const op = $.OR([
+          { ALT: () => $.CONSUME(Plus).image },
+          { ALT: () => $.CONSUME(Minus).image },
+        ]);
+        const right = $.SUBRULE2($.mulExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("mulExpr", () => {
+      let left = $.SUBRULE($.unaryExpr);
+      $.MANY(() => {
+        const op = $.OR([
+          { ALT: () => $.CONSUME(Star).image },
+          { ALT: () => $.CONSUME(Slash).image },
+          { ALT: () => $.CONSUME(Percent).image },
+        ]);
+        const right = $.SUBRULE2($.unaryExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("unaryExpr", () =>
       $.OR([
-        { ALT: () => $.SUBRULE($.stashStmt) },
-        { ALT: () => $.SUBRULE($.broadcastStmt) },
-        // Ajoute les autres rules pour intersect, flow, etc.
-        { ALT: () => $.SUBRULE($.uhqualiStmt) },
-        { ALT: () => $.SUBRULE($.cooldownStmt) },
-        { ALT: () => $.SUBRULE($.waitStmt) },
-        { ALT: () => $.SUBRULE($.saveStmt) },
-        { ALT: () => $.SUBRULE($.loadStmt) },
-        { ALT: () => $.SUBRULE($.territoryStmt) },
-        // ... (extend pour les autres)
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Not);
+            const expr = $.SUBRULE($.unaryExpr);
+            return node("un", { op: "not", expr, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Minus);
+            const expr = $.SUBRULE2($.unaryExpr);
+            return node("un", { op: "-", expr, loc: locOf(tok) });
+          },
+        },
+        { ALT: () => $.SUBRULE($.postfixExpr) },
+      ])
+    );
+
+    $.RULE("postfixExpr", () => {
+      let base = $.SUBRULE($.primaryExpr);
+
+      $.MANY(() => {
+        $.OR([
+          {
+            ALT: () => {
+              // call: foo(a,b)
+              $.CONSUME(LParen);
+              const args = [];
+              $.OPTION(() => {
+                args.push($.SUBRULE($.expression));
+                $.MANY2(() => {
+                  $.CONSUME(Comma);
+                  args.push($.SUBRULE2($.expression));
+                });
+              });
+              $.CONSUME(RParen);
+              base = node("call", { callee: base, args, loc: base.loc ?? null });
+            },
+          },
+          {
+            ALT: () => {
+              // dot: obj.key
+              $.CONSUME(Dot);
+              const keyTok = $.CONSUME(Identifier);
+              base = node("get", { obj: base, key: node("str", { value: keyTok.image }), loc: base.loc ?? null });
+            },
+          },
+          {
+            ALT: () => {
+              // index: obj[expr]
+              $.CONSUME(LBracket);
+              const idx = $.SUBRULE3($.expression);
+              $.CONSUME(RBracket);
+              base = node("idx", { obj: base, idx, loc: base.loc ?? null });
+            },
+          },
+        ]);
+      });
+
+      return base;
+    });
+
+    $.RULE("primaryExpr", () =>
+      $.OR([
+        { ALT: () => $.SUBRULE($.literal) },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Identifier);
+            return node("ident", { name: tok.image, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            $.CONSUME(LParen);
+            const e = $.SUBRULE($.expression);
+            $.CONSUME(RParen);
+            return e;
+          },
+        },
+        { ALT: () => $.SUBRULE($.listLiteral) },
+        { ALT: () => $.SUBRULE($.mapLiteral) },
+      ])
+    );
+
+    $.RULE("literal", () =>
+      $.OR([
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Float);
+            return node("num", { value: Number(tok.image), loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Integer);
+            return node("num", { value: Number(tok.image), loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(StringLiteral);
+            return node("str", { value: unescapeString(tok.image), loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(True);
+            return node("bool", { value: true, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(False);
+            return node("bool", { value: false, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Null);
+            return node("null", { loc: locOf(tok) });
+          },
+        },
+      ])
+    );
+
+    $.RULE("listLiteral", () => {
+      const tok = $.CONSUME(LBracket);
+      const items = [];
+      $.OPTION(() => {
+        items.push($.SUBRULE($.expression));
+        $.MANY(() => {
+          $.CONSUME(Comma);
+          items.push($.SUBRULE2($.expression));
+        });
+      });
+      $.CONSUME(RBracket);
+      return node("list", { items, loc: locOf(tok) });
+    });
+
+    $.RULE("mapLiteral", () => {
+      const tok = $.CONSUME(LBrace);
+      const entries = [];
+      $.OPTION(() => {
+        entries.push($.SUBRULE($.mapEntry));
+        $.MANY(() => {
+          $.CONSUME(Comma);
+          entries.push($.SUBRULE2($.mapEntry));
+        });
+      });
+      $.CONSUME(RBrace);
+      return node("map", { entries, loc: locOf(tok) });
+    });
+
+    $.RULE("mapEntry", () => {
+      // key can be Identifier or String
+      const key = $.OR([
+        {
+          ALT: () => {
+            const t = $.CONSUME(StringLiteral);
+            return node("str", { value: unescapeString(t.image), loc: locOf(t) });
+          },
+        },
+        {
+          ALT: () => {
+            const t = $.CONSUME(Identifier);
+            return node("str", { value: t.image, loc: locOf(t) });
+          },
+        },
       ]);
+      $.CONSUME(Colon);
+      const value = $.SUBRULE($.expression);
+      return { key, value };
     });
-    // Ajoute rules pour chaque stmt (ex: stashStmt: consume(Stash) then Identifier etc.)
+
     this.performSelfAnalysis();
   }
 }
-const parser = new FazerParser();
 
-class FazerInterpreter {
-  constructor() {
-    this.variables = {};
-    this.functions = {};
-    this.cooldowns = {}; // { name: endTime }
-    this.discordClient = null; // Init Discord lazy
-  }
-
-  // Parse avec Chevrotain
-  parse(code) {
-    const lexResult = fazerLexer.tokenize(code);
-    parser.input = lexResult.tokens;
-    const cst = parser.statement(); // Parse top-level
-    if (parser.errors.length > 0) throw new Error(parser.errors[0].message);
-    return cst; // Retourne CST pour exécution
-  }
-
-  // Exécute (simplifié, étend pour full CST)
-  async executeBlock(lines, isAsync = false) {
-    // Pour l'instant, mix regex + chevrotain ; full chevrotain later
-    // ... (garde la logique précédente, mais parse chaque line avec lexer)
-    let i = 0;
-    const output = [];
-    while (i < lines.length) {
-      const line = lines[i].trim();
-      if (!line || line.startsWith('#')) { i++; continue; }
-
-      // Exemple pour uhquali
-      if (line.startsWith('uhquali event ')) {
-        const eventName = line.slice(13).trim().replace(/"/g, '');
-        const events = ['Win culture boost +20 cultural_rep', 'Lose -10, rival diss', 'Neutral vibe'];
-        const outcome = events[Math.floor(Math.random() * events.length)];
-        this.variables['cultural_rep'] = (this.variables['cultural_rep'] || 0) + (outcome.includes('+') ? 20 : outcome.includes('-') ? -10 : 0);
-        console.log(`Uhquali event "${eventName}": ${outcome}`);
-        output.push(outcome);
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Runtime                                                                     */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+class FazerError extends Error {
+  constructor(message, meta = {}) {
+    super(message);
+    this.name = "FazerError";
+    this.meta = meta;
+  }
+}
+
+class ReturnSignal {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Scope {
+  constructor(parent = null) {
+    this.parent = parent;
+    this.vars = new Map(); // name -> {value, mut}
+  }
+  hasHere(name) { return this.vars.has(name); }
+  get(name) {
+    if (this.vars.has(name)) return this.vars.get(name);
+    if (this.parent) return this.parent.get(name);
+    return null;
+  }
+  set(name, value, mut = false) {
+    this.vars.set(name, { value, mut });
+  }
+  assign(name, value) {
+    if (this.vars.has(name)) {
+      const cell = this.vars.get(name);
+      if (!cell.mut) throw new FazerError(`Variable '${name}' is immutable (use mut)`);
+      cell.value = value;
+      return;
+    }
+    if (this.parent) return this.parent.assign(name, value);
+    throw new FazerError(`Undefined variable '${name}'`);
+  }
+}
+
+class FazerRuntime {
+  constructor({ argv = process.argv.slice(2), filename = "<stdin>", code = "" } = {}) {
+    this.filename = filename;
+    this.code = code;
+    this.global = new Scope(null);
+    this.fns = new Map(); // name -> {params, body, closure}
+    this._installStdlib(argv);
+  }
+
+  _installStdlib(argv) {
+    const { execFileSync } = require("child_process");
+
+    const ANSI = {
+      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",
+      gray: "\x1b[90m",
+    };
+
+    const style = (s, c) => (ANSI[c] || "") + String(s) + ANSI.reset;
+
+    const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, "");
+
+    const box = (title, lines) => {
+      const arr = Array.isArray(lines) ? lines.map(String) : [String(lines)];
+      const all = [String(title), ...arr];
+      
+      const visibleLen = (s) => stripAnsi(s).length;
+      const w = Math.max(...all.map(visibleLen)) + 4;
+      
+      const top = "┌" + "─".repeat(w - 2) + "┐";
+      const bot = "└" + "─".repeat(w - 2) + "┘";
+      
+      const mid = all.map((l) => {
+        const vl = visibleLen(l);
+        const pad = w - 4 - vl;
+        return "│ " + l + " ".repeat(Math.max(0, pad)) + " │";
+      });
+      
+      console.log(top);
+      for (const m of mid) console.log(m);
+      console.log(bot);
+      return null;
+    };
+
+    const toBuf = (x, enc = "utf8") => {
+      if (Buffer.isBuffer(x)) return x;
+      if (typeof x === "string") return Buffer.from(x, enc);
+      return Buffer.from(String(x), enc);
+    };
+
+    const readText = (p) => fs.readFileSync(path.resolve(String(p)), "utf8");
+    const writeText = (p, s) => { fs.writeFileSync(path.resolve(String(p)), String(s), "utf8"); return null; };
+
+    const readBytesB64 = (p) => fs.readFileSync(path.resolve(String(p))).toString("base64");
+    const writeBytesB64 = (p, b64) => { fs.writeFileSync(path.resolve(String(p)), Buffer.from(String(b64), "base64")); return null; };
+
+    const hex = (buf) => Buffer.from(buf).toString("hex");
+    const b64 = (buf) => Buffer.from(buf).toString("base64");
+    const fromHex = (h) => Buffer.from(String(h), "hex");
+    const fromB64 = (b) => Buffer.from(String(b), "base64");
+
+    const sha256 = (x) => hex(crypto.createHash("sha256").update(toBuf(x)).digest());
+
+    // AES-256-GCM(payload): [salt16|iv12|tag16|ct...], base64-encoded
+    const encText = (plaintext, password) => {
+      const salt = crypto.randomBytes(16);
+      const key = crypto.scryptSync(String(password), salt, 32);
+      const iv = crypto.randomBytes(12);
+      const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+      const ct = Buffer.concat([cipher.update(String(plaintext), "utf8"), cipher.final()]);
+      const tag = cipher.getAuthTag();
+      return b64(Buffer.concat([salt, iv, tag, ct]));
+    };
+
+    const decText = (payloadB64, password) => {
+      const payload = fromB64(payloadB64);
+      if (payload.length < 16 + 12 + 16) throw new FazerError("Invalid encrypted payload");
+      const salt = payload.subarray(0, 16);
+      const iv = payload.subarray(16, 28);
+      const tag = payload.subarray(28, 44);
+      const ct = payload.subarray(44);
+      const key = crypto.scryptSync(String(password), salt, 32);
+      const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(tag);
+      const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+      return pt.toString("utf8");
+    };
+
+    const encB64 = (b64data, password) => encText(String(b64data), password);
+    const decB64 = (payloadB64, password) => decText(payloadB64, password);
+
+    const pathJoin = (...xs) => path.join(...xs.map(String));
+    const pathAbs = (p) => path.resolve(String(p));
+    const pathDir = (p) => path.dirname(String(p));
+    const pathBase = (p) => path.basename(String(p));
+
+    const nowMs = () => Date.now();
+    const len = (x) => (x == null ? 0 : (typeof x === "string" || Array.isArray(x)) ? x.length : (typeof x === "object" ? Object.keys(x).length : 0));
+
+    const keys = (o) => {
+      if (o == null || typeof o !== "object") return [];
+      return Object.keys(o);
+    };
+
+    const get = (o, k) => {
+      if (o == null) return null;
+      if (Array.isArray(o)) return o[Number(k)];
+      return o[String(k)];
+    };
+
+    const set = (o, k, v) => {
+      if (o == null || typeof o !== "object") throw new FazerError("set(obj,key,val) expects object/list");
+      if (Array.isArray(o)) { o[Number(k)] = v; return o; }
+      o[String(k)] = v; return o;
+    };
+
+    const argvFn = () => argv.slice();
+    const envFn = (k) => process.env[String(k)] ?? null;
+    const cwdFn = () => process.cwd();
+
+    const http = require("http");
+    const child_process = require("child_process");
+
+    // register builtins in global scope
+    const builtins = {
+      println: (x = "") => (console.log(String(x)), null),
+      print: (x = "") => (process.stdout.write(String(x)), null),
+      ask: (prompt = "") => {
+        process.stdout.write(String(prompt));
+        const buf = Buffer.alloc(1);
+        let str = "";
+        try {
+          while (true) {
+            const n = fs.readSync(0, buf, 0, 1, null);
+            if (n === 0) break;
+            const c = buf.toString();
+            if (c === "\r") continue;
+            if (c === "\n") break;
+            str += c;
+          }
+          return str;
+        } catch (e) {
+          return null;
+        }
+      },
+
+      style: (s, color) => style(s, String(color || "reset")),
+      box: (title, ...lines) => box(title, lines),
+
+      readText,
+      writeText,
+      saveText: (s, p) => { fs.writeFileSync(path.resolve(String(p)), String(s), "utf8"); return null; },
+      exists: (p) => fs.existsSync(path.resolve(String(p))),
+      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; } },
+      
+      readB64: readBytesB64,
+      writeB64: writeBytesB64,
+      saveB64: (s, p) => { fs.writeFileSync(path.resolve(String(p)), Buffer.from(String(s), "base64")); return null; },
+
+      sha256,
+      encText,
+      decText,
+      encB64,
+      decB64,
+
+      hex,
+      b64,
+      fromHex,
+      fromB64,
+
+      join: pathJoin,
+      abs: pathAbs,
+      dir: pathDir,
+      base: pathBase,
+
+      nowMs,
+      len,
+      keys,
+      get,
+      set,
+      
+      json: (x) => JSON.stringify(x, null, 2),
+      parseJson: (s) => JSON.parse(s),
+      
+      exec: (cmd) => {
+        try {
+          return child_process.execSync(String(cmd)).toString();
+        } catch (e) {
+          return null;
+        }
+      },
+      
+      server: (port, handlerName) => {
+        const srv = http.createServer((req, res) => {
+           // We need to call the Fazer function `handlerName`
+           // But `this._call` requires scope context.
+           // This is tricky in a sync interpreter loop.
+           // For now, simple static server or basic response?
+           // To do it properly, we need to invoke the runtime from the callback.
+           // Since we are inside the class, we can do it!
+           
+           // We need to find the function in `this.fns`
+           const fn = this.fns.get(handlerName);
+           if (!fn) {
+             res.writeHead(500);
+             res.end("Handler not found");
+             return;
+           }
+           
+           // Construct request object
+           const reqObj = {
+             method: req.method,
+             url: req.url,
+             headers: req.headers
+           };
+           
+           // Call handler(req) -> { status, body, headers }
+           try {
+             const inner = new Scope(fn.closure);
+             inner.set(fn.params[0], reqObj, true); 
+             const result = this._execBlock(fn.body, inner);
+             const out = (result instanceof ReturnSignal) ? result.value : result;
+             
+             const status = (out && out.status) || 200;
+             const body = (out && out.body) || "";
+             const headers = (out && out.headers) || {};
+             
+             res.writeHead(status, headers);
+             res.end(String(body));
+           } catch (e) {
+             console.error(e);
+             res.writeHead(500);
+             res.end("Internal Server Error");
+           }
+        });
+        srv.listen(Number(port));
+        console.log(`Server listening on port ${port}`);
+      },
+
+      argv: argvFn,
+      env: envFn,
+      cwd: cwdFn,
+    };
+
+    this.global.set("__builtins__", builtins, false);
+    // Also expose builtins as top-level identifiers (fast path)
+    for (const [k, v] of Object.entries(builtins)) this.global.set(k, v, false);
+  }
+
+  run(ast) {
+    try {
+      return this._execBlock(ast, this.global);
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  _execBlock(stmts, scope) {
+    let last = null;
+    for (const s of stmts) {
+      const v = this._execStmt(s, scope);
+      if (v instanceof ReturnSignal) return v;
+      last = v;
+    }
+    return last;
+  }
+
+  _execStmt(stmt, scope) {
+    switch (stmt.type) {
+      case "assign": {
+        const val = this._eval(stmt.value, scope);
+        if (scope.hasHere(stmt.name)) {
+          scope.assign(stmt.name, val);
+        } else {
+          scope.set(stmt.name, val, stmt.mut);
+        }
+        return val;
       }
+      case "exprstmt":
+        return this._eval(stmt.expr, scope);
 
-      // Cooldown
-      if (line.startsWith('cooldown ')) {
-        const [name, timeStr] = line.slice(9).trim().split(' ');
-        const time = this.parseTime(timeStr);
-        this.cooldowns[name] = Date.now() + time;
-        console.log(`Cooldown set for ${name}: ${timeStr}`);
+      case "fn": {
+        this.fns.set(stmt.name, { params: stmt.params, body: stmt.body, closure: scope });
+        scope.set(stmt.name, { __fnref__: stmt.name }, false);
+        return null;
       }
 
-      // Check cooldown in actions (ex: in heist, if (Date.now() < this.cooldowns['heist']) bust)
+      case "return": {
+        const v = stmt.value ? this._eval(stmt.value, scope) : null;
+        return new ReturnSignal(v);
+      }
+
+      case "case": {
+        const val = this._eval(stmt.expr, scope);
+        for (const arm of stmt.arms) {
+          const { matched, bindings } = 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);
+            if (out instanceof ReturnSignal) return out;
+            return out;
+          }
+        }
+        return null;
+      }
+
+      default:
+        throw new FazerError(`Unknown statement type: ${stmt.type}`);
+    }
+  }
+
+  _eval(expr, scope) {
+    if (!expr) return null;
+
+    switch (expr.type) {
+      case "num":
+      case "str":
+      case "bool":
+        return expr.value;
+
+      case "null":
+        return null;
 
-      // Wait
-      if (line.startsWith('wait ')) {
-        const timeStr = line.slice(5).trim();
-        const time = this.parseTime(timeStr);
-        await new Promise(resolve => setTimeout(resolve, time));
+      case "list":
+        return expr.items.map((it) => this._eval(it, scope));
+
+      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);
+        }
+        return o;
       }
 
-      // Save
-      if (line.startsWith('save ')) {
-        const name = line.slice(5).trim();
-        fs.writeFileSync(`${name}.json`, JSON.stringify(this.variables));
-        console.log(`State saved to ${name}.json`);
+      case "ident": {
+        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;
       }
 
-      // Load
-      if (line.startsWith('load ')) {
-        const name = line.slice(5).trim();
-        if (fs.existsSync(`${name}.json`)) {
-          this.variables = JSON.parse(fs.readFileSync(`${name}.json`, 'utf8'));
-          console.log(`State loaded from ${name}.json`);
+      case "un": {
+        const v = 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);
+          if (!truthy(l)) return l;
+          return this._eval(expr.right, scope);
+        }
+        if (expr.op === "or") {
+          const l = this._eval(expr.left, scope);
+          if (truthy(l)) return l;
+          return this._eval(expr.right, scope);
+        }
+
+        const l = this._eval(expr.left, scope);
+        const r = this._eval(expr.right, scope);
+
+        switch (expr.op) {
+          case "+": return (typeof l === "string" || typeof r === "string") ? String(l) + String(r) : Number(l) + Number(r);
+          case "-": return Number(l) - Number(r);
+          case "*": return Number(l) * Number(r);
+          case "/": return Number(l) / Number(r);
+          case "%": return Number(l) % Number(r);
+
+          case "==": return deepEqual(l, r);
+          case "!=": return !deepEqual(l, r);
+          case ">": return Number(l) > Number(r);
+          case "<": return Number(l) < Number(r);
+          case ">=": return Number(l) >= Number(r);
+          case "<=": return Number(l) <= Number(r);
+          default:
+            throw new FazerError(`Unknown binary op ${expr.op}`);
         }
       }
 
-      // Broadcast to Discord
-      if (line.startsWith('broadcast to discord ')) {
-        const [channelId, ...msgParts] = line.slice(20).trim().split(' ');
-        const message = msgParts.join(' ');
-        await this.sendToDiscord(channelId, this.evaluate(message));
+      case "get": {
+        const obj = this._eval(expr.obj, scope);
+        const key = this._eval(expr.key, scope);
+        return (obj == null) ? null : obj[String(key)];
       }
 
-      // Territory
-      if (line.startsWith('territory ')) {
-        const [name, action, key, value] = line.slice(10).trim().split(' ');
-        if (!this.variables[name]) this.variables[name] = {};
-        if (action === 'add') this.variables[name][key] = this.evaluate(value);
-        console.log(`Territory ${name} updated`);
+      case "idx": {
+        const obj = this._eval(expr.obj, scope);
+        const idx = this._eval(expr.idx, scope);
+        if (obj == null) return null;
+        if (Array.isArray(obj)) return obj[Number(idx)];
+        return obj[String(idx)];
       }
 
-      // ... (intègre le reste de la logique précédente pour intersect, risk, etc.)
+      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);
+      }
+
+      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 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);
+        }
+
+        if (rightNode.type === "ident") {
+          const fn = this._eval(rightNode, scope);
+          return this._call(fn, [leftVal], scope);
+        }
+
+        const fn = this._eval(rightNode, scope);
+        return this._call(fn, [leftVal], scope);
+      }
 
-      i++;
+      default:
+        throw new FazerError(`Unknown expression type: ${expr.type}`);
     }
-    return output;
   }
 
-  parseTime(timeStr) {
-    const val = parseInt(timeStr.slice(0, -1));
-    const unit = timeStr.slice(-1);
-    return val * (unit === 's' ? 1000 : unit === 'm' ? 60000 : unit === 'h' ? 3600000 : 86400000); // s/m/h/d
+  _call(callee, args, scope) {
+    // builtin JS function
+    if (typeof callee === "function") return callee(...args);
+
+    // function reference stored as {__fnref__: "name"}
+    if (callee && typeof callee === "object" && callee.__fnref__) {
+      const name = callee.__fnref__;
+      const fn = this.fns.get(name);
+      if (!fn) throw new FazerError(`Unknown function '${name}'`);
+      if (args.length !== fn.params.length) {
+        throw new FazerError(`Arity mismatch: ${name} expects ${fn.params.length}, got ${args.length}`);
+      }
+      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);
+      if (out instanceof ReturnSignal) return out.value;
+      return out;
+    }
+
+    throw new FazerError(`Value is not callable`);
   }
 
-  async sendToDiscord(channelId, message) {
-    if (!this.discordClient) {
-      this.discordClient = new Client({ intents: [IntentsBitField.Flags.Guilds, IntentsBitField.Flags.GuildMessages] });
-      await this.discordClient.login(process.env.DISCORD_TOKEN);
+  _matchPattern(value, pat, scope) {
+    // returns { matched, bindings }
+    if (!pat) return { matched: false, bindings: {} };
+
+    if (pat.type === "else") return { matched: true, bindings: {} };
+
+    if (pat.type === "identPat") {
+      // binding: case x  name → ...
+      return { matched: true, bindings: { [pat.name]: value } };
     }
-    const channel = await this.discordClient.channels.fetch(channelId);
-    await channel.send(message);
+
+    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: {} };
+      }
+    }
+
+    // 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: {} };
+    }
+
+    return { matched: false, bindings: {} };
   }
+}
 
-  // ... (reste du code : evaluate, run, CLI)
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Utilities                                                                    */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+function unescapeString(rawTokenImage) {
+  // rawTokenImage includes quotes
+  const s = rawTokenImage.slice(1, -1);
+  // minimal escapes
+  return s
+    .replace(/\\n/g, "\n")
+    .replace(/\\r/g, "\r")
+    .replace(/\\t/g, "\t")
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, "\\");
+}
+
+function locOf(tok) {
+  return {
+    offset: tok.startOffset,
+    line: tok.startLine,
+    col: tok.startColumn,
+    endOffset: tok.endOffset,
+    endLine: tok.endLine,
+    endCol: tok.endColumn,
+  };
 }
 
-// CLI reste pareil
-// ...
+function truthy(v) {
+  return !!v;
+}
+
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length) return false;
+    for (const k of ka) if (!deepEqual(a[k], b[k])) return false;
+    return true;
+  }
+  return false;
+}
+
+function prettyError(err, filename, code) {
+  const lines = String(code).split(/\r?\n/);
+  const meta = err && err.meta ? err.meta : null;
+  if (!meta || !meta.line) return `${err.name}: ${err.message}`;
+
+  const lineNo = meta.line;
+  const col = meta.col || 1;
+  const line = lines[lineNo - 1] ?? "";
+  const caret = " ".repeat(Math.max(0, col - 1)) + "^";
+
+  return [
+    `${err.name}: ${err.message}`,
+    `at ${filename}:${lineNo}:${col}`,
+    line,
+    caret,
+  ].join("\n");
+}
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/* CLI                                                                          */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+function usage() {
+  console.log("Usage:");
+  console.log("  fazer run <file.fz> [-- args...]");
+  process.exit(1);
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0) usage();
+
+  const cmd = argv[0];
+
+  if (cmd !== "run") usage();
+  const fileArg = argv[1];
+  if (!fileArg) usage();
+
+  // forward args after "--" to the script
+  const sep = argv.indexOf("--");
+  const forwarded = sep >= 0 ? argv.slice(sep + 1) : [];
+
+  const filePath = path.resolve(fileArg);
+  if (!fs.existsSync(filePath)) {
+    console.error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+  const lex = lexer.tokenize(code);
+  if (lex.errors.length) {
+    console.error("Lexer error:", lex.errors[0].message || String(lex.errors[0]));
+    process.exit(1);
+  }
+
+  const parser = new FazerParser();
+  parser.input = lex.tokens;
+  const ast = parser.program();
+
+  if (parser.errors.length) {
+    const e = parser.errors[0];
+    const tok = e.token || (lex.tokens.length ? lex.tokens[0] : null);
+    const meta = tok ? locOf(tok) : null;
+    const ferr = new FazerError(e.message, meta || {});
+    console.error(prettyError(ferr, filePath, code));
+    process.exit(1);
+  }
+
+  const rt = new FazerRuntime({ argv: forwarded, filename: filePath, code });
+  try {
+    rt.run(ast);
+  } catch (err) {
+    if (err instanceof FazerError) {
+      console.error(prettyError(err, filePath, code));
+    } else {
+      console.error(err && err.stack ? err.stack : String(err));
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  Lexer,
+  createToken,
+  FazerParser,
+  FazerRuntime,
+  FazerError,
+  lexer,
+  prettyError,
+  locOf
+};
+
+if (require.main === module) main();