@yonathan124/zentry 1.0.0

package/src/core/ai.js

@@ -0,0 +1,328 @@
+/**
+ * Zentry — Moteur IA v3.0
+ * 
+ * Améliorations :
+ * - Prompt système ULTRA-STRICT avec scoring CVSS-like (0-10)
+ * - Nouveau provider : Mistral (meilleur rapport qualité/prix sur le code)
+ * - Retry automatique avec backoff exponentiel sur les erreurs réseau
+ * - Chunking intelligent : si le code dépasse la fenêtre, découpe proprement
+ * - Cache de résultats (évite de re-payer pour un fichier déjà analysé)
+ * - Parsing structuré de la réponse IA (JSON forcé)
+ */
+
+// ─── PROMPT SYSTÈME ULTRA-STRICT ───────────────────────────────────────────
+export const STRICT_SYSTEM_PROMPT = `Tu es un Auditeur de Sécurité et de Qualité de Code de niveau Industriel (OWASP Top 10, CWE, CVE).
+
+══════════════════════════════════════════════════════════
+RÈGLES ABSOLUES — VIOLATION = RÉSULTAT INUTILISABLE
+══════════════════════════════════════════════════════════
+
+RÈGLE 1 — ZÉRO FAUX POSITIF (la plus importante)
+  • Ne signale une faille que si tu as VU la ligne de code vulnérable.
+  • "Potentiellement" ou "il serait bon de" → ce n'est PAS une faille, c'est un conseil.
+  • Si le code fait la même chose de façon différente mais sécurisée → [SAFE]
+  • Si une lib gère la sécurité en interne (ex: Supabase RLS, Prisma paramètres auto) → valide [SAFE]
+
+RÈGLE 2 — FORMAT DE SORTIE STRICT JSON
+  Retourne UNIQUEMENT du JSON valide, sans markdown, sans texte avant/après.
+  
+  Si le code est sain :
+  { "status": "SAFE", "findings": [] }
+  
+  Si des failles existent :
+  {
+    "status": "FINDINGS",
+    "findings": [
+      {
+        "file": "chemin/vers/fichier.ts",
+        "line": 42,
+        "severity": "CRITICAL|HIGH|MEDIUM|LOW",
+        "cvss": 9.1,
+        "cwe": "CWE-89",
+        "category": "Injection|Auth|XSS|IDOR|Config|Deps|Perf|Architecture",
+        "title": "Injection SQL via interpolation de chaîne",
+        "description": "La requête SQL à la ligne 42 concatène directement req.body.id sans paramètre préparé.",
+        "vulnerable_code": "const q = \`SELECT * FROM users WHERE id = \${req.body.id}\`",
+        "fix": "Utilise des paramètres préparés : db.query('SELECT * FROM users WHERE id = $1', [req.body.id])",
+        "auto_fixable": true
+      }
+    ]
+  }
+
+RÈGLE 3 — SCORING CVSS OBLIGATOIRE
+  • CRITICAL : 9.0-10.0 — RCE, fuite de base de données complète, contournement d'auth total
+  • HIGH : 7.0-8.9 — IDOR, XSS stocké, injection SQL, secrets exposés
+  • MEDIUM : 4.0-6.9 — Rate limiting absent, informations de debug exposées, CSRF
+  • LOW : 0.1-3.9 — Problème de configuration mineur, code mort, mauvaise pratique sans impact direct
+
+RÈGLE 4 — CHAMPS CWE ET AUTO-FIX
+  • Toujours référencer le CWE (Common Weakness Enumeration) pertinent
+  • "auto_fixable": true UNIQUEMENT si tu fournis le correctif complet et applicable directement
+  • "auto_fixable": false si le correctif nécessite une décision architecturale
+
+RÈGLE 5 — CONTEXTE DU PROJET
+  Tu analyses du code de production réel. Chaque faille non signalée = risque réel pour les utilisateurs finaux.
+  Chaque faux positif = perte de confiance dans l'outil = outil abandonné.`;
+
+// ─── CACHE EN MÉMOIRE ──────────────────────────────────────────────────────
+const analysisCache = new Map();
+
+function cacheKey(provider, model, content) {
+  // Hash simple basé sur la longueur + premiers 200 chars + derniers 200 chars
+  const sig = `${provider}:${model}:${content.length}:${content.slice(0, 200)}:${content.slice(-200)}`;
+  return sig;
+}
+
+// ─── RETRY AVEC BACKOFF ────────────────────────────────────────────────────
+async function withRetry(fn, maxRetries = 3) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (attempt === maxRetries) throw err;
+      // Backoff exponentiel : 1s, 2s, 4s
+      await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+    }
+  }
+}
+
+// ─── CHUNKING INTELLIGENT ──────────────────────────────────────────────────
+/**
+ * Si le code dépasse le seuil, le découpe par fonctions/classes/lignes
+ * pour ne jamais tronquer au milieu d'un contexte important.
+ */
+function chunkContent(content, maxChars = 12000) {
+  if (content.length <= maxChars) return [content];
+  
+  const chunks = [];
+  const lines = content.split('\n');
+  let currentChunk = '';
+  let lineIndex = 0;
+
+  while (lineIndex < lines.length) {
+    const line = lines[lineIndex];
+    // Coupe proprement sur une ligne vide ou une déclaration de fonction
+    if (currentChunk.length + line.length > maxChars) {
+      if (currentChunk.trim()) chunks.push(currentChunk);
+      currentChunk = line + '\n';
+    } else {
+      currentChunk += line + '\n';
+    }
+    lineIndex++;
+  }
+  if (currentChunk.trim()) chunks.push(currentChunk);
+  return chunks;
+}
+
+// ─── PARSING SÉCURISÉ DE LA RÉPONSE ───────────────────────────────────────
+export function parseAIResponse(raw) {
+  try {
+    // Cherche le JSON dans la réponse (au cas où il y a du texte parasite)
+    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return { status: 'SAFE', findings: [] };
+    
+    const parsed = JSON.parse(jsonMatch[0]);
+    
+    // Validation du format
+    if (!parsed.status || !Array.isArray(parsed.findings)) {
+      return { status: 'SAFE', findings: [] };
+    }
+    
+    // Enrichit chaque finding avec un ID unique
+    parsed.findings = parsed.findings.map((f, i) => ({
+      id: `F${Date.now()}-${i}`,
+      ...f,
+      cvss: Number(f.cvss) || 5.0,
+      auto_fixable: Boolean(f.auto_fixable),
+    }));
+    
+    return parsed;
+  } catch {
+    // Si l'IA a quand même répondu "SAFE" en texte libre
+    if (raw.includes('[SAFE]') || raw.trim() === 'SAFE') {
+      return { status: 'SAFE', findings: [] };
+    }
+    return { status: 'PARSE_ERROR', findings: [], raw };
+  }
+}
+
+// ─── PROVIDERS ─────────────────────────────────────────────────────────────
+export const AI = {
+  anthropic: {
+    label: "Claude (Anthropic)",
+    models: ["claude-opus-4-5", "claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022"],
+    call: async (key, model, prompt) => {
+      const r = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": key,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model,
+          system: STRICT_SYSTEM_PROMPT,
+          max_tokens: 4096,
+          messages: [{ role: "user", content: prompt }]
+        })
+      });
+      if (!r.ok) throw new Error(`Anthropic API error ${r.status}`);
+      const d = await r.json();
+      return (d.content && d.content[0] && d.content[0].text) || '{"status":"SAFE","findings":[]}';
+    }
+  },
+
+  openai: {
+    label: "GPT-4 (OpenAI)",
+    models: ["gpt-4o", "gpt-4o-mini", "o4-mini"],
+    call: async (key, model, prompt) => {
+      const r = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+        body: JSON.stringify({
+          model,
+          response_format: { type: "json_object" },
+          messages: [
+            { role: "system", content: STRICT_SYSTEM_PROMPT },
+            { role: "user", content: prompt }
+          ]
+        })
+      });
+      if (!r.ok) throw new Error(`OpenAI API error ${r.status}`);
+      const d = await r.json();
+      return (d.choices && d.choices[0]?.message?.content) || '{"status":"SAFE","findings":[]}';
+    }
+  },
+
+  groq: {
+    label: "Llama 3.3 (Groq — Ultra-rapide)",
+    models: ["llama-3.3-70b-versatile", "llama3-70b-8192", "mixtral-8x7b-32768"],
+    call: async (key, model, prompt) => {
+      const r = await fetch("https://api.groq.com/openai/v1/chat/completions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+        body: JSON.stringify({
+          model,
+          response_format: { type: "json_object" },
+          messages: [
+            { role: "system", content: STRICT_SYSTEM_PROMPT },
+            { role: "user", content: prompt }
+          ]
+        })
+      });
+      if (!r.ok) throw new Error(`Groq API error ${r.status}`);
+      const d = await r.json();
+      return (d.choices && d.choices[0]?.message?.content) || '{"status":"SAFE","findings":[]}';
+    }
+  },
+
+  gemini: {
+    label: "Gemini 2.0 (Google)",
+    models: ["gemini-2.0-flash", "gemini-1.5-pro", "gemini-1.5-flash"],
+    call: async (key, model, prompt) => {
+      const r = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${key}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            systemInstruction: { parts: [{ text: STRICT_SYSTEM_PROMPT }] },
+            contents: [{ parts: [{ text: prompt }] }],
+            generationConfig: {
+              maxOutputTokens: 4096,
+              responseMimeType: "application/json"
+            }
+          })
+        }
+      );
+      if (!r.ok) throw new Error(`Gemini API error ${r.status}`);
+      const d = await r.json();
+      return (d.candidates?.[0]?.content?.parts?.[0]?.text) || '{"status":"SAFE","findings":[]}';
+    }
+  },
+
+  mistral: {
+    label: "Mistral Large (Meilleur code)",
+    models: ["mistral-large-latest", "codestral-latest", "mistral-small-latest"],
+    call: async (key, model, prompt) => {
+      const r = await fetch("https://api.mistral.ai/v1/chat/completions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+        body: JSON.stringify({
+          model,
+          response_format: { type: "json_object" },
+          messages: [
+            { role: "system", content: STRICT_SYSTEM_PROMPT },
+            { role: "user", content: prompt }
+          ]
+        })
+      });
+      if (!r.ok) throw new Error(`Mistral API error ${r.status}`);
+      const d = await r.json();
+      return (d.choices && d.choices[0]?.message?.content) || '{"status":"SAFE","findings":[]}';
+    }
+  }
+};
+
+// ─── FONCTION D'APPEL PRINCIPALE ───────────────────────────────────────────
+/**
+ * Appel IA avec cache, retry et chunking automatiques.
+ * Retourne toujours un objet structuré { status, findings }.
+ */
+export async function callAI(provider, key, model, prompt, useCache = true) {
+  const key_ = cacheKey(provider, model, prompt);
+  
+  // Vérifie le cache
+  if (useCache && analysisCache.has(key_)) {
+    return { ...analysisCache.get(key_), fromCache: true };
+  }
+
+  const providerObj = AI[provider];
+  if (!providerObj) throw new Error(`Provider inconnu: ${provider}`);
+
+  // Chunking si le prompt est trop long
+  const promptChunks = chunkContent(prompt, 15000);
+  
+  let allFindings = [];
+  
+  for (const chunk of promptChunks) {
+    const raw = await withRetry(() => providerObj.call(key, model, chunk));
+    const parsed = parseAIResponse(raw);
+    if (parsed.findings) allFindings = allFindings.concat(parsed.findings);
+  }
+
+  const result = {
+    status: allFindings.length > 0 ? 'FINDINGS' : 'SAFE',
+    findings: allFindings,
+    provider,
+    model,
+    timestamp: new Date().toISOString()
+  };
+
+  // Met en cache
+  if (useCache) analysisCache.set(key_, result);
+  
+  return result;
+}
+
+/**
+ * Vide le cache (utile entre deux scans complets)
+ */
+export function clearAnalysisCache() {
+  analysisCache.clear();
+}
+
+/**
+ * Génère le prompt complet pour un bloc de fichiers
+ */
+export function buildAuditPrompt(files, stack = null) {
+  const stackContext = stack
+    ? `\n\nCONTEXTE STACK : ${stack.label} (${stack.db}, auth: ${stack.auth})\nRÈGLES SPÉCIFIQUES:\n${stack.rules}`
+    : '';
+
+  const filesContent = files.map(({ path, content, truncated }) =>
+    `\n${'='.repeat(60)}\nFICHIER: ${path}${truncated ? ' [TRONQUÉ > 200kb]' : ''}\n${'='.repeat(60)}\n${content || '// Fichier vide ou illisible'}`
+  ).join('\n');
+
+  return `Analyse de sécurité et qualité pour les fichiers suivants.${stackContext}\n\nRetourne UNIQUEMENT du JSON valide selon le format spécifié.\n${filesContent}`;
+}

