Fix backend flow, installer edge cases, and generation progress

Author: Ali-dev11

CHANGELOG.md

@@ -6,6 +6,20 @@ The format follows Keep a Changelog and the version numbers follow Semantic Vers
 
 ## [Unreleased]
 
+## [0.3.4] - 2026-03-26
+
+### Changed
+
+- Improved architecture labels so backend and other non-frontend flows explain what `simple`, `modular`, and `monorepo` mean more clearly during prompting.
+- Added a real-time file generation progress bar during scaffold creation so the CLI shows visible progress after printing the target directory.
+
+### Fixed
+
+- Prevented incompatible backend selections by filtering out `Drizzle` when `MongoDB` is chosen and by normalizing any `Drizzle + MongoDB` plan back to a supported setup.
+- Stopped generating `.nvmrc` for `LTS` and `Latest` Node strategies, avoiding broken version-manager lookups like `lts-latest` on systems that cannot resolve that alias.
+- Hardened dependency installation for `yarn` and `pnpm` by using Corepack when available and by keeping package-manager caches local to the generated project.
+- Removed stale lockfiles from other package managers before installation so the selected package manager stays authoritative after retries or partial runs.
+
 ## [0.3.3] - 2026-03-26
 
 ### Added

docs/changelog.md

@@ -9,6 +9,20 @@ Track what changed in DevForge CLI across releases, including scaffolding behavi
 - [GitHub Releases](https://github.com/Ali-dev11/devforge/releases)
 - [Repository Changelog](https://github.com/Ali-dev11/devforge/blob/main/CHANGELOG.md)
 
+## [0.3.4] - 2026-03-26
+
+### Changed
+
+- Improved architecture labels so backend and other non-frontend flows explain what `simple`, `modular`, and `monorepo` mean more clearly during prompting.
+- Added a real-time file generation progress bar during scaffold creation so the CLI shows visible progress after printing the target directory.
+
+### Fixed
+
+- Prevented incompatible backend selections by filtering out `Drizzle` when `MongoDB` is chosen and by normalizing any `Drizzle + MongoDB` plan back to a supported setup.
+- Stopped generating `.nvmrc` for `LTS` and `Latest` Node strategies, avoiding broken version-manager lookups like `lts-latest` on systems that cannot resolve that alias.
+- Hardened dependency installation for `yarn` and `pnpm` by using Corepack when available and by keeping package-manager caches local to the generated project.
+- Removed stale lockfiles from other package managers before installation so the selected package manager stays authoritative after retries or partial runs.
+
 ## [0.3.3] - 2026-03-26
 
 ### Added

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@ali-dev11/devforge",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Production-focused AI-native project scaffolding CLI for JavaScript and TypeScript teams.",
   "license": "MIT",
   "author": "Ali-dev11",

package.json

@@ -13,7 +13,14 @@ import {
   removeFile,
   saveResumeState,
 } from "../utils/fs.js";
-import { banner, info, step, success, warn } from "../utils/logger.js";
+import {
+  banner,
+  createProgressReporter,
+  info,
+  step,
+  success,
+  warn,
+} from "../utils/logger.js";
 
 async function loadResumePlan(): Promise<ResumeState | undefined> {
   const resumePath = join(process.cwd(), RESUME_STATE_PATH);
@@ -64,7 +71,12 @@ export async function runInitCommand(options: CliOptions): Promise<void> {
   }
 
   step(`Generating project in ${plan.targetDir}`);
-  const generated = await generateProject(plan, environment);
+  const progressReporter = createProgressReporter("Writing files");
+  const generated = await generateProject(plan, environment, {
+    onWrite: ({ current, total }) => {
+      progressReporter({ current, total });
+    },
+  });
 
   const installResult = runInstallers(plan, environment, options.skipInstall);
 

src/commands/init.ts

@@ -85,10 +85,10 @@ export const ARCHITECTURE_CHOICES: Array<{
   title: string;
   value: ArchitectureMode;
 }> = [
-  { title: "Simple", value: "simple" },
-  { title: "Modular", value: "modular" },
-  { title: "Monorepo", value: "monorepo" },
-  { title: "Microfrontend", value: "microfrontend" },
+  { title: "Simple (single app)", value: "simple" },
+  { title: "Modular (feature modules)", value: "modular" },
+  { title: "Monorepo (apps + packages)", value: "monorepo" },
+  { title: "Microfrontend (frontend only)", value: "microfrontend" },
 ];
 
 export const FRONTEND_FRAMEWORK_CHOICES: Array<{
@@ -217,7 +217,7 @@ export const ORM_CHOICES: Array<{
 }> = [
   { title: "None", value: "none" },
   { title: "Prisma", value: "prisma" },
-  { title: "Drizzle", value: "drizzle" },
+  { title: "Drizzle (SQL)", value: "drizzle" },
 ];
 
 export const DATABASE_CHOICES: Array<{

src/constants.ts

@@ -166,6 +166,11 @@ export function normalizeProjectPlan(
       warnings.push("ORM selected without a database; defaulting to PostgreSQL.");
       plan.backend.database = "postgresql";
     }
+
+    if (plan.backend.orm === "drizzle" && plan.backend.database === "mongodb") {
+      warnings.push("Drizzle ORM does not support MongoDB in generated backends; switching ORM to none and keeping MongoDB.");
+      plan.backend.orm = "none";
+    }
   }
 
   if (plan.ai.tools.length === 0) {

src/engines/decision.ts

@@ -15,9 +15,14 @@ import {
   writeJson,
 } from "../utils/fs.js";
 
+type GenerateProjectOptions = {
+  onWrite?: (info: { current: number; total: number; path: string }) => void;
+};
+
 export async function generateProject(
   plan: ProjectPlan,
   environment: EnvironmentInfo,
+  options?: GenerateProjectOptions,
 ): Promise<GeneratedProjectResult> {
   const projectExists = await pathExists(plan.targetDir);
 
@@ -36,9 +41,19 @@ export async function generateProject(
   await ensureDir(plan.targetDir);
 
   const files = [...buildProjectFiles(plan, environment), ...buildAiRuleFiles(plan)];
-  const filesWritten = await writeGeneratedFiles(plan.targetDir, files);
+  const totalWrites = files.length + 1;
+  const filesWritten = await writeGeneratedFiles(plan.targetDir, files, options?.onWrite
+    ? ({ current, path }) => {
+        options.onWrite?.({ current, total: totalWrites, path });
+      }
+    : undefined);
 
   await writeJson(join(plan.targetDir, ".devforge", "project-plan.json"), plan);
+  options?.onWrite?.({
+    current: totalWrites,
+    total: totalWrites,
+    path: join(plan.targetDir, ".devforge", "project-plan.json"),
+  });
 
   return {
     targetDir: plan.targetDir,

src/engines/generator.ts

@@ -1,14 +1,34 @@
 import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import type { EnvironmentInfo, InstallResult, ProjectPlan } from "../types.js";
 
-function runCommand(command: string, args: string[], cwd: string): boolean {
+type CommandResult = {
+  ok: boolean;
+  output?: string;
+};
+
+function runCommand(
+  command: string,
+  args: string[],
+  cwd: string,
+  env?: Record<string, string>,
+): CommandResult {
   const result = spawnSync(command, args, {
     cwd,
-    stdio: "ignore",
     encoding: "utf8",
+    env: {
+      ...process.env,
+      ...env,
+    },
+    stdio: ["ignore", "pipe", "pipe"],
   });
 
-  return result.status === 0;
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim() || undefined;
+  return {
+    ok: result.status === 0,
+    output,
+  };
 }
 
 function installArgs(packageManager: ProjectPlan["packageManager"]): string[] {
@@ -25,6 +45,82 @@ function installArgs(packageManager: ProjectPlan["packageManager"]): string[] {
   }
 }
 
+function hasCorepack(cwd: string): boolean {
+  return runCommand("corepack", ["--version"], cwd).ok;
+}
+
+function installCacheEnv(
+  packageManager: ProjectPlan["packageManager"],
+  cwd: string,
+): Record<string, string> {
+  const devforgeDir = join(cwd, ".devforge");
+  mkdirSync(devforgeDir, { recursive: true });
+
+  const env: Record<string, string> = {};
+  if (packageManager === "npm") {
+    env.npm_config_cache = join(devforgeDir, "npm-cache");
+  }
+
+  if (packageManager === "pnpm") {
+    env.COREPACK_HOME = join(devforgeDir, "corepack");
+    env.PNPM_STORE_DIR = join(devforgeDir, "pnpm-store");
+  }
+
+  if (packageManager === "yarn") {
+    env.COREPACK_HOME = join(devforgeDir, "corepack");
+    env.YARN_CACHE_FOLDER = join(devforgeDir, "yarn-cache");
+  }
+
+  return env;
+}
+
+function installInvocation(
+  packageManager: ProjectPlan["packageManager"],
+  environment: EnvironmentInfo,
+  cwd: string,
+): { command: string; args: string[]; label: string; available: boolean; env?: Record<string, string> } {
+  const env = installCacheEnv(packageManager, cwd);
+
+  if ((packageManager === "pnpm" || packageManager === "yarn") && hasCorepack(cwd)) {
+    return {
+      command: "corepack",
+      args: [packageManager, ...installArgs(packageManager)],
+      label: `corepack ${packageManager} install`,
+      available: true,
+      env,
+    };
+  }
+
+  return {
+    command: packageManager,
+    args: installArgs(packageManager),
+    label: `${packageManager} install`,
+    available: environment.packageManagers[packageManager].installed,
+    env,
+  };
+}
+
+function removeIncompatibleLockfiles(cwd: string, packageManager: ProjectPlan["packageManager"]): void {
+  const lockfilesByManager: Record<ProjectPlan["packageManager"], string[]> = {
+    npm: ["package-lock.json"],
+    pnpm: ["pnpm-lock.yaml"],
+    yarn: ["yarn.lock"],
+    bun: ["bun.lock", "bun.lockb"],
+  };
+  const keep = new Set(lockfilesByManager[packageManager]);
+
+  for (const filename of Object.values(lockfilesByManager).flat()) {
+    if (keep.has(filename)) {
+      continue;
+    }
+
+    const filePath = join(cwd, filename);
+    if (existsSync(filePath)) {
+      rmSync(filePath, { force: true });
+    }
+  }
+}
+
 export function runInstallers(
   plan: ProjectPlan,
   environment: EnvironmentInfo,
@@ -34,30 +130,44 @@ export function runInstallers(
   const skipped: string[] = [];
 
   if (!skipInstall) {
-    const managerStatus = environment.packageManagers[plan.packageManager];
+    const invocation = installInvocation(plan.packageManager, environment, plan.targetDir);
 
-    if (!managerStatus.installed) {
+    if (!invocation.available) {
       skipped.push(
-        `${plan.packageManager} is not installed; generated project without installing dependencies.`,
+        `${plan.packageManager} is not installed and Corepack is unavailable; generated project without installing dependencies.`,
       );
-    } else if (runCommand(plan.packageManager, installArgs(plan.packageManager), plan.targetDir)) {
-      executed.push(`${plan.packageManager} install`);
     } else {
-      skipped.push(`${plan.packageManager} install failed; dependencies were not installed.`);
+      removeIncompatibleLockfiles(plan.targetDir, plan.packageManager);
+      const installResult = runCommand(
+        invocation.command,
+        invocation.args,
+        plan.targetDir,
+        invocation.env,
+      );
+
+      if (installResult.ok) {
+        executed.push(invocation.label);
+      } else {
+        skipped.push(
+          installResult.output
+            ? `${invocation.label} failed: ${installResult.output.split(/\r?\n/)[0]}`
+            : `${invocation.label} failed; dependencies were not installed.`,
+        );
+      }
     }
   } else {
     skipped.push("Dependency installation skipped by flag.");
   }
 
   if (plan.git.initialize) {
-    if (runCommand("git", ["init"], plan.targetDir)) {
+    if (runCommand("git", ["init"], plan.targetDir).ok) {
       executed.push("git init");
     } else {
       skipped.push("git init failed.");
     }
 
     if (plan.git.addRemote && plan.git.remoteUrl) {
-      if (runCommand("git", ["remote", "add", "origin", plan.git.remoteUrl], plan.targetDir)) {
+      if (runCommand("git", ["remote", "add", "origin", plan.git.remoteUrl], plan.targetDir).ok) {
         executed.push("git remote add origin");
       } else {
         skipped.push("git remote add origin failed.");