@configjs/cli 1.1.3 → 1.1.5

package/dist/{chunk-ZSDLWQSS.js → chunk-TVZWTKJU.js}

@@ -1,15 +1,200 @@
+import {
+  detectPackageManager
+} from "./chunk-MQV3WNMH.js";
 import {
   checkPathExists,
-  detectPackageManager,
+  createDefaultFsAdapter,
   logger,
   readFileContent,
   readPackageJson,
   readTsConfig,
   writeFileContent
-} from "./chunk-QRFLHLFE.js";
+} from "./chunk-HM2JWJOO.js";
+
+// src/core/plugin-tracker.ts
+import { join } from "path";
+var CONFIG_FILE_NAME = ".configjsrc";
+var CONFIG_VERSION = "1.0.0";
+var PluginTracker = class {
+  configPath;
+  config = null;
+  fsAdapter;
+  constructor(projectRoot, fsAdapter) {
+    this.configPath = join(projectRoot, CONFIG_FILE_NAME);
+    this.fsAdapter = fsAdapter;
+  }
+  /**
+   * Charge la configuration depuis le fichier
+   */
+  async load() {
+    try {
+      const exists = await checkPathExists(this.configPath, this.fsAdapter);
+      if (!exists) {
+        this.config = {
+          version: CONFIG_VERSION,
+          installedPlugins: [],
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return;
+      }
+      const content = await readFileContent(
+        this.configPath,
+        "utf-8",
+        this.fsAdapter
+      );
+      this.config = JSON.parse(content);
+      if (!this.config.version) {
+        logger.warn("Old config format detected, migrating...");
+        this.config.version = CONFIG_VERSION;
+        await this.save();
+      }
+    } catch (error) {
+      logger.error("Failed to load plugin configuration", error);
+      this.config = {
+        version: CONFIG_VERSION,
+        installedPlugins: [],
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  /**
+   * Sauvegarde la configuration dans le fichier
+   */
+  async save() {
+    if (!this.config) {
+      throw new Error("Configuration not loaded");
+    }
+    this.config.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const content = JSON.stringify(this.config, null, 2);
+      await writeFileContent(this.configPath, content, "utf-8", this.fsAdapter);
+    } catch (error) {
+      logger.error("Failed to save plugin configuration", error);
+      throw error;
+    }
+  }
+  /**
+   * Vérifie si un plugin est déjà installé
+   */
+  isInstalled(pluginName) {
+    if (!this.config) {
+      return false;
+    }
+    return this.config.installedPlugins.some((p) => p.name === pluginName);
+  }
+  /**
+   * Récupère les informations d'un plugin installé
+   */
+  getPlugin(pluginName) {
+    if (!this.config) {
+      return void 0;
+    }
+    return this.config.installedPlugins.find((p) => p.name === pluginName);
+  }
+  /**
+   * Récupère tous les plugins installés
+   */
+  getInstalledPlugins() {
+    return this.config?.installedPlugins || [];
+  }
+  /**
+   * Récupère tous les plugins installés d'une catégorie donnée
+   */
+  getPluginsByCategory(category) {
+    if (!this.config) {
+      return [];
+    }
+    return this.config.installedPlugins.filter((p) => p.category === category);
+  }
+  /**
+   * Ajoute un plugin à la liste des installés
+   */
+  async addPlugin(plugin) {
+    if (!this.config) {
+      throw new Error("Configuration not loaded");
+    }
+    if (this.isInstalled(plugin.name)) {
+      logger.warn(`Plugin ${plugin.name} is already marked as installed`);
+      return;
+    }
+    const installedPlugin = {
+      ...plugin,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.config.installedPlugins.push(installedPlugin);
+    await this.save();
+    logger.debug(`Marked plugin ${plugin.name} as installed`);
+  }
+  /**
+   * Supprime un plugin de la liste des installés
+   */
+  async removePlugin(pluginName) {
+    if (!this.config) {
+      throw new Error("Configuration not loaded");
+    }
+    const index = this.config.installedPlugins.findIndex(
+      (p) => p.name === pluginName
+    );
+    if (index === -1) {
+      logger.warn(`Plugin ${pluginName} not found in installed plugins`);
+      return;
+    }
+    this.config.installedPlugins.splice(index, 1);
+    await this.save();
+    logger.debug(`Removed plugin ${pluginName} from installed plugins`);
+  }
+  /**
+   * Met à jour les informations d'un plugin installé
+   */
+  async updatePlugin(pluginName, updates) {
+    if (!this.config) {
+      throw new Error("Configuration not loaded");
+    }
+    const plugin = this.config.installedPlugins.find(
+      (p) => p.name === pluginName
+    );
+    if (!plugin) {
+      throw new Error(`Plugin ${pluginName} not found`);
+    }
+    Object.assign(plugin, updates);
+    await this.save();
+    logger.debug(`Updated plugin ${pluginName}`);
+  }
+  /**
+   * Efface toute la configuration
+   */
+  async reset() {
+    this.config = {
+      version: CONFIG_VERSION,
+      installedPlugins: [],
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.save();
+    logger.info("Reset plugin configuration");
+  }
+  /**
+   * Vérifie les conflits potentiels avec un nouveau plugin
+   *
+   * @param category - Catégorie du plugin à installer
+   * @param exclusiveCategories - Catégories qui ne peuvent avoir qu'un seul plugin
+   * @returns Liste des plugins en conflit
+   */
+  checkCategoryConflicts(category, exclusiveCategories = ["routing", "state"]) {
+    if (!exclusiveCategories.includes(category)) {
+      return [];
+    }
+    return this.getPluginsByCategory(category);
+  }
+  /**
+   * Exporte la configuration pour affichage ou debug
+   */
+  export() {
+    return this.config;
+  }
+};
 
 // src/core/detector.ts
-import { resolve, join } from "path";
+import { resolve, join as join2 } from "path";
 import { platform, version } from "process";
 var detectionCache = /* @__PURE__ */ new Map();
 var DetectionError = class extends Error {
@@ -24,6 +209,12 @@ function detectFramework(pkg) {
     ...pkg["dependencies"] || {},
     ...pkg["devDependencies"] || {}
   };
+  if (deps["next"]) {
+    return {
+      framework: "nextjs",
+      version: deps["next"].replace(/[\^~]/, "")
+    };
+  }
   if (deps["react"]) {
     return {
       framework: "react",
@@ -31,9 +222,17 @@ function detectFramework(pkg) {
     };
   }
   if (deps["vue"]) {
+    const version2 = deps["vue"].replace(/[\^~]/, "");
+    const majorVersion = parseInt(version2.split(".")[0] || "0", 10);
+    if (majorVersion < 3) {
+      throw new DetectionError(
+        "Vue 2 is not supported. Please use Vue 3 (Vue 2 is not compatible with Vite).",
+        { vueVersion: version2 }
+      );
+    }
     return {
       framework: "vue",
-      version: deps["vue"].replace(/[\^~]/, "")
+      version: version2
     };
   }
   if (deps["svelte"]) {
@@ -43,17 +242,32 @@ function detectFramework(pkg) {
     };
   }
   throw new DetectionError(
-    "No supported framework detected. Supported frameworks: React, Vue, Svelte",
+    "No supported framework detected. Supported frameworks: Next.js, React, Vue, Svelte",
     { dependencies: Object.keys(deps) }
   );
 }
-async function detectBundler(projectRoot, pkg) {
+async function detectBundler(projectRoot, pkg, fsAdapter) {
   const deps = {
     ...pkg["dependencies"] || {},
     ...pkg["devDependencies"] || {}
   };
+  if (deps["next"]) {
+    const nextConfigExists = await checkPathExists(join2(projectRoot, "next.config.js"), fsAdapter) || await checkPathExists(join2(projectRoot, "next.config.ts"), fsAdapter) || await checkPathExists(
+      join2(projectRoot, "next.config.mjs"),
+      fsAdapter
+    ) || await checkPathExists(join2(projectRoot, "next.config.cjs"), fsAdapter);
+    if (nextConfigExists) {
+      return {
+        bundler: "nextjs",
+        version: deps["next"].replace(/[\^~]/, "")
+      };
+    }
+  }
   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"));
+    const viteConfigExists = await checkPathExists(join2(projectRoot, "vite.config.js"), fsAdapter) || await checkPathExists(join2(projectRoot, "vite.config.ts"), fsAdapter) || await checkPathExists(
+      join2(projectRoot, "vite.config.mjs"),
+      fsAdapter
+    ) || await checkPathExists(join2(projectRoot, "vite.config.cjs"), fsAdapter);
     if (viteConfigExists) {
       return {
         bundler: "vite",
@@ -61,6 +275,19 @@ async function detectBundler(projectRoot, pkg) {
       };
     }
   }
+  if (deps["vue"] && deps["@vue/cli-service"]) {
+    const vueConfigExists = await checkPathExists(
+      join2(projectRoot, "vue.config.js"),
+      fsAdapter
+    );
+    if (vueConfigExists) {
+      return {
+        bundler: "webpack",
+        // Vue CLI utilise Webpack
+        version: deps["@vue/cli-service"].replace(/[\^~]/, "")
+      };
+    }
+  }
   if (deps["react-scripts"]) {
     return {
       bundler: "cra",
@@ -68,7 +295,10 @@ async function detectBundler(projectRoot, pkg) {
     };
   }
   if (deps["webpack"]) {
-    const webpackConfigExists = await checkPathExists(join(projectRoot, "webpack.config.js")) || await checkPathExists(join(projectRoot, "webpack.config.ts"));
+    const webpackConfigExists = await checkPathExists(
+      join2(projectRoot, "webpack.config.js"),
+      fsAdapter
+    ) || await checkPathExists(join2(projectRoot, "webpack.config.ts"), fsAdapter);
     if (webpackConfigExists) {
       return {
         bundler: "webpack",
@@ -87,16 +317,16 @@ async function detectBundler(projectRoot, pkg) {
     version: null
   };
 }
-async function detectTypeScript(projectRoot) {
-  const tsConfig = await readTsConfig(projectRoot);
+async function detectTypeScript(projectRoot, fsAdapter) {
+  const tsConfig = await readTsConfig(projectRoot, fsAdapter);
   if (tsConfig) {
     const possiblePaths = [
-      join(projectRoot, "tsconfig.json"),
-      join(projectRoot, "tsconfig.app.json"),
-      join(projectRoot, "tsconfig.node.json")
+      join2(projectRoot, "tsconfig.json"),
+      join2(projectRoot, "tsconfig.app.json"),
+      join2(projectRoot, "tsconfig.node.json")
     ];
     for (const path of possiblePaths) {
-      if (await checkPathExists(path)) {
+      if (await checkPathExists(path, fsAdapter)) {
         return {
           typescript: true,
           tsconfigPath: path
@@ -105,47 +335,108 @@ async function detectTypeScript(projectRoot) {
     }
     return {
       typescript: true,
-      tsconfigPath: join(projectRoot, "tsconfig.json")
+      tsconfigPath: join2(projectRoot, "tsconfig.json")
     };
   }
   return {
     typescript: false
   };
 }
-async function detectSrcDir(projectRoot) {
+async function detectSrcDir(projectRoot, fsAdapter) {
   const possibleDirs = ["src", "app", "source", "lib"];
   for (const dir of possibleDirs) {
-    const dirPath = join(projectRoot, dir);
-    if (await checkPathExists(dirPath)) {
+    const dirPath = join2(projectRoot, dir);
+    if (await checkPathExists(dirPath, fsAdapter)) {
       return dir;
     }
   }
   return "src";
 }
-async function detectPublicDir(projectRoot) {
+async function detectPublicDir(projectRoot, fsAdapter) {
   const possibleDirs = ["public", "static", "assets"];
   for (const dir of possibleDirs) {
-    const dirPath = join(projectRoot, dir);
-    if (await checkPathExists(dirPath)) {
+    const dirPath = join2(projectRoot, dir);
+    if (await checkPathExists(dirPath, fsAdapter)) {
       return dir;
     }
   }
   return "public";
 }
-async function detectGit(projectRoot) {
-  const gitDir = join(projectRoot, ".git");
-  const hasGit = await checkPathExists(gitDir);
+async function detectNextjsRouter(projectRoot, srcDir, fsAdapter) {
+  const appDirInSrc = join2(projectRoot, srcDir, "app");
+  const pagesDirInSrc = join2(projectRoot, srcDir, "pages");
+  const appDirAtRoot = join2(projectRoot, "app");
+  const pagesDirAtRoot = join2(projectRoot, "pages");
+  const appDirExists = await checkPathExists(appDirInSrc, fsAdapter) || await checkPathExists(appDirAtRoot, fsAdapter);
+  const pagesDirExists = await checkPathExists(pagesDirInSrc, fsAdapter) || await checkPathExists(pagesDirAtRoot, fsAdapter);
+  if (appDirExists) {
+    return "app";
+  }
+  if (pagesDirExists) {
+    return "pages";
+  }
+  return void 0;
+}
+async function detectVueApi(projectRoot, srcDir, fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const srcPath = join2(projectRoot, srcDir);
+  if (!await checkPathExists(srcPath, adapter)) {
+    return void 0;
+  }
+  try {
+    const files = [];
+    async function findVueFiles(dir) {
+      const entries = await adapter.readdir(dir);
+      for (const entryName of entries) {
+        const fullPath = join2(dir, entryName);
+        const stat = await adapter.stat(fullPath);
+        if (stat.isDirectory()) {
+          await findVueFiles(fullPath);
+        } else if (entryName.endsWith(".vue")) {
+          files.push(fullPath);
+        }
+      }
+    }
+    await findVueFiles(srcPath);
+    let hasCompositionApi = false;
+    let hasOptionsApi = false;
+    for (const file of files.slice(0, 10)) {
+      try {
+        const content = await adapter.readFile(file, "utf-8");
+        if (content.includes("<script setup>") || content.includes('<script setup lang="ts">') || content.includes("export default defineComponent") || content.includes("setup()")) {
+          hasCompositionApi = true;
+        }
+        if (content.includes("export default {") || content.includes("export default{")) {
+          hasOptionsApi = true;
+        }
+      } catch {
+      }
+    }
+    if (hasCompositionApi) {
+      return "composition";
+    }
+    if (hasOptionsApi) {
+      return "options";
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function detectGit(projectRoot, fsAdapter) {
+  const gitDir = join2(projectRoot, ".git");
+  const hasGit = await checkPathExists(gitDir, fsAdapter);
   if (!hasGit) {
     return { hasGit: false };
   }
-  const hooksPath = join(gitDir, "hooks");
-  const hasHooks = await checkPathExists(hooksPath);
+  const hooksPath = join2(gitDir, "hooks");
+  const hasHooks = await checkPathExists(hooksPath, fsAdapter);
   return {
     hasGit: true,
     gitHooksPath: hasHooks ? hooksPath : void 0
   };
 }
-async function detectLockfile(projectRoot, packageManager) {
+async function detectLockfile(projectRoot, packageManager, fsAdapter) {
   const lockfiles = {
     npm: "package-lock.json",
     yarn: "yarn.lock",
@@ -153,13 +444,13 @@ async function detectLockfile(projectRoot, packageManager) {
     bun: "bun.lockb"
   };
   const lockfile = lockfiles[packageManager];
-  const lockfilePath = join(projectRoot, lockfile);
-  if (await checkPathExists(lockfilePath)) {
+  const lockfilePath = join2(projectRoot, lockfile);
+  if (await checkPathExists(lockfilePath, fsAdapter)) {
     return lockfile;
   }
   return lockfile;
 }
-async function detectContext(projectRoot) {
+async function detectContext(projectRoot, fsAdapter) {
   const fullPath = resolve(projectRoot);
   if (detectionCache.has(fullPath)) {
     logger.debug(`Using cached context for ${fullPath}`);
@@ -171,7 +462,7 @@ async function detectContext(projectRoot) {
   logger.debug(`Detecting context for project: ${fullPath}`);
   let pkg;
   try {
-    pkg = await readPackageJson(fullPath);
+    pkg = await readPackageJson(fullPath, fsAdapter);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     throw new DetectionError(
@@ -189,14 +480,17 @@ async function detectContext(projectRoot) {
     gitInfo
   ] = await Promise.all([
     Promise.resolve(detectFramework(pkg)),
-    detectTypeScript(fullPath),
-    detectBundler(fullPath, pkg),
+    detectTypeScript(fullPath, fsAdapter),
+    detectBundler(fullPath, pkg, fsAdapter),
     detectPackageManager(fullPath),
-    detectSrcDir(fullPath),
-    detectPublicDir(fullPath),
-    detectGit(fullPath)
+    detectSrcDir(fullPath, fsAdapter),
+    detectPublicDir(fullPath, fsAdapter),
+    detectGit(fullPath, fsAdapter)
   ]);
-  const lockfile = await detectLockfile(fullPath, packageManager);
+  const lockfile = await detectLockfile(fullPath, packageManager, fsAdapter);
+  const nextjsRouter = frameworkInfo.framework === "nextjs" ? await detectNextjsRouter(fullPath, srcDir, fsAdapter) : void 0;
+  const vueVersion = frameworkInfo.framework === "vue" ? "3" : void 0;
+  const vueApi = frameworkInfo.framework === "vue" ? await detectVueApi(fullPath, srcDir, fsAdapter) : void 0;
   const dependencies = pkg["dependencies"] || {};
   const devDependencies = pkg["devDependencies"] || {};
   const context = {
@@ -224,7 +518,14 @@ async function detectContext(projectRoot) {
     devDependencies,
     // Git
     hasGit: gitInfo.hasGit,
-    gitHooksPath: gitInfo.gitHooksPath
+    gitHooksPath: gitInfo.gitHooksPath,
+    // Next.js specific
+    nextjsRouter,
+    // Vue.js specific
+    vueVersion,
+    vueApi,
+    // Filesystem adapter (for testing with memfs)
+    fsAdapter
   };
   detectionCache.set(fullPath, context);
   logger.debug(`Context detected successfully for ${fullPath}`, {
@@ -235,184 +536,8 @@ async function detectContext(projectRoot) {
   return context;
 }
 
-// src/core/plugin-tracker.ts
-import { join as join2 } from "path";
-var CONFIG_FILE_NAME = ".configjsrc";
-var CONFIG_VERSION = "1.0.0";
-var PluginTracker = class {
-  configPath;
-  config = null;
-  constructor(projectRoot) {
-    this.configPath = join2(projectRoot, CONFIG_FILE_NAME);
-  }
-  /**
-   * Charge la configuration depuis le fichier
-   */
-  async load() {
-    try {
-      const exists = await checkPathExists(this.configPath);
-      if (!exists) {
-        this.config = {
-          version: CONFIG_VERSION,
-          installedPlugins: [],
-          lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        return;
-      }
-      const content = await readFileContent(this.configPath);
-      this.config = JSON.parse(content);
-      if (!this.config.version) {
-        logger.warn("Old config format detected, migrating...");
-        this.config.version = CONFIG_VERSION;
-        await this.save();
-      }
-    } catch (error) {
-      logger.error("Failed to load plugin configuration", error);
-      this.config = {
-        version: CONFIG_VERSION,
-        installedPlugins: [],
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    }
-  }
-  /**
-   * Sauvegarde la configuration dans le fichier
-   */
-  async save() {
-    if (!this.config) {
-      throw new Error("Configuration not loaded");
-    }
-    this.config.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    try {
-      const content = JSON.stringify(this.config, null, 2);
-      await writeFileContent(this.configPath, content);
-    } catch (error) {
-      logger.error("Failed to save plugin configuration", error);
-      throw error;
-    }
-  }
-  /**
-   * Vérifie si un plugin est déjà installé
-   */
-  isInstalled(pluginName) {
-    if (!this.config) {
-      return false;
-    }
-    return this.config.installedPlugins.some((p) => p.name === pluginName);
-  }
-  /**
-   * Récupère les informations d'un plugin installé
-   */
-  getPlugin(pluginName) {
-    if (!this.config) {
-      return void 0;
-    }
-    return this.config.installedPlugins.find((p) => p.name === pluginName);
-  }
-  /**
-   * Récupère tous les plugins installés
-   */
-  getInstalledPlugins() {
-    return this.config?.installedPlugins || [];
-  }
-  /**
-   * Récupère tous les plugins installés d'une catégorie donnée
-   */
-  getPluginsByCategory(category) {
-    if (!this.config) {
-      return [];
-    }
-    return this.config.installedPlugins.filter((p) => p.category === category);
-  }
-  /**
-   * Ajoute un plugin à la liste des installés
-   */
-  async addPlugin(plugin) {
-    if (!this.config) {
-      throw new Error("Configuration not loaded");
-    }
-    if (this.isInstalled(plugin.name)) {
-      logger.warn(`Plugin ${plugin.name} is already marked as installed`);
-      return;
-    }
-    const installedPlugin = {
-      ...plugin,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.config.installedPlugins.push(installedPlugin);
-    await this.save();
-    logger.debug(`Marked plugin ${plugin.name} as installed`);
-  }
-  /**
-   * Supprime un plugin de la liste des installés
-   */
-  async removePlugin(pluginName) {
-    if (!this.config) {
-      throw new Error("Configuration not loaded");
-    }
-    const index = this.config.installedPlugins.findIndex(
-      (p) => p.name === pluginName
-    );
-    if (index === -1) {
-      logger.warn(`Plugin ${pluginName} not found in installed plugins`);
-      return;
-    }
-    this.config.installedPlugins.splice(index, 1);
-    await this.save();
-    logger.debug(`Removed plugin ${pluginName} from installed plugins`);
-  }
-  /**
-   * Met à jour les informations d'un plugin installé
-   */
-  async updatePlugin(pluginName, updates) {
-    if (!this.config) {
-      throw new Error("Configuration not loaded");
-    }
-    const plugin = this.config.installedPlugins.find(
-      (p) => p.name === pluginName
-    );
-    if (!plugin) {
-      throw new Error(`Plugin ${pluginName} not found`);
-    }
-    Object.assign(plugin, updates);
-    await this.save();
-    logger.debug(`Updated plugin ${pluginName}`);
-  }
-  /**
-   * Efface toute la configuration
-   */
-  async reset() {
-    this.config = {
-      version: CONFIG_VERSION,
-      installedPlugins: [],
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await this.save();
-    logger.info("Reset plugin configuration");
-  }
-  /**
-   * Vérifie les conflits potentiels avec un nouveau plugin
-   *
-   * @param category - Catégorie du plugin à installer
-   * @param exclusiveCategories - Catégories qui ne peuvent avoir qu'un seul plugin
-   * @returns Liste des plugins en conflit
-   */
-  checkCategoryConflicts(category, exclusiveCategories = ["routing", "state"]) {
-    if (!exclusiveCategories.includes(category)) {
-      return [];
-    }
-    return this.getPluginsByCategory(category);
-  }
-  /**
-   * Exporte la configuration pour affichage ou debug
-   */
-  export() {
-    return this.config;
-  }
-};
-
 export {
+  PluginTracker,
   DetectionError,
-  detectContext,
-  PluginTracker
+  detectContext
 };