plugin-eco 0.1.0

package/out/scoring.d.ts

@@ -0,0 +1,26 @@
+import { Finding, Score } from './types';
+/** Convertit une valeur numérique (0–100) en lettre A–E. */
+export declare function letterFor(value: number): Score['letter'];
+/**
+ * Calcule le score énergétique (0–100) et la lettre A–E à partir des findings d'un fichier.
+ */
+export declare function computeScore(findings: Finding[]): Score;
+/**
+ * Score global d'un ensemble de fichiers.
+ *
+ * **Les fichiers sans aucune alerte sont exclus du calcul.** Une moyenne sur
+ * tous les fichiers diluait tout : baby-tracker sortait en A 99/100 alors que
+ * son unique fichier volumineux était en C 72, noyé par 22 modules utilitaires
+ * sans le moindre finding. Le score annonçait surtout combien le projet compte
+ * de petits fichiers anodins.
+ *
+ * Restreindre la moyenne aux fichiers réellement concernés répond à la question
+ * utile — « à quel point ce qui pose problème pose problème » — et empêche
+ * d'améliorer sa note en ajoutant du code sain.
+ *
+ * Le compte d'alertes, lui, reste calculé sur l'ensemble : c'est la mesure de
+ * l'étendue, que le panneau affiche à côté de la lettre.
+ */
+export declare function aggregateScore(scores: Score[]): Score;
+/** Étiquette textuelle du score pour les tooltips et le rapport. */
+export declare function scoreSummary(score: Score): string;

package/out/scoring.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.letterFor = letterFor;
+exports.computeScore = computeScore;
+exports.aggregateScore = aggregateScore;
+exports.scoreSummary = scoreSummary;
+// Seuils de lettres (ordre décroissant — premier match gagne)
+const THRESHOLDS = [
+    { min: 90, letter: 'A' },
+    { min: 75, letter: 'B' },
+    { min: 55, letter: 'C' },
+    { min: 35, letter: 'D' },
+    { min: 0, letter: 'E' },
+];
+/** Convertit une valeur numérique (0–100) en lettre A–E. */
+function letterFor(value) {
+    return THRESHOLDS.find(t => value >= t.min).letter;
+}
+/**
+ * Calcule le score énergétique (0–100) et la lettre A–E à partir des findings d'un fichier.
+ */
+function computeScore(findings) {
+    let penalty = 0;
+    const count = { high: 0, medium: 0, low: 0 };
+    for (const f of findings) {
+        penalty += f.weight;
+        count[f.severity]++;
+    }
+    const value = Math.max(0, 100 - penalty);
+    return { letter: letterFor(value), value, findingCount: count };
+}
+/**
+ * Score global d'un ensemble de fichiers.
+ *
+ * **Les fichiers sans aucune alerte sont exclus du calcul.** Une moyenne sur
+ * tous les fichiers diluait tout : baby-tracker sortait en A 99/100 alors que
+ * son unique fichier volumineux était en C 72, noyé par 22 modules utilitaires
+ * sans le moindre finding. Le score annonçait surtout combien le projet compte
+ * de petits fichiers anodins.
+ *
+ * Restreindre la moyenne aux fichiers réellement concernés répond à la question
+ * utile — « à quel point ce qui pose problème pose problème » — et empêche
+ * d'améliorer sa note en ajoutant du code sain.
+ *
+ * Le compte d'alertes, lui, reste calculé sur l'ensemble : c'est la mesure de
+ * l'étendue, que le panneau affiche à côté de la lettre.
+ */
+function aggregateScore(scores) {
+    const total = scores.reduce((acc, s) => ({
+        high: acc.high + s.findingCount.high,
+        medium: acc.medium + s.findingCount.medium,
+        low: acc.low + s.findingCount.low,
+    }), { high: 0, medium: 0, low: 0 });
+    const concerned = scores.filter(s => s.findingCount.high + s.findingCount.medium + s.findingCount.low > 0);
+    const value = concerned.length === 0
+        ? 100
+        : Math.round(concerned.reduce((sum, s) => sum + s.value, 0) / concerned.length);
+    return { letter: letterFor(value), value, findingCount: total };
+}
+/** Étiquette textuelle du score pour les tooltips et le rapport. */
+function scoreSummary(score) {
+    const labels = {
+        A: 'Excellent — code très sobre',
+        B: 'Bon — quelques optimisations possibles',
+        C: 'Moyen — des patterns énergivores détectés',
+        D: 'Faible — restructuration recommandée',
+        E: 'Critique — consommation élevée',
+    };
+    return labels[score.letter];
+}
+//# sourceMappingURL=scoring.js.map

