plugin-eco 0.1.0

package/out/context.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferContext = inferContext;
+// --- Indices --------------------------------------------------------------
+/** Modules du cœur de Node. Tout `node:*` est de toute façon serveur. */
+const NODE_BUILTINS = new Set([
+    'fs', 'path', 'http', 'https', 'net', 'tls', 'dns', 'os', 'crypto',
+    'child_process', 'cluster', 'worker_threads', 'stream', 'zlib', 'readline',
+    'buffer', 'querystring', 'url', 'util', 'v8', 'vm', 'perf_hooks',
+]);
+/** Frameworks serveur, clients de bases de données et outillage backend. */
+const SERVER_MODULES = new Set([
+    'express', 'fastify', 'koa', 'hapi', 'connect', 'body-parser',
+    '@nestjs/core', '@nestjs/common', 'next/server',
+    'pg', 'mysql', 'mysql2', 'mongodb', 'mongoose', 'redis', 'ioredis',
+    'prisma', '@prisma/client', 'sequelize', 'typeorm', 'knex',
+    'sqlite3', 'better-sqlite3', 'nodemailer', 'dotenv',
+]);
+/**
+ * Bibliothèques dont le coût de rendu est payé par le navigateur.
+ * `react` en fait partie même en rendu côté serveur : ce qui est produit ici
+ * sera hydraté et animé sur l'appareil du visiteur.
+ */
+const CLIENT_MODULES = new Set([
+    'react', 'react-dom', 'preact', 'vue', 'svelte', 'solid-js', 'lit',
+    '@angular/core', 'jquery', 'react-router-dom', 'framer-motion',
+]);
+/** Globales que seul un navigateur fournit. */
+const CLIENT_GLOBALS = new Set([
+    'document', 'window', 'navigator', 'localStorage', 'sessionStorage',
+    'history', 'XMLHttpRequest',
+]);
+/** Globales que seul Node fournit (CommonJS). */
+const SERVER_GLOBALS = new Set(['__dirname', '__filename']);
+// --- Inférence ------------------------------------------------------------
+/**
+ * @param root racine de l'arbre syntaxique
+ * @param spec descripteur du langage ; un `fixedContext` court-circuite l'analyse
+ */
+function inferContext(root, spec) {
+    if (spec.fixedContext) {
+        return { context: spec.fixedContext, clientSignals: [], serverSignals: [] };
+    }
+    // Une directive 'use client' / 'use server' est une déclaration explicite
+    // du développeur : elle prime sur tout ce qu'on pourrait déduire.
+    const directive = leadingDirective(root);
+    if (directive === 'use client') {
+        return { context: 'client', clientSignals: ["directive 'use client'"], serverSignals: [] };
+    }
+    if (directive === 'use server') {
+        return { context: 'server', clientSignals: [], serverSignals: ["directive 'use server'"] };
+    }
+    const found = {
+        client: new Set(),
+        server: new Set(),
+        globals: new Map(),
+        declared: new Set(),
+    };
+    collect(root, found);
+    // Une globale qui porte le même nom qu'une variable locale n'en est pas une.
+    // `document` est un nom de paramètre courant — le premier essai classait
+    // `src/extension.ts` de ce projet comme du code navigateur.
+    for (const [name, side] of found.globals) {
+        if (found.declared.has(name))
+            continue;
+        (side === 'client' ? found.client : found.server).add(name);
+    }
+    const clientSignals = [...found.client].sort();
+    const serverSignals = [...found.server].sort();
+    let context = 'unknown';
+    if (serverSignals.length > 0 && clientSignals.length === 0)
+        context = 'server';
+    else if (clientSignals.length > 0 && serverSignals.length === 0)
+        context = 'client';
+    return { context, clientSignals, serverSignals };
+}
+/** Directive en tête de fichier, si présente. */
+function leadingDirective(root) {
+    for (const stmt of root.namedChildren) {
+        if (stmt.type !== 'expression_statement')
+            return null;
+        const expr = stmt.namedChildren[0];
+        if (!expr || expr.type !== 'string')
+            return null;
+        const value = unquote(expr.text);
+        if (value === 'use client' || value === 'use server')
+            return value;
+        // Une autre directive ('use strict') n'interrompt pas la recherche.
+    }
+    return null;
+}
+/** Nœuds dont les identifiants descendants sont des liaisons, pas des usages. */
+const BINDING_PARENTS = new Set(['formal_parameters', 'import_clause']);
+function collect(node, found) {
+    switch (node.type) {
+        case 'import_statement':
+        case 'export_statement': {
+            const source = node.childForFieldName('source');
+            if (source)
+                classifyModule(unquote(source.text), found);
+            break;
+        }
+        case 'call_expression': {
+            const callee = node.childForFieldName('function');
+            // require('x') et import('x') portent tous deux leur cible en argument.
+            if (callee && (callee.text === 'require' || callee.type === 'import')) {
+                const arg = node.childForFieldName('arguments')?.namedChildren[0];
+                if (arg?.type === 'string')
+                    classifyModule(unquote(arg.text), found);
+            }
+            break;
+        }
+        case 'variable_declarator':
+        case 'function_declaration':
+        case 'class_declaration': {
+            const name = node.childForFieldName('name');
+            if (name?.type === 'identifier')
+                found.declared.add(name.text);
+            break;
+        }
+        case 'identifier': {
+            if (CLIENT_GLOBALS.has(node.text))
+                found.globals.set(node.text, 'client');
+            else if (SERVER_GLOBALS.has(node.text))
+                found.globals.set(node.text, 'server');
+            break;
+        }
+        default:
+            // Du JSX signifie un rendu, donc un coût payé par le navigateur.
+            if (node.type.startsWith('jsx_element') || node.type.startsWith('jsx_self_closing')) {
+                found.client.add('JSX');
+            }
+    }
+    if (BINDING_PARENTS.has(node.type))
+        declareAll(node, found.declared);
+    for (const child of node.namedChildren)
+        collect(child, found);
+}
+/** Enregistre tous les identifiants d'un sous-arbre comme noms liés. */
+function declareAll(node, declared) {
+    if (node.type === 'identifier' || node.type === 'shorthand_property_identifier_pattern') {
+        declared.add(node.text);
+    }
+    for (const child of node.namedChildren)
+        declareAll(child, declared);
+}
+function classifyModule(source, found) {
+    const client = found.client;
+    const server = found.server;
+    if (source.startsWith('.') || source.startsWith('/'))
+        return; // module local
+    if (source.startsWith('node:')) {
+        server.add(source);
+        return;
+    }
+    const root = moduleRoot(source);
+    if (NODE_BUILTINS.has(root) || SERVER_MODULES.has(root) || SERVER_MODULES.has(source)) {
+        server.add(root);
+    }
+    else if (CLIENT_MODULES.has(root) || CLIENT_MODULES.has(source)) {
+        client.add(root);
+    }
+    // Un module inconnu ne prouve rien : on ne l'utilise pas comme indice.
+}
+/** 'express/lib/router' → 'express' ; '@nestjs/core/x' → '@nestjs/core'. */
+function moduleRoot(source) {
+    const parts = source.split('/');
+    return source.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+}
+function unquote(text) {
+    return text.replace(/^['"`]|['"`]$/g, '');
+}
+//# sourceMappingURL=context.js.map

package/out/extension.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+export declare function activate(context: vscode.ExtensionContext): Promise<void>;
+export declare function deactivate(): void;

package/out/extension.js

@@ -0,0 +1,269 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = activate;
+exports.deactivate = deactivate;
+const vscode = __importStar(require("vscode"));
+const parser_1 = require("./parser");
+const rules_1 = require("./rules");
+const scoring_1 = require("./scoring");
+const webview_1 = require("./webview");
+const workspace_1 = require("./workspace");
+const languages_1 = require("./languages");
+const context_1 = require("./context");
+let diagnosticCollection;
+let statusBarItem;
+let panel;
+/** 'file' = rapport du fichier actif / 'workspace' = rapport global. */
+let panelMode = 'file';
+/** Timers de debounce par URI de document. */
+const debounceTimers = new Map();
+/** Dernier résultat d'analyse mono-fichier. */
+let lastFindings = [];
+let lastScore = { letter: 'A', value: 100, findingCount: { high: 0, medium: 0, low: 0 } };
+let lastFileName = '';
+let lastPartial = false;
+// ---------------------------------------------------------------------------
+// Point d'entrée
+// ---------------------------------------------------------------------------
+async function activate(context) {
+    try {
+        await (0, parser_1.initParser)(context.extensionUri.fsPath);
+    }
+    catch (err) {
+        vscode.window.showErrorMessage(`Plugin Eco : erreur d'initialisation — ${err}`);
+        return;
+    }
+    diagnosticCollection = vscode.languages.createDiagnosticCollection('greencoding');
+    context.subscriptions.push(diagnosticCollection);
+    statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+    statusBarItem.command = 'greencoding.showPanel';
+    context.subscriptions.push(statusBarItem);
+    // Commande : re-analyser le fichier actif
+    context.subscriptions.push(vscode.commands.registerCommand('greencoding.analyze', () => {
+        const doc = vscode.window.activeTextEditor?.document;
+        if (doc && (0, languages_1.isSupported)(doc.languageId))
+            analyzeDocument(doc);
+    }));
+    // Commande : ouvrir / révéler le panneau (mode fichier)
+    context.subscriptions.push(vscode.commands.registerCommand('greencoding.showPanel', () => {
+        panelMode = 'file';
+        openOrRevealPanel(context);
+    }));
+    // Commande : analyser tout le workspace
+    context.subscriptions.push(vscode.commands.registerCommand('greencoding.analyzeWorkspace', async () => {
+        const report = await (0, workspace_1.analyzeWorkspace)(diagnosticCollection);
+        if (!report)
+            return;
+        panelMode = 'workspace';
+        openOrRevealPanel(context);
+        if (panel) {
+            panel.title = '⚡ Rapport Éco — Workspace';
+            panel.webview.html = (0, webview_1.buildWorkspaceHtml)(report, getNonce());
+        }
+    }));
+    // Événements document
+    context.subscriptions.push(vscode.workspace.onDidOpenTextDocument(doc => {
+        if ((0, languages_1.isSupported)(doc.languageId))
+            analyzeDocument(doc);
+    }), vscode.workspace.onDidSaveTextDocument(doc => {
+        if ((0, languages_1.isSupported)(doc.languageId))
+            analyzeDocument(doc);
+    }), vscode.workspace.onDidChangeTextDocument(event => {
+        if (!(0, languages_1.isSupported)(event.document.languageId))
+            return;
+        scheduleAnalysis(event.document);
+    }), vscode.window.onDidChangeActiveTextEditor(editor => {
+        if (editor && (0, languages_1.isSupported)(editor.document.languageId)) {
+            analyzeDocument(editor.document);
+        }
+        else {
+            statusBarItem.hide();
+        }
+    }), vscode.workspace.onDidCloseTextDocument(doc => {
+        diagnosticCollection.delete(doc.uri);
+        const key = doc.uri.toString();
+        const timer = debounceTimers.get(key);
+        if (timer) {
+            clearTimeout(timer);
+            debounceTimers.delete(key);
+        }
+    }));
+    // Analyser le fichier actif au démarrage
+    const activeDoc = vscode.window.activeTextEditor?.document;
+    if (activeDoc && (0, languages_1.isSupported)(activeDoc.languageId))
+        analyzeDocument(activeDoc);
+}
+function deactivate() {
+    diagnosticCollection?.clear();
+    diagnosticCollection?.dispose();
+    statusBarItem?.dispose();
+    panel?.dispose();
+    debounceTimers.forEach(t => clearTimeout(t));
+    debounceTimers.clear();
+}
+// ---------------------------------------------------------------------------
+// Analyse mono-fichier
+// ---------------------------------------------------------------------------
+function scheduleAnalysis(document) {
+    const key = document.uri.toString();
+    const existing = debounceTimers.get(key);
+    if (existing)
+        clearTimeout(existing);
+    debounceTimers.set(key, setTimeout(() => {
+        analyzeDocument(document);
+        debounceTimers.delete(key);
+    }, 400));
+}
+function analyzeDocument(document) {
+    const spec = (0, languages_1.specFor)(document.languageId);
+    if (!spec)
+        return;
+    try {
+        const tree = (0, parser_1.parse)(document.getText(), document.languageId);
+        const { context, clientSignals, serverSignals } = (0, context_1.inferContext)(tree.rootNode, spec);
+        const findings = (0, rules_1.collectFindings)(tree.rootNode, spec, context);
+        const score = (0, scoring_1.computeScore)(findings);
+        // Un arbre incomplet donne une analyse incomplète : sans ce signal, un
+        // fichier illisible sortirait en A 100/100, ce qui est pire qu'aucun
+        // résultat. Fréquent pendant la frappe, d'où un simple avertissement
+        // plutôt qu'un blocage.
+        const partial = tree.rootNode.hasError;
+        lastFindings = findings;
+        lastScore = score;
+        lastFileName = document.fileName;
+        lastPartial = partial;
+        // Diagnostics inline
+        diagnosticCollection.set(document.uri, findings.map(f => {
+            const range = new vscode.Range(f.startLine, f.startChar, f.endLine, f.endChar);
+            const severity = f.severity === 'high'
+                ? vscode.DiagnosticSeverity.Warning
+                : vscode.DiagnosticSeverity.Information;
+            const diag = new vscode.Diagnostic(range, `⚡ ${f.message}`, severity);
+            diag.source = 'Plugin Eco';
+            return diag;
+        }));
+        // Barre de statut
+        statusBarItem.text = `⚡ Éco: ${score.letter}${partial ? ' ⚠' : ''}`;
+        statusBarItem.tooltip = [
+            `${spec.label} — score : ${score.value}/100 — ${(0, scoring_1.scoreSummary)(score)}`,
+            `Alertes : ${score.findingCount.high} haute(s), ${score.findingCount.medium} moyenne(s)`,
+            `Exécution : ${contextLabel(context)}${contextEvidence(clientSignals, serverSignals)}`,
+            ...(partial
+                ? ['', '⚠ Analyse partielle : le fichier n\'a pas pu être parsé entièrement.',
+                    'Le score est à prendre avec réserve.']
+                : []),
+            '',
+            'Cliquer pour ouvrir le rapport détaillé',
+        ].join('\n');
+        statusBarItem.backgroundColor =
+            score.letter === 'D' || score.letter === 'E'
+                ? new vscode.ThemeColor('statusBarItem.warningBackground')
+                : undefined;
+        statusBarItem.show();
+        // Mettre à jour le panneau uniquement si on est en mode fichier
+        if (panel && panelMode === 'file') {
+            panel.title = '⚡ Rapport Éco';
+            panel.webview.html = (0, webview_1.buildWebviewHtml)(findings, score, document.fileName, getNonce(), partial);
+        }
+    }
+    catch {
+        // Silencieux (fichier incomplet en cours de frappe)
+    }
+}
+// ---------------------------------------------------------------------------
+// Panneau WebView
+// ---------------------------------------------------------------------------
+function openOrRevealPanel(context) {
+    if (panel) {
+        panel.reveal(vscode.ViewColumn.Beside);
+        // Rafraîchir si on repasse en mode fichier
+        if (panelMode === 'file') {
+            panel.title = '⚡ Rapport Éco';
+            panel.webview.html = (0, webview_1.buildWebviewHtml)(lastFindings, lastScore, lastFileName, getNonce(), lastPartial);
+        }
+        return;
+    }
+    panel = vscode.window.createWebviewPanel('greencoding.report', '⚡ Rapport Éco', vscode.ViewColumn.Beside, {
+        enableScripts: true,
+        retainContextWhenHidden: true,
+    });
+    panel.webview.html = (0, webview_1.buildWebviewHtml)(lastFindings, lastScore, lastFileName, getNonce(), lastPartial);
+    // Handler : clic sur un fichier dans le rapport workspace → ouvrir dans l'éditeur
+    panel.webview.onDidReceiveMessage(async (message) => {
+        if (message.command === 'open' && typeof message.file === 'string') {
+            try {
+                const uri = vscode.Uri.parse(message.file);
+                const doc = await vscode.workspace.openTextDocument(uri);
+                const line = Math.max(0, (message.line || 1) - 1);
+                await vscode.window.showTextDocument(doc, {
+                    selection: new vscode.Range(line, 0, line, 0),
+                    viewColumn: vscode.ViewColumn.One,
+                });
+            }
+            catch {
+                // URI invalide ou fichier supprimé
+            }
+        }
+    }, null, context.subscriptions);
+    panel.onDidDispose(() => {
+        panel = undefined;
+        panelMode = 'file';
+    }, null, context.subscriptions);
+}
+// ---------------------------------------------------------------------------
+// Utilitaire
+// ---------------------------------------------------------------------------
+const CONTEXT_LABELS = {
+    client: 'navigateur — le coût est payé par chaque visiteur',
+    server: 'serveur',
+    unknown: 'indéterminée',
+};
+function contextLabel(context) {
+    return CONTEXT_LABELS[context];
+}
+/** Indices ayant conduit au verdict, tronqués pour rester lisibles. */
+function contextEvidence(clientSignals, serverSignals) {
+    const all = [...serverSignals, ...clientSignals];
+    if (all.length === 0)
+        return '';
+    const shown = all.slice(0, 4).join(', ');
+    return ` (${shown}${all.length > 4 ? '…' : ''})`;
+}
+function getNonce() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from({ length: 32 }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+}
+//# sourceMappingURL=extension.js.map

package/out/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Point d'entrée bibliothèque du paquet npm.
+ *
+ * Ce fichier expose le moteur d'analyse — parseur, règles, contexte, score —
+ * et **rien de l'intégration VSCode** : ni `extension.ts`, ni `webview.ts`, ni
+ * `workspace.ts`, qui importent `vscode` et ne se chargent pas hors éditeur.
+ * C'est la même frontière que celle tenue par `cli.ts`.
+ *
+ * Le manifeste garde `main` vers `out/extension.js` pour VSCode, qui charge ce
+ * chemin en absolu et ignore `exports` ; `require('plugin-eco')` passe ici.
+ *
+ * ```js
+ * const { initParser, parse, collectFindings, computeScore } = require('plugin-eco');
+ *
+ * await initParser();
+ * const tree = parse(source, 'java');
+ * const findings = collectFindings(tree.rootNode, specFor('java'));
+ * console.log(computeScore(findings).letter); // 'A' … 'E'
+ * ```
+ */
+export { initParser, parse, parseWith } from './parser';
+export { collectFindings } from './rules';
+export { letterFor, computeScore, aggregateScore, scoreSummary } from './scoring';
+export { inferContext } from './context';
+export type { ContextResult } from './context';
+export { LANGUAGES, RULE_CONTEXTS, ruleAppliesIn, specFor, specForPath, isSupported, } from './languages';
+export type { LanguageSpec, RuleId } from './languages';
+export type { ExecutionContext, Finding, FileResult, Score, Severity, WorkspaceReport, } from './types';

package/out/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Point d'entrée bibliothèque du paquet npm.
+ *
+ * Ce fichier expose le moteur d'analyse — parseur, règles, contexte, score —
+ * et **rien de l'intégration VSCode** : ni `extension.ts`, ni `webview.ts`, ni
+ * `workspace.ts`, qui importent `vscode` et ne se chargent pas hors éditeur.
+ * C'est la même frontière que celle tenue par `cli.ts`.
+ *
+ * Le manifeste garde `main` vers `out/extension.js` pour VSCode, qui charge ce
+ * chemin en absolu et ignore `exports` ; `require('plugin-eco')` passe ici.
+ *
+ * ```js
+ * const { initParser, parse, collectFindings, computeScore } = require('plugin-eco');
+ *
+ * await initParser();
+ * const tree = parse(source, 'java');
+ * const findings = collectFindings(tree.rootNode, specFor('java'));
+ * console.log(computeScore(findings).letter); // 'A' … 'E'
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupported = exports.specForPath = exports.specFor = exports.ruleAppliesIn = exports.RULE_CONTEXTS = exports.LANGUAGES = exports.inferContext = exports.scoreSummary = exports.aggregateScore = exports.computeScore = exports.letterFor = exports.collectFindings = exports.parseWith = exports.parse = exports.initParser = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "initParser", { enumerable: true, get: function () { return parser_1.initParser; } });
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } });
+Object.defineProperty(exports, "parseWith", { enumerable: true, get: function () { return parser_1.parseWith; } });
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "collectFindings", { enumerable: true, get: function () { return rules_1.collectFindings; } });
+var scoring_1 = require("./scoring");
+Object.defineProperty(exports, "letterFor", { enumerable: true, get: function () { return scoring_1.letterFor; } });
+Object.defineProperty(exports, "computeScore", { enumerable: true, get: function () { return scoring_1.computeScore; } });
+Object.defineProperty(exports, "aggregateScore", { enumerable: true, get: function () { return scoring_1.aggregateScore; } });
+Object.defineProperty(exports, "scoreSummary", { enumerable: true, get: function () { return scoring_1.scoreSummary; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "inferContext", { enumerable: true, get: function () { return context_1.inferContext; } });
+var languages_1 = require("./languages");
+Object.defineProperty(exports, "LANGUAGES", { enumerable: true, get: function () { return languages_1.LANGUAGES; } });
+Object.defineProperty(exports, "RULE_CONTEXTS", { enumerable: true, get: function () { return languages_1.RULE_CONTEXTS; } });
+Object.defineProperty(exports, "ruleAppliesIn", { enumerable: true, get: function () { return languages_1.ruleAppliesIn; } });
+Object.defineProperty(exports, "specFor", { enumerable: true, get: function () { return languages_1.specFor; } });
+Object.defineProperty(exports, "specForPath", { enumerable: true, get: function () { return languages_1.specForPath; } });
+Object.defineProperty(exports, "isSupported", { enumerable: true, get: function () { return languages_1.isSupported; } });
+//# sourceMappingURL=index.js.map

package/out/languages.d.ts

@@ -0,0 +1,76 @@
+import { ExecutionContext } from './types';
+/**
+ * Descripteurs de langage.
+ *
+ * Tout ce qui varie d'un langage à l'autre est décrit ici : la grammaire à
+ * charger, les noms de nœuds tree-sitter, et les règles applicables. Les autres
+ * modules ne connaissent que ce descripteur — ils n'ont plus de `if (java)`.
+ */
+/** Identifiant d'une règle de détection. */
+export type RuleId = 'nested-loops' | 'string-concat-in-loop' | 'object-creation-in-loop' | 'regex-compile-in-loop' | 'blocking-io-in-loop' | 'sql-without-limit' | 'await-in-loop' | 'sync-io-in-function' | 'polling-interval' | 'unthrottled-event-listener' | 'whole-library-import';
+/**
+ * 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.
+ */
+export declare const RULE_CONTEXTS: Record<RuleId, 'any' | ExecutionContext[]>;
+/** La règle s'applique-t-elle à un fichier dont le contexte est celui-ci ? */
+export declare function ruleAppliesIn(rule: RuleId, context: ExecutionContext): boolean;
+/**
+ * Noms des nœuds tree-sitter, qui diffèrent d'une grammaire à l'autre.
+ * Exemple : une instanciation est `object_creation_expression` en Java,
+ * `new_expression` en JS.
+ */
+export interface NodeNames {
+    loops: string[];
+    objectCreation: string[];
+    call: string[];
+    stringLiteral: string[];
+    /** Nœud portant `+=` — un opérateur composé a son propre type de nœud en JS. */
+    compoundAssignment: string[];
+    /** Frontières de fonction, qui bornent la portée de certaines règles. */
+    functions: string[];
+}
+export interface LanguageSpec {
+    /** Nom lisible, pour les messages. */
+    label: string;
+    /** Fichier WASM dans out/wasm/. */
+    grammarFile: string;
+    /** `languageId` VSCode couverts par ce descripteur. */
+    vscodeLanguageIds: string[];
+    /** Extensions de fichier couvertes, point compris. Source unique : le glob
+     *  du scan VSCode et la reconnaissance par chemin du CLI en découlent. */
+    extensions: string[];
+    nodes: NodeNames;
+    /** Règles applicables. Une règle absente n'est jamais évaluée. */
+    rules: RuleId[];
+    /**
+     * Contexte d'exécution connu d'avance, qui dispense de l'inférence.
+     * Java n'a pas de moitié navigateur : c'est du serveur par construction.
+     * Absent pour JS/TS, où le contexte se déduit du code.
+     */
+    fixedContext?: ExecutionContext;
+}
+export declare const LANGUAGES: LanguageSpec[];
+/** Descripteur correspondant à un `languageId` VSCode, ou undefined. */
+export declare function specFor(languageId: string): LanguageSpec | undefined;
+/** Le langage est-il analysable ? */
+export declare function isSupported(languageId: string): boolean;
+/** Fichiers WASM à charger, sans doublon (tsx sert deux descripteurs). */
+export declare function grammarFiles(): string[];
+/**
+ * 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.
+ */
+export declare const EXCLUDED_DIRS: string[];
+/** Motif VSCode excluant ces dossiers. */
+export declare function excludeGlob(): string;
+/** Motif de recherche VSCode pour un langage, dérivé de ses extensions. */
+export declare function globFor(spec: LanguageSpec): string;
+/** Descripteur correspondant à un chemin de fichier, ou undefined. */
+export declare function specForPath(filePath: string): LanguageSpec | undefined;