fbp-language 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,104 @@
-# Temporary Holding Version
+# FBP — French Bot Programming
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+FBP est un langage interprété par Node.js. Les fichiers source utilisent l'extension `.fbp`. Le paquet fournit le moteur et la commande `fbp`.
+
+## Prérequis
+
+- Node.js 20 ou plus récent
+- npm
+
+## Installation depuis npm
+
+Quand le paquet sera publié sur npm :
+
+```bash
+npm install fbp-language
+```
+
+Puis, dans le `package.json` de ton projet :
+
+```json
+{
+  "scripts": {
+    "start": "fbp run lancer"
+  },
+  "dependencies": {
+    "fbp-language": "^1.0.0"
+  }
+}
+```
+
+Lance le script avec `npm start`. npm rend la commande `fbp` disponible dans les scripts du projet.
+
+## Créer un projet FBP
+
+Crée un fichier `commandes.fbp` à la racine de ton projet. Malgré son extension, ce fichier est actuellement du JSON :
+
+```json
+{
+  "lancer": "scripts/main.fbp"
+}
+```
+
+Crée ensuite le fichier `scripts/main.fbp` :
+
+```fbp
+nom = "Mon projet"
+
+lance() {
+  affiche("FBP fonctionne !")
+  affiche("Projet :", nom)
+}
+
+lance()
+```
+
+Les chemins déclarés dans `commandes.fbp` sont relatifs à la racine du projet.
+
+## Commandes CLI
+
+```bash
+fbp help
+fbp version
+fbp info
+fbp ping
+fbp run lancer
+fbp run-file scripts/main.fbp
+```
+
+- `fbp run <nom>` exécute la commande correspondante dans le fichier `commandes.fbp` du dossier courant.
+- `fbp run-file <fichier>` exécute directement un fichier FBP.
+- `fbp ping` vérifie que le CLI répond ; il ne se connecte pas à Discord.
+
+## Syntaxe actuelle
+
+```fbp
+nom = "Gab"
+niveau = 15
+actif = true
+
+lance() {
+  affiche("Bonjour", nom)
+}
+
+lance()
+```
+
+- Types reconnus : texte, nombre et booléen.
+- Les fonctions ne prennent pas encore de paramètres.
+- `affiche(...)` écrit dans le terminal.
+- `import { fonction } de "./fichier.fbp"` importe des fonctions.
+- Les commentaires commencent par `//` ou `#`.
+
+## Limites actuelles
+
+FBP est encore un interpréteur de base. Les paramètres de fonction, les conditions, les boucles, les valeurs de retour et les expressions arithmétiques ne sont pas encore implémentés. La connexion à Discord n'est pas incluse dans le moteur.
+
+## Développement du dépôt
+
+```bash
+npm install
+npm test
+```
+
+Les fichiers d'essai internes se trouvent dans `tests/fixtures`. Ils ne font pas partie du paquet publié.

