create-morax 1.0.4 → 1.0.14

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import pc16 from "picocolors";
+import pc18 from "picocolors";
 
 // src/core/runner.ts
-import path13 from "path";
-import { spinner as spinner9 } from "@clack/prompts";
-import pc15 from "picocolors";
+import path15 from "path";
+import { spinner as spinner11, multiselect } from "@clack/prompts";
+import pc17 from "picocolors";
 
 // src/core/startcli.ts
 import gradient from "gradient-string";
@@ -55,21 +55,21 @@ function handleCancel(input) {
 }
 
 // src/core/workspaceName.ts
-async function promptWorkspaceName() {
+async function promptWorkspaceName(isMonorepo = true) {
   const nameInput = await text({
-    message: "What is the name of your new monorepo workspace?",
-    placeholder: "morax-workspace",
+    message: isMonorepo ? "What is the name of your new monorepo workspace?" : "What is the name of your new project?",
+    placeholder: isMonorepo ? "morax-workspace" : "my-app",
     validate(value) {
       if (value && value.includes(" "))
-        return "Workspace name cannot contain spaces!";
+        return isMonorepo ? "Workspace name cannot contain spaces!" : "Project name cannot contain spaces!";
     }
   });
   handleCancel(nameInput);
-  return String(nameInput).trim() || "morax-workspace";
+  return String(nameInput).trim() || (isMonorepo ? "morax-workspace" : "my-app");
 }
 
 // src/tasks/directories.ts
-import { multiselect, spinner } from "@clack/prompts";
+import { spinner } from "@clack/prompts";
 import fsPromises2 from "fs/promises";
 import path2 from "path";
 import pc4 from "picocolors";
@@ -162,36 +162,13 @@ async function createDirectories(directories, projectPath) {
   }
 }
 async function makeDirectories(name, projectPath) {
-  const directories = await multiselect({
-    message: "Which directories do you want to include in your workspace?",
-    options: [
-      {
-        value: "apps",
-        label: "apps/*",
-        hint: "For frontend apps and backend services"
-      },
-      {
-        value: "packages",
-        label: "packages/*",
-        hint: "For shared components, configs, and utilities"
-      }
-    ],
-    required: true
-  });
-  handleCancel(directories);
+  const directories = ["apps", "packages"];
   const s = spinner();
   console.log("\n");
   s.start("Generating workspace configs...");
   try {
-    await generateWorkspaceConfig(
-      name,
-      directories,
-      projectPath
-    );
-    await createDirectories(
-      directories,
-      projectPath
-    );
+    await generateWorkspaceConfig(name, directories, projectPath);
+    await createDirectories(directories, projectPath);
     s.stop(pc4.green("\u2714 Success: Generated Workspace Root & Folder Structures"));
   } catch (error) {
     s.stop(pc4.red("\u2716 Failed: Workspace generation failed"));
@@ -203,116 +180,704 @@ Error details: ${error.message || error}`));
   return directories;
 }
 
-// src/tasks/prettier.ts
-import { confirm, spinner as spinner2 } from "@clack/prompts";
+// src/core/react-runner.ts
+import path6 from "path";
+import { spinner as spinner4 } from "@clack/prompts";
+import pc8 from "picocolors";
+
+// src/tasks/react.ts
 import pc5 from "picocolors";
 import fsPromises3 from "fs/promises";
 import path3 from "path";
-async function promptPrettier() {
-  return await confirm({
-    message: "Do you want to setup Prettier code formatting?",
-    initialValue: true
+import { spawn } from "child_process";
+import { confirm, spinner as spinner2, text as text2 } from "@clack/prompts";
+function runInteractiveCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const fullCommand = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+    const child = spawn(fullCommand, [], {
+      cwd,
+      stdio: "inherit",
+      shell: true,
+      env: { ...process.env, NODE_NO_WARNINGS: "1" }
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new Error(
+            `Command "${command} ${args.join(" ")}" exited with code ${code}`
+          )
+        );
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
   });
 }
-async function setupPrettier(projectPath) {
-  await runCommand("pnpm add -D -E prettier -w", { cwd: projectPath });
-  const prettierrc = {
-    semi: true,
-    singleQuote: true,
-    tabWidth: 2,
-    trailingComma: "all",
-    printWidth: 100
-  };
-  await fsPromises3.writeFile(
-    path3.join(projectPath, ".prettierrc"),
-    JSON.stringify(prettierrc, null, 2),
-    "utf8"
+async function setupReact(projectPath, isMonorepo = true) {
+  const appsDir = isMonorepo ? path3.join(projectPath, "apps") : path3.dirname(projectPath);
+  console.log(pc5.magentaBright("\n\u{1F537} IMPORTANT INSTRUCTIONS:"));
+  console.log(
+    pc5.magentaBright(
+      "During the Vite interactive configuration prompts, please select:"
+    )
   );
-  const prettierignore = [
-    "# Dependencies",
-    "node_modules/",
-    "jspm_packages/",
-    "web_modules/",
-    "",
-    "# Build and outputs",
-    "dist/",
-    "build/",
-    ".next/",
-    "out/",
-    ".turbo/",
-    "",
-    "# Configuration locks",
-    "pnpm-lock.yaml",
-    "",
-    "# Environment files",
-    ".env",
-    ".env.*",
-    ""
-  ].join("\n");
-  await fsPromises3.writeFile(
-    path3.join(projectPath, ".prettierignore"),
-    prettierignore,
-    "utf8"
+  console.log(
+    pc5.magentaBright(
+      `  1. Install & Start: Choose ${pc5.bold("No")} when asked "Install with npm/pnpm and start now?"`
+    )
   );
-  const rootPackagePath = path3.join(projectPath, "package.json");
-  const rootPackageContent = await fsPromises3.readFile(rootPackagePath, "utf8");
-  const pkg = JSON.parse(rootPackageContent);
-  pkg.scripts = {
-    ...pkg.scripts || {},
-    format: "prettier --write ."
-  };
-  await fsPromises3.writeFile(
-    rootPackagePath,
-    JSON.stringify(pkg, null, 2),
-    "utf8"
+  console.log(
+    pc5.magentaBright(
+      "This allows Morax CLI to continue automatically configuring your workspace (ESLint, Prettier, Tailwind, packages, etc.)!"
+    )
   );
-  await runCommand("pnpm format", { cwd: projectPath });
-}
-async function runPrettierSetup(projectPath) {
-  const prettierPrompt = await promptPrettier();
-  handleCancel(prettierPrompt);
-  if (prettierPrompt) {
-    const s = spinner2();
-    console.log("\n");
-    s.start("Setting up Prettier auto-formatting...");
+  console.log(
+    pc5.cyan("\nStarting interactive Vite React application setup...")
+  );
+  let beforeDirs = [];
+  try {
+    beforeDirs = await fsPromises3.readdir(appsDir);
+  } catch {
+  }
+  try {
+    await runInteractiveCommand("pnpm", ["create", "vite@latest"], appsDir);
+    let afterDirs = [];
     try {
-      await setupPrettier(projectPath);
-      s.stop(pc5.green("\u2714 Success: Prettier formatting configured"));
-    } catch (error) {
-      s.stop(pc5.red("\u2716 Failed: Prettier setup failed"));
-      console.error(pc5.red(`
-Error details: ${error.message || error}`));
-      process.exit(1);
+      afterDirs = await fsPromises3.readdir(appsDir);
+    } catch {
     }
-    console.log("\n");
+    const newDirs = afterDirs.filter((d) => !beforeDirs.includes(d));
+    let createdDirName = "web";
+    if (newDirs.length > 0) {
+      createdDirName = newDirs[0];
+    }
+    const webDir = path3.join(appsDir, createdDirName);
+    try {
+      await fsPromises3.access(webDir);
+    } catch {
+      throw new Error(
+        `Vite React application directory "apps/${createdDirName}" was not found. Please ensure you complete the Vite installation.`
+      );
+    }
+    const aliasSpinner = spinner2();
+    aliasSpinner.start("Configuring import aliases and Node types...");
+    try {
+      const pkgPath = path3.join(webDir, "package.json");
+      try {
+        const pkgRaw = await fsPromises3.readFile(pkgPath, "utf8");
+        const pkg = JSON.parse(pkgRaw);
+        pkg.devDependencies = pkg.devDependencies || {};
+        pkg.devDependencies["@types/node"] = "^20.11.0";
+        await fsPromises3.writeFile(
+          pkgPath,
+          JSON.stringify(pkg, null, 2),
+          "utf8"
+        );
+      } catch {
+      }
+      const tsconfigPaths = [
+        path3.join(webDir, "tsconfig.json"),
+        path3.join(webDir, "tsconfig.app.json")
+      ];
+      for (const tsPath of tsconfigPaths) {
+        try {
+          let content = await fsPromises3.readFile(tsPath, "utf8");
+          if (content.includes('"compilerOptions"')) {
+            if (!content.includes('"paths"')) {
+              content = content.replace(
+                /("compilerOptions"\s*:\s*\{)/,
+                `$1
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    },`
+              );
+              await fsPromises3.writeFile(tsPath, content, "utf8");
+            }
+          } else {
+            content = content.replace(
+              /^(\s*\{)/,
+              `$1
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },`
+            );
+            await fsPromises3.writeFile(tsPath, content, "utf8");
+          }
+        } catch {
+        }
+      }
+      const viteConfigPath = path3.join(webDir, "vite.config.ts");
+      try {
+        let content = await fsPromises3.readFile(viteConfigPath, "utf8");
+        if (!content.includes("import path from 'path'")) {
+          content = "import path from 'path';\n" + content;
+        }
+        if (!content.includes("resolve:")) {
+          content = content.replace(
+            /(plugins:\s*\[[^\]]*\]),?/,
+            `$1,
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  }`
+          );
+        }
+        await fsPromises3.writeFile(viteConfigPath, content, "utf8");
+      } catch {
+      }
+      aliasSpinner.stop(
+        pc5.green("\u2714 Success: Import aliases and Node types configured")
+      );
+    } catch (err) {
+      aliasSpinner.stop(pc5.red("\u2716 Failed: Import alias configuration failed"));
+    }
+    console.log(
+      pc5.green(
+        isMonorepo ? `
+\u2714 Success: Vite React frontend configured in apps/${createdDirName}
+` : `
+\u2714 Success: Vite React frontend configured at root
+`
+      )
+    );
+    const setupTailwindPrompt = await confirm({
+      message: "Do you want to install and configure Tailwind CSS v4?",
+      initialValue: true
+    });
+    handleCancel(setupTailwindPrompt);
+    const setupShadcnPrompt = await confirm({
+      message: `Do you want to setup shadcn UI in your Vite React website (apps/${createdDirName})?`,
+      initialValue: true
+    });
+    handleCancel(setupShadcnPrompt);
+    const needsTailwind = setupTailwindPrompt || setupShadcnPrompt;
+    if (needsTailwind) {
+      const s = spinner2();
+      s.start(
+        "Installing Tailwind CSS v4, Vite integration, and Node types..."
+      );
+      try {
+        const pkgPath = path3.join(webDir, "package.json");
+        try {
+          const pkgRaw = await fsPromises3.readFile(pkgPath, "utf8");
+          const pkg = JSON.parse(pkgRaw);
+          pkg.dependencies = pkg.dependencies || {};
+          pkg.devDependencies = pkg.devDependencies || {};
+          pkg.dependencies["tailwindcss"] = "^4.0.0";
+          pkg.devDependencies["@tailwindcss/vite"] = "^4.0.0";
+          pkg.devDependencies["@types/node"] = "^20.11.0";
+          await fsPromises3.writeFile(
+            pkgPath,
+            JSON.stringify(pkg, null, 2),
+            "utf8"
+          );
+        } catch {
+        }
+        await runCommand("pnpm install", { cwd: webDir, silent: true });
+        s.message("Configuring Vite plugins and Tailwind CSS imports...");
+        const viteConfigPath = path3.join(webDir, "vite.config.ts");
+        try {
+          let content = await fsPromises3.readFile(viteConfigPath, "utf8");
+          if (!content.includes("@tailwindcss/vite")) {
+            content = "import tailwindcss from '@tailwindcss/vite';\n" + content;
+            if (content.includes("plugins: [react()]")) {
+              content = content.replace(
+                "plugins: [react()]",
+                "plugins: [react(), tailwindcss()]"
+              );
+            } else if (content.includes("plugins: [react(),]")) {
+              content = content.replace(
+                "plugins: [react(),]",
+                "plugins: [react(), tailwindcss()]"
+              );
+            } else {
+              content = content.replace(
+                /(plugins:\s*\[\s*react\(\),?\s*)(\])/g,
+                "$1\n    tailwindcss(),\n  $2"
+              );
+            }
+            await fsPromises3.writeFile(viteConfigPath, content, "utf8");
+          }
+        } catch {
+        }
+        const indexCssPath = path3.join(webDir, "src", "index.css");
+        try {
+          await fsPromises3.writeFile(
+            indexCssPath,
+            '@import "tailwindcss";\n',
+            "utf8"
+          );
+        } catch {
+        }
+        s.stop(
+          pc5.green("\u2714 Success: Tailwind CSS v4 configured successfully\n")
+        );
+      } catch (err) {
+        s.stop(pc5.red("\u2716 Failed: Tailwind CSS v4 setup failed"));
+        throw err;
+      }
+    }
+    if (setupShadcnPrompt) {
+      const hasPreset = await confirm({
+        message: "Do you have a custom shadcn UI preset code?",
+        initialValue: false
+      });
+      handleCancel(hasPreset);
+      let presetCode = "";
+      if (hasPreset) {
+        const enteredPreset = await text2({
+          message: "Enter your custom shadcn UI preset code:",
+          placeholder: "e.g. 123456",
+          validate: (val) => {
+            if (!val || !val.trim()) return "Preset code cannot be empty";
+            return;
+          }
+        });
+        handleCancel(enteredPreset);
+        presetCode = enteredPreset.trim();
+      }
+      const args = ["dlx", "shadcn@latest", "init"];
+      if (presetCode) {
+        args.push("--preset", presetCode);
+      }
+      args.push("--template", "vite");
+      console.log(
+        pc5.cyan("\nStarting interactive shadcn UI initialization...")
+      );
+      await runInteractiveCommand("pnpm", args, webDir);
+      console.log(
+        pc5.green(
+          isMonorepo ? `
+\u2714 Success: shadcn UI successfully initialized in apps/${createdDirName}
+` : `
+\u2714 Success: shadcn UI successfully initialized at root
+`
+        )
+      );
+    }
+    return webDir;
+  } catch (error) {
+    console.error(pc5.red(`
+\u2716 Failed: Vite React frontend setup failed`));
+    console.error(pc5.red(`Error details: ${error.message || error}
+`));
+    process.exit(1);
   }
 }
 
-// src/tasks/eslint.ts
+// src/tasks/git.ts
 import { confirm as confirm2, spinner as spinner3 } from "@clack/prompts";
 import pc6 from "picocolors";
 import fsPromises4 from "fs/promises";
 import path4 from "path";
-async function promptEslint() {
+async function promptGit() {
   return await confirm2({
-    message: "Do you want to setup ESLint linting in packages/eslint?",
+    message: "Do you want to initialize a local Git repository?",
     initialValue: true
   });
 }
-async function setupEslint(projectPath) {
-  const eslintDir = path4.join(projectPath, "packages", "eslint");
-  await fsPromises4.mkdir(eslintDir, { recursive: true });
-  await runCommand("pnpm init", { cwd: eslintDir, silent: true });
-  const eslintPackagePath = path4.join(eslintDir, "package.json");
-  const eslintPackageRaw = await fsPromises4.readFile(eslintPackagePath, "utf8");
-  const eslintPkg = JSON.parse(eslintPackageRaw);
-  eslintPkg.name = "@config/eslint";
-  eslintPkg.version = "1.0.0";
-  eslintPkg.private = true;
-  eslintPkg.type = "module";
-  eslintPkg.main = "eslint.config.ts";
-  eslintPkg.exports = {
-    ".": "./eslint.config.ts"
+async function gitInit(projectPath) {
+  await runCommand("git init", { cwd: projectPath, silent: true });
+  const gitignore = [
+    "# Dependency directories",
+    "node_modules/",
+    "jspm_packages/",
+    "web_modules/",
+    "",
+    "# Build and output outputs",
+    "dist/",
+    "build/",
+    ".next/",
+    "out/",
+    ".turbo/",
+    "",
+    "# Environments",
+    ".env",
+    ".env.local",
+    ".env.development.local",
+    ".env.test.local",
+    ".env.production.local",
+    "",
+    "# Logs",
+    "npm-debug.log*",
+    "yarn-debug.log*",
+    "yarn-error.log*",
+    "pnpm-debug.log*",
+    "*.log",
+    "",
+    "# OS Metadata",
+    ".DS_Store",
+    "Thumbs.db",
+    ""
+  ].join("\n");
+  await fsPromises4.writeFile(
+    path4.join(projectPath, ".gitignore"),
+    gitignore,
+    "utf8"
+  );
+}
+async function runGitSetup(projectPath) {
+  const gitPrompt = await promptGit();
+  handleCancel(gitPrompt);
+  let gitInitialized = false;
+  if (gitPrompt) {
+    const s = spinner3();
+    console.log("\n");
+    s.start("Initializing Git repository...");
+    try {
+      await gitInit(projectPath);
+      s.stop(pc6.green("\u2714 Success: Git repository initialized"));
+      gitInitialized = true;
+    } catch (error) {
+      s.stop(pc6.red("\u2716 Failed: Git initialization failed"));
+      console.error(pc6.red(`
+Error details: ${error.message || error}`));
+      process.exit(1);
+    }
+    console.log("\n");
+  }
+  return gitInitialized;
+}
+
+// src/tasks/addreadme.ts
+import fsPromises5 from "fs/promises";
+import path5 from "path";
+async function setupReadme(projectPath, workspaceName) {
+  const readmePath = path5.join(projectPath, "README.md");
+  const readmeContent = [
+    `# Morax `,
+    "",
+    "Welcome to your next-generation, high-performance monorepo workspace generated by **Morax**.",
+    "",
+    "## Workspace Structure",
+    "",
+    "- **`apps/`** \u2014 Frontend applications, backend servers, and user-facing services.",
+    "- **`packages/`** \u2014 Shared modules, TypeScript configurations, ESLint rule sets, and common utility libraries.",
+    "",
+    "## Key Commands",
+    "",
+    "Run the following commands from the root directory of your workspace:",
+    "",
+    "### Development",
+    "Start all dev servers and hot-reloading configurations concurrently:",
+    "```bash",
+    "pnpm dev",
+    "```",
+    "",
+    "### Linting",
+    "Run static analysis across all workspaces using your shared ESLint rules:",
+    "```bash",
+    "pnpm lint",
+    "```",
+    "",
+    "### Formatting",
+    "Automatically format all codebase files using Prettier:",
+    "```bash",
+    "pnpm format",
+    "```",
+    "",
+    "---",
+    "",
+    "*Generated with love by [Morax Scaffolder CLI](https://github.com/Elitedv/morax).*",
+    ""
+  ].join("\n");
+  await fsPromises5.writeFile(readmePath, readmeContent, "utf8");
+}
+
+// src/core/endcli.ts
+import pc7 from "picocolors";
+import { outro } from "@clack/prompts";
+function endCli(name, projectPath) {
+  outro(pc7.yellow("Morax scaffolding completed successfully!"));
+  console.log(
+    `\u26A1 ${pc7.bold("Workspace ready:")} ${pc7.yellow(name)}
+${pc7.bold("To start developing:")}
+ 1. ${pc7.cyan(`cd ${name}`)}
+ 2. ${pc7.cyan("pnpm dev")}`
+  );
+}
+
+// src/core/react-runner.ts
+async function runReactScaffolder(name, projectPath) {
+  const finalProjectPath = await setupReact(projectPath, false);
+  await setupReadme(finalProjectPath, path6.basename(finalProjectPath));
+  await runGitSetup(finalProjectPath);
+  const installSpinner = spinner4();
+  console.log("\n");
+  installSpinner.start("Running final package installation...");
+  try {
+    await runCommand("pnpm install", { cwd: finalProjectPath, silent: true });
+    installSpinner.stop(
+      pc8.green("\u2714 Success: Dependencies configured successfully")
+    );
+  } catch (error) {
+    installSpinner.stop(pc8.red("\u2716 Warning: Final package installation failed"));
+    console.error(pc8.red(`
+Error details: ${error.message || error}`));
+  }
+  console.log("\n");
+  endCli(path6.basename(finalProjectPath), finalProjectPath);
+}
+
+// src/core/next-runner.ts
+import path9 from "path";
+import { spinner as spinner5 } from "@clack/prompts";
+import pc11 from "picocolors";
+
+// src/tasks/nextjs.ts
+import { confirm as confirm3 } from "@clack/prompts";
+import pc9 from "picocolors";
+import fsPromises6 from "fs/promises";
+import path7 from "path";
+import { spawn as spawn2 } from "child_process";
+function runInteractiveCommand2(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: true,
+      env: { ...process.env, NODE_NO_WARNINGS: "1" }
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new Error(
+            `Command "${command} ${args.join(" ")}" exited with code ${code}`
+          )
+        );
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function setupNextjs(projectPath, isMonorepo = true) {
+  const appsDir = isMonorepo ? path7.join(projectPath, "apps") : path7.dirname(projectPath);
+  const targetName = isMonorepo ? "web" : path7.basename(projectPath);
+  const webDir = path7.join(appsDir, targetName);
+  try {
+    await fsPromises6.rm(webDir, { recursive: true, force: true });
+  } catch {
+  }
+  console.log(pc9.cyan("\nStarting interactive Next.js application setup..."));
+  await runInteractiveCommand2(
+    "npx",
+    ["create-next-app@latest", targetName],
+    appsDir
+  );
+  return webDir;
+}
+
+// src/tasks/shadcn.ts
+import { confirm as confirm4 } from "@clack/prompts";
+import pc10 from "picocolors";
+import fsPromises7 from "fs/promises";
+import path8 from "path";
+import { spawn as spawn3 } from "child_process";
+async function promptShadcn() {
+  return await confirm4({
+    message: "Do you want to setup shadcn UI in your Next.js website (apps/web)?",
+    initialValue: true
+  });
+}
+function runInteractiveCommand3(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: true,
+      env: { ...process.env, NODE_NO_WARNINGS: "1" }
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new Error(
+            `Command "${command} ${args.join(" ")}" exited with code ${code}`
+          )
+        );
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function setupShadcn(projectPath, isMonorepo = true) {
+  const webDir = isMonorepo ? path8.join(projectPath, "apps", "web") : projectPath;
+  console.log(pc10.cyan("\nStarting interactive shadcn UI initialization..."));
+  await runInteractiveCommand3(
+    "pnpm",
+    ["dlx", "shadcn@latest", "init", "--template", "next"],
+    webDir
+  );
+}
+async function runShadcnSetup(projectPath, isMonorepo = true) {
+  const webDir = isMonorepo ? path8.join(projectPath, "apps", "web") : projectPath;
+  try {
+    await fsPromises7.access(webDir);
+  } catch {
+    return;
+  }
+  const shadcnPrompt = await promptShadcn();
+  handleCancel(shadcnPrompt);
+  if (shadcnPrompt) {
+    try {
+      await setupShadcn(projectPath, isMonorepo);
+      console.log(
+        pc10.green(
+          isMonorepo ? "\n\u2714 Success: shadcn UI successfully initialized in apps/web\n" : "\n\u2714 Success: shadcn UI successfully initialized at root\n"
+        )
+      );
+    } catch (error) {
+      console.error(pc10.red(`
+\u2716 Failed: shadcn UI setup failed`));
+      console.error(pc10.red(`Error details: ${error.message || error}
+`));
+      process.exit(1);
+    }
+  }
+}
+
+// src/core/next-runner.ts
+async function runNextScaffolder(name, projectPath) {
+  const finalProjectPath = await setupNextjs(projectPath, false);
+  await runShadcnSetup(finalProjectPath, false);
+  await setupReadme(finalProjectPath, path9.basename(finalProjectPath));
+  await runGitSetup(finalProjectPath);
+  const installSpinner = spinner5();
+  console.log("\n");
+  installSpinner.start("Running final package installation...");
+  try {
+    await runCommand("pnpm install", { cwd: finalProjectPath, silent: true });
+    installSpinner.stop(
+      pc11.green("\u2714 Success: Dependencies configured successfully")
+    );
+  } catch (error) {
+    installSpinner.stop(pc11.red("\u2716 Warning: Final package installation failed"));
+    console.error(pc11.red(`
+Error details: ${error.message || error}`));
+  }
+  console.log("\n");
+  endCli(path9.basename(finalProjectPath), finalProjectPath);
+}
+
+// src/tasks/prettier.ts
+import { confirm as confirm5, spinner as spinner6 } from "@clack/prompts";
+import pc12 from "picocolors";
+import fsPromises8 from "fs/promises";
+import path10 from "path";
+async function promptPrettier() {
+  return await confirm5({
+    message: "Do you want to setup Prettier code formatting?",
+    initialValue: true
+  });
+}
+async function setupPrettier(projectPath) {
+  await runCommand("pnpm add -D -E prettier -w", { cwd: projectPath });
+  const prettierrc = {
+    semi: true,
+    singleQuote: true,
+    tabWidth: 2,
+    trailingComma: "all",
+    printWidth: 100
+  };
+  await fsPromises8.writeFile(
+    path10.join(projectPath, ".prettierrc"),
+    JSON.stringify(prettierrc, null, 2),
+    "utf8"
+  );
+  const prettierignore = [
+    "# Dependencies",
+    "node_modules/",
+    "jspm_packages/",
+    "web_modules/",
+    "",
+    "# Build and outputs",
+    "dist/",
+    "build/",
+    ".next/",
+    "out/",
+    ".turbo/",
+    "",
+    "# Configuration locks",
+    "pnpm-lock.yaml",
+    "",
+    "# Environment files",
+    ".env",
+    ".env.*",
+    ""
+  ].join("\n");
+  await fsPromises8.writeFile(
+    path10.join(projectPath, ".prettierignore"),
+    prettierignore,
+    "utf8"
+  );
+  const rootPackagePath = path10.join(projectPath, "package.json");
+  const rootPackageContent = await fsPromises8.readFile(rootPackagePath, "utf8");
+  const pkg = JSON.parse(rootPackageContent);
+  pkg.scripts = {
+    ...pkg.scripts || {},
+    format: "prettier --write ."
+  };
+  await fsPromises8.writeFile(
+    rootPackagePath,
+    JSON.stringify(pkg, null, 2),
+    "utf8"
+  );
+  await runCommand("pnpm format", { cwd: projectPath });
+}
+async function runPrettierSetup(projectPath) {
+  const prettierPrompt = await promptPrettier();
+  handleCancel(prettierPrompt);
+  if (prettierPrompt) {
+    const s = spinner6();
+    console.log("\n");
+    s.start("Setting up Prettier auto-formatting...");
+    try {
+      await setupPrettier(projectPath);
+      s.stop(pc12.green("\u2714 Success: Prettier formatting configured"));
+    } catch (error) {
+      s.stop(pc12.red("\u2716 Failed: Prettier setup failed"));
+      console.error(pc12.red(`
+Error details: ${error.message || error}`));
+      process.exit(1);
+    }
+    console.log("\n");
+  }
+}
+
+// src/tasks/eslint.ts
+import { spinner as spinner7 } from "@clack/prompts";
+import pc13 from "picocolors";
+import fsPromises9 from "fs/promises";
+import path11 from "path";
+async function setupEslint(projectPath) {
+  const eslintDir = path11.join(projectPath, "packages", "eslint");
+  await fsPromises9.mkdir(eslintDir, { recursive: true });
+  await runCommand("pnpm init", { cwd: eslintDir, silent: true });
+  const eslintPackagePath = path11.join(eslintDir, "package.json");
+  const eslintPackageRaw = await fsPromises9.readFile(eslintPackagePath, "utf8");
+  const eslintPkg = JSON.parse(eslintPackageRaw);
+  eslintPkg.name = "@config/eslint";
+  eslintPkg.version = "1.0.0";
+  eslintPkg.private = true;
+  eslintPkg.type = "module";
+  eslintPkg.main = "eslint.config.ts";
+  eslintPkg.exports = {
+    ".": "./eslint.config.ts"
   };
   eslintPkg.scripts = {
     lint: "eslint ."
@@ -320,7 +885,7 @@ async function setupEslint(projectPath) {
   delete eslintPkg.keywords;
   delete eslintPkg.author;
   delete eslintPkg.license;
-  await fsPromises4.writeFile(
+  await fsPromises9.writeFile(
     eslintPackagePath,
     JSON.stringify(eslintPkg, null, 2),
     "utf8"
@@ -360,69 +925,57 @@ async function setupEslint(projectPath) {
     ");",
     ""
   ].join("\n");
-  await fsPromises4.writeFile(
-    path4.join(eslintDir, "eslint.config.ts"),
+  await fsPromises9.writeFile(
+    path11.join(eslintDir, "eslint.config.ts"),
     eslintConfigContent,
     "utf8"
   );
-  const rootPackagePath = path4.join(projectPath, "package.json");
-  const rootPackageContent = await fsPromises4.readFile(rootPackagePath, "utf8");
+  const rootPackagePath = path11.join(projectPath, "package.json");
+  const rootPackageContent = await fsPromises9.readFile(rootPackagePath, "utf8");
   const rootPkg = JSON.parse(rootPackageContent);
   rootPkg.scripts = {
     ...rootPkg.scripts || {},
     lint: "pnpm --filter @config/eslint lint"
   };
-  await fsPromises4.writeFile(
+  await fsPromises9.writeFile(
     rootPackagePath,
     JSON.stringify(rootPkg, null, 2),
     "utf8"
   );
 }
 async function runEslintSetup(projectPath) {
-  const packagesDir = path4.join(projectPath, "packages");
+  const packagesDir = path11.join(projectPath, "packages");
   try {
-    await fsPromises4.access(packagesDir);
+    await fsPromises9.access(packagesDir);
   } catch {
     return;
   }
-  const eslintPrompt = await promptEslint();
-  handleCancel(eslintPrompt);
-  if (eslintPrompt) {
-    const s = spinner3();
-    console.log("\n");
-    s.start("Setting up modular ESLint in packages/eslint...");
-    try {
-      await setupEslint(projectPath);
-      s.stop(
-        pc6.green("\u2714 Success: Modular ESLint configured in packages/eslint")
-      );
-    } catch (error) {
-      s.stop(pc6.red("\u2716 Failed: ESLint setup failed"));
-      console.error(pc6.red(`
+  const s = spinner7();
+  console.log("\n");
+  s.start("Setting up modular ESLint in packages/eslint...");
+  try {
+    await setupEslint(projectPath);
+    s.stop(pc13.green("\u2714 Success: Modular ESLint configured in packages/eslint"));
+  } catch (error) {
+    s.stop(pc13.red("\u2716 Failed: ESLint setup failed"));
+    console.error(pc13.red(`
 Error details: ${error.message || error}`));
-      process.exit(1);
-    }
-    console.log("\n");
-  }
-}
-
-// src/tasks/typescript.ts
-import { confirm as confirm3, spinner as spinner4 } from "@clack/prompts";
-import pc7 from "picocolors";
-import fsPromises5 from "fs/promises";
-import path5 from "path";
-async function promptTypescript() {
-  return await confirm3({
-    message: "Do you want to setup TypeScript config in packages/typescript?",
-    initialValue: true
-  });
+    process.exit(1);
+  }
+  console.log("\n");
 }
+
+// src/tasks/typescript.ts
+import { spinner as spinner8 } from "@clack/prompts";
+import pc14 from "picocolors";
+import fsPromises10 from "fs/promises";
+import path12 from "path";
 async function setupTypescript(projectPath) {
-  const tsDir = path5.join(projectPath, "packages", "typescript");
-  await fsPromises5.mkdir(tsDir, { recursive: true });
+  const tsDir = path12.join(projectPath, "packages", "typescript");
+  await fsPromises10.mkdir(tsDir, { recursive: true });
   await runCommand("pnpm init", { cwd: tsDir, silent: true });
-  const tsPackagePath = path5.join(tsDir, "package.json");
-  const tsPackageRaw = await fsPromises5.readFile(tsPackagePath, "utf8");
+  const tsPackagePath = path12.join(tsDir, "package.json");
+  const tsPackageRaw = await fsPromises10.readFile(tsPackagePath, "utf8");
   const tsPkg = JSON.parse(tsPackageRaw);
   tsPkg.name = "@config/typescript";
   tsPkg.version = "1.0.0";
@@ -436,7 +989,7 @@ async function setupTypescript(projectPath) {
   delete tsPkg.license;
   delete tsPkg.main;
   delete tsPkg.scripts;
-  await fsPromises5.writeFile(
+  await fsPromises10.writeFile(
     tsPackagePath,
     JSON.stringify(tsPkg, null, 2),
     "utf8"
@@ -448,58 +1001,54 @@ async function setupTypescript(projectPath) {
   await runCommand("npx tsc --init", { cwd: tsDir });
 }
 async function runTypescriptSetup(projectPath) {
-  const packagesDir = path5.join(projectPath, "packages");
+  const packagesDir = path12.join(projectPath, "packages");
   try {
-    await fsPromises5.access(packagesDir);
+    await fsPromises10.access(packagesDir);
   } catch {
     return;
   }
-  const tsPrompt = await promptTypescript();
-  handleCancel(tsPrompt);
-  if (tsPrompt) {
-    const s = spinner4();
-    console.log("\n");
-    s.start("Setting up modular TypeScript config in packages/typescript...");
-    try {
-      await setupTypescript(projectPath);
-      s.stop(
-        pc7.green(
-          "\u2714 Success: Modular TypeScript config configured in packages/typescript"
-        )
-      );
-    } catch (error) {
-      s.stop(pc7.red("\u2716 Failed: TypeScript config setup failed"));
-      console.error(pc7.red(`
+  const s = spinner8();
+  console.log("\n");
+  s.start("Setting up modular TypeScript config in packages/typescript...");
+  try {
+    await setupTypescript(projectPath);
+    s.stop(
+      pc14.green(
+        "\u2714 Success: Modular TypeScript config configured in packages/typescript"
+      )
+    );
+  } catch (error) {
+    s.stop(pc14.red("\u2716 Failed: TypeScript config setup failed"));
+    console.error(pc14.red(`
 Error details: ${error.message || error}`));
-      process.exit(1);
-    }
-    console.log("\n");
+    process.exit(1);
   }
+  console.log("\n");
 }
 
 // src/tasks/server.ts
-import { confirm as confirm4, spinner as spinner5 } from "@clack/prompts";
-import pc8 from "picocolors";
-import fsPromises6 from "fs/promises";
-import path6 from "path";
+import { confirm as confirm6, spinner as spinner9 } from "@clack/prompts";
+import pc15 from "picocolors";
+import fsPromises11 from "fs/promises";
+import path13 from "path";
 async function promptServer() {
-  return await confirm4({
-    message: "Do you want to setup a basic Express backend in apps/server?",
+  return await confirm6({
+    message: "Do you want to setup a Express backend in apps/server?",
     initialValue: true
   });
 }
 async function setupServer(projectPath) {
-  const serverDir = path6.join(projectPath, "apps", "server");
-  const srcDir = path6.join(serverDir, "src");
-  await fsPromises6.mkdir(srcDir, { recursive: true });
+  const serverDir = path13.join(projectPath, "apps", "server");
+  const srcDir = path13.join(serverDir, "src");
+  await fsPromises11.mkdir(srcDir, { recursive: true });
   await runCommand("pnpm init", { cwd: serverDir, silent: true });
-  const serverPackagePath = path6.join(serverDir, "package.json");
-  const serverPackageRaw = await fsPromises6.readFile(serverPackagePath, "utf8");
+  const serverPackagePath = path13.join(serverDir, "package.json");
+  const serverPackageRaw = await fsPromises11.readFile(serverPackagePath, "utf8");
   const serverPkg = JSON.parse(serverPackageRaw);
-  const eslintDir = path6.join(projectPath, "packages", "eslint");
+  const eslintDir = path13.join(projectPath, "packages", "eslint");
   let hasEslint = false;
   try {
-    await fsPromises6.access(eslintDir);
+    await fsPromises11.access(eslintDir);
     hasEslint = true;
   } catch {
   }
@@ -523,7 +1072,7 @@ async function setupServer(projectPath) {
   delete serverPkg.keywords;
   delete serverPkg.author;
   delete serverPkg.license;
-  await fsPromises6.writeFile(
+  await fsPromises11.writeFile(
     serverPackagePath,
     JSON.stringify(serverPkg, null, 2),
     "utf8"
@@ -536,8 +1085,8 @@ async function setupServer(projectPath) {
     },
     include: ["src/**/*"]
   };
-  await fsPromises6.writeFile(
-    path6.join(serverDir, "tsconfig.json"),
+  await fsPromises11.writeFile(
+    path13.join(serverDir, "tsconfig.json"),
     JSON.stringify(tsconfigContent, null, 2),
     "utf8"
   );
@@ -553,8 +1102,8 @@ async function setupServer(projectPath) {
       "];",
       ""
     ].join("\n");
-    await fsPromises6.writeFile(
-      path6.join(serverDir, "eslint.config.ts"),
+    await fsPromises11.writeFile(
+      path13.join(serverDir, "eslint.config.ts"),
       eslintConfigContent,
       "utf8"
     );
@@ -589,586 +1138,115 @@ async function setupServer(projectPath) {
     "});",
     ""
   ].join("\n");
-  await fsPromises6.writeFile(
-    path6.join(srcDir, "index.ts"),
+  await fsPromises11.writeFile(
+    path13.join(srcDir, "index.ts"),
     indexTsContent,
     "utf8"
   );
 }
 async function runServerSetup(projectPath) {
-  const appsDir = path6.join(projectPath, "apps");
+  const appsDir = path13.join(projectPath, "apps");
   try {
-    await fsPromises6.access(appsDir);
+    await fsPromises11.access(appsDir);
   } catch {
     return;
   }
   const serverPrompt = await promptServer();
   handleCancel(serverPrompt);
   if (serverPrompt) {
-    const s = spinner5();
+    const s = spinner9();
     console.log("\n");
     s.start("Setting up modular Express backend in apps/server...");
     try {
       await setupServer(projectPath);
       s.stop(
-        pc8.green(
-          "\u2714 Success: Modular Express backend configured in apps/server"
-        )
-      );
-    } catch (error) {
-      s.stop(pc8.red("\u2716 Failed: Express backend setup failed"));
-      console.error(pc8.red(`
-Error details: ${error.message || error}`));
-      process.exit(1);
-    }
-    console.log("\n");
-  }
-}
-
-// src/tasks/git.ts
-import { confirm as confirm5, spinner as spinner6 } from "@clack/prompts";
-import pc9 from "picocolors";
-import fsPromises7 from "fs/promises";
-import path7 from "path";
-async function promptGit() {
-  return await confirm5({
-    message: "Do you want to initialize a local Git repository?",
-    initialValue: true
-  });
-}
-async function gitInit(projectPath) {
-  await runCommand("git init", { cwd: projectPath, silent: true });
-  const gitignore = [
-    "# Dependency directories",
-    "node_modules/",
-    "jspm_packages/",
-    "web_modules/",
-    "",
-    "# Build and output outputs",
-    "dist/",
-    "build/",
-    ".next/",
-    "out/",
-    ".turbo/",
-    "",
-    "# Environments",
-    ".env",
-    ".env.local",
-    ".env.development.local",
-    ".env.test.local",
-    ".env.production.local",
-    "",
-    "# Logs",
-    "npm-debug.log*",
-    "yarn-debug.log*",
-    "yarn-error.log*",
-    "pnpm-debug.log*",
-    "*.log",
-    "",
-    "# OS Metadata",
-    ".DS_Store",
-    "Thumbs.db",
-    ""
-  ].join("\n");
-  await fsPromises7.writeFile(
-    path7.join(projectPath, ".gitignore"),
-    gitignore,
-    "utf8"
-  );
-}
-async function runGitSetup(projectPath) {
-  const gitPrompt = await promptGit();
-  handleCancel(gitPrompt);
-  let gitInitialized = false;
-  if (gitPrompt) {
-    const s = spinner6();
-    console.log("\n");
-    s.start("Initializing Git repository...");
-    try {
-      await gitInit(projectPath);
-      s.stop(pc9.green("\u2714 Success: Git repository initialized"));
-      gitInitialized = true;
-    } catch (error) {
-      s.stop(pc9.red("\u2716 Failed: Git initialization failed"));
-      console.error(pc9.red(`
-Error details: ${error.message || error}`));
-      process.exit(1);
-    }
-    console.log("\n");
-  }
-  return gitInitialized;
-}
-
-// src/tasks/husky.ts
-import { confirm as confirm6, spinner as spinner7 } from "@clack/prompts";
-import pc10 from "picocolors";
-import fsPromises8 from "fs/promises";
-import path8 from "path";
-async function promptHusky() {
-  return await confirm6({
-    message: "Do you want to setup Husky pre-commit hooks?",
-    initialValue: true
-  });
-}
-async function setupHusky(projectPath) {
-  await runCommand("pnpm add -D -E husky -w", { cwd: projectPath });
-  await runCommand("pnpm exec husky init", { cwd: projectPath });
-  const preCommitPath = path8.join(projectPath, ".husky", "pre-commit");
-  let hookContent = "";
-  try {
-    hookContent = await fsPromises8.readFile(preCommitPath, "utf8");
-  } catch {
-    hookContent = "pnpm test";
-  }
-  hookContent = hookContent.replace("pnpm test", "pnpm format");
-  if (!hookContent.includes("git add .")) {
-    hookContent = hookContent.trim() + "\ngit add .\n";
-  }
-  await fsPromises8.writeFile(preCommitPath, hookContent, "utf8");
-  try {
-    await fsPromises8.chmod(preCommitPath, 493);
-  } catch {
-  }
-}
-async function runHuskySetup(projectPath, gitInitialized) {
-  if (!gitInitialized) return;
-  const huskyPrompt = await promptHusky();
-  handleCancel(huskyPrompt);
-  if (huskyPrompt) {
-    const s = spinner7();
-    console.log("\n");
-    s.start("Setting up Husky hooks...");
-    try {
-      await setupHusky(projectPath);
-      s.stop(pc10.green("\u2714 Success: Husky pre-commit hooks configured"));
-    } catch (error) {
-      s.stop(pc10.red("\u2716 Failed: Husky setup failed"));
-      console.error(pc10.red(`
-Error details: ${error.message || error}`));
-      process.exit(1);
-    }
-    console.log("\n");
-  }
-}
-
-// src/core/endcli.ts
-import pc11 from "picocolors";
-import { outro } from "@clack/prompts";
-import boxen2 from "boxen";
-function endCli(name, projectPath) {
-  outro(pc11.yellow("Morax scaffolding completed successfully!"));
-  console.log(
-    boxen2(
-      `\u26A1 ${pc11.bold("Workspace ready:")} ${pc11.yellow(name)}
-Location: ${pc11.cyan(projectPath)}
-
-${pc11.bold("To start developing:")}
- 1. ${pc11.cyan(`cd ${name}`)}
- 2. ${pc11.cyan("pnpm dev")}
-
-\u{1F4A1} Code formatting & git orchestration is fully active.`,
-      {
-        padding: 0,
-        margin: 0,
-        borderStyle: "round",
-        borderColor: "yellow",
-        title: pc11.black(pc11.bold(" Setup Complete ")),
-        titleAlignment: "center"
-      }
-    )
-  );
-}
-
-// src/tasks/addreadme.ts
-import fsPromises9 from "fs/promises";
-import path9 from "path";
-async function setupReadme(projectPath, workspaceName) {
-  const readmePath = path9.join(projectPath, "README.md");
-  const readmeContent = [
-    `# Morax `,
-    "",
-    "Welcome to your next-generation, high-performance monorepo workspace generated by **Morax**.",
-    "",
-    "## Workspace Structure",
-    "",
-    "- **`apps/`** \u2014 Frontend applications, backend servers, and user-facing services.",
-    "- **`packages/`** \u2014 Shared modules, TypeScript configurations, ESLint rule sets, and common utility libraries.",
-    "",
-    "## Key Commands",
-    "",
-    "Run the following commands from the root directory of your workspace:",
-    "",
-    "### Development",
-    "Start all dev servers and hot-reloading configurations concurrently:",
-    "```bash",
-    "pnpm dev",
-    "```",
-    "",
-    "### Linting",
-    "Run static analysis across all workspaces using your shared ESLint rules:",
-    "```bash",
-    "pnpm lint",
-    "```",
-    "",
-    "### Formatting",
-    "Automatically format all codebase files using Prettier:",
-    "```bash",
-    "pnpm format",
-    "```",
-    "",
-    "---",
-    "",
-    "*Generated with love by [Morax Scaffolder CLI](https://github.com/Elitedv/morax).*",
-    ""
-  ].join("\n");
-  await fsPromises9.writeFile(readmePath, readmeContent, "utf8");
-}
-
-// src/core/web.ts
-import { select } from "@clack/prompts";
-
-// src/tasks/shadcn.ts
-import { confirm as confirm7 } from "@clack/prompts";
-import pc12 from "picocolors";
-import fsPromises10 from "fs/promises";
-import path10 from "path";
-import { spawn } from "child_process";
-async function promptShadcn() {
-  return await confirm7({
-    message: "Do you want to setup shadcn UI in your Next.js website (apps/web)?",
-    initialValue: true
-  });
-}
-function runInteractiveCommand(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      stdio: "inherit",
-      shell: true,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Command "${command} ${args.join(" ")}" exited with code ${code}`));
-      }
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-async function setupShadcn(projectPath) {
-  const webDir = path10.join(projectPath, "apps", "web");
-  console.log(pc12.cyan("\nStarting interactive shadcn UI initialization..."));
-  await runInteractiveCommand("pnpm", ["dlx", "shadcn@latest", "init", "--template", "next"], webDir);
-}
-async function runShadcnSetup(projectPath) {
-  const webDir = path10.join(projectPath, "apps", "web");
-  try {
-    await fsPromises10.access(webDir);
-  } catch {
-    return;
-  }
-  const shadcnPrompt = await promptShadcn();
-  handleCancel(shadcnPrompt);
-  if (shadcnPrompt) {
-    try {
-      await setupShadcn(projectPath);
-      console.log(pc12.green("\n\u2714 Success: shadcn UI successfully initialized in apps/web\n"));
+        pc15.green(
+          "\u2714 Success: Modular Express backend configured in apps/server"
+        )
+      );
     } catch (error) {
-      console.error(pc12.red(`
-\u2716 Failed: shadcn UI setup failed`));
-      console.error(pc12.red(`Error details: ${error.message || error}
-`));
+      s.stop(pc15.red("\u2716 Failed: Express backend setup failed"));
+      console.error(pc15.red(`
+Error details: ${error.message || error}`));
       process.exit(1);
     }
+    console.log("\n");
   }
 }
 
-// src/tasks/nextjs.ts
-import { confirm as confirm8 } from "@clack/prompts";
-import pc13 from "picocolors";
-import fsPromises11 from "fs/promises";
-import path11 from "path";
-import { spawn as spawn2 } from "child_process";
-function runInteractiveCommand2(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn2(command, args, {
-      cwd,
-      stdio: "inherit",
-      shell: true,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(
-          new Error(
-            `Command "${command} ${args.join(" ")}" exited with code ${code}`
-          )
-        );
-      }
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
+// src/tasks/husky.ts
+import { confirm as confirm7, spinner as spinner10 } from "@clack/prompts";
+import pc16 from "picocolors";
+import fsPromises12 from "fs/promises";
+import path14 from "path";
+async function promptHusky() {
+  return await confirm7({
+    message: "Do you want to setup Husky pre-commit hooks?",
+    initialValue: true
   });
 }
-async function setupNextjs(projectPath) {
-  const appsDir = path11.join(projectPath, "apps");
-  const webDir = path11.join(appsDir, "web");
+async function setupHusky(projectPath) {
+  await runCommand("pnpm add -D -E husky -w", { cwd: projectPath });
+  await runCommand("pnpm exec husky init", { cwd: projectPath });
+  const preCommitPath = path14.join(projectPath, ".husky", "pre-commit");
+  let hookContent = "";
   try {
-    await fsPromises11.rm(webDir, { recursive: true, force: true });
+    hookContent = await fsPromises12.readFile(preCommitPath, "utf8");
   } catch {
+    hookContent = "pnpm test";
   }
-  console.log(pc13.cyan("\nStarting interactive Next.js application setup..."));
-  await runInteractiveCommand2(
-    "npx",
-    ["create-next-app@latest", "web"],
-    appsDir
-  );
-}
-
-// src/tasks/react.ts
-import pc14 from "picocolors";
-import fsPromises12 from "fs/promises";
-import path12 from "path";
-import { spawn as spawn3 } from "child_process";
-import { confirm as confirm9, spinner as spinner8, text as text2 } from "@clack/prompts";
-function runInteractiveCommand3(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn3(command, args, {
-      cwd,
-      stdio: "inherit",
-      shell: true,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(
-          new Error(
-            `Command "${command} ${args.join(" ")}" exited with code ${code}`
-          )
-        );
-      }
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-async function setupReact(projectPath) {
-  const appsDir = path12.join(projectPath, "apps");
-  console.log(pc14.magentaBright("\n\u{1F537} IMPORTANT INSTRUCTIONS:"));
-  console.log(pc14.magentaBright("During the Vite interactive configuration prompts, please select:"));
-  console.log(pc14.magentaBright(`  1. Install & Start: Choose ${pc14.bold("No")} when asked "Install with npm/pnpm and start now?"`));
-  console.log(pc14.magentaBright("This allows Morax CLI to continue automatically configuring your workspace (ESLint, Prettier, Tailwind, packages, etc.)!"));
-  console.log(pc14.cyan("\nStarting interactive Vite React application setup..."));
-  let beforeDirs = [];
+  hookContent = hookContent.replace("pnpm test", "pnpm format");
+  if (!hookContent.includes("git add .")) {
+    hookContent = hookContent.trim() + "\ngit add .\n";
+  }
+  await fsPromises12.writeFile(preCommitPath, hookContent, "utf8");
   try {
-    beforeDirs = await fsPromises12.readdir(appsDir);
+    await fsPromises12.chmod(preCommitPath, 493);
   } catch {
   }
-  try {
-    await runInteractiveCommand3(
-      "pnpm",
-      ["create", "vite@latest"],
-      appsDir
-    );
-    let afterDirs = [];
-    try {
-      afterDirs = await fsPromises12.readdir(appsDir);
-    } catch {
-    }
-    const newDirs = afterDirs.filter((d) => !beforeDirs.includes(d));
-    let createdDirName = "web";
-    if (newDirs.length > 0) {
-      createdDirName = newDirs[0];
-    }
-    const webDir = path12.join(appsDir, createdDirName);
+}
+async function runHuskySetup(projectPath, gitInitialized) {
+  if (!gitInitialized) return;
+  const huskyPrompt = await promptHusky();
+  handleCancel(huskyPrompt);
+  if (huskyPrompt) {
+    const s = spinner10();
+    console.log("\n");
+    s.start("Setting up Husky hooks...");
     try {
-      await fsPromises12.access(webDir);
-    } catch {
-      throw new Error(`Vite React application directory "apps/${createdDirName}" was not found. Please ensure you complete the Vite installation.`);
-    }
-    console.log(
-      pc14.green(`
-\u2714 Success: Vite React frontend configured in apps/${createdDirName}
-`)
-    );
-    const setupTailwindPrompt = await confirm9({
-      message: "Do you want to install and configure Tailwind CSS v4?",
-      initialValue: true
-    });
-    handleCancel(setupTailwindPrompt);
-    const setupShadcnPrompt = await confirm9({
-      message: `Do you want to setup shadcn UI in your Vite React website (apps/${createdDirName})?`,
-      initialValue: true
-    });
-    handleCancel(setupShadcnPrompt);
-    const needsTailwind = setupTailwindPrompt || setupShadcnPrompt;
-    if (needsTailwind) {
-      const s = spinner8();
-      s.start("Installing Tailwind CSS v4, Vite integration, and Node types...");
-      try {
-        const pkgPath = path12.join(webDir, "package.json");
-        try {
-          const pkgRaw = await fsPromises12.readFile(pkgPath, "utf8");
-          const pkg = JSON.parse(pkgRaw);
-          pkg.dependencies = pkg.dependencies || {};
-          pkg.devDependencies = pkg.devDependencies || {};
-          pkg.dependencies["tailwindcss"] = "^4.0.0";
-          pkg.devDependencies["@tailwindcss/vite"] = "^4.0.0";
-          pkg.devDependencies["@types/node"] = "^20.11.0";
-          await fsPromises12.writeFile(pkgPath, JSON.stringify(pkg, null, 2), "utf8");
-        } catch {
-        }
-        await runCommand("pnpm install", { cwd: webDir, silent: true });
-        s.message("Configuring Vite plugins and Tailwind CSS imports...");
-        const viteConfigPath = path12.join(webDir, "vite.config.ts");
-        try {
-          let content = await fsPromises12.readFile(viteConfigPath, "utf8");
-          if (!content.includes("@tailwindcss/vite")) {
-            content = "import tailwindcss from '@tailwindcss/vite';\n" + content;
-            if (content.includes("plugins: [react()]")) {
-              content = content.replace("plugins: [react()]", "plugins: [react(), tailwindcss()]");
-            } else if (content.includes("plugins: [react(),]")) {
-              content = content.replace("plugins: [react(),]", "plugins: [react(), tailwindcss()]");
-            } else {
-              content = content.replace(/(plugins:\s*\[\s*react\(\),?\s*)(\])/g, "$1\n    tailwindcss(),\n  $2");
-            }
-            await fsPromises12.writeFile(viteConfigPath, content, "utf8");
-          }
-        } catch {
-        }
-        const indexCssPath = path12.join(webDir, "src", "index.css");
-        try {
-          await fsPromises12.writeFile(indexCssPath, '@import "tailwindcss";\n', "utf8");
-        } catch {
-        }
-        s.stop(pc14.green("\u2714 Success: Tailwind CSS v4 configured successfully\n"));
-      } catch (err) {
-        s.stop(pc14.red("\u2716 Failed: Tailwind CSS v4 setup failed"));
-        throw err;
-      }
-    }
-    if (setupShadcnPrompt) {
-      const s = spinner8();
-      s.start("Configuring path aliases for shadcn UI preflight checks...");
-      try {
-        const tsconfigPaths = [
-          path12.join(webDir, "tsconfig.json"),
-          path12.join(webDir, "tsconfig.app.json")
-        ];
-        for (const tsPath of tsconfigPaths) {
-          try {
-            let content = await fsPromises12.readFile(tsPath, "utf8");
-            if (content.includes('"compilerOptions"')) {
-              if (!content.includes('"paths"')) {
-                content = content.replace(
-                  /("compilerOptions"\s*:\s*\{)/,
-                  `$1
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"]
-    },`
-                );
-                await fsPromises12.writeFile(tsPath, content, "utf8");
-              }
-            } else {
-              content = content.replace(
-                /^(\s*\{)/,
-                `$1
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },`
-              );
-              await fsPromises12.writeFile(tsPath, content, "utf8");
-            }
-          } catch {
-          }
-        }
-        const viteConfigPath = path12.join(webDir, "vite.config.ts");
-        try {
-          let content = await fsPromises12.readFile(viteConfigPath, "utf8");
-          if (!content.includes("import path from 'path'")) {
-            content = "import path from 'path';\n" + content;
-          }
-          if (!content.includes("resolve:")) {
-            content = content.replace(
-              /(plugins:\s*\[[^\]]*\]),?/,
-              `$1,
-  resolve: {
-    alias: {
-      "@": path.resolve(__dirname, "./src"),
-    },
-  }`
-            );
-          }
-          await fsPromises12.writeFile(viteConfigPath, content, "utf8");
-        } catch {
-        }
-        s.stop(pc14.green("\u2714 Success: Path aliases successfully configured\n"));
-      } catch (err) {
-        s.stop(pc14.red("\u2716 Failed: Path alias configuration failed"));
-        throw err;
-      }
-      const hasPreset = await confirm9({
-        message: "Do you have a custom shadcn UI preset code?",
-        initialValue: false
-      });
-      handleCancel(hasPreset);
-      let presetCode = "";
-      if (hasPreset) {
-        const enteredPreset = await text2({
-          message: "Enter your custom shadcn UI preset code:",
-          placeholder: "e.g. 123456",
-          validate: (val) => {
-            if (!val || !val.trim()) return "Preset code cannot be empty";
-            return;
-          }
-        });
-        handleCancel(enteredPreset);
-        presetCode = enteredPreset.trim();
-      }
-      const args = ["dlx", "shadcn@latest", "init"];
-      if (presetCode) {
-        args.push("--preset", presetCode);
-      }
-      args.push("--template", "vite");
-      console.log(pc14.cyan("\nStarting interactive shadcn UI initialization..."));
-      await runInteractiveCommand3("pnpm", args, webDir);
-      console.log(
-        pc14.green(`
-\u2714 Success: shadcn UI successfully initialized in apps/${createdDirName}
-`)
-      );
+      await setupHusky(projectPath);
+      s.stop(pc16.green("\u2714 Success: Husky pre-commit hooks configured"));
+    } catch (error) {
+      s.stop(pc16.red("\u2716 Failed: Husky setup failed"));
+      console.error(pc16.red(`
+Error details: ${error.message || error}`));
+      process.exit(1);
     }
-  } catch (error) {
-    console.error(pc14.red(`
-\u2716 Failed: Vite React frontend setup failed`));
-    console.error(pc14.red(`Error details: ${error.message || error}
-`));
-    process.exit(1);
+    console.log("\n");
   }
 }
 
 // src/core/web.ts
+import { select } from "@clack/prompts";
 async function addweb(projectPath) {
   const framework = await select({
     message: "Which frontend website setup would you like to include in apps/web?",
     options: [
-      { value: "nextjs", label: "Next.js", hint: "The React Framework for the Web" },
-      { value: "react", label: "React (Vite)", hint: "Vite React Starter Template" },
-      { value: "skip", label: "Skip", hint: "Skip setting up a frontend website" }
+      {
+        value: "nextjs",
+        label: "Next.js",
+        hint: "The React Framework for the Web"
+      },
+      {
+        value: "react",
+        label: "React (Vite)",
+        hint: "Vite React Starter Template"
+      },
+      {
+        value: "skip",
+        label: "Skip",
+        hint: "Skip setting up a frontend website"
+      }
     ],
     initialValue: "nextjs"
   });
@@ -1182,44 +1260,133 @@ async function addweb(projectPath) {
 }
 
 // src/core/runner.ts
-async function runWorkspaceScaffolder() {
+async function runWorkspaceScaffolder(options = {}) {
   startCli();
-  const name = await promptWorkspaceName();
-  const projectPath = path13.join(process.cwd(), name);
+  const isMonorepo = !options.react && !options.next;
+  const name = await promptWorkspaceName(isMonorepo);
+  const projectPath = path15.join(process.cwd(), name);
+  if (options.react) {
+    await runReactScaffolder(name, projectPath);
+    return;
+  }
+  if (options.next) {
+    await runNextScaffolder(name, projectPath);
+    return;
+  }
   await makeDirectories(name, projectPath);
   await setupReadme(projectPath, name);
   const gitInitialized = await runGitSetup(projectPath);
-  await runPrettierSetup(projectPath);
-  await runEslintSetup(projectPath);
-  await runTypescriptSetup(projectPath);
-  await runHuskySetup(projectPath, gitInitialized);
-  await runServerSetup(projectPath);
-  await addweb(projectPath);
-  const s = spinner9();
+  const selectedApps = await askServerorFrontendInclue();
+  const selectedTools = await askWhichToolToInclude(
+    selectedApps.includes("server")
+  );
+  if (selectedTools.includes("prettier")) {
+    await runPrettierSetup(projectPath);
+  }
+  if (selectedTools.includes("husky")) {
+    await runHuskySetup(projectPath, gitInitialized);
+  }
+  if (selectedTools.includes("eslint")) {
+    await runEslintSetup(projectPath);
+  }
+  if (selectedTools.includes("typescript")) {
+    await runTypescriptSetup(projectPath);
+  }
+  if (selectedApps.includes("server")) {
+    await runServerSetup(projectPath);
+  }
+  if (selectedApps.includes("web")) {
+    await addweb(projectPath);
+  }
+  const s = spinner11();
   console.log("\n");
   s.start("Running final workspace package installation...");
   try {
     await runCommand("pnpm install", { cwd: projectPath, silent: true });
     s.stop(
-      pc15.green(
+      pc17.green(
         "\u2714 Success: Workspace dependencies and symlinks configured successfully"
       )
     );
   } catch (error) {
-    s.stop(pc15.red("\u2716 Warning: Final workspace installation failed"));
-    console.error(pc15.red(`
+    s.stop(pc17.red("\u2716 Warning: Final workspace installation failed"));
+    console.error(pc17.red(`
 Error details: ${error.message || error}`));
   }
   console.log("\n");
   endCli(name, projectPath);
 }
+async function askWhichToolToInclude(hasServer) {
+  const options = [
+    {
+      value: "prettier",
+      label: "Prettier",
+      hint: "Code formatter rules & auto-formatting script"
+    },
+    {
+      value: "husky",
+      label: "Husky",
+      hint: "Git pre-commit hooks setup (requires Git)"
+    }
+  ];
+  if (!hasServer) {
+    options.splice(
+      1,
+      0,
+      {
+        value: "eslint",
+        label: "ESLint",
+        hint: "Modern Flat Config linter configurations"
+      },
+      {
+        value: "typescript",
+        label: "TypeScript",
+        hint: "Extendable shared TypeScript configurations"
+      }
+    );
+  }
+  const tools = await multiselect({
+    message: hasServer ? "ESLint & TypeScript are required for the Express backend. Select additional configurations/tools:" : "Which configurations/linter tools would you like to set up?",
+    options,
+    required: false
+  });
+  handleCancel(tools);
+  const selectedTools = tools;
+  if (hasServer) {
+    if (!selectedTools.includes("eslint")) selectedTools.push("eslint");
+    if (!selectedTools.includes("typescript")) selectedTools.push("typescript");
+  }
+  return selectedTools;
+}
+async function askServerorFrontendInclue() {
+  const apps = await multiselect({
+    message: "Which backend/frontend applications would you like to set up?",
+    options: [
+      {
+        value: "web",
+        label: "Frontend Web App",
+        hint: "Scaffold Next.js or React (Vite) frontend in apps/web"
+      },
+      {
+        value: "server",
+        label: "Backend Server",
+        hint: "Scaffold Express backend in apps/server"
+      }
+    ],
+    required: false
+  });
+  handleCancel(apps);
+  return apps;
+}
 
 // src/index.ts
 async function main() {
-  await runWorkspaceScaffolder();
+  const isReactOnly = process.argv.includes("--react") || process.argv.includes("-r");
+  const isNextOnly = process.argv.includes("--nextjs") || process.argv.includes("--next") || process.argv.includes("-n");
+  await runWorkspaceScaffolder({ react: isReactOnly, next: isNextOnly });
 }
 main().catch((err) => {
-  console.error(pc16.red("Fatal Error during execution:"), err);
+  console.error(pc18.red("Fatal Error during execution:"), err);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map