plugin-eco 0.1.0

package/out/languages.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXCLUDED_DIRS = exports.LANGUAGES = exports.RULE_CONTEXTS = void 0;
+exports.ruleAppliesIn = ruleAppliesIn;
+exports.specFor = specFor;
+exports.isSupported = isSupported;
+exports.grammarFiles = grammarFiles;
+exports.excludeGlob = excludeGlob;
+exports.globFor = globFor;
+exports.specForPath = specForPath;
+/**
+ * Contexte d'exécution dans lequel chaque règle a un sens.
+ *
+ * `'any'` signifie « partout, y compris quand le contexte est indéterminé ».
+ * Une règle restreinte ne se déclenche **pas** sur un fichier `unknown` : sans
+ * certitude, mieux vaut se taire que produire un faux positif.
+ */
+exports.RULE_CONTEXTS = {
+    'nested-loops': 'any',
+    'string-concat-in-loop': 'any',
+    'object-creation-in-loop': 'any',
+    'regex-compile-in-loop': 'any',
+    'blocking-io-in-loop': 'any',
+    'sql-without-limit': 'any',
+    // Enchaîner des attentes coûte des allers-retours des deux côtés.
+    'await-in-loop': 'any',
+    // Les API synchrones de Node n'existent que sur un serveur.
+    'sync-io-in-function': ['server'],
+    // Un timer permanent est payé par chaque appareil qui affiche la page.
+    'polling-interval': ['client'],
+    'unthrottled-event-listener': ['client'],
+    // Le poids du bundle est transféré sur le réseau vers chaque visiteur.
+    'whole-library-import': ['client'],
+};
+/** La règle s'applique-t-elle à un fichier dont le contexte est celui-ci ? */
+function ruleAppliesIn(rule, context) {
+    const allowed = exports.RULE_CONTEXTS[rule];
+    return allowed === 'any' || allowed.includes(context);
+}
+// --- Noms de nœuds --------------------------------------------------------
+const JAVA_NODES = {
+    loops: ['for_statement', 'enhanced_for_statement', 'while_statement', 'do_statement'],
+    objectCreation: ['object_creation_expression'],
+    call: ['method_invocation'],
+    stringLiteral: ['string_literal'],
+    compoundAssignment: ['assignment_expression'],
+    functions: ['method_declaration', 'constructor_declaration', 'lambda_expression'],
+};
+// Les grammaires typescript et tsx étendent toutes deux javascript :
+// les noms de nœuds sont identiques pour les trois.
+const JS_NODES = {
+    loops: ['for_statement', 'for_in_statement', 'while_statement', 'do_statement'],
+    objectCreation: ['new_expression'],
+    call: ['call_expression'],
+    stringLiteral: ['string', 'template_string'],
+    compoundAssignment: ['augmented_assignment_expression'],
+    functions: [
+        'function_declaration', 'function_expression', 'arrow_function',
+        'method_definition', 'generator_function_declaration',
+    ],
+};
+// --- Règles ---------------------------------------------------------------
+const JAVA_RULES = [
+    'nested-loops',
+    'string-concat-in-loop',
+    'object-creation-in-loop',
+    'regex-compile-in-loop',
+    'blocking-io-in-loop',
+    'sql-without-limit',
+];
+/**
+ * JS/TS n'hérite que des règles réellement pertinentes.
+ *
+ * `string-concat-in-loop` et `object-creation-in-loop` sont volontairement
+ * absentes : V8 représente les concaténations par des ropes et son GC
+ * générationnel rend l'allocation à courte durée de vie bon marché. Les porter
+ * produirait du bruit sur du code sain.
+ *
+ * S'y ajoutent les règles propres au web, dont plusieurs ne valent que d'un
+ * côté : voir RULE_CONTEXTS.
+ */
+const JS_RULES = [
+    'nested-loops',
+    'sql-without-limit',
+    'regex-compile-in-loop',
+    'await-in-loop',
+    'sync-io-in-function',
+    'polling-interval',
+    'unthrottled-event-listener',
+    'whole-library-import',
+];
+// --- Descripteurs ---------------------------------------------------------
+exports.LANGUAGES = [
+    {
+        label: 'Java',
+        grammarFile: 'tree-sitter-java.wasm',
+        vscodeLanguageIds: ['java'],
+        extensions: ['.java'],
+        nodes: JAVA_NODES,
+        rules: JAVA_RULES,
+        fixedContext: 'server',
+    },
+    {
+        // tsx couvre .js et .jsx : c'est un sur-ensemble de la grammaire javascript,
+        // qui devient inutile à embarquer.
+        label: 'JavaScript',
+        grammarFile: 'tree-sitter-tsx.wasm',
+        vscodeLanguageIds: ['javascript', 'javascriptreact'],
+        extensions: ['.js', '.jsx', '.mjs', '.cjs'],
+        nodes: JS_NODES,
+        rules: JS_RULES,
+    },
+    {
+        // .ts exige la grammaire typescript : tsx lit `<T>valeur` comme une
+        // ouverture JSX et perd le reste du fichier (mesuré le 3 sept. 2026).
+        label: 'TypeScript',
+        grammarFile: 'tree-sitter-typescript.wasm',
+        vscodeLanguageIds: ['typescript'],
+        extensions: ['.ts'],
+        nodes: JS_NODES,
+        rules: JS_RULES,
+    },
+    {
+        label: 'TypeScript React',
+        grammarFile: 'tree-sitter-tsx.wasm',
+        vscodeLanguageIds: ['typescriptreact'],
+        extensions: ['.tsx'],
+        nodes: JS_NODES,
+        rules: JS_RULES,
+    },
+];
+/** Descripteur correspondant à un `languageId` VSCode, ou undefined. */
+function specFor(languageId) {
+    return exports.LANGUAGES.find(l => l.vscodeLanguageIds.includes(languageId));
+}
+/** Le langage est-il analysable ? */
+function isSupported(languageId) {
+    return specFor(languageId) !== undefined;
+}
+/** Fichiers WASM à charger, sans doublon (tsx sert deux descripteurs). */
+function grammarFiles() {
+    return [...new Set(exports.LANGUAGES.map(l => l.grammarFile))];
+}
+/**
+ * Dossiers exclus de toute analyse de projet.
+ *
+ * Partagé par le scan VSCode et le CLI : deux listes divergentes donneraient
+ * deux verdicts différents sur le même dépôt, ce qui ruinerait la confiance
+ * dans l'outil bien plus sûrement qu'une règle imparfaite.
+ */
+exports.EXCLUDED_DIRS = [
+    'node_modules', 'target', 'build', 'dist', 'bin', 'out',
+    '.git', '.gradle', '.idea', '.next', 'coverage', 'vendor',
+];
+/** Motif VSCode excluant ces dossiers. */
+function excludeGlob() {
+    return `**/{${exports.EXCLUDED_DIRS.join(',')}}/**`;
+}
+/** Motif de recherche VSCode pour un langage, dérivé de ses extensions. */
+function globFor(spec) {
+    const exts = spec.extensions.map(e => e.replace(/^\./, ''));
+    return exts.length === 1 ? `**/*.${exts[0]}` : `**/*.{${exts.join(',')}}`;
+}
+/** Descripteur correspondant à un chemin de fichier, ou undefined. */
+function specForPath(filePath) {
+    const lower = filePath.toLowerCase();
+    return exports.LANGUAGES.find(l => l.extensions.some(e => lower.endsWith(e)));
+}
+//# sourceMappingURL=languages.js.map

