@configjs/cli 1.1.16 → 1.1.17

package/dist/{angular-command-XN26G6L3.js → angular-command-WRBFDIV6.js}

@@ -1,24 +1,24 @@
 import {
   BaseFrameworkCommand,
   getFrameworkMetadata
-} from "./chunk-TN27AX4L.js";
-import "./chunk-NYCK4R4K.js";
-import "./chunk-JYWGJJ4M.js";
+} from "./chunk-5FBN3L7R.js";
+import "./chunk-56AR5ZW2.js";
+import "./chunk-IY4KX4KL.js";
 import {
   DetectionError,
   detectContext
-} from "./chunk-UKEHW2LH.js";
-import "./chunk-6GV4NKUX.js";
+} from "./chunk-F3VNGA2S.js";
+import "./chunk-V2IBYLVH.js";
 import "./chunk-KAMPBTFG.js";
-import "./chunk-FIB2J36N.js";
-import "./chunk-QPEUT7QG.js";
+import "./chunk-5NXT5HCC.js";
+import "./chunk-VN4XTFDK.js";
 import {
   getTranslations
 } from "./chunk-L4GX22RG.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/cli/commands/angular-command.ts
-import pc from "picocolors";
+import pc from "chalk";
 var AngularCommand = class extends BaseFrameworkCommand {
   getFramework() {
     return "angular";

package/dist/{angular-installer-FY43HE72.js → angular-installer-TKZDPFLD.js}

@@ -9,9 +9,16 @@ import "./chunk-QGM4M3NI.js";
 // src/cli/utils/angular-installer.ts
 import { spawn } from "child_process";
 import { resolve } from "path";
+function validateProjectName(name) {
+  if (!/^[a-zA-Z0-9._-]+$/.test(name)) return false;
+  return !name.includes("..") && !name.includes("/") && !name.includes("\\");
+}
 async function createAngularProject(options, currentDir, language) {
   const t = getTranslations(language);
   const spinner = new SpinnerManager();
+  if (!validateProjectName(options.projectName)) {
+    throw new Error(`Invalid project name: ${options.projectName}`);
+  }
   const projectPath = resolve(currentDir, options.projectName);
   try {
     spinner.start(t.angular.creatingProject);
@@ -30,7 +37,8 @@ async function createAngularProject(options, currentDir, language) {
     await new Promise((resolve2, reject) => {
       const child = spawn("npx", args, {
         cwd: currentDir,
-        stdio: "pipe"
+        stdio: "pipe",
+        shell: false
       });
       child.on("error", reject);
       child.on("close", (code) => {

package/dist/angular-setup-QDTWXOB4.js

@@ -0,0 +1,30 @@
+import {
+  angularSetupSchema,
+  getValidationErrorMessage,
+  validateInput
+} from "./chunk-EDCNW4UO.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/cli/prompts/angular-setup.ts
+import pc from "chalk";
+function promptAngularSetup() {
+  console.log();
+  console.log(pc.cyan("\u2699\uFE0F  Angular Project Setup"));
+  console.log();
+  const options = {
+    projectName: "my-angular-app",
+    useTypeScript: true,
+    useRouting: true,
+    useStylesheet: "scss"
+  };
+  try {
+    const validated = validateInput(angularSetupSchema, options);
+    return Promise.resolve(validated);
+  } catch (error) {
+    console.error(pc.red(`\u274C ${getValidationErrorMessage(error)}`));
+    throw error;
+  }
+}
+export {
+  promptAngularSetup
+};

package/dist/check-5QZOSS2F.js

@@ -0,0 +1,168 @@
+import {
+  CompatibilityValidator,
+  allCompatibilityRules
+} from "./chunk-56AR5ZW2.js";
+import {
+  ConfigSanitizer,
+  pluginRegistry
+} from "./chunk-IY4KX4KL.js";
+import "./chunk-V2IBYLVH.js";
+import {
+  getPathValidationErrorMessage,
+  validatePathInProjectWithSymlinks
+} from "./chunk-5NXT5HCC.js";
+import {
+  logger
+} from "./chunk-VN4XTFDK.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/cli/commands/check.ts
+import { readFile, pathExists } from "fs-extra";
+import { join, resolve, relative } from "path";
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function parseConfigFile(content) {
+  const parsed = ConfigSanitizer.validateJSON(content);
+  const plugins = parsed["plugins"];
+  if (!Array.isArray(plugins)) {
+    throw new Error(
+      'Le champ "plugins" doit \xEAtre un tableau de noms de packages'
+    );
+  }
+  const normalizedPlugins = plugins.filter(
+    (plugin) => typeof plugin === "string"
+  );
+  if (normalizedPlugins.length !== plugins.length) {
+    throw new Error('Le champ "plugins" doit contenir uniquement des cha\xEEnes');
+  }
+  return { plugins: normalizedPlugins };
+}
+async function readConfigFileSafely(configPath, projectRoot) {
+  const resolvedRoot = resolve(projectRoot);
+  const resolvedConfigPath = resolve(configPath);
+  const relativePath = relative(resolvedRoot, resolvedConfigPath);
+  let safePath = resolvedConfigPath;
+  try {
+    safePath = await validatePathInProjectWithSymlinks(
+      resolvedRoot,
+      relativePath
+    );
+  } catch (error) {
+    const errorMessage = getPathValidationErrorMessage(error);
+    throw new Error(`Chemin de config invalide: ${errorMessage}`);
+  }
+  if (!await pathExists(safePath)) {
+    throw new Error(`Fichier de configuration introuvable: ${safePath}`);
+  }
+  const firstRead = await readFile(safePath, "utf-8");
+  const firstHash = hashContent(firstRead);
+  const secondRead = await readFile(safePath, "utf-8");
+  const secondHash = hashContent(secondRead);
+  if (firstHash !== secondHash) {
+    throw new Error(
+      "Le fichier de configuration a chang\xE9 pendant la lecture (TOCTOU d\xE9tect\xE9). Relancez la commande."
+    );
+  }
+  return parseConfigFile(firstRead);
+}
+async function checkCompatibility(options) {
+  try {
+    logger.header("V\xE9rification de la compatibilit\xE9");
+    const configPath = options.config || join(process.cwd(), ".confjs.json");
+    let config;
+    try {
+      config = await readConfigFileSafely(configPath, process.cwd());
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(
+        `Erreur de lecture du fichier de configuration: ${errorMessage}`
+      );
+      logger.info("Cr\xE9ez un fichier .confjs.json avec le format suivant:");
+      logger.info(
+        JSON.stringify(
+          {
+            plugins: ["react-router-dom", "zustand", "tailwindcss"]
+          },
+          null,
+          2
+        )
+      );
+      process.exit(1);
+    }
+    if (!config.plugins || !Array.isArray(config.plugins)) {
+      logger.error("Format de configuration invalide");
+      logger.info('Le champ "plugins" doit \xEAtre un tableau de noms de packages');
+      process.exit(1);
+    }
+    const selectedPlugins = config.plugins.map((name) => pluginRegistry.find((p) => p.name === name)).filter(Boolean);
+    if (selectedPlugins.length === 0) {
+      logger.error("Aucun plugin valide trouv\xE9 dans la configuration");
+      process.exit(1);
+    }
+    const notFound = config.plugins.filter(
+      (name) => !pluginRegistry.find((p) => p.name === name)
+    );
+    if (notFound.length > 0) {
+      logger.warn("Plugins non trouv\xE9s:");
+      for (const name of notFound) {
+        logger.item(name, "yellow");
+      }
+    }
+    logger.section(`Plugins \xE0 v\xE9rifier: ${selectedPlugins.length}`);
+    for (const plugin of selectedPlugins) {
+      if (plugin) {
+        logger.item(`${plugin.displayName} (${plugin.name})`, "blue");
+      }
+    }
+    logger.section("Analyse de compatibilit\xE9...");
+    const validator = new CompatibilityValidator(allCompatibilityRules);
+    const validation = validator.validate(
+      selectedPlugins
+    );
+    if (validation.errors.length === 0) {
+      logger.success("Aucun conflit d\xE9tect\xE9");
+    } else {
+      logger.error("Conflits d\xE9tect\xE9s:");
+      for (const error of validation.errors) {
+        logger.item(error.message, "yellow");
+        if ("plugins" in error && error.plugins) {
+          logger.dim(`Plugins: ${error.plugins.join(", ")}`);
+        }
+      }
+    }
+    if (validation.warnings.length > 0) {
+      logger.warn("Avertissements:");
+      for (const warning of validation.warnings) {
+        logger.item(warning.message, "yellow");
+        if ("plugins" in warning && warning.plugins) {
+          logger.dim(`Plugins: ${warning.plugins.join(", ")}`);
+        }
+      }
+    }
+    if (validation.suggestions.length > 0) {
+      logger.info("Suggestions:");
+      for (const suggestion of validation.suggestions) {
+        logger.item(suggestion, "blue");
+      }
+    }
+    if (validation.valid) {
+      logger.success(
+        "Configuration valide. Vous pouvez proc\xE9der \xE0 l'installation."
+      );
+      process.exit(0);
+    } else {
+      logger.error(
+        "Configuration invalide. Corrigez les erreurs avant d'installer."
+      );
+      process.exit(2);
+    }
+  } catch (error) {
+    logger.error("Erreur lors de la v\xE9rification:", error);
+    process.exit(1);
+  }
+}
+export {
+  checkCompatibility
+};