docstodev 1.0.0 → 1.0.2

package/src/cli/index.ts

@@ -11,6 +11,175 @@ import path from "node:path";
 
 const program = new Command();
 
+// Spinner pour les effets de chargement
+class Spinner {
+  private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  private currentFrame = 0;
+  private interval: NodeJS.Timeout | null = null;
+  private message = "";
+
+  start(message: string): void {
+    this.message = message;
+    this.currentFrame = 0;
+    
+    // Cacher le curseur
+    process.stdout.write("\x1B[?25l");
+    
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.currentFrame];
+      process.stdout.write(`\r${frame} ${this.message}`);
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    }, 80);
+  }
+
+  update(message: string): void {
+    this.message = message;
+  }
+
+  succeed(message: string): void {
+    this.stop();
+    console.log(`✓ ${message}`);
+  }
+
+  fail(message: string): void {
+    this.stop();
+    console.log(`✗ ${message}`);
+  }
+
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    // Effacer la ligne actuelle
+    if (process.stdout.clearLine) {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+    }
+    // Réafficher le curseur
+    process.stdout.write("\x1B[?25h");
+  }
+}
+
+// Barre de progression
+class ProgressBar {
+  private total: number;
+  private current = 0;
+  private barLength = 30;
+
+  constructor(total: number) {
+    this.total = total;
+  }
+
+  update(current: number, message?: string): void {
+    this.current = current;
+    const percentage = Math.floor((this.current / this.total) * 100);
+    const filledLength = Math.floor((this.current / this.total) * this.barLength);
+    const bar = "█".repeat(filledLength) + "░".repeat(this.barLength - filledLength);
+    
+    const msg = message ? ` ${message}` : "";
+    const output = `\r[${bar}] ${percentage}%${msg}`;
+    process.stdout.write(output);
+  }
+
+  complete(message: string): void {
+    this.update(this.total);
+    console.log(`\n✓ ${message}`);
+  }
+}
+
+// Animation de texte
+function typeWriter(text: string, delay = 30): Promise<void> {
+  return new Promise((resolve) => {
+    let i = 0;
+    const chars = text.split('');
+    const interval = setInterval(() => {
+      if (i < chars.length) {
+        process.stdout.write(chars[i] || '');
+        i++;
+      } else {
+        clearInterval(interval);
+        process.stdout.write("\n");
+        resolve();
+      }
+    }, delay);
+  });
+}
+
+// Bannière animée
+async function showBanner(lang: "fr" | "en"): Promise<void> {
+  const banner = `
+╔═══════════════════════════════════════════════════════╗
+║                                                       ║
+║     ██████╗  ██████╗  ██████╗███████╗████████╗       ║
+║     ██╔══██╗██╔═══██╗██╔════╝██╔════╝╚══██╔══╝       ║
+║     ██║  ██║██║   ██║██║     ███████╗   ██║          ║
+║     ██║  ██║██║   ██║██║     ╚════██║   ██║          ║
+║     ██████╔╝╚██████╔╝╚██████╗███████║   ██║          ║
+║     ╚═════╝  ╚═════╝  ╚═════╝╚══════╝   ╚═╝  DEV     ║
+║                                                       ║
+║        📚 Analyse Technique & Documentation          ║
+║                    Intelligente                       ║
+║                                                       ║
+╚═══════════════════════════════════════════════════════╝
+`;
+
+  console.clear();
+  const coloredBanner = "\x1b[36m" + banner + "\x1b[0m";
+  console.log(coloredBanner);
+  
+  const tagline = lang === "fr" 
+    ? "    Transformez votre code en documentation professionnelle"
+    : "    Transform your code into professional documentation";
+  
+  await typeWriter(tagline, 20);
+  console.log("");
+}
+
+// Sélection de langue interactive
+async function selectLanguage(): Promise<"fr" | "en"> {
+  console.log("\n🌍 Language Selection / Sélection de la langue\n");
+  console.log("  [1] 🇫🇷 Français");
+  console.log("  [2] 🇬🇧 English\n");
+  
+  const rl = readline.createInterface({ input, output });
+  
+  let answer = "";
+  while (!["1", "2", "fr", "en"].includes(answer.toLowerCase())) {
+    answer = await rl.question("👉 Votre choix / Your choice (1/2 or fr/en): ");
+  }
+  
+  rl.close();
+  
+  if (answer === "1" || answer.toLowerCase() === "fr") {
+    return "fr";
+  }
+  return "en";
+}
+
+// Effet de transition
+function showTransition(message: string): Promise<void> {
+  return new Promise((resolve) => {
+    const dots = ["   ", ".  ", ".. ", "..."];
+    let i = 0;
+    
+    const interval = setInterval(() => {
+      const output = `\r${message}${dots[i % dots.length]}`;
+      process.stdout.write(output);
+      i++;
+      
+      if (i >= 8) {
+        clearInterval(interval);
+        if (process.stdout.clearLine) {
+          process.stdout.clearLine(0);
+          process.stdout.cursorTo(0);
+        }
+        resolve();
+      }
+    }, 200);
+  });
+}
+
 // Configuration de base du CLI
 program
   .name("docs-to-dev")
