nestcraftx 0.2.6 → 0.4.0

package/utils/setups/setupPrisma.js

@@ -86,36 +86,41 @@ async function setupPrisma(inputs) {
     for (const relation of inputs.entitiesData.relations) {
       const fromLower = relation.from.toLowerCase();
       const toLower = relation.to.toLowerCase();
-      const fromCapitalized = capitalize(relation.from);
-      const toCapitalized = capitalize(relation.to); // 'from' side (source)
 
       if (relation.type === "1-n") {
         // 'One' side: exclude the name of the other entity's list (e.g., 'articles')
         fieldsToExcludeMap.get(fromLower).push(`${toLower}s`);
-      } else if (relation.type === "n-1") {
-        // 'Many' side: exclude the foreign key (e.g., 'articleId') and the relation name (e.g., 'article')
-        fieldsToExcludeMap.get(fromLower).push(`${toLower}id`, toLower);
-      } // Add other relation types (1-1, n-n) if necessary here... // 'to' side (target)
-      if (relation.type === "1-n") {
         // 'Many' side: exclude the foreign key (e.g., 'userId') and the relation name (e.g., 'user')
         fieldsToExcludeMap.get(toLower).push(`${fromLower}id`, fromLower);
       } else if (relation.type === "n-1") {
+        // 'Many' side: exclude the foreign key (e.g., 'articleId') and the relation name (e.g., 'article')
+        fieldsToExcludeMap.get(fromLower).push(`${toLower}id`, toLower);
         // 'One' side: exclude the name of the other entity's list (e.g., 'comments')
         fieldsToExcludeMap.get(toLower).push(`${fromLower}s`);
+      } else if (relation.type === "1-1") {
+        // 'from' side (source of relation, holds the FK): exclude foreign key and relation name
+        fieldsToExcludeMap.get(fromLower).push(`${toLower}id`, toLower);
+        // 'to' side (target of relation): exclude relation name
+        fieldsToExcludeMap.get(toLower).push(fromLower);
+      } else if (relation.type === "n-n") {
+        // Both sides hold list of other entity: exclude plurals
+        fieldsToExcludeMap.get(fromLower).push(`${toLower}s`);
+        fieldsToExcludeMap.get(toLower).push(`${fromLower}s`);
       }
     }
   }
   // 2. Initial generation of models WITHOUT incorrect relationship fields
   for (const entity of inputs.entitiesData.entities) {
     const entityNameLower = entity.name.toLowerCase();
+    const entityNameCap = capitalize(entity.name);
     // On utilise un Set pour suivre les noms de champs déjà écrits dans ce modèle
     const addedFields = new Set(["id", "createdat", "updatedat"]);
 
     schemaContent += `
     /**
-    * ${entity.name} Model
+    * ${entityNameCap} Model
     */
-    model ${entity.name} {
+    model ${entityNameCap} {
       id        String   @id @default(uuid())
       createdAt DateTime @default(now())
       updatedAt DateTime @updatedAt`;
@@ -142,7 +147,7 @@ async function setupPrisma(inputs) {
         !fieldsToExclude.includes(fieldNameLower) &&
         !addedFields.has(fieldNameLower)
       ) {
-        schemaContent += `\n  ${field.name} ${mapTypeToPrisma(field.type)}`;
+        schemaContent += `\n  ${field.name} ${formatPrismaField(field)}`;
         addedFields.add(fieldNameLower);
       }
     }
@@ -159,30 +164,35 @@ async function setupPrisma(inputs) {
       const to = relation.to;
       const type = relation.type;
 
+      const fromCap = capitalize(from);
+      const toCap = capitalize(to);
+      const fromLow = from.toLowerCase();
+      const toLow = to.toLowerCase();
+
       // The replacement must be done on the entire generated schemaContent // Using a replacement function to update the content of `schemaContent`
       if (type === "1-n") {
         // "One" side (source): adds the list (to[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fieldLine = `  ${to}s ${to}[]`;
+            const fieldLine = `  ${toLow}s ${toCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${from} {${content}\n${fieldLine}\n}`;
+              : `model ${fromCap} {${content}\n${fieldLine}\n}`;
           },
         );
 
         // "Many" side (target): adds the relation and the foreign key
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const relationLine = `  ${from} ${from} @relation(fields: [${from}Id], references: [id])`;
-            const fkLine = `  ${from}Id String`;
+            const relationLine = `  ${fromLow} ${fromCap} @relation(fields: [${fromLow}Id], references: [id])`;
+            const fkLine = `  ${fromLow}Id String`;
             let result = match.includes(relationLine)
               ? content
               : `${content}\n${relationLine}`;
             result = result.includes(fkLine) ? result : `${result}\n${fkLine}`;