package/out/parser.d.ts

@@ -0,0 +1,28 @@
+import Parser from 'web-tree-sitter';
+import { LanguageSpec } from './languages';
+/**
+ * Initialise web-tree-sitter et charge toutes les grammaires déclarées.
+ * Doit être appelé une seule fois dans activate().
+ *
+ * Les .wasm sont lus dans out/wasm/, où le script de build les a copiés :
+ * node_modules n'est pas présent dans un .vsix installé.
+ *
+ * Le chargement est immédiat plutôt que paresseux : une grammaire coûte
+ * quelques millisecondes (mesuré : 5 ms pour tsx, 2 ms pour java), ce qui ne
+ * justifie pas la complexité d'un chargement à la demande.
+ *
+ * @param extensionPath racine de l'extension (context.extensionUri.fsPath).
+ *   Par défaut, la racine du paquet installé : un consommateur npm ne peut pas
+ *   deviner ce chemin, VSCode le fournit explicitement.
+ */
+export declare function initParser(extensionPath?: string): Promise<void>;
+/**
+ * Parse du code source avec la grammaire du langage indiqué.
+ *
+ * @param code source à analyser
+ * @param languageId `languageId` VSCode ('java', 'typescriptreact'…)
+ * @throws si le parser n'est pas initialisé ou le langage non supporté
+ */
+export declare function parse(code: string, languageId: string): Parser.Tree;
+/** Variante prenant directement un descripteur, pour le scan workspace. */
+export declare function parseWith(code: string, spec: LanguageSpec): Parser.Tree;

