@configjs/cli 1.0.0

package/dist/chunk-PQLKGF6I.js

@@ -0,0 +1,224 @@
+import {
+  logger
+} from "./chunk-5T664O5A.js";
+
+// src/core/validator.ts
+var CompatibilityValidator = class {
+  /**
+   * @param rules - Règles de compatibilité à appliquer
+   */
+  constructor(rules) {
+    this.rules = rules;
+  }
+  /**
+   * Valide la compatibilité d'un ensemble de plugins
+   *
+   * @param plugins - Liste des plugins à valider
+   * @returns Résultat de la validation avec erreurs, warnings et suggestions
+   *
+   * @example
+   * ```typescript
+   * const result = validator.validate([plugin1, plugin2, plugin3])
+   * if (!result.valid) {
+   *   // Gérer les erreurs
+   * }
+   * ```
+   */
+  validate(plugins) {
+    logger.debug(`Validating ${plugins.length} plugin(s)`);
+    const pluginNames = new Set(plugins.map((p) => p.name));
+    const allConflicts = this.checkConflicts(plugins, pluginNames);
+    const conflictErrors = [];
+    const conflictWarnings = [];
+    for (const conflict of allConflicts) {
+      const rule = this.rules.find(
+        (r) => r.type === "CONFLICT" && r.plugins?.every((p) => conflict.plugins?.includes(p))
+      );
+      if (rule?.severity === "error") {
+        conflictErrors.push(conflict);
+      } else {
+        conflictWarnings.push(conflict);
+      }
+    }
+    const errors = [
+      ...this.checkExclusivity(plugins, pluginNames),
+      ...conflictErrors,
+      ...this.checkDependencies(plugins, pluginNames)
+    ];
+    const warnings = conflictWarnings;
+    const suggestions = this.checkRecommendations(plugins, pluginNames);
+    const valid = errors.length === 0;
+    logger.debug(`Validation result: ${valid ? "valid" : "invalid"}`, {
+      errors: errors.length,
+      warnings: warnings.length,
+      suggestions: suggestions.length
+    });
+    return {
+      valid,
+      errors,
+      warnings,
+      suggestions
+    };
+  }
+  /**
+   * Vérifie les règles d'exclusivité (EXCLUSIVE)
+   *
+   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
+   * @param pluginNames - Set des noms de plugins pour lookup rapide
+   * @returns Liste des erreurs d'exclusivité
+   *
+   * @internal
+   */
+  checkExclusivity(_plugins, pluginNames) {
+    const errors = [];
+    for (const rule of this.rules) {
+      if (rule.type !== "EXCLUSIVE" || !rule.plugins) {
+        continue;
+      }
+      const selectedExclusivePlugins = rule.plugins.filter(
+        (pluginName) => pluginNames.has(pluginName)
+      );
+      if (selectedExclusivePlugins.length > 1) {
+        errors.push({
+          type: "EXCLUSIVE",
+          plugins: selectedExclusivePlugins,
+          message: rule.reason,
+          canOverride: rule.allowOverride ?? false
+        });
+      }
+    }
+    return errors;
+  }
+  /**
+   * Vérifie les conflits entre plugins (CONFLICT)
+   *
+   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
+   * @param pluginNames - Set des noms de plugins pour lookup rapide
+   * @returns Liste des warnings/erreurs de conflit
+   *
+   * @internal
+   */
+  checkConflicts(_plugins, pluginNames) {
+    const conflicts = [];
+    for (const rule of this.rules) {
+      if (rule.type !== "CONFLICT" || !rule.plugins) {
+        continue;
+      }
+      const conflictingPlugins = rule.plugins.filter(
+        (pluginName) => pluginNames.has(pluginName)
+      );
+      if (conflictingPlugins.length > 1) {
+        conflicts.push({
+          type: "CONFLICT",
+          plugins: conflictingPlugins,
+          message: rule.reason,
+          canOverride: rule.allowOverride ?? true
+        });
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Vérifie les dépendances requises (REQUIRES)
+   *
+   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
+   * @param pluginNames - Set des noms de plugins pour lookup rapide
+   * @returns Liste des erreurs de dépendances manquantes
+   *
+   * @internal
+   */
+  checkDependencies(_plugins, pluginNames) {
+    const errors = [];
+    for (const rule of this.rules) {
+      if (rule.type !== "REQUIRES" || !rule.plugin || !rule.requires) {
+        continue;
+      }
+      if (!pluginNames.has(rule.plugin)) {
+        continue;
+      }
+      const missingDependencies = rule.requires.filter(
+        (dep) => !pluginNames.has(dep)
+      );
+      if (missingDependencies.length > 0) {
+        errors.push({
+          type: "REQUIRES",
+          plugin: rule.plugin,
+          required: missingDependencies.join(", "),
+          message: `${rule.plugin} requires: ${missingDependencies.join(", ")}. ${rule.reason}`,
+          canOverride: rule.allowOverride ?? false
+        });
+      }
+    }
+    return errors;
+  }
+  /**
+   * Vérifie les recommandations (RECOMMENDS)
+   *
+   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
+   * @param pluginNames - Set des noms de plugins pour lookup rapide
+   * @returns Liste des suggestions de plugins recommandés
+   *
+   * @internal
+   */
+  checkRecommendations(_plugins, pluginNames) {
+    const suggestions = [];
+    for (const rule of this.rules) {
+      if (rule.type !== "RECOMMENDS" || !rule.plugin || !rule.recommends) {
+        continue;
+      }
+      if (!pluginNames.has(rule.plugin)) {
+        continue;
+      }
+      const missingRecommendations = rule.recommends.filter(
+        (rec) => !pluginNames.has(rec)
+      );
+      if (missingRecommendations.length > 0) {
+        suggestions.push(
+          `${rule.plugin} recommends: ${missingRecommendations.join(", ")}. ${rule.reason}`
+        );
+      }
+    }
+    return suggestions;
+  }
+};
+var compatibilityRules = [
+  // Exclusivités - State Management
+  {
+    type: "EXCLUSIVE",
+    plugins: ["@reduxjs/toolkit", "zustand", "jotai"],
+    reason: "Une seule solution de state management est recommand\xE9e",
+    severity: "error",
+    allowOverride: false
+  },
+  // Conflits - CSS Frameworks
+  {
+    type: "CONFLICT",
+    plugins: ["tailwindcss", "bootstrap"],
+    reason: "Approches CSS potentiellement conflictuelles",
+    severity: "warning",
+    allowOverride: true
+  },
+  // Dépendances - TailwindCSS
+  {
+    type: "REQUIRES",
+    plugin: "tailwindcss",
+    requires: ["postcss", "autoprefixer"],
+    reason: "PostCSS et Autoprefixer sont n\xE9cessaires pour TailwindCSS",
+    severity: "error",
+    autoInstall: true,
+    allowOverride: false
+  },
+  // Recommandations - React Router
+  {
+    type: "RECOMMENDS",
+    plugin: "react-router-dom",
+    recommends: ["@types/react-router-dom"],
+    reason: "Types TypeScript recommand\xE9s pour une meilleure exp\xE9rience de d\xE9veloppement",
+    severity: "info"
+  }
+];
+
+export {
+  CompatibilityValidator,
+  compatibilityRules
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// package.json
+var version = "1.0.0";
+
+// src/cli.ts
+var program = new Command();
+program.name("confjs").description("Configure your frontend stack, instantly").version(version);
+program.command("react").description("Configure a React project").option("-y, --yes", "Accept all defaults").option("-d, --dry-run", "Simulate without writing to disk").option("-s, --silent", "Non-interactive mode").option("--debug", "Enable debug logs").option("-c, --config <file>", "Use configuration file").option("-f, --force", "Force installation (overwrite configs)").option("--no-install", "Generate configs only, skip package installation").action(
+  async (options) => {
+    try {
+      const { installReact } = await import("./install-X7G2IXXX.js");
+      await installReact(options);
+    } catch (error) {
+      console.error("Error:", error);
+      process.exit(1);
+    }
+  }
+);
+program.command("list").description("List available libraries").option("-c, --category <category>", "Filter by category").action(async (options) => {
+  try {
+    const { listLibraries } = await import("./list-J4E7JFII.js");
+    listLibraries(options);
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  }
+});
+program.command("check").description("Check compatibility without installing").option("-c, --config <file>", "Configuration file to check").action(async (options) => {
+  try {
+    const { checkCompatibility } = await import("./check-JF56SNQC.js");
+    await checkCompatibility(options);
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  }
+});
+program.parse(process.argv);