@@ -21,50 +190,165 @@ program
   .command("run")
   .description("Lancer le cycle complet d'analyse et de documentation")
   .option("-l, --lang <lang>", "Langue forcée du rapport (fr | en)")
+  .option("--no-animation", "Désactiver les animations")
+  .option("-i, --incremental", "Mode incrémental (analyser uniquement les fichiers modifiés)")
+  .option("--clear-cache", "Vider le cache avant l'analyse")
   .action(async (options) => {
+    const useAnimation = options.animation !== false;
     let lang: "fr" | "en";
 
-    // --- 1. Gestion de la Langue ---
+    // --- 1. Bannière et Sélection de Langue ---
+    if (useAnimation) {
+      await showBanner(options.lang || "fr");
+    }
+
     if (options.lang === "fr" || options.lang === "en") {
       lang = options.lang;
     } else {
-      const rl = readline.createInterface({ input, output });
-      console.log("\n🌍 Bienvenue dans DocsToDev / Welcome to DocsToDev");
-      
-      let answer = "";
-      while (!["fr", "en"].includes(answer.toLowerCase())) {
-        answer = await rl.question("👉 Choisissez votre langue / Choose your language (fr/en) : ");
-      }
-      rl.close();
-      lang = answer.toLowerCase() as "fr" | "en";
+      lang = await selectLanguage();
     }
 
-    // --- 2. Interface Utilisateur (Console) ---
     const messages = {
-      fr: { start: "🚀 Démarrage de l'analyse approfondie...", success: "✨ Documentation générée avec succès dans /docs !" },
-      en: { start: "🚀 Starting deep analysis...", success: "✨ Documentation successfully generated in /docs!" }
+      fr: {
+        initializing: "Initialisation de l'environnement",
+        scanning: "Scan des fichiers du projet",
+        analyzing: "Analyse approfondie du code",
+        generating: "Génération de l'analyse IA",
+        building: "Construction du rapport",
+        exporting: "Export HTML avec graphiques",
+        creating: "Création du PDF",
+        finalizing: "Finalisation",
+        success: "Documentation générée avec succès !",
+        error: "Une erreur est survenue lors de l'analyse"
+      },
+      en: {
+        initializing: "Initializing environment",
+        scanning: "Scanning project files",
+        analyzing: "Deep code analysis",
+        generating: "Generating AI insights",
+        building: "Building report",
+        exporting: "Exporting HTML with graphs",
+        creating: "Creating PDF",
+        finalizing: "Finalizing",
+        success: "Documentation generated successfully!",
+        error: "An error occurred during analysis"
+      }
     }[lang];
 
-    console.log(`\n${messages.start} [${lang.toUpperCase()}]\n`);
+    console.log(`\n\x1b[1m${lang === "fr" ? "🚀 Démarrage de l'analyse" : "🚀 Starting analysis"}\x1b[0m\n`);
 
     try {
-      // --- 3. Exécution du Moteur (runCommand) ---
-      // Analyse statique + MakazouIA + Export HTML
-      const fileCount = await runCommand(lang);
+      // --- 2. Phase d'initialisation ---
+      if (useAnimation) {
+        const spinner = new Spinner();
+        spinner.start(messages.initializing);
+        await new Promise(resolve => setTimeout(resolve, 800));
+        spinner.succeed(messages.initializing);
+        await new Promise(resolve => setTimeout(resolve, 200));
+      }
+
+      // --- 3. Exécution du Moteur avec feedback ---
+      console.log("");
+      const fileCount = await runCommand(lang, {
+        incremental: options.incremental,
+        clearCache: options.clearCache
+      });
 
       // --- 4. Génération du Résumé ---
+      if (useAnimation) {
+        await showTransition(messages.finalizing);
+      }
+      
       generateSummary("docs", fileCount || 0, lang);
 
-      console.log(`\n${messages.success}`);
-      console.log(`📂 Dossier : ${process.cwd()}${path.sep}docs\n`);
+      // --- 5. Message de succès avec animation ---
+      console.log("");
+      if (useAnimation) {
+        await new Promise(resolve => setTimeout(resolve, 300));
+        console.log("\n\x1b[32m" + "═".repeat(60) + "\x1b[0m");
+        console.log(`\x1b[32m✨ ${messages.success}\x1b[0m`);
+        console.log("\x1b[32m" + "═".repeat(60) + "\x1b[0m\n");
+      } else {
+        console.log(`\n✨ ${messages.success}\n`);
+      }
+
+      // --- 6. Informations finales ---
+      const outputDir = path.join(process.cwd(), "docs");
+      console.log(`📂 ${lang === "fr" ? "Dossier de sortie" : "Output folder"}: \x1b[36m${outputDir}\x1b[0m`);
+      console.log(`📊 ${lang === "fr" ? "Fichiers analysés" : "Files analyzed"}: \x1b[33m${fileCount}\x1b[0m`);
+      console.log(`\n📄 ${lang === "fr" ? "Fichiers générés" : "Generated files"}:`);
+      console.log(`   • docs-to-dev.md`);
+      console.log(`   • report.html`);
+      console.log(`   • report.pdf`);
+      console.log(`   • summary.json\n`);
       
+      if (lang === "fr") {
+        console.log("💡 \x1b[2mOuvrez report.html dans votre navigateur pour une visualisation interactive\x1b[0m\n");
+      } else {
+        console.log("💡 \x1b[2mOpen report.html in your browser for an interactive view\x1b[0m\n");
+      }
+
     } catch (error) {
-      const errorMsg = lang === "fr" 
-        ? "❌ Une erreur est survenue lors de l'analyse :" 
-        : "❌ An error occurred during analysis:";
-      console.error(errorMsg, error);
+      console.log("");
+      console.error(`\n\x1b[31m❌ ${messages.error}:\x1b[0m`, error);
       process.exit(1);
     }
   });
 
