@configjs/cli 1.0.0

package/dist/install-X7G2IXXX.js

@@ -0,0 +1,1127 @@
+import {
+  CompatibilityValidator,
+  compatibilityRules
+} from "./chunk-PQLKGF6I.js";
+import {
+  BackupManager,
+  ConfigWriter,
+  checkPathExists,
+  detectPackageManager,
+  getPluginsByCategory,
+  installPackages,
+  logger,
+  pluginRegistry,
+  readPackageJson,
+  readTsConfig
+} from "./chunk-5T664O5A.js";
+
+// src/core/detector.ts
+import { resolve, join } from "path";
+import { platform, version } from "process";
+var detectionCache = /* @__PURE__ */ new Map();
+var DetectionError = class extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "DetectionError";
+  }
+};
+function detectFramework(pkg) {
+  const deps = {
+    ...pkg["dependencies"] || {},
+    ...pkg["devDependencies"] || {}
+  };
+  if (deps["react"]) {
+    return {
+      framework: "react",
+      version: deps["react"].replace(/[\^~]/, "")
+    };
+  }
+  if (deps["vue"]) {
+    return {
+      framework: "vue",
+      version: deps["vue"].replace(/[\^~]/, "")
+    };
+  }
+  if (deps["svelte"]) {
+    return {
+      framework: "svelte",
+      version: deps["svelte"].replace(/[\^~]/, "")
+    };
+  }
+  throw new DetectionError(
+    "No supported framework detected. Supported frameworks: React, Vue, Svelte",
+    { dependencies: Object.keys(deps) }
+  );
+}
+async function detectBundler(projectRoot, pkg) {
+  const deps = {
+    ...pkg["dependencies"] || {},
+    ...pkg["devDependencies"] || {}
+  };
+  if (deps["vite"]) {
+    const viteConfigExists = await checkPathExists(join(projectRoot, "vite.config.js")) || await checkPathExists(join(projectRoot, "vite.config.ts")) || await checkPathExists(join(projectRoot, "vite.config.mjs")) || await checkPathExists(join(projectRoot, "vite.config.cjs"));
+    if (viteConfigExists) {
+      return {
+        bundler: "vite",
+        version: deps["vite"].replace(/[\^~]/, "")
+      };
+    }
+  }
+  if (deps["react-scripts"]) {
+    return {
+      bundler: "cra",
+      version: deps["react-scripts"].replace(/[\^~]/, "")
+    };
+  }
+  if (deps["webpack"]) {
+    const webpackConfigExists = await checkPathExists(join(projectRoot, "webpack.config.js")) || await checkPathExists(join(projectRoot, "webpack.config.ts"));
+    if (webpackConfigExists) {
+      return {
+        bundler: "webpack",
+        version: deps["webpack"].replace(/[\^~]/, "")
+      };
+    }
+  }
+  if (deps["@rspack/core"]) {
+    return {
+      bundler: "rspack",
+      version: deps["@rspack/core"].replace(/[\^~]/, "")
+    };
+  }
+  return {
+    bundler: null,
+    version: null
+  };
+}
+async function detectTypeScript(projectRoot) {
+  const tsConfig = await readTsConfig(projectRoot);
+  if (tsConfig) {
+    const possiblePaths = [
+      join(projectRoot, "tsconfig.json"),
+      join(projectRoot, "tsconfig.app.json"),
+      join(projectRoot, "tsconfig.node.json")
+    ];
+    for (const path of possiblePaths) {
+      if (await checkPathExists(path)) {
+        return {
+          typescript: true,
+          tsconfigPath: path
+        };
+      }
+    }
+    return {
+      typescript: true,
+      tsconfigPath: join(projectRoot, "tsconfig.json")
+    };
+  }
+  return {
+    typescript: false
+  };
+}
+async function detectSrcDir(projectRoot) {
+  const possibleDirs = ["src", "app", "source", "lib"];
+  for (const dir of possibleDirs) {
+    const dirPath = join(projectRoot, dir);
+    if (await checkPathExists(dirPath)) {
+      return dir;
+    }
+  }
+  return "src";
+}
+async function detectPublicDir(projectRoot) {
+  const possibleDirs = ["public", "static", "assets"];
+  for (const dir of possibleDirs) {
+    const dirPath = join(projectRoot, dir);
+    if (await checkPathExists(dirPath)) {
+      return dir;
+    }
+  }
+  return "public";
+}
+async function detectGit(projectRoot) {
+  const gitDir = join(projectRoot, ".git");
+  const hasGit = await checkPathExists(gitDir);
+  if (!hasGit) {
+    return { hasGit: false };
+  }
+  const hooksPath = join(gitDir, "hooks");
+  const hasHooks = await checkPathExists(hooksPath);
+  return {
+    hasGit: true,
+    gitHooksPath: hasHooks ? hooksPath : void 0
+  };
+}
+async function detectLockfile(projectRoot, packageManager) {
+  const lockfiles = {
+    npm: "package-lock.json",
+    yarn: "yarn.lock",
+    pnpm: "pnpm-lock.yaml",
+    bun: "bun.lockb"
+  };
+  const lockfile = lockfiles[packageManager];
+  const lockfilePath = join(projectRoot, lockfile);
+  if (await checkPathExists(lockfilePath)) {
+    return lockfile;
+  }
+  return lockfile;
+}
+async function detectContext(projectRoot) {
+  const fullPath = resolve(projectRoot);
+  if (detectionCache.has(fullPath)) {
+    logger.debug(`Using cached context for ${fullPath}`);
+    const cached = detectionCache.get(fullPath);
+    if (cached) {
+      return cached;
+    }
+  }
+  logger.debug(`Detecting context for project: ${fullPath}`);
+  let pkg;
+  try {
+    pkg = await readPackageJson(fullPath);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new DetectionError(
+      `Invalid project: package.json not found or invalid. ${errorMessage}`,
+      { projectRoot: fullPath }
+    );
+  }
+  const [
+    frameworkInfo,
+    typescriptInfo,
+    bundlerInfo,
+    packageManager,
+    srcDir,
+    publicDir,
+    gitInfo
+  ] = await Promise.all([
+    Promise.resolve(detectFramework(pkg)),
+    detectTypeScript(fullPath),
+    detectBundler(fullPath, pkg),
+    detectPackageManager(fullPath),
+    detectSrcDir(fullPath),
+    detectPublicDir(fullPath),
+    detectGit(fullPath)
+  ]);
+  const lockfile = await detectLockfile(fullPath, packageManager);
+  const dependencies = pkg["dependencies"] || {};
+  const devDependencies = pkg["devDependencies"] || {};
+  const context = {
+    // Framework
+    framework: frameworkInfo.framework,
+    frameworkVersion: frameworkInfo.version,
+    // Bundler
+    bundler: bundlerInfo.bundler,
+    bundlerVersion: bundlerInfo.version,
+    // Language
+    typescript: typescriptInfo.typescript,
+    tsconfigPath: typescriptInfo.tsconfigPath,
+    // Package Manager
+    packageManager,
+    lockfile,
+    // Structure
+    projectRoot: fullPath,
+    srcDir,
+    publicDir,
+    // Environment
+    os: platform,
+    nodeVersion: version,
+    // Dependencies
+    dependencies,
+    devDependencies,
+    // Git
+    hasGit: gitInfo.hasGit,
+    gitHooksPath: gitInfo.gitHooksPath
+  };
+  detectionCache.set(fullPath, context);
+  logger.debug(`Context detected successfully for ${fullPath}`, {
+    framework: context.framework,
+    bundler: context.bundler,
+    typescript: context.typescript
+  });
+  return context;
+}
+
+// src/cli/prompts/language.ts
+import inquirer from "inquirer";
+
+// src/cli/i18n/fr.ts
+var fr = {
+  language: {
+    select: "Choisissez votre langue",
+    options: [
+      { value: "fr", name: "Fran\xE7ais" },
+      { value: "en", name: "English" },
+      { value: "es", name: "Espa\xF1ol" }
+    ]
+  },
+  common: {
+    continue: "Continuer",
+    cancel: "Annuler",
+    back: "Retour",
+    none: "Aucun",
+    selected: (count) => count === 0 ? "Aucune biblioth\xE8que s\xE9lectionn\xE9e" : count === 1 ? "1 biblioth\xE8que s\xE9lectionn\xE9e" : `${count} biblioth\xE8ques s\xE9lectionn\xE9es`
+  },
+  plugins: {
+    selectCategory: (category) => `S\xE9lectionnez vos biblioth\xE8ques : ${category}`,
+    selectMultiple: "S\xE9lection multiple",
+    pressSpace: "Appuyez sur <espace> pour s\xE9lectionner",
+    pressEnter: "Appuyez sur <entr\xE9e> pour valider",
+    description: "Description"
+  },
+  detection: {
+    detecting: "\u{1F50D} D\xE9tection du contexte...",
+    framework: "Framework",
+    typescript: "TypeScript",
+    bundler: "Bundler",
+    packageManager: "Gestionnaire de paquets"
+  },
+  confirmation: {
+    summary: "\u{1F4CB} R\xE9sum\xE9 de l'installation",
+    packagesToInstall: "\u{1F4E6} Packages \xE0 installer",
+    filesToCreate: "\u{1F4DD} Fichiers qui seront cr\xE9\xE9s",
+    filesToModify: "\u{1F4DD} Fichiers qui seront modifi\xE9s",
+    continueQuestion: "Continuer avec l'installation ?"
+  },
+  installation: {
+    installing: "Installation en cours...",
+    configuring: "Configuration en cours...",
+    success: "\u2728 Installation termin\xE9e !",
+    error: "\u274C Erreur lors de l'installation",
+    rollback: "\u21BA Rollback en cours..."
+  },
+  report: {
+    title: "\u2728 Installation termin\xE9e !",
+    packagesInstalled: "\u{1F4E6} Packages install\xE9s",
+    filesCreated: "\u{1F4DD} Fichiers cr\xE9\xE9s",
+    filesModified: "\u{1F4DD} Fichiers modifi\xE9s",
+    nextSteps: "\u{1F680} Prochaines \xE9tapes"
+  },
+  errors: {
+    detectionFailed: "\xC9chec de la d\xE9tection du contexte",
+    installationFailed: "\xC9chec de l'installation",
+    validationFailed: "\xC9chec de la validation",
+    incompatiblePlugins: (plugins) => `Plugins incompatibles d\xE9tect\xE9s : ${plugins.join(", ")}`
+  }
+};
+
+// src/cli/i18n/en.ts
+var en = {
+  language: {
+    select: "Choose your language",
+    options: [
+      { value: "fr", name: "Fran\xE7ais" },
+      { value: "en", name: "English" },
+      { value: "es", name: "Espa\xF1ol" }
+    ]
+  },
+  common: {
+    continue: "Continue",
+    cancel: "Cancel",
+    back: "Back",
+    none: "None",
+    selected: (count) => count === 0 ? "No library selected" : count === 1 ? "1 library selected" : `${count} libraries selected`
+  },
+  plugins: {
+    selectCategory: (category) => `Select your libraries: ${category}`,
+    selectMultiple: "Multiple selection",
+    pressSpace: "Press <space> to select",
+    pressEnter: "Press <enter> to confirm",
+    description: "Description"
+  },
+  detection: {
+    detecting: "\u{1F50D} Detecting context...",
+    framework: "Framework",
+    typescript: "TypeScript",
+    bundler: "Bundler",
+    packageManager: "Package manager"
+  },
+  confirmation: {
+    summary: "\u{1F4CB} Installation Summary",
+    packagesToInstall: "\u{1F4E6} Packages to install",
+    filesToCreate: "\u{1F4DD} Files that will be created",
+    filesToModify: "\u{1F4DD} Files that will be modified",
+    continueQuestion: "Continue with installation?"
+  },
+  installation: {
+    installing: "Installing...",
+    configuring: "Configuring...",
+    success: "\u2728 Installation completed!",
+    error: "\u274C Installation error",
+    rollback: "\u21BA Rolling back..."
+  },
+  report: {
+    title: "\u2728 Installation completed!",
+    packagesInstalled: "\u{1F4E6} Installed packages",
+    filesCreated: "\u{1F4DD} Created files",
+    filesModified: "\u{1F4DD} Modified files",
+    nextSteps: "\u{1F680} Next steps"
+  },
+  errors: {
+    detectionFailed: "Context detection failed",
+    installationFailed: "Installation failed",
+    validationFailed: "Validation failed",
+    incompatiblePlugins: (plugins) => `Incompatible plugins detected: ${plugins.join(", ")}`
+  }
+};
+
+// src/cli/i18n/es.ts
+var es = {
+  language: {
+    select: "Elige tu idioma",
+    options: [
+      { value: "fr", name: "Fran\xE7ais" },
+      { value: "en", name: "English" },
+      { value: "es", name: "Espa\xF1ol" }
+    ]
+  },
+  common: {
+    continue: "Continuar",
+    cancel: "Cancelar",
+    back: "Volver",
+    none: "Ninguno",
+    selected: (count) => count === 0 ? "Ninguna biblioteca seleccionada" : count === 1 ? "1 biblioteca seleccionada" : `${count} bibliotecas seleccionadas`
+  },
+  plugins: {
+    selectCategory: (category) => `Selecciona tus bibliotecas: ${category}`,
+    selectMultiple: "Selecci\xF3n m\xFAltiple",
+    pressSpace: "Presiona <espacio> para seleccionar",
+    pressEnter: "Presiona <entrar> para confirmar",
+    description: "Descripci\xF3n"
+  },
+  detection: {
+    detecting: "\u{1F50D} Detectando contexto...",
+    framework: "Framework",
+    typescript: "TypeScript",
+    bundler: "Bundler",
+    packageManager: "Gestor de paquetes"
+  },
+  confirmation: {
+    summary: "\u{1F4CB} Resumen de la instalaci\xF3n",
+    packagesToInstall: "\u{1F4E6} Paquetes a instalar",
+    filesToCreate: "\u{1F4DD} Archivos que se crear\xE1n",
+    filesToModify: "\u{1F4DD} Archivos que se modificar\xE1n",
+    continueQuestion: "\xBFContinuar con la instalaci\xF3n?"
+  },
+  installation: {
+    installing: "Instalando...",
+    configuring: "Configurando...",
+    success: "\u2728 \xA1Instalaci\xF3n completada!",
+    error: "\u274C Error en la instalaci\xF3n",
+    rollback: "\u21BA Revirtiendo..."
+  },
+  report: {
+    title: "\u2728 \xA1Instalaci\xF3n completada!",
+    packagesInstalled: "\u{1F4E6} Paquetes instalados",
+    filesCreated: "\u{1F4DD} Archivos creados",
+    filesModified: "\u{1F4DD} Archivos modificados",
+    nextSteps: "\u{1F680} Pr\xF3ximos pasos"
+  },
+  errors: {
+    detectionFailed: "Fallo en la detecci\xF3n del contexto",
+    installationFailed: "Fallo en la instalaci\xF3n",
+    validationFailed: "Fallo en la validaci\xF3n",
+    incompatiblePlugins: (plugins) => `Plugins incompatibles detectados: ${plugins.join(", ")}`
+  }
+};
+
+// src/cli/i18n/index.ts
+function getTranslations(lang) {
+  switch (lang) {
+    case "fr":
+      return fr;
+    case "en":
+      return en;
+    case "es":
+      return es;
+    default:
+      return en;
+  }
+}
+
+// src/cli/prompts/language.ts
+async function promptLanguage() {
+  const defaultTranslations = getTranslations("en");
+  const { language } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "language",
+      message: defaultTranslations.language.select,
+      choices: defaultTranslations.language.options.map((opt) => ({
+        name: opt.name,
+        value: opt.value
+      })),
+      default: "en"
+    }
+  ]);
+  return language;
+}
+
+// src/cli/prompts/select-plugins.ts
+import inquirer2 from "inquirer";
+function getCategoryName(category, _lang) {
+  const categoryMap = {
+    ["routing" /* ROUTING */]: "Routing",
+    ["state" /* STATE */]: "State Management",
+    ["http" /* HTTP */]: "HTTP Client",
+    ["css" /* CSS */]: "CSS / Styling",
+    ["ui" /* UI */]: "UI Components",
+    ["forms" /* FORMS */]: "Forms",
+    ["tooling" /* TOOLING */]: "Tooling",
+    ["testing" /* TESTING */]: "Testing",
+    ["i18n" /* I18N */]: "Internationalization",
+    ["animation" /* ANIMATION */]: "Animation",
+    ["utils" /* UTILS */]: "Utilities"
+  };
+  return categoryMap[category] || category;
+}
+function formatPluginChoice(plugin, _lang) {
+  return {
+    name: `${plugin.displayName}
+  ${plugin.description}`,
+    value: plugin.name,
+    short: plugin.displayName
+  };
+}
+async function promptPluginSelection(ctx, availablePlugins, lang) {
+  const translations = getTranslations(lang);
+  const selectedPlugins = [];
+  const pluginsByCategory = /* @__PURE__ */ new Map();
+  for (const plugin of availablePlugins) {
+    if (!plugin.frameworks.includes(ctx.framework)) {
+      continue;
+    }
+    if (plugin.requiresTypeScript === true && !ctx.typescript) {
+      continue;
+    }
+    if (plugin.bundlers && ctx.bundler && !plugin.bundlers.includes(ctx.bundler)) {
+      continue;
+    }
+    const category = plugin.category;
+    if (!pluginsByCategory.has(category)) {
+      pluginsByCategory.set(category, []);
+    }
+    const categoryPluginsList = pluginsByCategory.get(category);
+    if (categoryPluginsList !== void 0) {
+      categoryPluginsList.push(plugin);
+    }
+  }
+  const categories = Array.from(pluginsByCategory.keys()).sort();
+  for (const category of categories) {
+    const plugins = pluginsByCategory.get(category);
+    if (plugins === void 0 || plugins.length === 0) {
+      continue;
+    }
+    const categoryName = getCategoryName(category, lang);
+    const categoryPlugins = getPluginsByCategory(category).filter(
+      (p) => plugins.some((ap) => ap.name === p.name)
+    );
+    const choices = [
+      ...categoryPlugins.map((plugin) => formatPluginChoice(plugin, lang)),
+      new inquirer2.Separator(),
+      {
+        name: translations.common.none,
+        value: "__none__",
+        short: translations.common.none
+      }
+    ];
+    const { selected } = await inquirer2.prompt([
+      {
+        type: "checkbox",
+        name: "selected",
+        message: `${translations.plugins.selectCategory(categoryName)}
+${translations.plugins.pressSpace} | ${translations.plugins.pressEnter}`,
+        choices,
+        pageSize: 10,
+        loop: false
+      }
+    ]);
+    const pluginNames = selected.filter((name) => name !== "__none__");
+    for (const pluginName of pluginNames) {
+      const plugin = categoryPlugins.find((p) => p.name === pluginName);
+      if (plugin !== void 0) {
+        selectedPlugins.push(plugin);
+      }
+    }
+  }
+  return selectedPlugins;
+}
+
+// src/cli/prompts/confirm.ts
+import inquirer3 from "inquirer";
+async function promptConfirmation(selectedPlugins, lang) {
+  const translations = getTranslations(lang);
+  console.log(`
+${translations.confirmation.summary}
+`);
+  console.log(`${translations.confirmation.packagesToInstall}:`);
+  for (const plugin of selectedPlugins) {
+    console.log(
+      `   \u2022 ${plugin.displayName}${plugin.version ? ` (${plugin.version})` : ""}`
+    );
+  }
+  const { confirm } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: translations.confirmation.continueQuestion,
+      default: true
+    }
+  ]);
+  return confirm;
+}
+
+// src/core/installer.ts
+var Installer = class {
+  /**
+   * @param ctx - Contexte du projet détecté
+   * @param validator - Validateur de compatibilité
+   * @param writer - Writer de configuration
+   * @param backupManager - Gestionnaire de backups
+   */
+  constructor(ctx, validator, writer, backupManager) {
+    this.ctx = ctx;
+    this.validator = validator;
+    this.writer = writer;
+    this.backupManager = backupManager;
+  }
+  /**
+   * Installe un ensemble de plugins
+   *
+   * @param plugins - Liste des plugins à installer
+   * @param options - Options d'installation (skipPackageInstall pour --no-install)
+   * @returns Rapport d'installation avec détails
+   * @throws {Error} Si l'installation échoue (après rollback)
+   *
+   * @example
+   * ```typescript
+   * const report = await installer.install([plugin1, plugin2])
+   * console.log(`Installed ${report.installed.length} plugin(s)`)
+   * ```
+   */
+  async install(plugins, options) {
+    const startTime = Date.now();
+    logger.info(`Starting installation of ${plugins.length} plugin(s)`);
+    try {
+      logger.debug("Validating plugins compatibility...");
+      const validationResult = this.validator.validate(plugins);
+      if (!validationResult.valid) {
+        const errorMessages = validationResult.errors.map((e) => e.message).join("; ");
+        throw new Error(
+          `Validation failed: ${errorMessages}. Please fix compatibility issues before installing.`
+        );
+      }
+      if (validationResult.warnings.length > 0) {
+        logger.warn(
+          `Found ${validationResult.warnings.length} warning(s):`,
+          validationResult.warnings.map((w) => w.message)
+        );
+      }
+      logger.debug("Resolving dependencies...");
+      const resolved = this.resolveDependencies(plugins);
+      const allPlugins = resolved.plugins;
+      if (resolved.autoInstalled.length > 0) {
+        logger.info(
+          `Auto-installing ${resolved.autoInstalled.length} required dependency(ies): ${resolved.autoInstalled.join(", ")}`
+        );
+      }
+      logger.debug("Running pre-install hooks...");
+      await this.runPreInstallHooks(allPlugins);
+      if (options?.skipPackageInstall) {
+        logger.info("Skipping package installation (--no-install mode)");
+      } else {
+        logger.debug("Installing packages...");
+        const installResults = await this.installPackages(allPlugins);
+        const failedInstalls = installResults.filter((r) => !r.success);
+        if (failedInstalls.length > 0) {
+          throw new Error(
+            `Failed to install packages for ${failedInstalls.length} plugin(s)`
+          );
+        }
+      }
+      logger.debug("Configuring plugins...");
+      const configResults = [];
+      const filesCreated = [];
+      for (const plugin of allPlugins) {
+        try {
+          logger.debug(`Configuring ${plugin.displayName}...`);
+          const configResult = await plugin.configure(this.ctx);
+          configResults.push(configResult);
+          filesCreated.push(...configResult.files || []);
+          if (!configResult.success) {
+            throw new Error(
+              `Configuration failed for ${plugin.displayName}: ${configResult.message || "Unknown error"}`
+            );
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          logger.error(
+            `Configuration failed for ${plugin.displayName}: ${errorMessage}`
+          );
+          throw error;
+        }
+      }
+      logger.debug("Running post-install hooks...");
+      await this.runPostInstallHooks(allPlugins);
+      const duration = Date.now() - startTime;
+      const installed = allPlugins.map((p) => p.name);
+      logger.info(
+        `Successfully installed ${installed.length} plugin(s) in ${duration}ms`
+      );
+      return {
+        success: true,
+        duration,
+        installed,
+        warnings: validationResult.warnings,
+        filesCreated
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Installation failed: ${errorMessage}`);
+      logger.debug("Rolling back changes...");
+      try {
+        await this.rollback(plugins);
+      } catch (rollbackError) {
+        const rollbackMessage = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+        logger.error(`Rollback failed: ${rollbackMessage}`);
+      }
+      const duration = Date.now() - startTime;
+      return {
+        success: false,
+        duration,
+        installed: [],
+        warnings: [],
+        filesCreated: []
+      };
+    }
+  }
+  /**
+   * Résout les dépendances requises et recommandées
+   *
+   * @param plugins - Liste des plugins initiaux
+   * @returns Plugins avec dépendances résolues
+   *
+   * @internal
+   */
+  resolveDependencies(plugins) {
+    const pluginMap = /* @__PURE__ */ new Map();
+    const autoInstalled = [];
+    for (const plugin of plugins) {
+      pluginMap.set(plugin.name, plugin);
+    }
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const plugin of Array.from(pluginMap.values())) {
+        if (!plugin.requires) {
+          continue;
+        }
+        for (const required of plugin.requires) {
+          if (!pluginMap.has(required)) {
+            logger.warn(
+              `Plugin ${plugin.name} requires ${required}, but it's not available in the registry`
+            );
+          }
+        }
+      }
+    }
+    return {
+      plugins: Array.from(pluginMap.values()),
+      autoInstalled
+    };
+  }
+  /**
+   * Installe les packages pour tous les plugins
+   *
+   * @param plugins - Liste des plugins
+   * @returns Résultats d'installation pour chaque plugin
+   *
+   * @internal
+   */
+  async installPackages(plugins) {
+    const results = [];
+    const installPromises = plugins.map(async (plugin) => {
+      try {
+        if (plugin.detect && await plugin.detect(this.ctx)) {
+          logger.debug(`${plugin.displayName} is already installed`);
+          return {
+            packages: {},
+            success: true,
+            message: "Already installed"
+          };
+        }
+        if (plugin.preInstall) {
+          await plugin.preInstall(this.ctx);
+        }
+        const result = await plugin.install(this.ctx);
+        if (plugin.postInstall) {
+          await plugin.postInstall(this.ctx);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to install ${plugin.displayName}: ${errorMessage}`);
+        return {
+          packages: {},
+          success: false,
+          message: errorMessage
+        };
+      }
+    });
+    const installResults = await Promise.all(installPromises);
+    results.push(...installResults);
+    const allDependencies = [];
+    const allDevDependencies = [];
+    for (const result of installResults) {
+      if (result.success && result.packages) {
+        if (result.packages.dependencies) {
+          allDependencies.push(...result.packages.dependencies);
+        }
+        if (result.packages.devDependencies) {
+          allDevDependencies.push(...result.packages.devDependencies);
+        }
+      }
+    }
+    if (allDependencies.length > 0) {
+      await installPackages(allDependencies, {
+        packageManager: this.ctx.packageManager,
+        projectRoot: this.ctx.projectRoot,
+        dev: false,
+        silent: false
+      });
+    }
+    if (allDevDependencies.length > 0) {
+      await installPackages(allDevDependencies, {
+        packageManager: this.ctx.packageManager,
+        projectRoot: this.ctx.projectRoot,
+        dev: true,
+        silent: false
+      });
+    }
+    return results;
+  }
+  /**
+   * Exécute les hooks pre-install de tous les plugins
+   *
+   * @param plugins - Liste des plugins
+   *
+   * @internal
+   */
+  async runPreInstallHooks(plugins) {
+    for (const plugin of plugins) {
+      if (plugin.preInstall) {
+        try {
+          await plugin.preInstall(this.ctx);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          logger.warn(
+            `Pre-install hook failed for ${plugin.displayName}: ${errorMessage}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Exécute les hooks post-install de tous les plugins
+   *
+   * @param plugins - Liste des plugins
+   *
+   * @internal
+   */
+  async runPostInstallHooks(plugins) {
+    for (const plugin of plugins) {
+      if (plugin.postInstall) {
+        try {
+          await plugin.postInstall(this.ctx);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          logger.warn(
+            `Post-install hook failed for ${plugin.displayName}: ${errorMessage}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Effectue un rollback complet en cas d'erreur
+   *
+   * @param plugins - Liste des plugins installés
+   *
+   * @internal
+   */
+  async rollback(plugins) {
+    logger.debug("Starting rollback...");
+    for (const plugin of plugins.reverse()) {
+      if (plugin.rollback) {
+        try {
+          await plugin.rollback(this.ctx);
+          logger.debug(`Rolled back ${plugin.displayName}`);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          logger.error(
+            `Rollback failed for ${plugin.displayName}: ${errorMessage}`
+          );
+        }
+      }
+    }
+    try {
+      await this.backupManager.restoreAll();
+      logger.debug("Restored all file backups");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to restore backups: ${errorMessage}`);
+    }
+  }
+};
+
+// src/cli/ui/spinner.ts
+import ora from "ora";
+var SpinnerManager = class {
+  spinner = null;
+  constructor() {
+  }
+  /**
+   * Démarre un spinner avec un message
+   *
+   * @param message - Message à afficher (peut être une clé de traduction)
+   * @param text - Texte personnalisé (optionnel, remplace le message traduit)
+   */
+  start(message, text) {
+    this.stop();
+    const displayText = text || message;
+    this.spinner = ora({
+      text: displayText,
+      spinner: "dots"
+    }).start();
+  }
+  /**
+   * Met à jour le message du spinner
+   *
+   * @param message - Nouveau message
+   */
+  update(message) {
+    if (this.spinner) {
+      this.spinner.text = message;
+    }
+  }
+  /**
+   * Arrête le spinner avec succès
+   *
+   * @param message - Message de succès (optionnel)
+   */
+  succeed(message) {
+    if (this.spinner) {
+      this.spinner.succeed(message);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Arrête le spinner avec une erreur
+   *
+   * @param message - Message d'erreur (optionnel)
+   */
+  fail(message) {
+    if (this.spinner) {
+      this.spinner.fail(message);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Arrête le spinner avec un avertissement
+   *
+   * @param message - Message d'avertissement (optionnel)
+   */
+  warn(message) {
+    if (this.spinner) {
+      this.spinner.warn(message);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Arrête le spinner avec un message d'information
+   *
+   * @param message - Message d'information (optionnel)
+   */
+  info(message) {
+    if (this.spinner) {
+      this.spinner.info(message);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Arrête le spinner sans message
+   */
+  stop() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+  /**
+   * Vérifie si un spinner est actif
+   */
+  isSpinning() {
+    return this.spinner !== null && this.spinner.isSpinning;
+  }
+};
+
+// src/cli/ui/report.ts
+function displayInstallationReport(report, plugins, lang) {
+  const t = getTranslations(lang);
+  console.log(`
+${t.report.title}`);
+  if (report.duration > 0) {
+    const durationSeconds = (report.duration / 1e3).toFixed(1);
+    console.log(`   (${durationSeconds}s)
+`);
+  } else {
+    console.log("");
+  }
+  if (report.installed.length > 0) {
+    console.log(`${t.report.packagesInstalled}:`);
+    for (const pluginName of report.installed) {
+      const plugin = plugins.find((p) => p.name === pluginName);
+      const version2 = plugin?.version ? ` (${plugin.version})` : "";
+      console.log(`   \u2713 ${plugin?.displayName || pluginName}${version2}`);
+    }
+    console.log("");
+  }
+  const createdFiles = report.filesCreated.filter((f) => f.type === "create");
+  if (createdFiles.length > 0) {
+    console.log(`${t.report.filesCreated}:`);
+    for (const file of createdFiles) {
+      console.log(`   \u2022 ${file.path}`);
+    }
+    console.log("");
+  }
+  const modifiedFiles = report.filesCreated.filter((f) => f.type === "modify");
+  if (modifiedFiles.length > 0) {
+    console.log(`${t.report.filesModified}:`);
+    for (const file of modifiedFiles) {
+      console.log(`   \u2022 ${file.path}`);
+    }
+    console.log("");
+  }
+  if (report.warnings.length > 0) {
+    console.log(`\u26A0\uFE0F  ${report.warnings.length} warning(s):`);
+    for (const warning of report.warnings) {
+      console.log(`   \u26A0 ${warning.message}`);
+      if (warning.plugins && warning.plugins.length > 0) {
+        console.log(`     Plugins: ${warning.plugins.join(", ")}`);
+      }
+    }
+    console.log("");
+  }
+  displayNextSteps(lang);
+}
+function displayNextSteps(lang) {
+  const t = getTranslations(lang);
+  console.log(`${t.report.nextSteps}:`);
+  console.log("   1. npm run dev");
+  console.log("   2. Visitez http://localhost:5173");
+  console.log("   3. Consultez la documentation dans src/");
+  console.log("");
+}
+
+// src/cli/commands/install.ts
+async function installReact(options) {
+  try {
+    const language = await promptLanguage();
+    const t = getTranslations(language);
+    console.log(`
+${t.detection.detecting}`);
+    const projectRoot = process.cwd();
+    const ctx = await detectContext(projectRoot);
+    console.log(
+      `   \u2713 ${t.detection.framework}: ${ctx.framework} ${ctx.frameworkVersion}`
+    );
+    console.log(
+      `   \u2713 ${t.detection.typescript}: ${ctx.typescript ? "Oui" : "Non"}`
+    );
+    if (ctx.bundler) {
+      console.log(
+        `   \u2713 ${t.detection.bundler}: ${ctx.bundler} ${ctx.bundlerVersion || ""}`
+      );
+    }
+    console.log(`   \u2713 ${t.detection.packageManager}: ${ctx.packageManager}
+`);
+    let selectedPlugins = [];
+    if (options.yes) {
+      logger.info("Using default recommendations (--yes mode)");
+    } else {
+      selectedPlugins = await promptPluginSelection(
+        ctx,
+        pluginRegistry,
+        language
+      );
+    }
+    if (selectedPlugins.length === 0) {
+      console.log(`
+${t.common.selected(0)}`);
+      console.log("Exiting...");
+      return;
+    }
+    console.log(`
+${t.common.selected(selectedPlugins.length)}`);
+    if (!options.yes && !options.silent) {
+      const confirmed = await promptConfirmation(selectedPlugins, language);
+      if (!confirmed) {
+        console.log(t.common.cancel);
+        return;
+      }
+    }
+    if (options.dryRun) {
+      console.log("\n\u{1F50D} MODE DRY-RUN (simulation uniquement)");
+      console.log("\u2501".repeat(50));
+      console.log("\n\u{1F4E6} Packages \xE0 installer :");
+      for (const plugin of selectedPlugins) {
+        console.log(
+          `   ${plugin.name}${plugin.version ? `@${plugin.version}` : ""}`
+        );
+      }
+      console.log("\n\u{1F4DD} Fichiers qui seraient cr\xE9\xE9s/modifi\xE9s :");
+      for (const plugin of selectedPlugins) {
+        console.log(`   ${plugin.displayName} configuration`);
+      }
+      console.log("\n\u26A0\uFE0F  Aucune modification n'a \xE9t\xE9 effectu\xE9e (dry-run)");
+      console.log("\u{1F4A1} Ex\xE9cutez sans --dry-run pour appliquer les changements");
+      return;
+    }
+    const backupManager = new BackupManager();
+    const configWriter = new ConfigWriter(backupManager);
+    const validator = new CompatibilityValidator(compatibilityRules);
+    const installer = new Installer(ctx, validator, configWriter, backupManager);
+    if (options.install === false) {
+      console.log("\n\u2699\uFE0F  Mode configuration uniquement (--no-install)");
+      console.log("Les packages ne seront PAS install\xE9s\n");
+    }
+    const spinner = new SpinnerManager();
+    spinner.start(t.installation.installing);
+    try {
+      const result = await installer.install(selectedPlugins, {
+        skipPackageInstall: options.install === false
+      });
+      spinner.succeed(t.installation.success);
+      if (result.success) {
+        displayInstallationReport(result, selectedPlugins, language);
+      } else {
+        console.error(`
+${t.installation.error}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      spinner.fail(t.installation.error);
+      throw error;
+    }
+  } catch (error) {
+    logger.error("Installation failed:", error);
+    if (error instanceof Error) {
+      console.error(`
+\u274C ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+export {
+  installReact
+};