-            return `model ${to} {${result}\n}`;
+            return `model ${toCap} {${result}\n}`;
           },
         );
       }
@@ -192,27 +202,26 @@ async function setupPrisma(inputs) {
 
         // "Many" side (source = from): adds the relation and the foreign key
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const relationLine = `  ${to} ${to} @relation(fields: [${to}Id], references: [id])`;
-            const fkLine = `  ${to}Id String`;
+            const relationLine = `  ${toLow} ${toCap} @relation(fields: [${toLow}Id], references: [id])`;
+            const fkLine = `  ${toLow}Id String`;
             let result = match.includes(relationLine)
               ? content
               : `${content}\n${relationLine}`;
             result = result.includes(fkLine) ? result : `${result}\n${fkLine}`;
-            return `model ${from} {${result}\n}`;
+            return `model ${fromCap} {${result}\n}`;
           },
         );
 
         // "One" side (target = to): adds the list (from[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fromCapitalized = capitalize(from);
-            const fieldLine = `  ${from}s ${from}[]`;
+            const fieldLine = `  ${fromLow}s ${fromCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${to} {${content}\n${fieldLine}\n}`;
+              : `model ${toCap} {${content}\n${fieldLine}\n}`;
           },
         );
       }
@@ -220,28 +229,28 @@ async function setupPrisma(inputs) {
       if (type === "1-1") {
         // 'from' side (source): adds the relation, foreign key, and @unique attribute
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const relationLine = `  ${to} ${to}? @relation(fields: [${to}Id], references: [id])`; // The foreign key must be unique in a 1-1 relationship, and optional for flexibility
-            const fkLine = `  ${to}Id String? @unique`;
+            const relationLine = `  ${toLow} ${toCap}? @relation(fields: [${toLow}Id], references: [id])`; // The foreign key must be unique in a 1-1 relationship, and optional for flexibility
+            const fkLine = `  ${toLow}Id String? @unique`;
 
             let result = match.includes(relationLine)
               ? content
               : `${content}\n${relationLine}`;
             result = result.includes(fkLine) ? result : `${result}\n${fkLine}`;
-            return `model ${from} {${result}\n}`;
+            return `model ${fromCap} {${result}\n}`;
           },
         );
 
         // 'to' side (target): adds the inverse relation (optional)
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
             // Inverse relation (optional because 'from' holds the FK)
-            const fieldLine = `  ${from} ${from}?`;
+            const fieldLine = `  ${fromLow} ${fromCap}?`;
             return match.includes(fieldLine)
               ? match
-              : `model ${to} {${content}\n${fieldLine}\n}`;
+              : `model ${toCap} {${content}\n${fieldLine}\n}`;
           },
         );
       }
@@ -249,23 +258,23 @@ async function setupPrisma(inputs) {
       if (type === "n-n") {
         // 'from' side (source): adds the list (to[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${from} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${fromCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fieldLine = `  ${to}s ${to}[]`;
+            const fieldLine = `  ${toLow}s ${toCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${from} {${content}\n${fieldLine}\n}`;
+              : `model ${fromCap} {${content}\n${fieldLine}\n}`;
           },
         );
 
         // 'to' side (target): adds the list (from[])
         schemaContent = schemaContent.replace(
-          new RegExp(`model ${to} \{([\\s\\S]*?)\n\\}`, "m"),
+          new RegExp(`model ${toCap} \\{([\\s\\S]*?)\\n\\}`, "m"),
           (match, content) => {
-            const fieldLine = `  ${from}s ${from}[]`;
+            const fieldLine = `  ${fromLow}s ${fromCap}[]`;
             return match.includes(fieldLine)
               ? match
-              : `model ${to} {${content}\n${fieldLine}\n}`;
+              : `model ${toCap} {${content}\n${fieldLine}\n}`;
           },
         );
       }
