docstodev 1.0.0 → 1.0.2

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(() => {});
+        }
+    }
 }