@yonathan124/zentry 1.0.0

package/src/core/scanner.js

@@ -0,0 +1,323 @@
+/**
+ * Zentry — Moteur de Découverte & Scanner RAG v2.0
+ * 
+ * Fonctionnalités :
+ * - Découverte récursive (FileSystem API navigateur & Node.js)
+ * - Parseur de graphe d'imports : regroupe les fichiers dépendants ensemble
+ * - Filtrage intelligent par criticité (routes, auth, DB, config en priorité)
+ * - Tri prioritaire : les fichiers les plus critiques sont audités en premier
+ */
+
+// ─── CONSTANTES ────────────────────────────────────────────────────────────
+const IGNORE_LIST = [
+  '.git', 'node_modules', '.next', 'dist', 'build', 'public',
+  '.vscode', 'coverage', 'storybook-static', '.turbo', '__pycache__',
+  '.pytest_cache', 'target', 'vendor', '.cargo'
+];
+
+const EXT_REGEX = /\.(ts|tsx|js|jsx|py|go|rs|php|java|rb|sql|prisma|yml|yaml|env\.example)$/i;
+
+// Fichiers à exclure malgré l'extension correcte
+const SKIP_PATTERNS = /\.(test|spec|stories|d)\.(ts|tsx|js|jsx)$/i;
+
+// Groupes de criticité : les fichiers correspondants sont traités en priorité
+const CRITICALITY = [
+  { pattern: /(middleware|auth|session|jwt|token|permission|role|policy|guard)\./i, score: 100 },
+  { pattern: /(route|api|handler|controller|endpoint)\./i,                          score: 90  },
+  { pattern: /(db|database|prisma|supabase|mongoose|sequelize|query|sql)\./i,       score: 85  },
+  { pattern: /(config|env|secret|key|credential|vault)\./i,                        score: 80  },
+  { pattern: /(payment|stripe|webhook|billing|invoice)\./i,                        score: 75  },
+  { pattern: /(schema|validator|zod|yup|validation)\./i,                           score: 70  },
+  { pattern: /(upload|file|storage|s3|bucket)\./i,                                score: 65  },
+  { pattern: /(email|sms|notification|mailer)\./i,                                score: 60  },
+];
+
+const MAX_FILES_PER_BLOCK = 4;
+
+// ─── SCORING ───────────────────────────────────────────────────────────────
+function getCriticalityScore(filePath) {
+  const filename = filePath.split('/').pop() || '';
+  for (const { pattern, score } of CRITICALITY) {
+    if (pattern.test(filename) || pattern.test(filePath)) return score;
+  }
+  return 30;
+}
+
+// ─── GRAPHE D'IMPORTS (RAG) ────────────────────────────────────────────────
+/**
+ * Extrait les chemins importés depuis le contenu d'un fichier.
+ * Supporte : import/export ES6, require() CommonJS, dynamic import()
+ */
+export function extractImports(content, filePath) {
+  const imports = new Set();
+  const dir = filePath.substring(0, filePath.lastIndexOf('/'));
+
+  const patterns = [
+    /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g,   // import ... from '...'
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,           // require('...')
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,            // import('...')
+    /export\s+.*?\s+from\s+['"]([^'"]+)['"]/g,         // export ... from '...'
+  ];
+
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const imp = match[1];
+      // On ne garde que les imports relatifs (pas npm packages)
+      if (imp.startsWith('.')) {
+        // Normalise le chemin relatif
+        const normalized = resolveRelativePath(dir, imp);
+        if (normalized) imports.add(normalized);
+      }
+    }
+  }
+  return [...imports];
+}
+
+function resolveRelativePath(fromDir, relativePath) {
+  const parts = (fromDir + '/' + relativePath).split('/');
+  const resolved = [];
+  for (const part of parts) {
+    if (part === '..') resolved.pop();
+    else if (part !== '.') resolved.push(part);
+  }
+  return resolved.join('/');
+}
+
+/**
+ * Construit un graphe d'imports : { filePath: [importedFiles] }
+ */
+export function buildImportGraph(filesWithContent) {
+  const graph = {};
+  for (const { path, content } of filesWithContent) {
+    graph[path] = extractImports(content, path);
+  }
+  return graph;
+}
+
+/**
+ * Algorithme de regroupement par dépendances.
+ * Les fichiers fortement connectés (qui s'importent mutuellement) sont mis dans le même bloc.
+ * 
+ * Algorithme : Union-Find sur le graphe d'imports (non orienté)
+ */
+export function groupByDependencies(files, importGraph) {
+  // Union-Find
+  const parent = {};
+  const find = (x) => {
+    if (parent[x] !== x) parent[x] = find(parent[x]);
+    return parent[x];
+  };
+  const union = (a, b) => {
+    const pa = find(a), pb = find(b);
+    if (pa !== pb) parent[pa] = pb;
+  };
+
+  // Initialise chaque fichier comme son propre parent
+  files.forEach(f => { parent[f] = f; });
+
+  // Unit les fichiers liés par import
+  for (const [file, imports] of Object.entries(importGraph)) {
+    for (const imp of imports) {
+      // Essaie plusieurs extensions pour trouver une correspondance
+      const candidates = [imp, imp + '.ts', imp + '.tsx', imp + '.js', imp + '/index.ts', imp + '/index.tsx'];
+      for (const candidate of candidates) {
+        if (files.includes(candidate)) {
+          union(file, candidate);
+          break;
+        }
+      }
+    }
+  }
+
+  // Regroupe par composante connexe
+  const groups = {};
+  for (const file of files) {
+    const root = find(file);
+    if (!groups[root]) groups[root] = [];
+    groups[root].push(file);
+  }
+
+  return Object.values(groups);
+}
+
+// ─── CONSTRUCTION DES BLOCS ────────────────────────────────────────────────
+/**
+ * Construit les blocs d'audit depuis le graphe de dépendances.
+ * 
+ * Stratégie :
+ * 1. Regrouper les fichiers par composante de dépendance (RAG)
+ * 2. Trier les groupes par score de criticité (décroissant)
+ * 3. Découper en blocs de MAX_FILES_PER_BLOCK fichiers max
+ * 
+ * Résultat : les fichiers liés sont audités ensemble, les plus critiques d'abord
+ */
+export function buildBlocks(files, importGraph = {}) {
+  if (Object.keys(importGraph).length > 0) {
+    // Mode RAG : regroupement par dépendances
+    const dependencyGroups = groupByDependencies(files, importGraph);
+
+    const blocks = [];
+    let bId = 1;
+
+    // Trie les groupes : les plus critiques (score moyen élevé) en premier
+    const scoredGroups = dependencyGroups.map(group => ({
+      group,
+      score: group.reduce((s, f) => s + getCriticalityScore(f), 0) / group.length
+    }));
+    scoredGroups.sort((a, b) => b.score - a.score);
+
+    for (const { group } of scoredGroups) {
+      // Trie les fichiers dans chaque groupe par criticité aussi
+      group.sort((a, b) => getCriticalityScore(b) - getCriticalityScore(a));
+      
+      for (let i = 0; i < group.length; i += MAX_FILES_PER_BLOCK) {
+        const slice = group.slice(i, i + MAX_FILES_PER_BLOCK);
+        const critScore = Math.round(slice.reduce((s, f) => s + getCriticalityScore(f), 0) / slice.length);
+        blocks.push({
+          id: `B${bId.toString().padStart(3, '0')}`,
+          name: `Groupe ${bId} (Criticité: ${critScore}/100)`,
+          files: slice,
+          criticalityScore: critScore,
+          // Indique si ce bloc contient des fichiers fortement liés
+          isRelated: slice.length > 1 && group.length > 1
+        });
+        bId++;
+      }
+    }
+
+    return blocks;
+
+  } else {
+    // Mode dossier (fallback sans graphe d'imports) : regroupement par répertoire
+    const dirs = {};
+    files.forEach(f => {
+      const dir = f.substring(0, f.lastIndexOf('/')) || '/root';
+      if (!dirs[dir]) dirs[dir] = [];
+      dirs[dir].push(f);
+    });
+
+    const blocks = [];
+    let bId = 1;
+
+    // Trie les dossiers par criticité moyenne
+    const sortedDirs = Object.entries(dirs).sort((a, b) => {
+      const scoreA = a[1].reduce((s, f) => s + getCriticalityScore(f), 0) / a[1].length;
+      const scoreB = b[1].reduce((s, f) => s + getCriticalityScore(f), 0) / b[1].length;
+      return scoreB - scoreA;
+    });
+
+    for (const [dir, dirFiles] of sortedDirs) {
+      dirFiles.sort((a, b) => getCriticalityScore(b) - getCriticalityScore(a));
+      for (let i = 0; i < dirFiles.length; i += MAX_FILES_PER_BLOCK) {
+        const slice = dirFiles.slice(i, i + MAX_FILES_PER_BLOCK);
+        blocks.push({
+          id: `B${bId.toString().padStart(3, '0')}`,
+          name: `${dir.split('/').pop() || 'root'} (${Math.floor(i / MAX_FILES_PER_BLOCK) + 1})`,
+          files: slice,
+          criticalityScore: Math.round(slice.reduce((s, f) => s + getCriticalityScore(f), 0) / slice.length),
+          isRelated: false
+        });
+        bId++;
+      }
+    }
+    return blocks;
+  }
+}
+
+// ─── SCANNER NAVIGATEUR ────────────────────────────────────────────────────
+/**
+ * Scan via l'API File System Access du navigateur (handle directory).
+ * Retourne les fichiers avec leur contenu pour le graphe d'imports.
+ */
+export async function scanBrowserDirectory(dirHandle) {
+  const filesWithContent = [];
+
+  async function walk(handle, currentPath = '') {
+    for await (const entry of handle.values()) {
+      if (IGNORE_LIST.includes(entry.name)) continue;
+      
+      const fullPath = currentPath + entry.name;
+      if (entry.kind === 'directory') {
+        await walk(entry, fullPath + '/');
+      } else if (entry.kind === 'file' && EXT_REGEX.test(entry.name) && !SKIP_PATTERNS.test(entry.name)) {
+        try {
+          const file = await entry.getFile();
+          // Limite à 200kb par fichier pour éviter de saturer le contexte IA
+          if (file.size < 204800) {
+            const content = await file.text();
+            filesWithContent.push({ path: fullPath, content, size: file.size });
+          } else {
+            // Fichier trop grand : on le garde mais sans contenu pour le graphe
+            filesWithContent.push({ path: fullPath, content: '', size: file.size, truncated: true });
+          }
+        } catch {
+          filesWithContent.push({ path: fullPath, content: '', size: 0, error: true });
+        }
+      }
+    }
+  }
+
+  await walk(dirHandle);
+  return filesWithContent;
+}
+
+/**
+ * Lit le contenu d'un fichier via FileList (input[type=file]) ou File System Access API
+ */
+export async function readBrowserFile(source, filePath) {
+  try {
+    // Source = FileList (input[type=file])
+    if (source && source[0] && source[0].webkitRelativePath !== undefined) {
+      const f = [...source].find(f => f.webkitRelativePath === filePath || f.name === filePath.split('/').pop());
+      if (f) return await f.text();
+    }
+    // Source = Directory Handle
+    if (source && source.kind === 'directory') {
+      const parts = filePath.split('/');
+      let h = source;
+      for (let i = 0; i < parts.length - 1; i++) {
+        h = await h.getDirectoryHandle(parts[i]);
+      }
+      const fh = await h.getFileHandle(parts[parts.length - 1]);
+      const file = await fh.getFile();
+      return await file.text();
+    }
+    return `// ⚠️ ERREUR DE LECTURE: ${filePath}`;
+  } catch (e) {
+    return `// ⚠️ ERREUR DE LECTURE: ${filePath} — ${e.message}`;
+  }
+}
+
+/**
+ * Construit le graphe d'imports et les blocs RAG depuis FileList (input[type=file])
+ */
+export async function buildRAGBlocksFromFileList(fileList) {
+  const filesWithContent = [];
+  
+  for (const file of fileList) {
+    const path = file.webkitRelativePath || file.name;
+    if (!EXT_REGEX.test(file.name) || SKIP_PATTERNS.test(file.name)) continue;
+    
+    const IGNORE = /node_modules|\.next|dist|\.git/;
+    if (IGNORE.test(path)) continue;
+    
+    try {
+      // Limite à 200kb
+      if (file.size < 204800) {
+        const content = await file.text();
+        filesWithContent.push({ path, content, size: file.size });
+      } else {
+        filesWithContent.push({ path, content: '', size: file.size, truncated: true });
+      }
+    } catch {
+      filesWithContent.push({ path, content: '', size: 0, error: true });
+    }
+  }
+
+  const files = filesWithContent.map(f => f.path);
+  const importGraph = buildImportGraph(filesWithContent);
+  const blocks = buildBlocks(files, importGraph);
+
+  return { files, filesWithContent, importGraph, blocks };
+}

package/src/core/utils.js

@@ -0,0 +1,3 @@
+import { PHASES, STACKS } from '../config/constants';
+
+export 

package/src/index.js

@@ -0,0 +1,7 @@
+// Exporte les composants React
+export { default as ZentryDashboard } from './components/ZentryDashboard';
+
+// Exporte les utilitaires et configurations
+export * from './config/constants';
+export * from './core/ai';
+export * from './core/scanner';