@@ -289,7 +298,7 @@ async function setupPrisma(inputs) {
     path: schemaPath,
     contente: baseSchema,
   });
-  await runCommand(`npx prisma format`, "❌ Failed to format prisma schema");
+  await runCommand(`npx prisma format`, "❌ Failed to format prisma schema — run 'npx prisma format' manually", { critical: false });
 
   // 📁 Step 6: Creating the `src/prisma` structure
   const defaultPatch = "src/prisma";
@@ -344,6 +353,7 @@ async function setupPrisma(inputs) {
   await runCommand(
     `${inputs.packageManager} add dotenv`,
     "❌ Failed to install dotenv",
+    { critical: false },
   );
 
   // Creating prisma.config.ts file to load environment variables
@@ -362,7 +372,7 @@ async function setupPrisma(inputs) {
   }
 
   // Step 7: Generating the Prisma client
-  await runCommand("npx prisma generate", "❌ Prisma generation failed");
+  await runCommand("npx prisma generate", "❌ Prisma client generation failed — run 'npx prisma generate' manually", { critical: false });
 
   // Step 8: Migration (ONLY in 'new' mode)
   if (inputs.isDemo) {
@@ -421,6 +431,44 @@ function mapTypeToPrisma(type) {
   }
 }
 
+/**
+ * Formats a field definition for the Prisma schema including constraints.
+ * @param {object} field
+ * @returns {string} Formatted field line content (e.g. "String? @unique")
+ */
+function formatPrismaField(field) {
+  let prismaType = mapTypeToPrisma(field.type);
+  if (field.nullable) {
+    if (!prismaType.endsWith("?") && !prismaType.endsWith("[]")) {
+      prismaType += "?";
+    }
+  }
+  let attributes = "";
+  if (field.unique) {
+    attributes += " @unique";
+  }
+  if (field.default !== undefined && field.default !== null && field.default !== "") {
+    let defaultVal = field.default;
+    if (typeof defaultVal === "string") {
+      if (defaultVal === "true") defaultVal = true;
+      else if (defaultVal === "false") defaultVal = false;
+      else if (defaultVal.toLowerCase() === "now" || defaultVal.toLowerCase() === "now()") {
+        defaultVal = "now()";
+      } else if (!isNaN(defaultVal) && defaultVal.trim() !== "") {
+        defaultVal = Number(defaultVal);
+      }
+    }
+    if (defaultVal === "now()") {
+      attributes += ` @default(now())`;
+    } else if (typeof defaultVal === "boolean" || typeof defaultVal === "number") {
+      attributes += ` @default(${defaultVal})`;
+    } else {
+      attributes += ` @default("${defaultVal}")`;
+    }
+  }
+  return `${prismaType}${attributes}`;
+}
+
 async function setupPrismaSeeding(inputs) {
   logInfo("⚙️ Configuring seeding for Prisma...");
 
@@ -645,18 +693,18 @@ async function updatePrismaSchema(entityData) {
 
     switch (relation.type) {
       case "n-1": // "Many to One" : Le nouveau module appartient à une cible
-        relationFields += `\n  ${targetLow}   ${targetLow} @relation(fields: [${targetLow}Id], references: [id])`;
+        relationFields += `\n  ${targetLow}   ${targetCap} @relation(fields: [${targetLow}Id], references: [id])`;
         relationFields += `\n  ${targetLow}Id String`;
         break;
       case "1-n": // "One to Many" : Le nouveau module possède plusieurs cibles
-        relationFields += `\n  ${targetLow}s  ${targetLow}[]`;
+        relationFields += `\n  ${targetLow}s  ${targetCap}[]`;
         break;
       case "1-1":
-        relationFields += `\n  ${targetLow}   ${targetLow}? @relation(fields: [${targetLow}Id], references: [id])`;
+        relationFields += `\n  ${targetLow}   ${targetCap}? @relation(fields: [${targetLow}Id], references: [id])`;
         relationFields += `\n  ${targetLow}Id String? @unique`;
         break;
       case "n-n":
-        relationFields += `\n  ${targetLow}s  ${targetLow}[]`;
+        relationFields += `\n  ${targetLow}s  ${targetCap}[]`;
         break;
     }
   }
@@ -665,13 +713,13 @@ async function updatePrismaSchema(entityData) {
   let modelBlock = `\n/**
  * ${capitalizedName} Model
  */
-model ${lowercasedName} {
+model ${capitalizedName} {
   id        String   @id @default(uuid())
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt${relationFields}`;
 
   fields.forEach((field) => {
-    modelBlock += `\n  ${field.name} ${mapTypeToPrisma(field.type)}`;
+    modelBlock += `\n  ${field.name} ${formatPrismaField(field)}`;
   });
 
   modelBlock += `\n}\n`;
@@ -686,117 +734,53 @@ model ${lowercasedName} {
   // 4️⃣ Injection de l'INVERSE dans le modèle cible (Target)
   if (relation) {
     const targetCap = capitalize(relation.target);
-    const targetLow = capitalize(relation.target);
+    const targetLow = relation.target.toLowerCase();
     const newCap = capitalizedName;
     const newLow = name.toLowerCase();
 
     let inverseField = "";
     switch (relation.type) {
       case "n-1": // Inverse d'un Many-to-One est un One-to-Many
-        inverseField = `  ${newLow}s ${newLow}[]`;
+        inverseField = `  ${newLow}s ${newCap}[]`;
         break;
       case "1-n": // Inverse d'un One-to-Many est un Many-to-One
-        inverseField = `  ${newLow}   ${newLow} @relation(fields: [${newLow}Id], references: [id])\n  ${newLow}Id String`;
+        inverseField = `  ${newLow}   ${newCap} @relation(fields: [${newLow}Id], references: [id])\n  ${newLow}Id String`;
         break;
       case "1-1":
-        inverseField = `  ${newLow}   ${newLow}?`;
+        inverseField = `  ${newLow}   ${newCap}?`;
         break;
       case "n-n":
-        inverseField = `  ${newLow}s ${newLow}[]`;
+        inverseField = `  ${newLow}s ${newCap}[]`;
         break;
     }
 
     // On utilise une RegEx pour trouver le bloc du modèle cible et insérer avant la fermeture "}"
     await updateFile({
       path: schemaPath,
-      pattern: new RegExp(`model ${targetLow} \\{([\\s\\S]*?)\\}`, "g"),
-      replacement: `model ${targetLow} {$1\n${inverseField}\n}`,
+      pattern: new RegExp(`model ${targetCap} \\{([\\s\\S]*?)\\}`, "g"),
+      replacement: `model ${targetCap} {$1\n${inverseField}\n}`,
     });
   }
 
   // 3️⃣ Prisma Commands Sync (meilleur sur Windows)
-  try {
-    console.log(info("Running: prisma format..."));
-    execSync("npx prisma format", { stdio: "pipe" });
-
-    console.log(info("Running: prisma generate..."));
-    execSync("npx prisma generate", { stdio: "pipe" });
-
-    console.log(info("Running: prisma migrate dev..."));
-    execSync(
-      `npx prisma migrate dev --name add_module_${entityData.name} --force`,
-      {
-        stdio: "pipe",
-      },
-    );
-
-    // console.log(success("🎉 Prisma migration completed successfully!"));
-  } catch (err) {
-    // 4️⃣ Gestion spécifique Windows EPERM
-    if (
-      err.message.includes("operation not permitted") ||
-      err.message.includes("EPERM") ||
-      err.message.includes("EBUSY")
-    ) {
-      logWarning("System Lock Detected!");
-      console.log(
-        `${info("Prisma Client binary is locked because your server is running.")}`,
-      );
-      console.log(
-        `${info("ACTION:")} Stop NestJS (Ctrl+C) and run manually:\n`,
-      );
-      console.log(`${success("npx prisma generate")}`);
-      console.log(`${success("npx prisma migrate dev")}\n`);
-    } else {
-      console.log(error("❌ Prisma error: " + err.message));
-    }
-  }
-}
-
-/* async function updatePrismaSchema(entityData) {
-  const schemaPath = "prisma/schema.prisma";
-
-  // Construction du bloc modèle
-  let modelBlock = `\nmodel ${capitalize(entityData.name)} {
-  id        String   @id @default(uuid())
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt`;
-
-  entityData.fields.forEach((field) => {
-    // Note: On réutilise ta fonction mapTypeToPrisma ici
-    modelBlock += `\n  ${field.name} ${mapTypeToPrisma(field.type)}`;
-  });
-
-  modelBlock += `\n}\n`;
-
-  // Injection à la fin du fichier
-  await updateFile({
-    path: schemaPath,
-    pattern: /$/, // On ajoute à la fin
-    replacement: modelBlock,
-  });
+  await runCommand(
+    "npx prisma format",
+    "❌ Failed to format prisma schema — run 'npx prisma format' manually",
+    { critical: false }
+  );
 
-  // ⚠️ IMPORTANT : On formate et on régénère le client pour supprimer les erreurs TS
-  try {
-    await runCommand("npx prisma format");
-    await runCommand("npx prisma generate");
-    await runCommand(
-      `npx prisma migrate dev --name add_module_${entityData.name}`,
-    );
-  } catch (err) {
-    if (err.message.includes("EPERM")) {
-      console.log(
-        `\n${warning("⚠️  System Lock:")} Could not update Prisma Client binary because your app is currently running.`,
-      );
-      console.log(
-        `${info("ACTION REQUIRED:")} Stop your dev server (Ctrl+C) and run: ${success("| npx prisma generate | and | npx prisma migrate dev |")}\n`,
-      );
-    } else {
-      logError("Prisma error: " + err.message);
-    }
-  }
+  await runCommand(
+    "npx prisma generate",
+    "❌ Failed to generate prisma client — run 'npx prisma generate' manually",
+    { critical: false }
+  );
 
-  throw new Error(err);
-} */
+  await runCommand(
+    `npx prisma migrate dev --name add_module_${entityData.name}`,
+    `❌ Failed to run prisma migration — run 'npx prisma migrate dev --name add_module_${entityData.name}' manually`,
+    { critical: false }
+  );
+}
 
 module.exports = { setupPrisma, updatePrismaSchema };
+

package/utils/setups/setupSwagger.js

@@ -1,5 +1,5 @@
 const fs = require("fs");
-const { execSync } = require("child_process");
+const { runCommand } = require("../shell");
 const { logInfo } = require("../loggers/logInfo");
 const { logSuccess } = require("../loggers/logSuccess");
 
@@ -7,13 +7,17 @@ async function setupSwagger(inputs) {
   logInfo("Installation et Configuration de Swagger...");
 
   // installation de swagger
-  try {
-    execSync("npm install @nestjs/swagger swagger-ui-express", {
-      stdio: "inherit",
-    });
-  } catch (error) {
-    console.error("❌ Échec de l'installation de Swagger :", error);
-    process.exit(1);
+  await runCommand(
+    "npm install @nestjs/swagger swagger-ui-express",
+    "Échec de l'installation de Swagger",
+    { spinner: "Installing Swagger..." }
+  );
+
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log("[DRY-RUN] Simulated: write Swagger configuration to src/main.ts");
+    logSuccess(" Swagger configuré avec succès !");
+    return;
   }
 
   // Modification de main.ts pour intégrer Swagger

package/utils/shell.js

@@ -1,32 +1,147 @@
 const { execSync } = require("child_process");
 const fs = require("fs");
 const { logError } = require("./loggers/logError");
+const { logWarning } = require("./loggers/logWarning");
 const { spinner } = require("./spinner");
+const { warning, info } = require("./colors");
+
+/**
+ * Accumulated warnings collected during a generation session.
+ * Displayed as a summary at the end via printSetupWarnings().
+ */
+const _warnings = [];
+
+/**
+ * Runs a shell command synchronously.
+ *
+ * @param {string} command - The shell command to execute.
+ * @param {string} errorMessage - Human-readable error message shown on failure.
+ * @param {object} [options] - Optional configuration.
+ * @param {boolean} [options.critical=true] - If true (default), a failure calls process.exit(1).
+ *   If false, the failure is logged as a warning and execution continues.
+ * @param {string|null} [options.spinner] - Optional spinner label shown during execution.
+ * @param {number} [options.timeout] - Custom timeout in milliseconds.
+ * @returns {Promise<boolean>} Resolves to true on success, false on non-critical failure.
+ */
+async function runCommand(command, errorMessage, options = {}) {
+  let critical = true;
+  let spinnerText = null;
+  let customTimeout = undefined;
+
+  if (typeof options === "string") {
+    spinnerText = options;
+  } else if (typeof options === "object" && options !== null) {
+    critical = options.critical !== false;
+    spinnerText = options.spinner || null;
+    customTimeout = options.timeout;
+  }
+
+  // Determine Timeout
+  let timeoutVal = 30000; // default 30 seconds
+  if (
+    command.includes("install") ||
+    command.includes("add") ||
+    command.includes(" new ") ||
+    command.includes("prisma migrate")
+  ) {
+    timeoutVal = 300000; // 5 minutes for heavy setup commands
+  }
+  if (customTimeout !== undefined) {
+    timeoutVal = customTimeout;
+  }
+
+  // Dry-Run Simulation Check
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    if (spinnerText) {
+      const spin = spinner(spinnerText);
+      spin.start();
+      spin.succeed(`[DRY-RUN] Simulated: ${command}`);
+    } else {
+      console.log(`[DRY-RUN] Simulated: ${command}`);
+    }
+    return true;
+  }
 
-async function runCommand(command, errorMessage, spinnerText = null) {
   const spin = spinnerText ? spinner(spinnerText) : null;
 
   try {
     if (spin) spin.start();
-    execSync(command, { stdio: spinnerText ? "pipe" : "inherit" });
+    execSync(command, {
+      stdio: spinnerText ? "pipe" : "inherit",
+      timeout: timeoutVal,
+    });
     if (spin) spin.succeed(spinnerText);
+    return true;
   } catch (error) {
     if (spin) spin.fail(errorMessage);
-    logError(errorMessage);
-    fs.appendFileSync(
-      "setup.log",
-      `[Erreur] ${errorMessage}: ${error.message}\n`,
-    );
-    process.exit(1);
+
+    let errorDetail = error.message;
+    if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+      errorDetail = `Command timed out after ${timeoutVal / 1000}s`;
+    }
+
+    const logLine = `[${new Date().toISOString()}] ${errorMessage}: ${errorDetail}\n`;
+    fs.appendFileSync("setup.log", logLine);
+
+    if (critical) {
+      logError(`${errorMessage}`);
+      logError(`Run: ${command}`);
+      logError(`Detail: ${errorDetail}`);
+      process.exit(1);
+    } else {
+      logWarning(`${errorMessage} (non-fatal, continuing...)`);
+      logWarning(`  Command: ${command}`);
+      logWarning(`  Detail: ${errorDetail}`);
+      logWarning(`  See setup.log for details`);
+      _warnings.push({ command, errorMessage });
+      return false;
+    }
   }
 }
 
+/**
+ * Silent command — returns stdout string or null on failure. Never exits.
+ * @param {string} command
+ * @returns {string|null}
+ */
 async function runCommandSilent(command) {
   try {
-    return execSync(command, { stdio: "pipe" }).toString();
+    return execSync(command, { stdio: "pipe", timeout: 10000 }).toString();
   } catch (error) {
     return null;
   }
 }
 
-module.exports = { runCommand, runCommandSilent };
+/**
+ * Prints a summary of all non-critical warnings accumulated during the session.
+ * Call this at the very end of the generation pipeline.
+ */
+function printSetupWarnings() {
+  if (_warnings.length === 0) return;
+
+  console.log(
+    `\n${warning("⚠️  Setup completed with")} ${warning(String(_warnings.length))} ${warning("warning(s):")}`,
+  );
+  _warnings.forEach((w, i) => {
+    console.log(`  ${info(`${i + 1}.`)} ${w.errorMessage}`);
+    console.log(`     ${info("Command:")} ${w.command}`);
+  });
+  console.log(
+    `\n  ${info("➜")} Full details in: ${info("setup.log")}\n`,
+  );
+}
+
+/**
+ * Clears the warnings accumulator (useful between test runs).
+ */
+function clearSetupWarnings() {
+  _warnings.length = 0;
+}
+
+module.exports = {
+  runCommand,
+  runCommandSilent,
+  printSetupWarnings,
+  clearSetupWarnings,
+};