@yonathan124/zentry 1.0.0

package/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Guide de Contribution - Zentry
+
+Merci de votre intérêt pour améliorer Zentry !
+
+## Architecture du projet
+
+Zentry est découpé en plusieurs modules internes :
+- \`src/cli/zentry-cli.js\` : Point d'entrée du CLI (Pre-commit, init, ui).
+- \`src/cli/server.js\` : Mini-serveur Express qui expose le Dashboard React et les routes locales d'auto-remédiation.
+- \`src/core/profiler.js\` : Le moteur d'auto-détection (lit le package.json, les schémas, génère les `.cursorrules`).
+- \`src/core/scanner.js\` : Moteur RAG et construction du Graphe d'Impact (parse les imports).
+- \`src/core/ai.js\` : Wrapper autour des LLMs (Groq, OpenAI, Gemini).
+- \`src/components/ZentryDashboard.jsx\` : Interface React standalone (chargée via Babel in-browser pour éviter un pipeline de build lourd).
+
+## Comment ajouter un nouveau moteur LLM (Provider) ?
+
+1. Ouvrez \`src/core/ai.js\`.
+2. Ajoutez la logique d'appel fetch() dans la fonction \`callAI\`.
+3. Assurez-vous que l'output JSON respecte le format interne de Zentry.
+4. Mettez à jour \`src/components/ZentryDashboard.jsx\` pour ajouter le logo et le modèle dans la liste des fournisseurs.
+
+## Comment ajouter une nouvelle règle de conformité automatique ?
+
+Si vous souhaitez que \`zentry init\` détecte un nouveau standard (par exemple SOC2) :
+1. Allez dans \`src/core/profiler.js\`.
+2. Ajoutez un test de détection (ex: vérifier la présence de certains mots-clés dans les dépendances ou fichiers de configuration).
+3. Poussez la chaîne `"SOC2"` dans le tableau \`config.compliance\`.
+
+## Pull Requests
+Nous privilégions les PRs courtes et testées localement. 
+Avant de soumettre :
+\`\`\`bash
+# 1. Vérifiez que le profiler marche
+node src/cli/zentry-cli.js init
+
+# 2. Vérifiez que l'UI se lance
+node src/cli/zentry-cli.js ui
+\`\`\`

package/LICENSE

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

package/README.md

@@ -0,0 +1,68 @@
+# Zentry Security Scanner 🛡️
+
+Zentry est un moteur DevSecOps (Sécurité & Qualité) piloté par l'IA, conçu pour sécuriser votre code à la source de manière autonome. Il intègre une approche de "Security By Design", intercepte les commits non sécurisés, et propose une auto-remédiation locale via un Dashboard visuel.
+
+## ✨ Fonctionnalités V6 (Universal Architecture)
+
+- **Proactif (IDE Guardrails) :** Génère automatiquement les règles `.cursorrules`, `.clinerules`, `.windsurfrules` pour forcer l'IA de votre IDE à respecter vos contraintes de sécurité *avant* l'écriture du code.
+- **Auto-Détection de Conformité :** Analyse votre `package.json` et vos schémas (Prisma) pour activer automatiquement les règles RGPD, PCI-DSS, ou HIPAA.
+- **Serveur UI Local Indépendant :** Pas besoin d'un backend Next.js. Zentry lance son propre serveur Express local pour son Dashboard.
+- **Graphe d'Impact (--diff) :** En pre-commit, il scanne les fichiers modifiés *ainsi que tous les fichiers qui en dépendent*, garantissant une non-régression absolue.
+- **Preuves d'Audit :** Génère des rapports Markdown persistants dans `.zentry/reports/`.
+
+## 📦 Installation
+
+\`\`\`bash
+npm install -g @orvia/zentry
+# ou l'ajouter à votre projet local :
+npm install --save-dev @orvia/zentry
+\`\`\`
+
+## 🚀 Utilisation Rapide
+
+### 1. Initialiser le profil de sécurité
+Dans le dossier racine de votre projet, lancez :
+\`\`\`bash
+npx zentry init
+\`\`\`
+*Cela génère `zentry.config.json` et sécurise vos IDE (Cursor, Windsurf, Cline).*
+
+### 2. Lancer le Dashboard Visuel (Serveur Local)
+\`\`\`bash
+npx zentry ui
+\`\`\`
+*Ouvre un serveur Express sur http://localhost:8080 avec l'interface d'audit et la fonctionnalité de correction automatique (God Mode).*
+
+### 3. Intégration Git (Pre-commit)
+Ajoutez cette ligne dans votre script de pre-commit (`.husky/pre-commit` ou `.git/hooks/pre-commit`) :
+\`\`\`bash
+npx zentry --diff
+\`\`\`
+*Bloquera les commits si une régression de sécurité est détectée.*
+
+### 4. Audit Global et Rapport
+\`\`\`bash
+npx zentry
+\`\`\`
+*Scanne l'intégralité du projet et génère un rapport Markdown dans `.zentry/reports/`.*
+
+## ⚙️ Configuration (zentry.config.json)
+
+Généré automatiquement par `init`, vous pouvez le modifier manuellement pour ajouter des règles métier :
+\`\`\`json
+{
+  "project": "MonProjet",
+  "compliance": ["RGPD", "PCI-DSS"],
+  "sla": "99.9%",
+  "customRules": [
+    { "category": "SÉCURITÉ", "rule": "Toutes les requêtes externes doivent inclure un timeout." }
+  ]
+}
+\`\`\`
+
+## 🔑 Clés API
+Zentry utilise les modèles LLM de pointe. Assurez-vous d'avoir au moins l'une de ces variables d'environnement (selon votre choix dans l'UI ou le CLI) :
+- \`GROQ_API_KEY\` (Recommandé, super rapide avec LLaMA 3.3)
+- \`GEMINI_API_KEY\`
+- \`OPENAI_API_KEY\`
+- \`ANTHROPIC_API_KEY\`

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@yonathan124/zentry",
+  "version": "1.0.0",
+  "description": "Zentry — AI-powered DevSecOps engine. Auto-detects vulnerabilities, generates IDE security guardrails, and auto-remediates code.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "zentry": "src/cli/zentry-cli.js"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "CONTRIBUTING.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "security",
+    "audit",
+    "devsecops",
+    "cli",
+    "ai",
+    "llm",
+    "vulnerability",
+    "sast",
+    "pre-commit",
+    "compliance",
+    "rgpd",
+    "pci-dss"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yonathan124/zentry.git"
+  },
+  "author": "Orvia",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^5.2.1"
+  },
+  "devDependencies": {
+    "vitest": "^1.6.1"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/cli/server.js

@@ -0,0 +1,170 @@
+import express from 'express';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function startUIServer(port = 8080) {
+  // Racine du projet = là où l'utilisateur a lancé la commande, jamais ailleurs
+  const rootDir = path.resolve(process.cwd());
+
+  const app = express();
+  app.use(express.json({ limit: '5mb' })); // Réduit de 50mb → 5mb (50mb = DoS local possible)
+
+  // ─── SÉCURITÉ : Uniquement localhost, jamais le réseau externe ───────────
+  // On bind explicitement sur 127.0.0.1 dans le listen() plus bas.
+
+  // ─── API Auto-Remediation (God Mode) ─────────────────────────────────────
+  app.post('/api/zentry/fix', (req, res) => {
+    try {
+      const { filePath, content } = req.body;
+
+      // Validation : les deux champs sont requis et non-vides
+      if (typeof filePath !== 'string' || !filePath.trim()) {
+        return res.status(400).json({ success: false, error: 'filePath manquant ou invalide.' });
+      }
+      if (typeof content !== 'string') {
+        return res.status(400).json({ success: false, error: 'content manquant ou invalide.' });
+      }
+
+      // Résolution sécurisée du chemin
+      const absolutePath = path.resolve(rootDir, filePath);
+
+      // ─── SÉCURITÉ : Protection Path Traversal ──────────────────────────
+      // path.resolve() normalise les `../../` avant la comparaison
+      // On vérifie avec un séparateur trailing pour éviter les faux positifs
+      // ex: rootDir='/home/project', absolutePath='/home/project-evil/...' serait capturé
+      const safeRoot = rootDir.endsWith(path.sep) ? rootDir : rootDir + path.sep;
+      if (!absolutePath.startsWith(safeRoot) && absolutePath !== rootDir) {
+        console.error(`[SECURITY] Tentative d'accès hors workspace: ${absolutePath}`);
+        return res.status(403).json({ success: false, error: 'Accès refusé. Le chemin est hors du workspace.' });
+      }
+
+      // On refuse d'écraser les fichiers de config critiques du projet Zentry
+      const PROTECTED = ['.cursorrules', '.clinerules', '.windsurfrules', 'zentry.config.json'];
+      if (PROTECTED.some(p => absolutePath.endsWith(p))) {
+        return res.status(403).json({ success: false, error: `Fichier protégé: ${path.basename(absolutePath)}` });
+      }
+
+      // Écriture atomique : on écrit dans un fichier temp puis on le renomme
+      const tmpPath = absolutePath + '.zentry.tmp';
+      fs.writeFileSync(tmpPath, content, 'utf8');
+      fs.renameSync(tmpPath, absolutePath);
+
+      console.log(`✅ [God Mode] Fichier corrigé: ${path.relative(rootDir, absolutePath)}`);
+      return res.json({ success: true, message: 'Fichier corrigé avec succès.' });
+    } catch (e) {
+      // Ne pas exposer le stack trace au client
+      console.error('[Server Error]', e.message);
+      return res.status(500).json({ success: false, error: 'Erreur interne du serveur.' });
+    }
+  });
+
+  // ─── Fichiers statiques du package Zentry ─────────────────────────────
+  const srcPath = path.join(__dirname, '..');
+  app.use('/src', express.static(srcPath, {
+    // Empêche de traverser hors du dossier src
+    dotfiles: 'deny',
+    index: false
+  }));
+
+  // ─── Interface HTML ───────────────────────────────────────────────────────
+  app.get('/', (_req, res) => {
+    res.send(`
+      <!DOCTYPE html>
+      <html lang="fr">
+      <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>Zentry Pro Dashboard</title>
+        <!-- CSP strict : pas d'inline eval arbitraire depuis une source externe -->
+        <meta http-equiv="Content-Security-Policy"
+              content="default-src 'self' https://unpkg.com https://fonts.googleapis.com; script-src 'self' 'unsafe-eval' https://unpkg.com; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src https://fonts.gstatic.com;">
+        <script src="https://unpkg.com/react@18/umd/react.production.min.js" crossorigin="anonymous"></script>
+        <script src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js" crossorigin="anonymous"></script>
+        <script src="https://unpkg.com/@babel/standalone/babel.min.js" crossorigin="anonymous"></script>
+        <style>
+          body { margin: 0; padding: 0; background: #0A0A12; color: #fff; font-family: sans-serif; }
+          #root { height: 100vh; overflow: hidden; }
+          #loader { display:flex; align-items:center; justify-content:center; height:100vh; flex-direction:column; gap:12px; }
+          #loader p { color: #8B5CF6; font-size: 14px; }
+          .spinner { width:32px; height:32px; border:3px solid #2A2A42; border-top-color:#8B5CF6; border-radius:50%; animation: spin .8s linear infinite; }
+          @keyframes spin { to { transform: rotate(360deg); } }
+        </style>
+      </head>
+      <body>
+        <div id="root">
+          <div id="loader">
+            <div class="spinner"></div>
+            <p>Chargement de Zentry Pro…</p>
+          </div>
+        </div>
+        <script type="text/babel">
+          // Note : 'unsafe-eval' est requis pour @babel/standalone (transpilation in-browser).
+          // Le code chargé vient uniquement de localhost (même origine), ce qui est sûr.
+          async function boot() {
+            const [constantsRes, dashboardRes] = await Promise.all([
+              fetch('/src/config/constants.js'),
+              fetch('/src/components/ZentryDashboard.jsx'),
+            ]);
+
+            if (!constantsRes.ok || !dashboardRes.ok) {
+              document.getElementById('root').innerHTML = '<div style="color:red;padding:40px">Erreur de chargement des fichiers Zentry. Vérifiez le serveur.</div>';
+              return;
+            }
+
+            const constantsCode = await constantsRes.text();
+            const dashboardCode = await dashboardRes.text();
+
+            // Transpile les deux fichiers
+            const transpileOptions = { presets: ['react'], plugins: ['transform-modules-commonjs'] };
+            const transpiledConstants = Babel.transform(constantsCode, transpileOptions).code;
+            const transpiledDashboard = Babel.transform(dashboardCode, transpileOptions).code;
+
+            // Évaluation sécurisée dans un contexte fermé
+            const moduleConstants = {};
+            const exportsConstants = {};
+            new Function('exports', 'module', transpiledConstants)(exportsConstants, { exports: moduleConstants });
+            const constants = Object.keys(exportsConstants).length > 0 ? exportsConstants : moduleConstants;
+
+            const require = (name) => {
+              if (name === 'react') return window.React;
+              if (name.includes('constants')) return constants;
+              return {};
+            };
+
+            const exportsApp = {};
+            new Function('require', 'exports', 'React', transpiledDashboard)(require, exportsApp, window.React);
+
+            const Zentry = exportsApp.default;
+            if (!Zentry) {
+              document.getElementById('root').innerHTML = '<div style="color:orange;padding:40px">Composant Zentry introuvable. Vérifiez ZentryDashboard.jsx.</div>';
+              return;
+            }
+
+            const root = ReactDOM.createRoot(document.getElementById('root'));
+            root.render(React.createElement(Zentry));
+          }
+
+          boot().catch(err => {
+            document.getElementById('root').innerHTML = '<div style="color:red;padding:40px">Erreur critique: ' + err.message + '</div>';
+          });
+        </script>
+      </body>
+      </html>
+    `);
+  });
+
+  // ─── SÉCURITÉ : Bind UNIQUEMENT sur localhost ─────────────────────────────
+  // Personne sur le réseau externe ne peut atteindre ce serveur
+  app.listen(port, '127.0.0.1', () => {
+    const url = `http://localhost:${port}`;
+    console.log(`\n🛡️  Zentry UI Server — Écoute uniquement sur localhost (réseau local protégé)`);
+    console.log(`✅  Dashboard disponible : ${url}\n`);
+    const startCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${startCmd} ${url}`);
+  });
+}

package/src/cli/zentry-cli.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+
+/**
+ * Zentry CLI v5.0 - Pre-commit & CI Scanner (Fully Wired)
+ * Usage: node zentry-cli.js [--all] [--diff] [--auto-fix] [--provider groq]
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { buildBlocks, buildImportGraph } from '../core/scanner.js';
+import { callAI, buildAuditPrompt } from '../core/ai.js';
+import { runProfiler } from '../core/profiler.js';
+import { startUIServer } from './server.js';
+
+const IGNORE_LIST = ['.git', 'node_modules', '.next', 'dist', 'build', 'public'];
+const EXT_REGEX = /\.(ts|tsx|js|jsx|py|go|rs|php|java|rb|sql|prisma)$/i;
+
+function scanLocalDirectory(dir) {
+  let results = [];
+  try {
+    const list = fs.readdirSync(dir);
+    for (const file of list) {
+      if (IGNORE_LIST.includes(file)) continue;
+      const fullPath = path.join(dir, file);
+      const stat = fs.statSync(fullPath);
+      if (stat && stat.isDirectory()) {
+        results = results.concat(scanLocalDirectory(fullPath));
+      } else if (EXT_REGEX.test(file)) {
+        results.push(fullPath);
+      }
+    }
+  } catch (e) {
+    // Ignore access errors
+  }
+  return results;
+}
+
+function getGitDiffFiles() {
+  try {
+    const output = execSync('git diff --name-only --cached', { encoding: 'utf-8' });
+    return output.split('\n')
+      .map(l => l.trim())
+      .filter(l => l && EXT_REGEX.test(l) && fs.existsSync(l));
+  } catch (e) {
+    return [];
+  }
+}
+
+async function applyAutoFix(filePath, finding) {
+  if (!finding.auto_fixable || !finding.vulnerable_code || !finding.fix) return false;
+  
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    if (!content.includes(finding.vulnerable_code)) {
+      console.warn(`⚠️  Le code vulnérable exact n'a pas été trouvé dans ${filePath}. Auto-fix ignoré.`);
+      return false;
+    }
+    const newContent = content.replace(finding.vulnerable_code, finding.fix);
+    fs.writeFileSync(filePath, newContent, 'utf8');
+    console.log(`✅ [FIXED] ${finding.title} dans ${filePath}`);
+    return true;
+  } catch (err) {
+    console.error(`❌ Erreur lors de l'application du fix dans ${filePath}:`, err.message);
+    return false;
+  }
+}
+
+async function run() {
+  const args = process.argv.slice(2);
+  
+  // Commande UI (Serveur local indépendant)
+  if (args.includes('ui')) {
+    startUIServer();
+    return; // Ne pas process.exit() pour laisser le serveur tourner
+  }
+
+  // Commande d'initialisation (Profile & IDE Guardrails)
+  if (args.includes('init')) {
+    await runProfiler();
+    process.exit(0);
+  }
+
+  const isDiff = args.includes('--diff');
+  const isAutoFix = args.includes('--auto-fix');
+  const isAutoPR = args.includes('--auto-pr');
+  
+  // Lecture du provider
+  const providerIndex = args.indexOf('--provider');
+  const provider = providerIndex !== -1 ? args[providerIndex + 1] : 'groq';
+  const model = provider === 'groq' ? 'llama-3.3-70b-versatile' : (provider === 'gemini' ? 'gemini-2.0-flash' : 'gpt-4o');
+  
+  // Récupération de la clé API
+  const envVarName = `${provider.toUpperCase()}_API_KEY`;
+  const apiKey = process.env[envVarName];
+  
+  console.log("🚀 Zentry CLI v5.0 — God Mode Activé");
+  console.log(`🧠 Provider: ${provider} (Modèle: ${model})`);
+  
+  if (!apiKey) {
+    console.error(`❌ ERREUR: La variable d'environnement ${envVarName} n'est pas définie.`);
+    process.exit(1);
+  }
+  
+  let diffFiles = [];
+  let filePaths = [];
+  
+  if (isDiff) {
+    console.log("🔍 Mode Incrémental: Scan via Graphe d'Impact...");
+    diffFiles = getGitDiffFiles();
+    if (diffFiles.length === 0) {
+      console.log("✅ Aucun fichier modifié à auditer. Terminé.");
+      process.exit(0);
+    }
+  } else {
+    console.log("🔍 Mode Global: Scan complet du répertoire local...");
+  }
+
+  // Pour construire un graphe d'impact fiable, on a besoin de tous les fichiers locaux
+  filePaths = scanLocalDirectory(process.cwd());
+
+  if (filePaths.length === 0) {
+    console.log("✅ Aucun fichier correspondant à auditer. Terminé.");
+    process.exit(0);
+  }
+
+  console.log(`📌 Lecture de ${filePaths.length} fichier(s). Préparation du contexte (RAG)...`);
+  
+  // Lire le contenu des fichiers
+  const filesWithContent = [];
+  for (const fp of filePaths) {
+    try {
+      const content = fs.readFileSync(fp, 'utf8');
+      filesWithContent.push({ path: fp, content });
+    } catch (e) {
+      // Ignorer
+    }
+  }
+
+  const importGraph = buildImportGraph(filesWithContent);
+  let blocks = buildBlocks(filePaths, importGraph);
+  
+  if (isDiff) {
+    // Filtrage Graphe d'Impact : on ne garde que les blocs contenant au moins un fichier modifié
+    const initialBlockCount = blocks.length;
+    blocks = blocks.filter(b => b.files.some(f => diffFiles.includes(f) || diffFiles.some(df => f.includes(df))));
+    console.log(`📦 Impact Graph: ${blocks.length} bloc(s) impacté(s) (sur ${initialBlockCount} blocs au total).`);
+  } else {
+    console.log(`📦 Regroupement terminé: ${blocks.length} bloc(s) d'analyse prêt(s).`);
+  }
+
+  let branchName = `zentry-security-fixes-${Date.now()}`;
+  if (isAutoPR) {
+    console.log(`🌿 Création de la branche: ${branchName}`);
+    try {
+      execSync(`git checkout -b ${branchName}`, { stdio: 'inherit' });
+    } catch (e) {
+      console.error("❌ Impossible de créer la branche Git.");
+      process.exit(1);
+    }
+  }
+
+  let totalFindings = [];
+  let fixedCount = 0;
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    console.log(`\n⏳ Analyse du bloc ${i + 1}/${blocks.length}: ${block.name} (${block.files.length} fichiers)`);
+    
+    const blockFiles = block.files.map(fPath => filesWithContent.find(fwc => fwc.path === fPath)).filter(Boolean);
+    const prompt = buildAuditPrompt(blockFiles);
+    
+    try {
+      const aiResult = await callAI(provider, apiKey, model, prompt, false);
+      if (aiResult.status === 'FINDINGS') {
+        totalFindings = totalFindings.concat(aiResult.findings);
+        console.log(`  🔴 Faille(s) détectée(s) : ${aiResult.findings.length}`);
+        
+        for (const finding of aiResult.findings) {
+          console.log(`    - [${finding.severity}] ${finding.title} (Fichier: ${finding.file})`);
+          
+          if ((isAutoFix || isAutoPR) && finding.auto_fixable) {
+            const absolutePath = path.resolve(process.cwd(), finding.file);
+            if (fs.existsSync(absolutePath)) {
+              const success = await applyAutoFix(absolutePath, finding);
+              if (success) fixedCount++;
+            } else {
+              console.warn(`    ⚠️ Fichier introuvable pour fix: ${absolutePath}`);
+            }
+          }
+        }
+      } else {
+        console.log("  ✅ Aucune faille détectée (SAFE).");
+      }
+    } catch (err) {
+      console.error(`  ❌ Échec de l'analyse du bloc:`, err.message);
+    }
+  }
+
+  console.log("\n=======================================================");
+  console.log("🏁 RAPPORT FINAL ZENTRY");
+  console.log("=======================================================");
+  console.log(`Total des fichiers audités: ${filePaths.length}`);
+  console.log(`Failles totales détectées : ${totalFindings.length}`);
+  if (isAutoFix || isAutoPR) {
+    console.log(`Failles corrigées auto.   : ${fixedCount}`);
+  }
+
+  // Export du rapport en mode Global
+  if (!isDiff) {
+    try {
+      const reportDir = path.join(process.cwd(), '.zentry', 'reports');
+      if (!fs.existsSync(reportDir)) fs.mkdirSync(reportDir, { recursive: true });
+      const dateStr = new Date().toISOString().split('T')[0];
+      const reportPath = path.join(reportDir, `audit-${dateStr}.md`);
+      
+      let md = `# Rapport d'Audit de Sécurité Zentry\n> Date: ${new Date().toLocaleString()}\n> Mode: Global (--all)\n\n`;
+      md += `**Résumé :** ${filePaths.length} fichiers audités, ${totalFindings.length} failles détectées.\n\n`;
+      
+      if (totalFindings.length === 0) {
+        md += `✅ **Aucune vulnérabilité détectée. Le code est sécurisé.**\n`;
+      } else {
+        md += `## Failles Détectées\n`;
+        totalFindings.forEach((f, idx) => {
+          md += `### ${idx + 1}. [${f.severity}] ${f.title}\n`;
+          md += `- **Fichier :** \`${f.file}\`\n`;
+          md += `- **Description :** ${f.description}\n`;
+          if (f.vulnerable_code) md += `- **Code vulnérable :**\n\`\`\`\n${f.vulnerable_code}\n\`\`\`\n`;
+          if (f.fix) md += `- **Solution proposée :**\n\`\`\`\n${f.fix}\n\`\`\`\n\n`;
+        });
+      }
+      
+      fs.writeFileSync(reportPath, md, 'utf8');
+      console.log(`\n📄 Rapport de preuve généré : ${reportPath}`);
+    } catch (e) {
+      console.error(`⚠️ Impossible d'écrire le rapport Markdown :`, e.message);
+    }
+  }
+
+  if (isAutoPR && fixedCount > 0) {
+    console.log(`\n🚀 Commit et Push automatique...`);
+    try {
+      execSync(`git add .`, { stdio: 'inherit' });
+      execSync(`git commit -m "[SECURITY] Zentry Auto-Remediation: ${fixedCount} fix(es)"`, { stdio: 'inherit' });
+      execSync(`git push origin ${branchName}`, { stdio: 'inherit' });
+      console.log(`✅ Pull Request prête sur la branche ${branchName} !`);
+    } catch (e) {
+      console.log("⚠️ Git push a échoué (vérifiez vos droits ou l'état du repo).");
+    }
+  }
+  
+  if (totalFindings.length > 0 && !(isAutoPR && fixedCount === totalFindings.length)) {
+    // Il reste des failles non corrigées (ou le push auto n'était pas demandé)
+    process.exit(1);
+  } else {
+    process.exit(0);
+  }
+}
+
+run().catch(err => {
+  console.error("Critical Error:", err);
+  process.exit(1);
+});