@jonathankablan/noraivoire-cli 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,64 @@
+NORAIVOIRE — LICENCE PROPRIÉTAIRE
+Copyright (c) 2026 Jonathan KABLAN. Tous droits réservés.
+
+Le présent logiciel, incluant sans limitation son code source, ses spécifications
+(fichiers .nora.json), son compilateur, son moteur d'effets, ses adaptateurs, ses
+modèles (templates), sa documentation, ses jeux de tests et ses éléments graphiques
+(ci-après « le Logiciel »), est la propriété exclusive de Jonathan KABLAN
+(ci-après « le Titulaire »).
+
+1. ABSENCE DE LICENCE OPEN SOURCE
+   Le Logiciel n'est pas distribué sous une licence open source. Aucun droit
+   n'est concédé implicitement, par estoppel ou autrement. La simple mise à
+   disposition du Logiciel, y compris dans un dépôt privé ou un registre de
+   paquets privé, ne vaut pas concession de licence.
+
+2. USAGE AUTORISÉ
+   Tout usage du Logiciel est subordonné à un contrat de licence écrit et signé
+   par le Titulaire (ci-après « Contrat de Licence »). En l'absence d'un tel
+   contrat, seul le Titulaire est autorisé à utiliser le Logiciel.
+
+3. INTERDICTIONS
+   Sauf autorisation écrite et préalable du Titulaire, il est interdit de :
+   a) copier, reproduire, modifier, adapter, traduire ou créer des œuvres
+      dérivées du Logiciel, en tout ou partie ;
+   b) distribuer, publier, sous-licencier, louer, prêter, vendre ou mettre à
+      disposition le Logiciel à des tiers, y compris sous forme de service
+      (SaaS) ou intégré dans un autre produit distribué ;
+   c) décompiler, désassembler ou procéder à de l'ingénierie inverse du
+      Logiciel, sauf dans les limites strictement prévues par l'article
+      L.122-6-1 du Code de la propriété intellectuelle ;
+   d) supprimer ou altérer les mentions de propriété, de copyright ou la
+      présente licence ;
+   e) utiliser le Logiciel, ses spécifications ou sa documentation pour
+      entraîner, affiner ou évaluer un modèle d'intelligence artificielle
+      destiné à des tiers, ou pour concevoir un produit concurrent.
+
+4. PRODUITS GÉNÉRÉS
+   Les fichiers produits par le compilateur NoraIvoire pour le compte d'un
+   licencié (CSS, Dart, TypeScript générés) peuvent être intégrés dans les
+   applications de ce licencié dans les conditions fixées par son Contrat de
+   Licence. Ils ne peuvent pas être redistribués en tant que bibliothèque,
+   framework ou kit de design autonome.
+
+5. CONFIDENTIALITÉ
+   Le Logiciel contient des informations confidentielles et des secrets
+   d'affaires du Titulaire. Toute personne y ayant accès s'engage à en
+   préserver la confidentialité.
+
+6. ABSENCE DE GARANTIE
+   Sauf stipulation contraire du Contrat de Licence, le Logiciel est fourni
+   « EN L'ÉTAT », sans garantie d'aucune sorte, expresse ou implicite. Dans
+   les limites autorisées par la loi, le Titulaire ne saurait être tenu
+   responsable d'aucun dommage résultant de l'utilisation du Logiciel.
+
+7. COMPOSANTS TIERS
+   Le Logiciel peut référencer des composants tiers soumis à leurs propres
+   licences, listés dans THIRD_PARTY_NOTICES.md. La présente licence ne
+   modifie pas ces licences.
+
+8. DROIT APPLICABLE
+   La présente licence est régie par le droit français. Tout litige relève de
+   la compétence des tribunaux du ressort de la Cour d'appel de Paris.
+
+Contact licences : jonathan.kablan@gmail.com

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# @jonathankablan/noraivoire-cli
 