package/src/core/profiler.js

@@ -0,0 +1,144 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Lance le profiler dans le répertoire passé en paramètre (ou process.cwd() par défaut).
+ * Accepter un `cwd` explicite permet de tester la fonction sans `process.chdir()`.
+ */
+export async function runProfiler(cwd = process.cwd()) {
+  console.log('🔍 Zentry — Démarrage du Profiler IA de Sécurité...');
+
+  const config = {
+    project: 'Unknown',
+    stackProfile: 'node',
+    compliance: [],
+    sensitiveData: [],
+    sla: '99.9%',
+    customRules: [
+      { category: "SÉCURITÉ", rule: "Toutes les requêtes externes doivent inclure un timeout." }
+    ]
+  };
+
+  // 1. Lire package.json
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      config.project = pkg.name || path.basename(cwd);
+      
+      const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+      
+      // Détection Stack
+      if (deps['next']) config.stackProfile = 'njs-supa'; // ou njs-prisma
+      if (deps['express']) config.stackProfile = 'node-express';
+      if (deps['@supabase/supabase-js']) config.stackProfile = 'njs-supa';
+      if (deps['prisma']) config.stackProfile = 'njs-prisma';
+
+      // Détection Conformité
+      if (deps['stripe']) {
+        config.compliance.push('PCI-DSS');
+        config.sensitiveData.push('paiements', 'cartes bancaires');
+      }
+    } catch (e) {
+      console.warn('⚠️ Impossible de parser package.json');
+    }
+  } else {
+    config.project = path.basename(cwd);
+  }
+
+  // 2. Détection Prisma (Santé, RGPD)
+  const prismaPath = path.join(cwd, 'prisma', 'schema.prisma');
+  if (fs.existsSync(prismaPath)) {
+    const schema = fs.readFileSync(prismaPath, 'utf8').toLowerCase();
+    if (schema.includes('patient') || schema.includes('health') || schema.includes('medical')) {
+      config.compliance.push('HIPAA');
+      config.sensitiveData.push('données médicales');
+    }
+    if (schema.includes('user') || schema.includes('email') || schema.includes('password')) {
+      config.compliance.push('RGPD');
+      config.sensitiveData.push('données personnelles (PII)');
+    }
+  }
+
+  // Dédoublonnage
+  config.compliance = [...new Set(config.compliance)];
+  config.sensitiveData = [...new Set(config.sensitiveData)];
+
+  if (config.compliance.length === 0) {
+    config.compliance.push('RGPD'); // Base
+  }
+
+  // 3. Sauvegarde de la configuration globale
+  const configPath = path.join(cwd, 'zentry.config.json');
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`✅ Fichier de configuration généré : ${configPath}`);
+
+  // 4. Génération des "System Prompts" IDE (Cursor, Windsurf, Cline)
+  const rulesContent = buildIdeRules(config);
+  
+  const ideFiles = [
+    '.cursorrules',
+    '.windsurfrules',
+    '.clinerules',
+    '.github/copilot-instructions.md'
+  ];
+
+  for (const file of ideFiles) {
+    const filePath = path.join(cwd, file);
+    // Créer le dossier parent si nécessaire (.github)
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    
+    fs.writeFileSync(filePath, rulesContent);
+    console.log(`✅ Règles IDE de sécurité générées : ${file}`);
+  }
+
+  console.log('🎉 Initialisation Zentry terminée. Les IA de votre IDE sont désormais verrouillées sur ces règles de sécurité.');
+}
+
+function buildIdeRules(config) {
+  return `---
+description: "Règles globales de sécurité et conformité générées par Zentry"
+---
+
+# CONTEXTE PROJET ET CONFORMITÉ (ZENTRY)
+Tu travailles sur le projet "${config.project}".
+Ce projet est soumis à des contraintes de sécurité STRICTES.
+
+## NORMES DE CONFORMITÉ ACTIVES
+${config.compliance.map(c => `- ${c}`).join('\n')}
+
+## DONNÉES SENSIBLES MANIPULÉES
+${config.sensitiveData.length > 0 ? config.sensitiveData.map(d => `- ${d}`).join('\n') : '- Aucune donnée hautement sensible détectée par défaut.'}
+SLA cible : ${config.sla}
+
+# 🔴 RÈGLE ABSOLUE : NON-RÉGRESSION ET RESPECT DE L'EXISTANT
+1. AVANT toute modification, tu DOIS analyser le graphe d'import et l'architecture locale.
+2. Tu ne dois JAMAIS casser le code existant qui fonctionne. Tes modifications doivent s'intégrer harmonieusement sans causer d'effets de bord.
+3. Si ta modification risque d'impacter un autre fichier, demande confirmation à l'utilisateur ou assure-toi de mettre à jour le fichier impacté.
+
+# 🛡️ DIRECTIVES DE SÉCURITÉ ("Security By Design")
+Lors de la génération de nouveau code ou de la modification de code existant, tu dois OBLIGATOIREMENT respecter les règles suivantes :
+
+1. **Injection (SQL/NoSQL/Commandes) :** 
+   - Utilise toujours des requêtes préparées ou l'ORM officiel (ex: Prisma).
+   - NE JAMAIS concaténer de chaînes de caractères contenant des inputs utilisateurs dans des requêtes.
+
+2. **Authentification et Autorisation :**
+   - Chaque nouvelle route d'API ou action serveur DOIT vérifier l'authentification ET l'autorisation (rôles/permissions) avant d'exécuter la moindre logique métier.
+   - Ne jamais faire confiance au client (valider systématiquement les IDs côté serveur).
+
+3. **Protection des Données (RGPD / HIPAA / PCI-DSS) :**
+   - Ne jamais logger (console.log) de mots de passe, tokens, clés d'API, ou données de cartes bancaires.
+   - Ne jamais renvoyer le mot de passe hashé au client.
+
+4. **Résilience (SLA ${config.sla}) :**
+   - Toutes les requêtes réseau externes (fetch, axios) doivent avoir un try/catch ET un Timeout défini.
+   - Gérer toutes les erreurs gracieusement sans exposer la stack trace au client.
+
+5. **Règles Personnalisées du Projet :**
+${config.customRules.map(r => `- [${r.category}] ${r.rule}`).join('\n')}
+
+Si tu détectes que l'utilisateur te demande d'écrire du code qui viole ces règles, tu dois REFUSER et proposer la version sécurisée.
+`;
+}