larkhre-mcp 1.1.0

package/LARKHRE_POUR_IA.md

@@ -0,0 +1,233 @@
+# LARKHRE_POUR_IA.md — Spécification du langage Larkhré pour agents IA
+
+> **Instruction pour l'agent IA qui lit ce fichier :** ce document contient la
+> spécification complète et exacte du langage de programmation Larkhré (v8.0),
+> créé par Ladji Doucaré. Après lecture, tu sais écrire du code Larkhré correct.
+> Respecte STRICTEMENT cette syntaxe — n'invente jamais de mots-clés ou de
+> fonctions absents de ce document. En cas de doute, préfère les constructions
+> montrées dans les exemples canoniques en fin de fichier.
+>
+> Exécution : playground https://larkhre.github.io/code/ (navigateur)
+> ou `pip install larkhre` puis `larkhre fichier.laz` (Python 3.8+).
+> Fichiers : extension `.laz`, encodage UTF-8.
+
+## 1. Règles de syntaxe fondamentales
+
+- Blocs délimités par accolades `{ }`. PAS de point-virgules (autorisés mais inutiles). Une instruction par ligne.
+- Commentaires : `# ...` ou `// ...` jusqu'à fin de ligne.
+- Chaînes : guillemets doubles uniquement `"texte"`. Échappements : `\n \t \" \\`.
+- Interpolation dans les chaînes : `"Salut {nom}"` remplace `{nom}` par la variable `nom` si elle existe (identificateurs simples uniquement, pas d'expressions). Accolades littérales : `{{` et `}}`.
+- Identificateurs : lettres/chiffres/underscore, pas d'espaces. Sensible à la casse.
+- Nombres : entiers `42` et décimaux `3.14`. Division `/` renvoie un entier si le résultat est entier (10/2 → 5, 10/3 → 3.333...).
+- Pas de `NULL`/`None`/`nil` : la valeur vide est `walu`.
+- Booléens : `vrai` et `faux` (PAS true/false, sauf pack de langue anglais actif).
+
+## 2. Les 22 mots-clés (et RIEN d'autre)
+
+| Mot-clé | Rôle | Équivalent Python |
+|---|---|---|
+| `laz` | déclarer une variable : `laz x = 5` | `x = 5` (première affectation) |
+| `garde` | variable PERSISTANTE entre exécutions : `garde score = 0` | (unique à Larkhré) |
+| `fonk` | définir une fonction : `fonk f(a, b) { ... }` | `def` |
+| `rend` | retourner une valeur : `rend x * 2` | `return` |
+| `kan` | condition : `kan x > 5 { ... }` | `if` |
+| `sinon kan` | sinon si (enchaînable) | `elif` |
+| `sinon` | sinon : `sinon { ... }` | `else` |
+| `tanke` | boucle tant que : `tanke x > 0 { ... }` | `while` |
+| `pou` + `dan` | boucle pour : `pou i dan 1..10 { ... }` | `for i in` |
+| `kase` | sortir de la boucle | `break` |
+| `swiv` | passer à l'itération suivante | `continue` |
+| `vrai` / `faux` | booléens | `True` / `False` |
+| `walu` | valeur vide | `None` |
+| `et` / `ou` / `non` | logique (aussi `&&` `\|\|` `!`) | `and` / `or` / `not` |
+| `klas` | classe : `klas Chien { ... }` | `class` |
+| `herite` | héritage : `klas Chiot herite Chien { ... }` | `class A(B)` |
+| `importe` | importer un fichier : `importe "outils.laz"` (Python seulement, pas playground) | `import` |
+| `essaie` / `rattrape` | gestion d'erreurs : `essaie { ... } rattrape err { ... }` | `try` / `except` |
+
+Réaffectation SANS `laz` : `x = x + 1`. Raccourcis : `+=` `-=` `*=` `/=` (sur variables, éléments de liste/dico, propriétés d'objet).
+
+## 3. Types et structures
+
+- **Texte** : `"abc"`. Concaténation `+` (coerce automatiquement : `"a" + 5` → `"a5"`). Indexation `t[0]`, négatif `t[-1]`.
+- **Liste** : `[1, 2, 3]`. Indexation base 0, négatifs OK. Affectation `l[0] = x`.
+- **Dictionnaire** : `{ "cle": valeur, "n": 2 }` (clés : textes ou nombres). Lecture `d["cle"]` (erreur si clé absente — vérifier avec `contient`), écriture/ajout `d["cle"] = v`. `pou k dan d { }` itère sur les CLÉS.
+- **Intervalle** : `1..10` produit la liste [1..10] BORNES INCLUSES. `10..1` compte à rebours.
+- Vérité : `faux`, `walu`, `0`, `""`, `[]`, `{}` sont faux ; tout le reste est vrai.
+- Comparaisons : `==` `!=` `<` `>` `<=` `>=`. Égalité par valeur (listes/dicos comparés en profondeur).
+- Modulo `%` : signe du diviseur (comme Python).
+
+## 4. Classes
+
+```larkhre
+klas Animal {
+    fonk init(moi, nom) {        # constructeur, appelé par Animal("Rex")
+        moi.nom = nom            # propriétés via moi.xxx
+    }
+    fonk parler(moi) {           # TOUTE fonction de klas a "moi" en 1er paramètre
+        vox(moi.nom, "fait du bruit")
+    }
+}
+klas Chien herite Animal {       # hérite de toutes les fonctions du parent
+    fonk parler(moi) {
+        vox(moi.nom, "dit wouf")
+    }
+}
+laz rex = Chien("Rex")           # instanciation SANS mot-clé new
+rex.parler()
+rex.nom = "Rexou"                # accès/écriture direct des propriétés
+```
+
+Pas de `super`, pas de méthodes statiques, pas d'attributs de classe.
+
+## 5. Les 48 fonctions intégrées (signatures exactes)
+
+E/S : `vox(a, b, ...)` affiche (sépare par espaces) · `demand(prompt)` → texte saisi (TOUJOURS convertir avec `nombre()` pour du calcul) · `vox_couleur(texte..., couleur)` dernier argument = couleur parmi rouge, vert, jaune, bleu, violet, cyan, blanc, or, gris, rose, noir · `stylise(texte, style)` → texte stylé (couleurs + "gras", "souligne") · `efface_ecran()` · `ralenti(sec)` exécution pas-à-pas visible (0 = normal, max 3 ; ignoré en mode traduit) · `echoue(message)` lève une erreur rattrapable.
+
+Conversion/inspection : `nombre(x)` · `texte(x)` · `tip(x)` → "nombre"/"texte"/"buli"/"liste"/"dico"/"walu"/"fonk"/nom de klas · `taille(x)` textes, listes, dicos.
+
+Listes : `ajoute(liste, x)` (mutation, fin) · `retire(liste, index)` ou `retire(dico, cle)` (mutation, renvoie l'élément) · `tri(liste)` → NOUVELLE liste triée (types homogènes) · `contient(conteneur, x)` texte/liste/dico → vrai/faux · `colle(liste, sep)` → texte joint.
+
+Dictionnaires : `cles(d)` → liste · `valeurs(d)` → liste.
+
+Textes : `majus(t)` · `minus(t)` · `koupe(t, sep)` → liste · `remplace(t, ancien, nouveau)`.
+
+Nombres : `hasard(a, b)` entier aléatoire inclusif · `arondi(x, decimales?)`.
+
+Fichiers (Python : disque réel ; playground : fichiers virtuels de session) : `lis_fichier(chemin)` · `ecris_fichier(chemin, texte)` · `ajoute_fichier(chemin, texte)` · `fichier_existe(chemin)`.
+
+Dessin (playground : toile visible en direct ; Python : buffer puis `sauve_dessin` → fichier SVG) : `toile(largeur, hauteur)` OBLIGATOIRE avant tout dessin · `fond(couleur)` · `trace_ligne(x1, y1, x2, y2, couleur)` · `trace_rect(x, y, l, h, couleur)` · `rect_plein(...)` · `trace_cercle(x, y, rayon, couleur)` · `cercle_plein(...)` · `trace_texte(x, y, texte, couleur)` · `sauve_dessin(chemin)`. Origine (0,0) en haut à gauche, y vers le bas. Couleurs : noms français ci-dessus ou `"#rrggbb"`.
+
+Mode JEU temps réel (v6 ; playground : toile animée + sons ; Python : vraie fenêtre tkinter) : `chaque_image(f)` enregistre la fonction `f` (SANS parenthèses : `chaque_image(image)`, pas `chaque_image(image())`) appelée ~30 fois/seconde APRÈS la fin du programme principal · `touche_pressee(nom)` → vrai/faux, la touche est-elle enfoncée maintenant (noms : `"a"`-`"z"`, `"0"`-`"9"`, `"haut"`, `"bas"`, `"gauche"`, `"droite"`, `"espace"`, `"entree"`, `"echap"`) · `arrete_jeu()` termine la boucle de jeu · `joue_son(nom)` parmi piece, saut, explosion, clic, moteur, victoire, defaite · `dis(texte...)` (v8) prononce le texte à voix haute en français (synthèse vocale ; silencieux si indisponible).
+
+Mode INTERFACE (v7 ; playground : widgets au-dessus de la console ; Python : fenêtre tkinter) : `titre(texte)` grand titre · `etiquette(texte)` → id (garder dans une variable pour `change_texte`) · `bouton(texte, f)` bouton cliquable, `f` SANS parenthèses, appelée à chaque clic · `champ(indication)` → id, zone de saisie · `valeur_de(id)` → TEXTE saisi (convertir avec `nombre()` pour calculer) · `change_texte(id, texte)` met à jour n'importe quel widget · `efface_interface()`. L'application reste vivante après le programme principal (elle attend les clics) ; `arrete_jeu()` la ferme. Compatible avec `garde`, `joue_son`, la toile et `chaque_image`.
+
+## 6. Pièges à éviter (erreurs fréquentes des IA)
+
+- PAS de `print`, `def`, `if`, `while`, `for`, `return`, `elif`, `try`, `let`, `function`, `console.log` → utiliser les mots-clés Larkhré.
+- PAS de `f"..."` ni de `.format()` ni de `${}` → interpolation native `"{variable}"`.
+- PAS de `else if` → `sinon kan`.
+- PAS de `:` après les conditions, PAS d'indentation significative → accolades obligatoires.
+- PAS de méthodes sur objets natifs : `liste.append(x)` n'existe PAS → `ajoute(liste, x)` ; `t.upper()` n'existe pas → `majus(t)` ; `len(x)` → `taille(x)`.
+- `demand()` renvoie du TEXTE : `laz n = nombre(demand("? "))` pour un nombre.
+- Une seule instruction par ligne dans les blocs (chaque `vox(...)` sur sa ligne).
+- `pou i dan 1..n` : bornes INCLUSES (1 à n, pas n-1).
+- Fonction de klas : premier paramètre `moi`, appels externes SANS passer moi : `rex.parler()`.
+- `rattrape` exige un nom de variable : `rattrape erreur { vox(erreur) }`.
+- Mode interface : l'état vit dans des variables globales ; les fonctions de boutons les modifient puis appellent `change_texte` ; JAMAIS de `demand()` dans une fonction de bouton (utiliser `champ` + `valeur_de`).
+- Mode jeu : la fonction d'image doit REDESSINER toute la scène (`toile` + `fond` + formes) à chaque appel ; JAMAIS de `demand()` ni `ralenti()` dedans ; l'état du jeu vit dans des variables globales déclarées AVANT `chaque_image(...)` ; `chaque_image` s'appelle UNE fois, en fin de programme.
+
+## 7. Packs de langue (v5)
+
+Un commentaire en tête de fichier change les mots-clés : `#langue: anglais` (let, func, give, when, else, while, for, in, true, false, null, and, or, not, stop, next, class, extends, load, try, catch, keep) · `#langue: francais` — français académique (soit, fonction, retourne, si, sinon, tantque, pour, dans, vrai, faux, rien, et, ou, non, casse, continue, classe, herite, importe, essaie, rattrape, garde). Brouillons `bambara` et `wolof` existent. Les fonctions intégrées (`vox`, etc.) restent identiques dans toutes les langues. Conversion de fichier : `larkhre --traduire-vers anglais f.laz`.
+
+## 8. Ligne de commande
+
+`larkhre f.laz` exécuter · `larkhre` REPL · `larkhre --traduire f.laz` → génère f.py Python natif (souvent ~10× plus rapide, nécessite larkhre installé) · `larkhre --traduire-vers <langue> f.laz` conversion de mots-clés.
+
+## 9. Exemples canoniques (à imiter)
+
+```larkhre
+# Jeu complet : boucle + condition + état + saisie
+laz secret = hasard(1, 100)
+laz trouve = faux
+laz essais = 0
+tanke non trouve {
+    laz nb = nombre(demand("Ton essai : "))
+    essais += 1
+    kan nb == secret {
+        trouve = vrai
+        vox_couleur("BRAVO en {essais} essais !", "vert")
+    } sinon kan nb < secret {
+        vox("Plus grand !")
+    } sinon {
+        vox("Plus petit !")
+    }
+}
+```
+
+```larkhre
+# Données : liste de dicos + fonction + interpolation
+fonk moyenne(notes) {
+    laz total = 0
+    pou n dan notes {
+        total += n
+    }
+    rend total / taille(notes)
+}
+laz eleves = [
+    { "nom": "Awa", "notes": [12, 15, 18] },
+    { "nom": "Issa", "notes": [9, 14, 11] }
+]
+pou e dan eleves {
+    vox(e["nom"], "→ moyenne :", arondi(moyenne(e["notes"]), 1))
+}
+```
+
+```larkhre
+# Persistance + erreurs + fichier
+garde visites = 0
+visites += 1
+essaie {
+    ecris_fichier("journal.txt", "Visite numéro {visites}")
+    vox(lis_fichier("journal.txt"))
+} rattrape probleme {
+    vox_couleur("Souci : {probleme}", "rouge")
+}
+```
+
+```larkhre
+# Jeu temps réel (v6) : la boucle d'images + clavier direct
+laz x = 200
+laz score = 0
+fonk image() {
+    kan touche_pressee("gauche") ou touche_pressee("q") {
+        x -= 5
+    }
+    kan touche_pressee("droite") ou touche_pressee("d") {
+        x += 5
+    }
+    toile(400, 200)
+    fond("noir")
+    cercle_plein(x, 100, 14, "cyan")
+    trace_texte(10, 24, "Score : {score}", "blanc")
+    kan touche_pressee("echap") {
+        joue_son("victoire")
+        arrete_jeu()
+    }
+}
+chaque_image(image)
+```
+
+```larkhre
+# Application (v7) : boutons + champ + mise à jour
+titre("Compteur de points")
+laz points = 0
+laz aff = etiquette("Points : 0")
+laz zone = champ("Combien de points ajouter ?")
+fonk ajoute_points() {
+    laz n = nombre(valeur_de(zone))
+    points += n
+    change_texte(aff, "Points : {points}")
+}
+bouton("Ajouter", ajoute_points)
+fonk fini() {
+    arrete_jeu()
+}
+bouton("Fermer", fini)
+```
+
+```larkhre
+# Dessin génératif
+toile(400, 300)
+fond("noir")
+pou i dan 1..10 {
+    cercle_plein(i * 38, 150, i * 3, "cyan")
+}
+trace_texte(140, 40, "Dessiné en Larkhré", "or")
+sauve_dessin("art.svg")
+```
+
+---
+*Larkhré v8.0 — langage open source (MIT) créé par Ladji Doucaré.
+Guide humain : GUIDE_LARKHRE.md · Source : github.com/larkhre/larkhre.github.io*

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ladji Doucaré
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# larkhre-mcp 🤖
+
+**Le serveur MCP du langage [Larkhré](https://larkhre.github.io/code/)** — il donne à n'importe quel agent IA (Claude, et tout client compatible Model Context Protocol) le pouvoir d'**écrire ET d'exécuter** du code Larkhré pour de vrai.
+
+## Ce que l'IA peut faire
+
+- `spec_larkhre` — lire la spécification complète du langage (mots-clés, 48 fonctions, pièges, exemples)
+- `executer_larkhre` — lancer un programme et recevoir : la sortie console, les **erreurs pédagogiques en français**, les **dessins SVG**, les fichiers écrits, les paroles `dis()`, les sons, et la mémoire persistante `garde`
+
+Demandez à votre IA : *« Code-moi un jeu en Larkhré et teste-le »* — elle écrit le code, l'exécute, lit les erreurs, corrige, et vous livre un programme **vérifié**.
+
+## Installation (Claude Desktop)
+
+Dans votre fichier `claude_desktop_config.json` :
+
+```json
+{
+  "mcpServers": {
+    "larkhre": {
+      "command": "npx",
+      "args": ["-y", "larkhre-mcp"]
+    }
+  }
+}
+```
+
+Redémarrez Claude Desktop — les outils `executer_larkhre` et `spec_larkhre` apparaissent.
+
+## Tout client MCP
+
+```bash
+npx -y larkhre-mcp   # serveur stdio
+```
+
+## Le bac à sable
+
+- Exécution limitée à 8 secondes / 240 images de jeu — les boucles infinies s'arrêtent proprement
+- Fichiers virtuels (rien n'est écrit sur le disque)
+- `demand()` lit le paramètre `entrees` ; `garde` persiste le temps de la session
+
+---
+*Larkhré — un langage libre (MIT) créé par Ladji Doucaré ·
+[Playground](https://larkhre.github.io/code/) ·
+[GitHub](https://github.com/larkhre/larkhre.github.io) ·
+`pip install larkhre` · `npm install larkhre`*

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "larkhre-mcp",
+  "version": "1.1.0",
+  "description": "Serveur MCP du langage Larkhré : permet à n'importe quel agent IA (Claude, etc.) d'ÉCRIRE et d'EXÉCUTER du code Larkhré pour de vrai — sortie console, dessins SVG, mémoire persistante.",
+  "type": "module",
+  "bin": {
+    "larkhre-mcp": "server.js"
+  },
+  "files": [
+    "server.js",
+    "LARKHRE_POUR_IA.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "larkhre": "^11.1.0",
+    "zod": "^3.23.0"
+  },
+  "keywords": ["larkhre", "mcp", "model-context-protocol", "ai", "agent", "langage", "french", "education"],
+  "author": "Ladji Doucaré",
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/larkhre/larkhre.github.io.git" },
+  "homepage": "https://larkhre.github.io/code/"
+}

package/server.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/* ============================================================
+   larkhre-mcp — le serveur MCP du langage Larkhré
+   Créé par Ladji Doucaré · https://larkhre.github.io/code/
+
+   Donne à n'importe quel agent IA le pouvoir d'ÉCRIRE et
+   d'EXÉCUTER du code Larkhré pour de vrai :
+   - executer_larkhre : lance un programme, renvoie la sortie,
+     les erreurs pédagogiques, les dessins SVG, la mémoire garde
+   - spec_larkhre : la spécification complète du langage
+   ============================================================ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const Larkhre = require('larkhre');
+const ICI = dirname(fileURLToPath(import.meta.url));
+
+const LIMITE_MS = 8000;        // temps maximum d'exécution
+const LIMITE_IMAGES = 240;     // ~8 secondes de jeu à 30 images/s
+
+// la mémoire « garde » vit le temps de la session MCP
+const memoireSession = {};
+
+async function executer(code, entrees) {
+  const sortie = [];
+  const sons = [];
+  const paroles = [];
+  const fs = new Map();
+  const fileEntrees = [...(entrees || [])];
+  let images = 0;
+  const debut = Date.now();
+  let tempsDepasse = false;
+
+  const resultat = await Larkhre.run(code, {
+    onPrint: (t) => { if (sortie.length < 2000) sortie.push(t); },
+    onInput: async () => fileEntrees.length ? String(fileEntrees.shift()) : '',
+    shouldStop: () => {
+      if (Date.now() - debut > LIMITE_MS || images > LIMITE_IMAGES) {
+        tempsDepasse = true;
+        return true;
+      }
+      return false;
+    },
+    onYield: () => new Promise((r) => setImmediate(r)),
+    onFrame: () => { images++; return new Promise((r) => setImmediate(r)); },
+    onDraw: () => { },
+    onSon: (n) => { if (sons.length < 50) sons.push(n); },
+    onDis: (t) => { if (paroles.length < 50) paroles.push(t); },
+    toucheEnfoncee: () => false,
+    prendClics: () => [],
+    getChampValeur: () => '',
+    onWidget: () => { },
+    fs,
+    memoire: memoireSession,
+    onSauveMemoire: (data) => Object.assign(memoireSession, data),
+  });
+
+  const fichiers = {};
+  const dessins = {};
+  for (const [nom, contenu] of fs.entries()) {
+    if (nom.endsWith('.svg')) dessins[nom] = contenu;
+    else fichiers[nom] = String(contenu).slice(0, 20000);
+  }
+
+  const rapport = [];
+  if (resultat.ok) rapport.push('✔ Programme exécuté avec succès.');
+  else if (resultat.stopped) {
+    rapport.push(tempsDepasse
+      ? `⏱ Programme arrêté par le bac à sable (limite : ${LIMITE_MS / 1000}s / ${LIMITE_IMAGES} images de jeu). La sortie ci-dessous est celle produite avant l'arrêt.`
+      : '⏹ Programme arrêté.');
+  } else {
+    rapport.push(resultat.error);
+    if (resultat.histoire && resultat.histoire.length) {
+      rapport.push("— Le film juste avant l'erreur :");
+      for (const [l, n, v] of resultat.histoire) rapport.push(`   ligne ${l} : ${n} = ${v}`);
+    }
+  }
+  rapport.push('');
+  rapport.push('=== SORTIE CONSOLE ===');
+  rapport.push(sortie.length ? sortie.join('\n') : '(aucune sortie)');
+  if (paroles.length) {
+    rapport.push('');
+    rapport.push('=== PAROLES (dis) ===');
+    rapport.push(paroles.join('\n'));
+  }
+  if (sons.length) {
+    rapport.push('');
+    rapport.push('=== SONS JOUÉS ===');
+    rapport.push(sons.join(', '));
+  }
+  for (const [nom, svg] of Object.entries(dessins)) {
+    rapport.push('');
+    rapport.push(`=== DESSIN ${nom} (SVG) ===`);
+    rapport.push(svg.length > 30000 ? svg.slice(0, 30000) + '\n[...SVG tronqué...]' : svg);
+  }
+  for (const [nom, contenu] of Object.entries(fichiers)) {
+    rapport.push('');
+    rapport.push(`=== FICHIER ${nom} ===`);
+    rapport.push(contenu);
+  }
+  const gardes = Object.keys(memoireSession);
+  if (gardes.length) {
+    rapport.push('');
+    rapport.push('=== MÉMOIRE garde (persiste entre les exécutions de cette session) ===');
+    rapport.push(JSON.stringify(memoireSession));
+  }
+  return rapport.join('\n');
+}
+
+const server = new McpServer({ name: 'larkhre', version: '1.0.0' });
+
+server.tool(
+  'executer_larkhre',
+  "Exécute un programme Larkhré (le langage de programmation en français créé par Ladji Doucaré) et renvoie la sortie console, les erreurs pédagogiques, les dessins SVG, les fichiers écrits et la mémoire persistante « garde ». Utilise l'outil spec_larkhre d'abord si tu ne connais pas la syntaxe. Les demand() lisent la liste `entrees` (une réponse par appel, '' si épuisée). Les jeux temps réel (chaque_image) tournent au maximum 240 images puis s'arrêtent proprement.",
+  {
+    code: z.string().describe('Le programme Larkhré complet à exécuter (extension .laz, UTF-8)'),
+    entrees: z.array(z.string()).optional().describe('Réponses aux demand(), dans l\'ordre'),
+  },
+  async ({ code, entrees }) => {
+    try {
+      const rapport = await executer(code, entrees);
+      return { content: [{ type: 'text', text: rapport }] };
+    } catch (e) {
+      return { content: [{ type: 'text', text: '✘ Erreur interne du bac à sable : ' + (e && e.message ? e.message : String(e)) }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  'spec_larkhre',
+  'Renvoie la spécification complète et exacte du langage Larkhré (mots-clés, fonctions intégrées, pièges à éviter, exemples canoniques). À lire AVANT d\'écrire du code Larkhré.',
+  {},
+  async () => {
+    const spec = readFileSync(join(ICI, 'LARKHRE_POUR_IA.md'), 'utf-8');
+    return { content: [{ type: 'text', text: spec }] };
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);