-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.
+`nora check` 0.1.0 : valide les templates (HTML, Twig, JSP, JSX/TSX, Vue, Angular, Svelte, Astro) contre le contrat NoraIvoire — classes, variantes, effets, accessibilité (libellés, `alt`, `aria-current`, rôles…) — et propose une correction pour chaque problème. 20 règles, zéro dépendance hors `@jonathankablan/noraivoire-core`.
+
+```bash
+npm install --save-dev @jonathankablan/noraivoire-cli
+npx nora check src templates --format=text   # ou --format=json ; code de sortie 1 en cas d'erreur
+```
+
+```text
+✖ src/page.html:12  [foreign-class] « btn-primary » : classe Bootstrap, inexistant dans NoraIvoire
+    → class="btn" data-tone="primary"
+```
+
+API : `import { checkSource } from '@jonathankablan/noraivoire-cli/check'`. Option `--manifest=<chemin>` pour un autre manifest.
+
+Logiciel propriétaire © 2026 Jonathan KABLAN, tous droits réservés (voir LICENSE). La mise à disposition sur npm ne vaut pas concession de licence : tout usage est subordonné à un contrat de licence écrit.

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@jonathankablan/noraivoire-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "UNLICENSED",
+  "description": "CLI NoraIvoire : validation des templates (nora check) et audit (nora audit). Propriétaire.",
+  "author": "Jonathan KABLAN",
+  "type": "module",
+  "bin": {
+    "nora": "src/cli.js"
+  },
+  "exports": {
+    "./check": "./src/check.js",
+    "./tokenize": "./src/tokenize.js",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@jonathankablan/noraivoire-core": "0.1.0"
+  },
+  "keywords": [
+    "noraivoire",
+    "lint",
+    "accessibility",
+    "templates"
+  ],
+  "files": [
+    "src/cli.js",
+    "src/check.js",
+    "src/tokenize.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/check.js

@@ -0,0 +1,332 @@
+// NoraIvoire — Validateur de templates (HTML, Twig, JSP, JSX/TSX, Vue, Angular).
+// © 2026 Jonathan KABLAN — Propriétaire, tous droits réservés.
+//
+// Conçu pour la boucle de correction des agents IA : chaque erreur porte une
+// suggestion « fix » directement applicable.
+
+import { readdirSync, readFileSync, lstatSync } from 'node:fs';
+import { join, extname, relative } from 'node:path';
+import { tokenize, attributeMap, parseDocument, DYNAMIC } from './tokenize.js';
+
+const EXTENSIONS = new Set(['.html', '.htm', '.twig', '.jsp', '.jspx', '.tag', '.jsx', '.tsx', '.vue', '.svelte', '.astro']);
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'vendor', 'var', '.dart_tool']);
+const MAX_FILE = 1024 * 1024;
+
+const UTILITY_PREFIX = /^(p|px|py|m|mx|my|gap|rounded|text|shadow|font)-/;
+const TEMPLATE_EXPR = /\{\{|\{%|\$\{|<%|#\{|\{\s*\w/;
+
+const FOREIGN = [
+  { re: /^btn-(primary|secondary|success|danger|warning|info|light|dark)$/, fix: (m) => `class="btn" data-tone="${map(m[1])}"`, msg: 'variante Bootstrap' },
+  { re: /^btn-outline-(\w+)$/, fix: () => 'class="btn" data-tone="neutral" (pas de variante outline dans NoraIvoire)', msg: 'variante Bootstrap' },
+  { re: /^btn-(lg|sm)$/, fix: (m) => `data-size="${m[1]}"`, msg: 'taille Bootstrap' },
+  { re: /^badge-(\w+)$/, fix: (m) => `class="badge" data-tone="${map(m[1])}"`, msg: 'variante Bootstrap' },
+  { re: /^(bg|text|bg-subtle)-(primary|secondary|success|danger|warning|info)$/, fix: () => 'utiliser un composant avec data-tone, ou la variable var(--nora-color-…)', msg: 'couleur Bootstrap' },
+  { re: /^col(-(sm|md|lg|xl|xxl))?-\d{1,2}$/, fix: () => 'class="grid-auto" (ou .cluster / .stack)', msg: 'grille Bootstrap' },
+  { re: /^row$/, fix: () => 'class="grid-auto" ou class="cluster"', msg: 'grille Bootstrap' },
+  { re: /^(bg|text|border|ring|from|to)-[a-z]+-\d{2,3}$/, fix: () => 'utiliser les tokens : var(--nora-color-…) ou data-tone', msg: 'couleur Tailwind' },
+  { re: /^(sm|md|lg|xl|2xl|hover|focus|active|dark|group-hover):/, fix: () => 'NoraIvoire gère états et responsive dans les composants ; utiliser .cq + container queries', msg: 'préfixe Tailwind' },
+  { re: /^(flex|grid|items-center|justify-between|justify-center)$/, fix: () => 'class="cluster" (ligne) ou class="stack" (colonne)', msg: 'utilitaire Tailwind' },
+];
+
+function map(bsTone) {
+  return { secondary: 'neutral', info: 'primary', light: 'neutral', dark: 'neutral' }[bsTone] ?? bsTone;
+}
+
+function levenshtein(a, b) {
+  const dp = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 1; j <= b.length; j++) dp[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+  }
+  return dp[a.length][b.length];
+}
+
+function nearest(word, list) {
+  let best = null;
+  let score = Infinity;
+  for (const w of list) {
+    const d = levenshtein(word, w);
+    if (d < score) { score = d; best = w; }
+  }
+  return score <= 3 ? best : null;
+}
+
+/** Extrait les attributs d'une balise ouvrante (chaîne d'attributs seule). Les liaisons valent DYNAMIC. */
+export function parseAttributes(src) {
+  const [tag] = tokenize(`<x ${src}>`);
+  return { ...attributeMap(tag.attributes) };
+}
+
+/** Un contenu de bouton fourni par le framework (slot, doBody, block, {children}…) compte comme un texte. */
+const SLOT_TAGS = new Set(['slot', 'ng-content', 'jsp:dobody', 'jsp:body']);
+
+function hasAccessibleContent(text, tokens, el) {
+  if (el.selfClosing) return false;
+  if (el.closeTokenIndex === null) return true; // fermeture introuvable : on ne conclut pas
+  for (let t = el.tokenIndex + 1; t < el.closeTokenIndex; t++) {
+    const tok = tokens[t];
+    if (tok.type === 'template' || tok.type === 'expr') return true;
+    if (tok.type === 'tag' && SLOT_TAGS.has(tok.name)) return true;
+    if (tok.type === 'text' && text.slice(tok.start, tok.end).trim() !== '') return true;
+  }
+  return false;
+}
+
+/** Valide un contenu de template. */
+export function checkSource(text, file, manifest) {
+  const issues = [];
+  const components = manifest.components;
+  const parts = Object.values(components).flatMap((c) => c.parts ?? []);
+  const utilities = new Set([...manifest.utilities, ...manifest.layout, ...manifest.surfaces, ...parts]);
+  const effects = new Set(Object.entries(manifest.effects).filter(([, e]) => e.kind !== 'surface-glass').map(([n]) => n));
+  const allKnown = [...Object.keys(components), ...utilities];
+  const { tokens, elements } = parseDocument(text);
+  const form = formIndex(elements);
+
+  for (const el of elements) {
+    const push = (level, rule, message, fix) => issues.push({ file, line: el.line, level, rule, message, ...(fix ? { fix } : {}) });
+    const tag = el.name;
+    const attrs = el.attrs;
+    const classAttr = attrs.class === DYNAMIC ? undefined : attrs.class;
+    const classes = classAttr && !TEMPLATE_EXPR.test(classAttr) ? classAttr.split(/\s+/).filter(Boolean)
+      : (classAttr ? classAttr.split(/\s+/).filter((c) => c && !/[{}%$<>]/.test(c)) : []);
+
+    const comps = classes.filter((c) => Object.hasOwn(components, c));
+
+    for (const c of classes) {
+      const foreign = FOREIGN.find((f) => f.re.test(c));
+      if (foreign) {
+        push('error', 'foreign-class', `« ${c} » : ${foreign.msg}, inexistant dans NoraIvoire`, foreign.fix(c.match(foreign.re)));
+        continue;
+      }
+      if (c.startsWith('fx-') && !utilities.has(c)) {
+        push('error', 'unknown-surface', `surface « ${c} » inconnue`, nearest(c, manifest.surfaces) ? `class="${nearest(c, manifest.surfaces)}"` : `surfaces disponibles : ${manifest.surfaces.join(', ')}`);
+      } else if (UTILITY_PREFIX.test(c) && !utilities.has(c)) {
+        const n = nearest(c, allKnown);
+        push('error', 'unknown-utility', `utilitaire « ${c} » inexistant`, n ? `remplacer par « ${n} »` : 'voir llms-full.txt › Utilitaires');
+      } else if (!utilities.has(c) && !Object.hasOwn(components, c) && c.length > 3) {
+        // Classe propre au projet ou faute de frappe ? Avertissement seulement si très proche d'une classe NoraIvoire.
+        const n = nearest(c, allKnown);
+        if (n && levenshtein(c, n) <= 2) push('warning', 'possible-typo', `« ${c} » ressemble à « ${n} »`, `remplacer par « ${n} » si c'était l'intention`);
+      }
+    }
+
+    for (const axis of ['tone', 'size']) {
+      const key = `data-${axis}`;
+      const v = attrs[key];
+      if (v === undefined || v === DYNAMIC || TEMPLATE_EXPR.test(v)) continue;
+      if (comps.length === 0) {
+        push('warning', 'orphan-variant', `${key}="${v}" sans composant NoraIvoire sur l'élément`);
+        continue;
+      }
+      for (const comp of comps) {
+        const allowed = components[comp].attributes[key];
+        if (!allowed.includes(v)) {
+          const n = nearest(v, allowed);
+          push('error', 'invalid-variant', `${key}="${v}" invalide pour .${comp} (valeurs : ${allowed.join(', ')})`, n ? `${key}="${n}"` : undefined);
+        }
+      }
+    }
+
+    const fxAttr = attrs['data-fx'];
+    if (fxAttr !== undefined && fxAttr !== DYNAMIC && !TEMPLATE_EXPR.test(fxAttr)) {
+      for (const fx of fxAttr.split(/\s+/).filter(Boolean)) {
+        if (!effects.has(fx)) {
+          const n = nearest(fx, [...effects]);
+          push('error', 'unknown-effect', `effet « ${fx} » inconnu`, n ? `data-fx="${n}"` : `effets : ${[...effects].join(', ')}`);
+        }
+      }
+    }
+
+    for (const comp of comps) {
+      const spec = components[comp];
+      if (!spec.elements.includes(tag) && !/^[a-z]+[-:.][a-z]/i.test(el.rawName) && !/^[A-Z]/.test(el.rawName)) {
+        push('warning', 'unexpected-element', `.${comp} sur <${tag}> (éléments prévus : ${spec.elements.join(', ')})`);
+      }
+      if (spec.a11y?.anchorRequiresHref && tag === 'a' && attrs.href === undefined) {
+        push('error', 'a11y-anchor-href', `<a class="${comp}"> sans href : ce n'est pas un lien`, 'ajouter href="…" ou utiliser <button type="button">');
+      }
+      if (spec.a11y?.requiresLabel && tag === 'button' && attrs['aria-label'] === undefined && attrs['aria-labelledby'] === undefined
+        && !hasAccessibleContent(text, tokens, el)) {
+        push('error', 'a11y-label', `<button class="${comp}"> sans texte ni aria-label`, 'ajouter un texte ou aria-label="…"');
+      }
+      checkFormComponent(comp, spec, el, text, tokens, elements, form, push);
+      checkPageComponent(comp, spec, el, text, tokens, elements, push);
+    }
+
+    if (attrs['aria-invalid'] === 'true' && attrs['aria-describedby'] === undefined && attrs['aria-errormessage'] === undefined) {
+      push('warning', 'a11y-invalid-message', `<${tag} aria-invalid="true"> sans message d'erreur relié`,
+        'ajouter aria-describedby="id-du-message" vers un <p class="field-error" id="id-du-message">');
+    }
+  }
+  return issues;
+}
+
+// ───────────── Formulaires ─────────────
+
+const NOT_LABELLABLE = new Set(['hidden', 'submit', 'button', 'reset', 'image']);
+const isStatic = (v) => typeof v === 'string' && v !== DYNAMIC && !TEMPLATE_EXPR.test(v);
+
+/** Index des libellés du document : <label for> statiques, présence de for dynamiques. */
+function formIndex(elements) {
+  const labelFor = new Set();
+  let dynamicFor = false;
+  for (const el of elements) {
+    if (el.name !== 'label') continue;
+    const f = el.attrs.for ?? el.attrs.htmlFor;
+    if (f === undefined) continue;
+    if (isStatic(f)) labelFor.add(f);
+    else dynamicFor = true;
+  }
+  return { labelFor, dynamicFor };
+}
+
+function ancestor(el, pred) {
+  for (let p = el.parent; p; p = p.parent) if (pred(p)) return p;
+  return null;
+}
+
+/** Descendants d'un élément : contigus après lui dans l'ordre du document. */
+function descendants(el, elements) {
+  const out = [];
+  for (let j = elements.indexOf(el) + 1; j < elements.length; j++) {
+    if (!ancestor(elements[j], (p) => p === el)) break;
+    out.push(elements[j]);
+  }
+  return out;
+}
+
+/** Un contrôle a-t-il un nom accessible : aria-label(ledby), <label> ancêtre ou <label for> relié à son id ? */
+function hasFormLabel(el, form) {
+  const a = el.attrs;
+  if ((a['aria-label'] !== undefined && a['aria-label'] !== '') || a['aria-labelledby'] !== undefined) return true;
+  if (ancestor(el, (p) => p.name === 'label')) return true;
+  const id = a.id;
+  if (id === undefined) return false;
+  if (!isStatic(id)) return form.dynamicFor || form.labelFor.size > 0; // identifiant calculé : on ne conclut pas
+  return form.labelFor.has(id) || form.dynamicFor;
+}
+
+/** Règles des composants de formulaire : label associé, input attendu, rôle d'interrupteur. */
+function checkFormComponent(comp, spec, el, text, tokens, elements, form, push) {
+  const shape = spec.shape;
+  const tag = el.name;
+  const opaque = (d) => /^[A-Z]/.test(d.rawName) || /[-:.]/.test(d.rawName); // composant de framework : contenu inconnu
+  if (shape === 'control') {
+    if (!spec.elements.includes(tag)) return;
+    if (tag === 'input' && isStatic(el.attrs.type) && NOT_LABELLABLE.has(el.attrs.type)) return;
+    if (!hasFormLabel(el, form)) {
+      const id = isStatic(el.attrs.id) ? el.attrs.id : 'mon-champ';
+      push('error', 'a11y-form-label', `<${tag} class="${comp}"> sans label associé`,
+        `ajouter <label for="${id}">…</label>${el.attrs.id === undefined ? ` et id="${id}"` : ''}, ou aria-label="…"`);
+    }
+  } else if (shape === 'toggle') {
+    if (tag !== 'label') return;
+    const inner = descendants(el, elements);
+    const inputType = spec.a11y?.inputType ?? 'checkbox';
+    const input = inner.find((d) => d.name === 'input');
+    if (!input) {
+      if (!inner.some(opaque)) {
+        const role = spec.a11y?.role && spec.a11y.role !== inputType ? ` role="${spec.a11y.role}"` : '';
+        push('error', 'a11y-toggle-input', `<label class="${comp}"> sans <input type="${inputType}">`, `<label class="${comp}"><input type="${inputType}"${role}> Texte</label>`);
+      }
+      return;
+    }
+    if (isStatic(input.attrs.type) && input.attrs.type !== inputType) {
+      push('error', 'a11y-toggle-input', `<input type="${input.attrs.type}"> dans .${comp} : type="${inputType}" attendu`, `type="${inputType}"`);
+    }
+    if (inputType === 'radio' && (input.attrs.name === undefined || input.attrs.name === '')) {
+      push('warning', 'a11y-radio-name', `<input type="radio"> de .${comp} sans name`, 'ajouter name="…" commun aux options du groupe (sélection exclusive, flèches du clavier)');
+    }
+    const role = spec.a11y?.role;
+    if (role && role !== inputType && input.attrs.role !== DYNAMIC && input.attrs.role !== role) {
+      push('error', 'a11y-switch-role', `<input> de .${comp} sans role="${role}"`, `ajouter role="${role}" sur l'input`);
+    }
+    const named = input.attrs['aria-label'] !== undefined || input.attrs['aria-labelledby'] !== undefined;
+    if (!named && !hasAccessibleContent(text, tokens, el)) {
+      push('error', 'a11y-form-label', `<label class="${comp}"> sans texte`, 'ajouter le texte du libellé dans le <label>');
+    }
+  } else if (shape === 'group') {
+    const inner = descendants(el, elements);
+    const hasLabel = inner.some((d) => d.name === 'label' || d.name === 'legend'
+      || (isStatic(d.attrs.class) && d.attrs.class.split(/\s+/).includes(`${comp}-label`)));
+    if (!hasLabel && !inner.some(opaque)) {
+      push('warning', 'field-label-missing', `.${comp} sans libellé`, `ajouter <label class="${comp}-label" for="…">…</label> (ou <legend> dans un <fieldset>)`);
+    }
+  }
+}
+
+// ───────────── Mise en page : lien, navigation, avatar, média ─────────────
+
+/** Classes qui signalent visuellement l'élément courant d'une navigation (Bootstrap, Tailwind, maison). */
+const ACTIVE_CLASSES = new Set(['active', 'is-active', 'current', 'is-current', 'selected', 'router-link-active', 'router-link-exact-active']);
+const classesOf = (el) => (isStatic(el.attrs.class) ? el.attrs.class.split(/\s+/).filter(Boolean) : []);
+const hasName = (a) => (a['aria-label'] !== undefined && a['aria-label'] !== '') || a['aria-labelledby'] !== undefined;
+const isHidden = (a) => a['aria-hidden'] === 'true' || a['aria-hidden'] === DYNAMIC;
+
+/** Une image a-t-elle un texte alternatif déclaré (alt, même vide pour une image décorative) ? */
+function imgAltOk(img) {
+  const a = img.attrs;
+  return a.alt !== undefined || a[':alt'] !== undefined || a['[alt]'] !== undefined || hasName(a) || isHidden(a) || a.role === 'presentation' || a.role === 'none';
+}
+
+function checkPageComponent(comp, spec, el, text, tokens, elements, push) {
+  const shape = spec.shape;
+  const tag = el.name;
+  const a = el.attrs;
+  if (shape === 'link') {
+    if (tag === 'a' && !hasName(a) && !hasAccessibleContent(text, tokens, el)) {
+      push('error', 'a11y-label', `<a class="${comp}"> sans texte ni aria-label`, 'ajouter le texte du lien (il doit dire où il mène)');
+    }
+  } else if (shape === 'avatar') {
+    if (tag === 'img' && !imgAltOk(el)) {
+      push('error', 'a11y-img-alt', `<img class="${comp}"> sans alt`, 'ajouter alt="Nom de la personne" (ou alt="" si l\'avatar est décoratif)');
+    } else if (tag !== 'img' && !hasName(a) && !isHidden(a)) {
+      push('error', 'a11y-img-alt', `<${tag} class="${comp}"> (initiales) sans nom accessible`, 'ajouter role="img" aria-label="Nom de la personne" (ou aria-hidden="true" si décoratif)');
+    } else if (tag !== 'img' && hasName(a) && a.role !== 'img' && a.role !== DYNAMIC) {
+      push('warning', 'a11y-img-role', `<${tag} class="${comp}" aria-label> sans role="img"`, 'ajouter role="img" : sans rôle, aria-label est ignoré sur un <span>');
+    }
+  } else if (shape === 'media') {
+    for (const img of descendants(el, elements).filter((d) => d.name === 'img')) {
+      if (!imgAltOk(img)) {
+        push('error', 'a11y-img-alt', `<img> de .${comp} sans alt`, 'décrire l\'image dans alt="…" (ou alt="" si elle est purement décorative)');
+      }
+    }
+  } else if (shape === 'nav') {
+    if (!hasName(a)) {
+      push('warning', 'a11y-nav-label', `<${tag} class="${comp}"> sans aria-label`, 'ajouter aria-label="Principale" (ou aria-labelledby) : plusieurs navigations doivent se distinguer');
+    }
+    for (const d of descendants(el, elements).filter((x) => x.name === 'a')) {
+      const flagged = [d, d.parent].some((x) => x && classesOf(x).some((k) => ACTIVE_CLASSES.has(k)));
+      if (flagged && d.attrs['aria-current'] === undefined) {
+        push('warning', 'a11y-nav-current', `lien actif de .${comp} sans aria-current`, 'ajouter aria-current="page" sur le lien de la page courante (la classe seule n\'est pas annoncée)');
+      }
+    }
+  }
+}
+
+function walk(dir, out) {
+  for (const name of readdirSync(dir)) {
+    if (IGNORED_DIRS.has(name)) continue;
+    const full = join(dir, name);
+    const st = lstatSync(full);
+    if (st.isSymbolicLink()) continue;
+    if (st.isDirectory()) walk(full, out);
+    else if (st.isFile() && st.size <= MAX_FILE && (EXTENSIONS.has(extname(name)) || name.endsWith('.component.html'))) out.push(full);
+  }
+  return out;
+}
+
+export function checkPaths(paths, manifest, cwd = process.cwd()) {
+  const files = [];
+  for (const p of paths) {
+    const st = lstatSync(p);
+    if (st.isDirectory()) walk(p, files);
+    else if (st.isFile()) files.push(p);
+  }
+  const issues = [];
+  for (const f of files.sort()) issues.push(...checkSource(readFileSync(f, 'utf8'), relative(cwd, f), manifest));
+  return { files: files.length, issues };
+}

package/src/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// NoraIvoire — CLI : nora check <chemins…> [--format=json|text] · nora audit [--format=json|text]
+// © 2026 Jonathan KABLAN — Propriétaire, tous droits réservés.
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { checkPaths } from './check.js';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(here, '..', '..', '..');
+const args = process.argv.slice(2);
+const cmd = args[0];
+const format = (args.find((a) => a.startsWith('--format=')) ?? '--format=text').split('=')[1];
+const positional = args.slice(1).filter((a) => !a.startsWith('--'));
+
+/** Manifest du dépôt source, sinon celui du paquet @jonathankablan/noraivoire-core installé. */
+function defaultManifest() {
+  const inRepo = join(repoRoot, 'packages', 'core', 'dist', 'manifest.json');
+  if (existsSync(inRepo)) return inRepo;
+  try {
+    return createRequire(import.meta.url).resolve('@jonathankablan/noraivoire-core/manifest.json');
+  } catch {
+    return inRepo;
+  }
+}
+
+function loadManifest() {
+  const flag = args.find((a) => a.startsWith('--manifest='));
+  const path = flag ? flag.slice('--manifest='.length) : defaultManifest();
+  if (!existsSync(path)) {
+    console.error('✖ manifest.json introuvable : lancer « npm run build » ou passer --manifest=<chemin>');
+    process.exit(2);
+  }
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+if (cmd === 'check') {
+  const manifest = loadManifest();
+  const { files, issues } = checkPaths(positional.length ? positional : ['.'], manifest);
+  const errors = issues.filter((i) => i.level === 'error').length;
+  if (format === 'json') {
+    console.log(JSON.stringify({ files, errors, warnings: issues.length - errors, issues }, null, 2));
+  } else {
+    for (const i of issues) {
+      console.log(`${i.level === 'error' ? '✖' : '⚠'} ${i.file}:${i.line}  [${i.rule}] ${i.message}${i.fix ? `\n    → ${i.fix}` : ''}`);
+    }
+    console.log(`\n${files} fichier(s) analysé(s) — ${errors} erreur(s), ${issues.length - errors} avertissement(s)`);
+  }
+  process.exit(errors ? 1 : 0);
+} else if (cmd === 'audit') {
+  // L'audit vérifie le dépôt source (spec, compilateur) : absent du paquet publié.
+  let runAudit;
+  try {
+    ({ runAudit } = await import('./audit.js'));
+  } catch {
+    console.error('✖ nora audit ne s\'exécute que dans le dépôt source NoraIvoire');
+    process.exit(2);
+  }
+  const report = runAudit(repoRoot);
+  if (format === 'json') {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    let cat = '';
+    for (const r of report.results) {
+      if (r.category !== cat) { cat = r.category; console.log(`\n■ ${cat.toUpperCase()}`); }
+      console.log(`  ${r.status === 'pass' ? '✔' : '✖'} ${r.detail}`);
+    }
+    console.log(`\nAudit NoraIvoire : ${report.passed}/${report.total} contrôles réussis, ${report.failed} échec(s).`);
+  }
+  process.exit(report.failed ? 1 : 0);
+} else {
+  console.log('Usage :\n  nora check <chemins…> [--format=json|text] [--manifest=<chemin>]\n  nora audit [--format=json|text]');
+  process.exit(cmd ? 1 : 0);
+}

package/src/tokenize.js

@@ -0,0 +1,406 @@
+// NoraIvoire — Tokenizer HTML tolérant pour `nora check` (HTML, Twig, JSP, JSX/TSX, Vue, Angular, Svelte).
+// © 2026 Jonathan KABLAN — Propriétaire, tous droits réservés.
+//
+// Écrit à la main, sans dépendance ni expression régulière à retour arrière :
+// chaque caractère est lu un nombre borné de fois, l'analyse est linéaire même
+// sur une entrée hostile. Le tokenizer ne rejette jamais un fichier : une
+// construction non fermée est consommée jusqu'à la fin, comme le ferait un
+// navigateur, ou relue comme du texte quand c'est plus prudent.
+
+const VOID = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const RAW_TEXT = new Set(['script', 'style']);
+const MAX_DEPTH = 16; // imbrication maximale d'expressions JSX analysées récursivement
+const MAX_TEMPLATE = 4096; // longueur maximale d'une expression de gabarit dans une valeur entre guillemets
+
+export const DYNAMIC = '__dynamic__';
+
+const isAlpha = (c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+const isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 13 || c === 12;
+const isNameChar = (c) => isAlpha(c) || (c >= 48 && c <= 57) || c === 95 || c === 45 || c === 58 || c === 46;
+
+/** Ouvreurs de gabarit reconnus et leur fermeture. L'ordre compte (`<%--` avant `<%`). */
+const TEMPLATES = [
+  ['{{', '}}', 'mustache'], // Twig, Vue, Angular, Handlebars
+  ['{%', '%}', 'twig'],
+  ['{#', '#}', 'twig-comment'],
+  ['<%--', '--%>', 'jsp-comment'],
+  ['<%', '%>', 'jsp'],
+];
+
+/** Recherche mémoïsée : indexOf(needle, from) amorti en O(n) sur tout le fichier. */
+function makeFinder(text) {
+  const cache = new Map();
+  return (needle, from) => {
+    const c = cache.get(needle);
+    if (c && c.from <= from && (c.at === -1 || c.at >= from)) return c.at;
+    const at = text.indexOf(needle, from);
+    cache.set(needle, { from, at });
+    return at;
+  };
+}
+
+/**
+ * Saute une expression JavaScript équilibrée commençant par `{` à la position i.
+ * Gère accolades imbriquées, chaînes '…' "…", gabarits `…${…}…` et commentaires.
+ * Retourne l'indice suivant l'accolade fermante, ou -1 si l'expression n'est pas fermée avant `limit`.
+ */
+export function skipBraces(text, i, limit = text.length) {
+  const stack = [0]; // profondeur d'accolades ; un niveau par gabarit `…` ouvert
+  let inTemplate = false;
+  i++;
+  while (i < limit) {
+    const c = text.charCodeAt(i);
+    if (inTemplate) {
+      if (c === 92) { i += 2; continue; }
+      if (c === 96) { inTemplate = false; i++; continue; }
+      if (c === 36 && text.charCodeAt(i + 1) === 123) { stack.push(0); inTemplate = false; i += 2; continue; }
+      i++;
+      continue;
+    }
+    if (c === 34 || c === 39) {
+      // chaîne simple : une fin de ligne la termine aussi (JS invalide, ou apostrophe dans du texte JSX)
+      i++;
+      while (i < limit) {
+        const d = text.charCodeAt(i);
+        if (d === 92) { i += 2; continue; }
+        if (d === c || d === 10) break;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (c === 96) { inTemplate = true; i++; continue; }
+    if (c === 47 && text.charCodeAt(i + 1) === 42) {
+      const end = text.indexOf('*/', i + 2);
+      if (end === -1 || end >= limit) return -1;
+      i = end + 2;
+      continue;
+    }
+    if (c === 123) { stack[stack.length - 1]++; i++; continue; }
+    if (c === 125) {
+      if (stack[stack.length - 1] > 0) { stack[stack.length - 1]--; i++; continue; }
+      if (stack.length === 1) return i + 1;
+      stack.pop();
+      inTemplate = true; // fin d'un ${…} : retour dans le gabarit
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+
+/** Normalise le nom d'un attribut selon les syntaxes de liaison des frameworks. */
+export function normalizeAttribute(raw) {
+  if (raw === '') return { kind: 'ignored', name: raw };
+  const c = raw[0];
+  if (c === '@' || c === '(' || c === '#' || c === '*' || raw.startsWith('v-on:') || raw.startsWith('on:')) return { kind: 'event', name: raw };
+  if (c === '[') {
+    let inner = raw.endsWith(']') ? raw.slice(1, -1) : raw.slice(1);
+    if (inner.startsWith('(')) return { kind: 'event', name: raw }; // [(ngModel)]
+    if (inner.startsWith('attr.')) inner = inner.slice(5);
+    return { kind: 'bound', name: inner };
+  }
+  if (c === ':') return { kind: 'bound', name: raw.slice(1) };
+  for (const p of ['v-bind:', 'bind:', 'th:']) if (raw.startsWith(p)) return { kind: 'bound', name: raw.slice(p.length) };
+  return { kind: 'plain', name: raw === 'className' ? 'class' : raw };
+}
+
+/** Valeur statique d'une expression JSX `{"…"}`, `{'…'}` ou `{`…`}` sans interpolation ; sinon null. */
+function jsxStaticString(expr) {
+  const s = expr.slice(1, -1).trim();
+  const q = s[0];
+  if ((q === '"' || q === "'" || q === '`') && s.length >= 2 && s.at(-1) === q) {
+    const body = s.slice(1, -1);
+    if (!body.includes(q) && !(q === '`' && body.includes('${'))) return body;
+  }
+  return null;
+}
+
+/**
+ * Découpe un texte en jetons. Positions absolues (base `offset`).
+ * Types : tag, endtag, text, comment, template, expr (accolade JSX dans le texte), raw, doctype.
+ */
+export function tokenize(text, offset = 0, depth = 0, end = text.length) {
+  const tokens = [];
+  const find = makeFinder(text);
+  let elFailed = false; // un `${` non fermé désactive l'analyse équilibrée des suivants (linéarité)
+  let i = offset;
+  let textStart = i;
+
+  const flushText = (to) => {
+    if (to > textStart) tokens.push({ type: 'text', start: textStart, end: to });
+  };
+
+  /** Tente de reconnaître un gabarit à la position j ; retourne la fin ou -1. */
+  const matchTemplate = (j, maxLen = Infinity) => {
+    for (const [open, close, syntax] of TEMPLATES) {
+      if (!text.startsWith(open, j)) continue;
+      const at = find(close, j + open.length);
+      if (at === -1 || at + close.length > end || at - j > maxLen) return null;
+      return { end: at + close.length, syntax };
+    }
+    if ((text.charCodeAt(j) === 36 || text.charCodeAt(j) === 35) && text.charCodeAt(j + 1) === 123 && !elFailed) {
+      // ${…} (JSP EL, gabarits JS) et #{…} (JSF)
+      const stop = Math.min(end, maxLen === Infinity ? end : j + maxLen);
+      const e = skipBraces(text, j + 1, stop);
+      if (e === -1) { elFailed = true; return null; }
+      return { end: e, syntax: 'el' };
+    }
+    return null;
+  };
+
+  while (i < end) {
+    const c = text.charCodeAt(i);
+
+    if (c === 123 || c === 36 || c === 35 || (c === 60 && text.charCodeAt(i + 1) === 37)) {
+      const t = matchTemplate(i);
+      if (t) {
+        flushText(i);
+        tokens.push({ type: 'template', syntax: t.syntax, start: i, end: t.end });
+        i = textStart = t.end;
+        continue;
+      }
+      if (c === 123) {
+        // accolade JSX : on la note sans sauter son contenu, pour analyser les balises imbriquées
+        flushText(i);
+        tokens.push({ type: 'expr', start: i, end: i + 1 });
+        i = textStart = i + 1;
+        continue;
+      }
+    }
+
+    if (c !== 60) { i++; continue; }
+    const n = text.charCodeAt(i + 1);
+
+    if (n === 33) { // <!
+      flushText(i);
+      if (text.startsWith('<!--', i)) {
+        const e = find('-->', i + 4);
+        const stop = e === -1 || e + 3 > end ? end : e + 3;
+        tokens.push({ type: 'comment', start: i, end: stop });
+        i = textStart = stop;
+      } else if (text.startsWith('<![CDATA[', i)) {
+        const e = find(']]>', i + 9);
+        const stop = e === -1 || e + 3 > end ? end : e + 3;
+        tokens.push({ type: 'comment', start: i, end: stop });
+        i = textStart = stop;
+      } else {
+        const e = find('>', i + 2);
+        const stop = e === -1 || e + 1 > end ? end : e + 1;
+        tokens.push({ type: 'doctype', start: i, end: stop });
+        i = textStart = stop;
+      }
+      continue;
+    }
+    if (n === 63) { // <? … ?> (XML, PHP)
+      flushText(i);
+      const e = find('?>', i + 2);
+      const stop = e === -1 || e + 2 > end ? end : e + 2;
+      tokens.push({ type: 'comment', start: i, end: stop });
+      i = textStart = stop;
+      continue;
+    }
+    if (n === 47 && isAlpha(text.charCodeAt(i + 2))) { // </nom>
+      flushText(i);
+      let j = i + 2;
+      while (j < end && isNameChar(text.charCodeAt(j))) j++;
+      const rawName = text.slice(i + 2, j);
+      const e = find('>', j);
+      const stop = e === -1 || e + 1 > end ? end : e + 1;
+      tokens.push({ type: 'endtag', name: rawName.toLowerCase(), rawName, start: i, end: stop });
+      i = textStart = stop;
+      continue;
+    }
+    if (n === 62 && depth > 0) { i += 2; continue; } // fragment JSX <>
+    if (!isAlpha(n)) { i++; continue; }
+
+    // Balise ouvrante
+    flushText(i);
+    const tag = readTag(i);
+    tokens.push(tag);
+    for (const nested of tag.nested) tokens.push(nested);
+    delete tag.nested;
+    i = textStart = tag.end;
+
+    if (!tag.selfClosing && RAW_TEXT.has(tag.name)) {
+      // contenu brut : rien n'y est une balise jusqu'à </script> ou </style>
+      let k = tag.end;
+      const closer = `</${tag.name}`;
+      let e = -1;
+      while (k < end) {
+        e = text.indexOf('<', k);
+        if (e === -1 || e >= end) { e = -1; break; }
+        if (text.slice(e, e + closer.length).toLowerCase() === closer && !isNameChar(text.charCodeAt(e + closer.length))) break;
+        k = e + 1;
+        e = -1;
+      }
+      const stop = e === -1 ? end : e;
+      if (stop > tag.end) tokens.push({ type: 'raw', start: tag.end, end: stop });
+      i = textStart = stop;
+    }
+  }
+  flushText(end);
+  return tokens;
+
+  function readTag(start) {
+    let j = start + 1;
+    while (j < end && isNameChar(text.charCodeAt(j))) j++;
+    const rawName = text.slice(start + 1, j);
+    const tag = { type: 'tag', name: rawName.toLowerCase(), rawName, start, end, attributes: [], selfClosing: false, incomplete: true, nested: [] };
+
+    while (j < end) {
+      const c = text.charCodeAt(j);
+      if (isSpace(c)) { j++; continue; }
+      if (c === 62) { tag.end = j + 1; tag.incomplete = false; return tag; }
+      if (c === 47 && text.charCodeAt(j + 1) === 62) { tag.end = j + 2; tag.selfClosing = true; tag.incomplete = false; return tag; }
+      if (c === 47) { j++; continue; }
+
+      // Gabarits dans la balise : {% if %}disabled{% endif %}, {{ attrs }}, <%= … %>, ${…}
+      if (c === 123 && (text.charCodeAt(j + 1) === 123 || text.charCodeAt(j + 1) === 37 || text.charCodeAt(j + 1) === 35)
+        || (c === 60 && text.charCodeAt(j + 1) === 37) || ((c === 36 || c === 35) && text.charCodeAt(j + 1) === 123)) {
+        const t = matchTemplate(j);
+        if (t) { tag.attributes.push({ name: '', rawName: text.slice(j, t.end), kind: 'template', value: DYNAMIC, start: j }); j = t.end; continue; }
+      }
+      // Décomposition JSX {...props}
+      if (c === 123) {
+        const e = skipBraces(text, j, end);
+        if (e === -1) { tag.end = end; return tag; }
+        tag.attributes.push({ name: '', rawName: text.slice(j, e), kind: 'spread', value: DYNAMIC, start: j });
+        if (depth < MAX_DEPTH) tag.nested.push(...tokenize(text, j + 1, depth + 1, e - 1).filter((t) => t.type === 'tag').map((t) => ({ ...t, inAttribute: true })));
+        j = e;
+        continue;
+      }
+
+      // Nom d'attribut (jusqu'à espace, =, >, /> ou guillemet)
+      const nameStart = j;
+      while (j < end) {
+        const d = text.charCodeAt(j);
+        if (isSpace(d) || d === 61 || d === 62 || d === 34 || d === 39 || (d === 47 && text.charCodeAt(j + 1) === 62)) break;
+        j++;
+      }
+      if (j === nameStart) { j++; continue; } // guillemet isolé : ignoré
+      const rawAttr = text.slice(nameStart, j);
+      let k = j;
+      while (k < end && isSpace(text.charCodeAt(k))) k++;
+      const attr = { ...normalizeAttribute(rawAttr), rawName: rawAttr, value: '', quoted: false, start: nameStart };
+      if (text.charCodeAt(k) !== 61) { // attribut booléen
+        attr.boolean = true;
+        tag.attributes.push(attr);
+        continue;
+      }
+      k++;
+      while (k < end && isSpace(text.charCodeAt(k))) k++;
+      const q = text.charCodeAt(k);
+      if (q === 34 || q === 39) {
+        // valeur entre guillemets ; les gabarits qu'elle contient peuvent eux-mêmes contenir ce guillemet
+        let m = k + 1;
+        let dynamic = false;
+        while (m < end && text.charCodeAt(m) !== q) {
+          const d = text.charCodeAt(m);
+          if (d === 123 || d === 36 || d === 35 || (d === 60 && text.charCodeAt(m + 1) === 37)) {
+            const t = matchTemplate(m, MAX_TEMPLATE);
+            if (t) { dynamic = true; m = t.end; continue; }
+          }
+          m++;
+        }
+        if (m >= end) { tag.end = end; return tag; } // guillemet jamais fermé
+        attr.value = text.slice(k + 1, m);
+        attr.quoted = true;
+        if (dynamic) attr.template = true;
+        j = m + 1;
+      } else if (q === 123) {
+        const e = skipBraces(text, k, end);
+        if (e === -1) { tag.end = end; return tag; }
+        const expr = text.slice(k, e);
+        const s = jsxStaticString(expr);
+        attr.value = s ?? DYNAMIC;
+        attr.jsx = true;
+        if (s === null && depth < MAX_DEPTH) tag.nested.push(...tokenize(text, k + 1, depth + 1, e - 1).filter((t) => t.type === 'tag').map((t) => ({ ...t, inAttribute: true })));
+        j = e;
+      } else {
+        let m = k;
+        while (m < end) {
+          const d = text.charCodeAt(m);
+          if (isSpace(d) || d === 62) break;
+          if (d === 47 && text.charCodeAt(m + 1) === 62) break;
+          m++;
+        }
+        attr.value = text.slice(k, m);
+        j = m;
+      }
+      tag.attributes.push(attr);
+    }
+    tag.end = end;
+    return tag;
+  }
+}
+
+/**
+ * Réduit la liste d'attributs d'une balise en dictionnaire nom → valeur.
+ * Les liaisons (`:href`, `[href]`, `v-bind:href`, `href={url}`) valent DYNAMIC ;
+ * une valeur statique l'emporte toujours sur une liaison du même nom ; les
+ * événements, décompositions et gabarits sont ignorés.
+ */
+export function attributeMap(attributes) {
+  const map = Object.create(null);
+  for (const a of attributes) {
+    if (a.kind === 'plain') {
+      if (!(a.name in map) || map[a.name] === DYNAMIC) map[a.name] = a.value;
+    } else if (a.kind === 'bound') {
+      if (!(a.name in map)) map[a.name] = DYNAMIC;
+    }
+  }
+  return map;
+}
+
+/**
+ * Analyse un document : jetons + éléments ouvrants avec parent, fermeture et dictionnaire d'attributs.
+ * Chaque élément : { name, rawName, start, end, line, attrs, attributes, selfClosing, parent, close, tokenIndex, closeTokenIndex }.
+ * `close` vaut la position de la balise fermante correspondante (null si implicite ou absente).
+ */
+export function parseDocument(text) {
+  const tokens = tokenize(text);
+  const lines = lineStarts(text);
+  const elements = [];
+  const stack = [];
+  for (let t = 0; t < tokens.length; t++) {
+    const tok = tokens[t];
+    if (tok.type === 'tag') {
+      if (tok.incomplete) continue;
+      const el = {
+        name: tok.name, rawName: tok.rawName, start: tok.start, end: tok.end, line: lineAt(lines, tok.start),
+        attrs: attributeMap(tok.attributes), attributes: tok.attributes, selfClosing: tok.selfClosing,
+        parent: stack.at(-1) ?? null, close: null, tokenIndex: t, closeTokenIndex: null,
+      };
+      elements.push(el);
+      if (!tok.selfClosing && !tok.inAttribute && !VOID.has(tok.name)) stack.push(el);
+    } else if (tok.type === 'endtag') {
+      // fermeture tolérante : on dépile jusqu'à l'élément correspondant, s'il est ouvert
+      let k = stack.length - 1;
+      while (k >= 0 && stack[k].rawName !== tok.rawName && stack[k].name !== tok.name) k--;
+      if (k < 0) continue;
+      stack[k].close = tok.start;
+      stack[k].closeTokenIndex = t;
+      stack.length = k;
+    }
+  }
+  return { tokens, elements, lines };
+}
+
+/** Débuts de ligne, pour convertir une position en numéro de ligne par dichotomie. */
+export function lineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+  return starts;
+}
+
+export function lineAt(starts, index) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1;
+    if (starts[mid] <= index) lo = mid; else hi = mid - 1;
+  }
+  return lo + 1;
+}