docstodev 1.0.0 → 1.0.3

package/src/cache/cacheManager.ts

@@ -0,0 +1,179 @@
+// Emplacement : M:\workspace\extensions\docstodev\src\cache\cacheManager.ts
+
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from "node:fs";
+import path from "node:path";
+
+export interface CacheEntry {
+  hash: string;
+  timestamp: number;
+  analysis: any;
+  metadata: {
+    lines: number;
+    size: number;
+  };
+}
+
+export interface CacheManifest {
+  version: string;
+  files: Map<string, CacheEntry>;
+  lastUpdate: number;
+}
+
+export class CacheManager {
+  private cacheDir: string;
+  private manifestPath: string;
+  private manifest: CacheManifest;
+  private readonly CACHE_VERSION = "1.0.0";
+
+  constructor(projectRoot: string) {
+    this.cacheDir = path.join(projectRoot, ".docstodev", "cache");
+    this.manifestPath = path.join(this.cacheDir, "manifest.json");
+    
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+
+    this.manifest = this.loadManifest();
+  }
+
+  private loadManifest(): CacheManifest {
+    if (existsSync(this.manifestPath)) {
+      try {
+        const data = JSON.parse(readFileSync(this.manifestPath, "utf-8"));
+        
+        // Vérifier la version du cache
+        if (data.version !== this.CACHE_VERSION) {
+          console.log("⚠️  Cache version mismatch, clearing cache...");
+          return this.createNewManifest();
+        }
+
+        // Reconstituer la Map depuis l'objet
+        return {
+          version: data.version,
+          files: new Map(Object.entries(data.files || {})),
+          lastUpdate: data.lastUpdate
+        };
+      } catch (e) {
+        console.error("⚠️  Failed to load cache manifest:", e);
+        return this.createNewManifest();
+      }
+    }
+    return this.createNewManifest();
+  }
+
+  private createNewManifest(): CacheManifest {
+    return {
+      version: this.CACHE_VERSION,
+      files: new Map(),
+      lastUpdate: Date.now()
+    };
+  }
+
+  private saveManifest(): void {
+    try {
+      const data = {
+        version: this.manifest.version,
+        files: Object.fromEntries(this.manifest.files),
+        lastUpdate: this.manifest.lastUpdate
+      };
+      writeFileSync(this.manifestPath, JSON.stringify(data, null, 2));
+    } catch (e) {
+      console.error("⚠️  Failed to save cache manifest:", e);
+    }
+  }
+
+  private computeHash(filePath: string, content: string): string {
+    const stats = statSync(filePath);
+    const hashContent = `${content}|${stats.mtime.getTime()}|${stats.size}`;
+    return createHash("sha256").update(hashContent).digest("hex");
+  }
+
+  public isCached(filePath: string, content: string): boolean {
+    const entry = this.manifest.files.get(filePath);
+    if (!entry) return false;
+
+    const currentHash = this.computeHash(filePath, content);
+    return entry.hash === currentHash;
+  }
+
+  public get(filePath: string): CacheEntry | null {
+    return this.manifest.files.get(filePath) || null;
+  }
+
+  public set(filePath: string, content: string, analysis: any): void {
+    const stats = statSync(filePath);
+    const hash = this.computeHash(filePath, content);
+
+    const entry: CacheEntry = {
+      hash,
+      timestamp: Date.now(),
+      analysis,
+      metadata: {
+        lines: content.split(/\r?\n/).length,
+        size: stats.size
+      }
+    };
+
+    this.manifest.files.set(filePath, entry);
+    this.manifest.lastUpdate = Date.now();
+    this.saveManifest();
+  }
+
+  public invalidate(filePath: string): void {
+    this.manifest.files.delete(filePath);
+    this.saveManifest();
+  }
+
+  public invalidateAll(): void {
+    this.manifest = this.createNewManifest();
+    this.saveManifest();
+  }
+
+  public getStats(): { total: number; size: number; oldestEntry: number } {
+    const entries = Array.from(this.manifest.files.values());
+    return {
+      total: entries.length,
+      size: entries.reduce((sum, e) => sum + e.metadata.size, 0),
+      oldestEntry: Math.min(...entries.map(e => e.timestamp), Date.now())
+    };
+  }
+
+  public pruneOldEntries(maxAgeMs: number = 7 * 24 * 60 * 60 * 1000): number {
+    const now = Date.now();
+    let pruned = 0;
+
+    for (const [filePath, entry] of this.manifest.files.entries()) {
+      if (now - entry.timestamp > maxAgeMs) {
+        this.manifest.files.delete(filePath);
+        pruned++;
+      }
+    }
+
+    if (pruned > 0) {
+      this.saveManifest();
+    }
+
+    return pruned;
+  }
+
+  public getModifiedFiles(files: string[]): string[] {
+    const modified: string[] = [];
+
+    for (const file of files) {
+      if (!existsSync(file)) continue;
+
+      try {
+        const content = readFileSync(file, "utf-8");
+        if (!this.isCached(file, content)) {
+          modified.push(file);
+        }
+      } catch (e) {
+        // Si erreur de lecture, considérer comme modifié
+        modified.push(file);
+      }
+    }
+
+    return modified;
+  }
+}

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);