@configjs/cli 1.1.4 → 1.1.5

package/dist/chunk-HM2JWJOO.js

@@ -0,0 +1,418 @@
+// 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.cyan(`\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\uFE0F  ${message}`), ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(pc.red(`\u2716 ${message}`), ...args);
+    }
+  }
+  header(message) {
+    if (this.level <= 1 /* INFO */) {
+      console.log();
+      console.log(pc.bold(pc.magenta(`\u25C6 ${message}`)));
+      console.log();
+    }
+  }
+  section(title) {
+    if (this.level <= 1 /* INFO */) {
+      console.log();
+      console.log(pc.bold(pc.cyan(`\u25B8 ${title}`)));
+    }
+  }
+  item(message, color = "gray") {
+    if (this.level <= 1 /* INFO */) {
+      const colorFn = pc[color];
+      console.log(colorFn(`  \u2022 ${message}`));
+    }
+  }
+  dim(message) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(pc.gray(`  ${message}`));
+    }
+  }
+  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 { resolve as resolve2, dirname as dirname2, extname } from "path";
+
+// src/core/fs-adapter.ts
+import fs from "fs-extra";
+import { resolve, dirname } from "path";
+var FileSystemAdapter = class {
+  /**
+   * @param fsImpl - Implémentation du filesystem (memfs) ou undefined pour fs-extra
+   */
+  constructor(fsImpl) {
+    this.fsImpl = fsImpl;
+  }
+  /**
+   * Obtient l'implémentation du filesystem
+   */
+  getFs() {
+    return this.fsImpl || fs;
+  }
+  /**
+   * Normalise un chemin (résout les chemins relatifs)
+   */
+  normalizePath(path) {
+    return resolve(path);
+  }
+  // ===== Async Operations =====
+  async readFile(path, encoding = "utf-8") {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      const content = await implementation.promises.readFile(fullPath, encoding);
+      if (typeof content === "string") {
+        return content;
+      }
+      const buffer = content;
+      return buffer.toString(encoding);
+    } else {
+      const content = await fs.readFile(fullPath, encoding);
+      if (typeof content === "string") {
+        return content;
+      }
+      const buffer = content;
+      return buffer.toString(encoding);
+    }
+  }
+  async writeFile(path, content, encoding = "utf-8") {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    const parentDir = dirname(fullPath);
+    await this.mkdir(parentDir, { recursive: true });
+    if (this.fsImpl) {
+      await implementation.promises.writeFile(fullPath, content, encoding);
+    } else {
+      await fs.writeFile(fullPath, content, encoding);
+    }
+  }
+  async mkdir(path, _options) {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      await implementation.promises.mkdir(fullPath, { recursive: true });
+    } else {
+      await fs.ensureDir(fullPath);
+    }
+  }
+  async readdir(path) {
+    const fullPath = this.normalizePath(path);
+    if (this.fsImpl) {
+      const entries = this.fsImpl.readdirSync(fullPath);
+      return Promise.resolve(entries.map((entry) => String(entry)));
+    } else {
+      return await fs.readdir(fullPath);
+    }
+  }
+  async stat(path) {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      const stats = await implementation.promises.stat(fullPath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        mtime: stats.mtime
+      };
+    } else {
+      const stats = await fs.stat(fullPath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        mtime: stats.mtime
+      };
+    }
+  }
+  async pathExists(path) {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      try {
+        await implementation.promises.access(fullPath);
+        return true;
+      } catch {
+        return false;
+      }
+    } else {
+      return await fs.pathExists(fullPath);
+    }
+  }
+  async readJson(path) {
+    const fullPath = this.normalizePath(path);
+    if (this.fsImpl) {
+      const content = await this.readFile(fullPath);
+      return JSON.parse(content);
+    } else {
+      return await fs.readJson(fullPath);
+    }
+  }
+  async writeJson(path, data, options) {
+    const fullPath = this.normalizePath(path);
+    const parentDir = dirname(fullPath);
+    await this.mkdir(parentDir, { recursive: true });
+    if (this.fsImpl) {
+      const content = JSON.stringify(data, null, options?.spaces ?? 2);
+      await this.writeFile(fullPath, content);
+    } else {
+      await fs.writeJson(fullPath, data, {
+        spaces: options?.spaces ?? 2,
+        EOL: options?.EOL ?? "\n"
+      });
+    }
+  }
+  async copyFile(src, dest) {
+    const srcPath = this.normalizePath(src);
+    const destPath = this.normalizePath(dest);
+    const destDir = dirname(destPath);
+    await this.mkdir(destDir, { recursive: true });
+    if (this.fsImpl) {
+      const content = await this.readFile(srcPath);
+      await this.writeFile(destPath, content);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+  async remove(path) {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      try {
+        const stats = await this.stat(fullPath);
+        if (stats.isDirectory()) {
+          await implementation.promises.rm(fullPath, { recursive: true });
+        } else {
+          await implementation.promises.unlink(fullPath);
+        }
+      } catch {
+      }
+    } else {
+      await fs.remove(fullPath);
+    }
+  }
+  // ===== Sync Operations (pour compatibilité) =====
+  readFileSync(path, encoding = "utf-8") {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      const content = implementation.readFileSync(fullPath, encoding);
+      if (typeof content === "string") {
+        return content;
+      }
+      const buffer = content;
+      return buffer.toString(encoding);
+    } else {
+      const content = fs.readFileSync(fullPath, encoding);
+      if (typeof content === "string") {
+        return content;
+      }
+      const buffer = content;
+      return buffer.toString(encoding);
+    }
+  }
+  writeFileSync(path, content) {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    const parentDir = dirname(fullPath);
+    if (!this.existsSync(parentDir)) {
+      this.mkdirSync(parentDir, { recursive: true });
+    }
+    if (this.fsImpl) {
+      implementation.writeFileSync(fullPath, content);
+    } else {
+      fs.writeFileSync(fullPath, content);
+    }
+  }
+  existsSync(path) {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      try {
+        implementation.statSync(fullPath);
+        return true;
+      } catch {
+        return false;
+      }
+    } else {
+      return fs.existsSync(fullPath);
+    }
+  }
+  mkdirSync(path, _options) {
+    const fullPath = this.normalizePath(path);
+    const implementation = this.getFs();
+    if (this.fsImpl) {
+      implementation.mkdirSync(fullPath, { recursive: true });
+    } else {
+      fs.ensureDirSync(fullPath);
+    }
+  }
+};
+function createDefaultFsAdapter() {
+  return new FileSystemAdapter();
+}
+
+// src/utils/fs-helpers.ts
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+async function readPackageJson(root, fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const packageJsonPath = resolve2(root, "package.json");
+  if (!await adapter.pathExists(packageJsonPath)) {
+    throw new Error(`package.json not found at ${packageJsonPath}`);
+  }
+  try {
+    const pkg = await adapter.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, fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const packageJsonPath = resolve2(root, "package.json");
+  try {
+    await adapter.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, fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const possiblePaths = [
+    resolve2(root, "tsconfig.json"),
+    resolve2(root, "tsconfig.app.json"),
+    resolve2(root, "tsconfig.node.json")
+  ];
+  for (const tsconfigPath of possiblePaths) {
+    if (await adapter.pathExists(tsconfigPath)) {
+      try {
+        const config = await adapter.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, fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const fullPath = resolve2(path);
+  return adapter.pathExists(fullPath);
+}
+async function ensureDirectory(path, fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const fullPath = resolve2(path);
+  try {
+    await adapter.mkdir(fullPath, { recursive: true });
+    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", fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const fullPath = resolve2(filePath);
+  if (!await adapter.pathExists(fullPath)) {
+    throw new Error(`File not found: ${fullPath}`);
+  }
+  try {
+    const content = await adapter.readFile(fullPath, encoding || "utf-8");
+    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", fsAdapter) {
+  const adapter = fsAdapter || createDefaultFsAdapter();
+  const fullPath = resolve2(filePath);
+  const parentDir = dirname2(fullPath);
+  await ensureDirectory(parentDir, adapter);
+  try {
+    await adapter.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}`);
+  }
+}
+
+export {
+  logger,
+  createDefaultFsAdapter,
+  normalizePath,
+  readPackageJson,
+  writePackageJson,
+  readTsConfig,
+  checkPathExists,
+  ensureDirectory,
+  readFileContent,
+  writeFileContent
+};

package/dist/chunk-MQV3WNMH.js

@@ -0,0 +1,114 @@
+import {
+  logger
+} from "./chunk-HM2JWJOO.js";
+
+// src/utils/package-manager.ts
+import { execa } from "execa";
+import fs from "fs-extra";
+import { resolve, join } from "path";
+async function detectPackageManager(projectRoot) {
+  const root = resolve(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 fs.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 = resolve(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 {
+  detectPackageManager,
+  installPackages
+};