package/dist/cli.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const compiler_1 = require("./compiler");
+const errors_1 = require("./errors");
+const VERSION = "1.0.0";
+function help() {
+    console.log(`FBP — French Bot Programming
+
+Utilisation :
+  fbp help                 Affiche cette aide
+  fbp version              Affiche la version de FBP
+  fbp info                 Affiche les informations du moteur
+  fbp ping                 Vérifie que le CLI répond
+  fbp run <commande>       Exécute une commande de commandes.fbp
+  fbp run-file <fichier>   Exécute directement un fichier .fbp`);
+}
+function ping() {
+    console.log("FBP : opérationnel");
+    console.log(`Version : ${VERSION}`);
+    console.log(`Node.js : ${process.version}`);
+    console.log("Bot : aucune connexion externe n'est configurée par le CLI seul.");
+}
+function runCommand(name) {
+    const configPath = node_path_1.default.resolve("commandes.fbp");
+    if (!node_fs_1.default.existsSync(configPath)) {
+        throw new errors_1.FbpError("Fichier commandes.fbp introuvable à la racine du projet. Crée ce fichier pour définir tes commandes.");
+    }
+    let commands;
+    try {
+        commands = JSON.parse(node_fs_1.default.readFileSync(configPath, "utf8"));
+    }
+    catch {
+        throw new errors_1.FbpError("commandes.fbp doit contenir un objet JSON valide associant chaque commande à un fichier .fbp.");
+    }
+    if (!commands || typeof commands !== "object" || Array.isArray(commands)) {
+        throw new errors_1.FbpError("commandes.fbp doit être un objet de commandes.");
+    }
+    const target = commands[name];
+    if (typeof target !== "string" || !target.trim()) {
+        const available = Object.keys(commands);
+        throw new errors_1.FbpError(`Commande « ${name} » inconnue.${available.length ? ` Commandes disponibles : ${available.join(", ")}.` : " Aucune commande n'est définie."}`);
+    }
+    new compiler_1.FbpCompiler().runFile(node_path_1.default.resolve(node_path_1.default.dirname(configPath), target));
+}
+function main() {
+    const [command, ...args] = process.argv.slice(2);
+    try {
+        switch (command) {
+            case "help":
+            case "--help":
+            case "-h":
+            case undefined:
+                help();
+                break;
+            case "version":
+            case "--version":
+            case "-v":
+                console.log(`FBP ${VERSION}`);
+                break;
+            case "info":
+                console.log("FBP — French Bot Programming");
+                console.log("Moteur : TypeScript / Node.js");
+                console.log("Fichiers source : .fbp");
+                break;
+            case "ping":
+                ping();
+                break;
+            case "run":
+                if (!args[0])
+                    throw new errors_1.FbpError("Indique le nom de la commande. Exemple : fbp run lancer");
+                runCommand(args[0]);
+                break;
+            case "run-file":
+                if (!args[0])
+                    throw new errors_1.FbpError("Indique un fichier. Exemple : fbp run-file bot/main.fbp");
+                new compiler_1.FbpCompiler().runFile(args[0]);
+                break;
+            default:
+                throw new errors_1.FbpError(`Commande CLI inconnue : « ${command} ». Utilise « fbp help » pour afficher l'aide.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof errors_1.FbpError) {
+            console.error(error.format());
+            process.exitCode = 1;
+        }
+        else {
+            console.error("Erreur FBP : une erreur inattendue est survenue.");
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    }
+}
+main();

package/dist/compiler.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FbpCompiler = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+function valueType(value) {
+    const v = value.trim();
+    if (/^"(?:[^"\\]|\\.)*"$/.test(v) || /^'(?:[^'\\]|\\.)*'$/.test(v))
+        return "texte";
+    if (/^-?\d+(?:\.\d+)?$/.test(v))
+        return "nombre";
+    if (v === "true" || v === "false")
+        return "booleen";
+    return "inconnu";
+}
+function splitArguments(raw) {
+    const result = [];
+    let current = "";
+    let quote = "";
+    let depth = 0;
+    for (const char of raw) {
+        if (quote) {
+            current += char;
+            if (char === quote)
+                quote = "";
+        }
+        else if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+        }
+        else if (char === "(") {
+            depth++;
+            current += char;
+        }
+        else if (char === ")") {
+            depth--;
+            current += char;
+        }
+        else if (char === "," && depth === 0) {
+            if (current.trim())
+                result.push(current.trim());
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim())
+        result.push(current.trim());
+    return result;
+}
+function parseFile(file, source) {
+    const lines = source.split(/\r?\n/);
+    const root = [];
+    const stack = [];
+    const target = () => stack.length ? stack[stack.length - 1].body : root;
+    for (let index = 0; index < lines.length; index++) {
+        const raw = lines[index];
+        const line = raw.trim();
+        const lineNo = index + 1;
+        if (!line || line.startsWith("//") || line.startsWith("#"))
+            continue;
+        const importMatch = line.match(/^import\s*\{\s*([^}]+)\s*\}\s*de\s*(["'])(.+?)\2\s*$/);
+        if (importMatch) {
+            target().push({ kind: "import", names: importMatch[1].split(",").map(x => x.trim()), source: importMatch[3], line: lineNo });
+            continue;
+        }
+        const functionMatch = line.match(/^([\p{L}_][\p{L}\p{N}_]*)\s*\(\s*\)\s*\{$/u);
+        if (functionMatch) {
+            const entry = { name: functionMatch[1], line: lineNo, body: [] };
+            target().push({ kind: "function", ...entry });
+            stack.push(entry);
+            continue;
+        }
+        if (line === "}") {
+            if (!stack.length)
+                throw new errors_1.FbpError("Accolade fermante sans fonction correspondante.", file, lineNo);
+            stack.pop();
+            continue;
+        }
+        const assignment = line.match(/^([\p{L}_][\p{L}\p{N}_]*)\s*=\s*(.+)$/u);
+        if (assignment) {
+            target().push({ kind: "assign", name: assignment[1], value: assignment[2].trim(), line: lineNo });
+            continue;
+        }
+        const call = line.match(/^([\p{L}_][\p{L}\p{N}_]*)\s*\((.*)\)\s*;?$/u);
+        if (call) {
+            target().push({ kind: "call", name: call[1], args: splitArguments(call[2]), line: lineNo });
+            continue;
+        }
+        throw new errors_1.FbpError(`Syntaxe non reconnue : « ${line} ». Vérifie les parenthèses, les accolades et le signe =.`, file, lineNo);
+    }
+    if (stack.length) {
+        const open = stack[stack.length - 1];
+        throw new errors_1.FbpError(`La fonction « ${open.name} » n'est pas fermée par }.`, file, open.line);
+    }
+    return root;
+}
+class FbpCompiler {
+    variables = new Map();
+    functions = new Map();
+    imports = new Map();
+    output;
+    constructor(options = {}) {
+        this.output = options.onOutput ?? (value => console.log(value));
+    }
+    runFile(filePath) {
+        const absolute = node_path_1.default.resolve(filePath);
+        if (!node_fs_1.default.existsSync(absolute))
+            throw new errors_1.FbpError(`Fichier introuvable : ${absolute}`);
+        if (!node_fs_1.default.statSync(absolute).isFile())
+            throw new errors_1.FbpError(`Le chemin indiqué n'est pas un fichier : ${absolute}`);
+        this.execute(parseFile(absolute, node_fs_1.default.readFileSync(absolute, "utf8")), node_path_1.default.dirname(absolute));
+    }
+    execute(statements, baseDir) {
+        for (const statement of statements) {
+            if (statement.kind === "import") {
+                const targetFile = node_path_1.default.resolve(baseDir, statement.source);
+                if (!node_fs_1.default.existsSync(targetFile))
+                    throw new errors_1.FbpError(`Fichier importé introuvable : ${statement.source}`);
+                const nested = parseFile(targetFile, node_fs_1.default.readFileSync(targetFile, "utf8"));
+                for (const item of nested) {
+                    if (item.kind === "function")
+                        this.functions.set(item.name, item);
+                }
+                for (const name of statement.names) {
+                    if (!this.functions.has(name))
+                        throw new errors_1.FbpError(`La fonction « ${name} » n'existe pas dans ${statement.source}.`);
+                    this.imports.set(name, targetFile);
+                }
+            }
+            else if (statement.kind === "function") {
+                if (this.functions.has(statement.name))
+                    throw new errors_1.FbpError(`La fonction « ${statement.name} » est définie plusieurs fois.`, undefined, statement.line);
+                this.functions.set(statement.name, statement);
+            }
+            else if (statement.kind === "assign") {
+                const type = valueType(statement.value);
+                const previous = this.variables.get(statement.name);
+                if (previous && type !== "inconnu" && previous.type !== "inconnu" && previous.type !== type) {
+                    throw new errors_1.FbpError(`Type incompatible pour « ${statement.name} » : attendu ${previous.type}, reçu ${type}.`, undefined, statement.line);
+                }
+                const value = this.evaluate(statement.value, statement.line);
+                this.variables.set(statement.name, { type: previous?.type ?? type, value });
+            }
+            else {
+                this.call(statement.name, statement.args, statement.line, baseDir);
+            }
+        }
+    }
+    evaluate(expression, line) {
+        const value = expression.trim();
+        if (value === "true")
+            return true;
+        if (value === "false")
+            return false;
+        if (/^-?\d+(?:\.\d+)?$/.test(value))
+            return Number(value);
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            return value.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\(["'\\])/g, "$1");
+        }
+        if (this.variables.has(value))
+            return this.variables.get(value).value;
+        throw new errors_1.FbpError(`Valeur inconnue « ${value} ». Utilise un texte, un nombre, true, false ou une variable déclarée.`, undefined, line);
+    }
+    call(name, args, line, baseDir) {
+        const values = args.map(arg => this.evaluate(arg, line));
+        if (name === "affiche") {
+            this.output(values.map(value => value === undefined ? "" : String(value)).join(" "));
+            return;
+        }
+        if (name === "ping") {
+            this.output("FBP fonctionne. Cette commande ne vérifie pas à elle seule une connexion Discord.");
+            return;
+        }
+        const fn = this.functions.get(name);
+        if (!fn)
+            throw new errors_1.FbpError(`Fonction « ${name} » inconnue. Vérifie son nom ou son import.`, undefined, line);
+        this.execute(fn.body, this.imports.has(name) ? node_path_1.default.dirname(this.imports.get(name)) : baseDir);
+    }
+}
+exports.FbpCompiler = FbpCompiler;

package/dist/errors.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FbpError = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+class FbpError extends Error {
+    file;
+    line;
+    constructor(message, file, line) {
+        super(message);
+        this.file = file;
+        this.line = line;
+        this.name = "FbpError";
+    }
+    format() {
+        const location = this.file
+            ? `${node_path_1.default.relative(process.cwd(), this.file)}${this.line ? `:${this.line}` : ""}: `
+            : "";
+        return `Erreur FBP : ${location}${this.message}`;
+    }
+}
+exports.FbpError = FbpError;

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "fbp-language",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "displayName": "FBP - French Bot Programming",
+  "description": "Interpréteur et CLI du langage FBP.",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "main": "dist/compiler.js",
+  "bin": {
+    "fbp": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GabyY-1/French-Bot-Programming.git"
+  },
+  "homepage": "https://github.com/GabyY-1/French-Bot-Programming#readme",
+  "bugs": {
+    "url": "https://github.com/GabyY-1/French-Bot-Programming/issues"
+  },
+  "keywords": [
+    "fbp",
+    "language",
+    "interpreter",
+    "french",
+    "cli"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm test",
+    "start": "node dist/cli.js",
+    "dev": "ts-node src/cli.ts",
+    "test": "npm run build && node --test tests/*.test.cjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2"
+  }
+}