@configjs/cli 1.1.16 → 1.1.17

package/dist/{chunk-NYCK4R4K.js → chunk-56AR5ZW2.js}

@@ -1,9 +1,9 @@
 import {
   pluginRegistry
-} from "./chunk-JYWGJJ4M.js";
+} from "./chunk-IY4KX4KL.js";
 import {
   getModuleLogger
-} from "./chunk-QPEUT7QG.js";
+} from "./chunk-VN4XTFDK.js";
 
 // src/core/compatibility-generator.ts
 var logger = getModuleLogger();
@@ -158,6 +158,300 @@ function generateRecommendsRules(plugins) {
   return rules;
 }
 
+// src/core/indexing.ts
+var ConflictIndex = class _ConflictIndex {
+  pluginToRules;
+  // private readonly categoryIndex: Map<string, string[]> // Reserved for future use
+  constructor(pluginToRules, _categoryIndex) {
+    this.pluginToRules = pluginToRules;
+  }
+  /**
+   * Build conflict index from rules
+   * Time complexity: O(rules × plugins per rule)
+   * Space complexity: O(rules × average plugins per rule)
+   *
+   * @param rules - All compatibility rules
+   * @returns ConflictIndex instance
+   */
+  static build(rules) {
+    const pluginToRules = /* @__PURE__ */ new Map();
+    const categoryIndex = /* @__PURE__ */ new Map();
+    for (const rule of rules) {
+      if (rule.type !== "CONFLICT" || !rule.plugins) {
+        continue;
+      }
+      for (const pluginName of rule.plugins) {
+        if (!pluginToRules.has(pluginName)) {
+          pluginToRules.set(pluginName, []);
+        }
+        const rules2 = pluginToRules.get(pluginName);
+        if (rules2) {
+          rules2.push(rule);
+        }
+      }
+    }
+    return new _ConflictIndex(pluginToRules, categoryIndex);
+  }
+  /**
+   * Get all conflicts for a set of plugins
+   * Time complexity: O(selectedPlugins) + O(rules found)
+   *
+   * @param pluginNames - Set of plugin names to check
+   * @param rules - Rules array for fallback filtering
+   * @returns Array of applicable conflict rules
+   */
+  getConflicts(pluginNames, rules) {
+    const conflicts = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const pluginName of pluginNames) {
+      const rulesForPlugin = this.pluginToRules.get(pluginName);
+      if (rulesForPlugin) {
+        for (const rule of rulesForPlugin) {
+          if (seen.has(rule)) {
+            continue;
+          }
+          seen.add(rule);
+          if (rule.plugins) {
+            const selectedCount = rule.plugins.filter(
+              (p) => pluginNames.has(p)
+            ).length;
+            if (selectedCount > 1) {
+              conflicts.push(rule);
+            }
+          }
+        }
+      }
+    }
+    for (const rule of rules) {
+      if (seen.has(rule) || rule.type !== "CONFLICT" || !rule.plugins) {
+        continue;
+      }
+      const selectedCount = rule.plugins.filter(
+        (p) => pluginNames.has(p)
+      ).length;
+      if (selectedCount > 1) {
+        conflicts.push(rule);
+      }
+    }
+    return conflicts;
+  }
+};
+var DependencyIndex = class _DependencyIndex {
+  pluginToDeps;
+  reverseDeps;
+  // dep → plugins that require it
+  constructor(pluginToDeps, reverseDeps) {
+    this.pluginToDeps = pluginToDeps;
+    this.reverseDeps = reverseDeps;
+  }
+  /**
+   * Build dependency index from rules
+   * Time complexity: O(rules × requires per rule)
+   * Space complexity: O(rules + total dependencies)
+   *
+   * @param rules - All compatibility rules
+   * @returns DependencyIndex instance
+   */
+  static build(rules) {
+    const pluginToDeps = /* @__PURE__ */ new Map();
+    const reverseDeps = /* @__PURE__ */ new Map();
+    for (const rule of rules) {
+      if (rule.type !== "REQUIRES" || !rule.plugin || !rule.requires) {
+        continue;
+      }
+      pluginToDeps.set(rule.plugin, rule);
+      for (const dep of rule.requires) {
+        const depName = dep.split("@")[0];
+        if (!depName) continue;
+        if (!reverseDeps.has(depName)) {
+          reverseDeps.set(depName, /* @__PURE__ */ new Set());
+        }
+        const revDeps = reverseDeps.get(depName);
+        if (revDeps) {
+          revDeps.add(rule.plugin);
+        }
+      }
+    }
+    return new _DependencyIndex(pluginToDeps, reverseDeps);
+  }
+  /**
+   * Get dependencies for a plugin
+   * Time complexity: O(1)
+   *
+   * @param pluginName - Plugin name
+   * @returns CompatibilityRule or undefined
+   */
+  getDependencies(pluginName) {
+    return this.pluginToDeps.get(pluginName);
+  }
+  /**
+   * Get all dependencies for a set of plugins
+   * Time complexity: O(selectedPlugins)
+   *
+   * @param pluginNames - Set of plugin names
+   * @returns Array of REQUIRES rules for selected plugins
+   */
+  getAllDependencies(pluginNames) {
+    const deps = [];
+    for (const pluginName of pluginNames) {
+      const rule = this.pluginToDeps.get(pluginName);
+      if (rule) {
+        deps.push(rule);
+      }
+    }
+    return deps;
+  }
+  /**
+   * Get which plugins require a specific dependency
+   * Time complexity: O(1)
+   *
+   * @param depName - Dependency name
+   * @returns Set of plugin names that require this dependency
+   */
+  getPluginsRequiring(depName) {
+    return this.reverseDeps.get(depName) ?? /* @__PURE__ */ new Set();
+  }
+};
+var RecommendationIndex = class _RecommendationIndex {
+  pluginToRecs;
+  constructor(pluginToRecs) {
+    this.pluginToRecs = pluginToRecs;
+  }
+  /**
+   * Build recommendation index from rules
+   * Time complexity: O(rules)
+   * Space complexity: O(rules)
+   *
+   * @param rules - All compatibility rules
+   * @returns RecommendationIndex instance
+   */
+  static build(rules) {
+    const pluginToRecs = /* @__PURE__ */ new Map();
+    for (const rule of rules) {
+      if (rule.type !== "RECOMMENDS" || !rule.plugin) {
+        continue;
+      }
+      pluginToRecs.set(rule.plugin, rule);
+    }
+    return new _RecommendationIndex(pluginToRecs);
+  }
+  /**
+   * Get recommendations for a plugin
+   * Time complexity: O(1)
+   *
+   * @param pluginName - Plugin name
+   * @returns CompatibilityRule or undefined
+   */
+  getRecommendations(pluginName) {
+    return this.pluginToRecs.get(pluginName);
+  }
+  /**
+   * Get all recommendations for a set of plugins
+   * Time complexity: O(selectedPlugins)
+   *
+   * @param pluginNames - Set of plugin names
+   * @returns Array of RECOMMENDS rules for selected plugins
+   */
+  getAllRecommendations(pluginNames) {
+    const recs = [];
+    for (const pluginName of pluginNames) {
+      const rule = this.pluginToRecs.get(pluginName);
+      if (rule) {
+        recs.push(rule);
+      }
+    }
+    return recs;
+  }
+};
+var ExclusivityIndex = class _ExclusivityIndex {
+  // private readonly exclusivityGroups: Map<string, CompatibilityRule> // Reserved for future use
+  pluginToRule;
+  constructor(_exclusivityGroups, pluginToRule) {
+    this.pluginToRule = pluginToRule;
+  }
+  /**
+   * Build exclusivity index from rules
+   * Time complexity: O(rules × plugins per rule)
+   * Space complexity: O(rules + total plugins in exclusive rules)
+   *
+   * @param rules - All compatibility rules
+   * @returns ExclusivityIndex instance
+   */
+  static build(rules) {
+    const exclusivityGroups = /* @__PURE__ */ new Map();
+    const pluginToRule = /* @__PURE__ */ new Map();
+    let groupId = 0;
+    for (const rule of rules) {
+      if (rule.type !== "EXCLUSIVE" || !rule.plugins) {
+        continue;
+      }
+      const key = `exclusive-group-${groupId++}`;
+      exclusivityGroups.set(key, rule);
+      for (const pluginName of rule.plugins) {
+        pluginToRule.set(pluginName, rule);
+      }
+    }
+    return new _ExclusivityIndex(exclusivityGroups, pluginToRule);
+  }
+  /**
+   * Get exclusivity violations for a set of plugins
+   * Time complexity: O(selectedPlugins)
+   *
+   * @param pluginNames - Set of plugin names to check
+   * @returns Array of EXCLUSIVE violations with error properties
+   */
+  getViolations(pluginNames) {
+    const violations = [];
+    const seenRules = /* @__PURE__ */ new Set();
+    for (const pluginName of pluginNames) {
+      const rule = this.pluginToRule.get(pluginName);
+      if (rule && rule.plugins && !seenRules.has(rule)) {
+        seenRules.add(rule);
+        const selectedCount = rule.plugins.filter(
+          (p) => pluginNames.has(p)
+        ).length;
+        if (selectedCount > 1) {
+          violations.push({
+            type: "EXCLUSIVE",
+            plugins: rule.plugins.filter((p) => pluginNames.has(p)),
+            message: rule.reason,
+            canOverride: rule.allowOverride ?? false
+          });
+        }
+      }
+    }
+    return violations;
+  }
+};
+var ValidationIndex = class _ValidationIndex {
+  conflicts;
+  dependencies;
+  recommendations;
+  exclusivity;
+  constructor(conflicts, dependencies, recommendations, exclusivity) {
+    this.conflicts = conflicts;
+    this.dependencies = dependencies;
+    this.recommendations = recommendations;
+    this.exclusivity = exclusivity;
+  }
+  /**
+   * Build complete validation index from rules
+   * Time complexity: O(rules × average items per rule)
+   * Space complexity: O(rules + total indexed items)
+   *
+   * @param rules - All compatibility rules
+   * @returns ValidationIndex instance ready for validation
+   */
+  static build(rules) {
+    return new _ValidationIndex(
+      ConflictIndex.build(rules),
+      DependencyIndex.build(rules),
+      RecommendationIndex.build(rules),
+      ExclusivityIndex.build(rules)
+    );
+  }
+};
+
 // src/core/validator.ts
 var CompatibilityValidator = class {
   /**
@@ -165,11 +459,16 @@ var CompatibilityValidator = class {
    */
   constructor(rules) {
     this.rules = rules;
+    this.validationIndex = ValidationIndex.build(rules);
   }
   logger = getModuleLogger();
+  validationIndex;
   /**
    * Valide la compatibilité d'un ensemble de plugins
    *
+   * Time complexity: O(n) where n = number of plugins (previously O(n²))
+   * Space complexity: O(n) for index structures
+   *
    * @param plugins - Liste des plugins à valider
    * @param ctx - Contexte du projet (optionnel, pour règles spécifiques framework)
    * @returns Résultat de la validation avec erreurs, warnings et suggestions
@@ -188,27 +487,45 @@ var CompatibilityValidator = class {
     const applicableRules = ctx ? this.rules.filter(
       (rule) => !rule.framework || rule.framework === ctx.framework
     ) : this.rules.filter((rule) => !rule.framework);
-    const allConflicts = this.checkConflicts(
-      plugins,
+    const exclusivityViolations = this.checkExclusivity(
       pluginNames,
       applicableRules
     );
-    const conflictErrors = [];
-    const conflictWarnings = [];
-    for (const conflict of allConflicts) {
+    const exclusivityErrors = [];
+    const exclusivityWarnings = [];
+    for (const violation of exclusivityViolations) {
+      if (!violation.plugins) continue;
+      const plugins2 = violation.plugins;
       const rule = applicableRules.find(
-        (r) => r.type === "CONFLICT" && r.plugins?.every((p) => conflict.plugins?.includes(p))
+        (r) => r.type === "EXCLUSIVE" && plugins2.every((p) => r.plugins?.includes(p))
       );
-      if (rule?.severity === "error") {
-        conflictErrors.push(conflict);
+      if (rule?.severity === "warning") {
+        exclusivityWarnings.push(violation);
+      } else {
+        exclusivityErrors.push(violation);
+      }
+    }
+    const conflictResults = this.checkConflicts(pluginNames, applicableRules);
+    const conflictErrors = [];
+    const conflictWarnings = [];
+    for (const rule of conflictResults) {
+      const error = {
+        plugin: rule.plugin,
+        plugins: rule.plugins,
+        message: rule.reason,
+        type: rule.type
+      };
+      if (rule.severity === "error") {
+        conflictErrors.push(error);
       } else {
-        conflictWarnings.push(conflict);
+        conflictWarnings.push(error);
       }
     }
-    const frameworkConflicts = ctx ? this.checkFrameworkConflicts(plugins, pluginNames, ctx, applicableRules) : [];
+    const frameworkConflicts = ctx ? this.checkFrameworkConflicts(pluginNames, ctx, applicableRules) : [];
     const frameworkErrors = [];
     const frameworkWarnings = [];
     for (const conflict of frameworkConflicts) {
+      if (!conflict.plugins) continue;
       const rule = applicableRules.find(
         (r) => r.type === "CONFLICT" && r.framework === ctx?.framework && r.plugins?.some((p) => conflict.plugins?.includes(p))
       );
@@ -218,27 +535,19 @@ var CompatibilityValidator = class {
         frameworkWarnings.push(conflict);
       }
     }
-    const exclusivityResults = this.checkExclusivity(
-      plugins,
+    const dependencyErrors = this.checkDependencies(
+      pluginNames,
+      applicableRules,
+      ctx
+    );
+    const suggestionsList = this.checkRecommendations(
       pluginNames,
       applicableRules
     );
-    const exclusivityErrors = [];
-    const exclusivityWarnings = [];
-    for (const result of exclusivityResults) {
-      const rule = applicableRules.find(
-        (r) => r.type === "EXCLUSIVE" && result.plugins?.every((p) => r.plugins?.includes(p))
-      );
-      if (rule?.severity === "warning") {
-        exclusivityWarnings.push(result);
-      } else {
-        exclusivityErrors.push(result);
-      }
-    }
     const errors = [
       ...exclusivityErrors,
       ...conflictErrors,
-      ...this.checkDependencies(plugins, pluginNames, applicableRules, ctx),
+      ...dependencyErrors,
       ...frameworkErrors
     ];
     const warnings = [
@@ -246,28 +555,23 @@ var CompatibilityValidator = class {
       ...conflictWarnings,
       ...frameworkWarnings
     ];
-    const suggestions = this.checkRecommendations(
-      plugins,
-      pluginNames,
-      applicableRules
-    );
     const valid = errors.length === 0;
     this.logger.debug(`Validation result: ${valid ? "valid" : "invalid"}`, {
       errors: errors.length,
       warnings: warnings.length,
-      suggestions: suggestions.length
+      suggestions: suggestionsList.length
     });
     return {
       valid,
       errors,
       warnings,
-      suggestions
+      suggestions: suggestionsList
     };
   }
   /**
-   * Vérifie les conflits avec le framework
+   * Vérifie les conflits avec le framework (optimized with indexing)
+   * Time complexity: O(selectedPlugins) instead of O(rules × plugins)
    *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
    * @param pluginNames - Set des noms de plugins pour lookup rapide
    * @param ctx - Contexte du projet
    * @param rules - Règles applicables
@@ -275,7 +579,7 @@ var CompatibilityValidator = class {
    *
    * @internal
    */
-  checkFrameworkConflicts(_plugins, pluginNames, ctx, rules) {
+  checkFrameworkConflicts(pluginNames, ctx, rules) {
     const conflicts = [];
     for (const rule of rules) {
       if (rule.type !== "CONFLICT" || !rule.framework || rule.framework !== ctx.framework) {
@@ -300,72 +604,37 @@ var CompatibilityValidator = class {
     return conflicts;
   }
   /**
-   * Vérifie les règles d'exclusivité (EXCLUSIVE)
+   * Vérifie les règles d'exclusivité (EXCLUSIVE) - Optimized with indexing
+   * Time complexity: O(selectedPlugins) instead of O(rules × plugins)
    *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
    * @param pluginNames - Set des noms de plugins pour lookup rapide
    * @param rules - Règles applicables
    * @returns Liste des erreurs d'exclusivité
    *
    * @internal
    */
-  checkExclusivity(_plugins, pluginNames, rules = this.rules) {
-    const errors = [];
-    for (const rule of 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;
+  checkExclusivity(pluginNames, _rules = this.rules) {
+    return this.validationIndex.exclusivity.getViolations(
+      pluginNames
+    );
   }
   /**
-   * Vérifie les conflits entre plugins (CONFLICT)
+   * Vérifie les conflits entre plugins (CONFLICT) - Optimized with indexing
+   * Time complexity: O(selectedPlugins) instead of O(rules × plugins)
    *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
    * @param pluginNames - Set des noms de plugins pour lookup rapide
    * @param rules - Règles applicables
    * @returns Liste des warnings/erreurs de conflit
    *
    * @internal
    */
-  checkConflicts(_plugins, pluginNames, rules = this.rules) {
-    const conflicts = [];
-    for (const rule of rules) {
-      if (rule.framework) {
-        continue;
-      }
-      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;
+  checkConflicts(pluginNames, _rules = this.rules) {
+    return this.validationIndex.conflicts.getConflicts(pluginNames, _rules);
   }
   /**
-   * Vérifie les dépendances requises (REQUIRES)
+   * Vérifie les dépendances requises (REQUIRES) - Optimized with indexing
+   * Time complexity: O(selectedPlugins) instead of O(rules × plugins)
    *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
    * @param pluginNames - Set des noms de plugins pour lookup rapide
    * @param rules - Règles applicables
    * @param ctx - Contexte du projet (optionnel)
@@ -373,15 +642,13 @@ var CompatibilityValidator = class {
    *
    * @internal
    */
-  checkDependencies(_plugins, pluginNames, rules = this.rules, ctx) {
+  checkDependencies(pluginNames, _rules = this.rules, ctx) {
     const errors = [];
-    for (const rule of rules) {
+    const dependencyRules = this.validationIndex.dependencies.getAllDependencies(pluginNames);
+    for (const rule of dependencyRules) {
       if (rule.type !== "REQUIRES" || !rule.plugin || !rule.requires) {
         continue;
       }
-      if (!pluginNames.has(rule.plugin)) {
-        continue;
-      }
       const missingDependencies = [];
       for (const dep of rule.requires) {
         const pluginName = dep.split("@")[0];
@@ -412,24 +679,22 @@ var CompatibilityValidator = class {
     return errors;
   }
   /**
-   * Vérifie les recommandations (RECOMMENDS)
+   * Vérifie les recommandations (RECOMMENDS) - Optimized with indexing
+   * Time complexity: O(selectedPlugins) instead of O(rules × plugins)
    *
-   * @param _plugins - Liste des plugins (non utilisée, conservée pour cohérence)
    * @param pluginNames - Set des noms de plugins pour lookup rapide
    * @param rules - Règles applicables
    * @returns Liste des suggestions de plugins recommandés
    *
    * @internal
    */
-  checkRecommendations(_plugins, pluginNames, rules = this.rules) {
+  checkRecommendations(pluginNames, _rules = this.rules) {
     const suggestions = [];
-    for (const rule of rules) {
+    const recommendationRules = this.validationIndex.recommendations.getAllRecommendations(pluginNames);
+    for (const rule of recommendationRules) {
       if (rule.type !== "RECOMMENDS" || !rule.plugin || !rule.recommends) {
         continue;
       }
-      if (!pluginNames.has(rule.plugin)) {
-        continue;
-      }
       const missingRecommendations = rule.recommends.filter(
         (rec) => !pluginNames.has(rec)
       );