create-morax 1.0.2 → 1.0.14

package/dist/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import pc9 from "picocolors";
+import pc18 from "picocolors";
 
 // src/core/runner.ts
-import path6 from "path";
+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";
@@ -53,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";
@@ -82,6 +84,7 @@ import { promisify } from "util";
 import pc3 from "picocolors";
 var execAsync = promisify(exec);
 async function runCommand(command, options = {}) {
+  options.silent = true;
   if (!options.silent) {
     console.log(pc3.cyan(`> ${command}`));
   }
@@ -159,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"));
@@ -200,13 +180,607 @@ 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";
+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 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:"
+    )
+  );
+  console.log(
+    pc5.magentaBright(
+      `  1. Install & Start: Choose ${pc5.bold("No")} when asked "Install with npm/pnpm and start now?"`
+    )
+  );
+  console.log(
+    pc5.magentaBright(
+      "This allows Morax CLI to continue automatically configuring your workspace (ESLint, Prettier, Tailwind, packages, etc.)!"
+    )
+  );
+  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 {
+      afterDirs = await fsPromises3.readdir(appsDir);
+    } catch {
+    }
+    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/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 promptGit() {
+  return await confirm2({
+    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 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 confirm({
+  return await confirm5({
     message: "Do you want to setup Prettier code formatting?",
     initialValue: true
   });
@@ -220,8 +794,8 @@ async function setupPrettier(projectPath) {
     trailingComma: "all",
     printWidth: 100
   };
-  await fsPromises3.writeFile(
-    path3.join(projectPath, ".prettierrc"),
+  await fsPromises8.writeFile(
+    path10.join(projectPath, ".prettierrc"),
     JSON.stringify(prettierrc, null, 2),
     "utf8"
   );
@@ -246,19 +820,19 @@ async function setupPrettier(projectPath) {
     ".env.*",
     ""
   ].join("\n");
-  await fsPromises3.writeFile(
-    path3.join(projectPath, ".prettierignore"),
+  await fsPromises8.writeFile(
+    path10.join(projectPath, ".prettierignore"),
     prettierignore,
     "utf8"
   );
-  const rootPackagePath = path3.join(projectPath, "package.json");
-  const rootPackageContent = await fsPromises3.readFile(rootPackagePath, "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 fsPromises3.writeFile(
+  await fsPromises8.writeFile(
     rootPackagePath,
     JSON.stringify(pkg, null, 2),
     "utf8"
@@ -269,15 +843,15 @@ async function runPrettierSetup(projectPath) {
   const prettierPrompt = await promptPrettier();
   handleCancel(prettierPrompt);
   if (prettierPrompt) {
-    const s = spinner2();
+    const s = spinner6();
     console.log("\n");
     s.start("Setting up Prettier auto-formatting...");
     try {
       await setupPrettier(projectPath);
-      s.stop(pc5.green("\u2714 Success: Prettier formatting configured"));
+      s.stop(pc12.green("\u2714 Success: Prettier formatting configured"));
     } catch (error) {
-      s.stop(pc5.red("\u2716 Failed: Prettier setup failed"));
-      console.error(pc5.red(`
+      s.stop(pc12.red("\u2716 Failed: Prettier setup failed"));
+      console.error(pc12.red(`
 Error details: ${error.message || error}`));
       process.exit(1);
     }
@@ -285,87 +859,328 @@ Error details: ${error.message || error}`));
   }
 }
 
-// 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 promptGit() {
-  return await confirm2({
-    message: "Do you want to initialize a local Git repository?",
+// 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 ."
+  };
+  delete eslintPkg.keywords;
+  delete eslintPkg.author;
+  delete eslintPkg.license;
+  await fsPromises9.writeFile(
+    eslintPackagePath,
+    JSON.stringify(eslintPkg, null, 2),
+    "utf8"
+  );
+  await runCommand(
+    "pnpm add -D eslint @eslint/js @eslint/json globals typescript-eslint",
+    { cwd: eslintDir }
+  );
+  const eslintConfigContent = [
+    'import js from "@eslint/js";',
+    'import globals from "globals";',
+    'import tseslint from "typescript-eslint";',
+    'import eslintJson from "@eslint/json";',
+    "",
+    "export default tseslint.config(",
+    "  {",
+    '    ignores: ["**/dist/**", "**/node_modules/**"],',
+    "  },",
+    "  js.configs.recommended,",
+    "  ...tseslint.configs.recommended,",
+    "  {",
+    "    languageOptions: {",
+    "      globals: {",
+    "        ...globals.node,",
+    "      },",
+    "    },",
+    "    rules: {",
+    '      "no-unused-vars": "off",',
+    '      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],',
+    "    },",
+    "  },",
+    "  {",
+    '    files: ["**/*.json"],',
+    '    language: "json/json",',
+    "    ...eslintJson.configs.recommended,",
+    "  }",
+    ");",
+    ""
+  ].join("\n");
+  await fsPromises9.writeFile(
+    path11.join(eslintDir, "eslint.config.ts"),
+    eslintConfigContent,
+    "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 fsPromises9.writeFile(
+    rootPackagePath,
+    JSON.stringify(rootPkg, null, 2),
+    "utf8"
+  );
+}
+async function runEslintSetup(projectPath) {
+  const packagesDir = path11.join(projectPath, "packages");
+  try {
+    await fsPromises9.access(packagesDir);
+  } catch {
+    return;
+  }
+  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 { 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 = path12.join(projectPath, "packages", "typescript");
+  await fsPromises10.mkdir(tsDir, { recursive: true });
+  await runCommand("pnpm init", { cwd: tsDir, silent: true });
+  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";
+  tsPkg.private = true;
+  tsPkg.type = "module";
+  tsPkg.exports = {
+    "./tsconfig.json": "./tsconfig.json"
+  };
+  delete tsPkg.keywords;
+  delete tsPkg.author;
+  delete tsPkg.license;
+  delete tsPkg.main;
+  delete tsPkg.scripts;
+  await fsPromises10.writeFile(
+    tsPackagePath,
+    JSON.stringify(tsPkg, null, 2),
+    "utf8"
+  );
+  await runCommand(
+    "cd ../.. && pnpm add -D typescript -w && cd packages/typescript",
+    { cwd: tsDir, silent: true }
+  );
+  await runCommand("npx tsc --init", { cwd: tsDir });
+}
+async function runTypescriptSetup(projectPath) {
+  const packagesDir = path12.join(projectPath, "packages");
+  try {
+    await fsPromises10.access(packagesDir);
+  } catch {
+    return;
+  }
+  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");
+}
+
+// src/tasks/server.ts
+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 confirm6({
+    message: "Do you want to setup a Express backend in apps/server?",
     initialValue: true
   });
 }
-async function gitInit(projectPath) {
-  await runCommand("git init", { cwd: projectPath, silent: true });
-  const gitignore = [
-    "# Dependency directories",
-    "node_modules/",
-    "jspm_packages/",
-    "web_modules/",
+async function setupServer(projectPath) {
+  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 = path13.join(serverDir, "package.json");
+  const serverPackageRaw = await fsPromises11.readFile(serverPackagePath, "utf8");
+  const serverPkg = JSON.parse(serverPackageRaw);
+  const eslintDir = path13.join(projectPath, "packages", "eslint");
+  let hasEslint = false;
+  try {
+    await fsPromises11.access(eslintDir);
+    hasEslint = true;
+  } catch {
+  }
+  serverPkg.name = "server";
+  serverPkg.version = "1.0.0";
+  serverPkg.private = true;
+  serverPkg.type = "module";
+  serverPkg.main = "dist/index.js";
+  serverPkg.scripts = {
+    dev: "tsx watch src/index.ts",
+    build: "tsc",
+    start: "node dist/index.js"
+  };
+  serverPkg.devDependencies = {
+    "@config/typescript": "workspace:*"
+  };
+  if (hasEslint) {
+    serverPkg.devDependencies["@config/eslint"] = "workspace:*";
+    serverPkg.scripts["lint"] = "eslint .";
+  }
+  delete serverPkg.keywords;
+  delete serverPkg.author;
+  delete serverPkg.license;
+  await fsPromises11.writeFile(
+    serverPackagePath,
+    JSON.stringify(serverPkg, null, 2),
+    "utf8"
+  );
+  const tsconfigContent = {
+    extends: "@config/typescript/tsconfig.json",
+    compilerOptions: {
+      rootDir: "src",
+      outDir: "dist"
+    },
+    include: ["src/**/*"]
+  };
+  await fsPromises11.writeFile(
+    path13.join(serverDir, "tsconfig.json"),
+    JSON.stringify(tsconfigContent, null, 2),
+    "utf8"
+  );
+  if (hasEslint) {
+    const eslintConfigContent = [
+      "import baseConfig from '@config/eslint';",
+      "",
+      "export default [",
+      "  ...baseConfig,",
+      "  {",
+      "    // Add server-specific overrides if necessary",
+      "  },",
+      "];",
+      ""
+    ].join("\n");
+    await fsPromises11.writeFile(
+      path13.join(serverDir, "eslint.config.ts"),
+      eslintConfigContent,
+      "utf8"
+    );
+  }
+  await runCommand("pnpm add express cors", { cwd: serverDir, silent: false });
+  await runCommand("pnpm add -D @types/express @types/cors tsx typescript", {
+    cwd: serverDir,
+    silent: false
+  });
+  const indexTsContent = [
+    "import express from 'express';",
+    "import cors from 'cors';",
     "",
-    "# Build and output outputs",
-    "dist/",
-    "build/",
-    ".next/",
-    "out/",
-    ".turbo/",
+    "const app = express();",
+    "const port = process.env.PORT || 3001;",
     "",
-    "# Environments",
-    ".env",
-    ".env.local",
-    ".env.development.local",
-    ".env.test.local",
-    ".env.production.local",
+    "// Enable CORS and parsing of JSON request bodies",
+    "app.use(cors());",
+    "app.use(express.json());",
     "",
-    "# Logs",
-    "npm-debug.log*",
-    "yarn-debug.log*",
-    "yarn-error.log*",
-    "pnpm-debug.log*",
-    "*.log",
+    "// Root API health and welcome route",
+    "app.get('/api', (req, res) => {",
+    "  res.json({",
+    "    message: 'Welcome to the Morax High-Performance Backend API!',",
+    "    timestamp: new Date().toISOString(),",
+    "    status: 'healthy',",
+    "  });",
+    "});",
     "",
-    "# OS Metadata",
-    ".DS_Store",
-    "Thumbs.db",
+    "app.listen(port, () => {",
+    "  console.log(`\u{1F680} Server is running on http://localhost:${port}`);",
+    "});",
     ""
   ].join("\n");
-  await fsPromises4.writeFile(
-    path4.join(projectPath, ".gitignore"),
-    gitignore,
+  await fsPromises11.writeFile(
+    path13.join(srcDir, "index.ts"),
+    indexTsContent,
     "utf8"
   );
 }
-async function runGitSetup(projectPath) {
-  const gitPrompt = await promptGit();
-  handleCancel(gitPrompt);
-  let gitInitialized = false;
-  if (gitPrompt) {
-    const s = spinner3();
+async function runServerSetup(projectPath) {
+  const appsDir = path13.join(projectPath, "apps");
+  try {
+    await fsPromises11.access(appsDir);
+  } catch {
+    return;
+  }
+  const serverPrompt = await promptServer();
+  handleCancel(serverPrompt);
+  if (serverPrompt) {
+    const s = spinner9();
     console.log("\n");
-    s.start("Initializing Git repository...");
+    s.start("Setting up modular Express backend in apps/server...");
     try {
-      await gitInit(projectPath);
-      s.stop(pc6.green("\u2714 Success: Git repository initialized"));
-      gitInitialized = true;
+      await setupServer(projectPath);
+      s.stop(
+        pc15.green(
+          "\u2714 Success: Modular Express backend configured in apps/server"
+        )
+      );
     } catch (error) {
-      s.stop(pc6.red("\u2716 Failed: Git initialization failed"));
-      console.error(pc6.red(`
+      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");
   }
-  return gitInitialized;
 }
 
 // src/tasks/husky.ts
-import { confirm as confirm3, spinner as spinner4 } from "@clack/prompts";
-import pc7 from "picocolors";
-import fsPromises5 from "fs/promises";
-import path5 from "path";
+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 confirm3({
+  return await confirm7({
     message: "Do you want to setup Husky pre-commit hooks?",
     initialValue: true
   });
@@ -373,10 +1188,10 @@ async function promptHusky() {
 async function setupHusky(projectPath) {
   await runCommand("pnpm add -D -E husky -w", { cwd: projectPath });
   await runCommand("pnpm exec husky init", { cwd: projectPath });
-  const preCommitPath = path5.join(projectPath, ".husky", "pre-commit");
+  const preCommitPath = path14.join(projectPath, ".husky", "pre-commit");
   let hookContent = "";
   try {
-    hookContent = await fsPromises5.readFile(preCommitPath, "utf8");
+    hookContent = await fsPromises12.readFile(preCommitPath, "utf8");
   } catch {
     hookContent = "pnpm test";
   }
@@ -384,9 +1199,9 @@ async function setupHusky(projectPath) {
   if (!hookContent.includes("git add .")) {
     hookContent = hookContent.trim() + "\ngit add .\n";
   }
-  await fsPromises5.writeFile(preCommitPath, hookContent, "utf8");
+  await fsPromises12.writeFile(preCommitPath, hookContent, "utf8");
   try {
-    await fsPromises5.chmod(preCommitPath, 493);
+    await fsPromises12.chmod(preCommitPath, 493);
   } catch {
   }
 }
@@ -395,15 +1210,15 @@ async function runHuskySetup(projectPath, gitInitialized) {
   const huskyPrompt = await promptHusky();
   handleCancel(huskyPrompt);
   if (huskyPrompt) {
-    const s = spinner4();
+    const s = spinner10();
     console.log("\n");
     s.start("Setting up Husky hooks...");
     try {
       await setupHusky(projectPath);
-      s.stop(pc7.green("\u2714 Success: Husky pre-commit hooks configured"));
+      s.stop(pc16.green("\u2714 Success: Husky pre-commit hooks configured"));
     } catch (error) {
-      s.stop(pc7.red("\u2716 Failed: Husky setup failed"));
-      console.error(pc7.red(`
+      s.stop(pc16.red("\u2716 Failed: Husky setup failed"));
+      console.error(pc16.red(`
 Error details: ${error.message || error}`));
       process.exit(1);
     }
@@ -411,52 +1226,167 @@ Error details: ${error.message || error}`));
   }
 }
 
-// src/core/endcli.ts
-import pc8 from "picocolors";
-import { outro } from "@clack/prompts";
-import boxen2 from "boxen";
-function endCli(name, projectPath) {
-  outro(pc8.yellow("Morax scaffolding completed successfully!"));
-  console.log(
-    boxen2(
-      `\u26A1 ${pc8.bold("Workspace ready:")} ${pc8.yellow(name)}
-Location: ${pc8.cyan(projectPath)}
-
-${pc8.bold("To start developing:")}
- 1. ${pc8.cyan(`cd ${name}`)}
- 2. ${pc8.cyan("pnpm dev")}
-
-\u{1F4A1} Code formatting & git orchestration is fully active.`,
+// 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: [
       {
-        padding: 0,
-        margin: 0,
-        borderStyle: "round",
-        borderColor: "yellow",
-        title: pc8.black(pc8.bold(" Setup Complete ")),
-        titleAlignment: "center"
+        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"
+  });
+  handleCancel(framework);
+  if (framework === "nextjs") {
+    await setupNextjs(projectPath);
+    await runShadcnSetup(projectPath);
+  } else if (framework === "react") {
+    await setupReact(projectPath);
+  }
 }
 
 // src/core/runner.ts
-async function runWorkspaceScaffolder() {
+async function runWorkspaceScaffolder(options = {}) {
   startCli();
-  const name = await promptWorkspaceName();
-  const projectPath = path6.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 runHuskySetup(projectPath, gitInitialized);
+  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(
+      pc17.green(
+        "\u2714 Success: Workspace dependencies and symlinks configured successfully"
+      )
+    );
+  } catch (error) {
+    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(pc9.red("Fatal Error during execution:"), err);
+  console.error(pc18.red("Fatal Error during execution:"), err);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map