package/out/types.d.ts

@@ -0,0 +1,47 @@
+/** Sévérité d'un pattern énergivore détecté. */
+export type Severity = 'high' | 'medium' | 'low';
+/**
+ * Où s'exécute le code analysé.
+ *
+ * L'enjeu énergétique n'est pas le même : un `setInterval` de polling coûte une
+ * fois sur un serveur, et autant de fois qu'il y a d'utilisateurs sur le client.
+ * `unknown` est un état légitime, pas un échec — en rendu côté serveur, un même
+ * fichier tourne réellement des deux côtés.
+ */
+export type ExecutionContext = 'client' | 'server' | 'unknown';
+/** Un pattern énergivore détecté dans le code, avec sa position et son poids de pénalité. */
+export interface Finding {
+    startLine: number;
+    startChar: number;
+    endLine: number;
+    endChar: number;
+    message: string;
+    severity: Severity;
+    weight: number;
+}
+/** Score énergétique agrégé pour un fichier. */
+export interface Score {
+    letter: 'A' | 'B' | 'C' | 'D' | 'E';
+    value: number;
+    findingCount: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+}
+/** Résultat d'analyse d'un fichier Java unique (utilisé dans le rapport workspace). */
+export interface FileResult {
+    uri: string;
+    fileName: string;
+    score: Score;
+    findings: Finding[];
+}
+/** Rapport global d'un scan workspace. */
+export interface WorkspaceReport {
+    files: FileResult[];
+    /** Moyenne des seuls fichiers présentant au moins une alerte. */
+    global: Score;
+    /** Étendue : combien de fichiers sont concernés, sur combien d'analysés. */
+    filesWithFindings: number;
+    scannedAt: string;
+}

package/out/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/out/webview.d.ts

@@ -0,0 +1,5 @@
+import { Finding, Score, WorkspaceReport } from './types';
+/** Génère le HTML du panneau mono-fichier (pas de scripts nécessaires). */
+export declare function buildWebviewHtml(findings: Finding[], score: Score, fileName: string, nonce: string, partial?: boolean): string;
+/** Génère le HTML du panneau workspace avec lignes cliquables (requiert enableScripts). */
+export declare function buildWorkspaceHtml(report: WorkspaceReport, nonce: string): string;

