@configjs/cli 1.0.2 → 1.0.4

package/dist/{check-KGNJBAPL.js → check-OTK3GSIY.js}

@@ -1,11 +1,14 @@
 import {
   CompatibilityValidator,
   compatibilityRules
-} from "./chunk-SCNFVSYD.js";
+} from "./chunk-G5QBS6TL.js";
 import {
-  logger,
   pluginRegistry
-} from "./chunk-7ZLAP62L.js";
+} from "./chunk-GICPMTU2.js";
+import {
+  logger
+} from "./chunk-5S5KGCVY.js";
+import "./chunk-QGM4M3NI.js";
 
 // src/cli/commands/check.ts
 import { readFile } from "fs/promises";

package/dist/chunk-5S5KGCVY.js

@@ -0,0 +1,276 @@
+// src/utils/logger.ts
+import pc from "picocolors";
+var Logger = class {
+  level = 1 /* INFO */;
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.log(pc.gray(`[DEBUG] ${message}`), ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(pc.blue(`\u2139 ${message}`), ...args);
+    }
+  }
+  success(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(pc.green(`\u2713 ${message}`), ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(pc.yellow(`\u26A0 ${message}`), ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(pc.red(`\u2716 ${message}`), ...args);
+    }
+  }
+  step(message) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(pc.cyan(`
+\u2192 ${message}`));
+    }
+  }
+  box(title, content) {
+    if (this.level <= 1 /* INFO */) {
+      const maxLength = Math.max(
+        title.length,
+        ...content.map((line) => line.length)
+      );
+      const border = "\u2500".repeat(maxLength + 4);
+      console.log(pc.cyan(`\u250C${border}\u2510`));
+      console.log(pc.cyan(`\u2502  ${title.padEnd(maxLength)}  \u2502`));
+      console.log(pc.cyan(`\u251C${border}\u2524`));
+      content.forEach((line) => {
+        console.log(pc.cyan(`\u2502  ${line.padEnd(maxLength)}  \u2502`));
+      });
+      console.log(pc.cyan(`\u2514${border}\u2518`));
+    }
+  }
+};
+var logger = new Logger();
+
+// src/utils/fs-helpers.ts
+import fs from "fs-extra";
+import { resolve, dirname, extname } from "path";
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+async function readPackageJson(root) {
+  const packageJsonPath = resolve(root, "package.json");
+  if (!await fs.pathExists(packageJsonPath)) {
+    throw new Error(`package.json not found at ${packageJsonPath}`);
+  }
+  try {
+    const pkg = await fs.readJson(packageJsonPath);
+    logger.debug(`Read package.json from ${packageJsonPath}`);
+    return pkg;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to read package.json: ${errorMessage}. File may be invalid JSON.`
+    );
+  }
+}
+async function writePackageJson(root, pkg) {
+  const packageJsonPath = resolve(root, "package.json");
+  try {
+    await fs.writeJson(packageJsonPath, pkg, {
+      spaces: 2,
+      EOL: "\n"
+    });
+    logger.debug(`Wrote package.json to ${packageJsonPath}`);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to write package.json: ${errorMessage}`);
+  }
+}
+async function readTsConfig(root) {
+  const possiblePaths = [
+    resolve(root, "tsconfig.json"),
+    resolve(root, "tsconfig.app.json"),
+    resolve(root, "tsconfig.node.json")
+  ];
+  for (const tsconfigPath of possiblePaths) {
+    if (await fs.pathExists(tsconfigPath)) {
+      try {
+        const config = await fs.readJson(tsconfigPath);
+        logger.debug(`Read tsconfig.json from ${tsconfigPath}`);
+        return config;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.warn(
+          `Failed to parse tsconfig.json at ${tsconfigPath}: ${errorMessage}`
+        );
+        return null;
+      }
+    }
+  }
+  logger.debug("No tsconfig.json found");
+  return null;
+}
+async function checkPathExists(path) {
+  const fullPath = resolve(path);
+  return fs.pathExists(fullPath);
+}
+async function ensureDirectory(path) {
+  const fullPath = resolve(path);
+  try {
+    await fs.ensureDir(fullPath);
+    logger.debug(`Ensured directory exists: ${fullPath}`);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to create directory ${fullPath}: ${errorMessage}`);
+  }
+}
+async function readFileContent(filePath, encoding = "utf-8") {
+  const fullPath = resolve(filePath);
+  if (!await fs.pathExists(fullPath)) {
+    throw new Error(`File not found: ${fullPath}`);
+  }
+  try {
+    const content = await fs.readFile(fullPath, encoding);
+    logger.debug(`Read file: ${fullPath}`);
+    return content;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read file ${fullPath}: ${errorMessage}`);
+  }
+}
+async function writeFileContent(filePath, content, encoding = "utf-8") {
+  const fullPath = resolve(filePath);
+  const parentDir = dirname(fullPath);
+  await ensureDirectory(parentDir);
+  try {
+    await fs.writeFile(fullPath, content, encoding);
+    logger.debug(`Wrote file: ${fullPath}`);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to write file ${fullPath}: ${errorMessage}`);
+  }
+}
+
+// src/utils/package-manager.ts
+import { execa } from "execa";
+import fs2 from "fs-extra";
+import { resolve as resolve2, join } from "path";
+async function detectPackageManager(projectRoot) {
+  const root = resolve2(projectRoot);
+  const lockfiles = [
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "package-lock.json", manager: "npm" },
+    { file: "bun.lockb", manager: "bun" }
+  ];
+  for (const { file, manager } of lockfiles) {
+    const lockfilePath = join(root, file);
+    if (await fs2.pathExists(lockfilePath)) {
+      logger.debug(`Detected package manager: ${manager} (found ${file})`);
+      return manager;
+    }
+  }
+  logger.debug("No lockfile found, defaulting to npm");
+  return "npm";
+}
+async function installPackages(packages, options) {
+  if (packages.length === 0) {
+    logger.warn("No packages to install");
+    return { success: true, packages: [] };
+  }
+  const {
+    packageManager,
+    projectRoot,
+    dev = false,
+    exact = false,
+    silent = false
+  } = options;
+  logger.info(
+    `Installing ${packages.length} package(s) with ${packageManager}...`
+  );
+  try {
+    const command = getInstallCommand(packageManager, packages, { dev, exact });
+    const cwd = resolve2(projectRoot);
+    logger.debug(`Executing: ${command.join(" ")} in ${cwd}`);
+    const [cmd, ...args] = command;
+    if (!cmd) {
+      throw new Error("Command is empty");
+    }
+    const result = await execa(cmd, args, {
+      cwd,
+      stdio: silent ? "pipe" : "inherit",
+      env: {
+        ...process.env,
+        // Désactiver les prompts interactifs
+        npm_config_yes: "true",
+        YARN_ENABLE_IMMUTABLE_INSTALLS: "false"
+      }
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Installation failed with exit code ${result.exitCode}`);
+    }
+    logger.success(`Successfully installed ${packages.length} package(s)`);
+    return {
+      success: true,
+      packages
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to install packages: ${errorMessage}`);
+    return {
+      success: false,
+      packages,
+      error: errorMessage
+    };
+  }
+}
+function getInstallCommand(packageManager, packages, options) {
+  const { dev, exact } = options;
+  switch (packageManager) {
+    case "pnpm":
+      return [
+        "pnpm",
+        "add",
+        ...dev ? ["-D"] : [],
+        ...exact ? ["--save-exact"] : [],
+        ...packages
+      ];
+    case "yarn":
+      return [
+        "yarn",
+        "add",
+        ...dev ? ["--dev"] : [],
+        ...exact ? ["--exact"] : [],
+        ...packages
+      ];
+    case "bun":
+      return ["bun", "add", ...dev ? ["--dev"] : [], ...packages];
+    case "npm":
+    default:
+      return [
+        "npm",
+        "install",
+        ...dev ? ["--save-dev"] : [],
+        ...exact ? ["--save-exact"] : [],
+        ...packages
+      ];
+  }
+}
+
+export {
+  logger,
+  normalizePath,
+  readPackageJson,
+  writePackageJson,
+  readTsConfig,
+  checkPathExists,
+  ensureDirectory,
+  readFileContent,
+  writeFileContent,
+  detectPackageManager,
+  installPackages
+};

package/dist/chunk-AMLNK7QR.js

@@ -0,0 +1,417 @@
+import {
+  checkPathExists,
+  detectPackageManager,
+  logger,
+  readFileContent,
+  readPackageJson,
+  readTsConfig,
+  writeFileContent
+} from "./chunk-5S5KGCVY.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/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 {
+  detectContext,
+  PluginTracker
+};