@configjs/cli 1.1.16 → 1.1.18

package/dist/{chunk-TN27AX4L.js → chunk-FJLN62L4.js}

@@ -1,24 +1,29 @@
 import {
   CompatibilityValidator,
   allCompatibilityRules
-} from "./chunk-NYCK4R4K.js";
+} from "./chunk-RIJNUJDC.js";
 import {
   BackupManager,
   ConfigWriter,
   getPluginsByCategory,
   getRecommendedPlugins,
   pluginRegistry
-} from "./chunk-JYWGJJ4M.js";
+} from "./chunk-D7IWYKUX.js";
 import {
   PluginTracker
-} from "./chunk-UKEHW2LH.js";
+} from "./chunk-Y4XYC7QV.js";
 import {
   SpinnerManager
 } from "./chunk-KAMPBTFG.js";
+import {
+  checkPathExists,
+  readFileContent,
+  writeFileContent
+} from "./chunk-HI7RYD6W.js";
 import {
   getModuleLogger,
   logger
-} from "./chunk-QPEUT7QG.js";
+} from "./chunk-VN4XTFDK.js";
 import {
   getTranslations
 } from "./chunk-L4GX22RG.js";
@@ -36,11 +41,11 @@ var frameworkRegistry = {
       ts: "react-ts"
     },
     getSetupPrompt: async (language) => {
-      const { promptViteSetup } = await import("./vite-setup-JRELX6K2.js");
+      const { promptViteSetup } = await import("./vite-setup-VO5BOI46.js");
       return await promptViteSetup(language);
     },
     createProject: async (options, currentDir, language) => {
-      const { createViteProject } = await import("./vite-installer-Y6VMFHIM.js");
+      const { createViteProject } = await import("./vite-installer-EE2LE76G.js");
       return await createViteProject(
         options,
         currentDir,
@@ -60,11 +65,11 @@ var frameworkRegistry = {
     defaultBundler: "nextjs",
     createCommand: "npm create next-app@latest",
     getSetupPrompt: async (language) => {
-      const { promptNextjsSetup } = await import("./nextjs-setup-DYOFF72S.js");
+      const { promptNextjsSetup } = await import("./nextjs-setup-JIKPIJCX.js");
       return await promptNextjsSetup(language);
     },
     createProject: async (options, currentDir, language) => {
-      const { createNextjsProject } = await import("./nextjs-installer-2ZC5IWJ6.js");
+      const { createNextjsProject } = await import("./nextjs-installer-OFY5BQC4.js");
       return await createNextjsProject(
         options,
         currentDir,
@@ -88,11 +93,11 @@ var frameworkRegistry = {
       ts: "vue-ts"
     },
     getSetupPrompt: async (language) => {
-      const { promptVueSetup } = await import("./vue-setup-G44DLT2U.js");
+      const { promptVueSetup } = await import("./vue-setup-FK5QT7AY.js");
       return await promptVueSetup(language);
     },
     createProject: async (options, currentDir, language) => {
-      const { createVueProject } = await import("./vue-installer-DGBBVF6F.js");
+      const { createVueProject } = await import("./vue-installer-LEGLVD77.js");
       return await createVueProject(
         options,
         currentDir,
@@ -112,11 +117,11 @@ var frameworkRegistry = {
     defaultBundler: "vite",
     createCommand: "npm create svelte@latest",
     getSetupPrompt: async (language) => {
-      const { promptSvelteSetup } = await import("./svelte-setup-FWXLXJAC.js");
+      const { promptSvelteSetup } = await import("./svelte-setup-33E46IBT.js");
       return await promptSvelteSetup(language);
     },
     createProject: async (options, currentDir, language) => {
-      const { createSvelteProject } = await import("./svelte-installer-EOSC3EP3.js");
+      const { createSvelteProject } = await import("./svelte-installer-UP3KDZSY.js");
       return await createSvelteProject(
         options,
         currentDir,
@@ -136,11 +141,11 @@ var frameworkRegistry = {
     defaultBundler: "webpack",
     createCommand: "npx @angular/cli@latest new",
     getSetupPrompt: async () => {
-      const { promptAngularSetup } = await import("./angular-setup-Z6TCKNBG.js");
+      const { promptAngularSetup } = await import("./angular-setup-QDTWXOB4.js");
       return await promptAngularSetup();
     },
     createProject: async (options, currentDir, language) => {
-      const { createAngularProject } = await import("./angular-installer-FY43HE72.js");
+      const { createAngularProject } = await import("./angular-installer-TKZDPFLD.js");
       return await createAngularProject(
         options,
         currentDir,
@@ -303,6 +308,669 @@ ${translations.confirmation.summary}
   return confirm;
 }
 
+// src/core/snapshot-manager.ts
+import { resolve } from "path";
+var SnapshotManager = class {
+  /**
+   * @param projectRoot - Racine du projet
+   * @param fsAdapter - Adaptateur filesystem optionnel (pour tests)
+   */
+  constructor(projectRoot, fsAdapter) {
+    this.projectRoot = projectRoot;
+    this.fsAdapter = fsAdapter;
+    this.startCleanupInterval();
+  }
+  logger = getModuleLogger();
+  /**
+   * Map des snapshots actifs: id -> snapshot
+   */
+  snapshots = /* @__PURE__ */ new Map();
+  /**
+   * Interval ID pour le cleanup des snapshots expirés
+   */
+  cleanupInterval;
+  /**
+   * TTL des snapshots en millisecondes (24 heures par défaut)
+   */
+  snapshotTTL = 24 * 60 * 60 * 1e3;
+  /**
+   * Crée un snapshot de l'état actuel du projet
+   *
+   * Sauvegarde les fichiers critiques:
+   * - package.json
+   * - package-lock.json
+   * - yarn.lock / pnpm-lock.yaml
+   * - .npmrc / .yarnrc
+   *
+   * @param description - Description optionnelle du snapshot
+   * @returns ID du snapshot créé
+   * @throws {Error} Si le snapshot échoue
+   *
+   * @example
+   * ```typescript
+   * const snapshotId = await snapshotManager.createSnapshot('Before React installation')
+   * console.log('Created snapshot:', snapshotId)
+   * ```
+   */
+  async createSnapshot(description) {
+    const snapshotId = this.generateSnapshotId();
+    const now = Date.now();
+    const files = /* @__PURE__ */ new Map();
+    this.logger.debug(`Creating snapshot ${snapshotId}`);
+    const criticalFiles = [
+      "package.json",
+      "package-lock.json",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      ".npmrc",
+      ".yarnrc",
+      ".yarnrc.yml",
+      "tsconfig.json",
+      ".eslintrc.json",
+      "vitest.config.ts"
+    ];
+    for (const filename of criticalFiles) {
+      const filePath = resolve(this.projectRoot, filename);
+      try {
+        if (await checkPathExists(filePath, this.fsAdapter)) {
+          const content = await readFileContent(
+            filePath,
+            "utf-8",
+            this.fsAdapter
+          );
+          files.set(filePath, content);
+          this.logger.debug(`Snapshotted ${filename}`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.debug(`Could not snapshot ${filename}: ${errorMessage}`);
+      }
+    }
+    const snapshot = {
+      id: snapshotId,
+      timestamp: now,
+      projectRoot: this.projectRoot,
+      files,
+      metadata: {
+        description,
+        createdAt: new Date(now).toISOString(),
+        expiresAt: new Date(now + this.snapshotTTL).toISOString()
+      }
+    };
+    this.snapshots.set(snapshotId, snapshot);
+    this.logger.info(
+      `Created snapshot ${snapshotId} with ${files.size} file(s)`
+    );
+    return snapshotId;
+  }
+  /**
+   * Restaure un projet depuis un snapshot
+   *
+   * Restore tous les fichiers sauvegardés dans le snapshot.
+   * Effectue une restauration atomique ou lance une erreur.
+   *
+   * @param snapshotId - ID du snapshot à restaurer
+   * @throws {Error} Si le snapshot n'existe pas ou si la restauration échoue
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await snapshotManager.restoreSnapshot(snapshotId)
+   *   console.log('Project restored successfully')
+   * } catch (error) {
+   *   console.error('Restore failed:', error)
+   * }
+   * ```
+   */
+  async restoreSnapshot(snapshotId) {
+    const snapshot = this.snapshots.get(snapshotId);
+    if (!snapshot) {
+      const availableIds = Array.from(this.snapshots.keys()).join(", ");
+      throw new Error(
+        `Snapshot not found: ${snapshotId}. Available: ${availableIds}`
+      );
+    }
+    this.logger.info(`Restoring snapshot ${snapshotId}`);
+    const errors = [];
+    for (const [filePath, content] of snapshot.files) {
+      try {
+        await writeFileContent(filePath, content, "utf-8", this.fsAdapter);
+        this.logger.debug(`Restored ${filePath}`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const restoreError = new Error(
+          `Failed to restore ${filePath}: ${errorMessage}`
+        );
+        errors.push({ file: filePath, error: restoreError });
+        this.logger.error(errorMessage);
+      }
+    }
+    if (errors.length > 0) {
+      const errorMessages = errors.map((e) => `${e.file}: ${e.error.message}`).join("; ");
+      throw new Error(
+        `Restore failed for ${errors.length}/${snapshot.files.size} file(s): ${errorMessages}`
+      );
+    }
+    this.logger.info(
+      `Successfully restored snapshot ${snapshotId} (${snapshot.files.size} file(s))`
+    );
+  }
+  /**
+   * Libère (supprime) un snapshot
+   *
+   * À appeler après une installation réussie pour nettoyer les snapshots.
+   * Les snapshots sont aussi nettoyés automatiquement après 24h.
+   *
+   * @param snapshotId - ID du snapshot à libérer
+   * @returns true si le snapshot a été libéré, false s'il n'existait pas
+   *
+   * @example
+   * ```typescript
+   * await snapshotManager.releaseSnapshot(snapshotId)
+   * console.log('Snapshot cleaned up')
+   * ```
+   */
+  releaseSnapshot(snapshotId) {
+    const removed = this.snapshots.delete(snapshotId);
+    if (removed) {
+      this.logger.info(`Released snapshot ${snapshotId}`);
+    } else {
+      this.logger.warn(`Snapshot ${snapshotId} not found for release`);
+    }
+    return removed;
+  }
+  /**
+   * Récupère les détails d'un snapshot
+   *
+   * @param snapshotId - ID du snapshot
+   * @returns Métadonnées du snapshot ou undefined
+   *
+   * @example
+   * ```typescript
+   * const info = snapshotManager.getSnapshotInfo(snapshotId)
+   * console.log('Created at:', info?.metadata.createdAt)
+   * ```
+   */
+  getSnapshotInfo(snapshotId) {
+    return this.snapshots.get(snapshotId);
+  }
+  /**
+   * Liste tous les snapshots actifs
+   *
+   * @returns Array de métadonnées des snapshots
+   *
+   * @example
+   * ```typescript
+   * const snapshots = snapshotManager.listSnapshots()
+   * snapshots.forEach(s => {
+   *   console.log(`${s.id}: ${s.metadata.description}`)
+   * })
+   * ```
+   */
+  listSnapshots() {
+    return Array.from(this.snapshots.values());
+  }
+  /**
+   * Vérifie si un snapshot existe
+   *
+   * @param snapshotId - ID du snapshot
+   * @returns true si le snapshot existe, false sinon
+   */
+  hasSnapshot(snapshotId) {
+    return this.snapshots.has(snapshotId);
+  }
+  /**
+   * Nettoie tous les snapshots expirés
+   *
+   * Appelé automatiquement toutes les heures.
+   * Peut aussi être appelé manuellement si nécessaire.
+   *
+   * @returns Nombre de snapshots nettoyés
+   *
+   * @example
+   * ```typescript
+   * const cleaned = snapshotManager.cleanupExpired()
+   * console.log(`Cleaned up ${cleaned} expired snapshot(s)`)
+   * ```
+   */
+  cleanupExpired() {
+    const now = Date.now();
+    const toDelete = [];
+    for (const [id, snapshot] of this.snapshots) {
+      if (now > snapshot.timestamp + this.snapshotTTL) {
+        toDelete.push(id);
+      }
+    }
+    for (const id of toDelete) {
+      this.releaseSnapshot(id);
+    }
+    if (toDelete.length > 0) {
+      this.logger.info(`Cleaned up ${toDelete.length} expired snapshot(s)`);
+    }
+    return toDelete.length;
+  }
+  /**
+   * Nettoie TOUS les snapshots (utile pour reset complet)
+   *
+   * @returns Nombre de snapshots nettoyés
+   *
+   * @example
+   * ```typescript
+   * const count = snapshotManager.clearAll()
+   * console.log(`Cleared ${count} snapshot(s)`)
+   * ```
+   */
+  clearAll() {
+    const count = this.snapshots.size;
+    this.snapshots.clear();
+    if (count > 0) {
+      this.logger.info(`Cleared all ${count} snapshot(s)`);
+    }
+    return count;
+  }
+  /**
+   * Arrête le cleanup interval (à appeler avant destruction)
+   *
+   * @example
+   * ```typescript
+   * snapshotManager.destroy()
+   * ```
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = void 0;
+    }
+    this.logger.debug("SnapshotManager destroyed");
+  }
+  /**
+   * Génère un ID unique pour snapshot
+   *
+   * @internal
+   */
+  generateSnapshotId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 11);
+    return `snapshot-${timestamp}-${random}`;
+  }
+  /**
+   * Démarre le nettoyage automatique des snapshots expirés
+   *
+   * @internal
+   */
+  startCleanupInterval() {
+    const interval = 60 * 60 * 1e3;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpired();
+    }, interval);
+    if (this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
+  }
+};
+
+// src/core/transaction-log.ts
+var TransactionLog = class {
+  /**
+   * @param projectRoot - Racine du projet
+   */
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  logger = getModuleLogger();
+  /**
+   * Map des transactions actives: txId -> metadata + entries
+   */
+  transactions = /* @__PURE__ */ new Map();
+  /**
+   * Transaction courante (pour logging convenience)
+   */
+  currentTxId;
+  /**
+   * Counter pour IDs d'entries
+   */
+  entryIdCounter = 0;
+  /**
+   * Démarre une nouvelle transaction
+   *
+   * @param plugins - Noms des plugins à installer
+   * @returns ID de la transaction
+   *
+   * @example
+   * ```typescript
+   * const txId = txLog.startTransaction(['react', 'redux'])
+   * ```
+   */
+  startTransaction(plugins) {
+    const txId = this.generateTransactionId();
+    const now = Date.now();
+    const metadata = {
+      id: txId,
+      startTime: now,
+      projectRoot: this.projectRoot,
+      plugins
+    };
+    this.transactions.set(txId, {
+      metadata,
+      entries: []
+    });
+    this.currentTxId = txId;
+    this.logger.debug(`Started transaction ${txId}`);
+    return txId;
+  }
+  /**
+   * Enregistre une action dans la transaction courante
+   *
+   * @param action - Type d'action
+   * @param message - Message descriptif
+   * @param data - Données optionnelles
+   * @throws {Error} Si aucune transaction active
+   *
+   * @example
+   * ```typescript
+   * txLog.log(
+   *   TransactionActionType.PACKAGE_INSTALL_START,
+   *   'Installing react',
+   *   { package: 'react', version: '18.0.0' }
+   * )
+   * ```
+   */
+  log(action, message, data) {
+    if (!this.currentTxId) {
+      throw new Error("No active transaction");
+    }
+    const tx = this.transactions.get(this.currentTxId);
+    if (!tx) {
+      throw new Error(`Transaction ${this.currentTxId} not found`);
+    }
+    const entry = {
+      id: this.generateEntryId(),
+      timestamp: Date.now(),
+      action,
+      message,
+      data
+    };
+    tx.entries.push(entry);
+  }
+  /**
+   * Enregistre une erreur dans la transaction courante
+   *
+   * @param message - Message d'erreur
+   * @param error - L'erreur originale
+   * @param data - Données optionnelles
+   * @throws {Error} Si aucune transaction active
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   // ... perform action ...
+   * } catch (error) {
+   *   txLog.logError('Package install failed', error)
+   * }
+   * ```
+   */
+  logError(message, error, data) {
+    if (!this.currentTxId) {
+      throw new Error("No active transaction");
+    }
+    const tx = this.transactions.get(this.currentTxId);
+    if (!tx) {
+      throw new Error(`Transaction ${this.currentTxId} not found`);
+    }
+    const entry = {
+      id: this.generateEntryId(),
+      timestamp: Date.now(),
+      action: "ERROR" /* ERROR */,
+      message,
+      data,
+      error: {
+        message: error.message,
+        stack: error.stack,
+        code: error.code
+      }
+    };
+    tx.entries.push(entry);
+  }
+  /**
+   * Enregistre un warning dans la transaction courante
+   *
+   * @param message - Message de warning
+   * @param data - Données optionnelles
+   * @throws {Error} Si aucune transaction active
+   *
+   * @example
+   * ```typescript
+   * txLog.logWarning('Plugin deprecation notice', {
+   *   plugin: 'old-plugin',
+   *   replacement: 'new-plugin'
+   * })
+   * ```
+   */
+  logWarning(message, data) {
+    if (!this.currentTxId) {
+      throw new Error("No active transaction");
+    }
+    const tx = this.transactions.get(this.currentTxId);
+    if (!tx) {
+      throw new Error(`Transaction ${this.currentTxId} not found`);
+    }
+    const entry = {
+      id: this.generateEntryId(),
+      timestamp: Date.now(),
+      action: "WARNING" /* WARNING */,
+      message,
+      data
+    };
+    tx.entries.push(entry);
+  }
+  /**
+   * Enregistre une action avec timing (pour debugging performance)
+   *
+   * Utile pour mesurer la durée d'opérations comme install, validate, config.
+   *
+   * @param action - Type d'action
+   * @param message - Message descriptif
+   * @param durationMs - Durée en millisecondes
+   * @param data - Données optionnelles
+   * @throws {Error} Si aucune transaction active
+   *
+   * @example
+   * ```typescript
+   * const start = Date.now()
+   * // ... perform action ...
+   * txLog.logTimed(
+   *   TransactionActionType.PACKAGE_INSTALL_COMPLETE,
+   *   'React installed',
+   *   Date.now() - start,
+   *   { packages: 1 }
+   * )
+   * ```
+   */
+  logTimed(action, message, durationMs, data) {
+    if (!this.currentTxId) {
+      throw new Error("No active transaction");
+    }
+    const tx = this.transactions.get(this.currentTxId);
+    if (!tx) {
+      throw new Error(`Transaction ${this.currentTxId} not found`);
+    }
+    const entry = {
+      id: this.generateEntryId(),
+      timestamp: Date.now(),
+      action,
+      message,
+      data,
+      duration: durationMs
+    };
+    tx.entries.push(entry);
+  }
+  /**
+   * Termine la transaction courante
+   *
+   * @param success - Succès de la transaction
+   * @param snapshotId - ID du snapshot associé (optionnel)
+   * @throws {Error} Si aucune transaction active
+   *
+   * @example
+   * ```typescript
+   * txLog.endTransaction(true, snapshotId)
+   * ```
+   */
+  endTransaction(success, snapshotId) {
+    if (!this.currentTxId) {
+      throw new Error("No active transaction");
+    }
+    const tx = this.transactions.get(this.currentTxId);
+    if (!tx) {
+      throw new Error(`Transaction ${this.currentTxId} not found`);
+    }
+    tx.metadata.endTime = Date.now();
+    tx.metadata.success = success;
+    tx.metadata.snapshotId = snapshotId;
+    const duration = (tx.metadata.endTime - tx.metadata.startTime) / 1e3;
+    this.logger.info(
+      `Transaction ${this.currentTxId} ${success ? "succeeded" : "failed"} in ${duration.toFixed(2)}s`
+    );
+    this.currentTxId = void 0;
+  }
+  /**
+   * Récupère le rapport complet d'une transaction
+   *
+   * @param txId - ID de la transaction
+   * @returns Rapport avec métadonnées et entries, ou undefined
+   *
+   * @example
+   * ```typescript
+   * const report = txLog.getReport(txId)
+   * console.log(`Transaction took ${report?.duration}ms`)
+   * console.log(`Total errors: ${report?.errorCount}`)
+   * ```
+   */
+  getReport(txId) {
+    const tx = this.transactions.get(txId);
+    if (!tx) {
+      return void 0;
+    }
+    const duration = (tx.metadata.endTime ?? Date.now()) - tx.metadata.startTime;
+    const errorCount = tx.entries.filter(
+      (e) => e.action === "ERROR" /* ERROR */
+    ).length;
+    const warningCount = tx.entries.filter(
+      (e) => e.action === "WARNING" /* WARNING */
+    ).length;
+    return {
+      metadata: tx.metadata,
+      entries: tx.entries,
+      duration,
+      errorCount,
+      warningCount
+    };
+  }
+  /**
+   * Récupère les entries d'une transaction
+   *
+   * @param txId - ID de la transaction
+   * @returns Array d'entries, ou undefined si transaction pas trouvée
+   *
+   * @example
+   * ```typescript
+   * const entries = txLog.getEntries(txId)
+   * entries?.forEach(e => console.log(`[${e.action}] ${e.message}`))
+   * ```
+   */
+  getEntries(txId) {
+    const tx = this.transactions.get(txId);
+    return tx?.entries;
+  }
+  /**
+   * Formate le rapport pour affichage/debugging
+   *
+   * @param txId - ID de la transaction
+   * @returns String formaté du rapport
+   *
+   * @example
+   * ```typescript
+   * console.log(txLog.formatReport(txId))
+   * ```
+   */
+  formatReport(txId) {
+    const report = this.getReport(txId);
+    if (!report) {
+      return `Transaction ${txId} not found`;
+    }
+    const lines = [];
+    lines.push(`=== Transaction Report: ${txId} ===`);
+    lines.push(`Status: ${report.metadata.success ? "SUCCESS" : "FAILED"}`);
+    lines.push(`Duration: ${(report.duration / 1e3).toFixed(2)}s`);
+    lines.push(`Plugins: ${report.metadata.plugins.join(", ")}`);
+    lines.push(`Errors: ${report.errorCount}, Warnings: ${report.warningCount}`);
+    lines.push("");
+    lines.push("Timeline:");
+    for (const entry of report.entries) {
+      const time = new Date(entry.timestamp).toLocaleTimeString();
+      const duration = entry.duration ? ` (${entry.duration}ms)` : "";
+      lines.push(`  [${time}] ${entry.action}${duration}: ${entry.message}`);
+      if (entry.error) {
+        lines.push(`    Error: ${entry.error.message}`);
+        if (entry.error.code) {
+          lines.push(`    Code: ${entry.error.code}`);
+        }
+      }
+      if (entry.data) {
+        lines.push(`    Data: ${JSON.stringify(entry.data)}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Supprime une transaction du log
+   *
+   * @param txId - ID de la transaction
+   * @returns true si la transaction a été supprimée, false sinon
+   *
+   * @example
+   * ```typescript
+   * txLog.removeTransaction(txId)
+   * ```
+   */
+  removeTransaction(txId) {
+    if (this.currentTxId === txId) {
+      this.currentTxId = void 0;
+    }
+    return this.transactions.delete(txId);
+  }
+  /**
+   * Nettoie tous les logs des transactions
+   *
+   * @example
+   * ```typescript
+   * txLog.clear()
+   * ```
+   */
+  clear() {
+    this.transactions.clear();
+    this.currentTxId = void 0;
+  }
+  /**
+   * Génère un ID unique pour transaction
+   *
+   * @internal
+   */
+  generateTransactionId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 11);
+    return `tx-${timestamp}-${random}`;
+  }
+  /**
+   * Génère un ID unique pour entry
+   *
+   * @internal
+   */
+  generateEntryId() {
+    return `entry-${++this.entryIdCounter}`;
+  }
+};
+
 // src/core/installer.ts
 var Installer = class {
   /**
@@ -316,8 +984,12 @@ var Installer = class {
     this.validator = validator;
     this.backupManager = backupManager;
     this.tracker = new PluginTracker(ctx.projectRoot, ctx.fsAdapter);
+    this.snapshotManager = new SnapshotManager(ctx.projectRoot, ctx.fsAdapter);
+    this.transactionLog = new TransactionLog(ctx.projectRoot);
   }
   tracker;
+  snapshotManager;
+  transactionLog;
   logger = getModuleLogger();
   /**
    * Installe un ensemble de plugins
@@ -336,7 +1008,16 @@ var Installer = class {
   async install(plugins, options) {
     const startTime = Date.now();
     this.logger.info(`Starting installation of ${plugins.length} plugin(s)`);
+    const txId = this.transactionLog.startTransaction(
+      plugins.map((p) => p.name)
+    );
+    let snapshotId;
     try {
+      this.logger.debug("PHASE 1: Validation (no modifications)");
+      this.transactionLog.log(
+        "VALIDATION_START" /* VALIDATION_START */,
+        "Starting validation phase"
+      );
       await this.tracker.load();
       const notInstalledPromises = plugins.map(async (p) => {
         const isTracked = this.tracker.isInstalled(p.name);
@@ -375,6 +1056,7 @@ var Installer = class {
       );
       if (notInstalled.length === 0) {
         this.logger.info("All plugins are already installed");
+        this.transactionLog.endTransaction(true);
         return {
           success: true,
           duration: Date.now() - startTime,
@@ -405,8 +1087,19 @@ var Installer = class {
           `Found ${validationResult.warnings.length} warning(s):`,
           validationResult.warnings.map((w) => w.message)
         );
+        for (const warning of validationResult.warnings) {
+          this.transactionLog.logWarning(warning.message);
+        }
       }
+      this.transactionLog.log(
+        "VALIDATION_COMPLETE" /* VALIDATION_COMPLETE */,
+        `Validation passed for ${notInstalled.length} plugin(s)`
+      );
       this.logger.debug("Resolving dependencies...");
+      this.transactionLog.log(
+        "DEPENDENCY_RESOLUTION" /* DEPENDENCY_RESOLUTION */,
+        "Resolving plugin dependencies"
+      );
       const resolved = this.resolveDependencies(notInstalled);
       const allPlugins = resolved.plugins;
       if (resolved.autoInstalled.length > 0) {
@@ -414,13 +1107,31 @@ var Installer = class {
           `Auto-installing ${resolved.autoInstalled.length} required dependency(ies): ${resolved.autoInstalled.join(", ")}`
         );
       }
+      this.logger.debug("PHASE 2: Creating backup and snapshot");
+      snapshotId = await this.snapshotManager.createSnapshot(
+        `Before installing ${allPlugins.map((p) => p.displayName).join(", ")}`
+      );
+      this.transactionLog.log(
+        "SNAPSHOT_CREATED" /* SNAPSHOT_CREATED */,
+        `Snapshot created for rollback protection`,
+        { snapshotId }
+      );
       this.logger.debug("Running pre-install hooks...");
+      this.transactionLog.log(
+        "PRE_INSTALL_HOOK" /* PRE_INSTALL_HOOK */,
+        "Running pre-install hooks"
+      );
       await this.runPreInstallHooks(allPlugins);
+      this.logger.debug("PHASE 3: Installation");
       let installResults = [];
       if (options?.skipPackageInstall) {
         this.logger.info("Skipping package installation (--no-install mode)");
       } else {
         this.logger.debug("Installing packages...");
+        this.transactionLog.log(
+          "PACKAGE_INSTALL_START" /* PACKAGE_INSTALL_START */,
+          "Starting package installation"
+        );
         installResults = await this.installPackages(allPlugins);
         const failedInstalls = installResults.filter((r) => !r.success);
         if (failedInstalls.length > 0) {
@@ -428,6 +1139,10 @@ var Installer = class {
             `Failed to install packages for ${failedInstalls.length} plugin(s)`
           );
         }
+        this.transactionLog.log(
+          "PACKAGE_INSTALL_COMPLETE" /* PACKAGE_INSTALL_COMPLETE */,
+          `Successfully installed packages for ${allPlugins.length} plugin(s)`
+        );
       }
       this.logger.debug("Configuring plugins...");
       const configResults = [];
@@ -435,6 +1150,11 @@ var Installer = class {
       for (const plugin of allPlugins) {
         try {
           this.logger.debug(`Configuring ${plugin.displayName}...`);
+          this.transactionLog.log(
+            "PLUGIN_CONFIGURE_START" /* PLUGIN_CONFIGURE_START */,
+            `Starting configuration for ${plugin.displayName}`,
+            { plugin: plugin.name }
+          );
           const configResult = await plugin.configure(this.ctx);
           configResults.push(configResult);
           filesCreated.push(...configResult.files || []);
@@ -443,16 +1163,38 @@ var Installer = class {
               `Configuration failed for ${plugin.displayName}: ${configResult.message || "Unknown error"}`
             );
           }
+          this.transactionLog.log(
+            "PLUGIN_CONFIGURE_COMPLETE" /* PLUGIN_CONFIGURE_COMPLETE */,
+            `Configuration complete for ${plugin.displayName}`,
+            {
+              plugin: plugin.name,
+              filesCreated: configResult.files?.length ?? 0
+            }
+          );
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           this.logger.error(
             `Configuration failed for ${plugin.displayName}: ${errorMessage}`
           );
+          this.transactionLog.logError(
+            `Configuration failed for ${plugin.displayName}`,
+            error instanceof Error ? error : new Error(errorMessage),
+            { plugin: plugin.name }
+          );
           throw error;
         }
       }
       this.logger.debug("Running post-install hooks...");
+      this.transactionLog.log(
+        "POST_INSTALL_HOOK" /* POST_INSTALL_HOOK */,
+        "Running post-install hooks"
+      );
       await this.runPostInstallHooks(allPlugins);
+      this.logger.debug("PHASE 4: Cleanup on success");
+      this.transactionLog.log(
+        "CLEANUP_START" /* CLEANUP_START */,
+        "Starting cleanup"
+      );
       this.logger.debug("Tracking installed plugins...");
       const installResultsByName = /* @__PURE__ */ new Map();
       for (let i = 0; i < allPlugins.length; i++) {
@@ -475,11 +1217,19 @@ var Installer = class {
           }
         });
       }
+      if (snapshotId) {
+        this.snapshotManager.releaseSnapshot(snapshotId);
+      }
+      this.transactionLog.log(
+        "CLEANUP_COMPLETE" /* CLEANUP_COMPLETE */,
+        "Cleanup complete"
+      );
       const duration = Date.now() - startTime;
       const installed = allPlugins.map((p) => p.name);
       this.logger.info(
         `Successfully installed ${installed.length} plugin(s) in ${duration}ms`
       );
+      this.transactionLog.endTransaction(true, snapshotId);
       return {
         success: true,
         duration,
@@ -490,14 +1240,41 @@ var Installer = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.logger.error(`Installation failed: ${errorMessage}`);
-      this.logger.debug("Rolling back changes...");
+      this.transactionLog.logError(
+        "Installation failed",
+        error instanceof Error ? error : new Error(errorMessage)
+      );
+      this.logger.debug("ROLLBACK: Starting rollback procedure");
+      this.transactionLog.log(
+        "ROLLBACK_START" /* ROLLBACK_START */,
+        "Starting rollback"
+      );
       try {
+        if (snapshotId && this.snapshotManager.hasSnapshot(snapshotId)) {
+          this.logger.debug(
+            `Restoring snapshot ${snapshotId} to previous state`
+          );
+          await this.snapshotManager.restoreSnapshot(snapshotId);
+          this.logger.info("Snapshot restored successfully");
+        }
         await this.rollback(plugins);
+        this.transactionLog.log(
+          "ROLLBACK_COMPLETE" /* ROLLBACK_COMPLETE */,
+          "Rollback complete - snapshot retained for debugging"
+        );
       } catch (rollbackError) {
         const rollbackMessage = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
         this.logger.error(`Rollback failed: ${rollbackMessage}`);
+        this.transactionLog.logError(
+          "Rollback procedure failed",
+          rollbackError instanceof Error ? rollbackError : new Error(rollbackMessage)
+        );
       }
       const duration = Date.now() - startTime;
+      this.transactionLog.endTransaction(false, snapshotId);
+      const txReport = this.transactionLog.formatReport(txId);
+      this.logger.debug(`Transaction report:
+${txReport}`);
       return {
         success: false,
         duration,
@@ -505,6 +1282,8 @@ var Installer = class {
         warnings: [],
         filesCreated: []
       };
+    } finally {
+      this.snapshotManager.destroy();
     }
   }
   /**
@@ -654,7 +1433,7 @@ var Installer = class {
 };
 
 // src/cli/ui/report.ts
-import pc from "picocolors";
+import pc from "chalk";
 function displayInstallationReport(report, plugins, lang) {
   const t = getTranslations(lang);
   console.log();
@@ -719,7 +1498,7 @@ function displayNextSteps(lang) {
 }
 
 // src/cli/ui/logo.ts
-import pc2 from "picocolors";
+import pc2 from "chalk";
 function LOGO() {
   return [
     "   \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
@@ -735,7 +1514,7 @@ function displayLogo() {
 }
 
 // src/cli/commands/base-framework-command.ts
-import pc3 from "picocolors";
+import pc3 from "chalk";
 var BaseFrameworkCommand = class {
   /**
    * Affiche les informations spécifiques du contexte détecté