package/out/webview.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWebviewHtml = buildWebviewHtml;
+exports.buildWorkspaceHtml = buildWorkspaceHtml;
+const scoring_1 = require("./scoring");
+const DPE_COLORS = {
+    A: { bg: '#00A550', fg: '#ffffff' },
+    B: { bg: '#52B747', fg: '#ffffff' },
+    C: { bg: '#F0E729', fg: '#1a1a1a' },
+    D: { bg: '#F7A329', fg: '#ffffff' },
+    E: { bg: '#EC1C24', fg: '#ffffff' },
+};
+const SEVERITY_LABELS = {
+    high: { label: 'Haute', color: '#EC1C24' },
+    medium: { label: 'Moyenne', color: '#F7A329' },
+    low: { label: 'Faible', color: '#52B747' },
+};
+// ---------------------------------------------------------------------------
+// Composants réutilisables
+// ---------------------------------------------------------------------------
+function dpeStrip(activeLetter) {
+    return ['A', 'B', 'C', 'D', 'E']
+        .map(l => {
+        const c = DPE_COLORS[l];
+        const active = l === activeLetter;
+        return `<div class="dpe-box${active ? ' active' : ''}"
+                   style="background:${c.bg};color:${c.fg}">${l}</div>`;
+    })
+        .join('');
+}
+function sharedStyles() {
+    return `
+  body {
+    font-family: var(--vscode-font-family, sans-serif);
+    font-size: var(--vscode-font-size, 13px);
+    color: var(--vscode-editor-foreground);
+    background: var(--vscode-editor-background);
+    padding: 20px 24px;
+    margin: 0;
+  }
+  h1 { font-size: 1.1em; margin: 0 0 4px; opacity: 0.7; font-weight: 400; }
+  .subtitle { font-size: 0.85em; opacity: 0.5; margin-bottom: 20px; word-break: break-all; }
+  .dpe-strip { display: flex; gap: 6px; align-items: flex-end; margin-bottom: 8px; }
+  .dpe-box {
+    width: 44px; height: 36px;
+    display: flex; align-items: center; justify-content: center;
+    font-weight: 700; font-size: 1em;
+    border-radius: 3px; opacity: 0.28;
+  }
+  .dpe-box.active {
+    opacity: 1; height: 52px; font-size: 1.4em;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.35);
+  }
+  .score-line { font-size: 0.9em; margin-bottom: 6px; font-weight: 600; }
+  .summary { font-size: 0.85em; opacity: 0.6; margin-bottom: 16px; }
+  .worst {
+    font-size: 0.9em; margin-bottom: 24px; padding: 8px 12px;
+    border-left: 3px solid var(--vscode-textLink-foreground);
+    background: var(--vscode-textBlockQuote-background);
+  }
+  h2 {
+    font-size: 0.95em; margin: 0 0 10px;
+    border-bottom: 1px solid var(--vscode-panel-border, #444);
+    padding-bottom: 6px;
+  }
+  table { width: 100%; border-collapse: collapse; }
+  th {
+    text-align: left; font-size: 0.8em; opacity: 0.55; font-weight: 600;
+    padding: 4px 8px; border-bottom: 1px solid var(--vscode-panel-border, #444);
+  }
+  td {
+    padding: 6px 8px; vertical-align: top;
+    border-bottom: 1px solid var(--vscode-panel-border, #333);
+    font-size: 0.88em;
+  }
+  tr:last-child td { border-bottom: none; }
+  .col-line { white-space: nowrap; opacity: 0.55; font-family: monospace; }
+  .col-msg { line-height: 1.45; }
+  .col-file { font-family: monospace; font-size: 0.85em; }
+  .col-score { text-align: center; }
+  td.empty { text-align: center; padding: 20px; opacity: 0.6; }
+  .badge {
+    display: inline-block; padding: 1px 7px; border-radius: 10px;
+    font-size: 0.8em; font-weight: 700; color: #fff; white-space: nowrap;
+  }
+  .letter-badge {
+    display: inline-block; width: 24px; height: 24px; line-height: 24px;
+    text-align: center; border-radius: 3px; font-weight: 700; font-size: 0.9em;
+  }
+  .clickable { cursor: pointer; }
+  .clickable:hover td { background: var(--vscode-list-hoverBackground, rgba(255,255,255,0.06)); }`;
+}
+// ---------------------------------------------------------------------------
+// Rapport fichier unique
+// ---------------------------------------------------------------------------
+/** Génère le HTML du panneau mono-fichier (pas de scripts nécessaires). */
+function buildWebviewHtml(findings, score, fileName, nonce, partial = false) {
+    const color = DPE_COLORS[score.letter];
+    const total = findings.length;
+    const { high, medium } = score.findingCount;
+    const partialBlock = partial
+        ? `<div class="worst" style="border-left-color:#F7A329">
+         ⚠ Analyse partielle : le fichier n'a pas pu être parsé entièrement.
+         Le score est à prendre avec réserve.
+       </div>`
+        : '';
+    const sorted = [...findings].sort((a, b) => {
+        const order = { high: 0, medium: 1, low: 2 };
+        return order[a.severity] - order[b.severity];
+    });
+    const rows = sorted.length === 0
+        ? `<tr><td colspan="3" class="empty">Aucun pattern énergivore détecté 🎉</td></tr>`
+        : sorted.map(f => {
+            const sv = SEVERITY_LABELS[f.severity];
+            return `<tr>
+          <td class="col-line">L.${f.startLine + 1}</td>
+          <td><span class="badge" style="background:${sv.color}">${sv.label}</span></td>
+          <td class="col-msg">${esc(f.message)}</td>
+        </tr>`;
+        }).join('');
+    return html(`
+    <h1>⚡ Rapport éco — fichier</h1>
+    <div class="subtitle">${esc(fileName)}</div>
+
+    <div class="dpe-strip">${dpeStrip(score.letter)}</div>
+    <div class="score-line" style="color:${color.bg}">${score.value}/100 — ${(0, scoring_1.scoreSummary)(score)}</div>
+    <div class="summary">${total === 0
+        ? 'Aucune alerte.'
+        : `${total} alerte${total > 1 ? 's' : ''} : ${high} haute${high > 1 ? 's' : ''}, ${medium} moyenne${medium > 1 ? 's' : ''}`}</div>
+    ${partialBlock}
+
+    <h2>Détail des alertes</h2>
+    <table>
+      <thead><tr><th>Ligne</th><th>Sévérité</th><th>Message</th></tr></thead>
+      <tbody>${rows}</tbody>
+    </table>
+  `, nonce);
+}
+// ---------------------------------------------------------------------------
+// Rapport workspace
+// ---------------------------------------------------------------------------
+/** Génère le HTML du panneau workspace avec lignes cliquables (requiert enableScripts). */
+function buildWorkspaceHtml(report, nonce) {
+    const { global, files, scannedAt, filesWithFindings } = report;
+    const color = DPE_COLORS[global.letter];
+    const totalFiles = files.length;
+    const { high, medium } = global.findingCount;
+    // Le pire fichier est mis en avant : c'est lui qu'il faut regarder d'abord,
+    // et une lettre unique ne peut pas le désigner.
+    const worst = files.reduce((a, b) => (b.score.value < a.score.value ? b : a), files[0]);
+    const worstBlock = worst && worst.findings.length > 0
+        ? `<div class="worst">
+         À regarder en premier :
+         <span class="letter-badge" style="background:${DPE_COLORS[worst.score.letter].bg};color:${DPE_COLORS[worst.score.letter].fg}">${worst.score.letter}</span>
+         <strong>${esc(worst.fileName)}</strong>
+         <span style="opacity:0.6">— ${worst.findings.length} alerte${worst.findings.length > 1 ? 's' : ''}</span>
+       </div>`
+        : '';
+    const rows = files.map(f => {
+        const c = DPE_COLORS[f.score.letter];
+        const firstLine = f.findings.length > 0 ? f.findings[0].startLine + 1 : 1;
+        const totalFindings = f.findings.length;
+        return `<tr class="clickable"
+                data-uri="${esc(f.uri)}"
+                data-line="${firstLine}">
+      <td class="col-file">${esc(f.fileName)}</td>
+      <td class="col-score">
+        <span class="letter-badge" style="background:${c.bg};color:${c.fg}">${f.score.letter}</span>
+        <span style="opacity:0.6;font-size:0.85em;margin-left:4px">${f.score.value}</span>
+      </td>
+      <td>${totalFindings > 0
+            ? `${totalFindings} alerte${totalFindings > 1 ? 's' : ''}`
+            : '<span style="opacity:0.4">–</span>'}</td>
+    </tr>`;
+    }).join('');
+    const script = `
+    <script nonce="${nonce}">
+      const vscode = acquireVsCodeApi();
+      document.querySelectorAll('.clickable').forEach(row => {
+        row.addEventListener('click', () => {
+          vscode.postMessage({
+            command: 'open',
+            file: row.dataset.uri,
+            line: parseInt(row.dataset.line, 10)
+          });
+        });
+      });
+    </script>`;
+    return html(`
+    <h1>⚡ Rapport éco — workspace</h1>
+    <div class="subtitle">Analysé le ${esc(scannedAt)} · ${totalFiles} fichier${totalFiles > 1 ? 's' : ''}</div>
+
+    <div class="dpe-strip">${dpeStrip(global.letter)}</div>
+    <div class="score-line" style="color:${color.bg}">${global.value}/100 — ${(0, scoring_1.scoreSummary)(global)}</div>
+    <div class="summary">
+      ${high + medium} alerte${(high + medium) > 1 ? 's' : ''} au total : ${high} haute${high > 1 ? 's' : ''}, ${medium} moyenne${medium > 1 ? 's' : ''}<br>
+      <span style="opacity:0.75">Moyenne des ${filesWithFindings} fichier${filesWithFindings > 1 ? 's' : ''} concerné${filesWithFindings > 1 ? 's' : ''} sur ${totalFiles} analysé${totalFiles > 1 ? 's' : ''} — les fichiers sans alerte ne comptent pas dans la note.</span>
+    </div>
+    ${worstBlock}
+
+    <h2>Fichiers — pires en premier</h2>
+    <table>
+      <thead><tr><th>Fichier</th><th>Score</th><th>Alertes</th></tr></thead>
+      <tbody>${rows}</tbody>
+    </table>
+    ${script}
+  `, nonce, `script-src 'nonce-${nonce}';`);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function html(body, nonce, extraCsp = '') {
+    return `<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8">
+<meta http-equiv="Content-Security-Policy"
+      content="default-src 'none'; style-src 'unsafe-inline'; ${extraCsp}">
+<style>${sharedStyles()}</style>
+</head>
+<body>${body}</body>
+</html>`;
+}
+function esc(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+//# sourceMappingURL=webview.js.map

package/out/workspace.d.ts

@@ -0,0 +1,10 @@
+import * as vscode from 'vscode';
+import { WorkspaceReport } from './types';
+/**
+ * Scanne tous les fichiers analysables du workspace, calcule un score par
+ * fichier, et retourne un rapport global (score moyen + liste triée par score
+ * croissant).
+ *
+ * Les diagnostics de chaque fichier sont posés dans la collection partagée.
+ */
+export declare function analyzeWorkspace(diagnosticCollection: vscode.DiagnosticCollection): Promise<WorkspaceReport | null>;

package/out/workspace.js

@@ -0,0 +1,122 @@
+"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.analyzeWorkspace = analyzeWorkspace;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const parser_1 = require("./parser");
+const rules_1 = require("./rules");
+const scoring_1 = require("./scoring");
+const languages_1 = require("./languages");
+const context_1 = require("./context");
+/**
+ * Scanne tous les fichiers analysables du workspace, calcule un score par
+ * fichier, et retourne un rapport global (score moyen + liste triée par score
+ * croissant).
+ *
+ * Les diagnostics de chaque fichier sont posés dans la collection partagée.
+ */
+async function analyzeWorkspace(diagnosticCollection) {
+    // Un passage par langage : chaque fichier garde le descripteur qui le décrit,
+    // faute de quoi on ne saurait plus quelle grammaire lui appliquer.
+    const targets = [];
+    for (const spec of languages_1.LANGUAGES) {
+        const found = await vscode.workspace.findFiles((0, languages_1.globFor)(spec), (0, languages_1.excludeGlob)());
+        for (const uri of found)
+            targets.push({ uri, spec });
+    }
+    if (targets.length === 0) {
+        vscode.window.showInformationMessage('Plugin Eco : aucun fichier analysable trouvé dans le workspace ' +
+            `(${languages_1.LANGUAGES.map(l => l.label).join(', ')}).`);
+        return null;
+    }
+    const results = [];
+    await vscode.window.withProgress({
+        location: vscode.ProgressLocation.Notification,
+        title: '⚡ Plugin Eco — Analyse du workspace',
+        cancellable: true,
+    }, async (progress, token) => {
+        const total = targets.length;
+        for (let i = 0; i < total; i++) {
+            if (token.isCancellationRequested)
+                break;
+            const { uri, spec } = targets[i];
+            const baseName = path.basename(uri.fsPath);
+            progress.report({
+                message: `${baseName} (${i + 1}/${total})`,
+                increment: (1 / total) * 100,
+            });
+            try {
+                const bytes = await vscode.workspace.fs.readFile(uri);
+                const code = Buffer.from(bytes).toString('utf-8');
+                const tree = (0, parser_1.parseWith)(code, spec);
+                const { context } = (0, context_1.inferContext)(tree.rootNode, spec);
+                const findings = (0, rules_1.collectFindings)(tree.rootNode, spec, context);
+                const score = (0, scoring_1.computeScore)(findings);
+                // Poser les diagnostics inline pour ce fichier
+                diagnosticCollection.set(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;
+                }));
+                // Nom d'affichage : chemin relatif au workspace si possible
+                const wsFolder = vscode.workspace.getWorkspaceFolder(uri);
+                const displayName = wsFolder
+                    ? path.relative(wsFolder.uri.fsPath, uri.fsPath).replace(/\\/g, '/')
+                    : baseName;
+                results.push({ uri: uri.toString(), fileName: displayName, score, findings });
+            }
+            catch {
+                // Fichier illisible ou non parsable → ignoré silencieusement
+            }
+        }
+    });
+    if (results.length === 0)
+        return null;
+    const global = (0, scoring_1.aggregateScore)(results.map(r => r.score));
+    // Trier : pires fichiers en premier
+    results.sort((a, b) => a.score.value - b.score.value);
+    return {
+        files: results,
+        global,
+        filesWithFindings: results.filter(r => r.findings.length > 0).length,
+        scannedAt: new Date().toLocaleString('fr-CA'),
+    };
+}
+//# sourceMappingURL=workspace.js.map

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "plugin-eco",
+  "displayName": "Plugin Eco — Green Coding",
+  "description": "Analyse statique de la consommation énergétique du code Java, JavaScript et TypeScript. Score A–E inspiré du DPE.",
+  "version": "0.1.0",
+  "publisher": "greencoding",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Tekateyy/plugin-eco.git"
+  },
+  "engines": {
+    "vscode": "^1.80.0"
+  },
+  "categories": ["Linters", "Other"],
+  "keywords": ["green coding", "java", "javascript", "typescript", "energy", "performance", "éco"],
+  "activationEvents": [
+    "onLanguage:java",
+    "onLanguage:javascript",
+    "onLanguage:javascriptreact",
+    "onLanguage:typescript",
+    "onLanguage:typescriptreact"
+  ],
+  "main": "./out/extension",
+  "exports": {
+    ".": "./out/index.js",
+    "./package.json": "./package.json"
+  },
+  "types": "./out/index.d.ts",
+  "bin": {
+    "plugin-eco": "./out/cli.js"
+  },
+  "contributes": {
+    "commands": [
+      {
+        "command": "greencoding.analyze",
+        "title": "Greencoding: Analyser le fichier"
+      },
+      {
+        "command": "greencoding.showPanel",
+        "title": "Greencoding: Ouvrir le rapport détaillé"
+      },
+      {
+        "command": "greencoding.analyzeWorkspace",
+        "title": "Greencoding: Analyser tout le workspace"
+      }
+    ]
+  },
+  "scripts": {
+    "copy-wasm": "node scripts/copy-wasm.js",
+    "compile": "tsc -p ./ && npm run copy-wasm",
+    "watch": "npm run copy-wasm && tsc -watch -p ./",
+    "test": "npm run compile && node --test",
+    "package": "npx @vscode/vsce package",
+    "prepublishOnly": "npm run compile && npm test",
+    "vscode:prepublish": "npm run compile"
+  },
+  "dependencies": {
+    "web-tree-sitter": "^0.22.6"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.5",
+    "@types/vscode": "^1.80.0",
+    "@types/node": "^20.0.0",
+    "tree-sitter-wasms": "^0.1.12"
+  }
+}