package/out/parser.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initParser = initParser;
+exports.parse = parse;
+exports.parseWith = parseWith;
+const web_tree_sitter_1 = __importDefault(require("web-tree-sitter"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const languages_1 = require("./languages");
+let _parser = null;
+/** Grammaires chargées, indexées par nom de fichier WASM. */
+const _grammars = new Map();
+/**
+ * Initialise web-tree-sitter et charge toutes les grammaires déclarées.
+ * Doit être appelé une seule fois dans activate().
+ *
+ * Les .wasm sont lus dans out/wasm/, où le script de build les a copiés :
+ * node_modules n'est pas présent dans un .vsix installé.
+ *
+ * Le chargement est immédiat plutôt que paresseux : une grammaire coûte
+ * quelques millisecondes (mesuré : 5 ms pour tsx, 2 ms pour java), ce qui ne
+ * justifie pas la complexité d'un chargement à la demande.
+ *
+ * @param extensionPath racine de l'extension (context.extensionUri.fsPath).
+ *   Par défaut, la racine du paquet installé : un consommateur npm ne peut pas
+ *   deviner ce chemin, VSCode le fournit explicitement.
+ */
+async function initParser(extensionPath = path.join(__dirname, '..')) {
+    if (_parser)
+        return; // déjà initialisé
+    const wasmDir = path.join(extensionPath, 'out', 'wasm');
+    // Le runtime emscripten réclame tree-sitter.wasm par son nom de fichier
+    await web_tree_sitter_1.default.init({
+        locateFile(scriptName) {
+            return path.join(wasmDir, scriptName);
+        }
+    });
+    for (const file of (0, languages_1.grammarFiles)()) {
+        const buffer = fs.readFileSync(path.join(wasmDir, file));
+        _grammars.set(file, await web_tree_sitter_1.default.Language.load(buffer));
+    }
+    _parser = new web_tree_sitter_1.default();
+}
+/**
+ * Parse du code source avec la grammaire du langage indiqué.
+ *
+ * @param code source à analyser
+ * @param languageId `languageId` VSCode ('java', 'typescriptreact'…)
+ * @throws si le parser n'est pas initialisé ou le langage non supporté
+ */
+function parse(code, languageId) {
+    const spec = (0, languages_1.specFor)(languageId);
+    if (!spec) {
+        throw new Error(`Langage non supporté : ${languageId}`);
+    }
+    return parseWith(code, spec);
+}
+/** Variante prenant directement un descripteur, pour le scan workspace. */
+function parseWith(code, spec) {
+    if (!_parser) {
+        throw new Error('Parser non initialisé. Appeler initParser() d\'abord.');
+    }
+    const grammar = _grammars.get(spec.grammarFile);
+    if (!grammar) {
+        throw new Error(`Grammaire non chargée : ${spec.grammarFile}`);
+    }
+    _parser.setLanguage(grammar);
+    return _parser.parse(code);
+}
+//# sourceMappingURL=parser.js.map

package/out/rules.d.ts

@@ -0,0 +1,18 @@
+import Parser from 'web-tree-sitter';
+import { ExecutionContext, Finding } from './types';
+import { LanguageSpec } from './languages';
+/**
+ * Parcourt l'AST et collecte les findings énergivores applicables au langage.
+ *
+ * Les règles évaluées, comme les noms de nœuds, viennent du descripteur : ce
+ * module ne connaît aucun langage en particulier.
+ *
+ * Règles implémentées :
+ *  1. nested-loops             Boucle imbriquée               (haute,   poids 15)
+ *  2. string-concat-in-loop    Concaténation `+=` en boucle   (moyenne, poids  7)
+ *  3. object-creation-in-loop  Instanciation en boucle        (moyenne, poids  7)
+ *  4. regex-compile-in-loop    Pattern.compile() en boucle    (haute,   poids 12)
+ *  5. blocking-io-in-loop      I/O bloquant en boucle         (haute,   poids 12)
+ *  6. sql-without-limit        Requête SQL sans LIMIT         (haute,   poids 12)
+ */
+export declare function collectFindings(root: Parser.SyntaxNode, spec: LanguageSpec, context?: ExecutionContext): Finding[];

package/out/rules.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectFindings = collectFindings;
+const languages_1 = require("./languages");
+/** Méthodes d'I/O bloquantes à détecter lorsqu'elles sont appelées en boucle. */
+const IO_METHOD_NAMES = new Set([
+    'readLine', 'readAllBytes', 'readString', 'readAllLines',
+    'readNBytes', 'readFully', 'read', 'nextLine',
+]);
+/** API synchrones de Node : elles bloquent la boucle d'événements. */
+const SYNC_NODE_METHODS = new Set([
+    'readFileSync', 'writeFileSync', 'appendFileSync', 'existsSync',
+    'readdirSync', 'statSync', 'lstatSync', 'mkdirSync', 'rmSync',
+    'unlinkSync', 'copyFileSync', 'readlinkSync', 'execSync', 'spawnSync',
+    'execFileSync',
+]);
+/** Événements tirés en rafale pendant l'interaction. */
+const HIGH_FREQUENCY_EVENTS = new Set([
+    'scroll', 'resize', 'mousemove', 'wheel', 'touchmove', 'pointermove', 'drag',
+]);
+/** Leurs équivalents en attributs JSX. */
+const HIGH_FREQUENCY_JSX_PROPS = new Set([
+    'onScroll', 'onMouseMove', 'onWheel', 'onTouchMove', 'onPointerMove', 'onDrag',
+]);
+/**
+ * Bibliothèques dont l'import par défaut embarque tout le paquet, là où un
+ * import nommé ou un sous-chemin ne prendrait que le nécessaire.
+ */
+const HEAVY_MODULES = new Set([
+    'lodash', 'underscore', 'moment', 'rxjs', 'jquery',
+]);
+/** En dessous, un timer permanent maintient le processeur éveillé en continu. */
+const FREQUENT_INTERVAL_MS = 1000;
+/** Un gestionnaire passé par `debounce()` ou `throttle()` est déjà maîtrisé. */
+const THROTTLE_PATTERN = /debounce|throttle|raf|requestAnimationFrame/i;
+/**
+ * Une vraie requête, pas une chaîne qui contient les mots.
+ *
+ * Deux faux positifs successifs ont façonné ces critères :
+ *  - `includes('SELECT')` classait `"selection"` et `"onSelect"` comme des
+ *    requêtes — 34 alertes sur le seul compilateur TypeScript ;
+ *  - exiger seulement `SELECT` puis `FROM` en délimiteurs de mot ne suffisait
+ *    pas non plus : un bloc CSS-in-JS contenant `input, select, textarea {…}`
+ *    et `@keyframes spin { from {…} }` déclenchait la règle.
+ *
+ * Une requête *commence* par `SELECT`, éventuellement précédé d'un `WITH`, et
+ * contient les deux mots-clés.
+ *
+ * **Trois motifs sans quantificateur imbriqué plutôt qu'un seul.** La version
+ * combinée `/^\s*(WITH\b[\s\S]*?)?SELECT\b[\s\S]*\bFROM\b/` était quadratique :
+ * sur une chaîne commençant par `WITH` et enchaînant des `SELECT` sans jamais
+ * de `FROM`, le temps quadruplait à chaque doublement de taille — 63 ms pour
+ * 36 Ko, plusieurs secondes pour quelques centaines de Ko. Un littéral forgé
+ * suffisait à faire traîner une analyse, ce qui compte quand la CI examine le
+ * code d'une contribution extérieure. Chacun de ces trois motifs est linéaire.
+ */
+const SQL_STARTS = /^\s*(SELECT|WITH)\b/;
+const HAS_SELECT = /\bSELECT\b/;
+const HAS_FROM = /\bFROM\b/;
+function looksLikeQuery(upper) {
+    return SQL_STARTS.test(upper) && HAS_SELECT.test(upper) && HAS_FROM.test(upper);
+}
+/**
+ * Parcourt l'AST et collecte les findings énergivores applicables au langage.
+ *
+ * Les règles évaluées, comme les noms de nœuds, viennent du descripteur : ce
+ * module ne connaît aucun langage en particulier.
+ *
+ * Règles implémentées :
+ *  1. nested-loops             Boucle imbriquée               (haute,   poids 15)
+ *  2. string-concat-in-loop    Concaténation `+=` en boucle   (moyenne, poids  7)
+ *  3. object-creation-in-loop  Instanciation en boucle        (moyenne, poids  7)
+ *  4. regex-compile-in-loop    Pattern.compile() en boucle    (haute,   poids 12)
+ *  5. blocking-io-in-loop      I/O bloquant en boucle         (haute,   poids 12)
+ *  6. sql-without-limit        Requête SQL sans LIMIT         (haute,   poids 12)
+ */
+function collectFindings(root, spec, context = 'unknown') {
+    const findings = [];
+    const ctx = {
+        nodes: spec.nodes,
+        active: (rule) => spec.rules.includes(rule) && (0, languages_1.ruleAppliesIn)(rule, context),
+    };
+    traverse(root, { loopDepth: 0, inLoop: false, inLoopHere: false, inFunction: false }, findings, ctx);
+    return findings;
+}
+// ---------------------------------------------------------------------------
+// Traversée récursive
+// ---------------------------------------------------------------------------
+function traverse(node, scope, findings, ctx) {
+    const { loopDepth, inLoop } = scope;
+    const isLoop = ctx.nodes.loops.includes(node.type);
+    const isFunction = ctx.nodes.functions.includes(node.type);
+    // Une fonction imbriquée dans une boucle s'exécute dans son propre flot :
+    // `items.map(async x => await f(x))` lance des attentes concurrentes, pas
+    // séquentielles. La profondeur de boucle « locale » repart donc à zéro.
+    const next = {
+        loopDepth: isLoop ? loopDepth + 1 : loopDepth,
+        inLoop: inLoop || isLoop,
+        inLoopHere: isFunction ? false : (scope.inLoopHere || isLoop),
+        inFunction: scope.inFunction || isFunction,
+    };
+    const nextInLoop = next.inLoop;
+    // ── Règle 1 : boucle imbriquée ───────────────────────────────────────────
+    if (ctx.active('nested-loops') && isLoop && loopDepth >= 1) {
+        findings.push({
+            startLine: node.startPosition.row,
+            startChar: node.startPosition.column,
+            endLine: node.startPosition.row,
+            endChar: 9999,
+            message: 'Boucle imbriquée — complexité ≥ O(n²), forte consommation énergétique. ' +
+                'Envisager une restructuration algorithmique ou une mise en cache.',
+            severity: 'high',
+            weight: 15,
+        });
+    }
+    // ── Règle 2 : concaténation String avec += en boucle ─────────────────────
+    if (ctx.active('string-concat-in-loop') && nextInLoop &&
+        ctx.nodes.compoundAssignment.includes(node.type)) {
+        if (node.children.some(c => c.text === '+=')) {
+            findings.push({
+                startLine: node.startPosition.row,
+                startChar: node.startPosition.column,
+                endLine: node.endPosition.row,
+                endChar: node.endPosition.column,
+                message: 'Concaténation potentielle via `+=` en boucle — ' +
+                    "préférer StringBuilder pour éviter la création d'objets String répétés.",
+                severity: 'medium',
+                weight: 7,
+            });
+        }
+    }
+    // ── Règle 3 : création d'objet en boucle ─────────────────────────────────
+    if (ctx.active('object-creation-in-loop') && nextInLoop &&
+        ctx.nodes.objectCreation.includes(node.type)) {
+        findings.push({
+            startLine: node.startPosition.row,
+            startChar: node.startPosition.column,
+            endLine: node.endPosition.row,
+            endChar: node.endPosition.column,
+            message: "Création d'objet (`new`) en boucle — envisager de déplacer l'instanciation " +
+                'hors de la boucle ou de réutiliser l\'instance existante.',
+            severity: 'medium',
+            weight: 7,
+        });
+    }
+    // ── Règles 4 et 5 : appels de méthodes détectables en boucle ─────────────
+    // Ces deux règles lisent les champs `name` et `object`, propres à la
+    // structure d'appel de Java. Elles ne sont pour l'instant déclarées que
+    // pour ce langage ; l'équivalent JS/TS relève du jeu de règles web.
+    if (nextInLoop && ctx.nodes.call.includes(node.type)) {
+        const methodName = node.childForFieldName('name')?.text ?? '';
+        const objectName = node.childForFieldName('object')?.text ?? '';
+        // Règle 4 : Pattern.compile() en boucle
+        if (ctx.active('regex-compile-in-loop') && objectName === 'Pattern' && methodName === 'compile') {
+            findings.push({
+                startLine: node.startPosition.row,
+                startChar: node.startPosition.column,
+                endLine: node.endPosition.row,
+                endChar: node.endPosition.column,
+                message: 'Pattern.compile() appelé en boucle — compiler la regex une seule fois ' +
+                    'en dehors de la boucle (constante statique ou champ de classe).',
+                severity: 'high',
+                weight: 12,
+            });
+        }
+        // Règle 5 : I/O bloquant en boucle
+        if (ctx.active('blocking-io-in-loop') && IO_METHOD_NAMES.has(methodName)) {
+            findings.push({
+                startLine: node.startPosition.row,
+                startChar: node.startPosition.column,
+                endLine: node.endPosition.row,
+                endChar: node.endPosition.column,
+                message: `Appel I/O bloquant \`${methodName}()\` en boucle — ` +
+                    'charger les données hors de la boucle ou traiter en batch.',
+                severity: 'high',
+                weight: 12,
+            });
+        }
+    }
+    // ── Règle 6 : requête SQL sans pagination (partout, pas seulement en boucle) ──
+    if (ctx.active('sql-without-limit') && ctx.nodes.stringLiteral.includes(node.type)) {
+        // Sans retirer les guillemets, l'ancrage en tête ne peut pas s'appliquer.
+        const upper = unquote(node.text).toUpperCase();
+        if (looksLikeQuery(upper) && !upper.includes('LIMIT') && !upper.includes('ROWNUM')) {
+            findings.push({
+                startLine: node.startPosition.row,
+                startChar: node.startPosition.column,
+                endLine: node.endPosition.row,
+                endChar: node.endPosition.column,
+                message: 'Requête SQL sans clause LIMIT détectée — ajouter une pagination ' +
+                    'pour éviter de charger un volume non borné de données.',
+                severity: 'high',
+                weight: 12,
+            });
+        }
+    }
+    // ── Règles web ───────────────────────────────────────────────────────────
+    // Les cinq suivantes sont propres à JS/TS : elles lisent des formes d'arbre
+    // et des API qui n'existent que là, et ne sont déclarées que pour ces
+    // langages. Même convention que les règles 4 et 5 pour Java.
+    // Attente enchaînée dans une boucle
+    if (ctx.active('await-in-loop') && scope.inLoopHere && node.type === 'await_expression') {
+        findings.push({
+            ...span(node),
+            message: 'Attente (`await`) dans une boucle — les appels s\'enchaînent au lieu de ' +
+                'se recouvrir. Collecter les promesses et les attendre ensemble ' +
+                '(`Promise.all`), sauf si l\'ordre est réellement nécessaire.',
+            severity: 'high',
+            weight: 12,
+        });
+    }
+    if (ctx.nodes.call.includes(node.type)) {
+        const callee = node.childForFieldName('function');
+        const calleeName = callee?.type === 'member_expression'
+            ? callee.childForFieldName('property')?.text ?? ''
+            : callee?.text ?? '';
+        const args = node.childForFieldName('arguments')?.namedChildren ?? [];
+        // I/O synchrone dans une fonction : au démarrage c'est acceptable, dans
+        // une fonction ça se répète et bloque la boucle d'événements.
+        if (ctx.active('sync-io-in-function') && scope.inFunction && SYNC_NODE_METHODS.has(calleeName)) {
+            findings.push({
+                ...span(node),
+                message: `Appel synchrone \`${calleeName}()\` dans une fonction — il bloque la ` +
+                    'boucle d\'événements et donc toutes les requêtes en cours. Préférer ' +
+                    'la variante asynchrone (`fs/promises`).',
+                severity: 'high',
+                weight: 12,
+            });
+        }
+        // Polling : un timer permanent empêche l'appareil de se mettre au repos.
+        if (ctx.active('polling-interval') && calleeName === 'setInterval') {
+            const delay = numericValue(args[1]);
+            const frequent = delay !== null && delay < FREQUENT_INTERVAL_MS;
+            findings.push({
+                ...span(node),
+                message: `Timer périodique${delay !== null ? ` toutes les ${delay} ms` : ''} — ` +
+                    'il empêche le processeur de se mettre au repos, sur chaque appareil ' +
+                    'qui affiche la page. Préférer un événement, une requête à la demande ' +
+                    'ou un intervalle plus long.',
+                severity: frequent ? 'high' : 'medium',
+                weight: frequent ? 12 : 7,
+            });
+        }
+        // Gestionnaire d'événement à haute fréquence sans limitation de débit
+        if (ctx.active('unthrottled-event-listener') && calleeName === 'addEventListener') {
+            const event = args[0] && isStringNode(args[0], ctx) ? unquote(args[0].text) : '';
+            if (HIGH_FREQUENCY_EVENTS.has(event) && !isThrottled(args[1])) {
+                findings.push({
+                    ...span(node),
+                    message: `Gestionnaire \`${event}\` sans limitation de débit — cet événement est ` +
+                        'tiré en rafale. Passer par `debounce()`, `throttle()` ou ' +
+                        '`requestAnimationFrame()`.',
+                    severity: 'medium',
+                    weight: 7,
+                });
+            }
+        }
+        // require() d'une bibliothèque entière
+        if (ctx.active('whole-library-import') && calleeName === 'require') {
+            const source = args[0] && isStringNode(args[0], ctx) ? unquote(args[0].text) : '';
+            if (HEAVY_MODULES.has(source))
+                findings.push(heavyImportFinding(node, source));
+        }
+    }
+    // Version JS de la règle 4 : `new RegExp(...)` recompile à chaque tour,
+    // là où un littéral /.../ est compilé une seule fois.
+    if (ctx.active('regex-compile-in-loop') && nextInLoop &&
+        ctx.nodes.objectCreation.includes(node.type) &&
+        node.childForFieldName('constructor')?.text === 'RegExp') {
+        findings.push({
+            ...span(node),
+            message: '`new RegExp()` en boucle — la regex est recompilée à chaque tour. ' +
+                'La construire une seule fois hors de la boucle, ou utiliser un ' +
+                'littéral `/.../`.',
+            severity: 'high',
+            weight: 12,
+        });
+    }
+    // Import par défaut ou global d'une bibliothèque lourde
+    if (ctx.active('whole-library-import') && node.type === 'import_statement') {
+        const source = unquote(node.childForFieldName('source')?.text ?? '');
+        const clause = node.namedChildren.find(c => c.type === 'import_clause');
+        const wholePackage = clause?.namedChildren.some(c => c.type === 'identifier' || c.type === 'namespace_import');
+        if (HEAVY_MODULES.has(source) && wholePackage) {
+            findings.push(heavyImportFinding(node, source));
+        }
+    }
+    // Gestionnaire JSX à haute fréquence — le cas courant en React
+    if (ctx.active('unthrottled-event-listener') && node.type === 'jsx_attribute') {
+        const name = node.namedChildren[0]?.text ?? '';
+        if (HIGH_FREQUENCY_JSX_PROPS.has(name)) {
+            const value = node.namedChildren[1];
+            const expr = value?.type === 'jsx_expression' ? value.namedChildren[0] : value;
+            if (!isThrottled(expr)) {
+                findings.push({
+                    ...span(node),
+                    message: `Gestionnaire \`${name}\` sans limitation de débit — cet événement est ` +
+                        'tiré en rafale. Passer par `debounce()`, `throttle()` ou ' +
+                        '`requestAnimationFrame()`.',
+                    severity: 'medium',
+                    weight: 7,
+                });
+            }
+        }
+    }
+    // Récursion sur les enfants nommés
+    for (const child of node.namedChildren) {
+        traverse(child, next, findings, ctx);
+    }
+}
+// ---------------------------------------------------------------------------
+// Utilitaires
+// ---------------------------------------------------------------------------
+function span(node) {
+    return {
+        startLine: node.startPosition.row,
+        startChar: node.startPosition.column,
+        endLine: node.endPosition.row,
+        endChar: node.endPosition.column,
+    };
+}
+function heavyImportFinding(node, source) {
+    return {
+        ...span(node),
+        message: `Import global de \`${source}\` — tout le paquet part dans le bundle, donc ` +
+            'sur le réseau vers chaque visiteur. Importer seulement ce qui sert ' +
+            `(\`import { x } from '${source}/x'\`).`,
+        severity: 'medium',
+        weight: 7,
+    };
+}
+function isStringNode(node, ctx) {
+    return ctx.nodes.stringLiteral.includes(node.type);
+}
+/** Valeur d'un littéral numérique, ou null si l'argument n'en est pas un. */
+function numericValue(node) {
+    if (!node || node.type !== 'number')
+        return null;
+    const value = Number(node.text);
+    return Number.isFinite(value) ? value : null;
+}
+/** Le gestionnaire passe-t-il visiblement par un limiteur de débit ? */
+function isThrottled(node) {
+    if (!node)
+        return false;
+    return THROTTLE_PATTERN.test(node.text);
+}
+function unquote(text) {
+    return text.replace(/^['"`]|['"`]$/g, '');
+}
+//# sourceMappingURL=rules.js.map