+// Commande info
+program
+  .command("info")
+  .description("Afficher les informations sur DocsToDev")
+  .action(() => {
+    console.log("\n\x1b[36m╔═══════════════════════════════════════╗\x1b[0m");
+    console.log("\x1b[36m║        DocsToDev - Info               ║\x1b[0m");
+    console.log("\x1b[36m╚═══════════════════════════════════════╝\x1b[0m\n");
+    console.log("📦 Version: 1.0.0");
+    console.log("👨‍💻 Auteur: Makazou");
+    console.log("📝 Description: Outil d'analyse de code et génération de documentation");
+    console.log("🔗 Repository: https://github.com/votre-repo/docstodev");
+    console.log("\n✨ Fonctionnalités:");
+    console.log("   • Analyse statique multi-langages (TS/JS, Python, Java, C#, Go, Rust)");
+    console.log("   • Génération de graphiques de dépendances");
+    console.log("   • Synthèse intelligente par IA");
+    console.log("   • Export multi-formats (MD, HTML, PDF)");
+    console.log("   • Support i18n (FR/EN)");
+    console.log("   • Cache intelligent avec mode incrémental");
+    console.log("\n📚 Langages supportés:");
+    console.log("   • TypeScript/JavaScript (.ts, .js, .tsx, .jsx, .mjs, .cjs)");
+    console.log("   • Python (.py)");
+    console.log("   • Java (.java)");
+    console.log("   • C# (.cs)");
+    console.log("   • Go (.go)");
+    console.log("   • Rust (.rs)\n");
+  });
+
+// Commande cache
+program
+  .command("cache")
+  .description("Gérer le cache des analyses")
+  .option("--clear", "Vider complètement le cache")
+  .option("--stats", "Afficher les statistiques du cache")
+  .option("--prune", "Supprimer les entrées de plus de 7 jours")
+  .action((options) => {
+    const { CacheManager } = require("../cache/cacheManager.js");
+    const cache = new CacheManager(process.cwd());
+
+    if (options.clear) {
+      cache.invalidateAll();
+      console.log("\n✓ Cache vidé avec succès\n");
+    } else if (options.prune) {
+      const pruned = cache.pruneOldEntries();
+      console.log(`\n✓ ${pruned} entrées obsolètes supprimées\n`);
+    } else if (options.stats) {
+      const stats = cache.getStats();
+      console.log("\n📊 Statistiques du cache:");
+      console.log(`   • Entrées totales: ${stats.total}`);
+      console.log(`   • Taille: ${Math.round(stats.size / 1024)} KB`);
+      console.log(`   • Entrée la plus ancienne: ${new Date(stats.oldestEntry).toLocaleString()}\n`);
+    } else {
+      console.log("\n⚠️  Spécifiez une option: --clear, --stats, ou --prune\n");
+    }
+  });
+
 program.parse(process.argv);