@configjs/cli 1.0.2 → 1.0.4

package/dist/chunk-QGM4M3NI.js

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
+import "./chunk-QGM4M3NI.js";
 
 // src/cli.ts
 import { Command } from "commander";
 
 // package.json
-var version = "1.0.2";
+var version = "1.0.4";
 
 // src/cli.ts
 var program = new Command();
@@ -12,7 +13,7 @@ program.name("confjs").description("Configure your frontend stack, instantly").v
 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-FNUEIZQ2.js");
+      const { installReact } = await import("./install-LJAWO26W.js");
       await installReact(options);
     } catch (error) {
       console.error("Error:", error);
@@ -22,7 +23,7 @@ program.command("react").description("Configure a React project").option("-y, --
 );
 program.command("list").description("List available libraries").option("-c, --category <category>", "Filter by category").action(async (options) => {
   try {
-    const { listLibraries } = await import("./list-CBEUUZUI.js");
+    const { listLibraries } = await import("./list-QC4T762H.js");
     listLibraries(options);
   } catch (error) {
     console.error("Error:", error);
@@ -31,11 +32,29 @@ program.command("list").description("List available libraries").option("-c, --ca
 });
 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-KGNJBAPL.js");
+    const { checkCompatibility } = await import("./check-OTK3GSIY.js");
     await checkCompatibility(options);
   } catch (error) {
     console.error("Error:", error);
     process.exit(1);
   }
 });
+program.command("installed").description("List installed plugins").action(async () => {
+  try {
+    const { installedCommand } = await import("./installed-BXP7ZWOU.js");
+    await installedCommand();
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  }
+});
+program.command("remove <plugin>").description("Remove an installed plugin").action(async (plugin) => {
+  try {
+    const { removeCommand } = await import("./remove-ZZD67W4M.js");
+    await removeCommand(plugin);
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  }
+});
 program.parse(process.argv);

package/dist/{install-FNUEIZQ2.js → install-LJAWO26W.js}

@@ -1,246 +1,22 @@
 import {
   CompatibilityValidator,
   compatibilityRules
-} from "./chunk-SCNFVSYD.js";
+} from "./chunk-G5QBS6TL.js";
 import {
   BackupManager,
   ConfigWriter,
-  checkPathExists,
-  detectPackageManager,
   getPluginsByCategory,
+  pluginRegistry
+} from "./chunk-GICPMTU2.js";
+import {
+  PluginTracker,
+  detectContext
+} from "./chunk-AMLNK7QR.js";
+import {
   installPackages,
-  logger,
-  pluginRegistry,
-  readPackageJson,
-  readTsConfig
-} from "./chunk-7ZLAP62L.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;
-}
+  logger
+} from "./chunk-5S5KGCVY.js";
+import "./chunk-QGM4M3NI.js";
 
 // src/cli/prompts/language.ts
 import inquirer from "inquirer";
@@ -584,7 +360,9 @@ var Installer = class {
     this.validator = validator;
     this.writer = writer;
     this.backupManager = backupManager;
+    this.tracker = new PluginTracker(ctx.projectRoot);
   }
+  tracker;
   /**
    * Installe un ensemble de plugins
    *
@@ -603,8 +381,35 @@ var Installer = class {
     const startTime = Date.now();
     logger.info(`Starting installation of ${plugins.length} plugin(s)`);
     try {
+      await this.tracker.load();
+      const notInstalled = plugins.filter((p) => {
+        const isInstalled = this.tracker.isInstalled(p.name);
+        if (isInstalled) {
+          logger.info(`${p.displayName} is already installed, skipping...`);
+        }
+        return !isInstalled;
+      });
+      if (notInstalled.length === 0) {
+        logger.info("All plugins are already installed");
+        return {
+          success: true,
+          duration: Date.now() - startTime,
+          installed: [],
+          warnings: [],
+          filesCreated: []
+        };
+      }
+      for (const plugin of notInstalled) {
+        const conflicts = this.tracker.checkCategoryConflicts(plugin.category);
+        if (conflicts.length > 0) {
+          const conflictNames = conflicts.map((c) => c.displayName).join(", ");
+          throw new Error(
+            `Cannot install ${plugin.displayName}: conflicts with already installed plugin(s) in category ${plugin.category}: ${conflictNames}. Please remove conflicting plugins first.`
+          );
+        }
+      }
       logger.debug("Validating plugins compatibility...");
-      const validationResult = this.validator.validate(plugins);
+      const validationResult = this.validator.validate(notInstalled);
       if (!validationResult.valid) {
         const errorMessages = validationResult.errors.map((e) => e.message).join("; ");
         throw new Error(
@@ -618,7 +423,7 @@ var Installer = class {
         );
       }
       logger.debug("Resolving dependencies...");
-      const resolved = this.resolveDependencies(plugins);
+      const resolved = this.resolveDependencies(notInstalled);
       const allPlugins = resolved.plugins;
       if (resolved.autoInstalled.length > 0) {
         logger.info(
@@ -663,6 +468,19 @@ var Installer = class {
       }
       logger.debug("Running post-install hooks...");
       await this.runPostInstallHooks(allPlugins);
+      logger.debug("Tracking installed plugins...");
+      for (const plugin of allPlugins) {
+        await this.tracker.addPlugin({
+          name: plugin.name,
+          displayName: plugin.displayName,
+          category: plugin.category,
+          version: plugin.version,
+          packages: {
+            dependencies: [],
+            devDependencies: []
+          }
+        });
+      }
       const duration = Date.now() - startTime;
       const installed = allPlugins.map((p) => p.name);
       logger.info(
@@ -981,8 +799,8 @@ ${t.report.title}`);
     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}`);
+      const version = plugin?.version ? ` (${plugin.version})` : "";
+      console.log(`   \u2713 ${plugin?.displayName || pluginName}${version}`);
     }
     console.log("");
   }

package/dist/installed-BXP7ZWOU.js

@@ -0,0 +1,41 @@
+import {
+  PluginTracker,
+  detectContext
+} from "./chunk-AMLNK7QR.js";
+import {
+  logger
+} from "./chunk-5S5KGCVY.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/cli/commands/installed.ts
+async function installedCommand() {
+  try {
+    const ctx = await detectContext(process.cwd());
+    const tracker = new PluginTracker(ctx.projectRoot);
+    await tracker.load();
+    const installedPlugins = tracker.getInstalledPlugins();
+    if (installedPlugins.length === 0) {
+      console.log("\n\u{1F4E6} No plugins installed yet.\n");
+      console.log("Run `configjs install` to add plugins to your project.\n");
+      return;
+    }
+    console.log(`
+\u{1F4E6} Installed plugins (${installedPlugins.length}):
+`);
+    for (const plugin of installedPlugins) {
+      const date = new Date(plugin.installedAt).toLocaleDateString();
+      console.log(`  \u2713 ${plugin.displayName}`);
+      console.log(`    Category: ${plugin.category.toUpperCase()}`);
+      console.log(`    Version: ${plugin.version || "N/A"}`);
+      console.log(`    Installed: ${date}`);
+      console.log();
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to list installed plugins: ${errorMessage}`);
+    process.exit(1);
+  }
+}
+export {
+  installedCommand
+};

package/dist/{list-CBEUUZUI.js → list-QC4T762H.js}

@@ -1,6 +1,8 @@
 import {
   pluginRegistry
-} from "./chunk-7ZLAP62L.js";
+} from "./chunk-GICPMTU2.js";
+import "./chunk-5S5KGCVY.js";
+import "./chunk-QGM4M3NI.js";
 
 // src/cli/commands/list.ts
 function listLibraries(options) {