docstodev 1.0.0 → 1.0.3

package/src/commands/generateSummary.ts

@@ -3,55 +3,145 @@
 import { writeFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
 
+interface SummaryData {
+  totalFiles: number;
+  sourceFiles?: number;
+  totalComplexity?: number;
+  avgComplexity?: number;
+  totalDeps?: number;
+  topLanguages?: { lang: string; count: number }[];
+  criticalFiles?: string[];
+}
+
 /**
  * Génère un résumé global du projet avec un ton humain et bilingue.
  */
-export function generateSummary(docsDir: string, totalFiles: number, lang: "fr" | "en" = "fr") {
+export function generateSummary(
+  docsDir: string, 
+  data: SummaryData | number, 
+  lang: "fr" | "en" = "fr"
+) {
   mkdirSync(docsDir, { recursive: true });
 
-  const dateStr = new Date().toLocaleString();
-  
-  // Contenu bilingue avec un ton "Expert & Humain"
-  const content = lang === "fr" 
-    ? `# 📊 Vue d'ensemble du Projet – DocsToDev
-
-> 📅 **Rapport généré le :** ${dateStr}
-
-## 🚀 État des lieux
-Salut ! J'ai passé ton projet au peigne fin. Voici un résumé rapide de ce que j'ai trouvé :
-- **Volume traité :** ${totalFiles} fichiers analysés avec succès.
-- **Diagnostic :** La structure est claire et l'analyse est complète. ✅
-
-## 🧭 Navigation Rapide
-Pour aller plus loin, tu peux consulter les documents suivants :
-- **[📂 Arborescence & Analyse](../docs/docs-to-dev.md)** : Pour comprendre la vocation de chaque fichier et les capacités du système.
-- **[💻 Code Source](../)** : Pour retourner explorer la racine de ton projet.
-
----
-*DocsToDev – Ton allié pour une documentation technique vivante et intelligente.*
-`
-    : `# 📊 Project Overview – DocsToDev
+  // Support de l'ancien format (juste un nombre) et du nouveau format (objet complet)
+  const summaryData: SummaryData = typeof data === 'number' 
+    ? { totalFiles: data } 
+    : data;
 
-> 📅 **Generated on:** ${dateStr}
-
-## 🚀 Project Status
-Hey! I've scanned your entire codebase. Here's a quick summary of the findings:
-- **Volume processed:** ${totalFiles} files successfully analyzed.
-- **Diagnosis:** The structure is clear and the analysis is complete. ✅
-
-## 🧭 Quick Navigation
-To dive deeper, check out these documents:
-- **[📂 Tree & Analysis](../docs/docs-to-dev.md)**: Explore file purposes and system capabilities.
-- **[💻 Source Code](../)**: Head back to the project root.
-
----
-*DocsToDev – Your partner for living and intelligent technical documentation.*
-`;
+  const dateStr = new Date().toLocaleString(lang === "fr" ? "fr-FR" : "en-US", {
+    dateStyle: "full",
+    timeStyle: "short"
+  });
+  
+  const t = lang === "fr" ? {
+    title: "📊 Vue d'ensemble du Projet – DocsToDev",
+    genOn: "Rapport généré le",
+    status: "🚀 État des lieux",
+    intro: "Salut ! J'ai passé ton projet au peigne fin. Voici un résumé rapide de ce que j'ai trouvé :",
+    volume: "Volume traité",
+    filesAnalyzed: "fichiers analysés avec succès",
+    sourceFiles: "fichiers sources détectés",
+    diagnosis: "Diagnostic",
+    structureClear: "La structure est claire et l'analyse est complète. ✅",
+    metrics: "📈 Métriques clés",
+    complexity: "Complexité totale",
+    avgComplexity: "Complexité moyenne",
+    dependencies: "Dépendances uniques",
+    topLangs: "🔤 Langages détectés",
+    criticalFiles: "⚠️ Fichiers critiques (haute complexité)",
+    navigation: "🧭 Navigation Rapide",
+    navDesc: "Pour aller plus loin, tu peux consulter les documents suivants :",
+    treeLink: "📂 Arborescence & Analyse",
+    treeDesc: "Pour comprendre la vocation de chaque fichier et les capacités du système.",
+    codeLink: "💻 Code Source",
+    codeDesc: "Pour retourner explorer la racine de ton projet.",
+    footer: "DocsToDev – Ton allié pour une documentation technique vivante et intelligente."
+  } : {
+    title: "📊 Project Overview – DocsToDev",
+    genOn: "Generated on",
+    status: "🚀 Project Status",
+    intro: "Hey! I've scanned your entire codebase. Here's a quick summary of the findings:",
+    volume: "Volume processed",
+    filesAnalyzed: "files successfully analyzed",
+    sourceFiles: "source files detected",
+    diagnosis: "Diagnosis",
+    structureClear: "The structure is clear and the analysis is complete. ✅",
+    metrics: "📈 Key Metrics",
+    complexity: "Total complexity",
+    avgComplexity: "Average complexity",
+    dependencies: "Unique dependencies",
+    topLangs: "🔤 Languages Detected",
+    criticalFiles: "⚠️ Critical Files (high complexity)",
+    navigation: "🧭 Quick Navigation",
+    navDesc: "To dive deeper, check out these documents:",
+    treeLink: "📂 Tree & Analysis",
+    treeDesc: "Explore file purposes and system capabilities.",
+    codeLink: "💻 Source Code",
+    codeDesc: "Head back to the project root.",
+    footer: "DocsToDev – Your partner for living and intelligent technical documentation."
+  };
+  
+  let content = `# ${t.title}\n\n`;
+  content += `> 📅 **${t.genOn} :** ${dateStr}\n\n`;
+  
+  content += `## ${t.status}\n`;
+  content += `${t.intro}\n`;
+  content += `- **${t.volume} :** ${summaryData.totalFiles} ${t.filesAnalyzed}.\n`;
+  
+  if (summaryData.sourceFiles) {
+    content += `- **${t.sourceFiles} :** ${summaryData.sourceFiles} ${t.sourceFiles.toLowerCase()}.\n`;
+  }
+  
+  content += `- **${t.diagnosis} :** ${t.structureClear}\n\n`;
+  
+  // Métriques additionnelles si disponibles
+  if (summaryData.totalComplexity || summaryData.avgComplexity || summaryData.totalDeps) {
+    content += `## ${t.metrics}\n`;
+    
+    if (summaryData.totalComplexity) {
+      content += `- **${t.complexity} :** ${summaryData.totalComplexity}\n`;
+    }
+    
+    if (summaryData.avgComplexity) {
+      content += `- **${t.avgComplexity} :** ${summaryData.avgComplexity}\n`;
+    }
+    
+    if (summaryData.totalDeps) {
+      content += `- **${t.dependencies} :** ${summaryData.totalDeps}\n`;
+    }
+    
+    content += `\n`;
+  }
+  
+  // Langages détectés
+  if (summaryData.topLanguages && summaryData.topLanguages.length > 0) {
+    content += `## ${t.topLangs}\n`;
+    summaryData.topLanguages.forEach(({ lang, count }) => {
+      content += `- **${lang}** : ${count} ${lang === "fr" ? "fichiers" : "files"}\n`;
+    });
+    content += `\n`;
+  }
+  
+  // Fichiers critiques
+  if (summaryData.criticalFiles && summaryData.criticalFiles.length > 0) {
+    content += `## ${t.criticalFiles}\n`;
+    summaryData.criticalFiles.forEach(file => {
+      content += `- \`${file}\`\n`;
+    });
+    content += `\n`;
+  }
+  
+  content += `## ${t.navigation}\n`;
+  content += `${t.navDesc}\n`;
+  content += `- **[${t.treeLink}](../docs/docs-to-dev.md)** : ${t.treeDesc}\n`;
+  content += `- **[${t.codeLink}](../)** : ${t.codeDesc}\n\n`;
+  
+  content += `---\n`;
+  content += `*${t.footer}*\n`;
 
   const outputPath = path.join(docsDir, "summary.md");
   writeFileSync(outputPath, content);
   
-  // Log de succès bilingue
   const successMsg = lang === "fr" 
     ? `📑 Résumé humain généré avec succès : ${outputPath}`
     : `📑 Human-friendly summary successfully generated: ${outputPath}`;

package/src/commands/run.ts

@@ -2,34 +2,56 @@
 import { globby } from "globby";
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
-import puppeteer from "puppeteer";
+import puppeteer, { Browser, Page } from "puppeteer";
 import { exportToHTML } from "../exporters/html.js";
 import { askAI } from "../ai/analyzer.js";
+import { getAnalyzer, getSupportedExtensions } from "../analyzers/languageAnalyzer.js";
+import { CacheManager } from "../cache/cacheManager.js";
 
-type TreeNode = { [key: string]: TreeNode | null };
+type TreeNode = { [key: string]: TreeNode };
+
+interface FileAnalysis {
+    path: string;
+    lines: number;
+    exports: string[];
+    // Ajout de '| undefined' pour supporter les propriétés optionnelles en mode strict
+    imports: Array<{ name: string; type: string; usage?: string | undefined }>;
+    functions: string[];
+    classes: string[];
+    types: string[];
+    complexity: number;
+}
 
 const i18n = {
     fr: {
-        role: "Vocation du fichier",
-        density: "Densité et maintenance",
-        exports: "Capacités offertes",
-        imports: "Collaborations sollicitées",
-        structure: "Architecture des dossiers",
-        deps: "Inventaire des modules externes",
-        aiTitle: "Synthèse Métier (par MakazouIA)",
+        role: "Rôle et responsabilités",
+        density: "Complexité et maintenance",
+        exports: "Exports publics",
+        imports: "Dépendances",
+        structure: "Architecture du projet",
+        deps: "Modules externes",
+        aiTitle: "Analyse Intelligente",
         genAt: "Généré le",
-        reportTitle: "Rapport d'Analyse Technique DocsToDev"
+        reportTitle: "Rapport Technique DocsToDev",
+        functions: "Fonctions",
+        classes: "Classes",
+        types: "Types/Interfaces",
+        complexity: "Score de complexité"
     },
     en: {
-        role: "File Purpose",
-        density: "Density & Maintenance",
-        exports: "Capabilities offered",
-        imports: "External services",
+        role: "Role and responsibilities",
+        density: "Complexity & Maintenance",
+        exports: "Public exports",
+        imports: "Dependencies",
         structure: "Project Architecture",
-        deps: "External Modules Inventory",
-        aiTitle: "Business Insights (by MakazouIA)",
+        deps: "External Modules",
+        aiTitle: "Smart Analysis",
         genAt: "Generated on",
-        reportTitle: "DocsToDev Technical Report"
+        reportTitle: "DocsToDev Technical Report",
+        functions: "Functions",
+        classes: "Classes",
+        types: "Types/Interfaces",
+        complexity: "Complexity score"
     }
 };
 
@@ -37,9 +59,11 @@ function buildTree(files: string[]): TreeNode {
     const root: TreeNode = {};
     for (const file of files) {
         const parts = file.split(path.sep);
-        let current = root;
+        let current: TreeNode = root;
         for (const part of parts) {
-            if (!current[part]) current[part] = {};
+            if (!current[part]) {
+                current[part] = {};
+            }
             current = current[part] as TreeNode;
         }
     }
@@ -57,100 +81,313 @@ function renderTree(tree: TreeNode, prefix = "", currentPath = ""): string {
         const isFile = !child || Object.keys(child).length === 0;
         const label = isFile ? `[${key}](../${fullPath.replace(/\\/g, '/')})` : `**${key}/**`;
         output += `${prefix}${connector}${label}\n`;
-        if (child && Object.keys(child).length > 0) {
+        if (child && typeof child === 'object' && Object.keys(child).length > 0) {
             output += renderTree(child, prefix + (isLast ? "    " : "│   "), fullPath);
         }
     });
     return output;
 }
 
-export async function runCommand(language: "fr" | "en" = "fr"): Promise<number> {
-    const t = i18n[language];
-    console.log(language === "fr" ? "🚀 DocsToDev : Analyse Deep Scan & Graphe..." : "🚀 DocsToDev: Deep Scan & Graph analysis...");
+function analyzeFile(file: string, content: string): FileAnalysis {
+    const lines = content.split(/\r?\n/);
+    const analyzer = getAnalyzer(file);
+    
+    if (analyzer) {
+        const result = analyzer.analyzeFile(content);
+        
+        const ifCount = (content.match(/\b(if|elif|else if)\s*\(/g) || []).length;
+        const forCount = (content.match(/\b(for|foreach|while)\s*\(/g) || []).length;
+        const whileCount = (content.match(/\bwhile\s*\(/g) || []).length;
+        
+        const complexity = 
+            lines.length * 0.1 +
+            result.functions.length * 2 +
+            result.classes.length * 3 +
+            result.imports.length * 1.5 +
+            ifCount * 1 +
+            forCount * 1.5 +
+            whileCount * 1.5;
+        
+        return {
+            path: file,
+            lines: lines.length,
+            exports: result.exports,
+            imports: result.imports,
+            functions: result.functions,
+            classes: result.classes,
+            types: result.types,
+            complexity: Math.round(complexity)
+        };
+    }
+    
+    return {
+        path: file,
+        lines: lines.length,
+        exports: [],
+        imports: [],
+        functions: [],
+        classes: [],
+        types: [],
+        complexity: 0
+    };
+}
+
+function getComplexityLevel(score: number): string {
+    if (score < 50) return "🟢 Faible";
+    if (score < 150) return "🟡 Modérée";
+    if (score < 300) return "🟠 Élevée";
+    return "🔴 Très élevée";
+}
 
+function formatAISummary(summary: string): string {
+    let formatted = summary.replace(/([a-zA-Z0-9_-]+\.(ts|js|py|java|cs|go|rs|tsx|jsx|mjs|cjs))/g, '`$1`');
+    formatted = formatted.replace(/([a-zA-Z0-9_-]+\/[a-zA-Z0-9_\/-]+)/g, '`$1`');
+    formatted = formatted.replace(/\b([a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*|[A-Z][a-z][a-zA-Z0-9]*)\b/g, '`$1`');
+    formatted = formatted.replace(/\.\s+/g, '.\n\n');
+    formatted = formatted.replace(/`+/g, '`');
+    return formatted.trim();
+}
+
+export async function runCommand(
+    language: "fr" | "en" = "fr",
+    options: { incremental?: boolean; clearCache?: boolean } = {}
+): Promise<number> {
+    const t = i18n[language];
+    
+    console.log("\n╔══════════════════════════════════════════╗");
+    console.log("║    🚀 DocsToDev - Analyse Avancée        ║");
+    console.log("╚══════════════════════════════════════════╝\n");
+    
+    const projectRoot = process.cwd();
+    const cache = new CacheManager(projectRoot);
+    
+    if (options.clearCache) {
+        console.log("🗑️  Nettoyage du cache...");
+        cache.invalidateAll();
+        console.log("   ✓ Cache vidé\n");
+    }
+    
+    console.log("📂 Étape 1/6 : Scan des fichiers du projet...");
+    const supportedExts = getSupportedExtensions();
     const files = await globby(["**/*"], {
         gitignore: true,
-        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/docs/**"]
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/docs/**", "**/.docstodev/**"]
     });
+    
+    const sourceFiles = files.filter(f => {
+        const ext = path.extname(f);
+        return supportedExts.includes(ext);
+    });
+    
+    console.log(`   ✓ ${files.length} fichiers détectés (${sourceFiles.length} fichiers sources)\n`);
 
     const docsDir = "docs";
-    if (!existsSync(docsDir)) mkdirSync(docsDir, { recursive: true });
+    if (!existsSync(docsDir)) {
+        console.log("📁 Création du dossier 'docs'...");
+        mkdirSync(docsDir, { recursive: true });
+    }
+
+    let filesToAnalyze = sourceFiles;
+    let cachedCount = 0;
+    
+    if (options.incremental) {
+        console.log("⚡ Mode incrémental activé - Détection des modifications...");
+        const modifiedFiles = cache.getModifiedFiles(sourceFiles);
+        filesToAnalyze = modifiedFiles;
+        cachedCount = sourceFiles.length - modifiedFiles.length;
+        console.log(`   ✓ ${modifiedFiles.length} fichiers modifiés, ${cachedCount} en cache\n`);
+    }
 
-    let aiContext = `Analyse ces fichiers pour DocsToDev. Explique pourquoi ils utilisent leurs dépendances. Format: "Utilise [X] pour [Y]".\n\n`;
+    console.log("🔍 Étape 2/6 : Analyse approfondie des fichiers sources...");
+    let aiContext = `Tu es un expert en analyse de code. Analyse ces fichiers et explique leur architecture, leurs responsabilités et comment ils collaborent ensemble. Identifie le rôle de chaque fichier (Page, Component, Service, API, Utility, etc.). Sois précis et technique.\n\n`;
     let detailContent = `## 🔬 Analyse détaillée des composants\n\n`;
-    let mermaidGraph = "";
+    let mermaidGraph = "graph LR\n";
     const allDeps = new Map<string, string>();
-
-    for (const file of files) {
-        const ext = path.extname(file);
-        if (![".ts", ".js", ".tsx", ".jsx"].includes(ext)) continue;
+    const analyses: FileAnalysis[] = [];
+    
+    let processedCount = 0;
+    
+    if (options.incremental) {
+        for (const file of sourceFiles) {
+            if (!filesToAnalyze.includes(file)) {
+                const cached = cache.get(file);
+                if (cached) {
+                    analyses.push(cached.analysis);
+                }
+            }
+        }
+    }
+    
+    for (const file of filesToAnalyze) {
+        processedCount++;
+        if (processedCount % 5 === 0) {
+            process.stdout.write(`   Analysé: ${processedCount}/${filesToAnalyze.length} fichiers...\r`);
+        }
         
         const content = readFileSync(file, "utf-8");
-        const lines = content.split(/\r?\n/);
-        const fileNameSanitized = path.basename(file).replace(/\./g, '_');
-
-        const exports = lines
-            .filter(l => l.startsWith("export "))
-            .map(l => l.match(/(?:function|const|class|type|interface)\s+([a-zA-Z0-9_]+)/)?.[1])
-            .filter(Boolean) as string[];
-
-        const importLines = lines.filter(l => l.trim().startsWith("import "));
-        
-        detailContent += `### 📄 [\`${file}\`](../${file.replace(/\\/g, '/')})\n`;
-        detailContent += `• **${t.density} :** ${lines.length} lignes\n`;
-        if (exports.length > 0) detailContent += `• **${t.exports} :** ${exports.map(e => `\`${e}\``).join(", ")}\n`;
-
-        if (importLines.length > 0) {
-            detailContent += `• **${t.imports} :**\n`;
-            importLines.forEach(line => {
-                const match = line.match(/from ['"]([^'"]+)['"]/);
-                if (match?.[1]) {
-                    const name = match[1];
-                    const type = name.startsWith('.') ? 'Internal' : (name.startsWith('node:') ? 'Node.js' : 'External');
-                    allDeps.set(name, type);
-                    detailContent += `    - Utilise \`${name}\` (${type})\n`;
-                    
-                    if (type === 'Internal') {
-                        const targetName = path.basename(name).replace(/\./g, '_');
-                        mermaidGraph += `    ${fileNameSanitized} --> ${targetName}\n`;
-                    }
+        const analysis = analyzeFile(file, content);
+        analyses.push(analysis);
+        
+        if (options.incremental) {
+            cache.set(file, content, analysis);
+        }
+        
+        const fileNameSanitized = path.basename(file).replace(/[.\-]/g, '_');
+
+        detailContent += `### 📄 [\`${file}\`](../${file.replace(/\\/g, '/')})\n\n`;
+        detailContent += `**${t.density}** : ${analysis.lines} lignes • ${getComplexityLevel(analysis.complexity)} (${analysis.complexity})\n\n`;
+        
+        if (analysis.functions.length > 0) {
+            detailContent += `**${t.functions}** : ${analysis.functions.map(f => `\`${f}()\``).join(", ")}\n\n`;
+        }
+        
+        if (analysis.classes.length > 0) {
+            detailContent += `**${t.classes}** : ${analysis.classes.map(c => `\`${c}\``).join(", ")}\n\n`;
+        }
+        
+        if (analysis.types.length > 0) {
+            detailContent += `**${t.types}** : ${analysis.types.map(t => `\`${t}\``).join(", ")}\n\n`;
+        }
+
+        if (analysis.exports.length > 0) {
+            detailContent += `**${t.exports}** : ${analysis.exports.map(e => `\`${e}\``).join(", ")}\n\n`;
+        }
+
+        if (analysis.imports.length > 0) {
+            detailContent += `**${t.imports}** :\n\n`;
+            analysis.imports.forEach(imp => {
+                allDeps.set(imp.name, imp.type);
+                const usageInfo = imp.usage ? ` → utilise \`${imp.usage}\`` : '';
+                detailContent += `• \`${imp.name}\` (${imp.type})${usageInfo}\n`;
+                
+                if (imp.type === 'Interne') {
+                    const targetName = path.basename(imp.name).replace(/[.\-]/g, '_');
+                    mermaidGraph += `    ${fileNameSanitized} --> ${targetName}\n`;
                 }
             });
+            detailContent += `\n`;
         }
-        detailContent += `\n---\n\n`;
-        aiContext += `FICHIER: ${file}\nEXPORTS: ${exports.join(",")}\nCODE:\n${lines.slice(0, 40).join("\n")}\n\n`;
+        
+        detailContent += `---\n\n`;
+        
+        aiContext += `═══ FICHIER: ${file} ═══\n`;
+        aiContext += `Langage: ${path.extname(file)}\n`;
+        aiContext += `Complexité: ${analysis.complexity}\n`;
+        aiContext += `Fonctions: ${analysis.functions.join(", ") || "Aucune"}\n`;
+        aiContext += `Classes: ${analysis.classes.join(", ") || "Aucune"}\n`;
+        aiContext += `Exports: ${analysis.exports.join(", ") || "Aucun"}\n`;
+        aiContext += `Dépendances: ${analysis.imports.map(i => i.name).join(", ")}\n`;
+        aiContext += `\nExtrait du code:\n${content.split(/\r?\n/).slice(0, 50).join("\n")}\n\n`;
     }
+    
+    const totalAnalyzed = processedCount + cachedCount;
+    console.log(`   ✓ ${totalAnalyzed} fichiers analysés (${processedCount} nouvelles analyses, ${cachedCount} depuis cache)\n`);
 
-    const aiSummary = await askAI(aiContext) || "Synthèse IA indisponible.";
+    console.log("🤖 Étape 3/6 : Génération de l'analyse intelligente (IA)...");
+    const aiSummary = await askAI(aiContext) || "⚠️ Analyse IA indisponible. Vérifiez votre configuration.";
+    const formattedAiSummary = formatAISummary(aiSummary);
+    console.log(`   ✓ Synthèse IA générée\n`);
 
+    console.log("📝 Étape 4/6 : Construction du rapport Markdown...");
     let finalMD = `# ${t.reportTitle}\n\n`;
-    finalMD += `> 📅 ${t.genAt} : ${new Date().toLocaleString()}\n\n`;
-    finalMD += `## 💡 ${t.aiTitle}\n${aiSummary}\n\n`;
-    finalMD += `## 📂 ${t.structure}\n\n${renderTree(buildTree(files))}\n\n`;
+    finalMD += `> 📅 ${t.genAt} : ${new Date().toLocaleString("fr-FR", { dateStyle: "full", timeStyle: "short" })}\n`;
+    finalMD += `> 📊 ${totalAnalyzed} fichiers analysés • ${allDeps.size} dépendances identifiées\n`;
+    if (options.incremental && cachedCount > 0) {
+        finalMD += `> ⚡ Mode incrémental : ${cachedCount} fichiers depuis cache\n`;
+    }
+    finalMD += `\n`;
+    finalMD += `## 💡 ${t.aiTitle}\n\n${formattedAiSummary}\n\n`;
+    finalMD += `## 📂 ${t.structure}\n\n`;
+    finalMD += "```\n";
+    finalMD += renderTree(buildTree(files));
+    finalMD += "```\n\n";
     finalMD += detailContent;
-    finalMD += `## 📦 ${t.deps}\n\n| Module | Type |\n| :--- | :--- |\n`;
-    Array.from(allDeps.entries()).sort().forEach(([n, ty]) => finalMD += `| \`${n}\` | ${ty} |\n`);
+    finalMD += `## 📦 ${t.deps}\n\n`;
+    finalMD += `| Module | Type | Occurrences |\n`;
+    finalMD += `| :--- | :--- | :---: |\n`;
+    
+    const depCount = new Map<string, number>();
+    analyses.forEach(a => {
+        a.imports.forEach(imp => {
+            depCount.set(imp.name, (depCount.get(imp.name) || 0) + 1);
+        });
+    });
+    
+    Array.from(allDeps.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
+        .forEach(([name, type]) => {
+            finalMD += `| \`${name}\` | ${type} | ${depCount.get(name) || 1} |\n`;
+        });
 
     writeFileSync(path.join(docsDir, "docs-to-dev.md"), finalMD);
-    exportToHTML(docsDir, finalMD, mermaidGraph, language);
+    console.log(`   ✓ Rapport Markdown généré : docs/docs-to-dev.md\n`);
+
+    console.log("🎨 Étape 5/6 : Export HTML avec graphiques...");
+    const fileTreeStructure = buildTree(files);
+    exportToHTML(docsDir, finalMD, mermaidGraph, language, fileTreeStructure);
+    console.log(`   ✓ Rapport HTML généré : docs/report.html\n`);
 
-    console.log("📄 Génération du PDF automatique...");
+    console.log("📄 Étape 6/6 : Génération du PDF...");
     await generatePDF(path.join(docsDir, "report.html"), path.join(docsDir, "report.pdf"));
+    console.log(`   ✓ PDF exporté : docs/report.pdf\n`);
+
+    console.log("╔══════════════════════════════════════════╗");
+    console.log("║   ✨ Analyse terminée avec succès !      ║");
+    console.log("╚══════════════════════════════════════════╝\n");
+    console.log(`📊 Statistiques :`);
+    console.log(`   • ${files.length} fichiers scannés`);
+    console.log(`   • ${totalAnalyzed} fichiers analysés`);
+    if (options.incremental) {
+        console.log(`   • ${cachedCount} fichiers depuis cache`);
+    }
+    console.log(`   • ${allDeps.size} dépendances uniques`);
+    const avgComp = analyses.length > 0 ? Math.round(analyses.reduce((sum, a) => sum + a.complexity, 0) / analyses.length) : 0;
+    console.log(`   • Complexité moyenne : ${avgComp}`);
+    
+    if (options.incremental) {
+        const cacheStats = cache.getStats();
+        console.log(`\n💾 Cache :`);
+        console.log(`   • ${cacheStats.total} entrées`);
+        console.log(`   • ${Math.round(cacheStats.size / 1024)} KB`);
+    }
+    console.log("");
 
     return files.length;
 }
 
-async function generatePDF(htmlPath: string, outputPath: string) {
+async function generatePDF(htmlPath: string, outputPath: string): Promise<void> {
+    let browser: Browser | null = null;
     try {
-        const browser = await puppeteer.launch({ headless: true });
-        const page = await browser.newPage();
-        await page.goto(`file://${path.resolve(htmlPath)}`, { waitUntil: "networkidle0" });
+        browser = await puppeteer.launch({ 
+            headless: true,
+            args: ['--no-sandbox', '--disable-setuid-sandbox']
+        });
+        const page: Page = await browser.newPage();
+        
+        await page.goto(`file://${path.resolve(htmlPath)}`, { 
+            waitUntil: "networkidle0",
+            timeout: 30000
+        });
+        
+        await page.waitForFunction(() => {
+            return typeof (window as any).mermaid !== 'undefined';
+        }, { timeout: 5000 }).catch(() => {});
+        
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
         await page.pdf({ 
             path: outputPath, 
             format: 'A4', 
             printBackground: true, 
-            margin: { top: '1cm', bottom: '1cm', left: '1cm', right: '1cm' } 
+            margin: { top: '1cm', bottom: '1cm', left: '1cm', right: '1cm' },
+            preferCSSPageSize: true
         });
+        
         await browser.close();
-    } catch (e) { console.error("Erreur PDF:", e); }
+    } catch (e) { 
+        console.error("   ⚠️ Erreur lors de la génération du PDF:", e);
+        if (browser) {
+            await browser.close().catch(() => {});
+        }
+    }
 }