create-sumit-app 1.0.4 → 1.1.1

package/dist/index.js

@@ -1,27 +1,24 @@
 #!/usr/bin/env node
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-import { Command } from 'commander';
-import { execa } from 'execa';
-import prompts from 'prompts';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import degit from 'degit';
-import path from 'path';
-import ora from 'ora';
-import { TEMPLATES, getTemplate, listTemplates } from './lib/templates.js';
-import { Logger } from './lib/logger.js';
-import { loadConfig, updateConfig, resetConfig, showConfig, getConfigPath, } from './lib/config.js';
-import { getPackageManagerInfo, checkForUpdates, isDirectoryEmpty, validateProjectName, formatDuration,
-// initializeGitRepository,
- } from './lib/utils.js';
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import { execa } from "execa";
+import prompts from "prompts";
+import chalk from "chalk";
+import fs from "fs-extra";
+import degit from "degit";
+import path from "path";
+import ora from "ora";
+import { loadConfig, updateConfig, resetConfig, showConfig, getConfigPath } from "./lib/config.js";
+import { PROJECTS, PRESETS, BASE_TEMPLATE } from "./lib/templates.js";
+import { Logger } from "./lib/logger.js";
+import { getPackageManagerInfo, checkForUpdates, isDirectoryEmpty, validateProjectName, formatDuration, 
+// enableWindowsLongPaths,
+getPreset, listPresets, listProjects, getTemplate, listTemplates, } from "./lib/utils.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-function getTemplatePath(template) {
-    return template.path || `templates/${template.name}`;
-}
 async function cleanupGitDirectory(projectPath, logger) {
-    const gitDir = path.join(projectPath, '.git');
+    const gitDir = path.join(projectPath, ".git");
     if (!(await fs.pathExists(gitDir))) {
         return;
     }
@@ -29,17 +26,15 @@ async function cleanupGitDirectory(projectPath, logger) {
     while (retries > 0) {
         try {
             await fs.remove(gitDir);
-            logger.verbose('Removed template .git directory');
+            logger.verbose("Removed template .git directory");
             return;
         }
         catch (error) {
             retries--;
-            if (error.code === 'EBUSY' || error.code === 'EPERM') {
+            if (error.code === "EBUSY" || error.code === "EPERM") {
                 if (retries > 0) {
                     logger.verbose(`Git cleanup failed, retrying... (${retries} attempts left)`);
-                    // Wait a bit before retrying
                     await new Promise((resolve) => setTimeout(resolve, 1000));
-                    // Try to make files writable on Windows
                     try {
                         await makeGitFilesWritable(gitDir);
                     }
@@ -48,20 +43,18 @@ async function cleanupGitDirectory(projectPath, logger) {
                     }
                 }
                 else {
-                    logger.warn('Could not remove .git directory automatically');
-                    logger.info('You may need to manually delete the .git folder if it exists');
+                    logger.warn("Could not remove .git directory automatically");
+                    logger.info("You may need to manually delete the .git folder if it exists");
                     return;
                 }
             }
             else {
-                // For other errors, just warn and continue
                 logger.verbose(`Git cleanup error: ${error.message}`);
                 return;
             }
         }
     }
 }
-// Helper function to make git files writable
 async function makeGitFilesWritable(gitDir) {
     try {
         const files = await fs.readdir(gitDir, { withFileTypes: true });
@@ -72,7 +65,7 @@ async function makeGitFilesWritable(gitDir) {
             }
             else {
                 try {
-                    await fs.chmod(fullPath, 0o666); // Make file writable
+                    await fs.chmod(fullPath, 0o666);
                 }
                 catch (error) {
                     // Ignore individual file errors
@@ -85,48 +78,44 @@ async function makeGitFilesWritable(gitDir) {
     }
 }
 async function selectPackageManager(config, logger, packageManagerName) {
-    // Available package managers with descriptions
     const availableManagers = [
         {
-            name: 'bun',
-            description: '⚡ Ultra-fast JavaScript runtime and package manager',
+            name: "bun",
+            description: "⚡ Ultra-fast JavaScript runtime and package manager",
+        },
+        {
+            name: "pnpm",
+            description: "📦 Fast, disk space efficient package manager",
+        },
+        {
+            name: "yarn",
+            description: "🐈 Fast, reliable, and secure dependency management",
+        },
+        {
+            name: "npm",
+            description: "📦 Default Node.js package manager",
         },
-        // {
-        //   name: 'pnpm',
-        //   description: '📦 Fast, disk space efficient package manager',
-        // },
-        // {
-        //   name: 'yarn',
-        //   description: '🐈 Fast, reliable, and secure dependency management',
-        // },
-        // {
-        //   name: 'npm',
-        //   description: '📦 Simple and widely used Node.js package manager',
-        // },
     ];
-    // If package manager specified via CLI, use it
     if (packageManagerName) {
         const manager = availableManagers.find((m) => m.name === packageManagerName);
         if (!manager) {
             logger.error(`Package manager "${packageManagerName}" not found.`);
-            logger.info('Available package managers:');
+            logger.info("Available package managers:");
             availableManagers.forEach((m) => logger.info(`  • ${m.name} - ${m.description}`));
             process.exit(1);
         }
         logger.verbose(`Using CLI specified package manager: ${manager.name}`);
         return manager.name;
     }
-    // If default package manager in config, use it
     if (config.packageManager) {
         logger.verbose(`Using config default package manager: ${config.packageManager}`);
         return config.packageManager;
     }
-    // Check for lockfiles in the CURRENT directory for auto-detection
     const lockFiles = [
-        { name: 'bun', file: 'bun.lockb' },
-        { name: 'pnpm', file: 'pnpm-lock.yaml' },
-        { name: 'yarn', file: 'yarn.lock' },
-        { name: 'npm', file: 'package-lock.json' },
+        { name: "bun", file: "bun.lockb" },
+        { name: "pnpm", file: "pnpm-lock.yaml" },
+        { name: "yarn", file: "yarn.lock" },
+        { name: "npm", file: "package-lock.json" },
     ];
     for (const lockFile of lockFiles) {
         if (await fs.pathExists(path.join(process.cwd(), lockFile.file))) {
@@ -134,65 +123,187 @@ async function selectPackageManager(config, logger, packageManagerName) {
             return lockFile.name;
         }
     }
-    // Interactive selection (no auto-detection from global availability)
     logger.newLine();
-    logger.log('📦 Choose a package manager:');
+    logger.log("📦 Choose a package manager:");
     const { selectedManager } = await prompts({
-        type: 'select',
-        name: 'selectedManager',
-        message: 'Select a package manager',
+        type: "select",
+        name: "selectedManager",
+        message: "Select a package manager",
         choices: availableManagers.map((manager) => ({
             title: `${manager.name}`,
             description: manager.description,
             value: manager.name,
         })),
-        initial: 0, // Default to bun (first option)
+        initial: 0,
     });
     if (!selectedManager) {
-        logger.error('Package manager selection cancelled');
+        logger.error("Package manager selection cancelled");
         process.exit(0);
     }
     return selectedManager;
 }
-async function selectTemplate(config, logger, templateName) {
-    // If template specified via CLI, use it
-    if (templateName) {
-        const template = getTemplate(templateName);
-        if (!template) {
-            logger.error(`Template "${templateName}" not found.`);
-            logger.info('Available templates:');
-            TEMPLATES.forEach((t) => logger.info(`  • ${t.name} - ${t.description}`));
+async function selectPresetOrProjects(config, logger, presetName, projectNames) {
+    // If specific projects provided via CLI, use them
+    if (projectNames && projectNames.length > 0) {
+        const validProjects = projectNames.filter((p) => PROJECTS[p]);
+        if (validProjects.length !== projectNames.length) {
+            const invalid = projectNames.filter((p) => !PROJECTS[p]);
+            logger.error(`Invalid project(s): ${invalid.join(", ")}`);
+            logger.info(`Available projects: ${Object.keys(PROJECTS).join(", ")}`);
             process.exit(1);
         }
-        return template;
+        return validProjects;
     }
-    // If default template in config, use it
-    if (config.defaultTemplate) {
-        const template = getTemplate(config.defaultTemplate);
-        if (template) {
-            logger.verbose(`Using default template: ${template.name}`);
-            return template;
+    // If preset specified via CLI, use it
+    if (presetName) {
+        const preset = getPreset(presetName);
+        if (!preset) {
+            logger.error(`Preset "${presetName}" not found.`);
+            logger.info("Available presets:");
+            PRESETS.forEach((p) => logger.info(`  • ${p.name} - ${p.description}`));
+            process.exit(1);
+        }
+        if (preset.name === "custom") {
+            return await selectProjects(logger);
         }
+        return preset.projects;
     }
-    // Interactive selection
-    // logger.newLine();
-    logger.log('🎨 Choose a template for your project:');
-    const { selectedTemplate } = await prompts({
-        type: 'select',
-        name: 'selectedTemplate',
-        message: 'Select a template',
-        choices: TEMPLATES.map((template, index) => ({
-            title: `${template.name}`,
-            description: template.description,
-            value: template,
+    // If default preset in config, use it
+    if (config.defaultPreset) {
+        const preset = getPreset(config.defaultPreset);
+        if (preset && preset.name !== "custom") {
+            logger.verbose(`Using default preset: ${preset.name}`);
+            return preset.projects;
+        }
+    }
+    // Interactive project selection - show multi-select checkboxes directly
+    return await selectProjects(logger);
+}
+async function selectProjects(logger) {
+    const { selectedProjects } = await prompts({
+        type: "multiselect",
+        name: "selectedProjects",
+        message: "Choose projects",
+        choices: Object.values(PROJECTS).map((project) => ({
+            title: project.name,
+            description: project.description,
+            value: project.name,
+            selected: true, // All selected by default
         })),
-        initial: 0,
+        min: 1,
+        hint: "- Space to toggle, Enter to confirm",
+        instructions: false,
     });
-    if (!selectedTemplate) {
-        logger.error('Template selection cancelled');
+    if (!selectedProjects || selectedProjects.length === 0) {
+        logger.error("At least one project must be selected");
         process.exit(0);
     }
-    return selectedTemplate;
+    return selectedProjects;
+}
+function generatePackageJson(projectName, selectedProjects, packageManager) {
+    const hasMobile = selectedProjects.includes("mobile");
+    // Package manager versions
+    const packageManagerVersions = {
+        bun: "bun@1.3.6",
+        pnpm: "pnpm@10.28.1",
+        yarn: "yarn@4.12.0",
+        npm: "npm@11.8.0",
+    };
+    // Clean commands per package manager
+    const cleanCommands = {
+        bun: "turbo run clean && node scripts/clean.js && bun pm cache rm",
+        pnpm: "turbo run clean && node scripts/clean.js && pnpm store prune",
+        yarn: "turbo run clean && node scripts/clean.js && yarn cache clean",
+        npm: "turbo run clean && node scripts/clean.js && npm cache clean --force",
+    };
+    const packageJson = {
+        name: projectName,
+        version: "1.0.0",
+        private: true,
+        strict: true,
+        scripts: {
+            dev: "turbo run dev",
+            build: "turbo run build",
+            lint: "turbo run lint",
+            format: "prettier --write .",
+            "check-types": "turbo run check-types",
+            clean: cleanCommands[packageManager] || cleanCommands.bun,
+        },
+        devDependencies: {
+            "@packages/eslint-config": packageManager === "npm" ? "*" : "workspace:^",
+            "@packages/typescript-config": packageManager === "npm" ? "*" : "workspace:^",
+            "@types/node": "^25.0.10",
+            prettier: "^3.8.1",
+            "prettier-plugin-tailwindcss": "^0.7.2",
+            rimraf: "^6.1.2",
+            turbo: "^2.7.6",
+            typescript: "^5.9.3",
+        },
+        engines: {
+            node: ">=22",
+        },
+        workspaces: ["projects/*", "packages/*"],
+        packageManager: packageManagerVersions[packageManager] || packageManagerVersions.bun,
+    };
+    // Add expo-dev-menu resolution only if mobile project is selected
+    if (hasMobile) {
+        packageJson.resolutions = {
+            "expo-dev-menu": "^7.0.10",
+        };
+    }
+    return packageJson;
+}
+async function generatePackageManagerConfig(projectPath, packageManager, logger) {
+    switch (packageManager) {
+        case "yarn":
+            // Yarn: Use hoisted node_modules for compatibility
+            const yarnrcContent = `# Yarn configuration - hoisted node_modules for compatibility
+nodeLinker: node-modules
+`;
+            await fs.writeFile(path.join(projectPath, ".yarnrc.yml"), yarnrcContent);
+            logger.verbose("Created .yarnrc.yml with node-modules linker");
+            break;
+        case "pnpm":
+            // pnpm: Use hoisted node_modules for compatibility
+            const npmrcContent = `# pnpm configuration - hoisted node_modules for compatibility
+node-linker=hoisted
+shamefully-hoist=true
+`;
+            await fs.writeFile(path.join(projectPath, ".npmrc"), npmrcContent);
+            // pnpm requires pnpm-workspace.yaml instead of workspaces in package.json
+            const pnpmWorkspaceContent = `# pnpm workspace configuration
+packages:
+  - "projects/*"
+  - "packages/*"
+`;
+            await fs.writeFile(path.join(projectPath, "pnpm-workspace.yaml"), pnpmWorkspaceContent);
+            logger.verbose("Created .npmrc and pnpm-workspace.yaml");
+            // Verify workspace structure
+            const packagesPath = path.join(projectPath, "packages");
+            if (await fs.pathExists(packagesPath)) {
+                const pkgs = await fs.readdir(packagesPath);
+                logger.verbose(`Found packages: ${pkgs.join(", ")}`);
+            }
+            else {
+                logger.warn("Warning: packages/ directory not found in project root");
+            }
+            break;
+        case "bun":
+            // Bun: Use hoisted node_modules for compatibility
+            const bunfigContent = `# Bun configuration - hoisted node_modules for compatibility
+[install]
+linker = "hoisted"
+`;
+            await fs.writeFile(path.join(projectPath, "bunfig.toml"), bunfigContent);
+            logger.verbose("Created bunfig.toml with symlink backend");
+            break;
+        case "npm":
+            // npm: Uses node_modules by default, no special config needed
+            logger.verbose("npm uses node_modules by default, no config needed");
+            break;
+        default:
+            break;
+    }
 }
 async function createProject(projectName, options = {}) {
     const startTime = Date.now();
@@ -200,37 +311,46 @@ async function createProject(projectName, options = {}) {
     const config = await loadConfig();
     // Show banner
     logger.banner();
+    // Enable Windows Long Paths if needed
+    // await enableWindowsLongPaths(logger);
     // Check for updates
     if (!config.skipUpdateCheck && !options.verbose) {
         await checkForUpdates(logger);
     }
+    // Handle legacy --template option
+    let presetName = options.preset;
+    if (options.template && !presetName) {
+        const template = getTemplate(options.template);
+        if (template) {
+            presetName = template.name;
+            logger.warn(`--template is deprecated, use --preset instead`);
+        }
+    }
     let targetDir = projectName;
     // Handle project name
     if (!targetDir) {
         const { projectName: inputName } = await prompts({
-            type: 'text',
-            name: 'projectName',
-            message: 'What is your project named?',
-            initial: 'my-sumit-app',
+            type: "text",
+            name: "projectName",
+            message: "What is your project named?",
+            initial: "my-sumit-app",
             validate: async (value) => {
                 if (!value.trim())
-                    return 'Project name is required';
-                // Allow dot (.) for current directory
-                if (value === '.')
+                    return "Project name is required";
+                if (value === ".")
                     return true;
                 const validation = await validateProjectName(value);
                 return validation.valid || validation.message;
             },
         });
         if (!inputName) {
-            logger.warn('Project creation cancelled.');
+            logger.warn("Project creation cancelled.");
             process.exit(0);
         }
         targetDir = inputName;
     }
     else {
-        // Validate provided project name (allow dot for current directory)
-        if (targetDir !== '.') {
+        if (targetDir !== ".") {
             const validation = await validateProjectName(targetDir);
             if (!validation.valid) {
                 logger.error(validation.message);
@@ -238,253 +358,331 @@ async function createProject(projectName, options = {}) {
             }
         }
     }
-    // Type guard to ensure targetDir is defined
     if (!targetDir) {
-        logger.error('Project name is required');
+        logger.error("Project name is required");
         process.exit(1);
     }
     // Handle current directory installation
-    let resolvedProjectPath; // ← Changed name to avoid conflict
-    let displayPath; // ← Changed name to avoid conflict
-    if (targetDir === '.') {
-        // Install in current directory
+    let resolvedProjectPath;
+    let displayPath;
+    if (targetDir === ".") {
         resolvedProjectPath = process.cwd();
-        displayPath = 'current directory';
-        // Validate current directory name for package.json compatibility
+        displayPath = "current directory";
         const currentDirName = path.basename(resolvedProjectPath);
         const validation = await validateProjectName(currentDirName);
         if (!validation.valid) {
             logger.error(`Current directory name "${currentDirName}" is not a valid package name.`);
             logger.error(validation.message);
-            logger.info('Please rename your directory to use lowercase letters, numbers, hyphens, underscores, and dots only.');
+            logger.info("Please rename your directory to use lowercase letters, numbers, hyphens, underscores, and dots only.");
             process.exit(1);
         }
     }
     else {
-        // Install in new directory
         resolvedProjectPath = path.resolve(process.cwd(), targetDir);
         const relativeProjectPath = path.relative(process.cwd(), resolvedProjectPath);
-        displayPath = relativeProjectPath || 'current directory';
+        displayPath = relativeProjectPath || "current directory";
     }
     logger.newLine();
-    logger.step(1, 4, `Creating project in ${chalk.cyan(displayPath)}`);
+    logger.step(1, 5, `Creating project in ${chalk.cyan(displayPath)}`);
     // Check if directory exists and is not empty
     if (await fs.pathExists(resolvedProjectPath)) {
         if (!(await isDirectoryEmpty(resolvedProjectPath))) {
-            logger.error(`Directory "${targetDir === '.' ? 'current directory' : targetDir}" already exists and is not empty.`);
+            logger.error(`Directory "${targetDir === "." ? "current directory" : targetDir}" already exists and is not empty.`);
             const { overwrite } = await prompts({
-                type: 'confirm',
-                name: 'overwrite',
-                message: 'Remove existing files and continue?',
+                type: "confirm",
+                name: "overwrite",
+                message: "Remove existing files and continue?",
                 initial: false,
             });
             if (overwrite) {
-                // Add spinner while deleting files
                 const deleteSpinner = ora({
-                    text: 'Removing existing files...',
-                    spinner: 'dots',
+                    text: "Removing existing files...",
+                    spinner: "dots",
                 }).start();
                 try {
                     await fs.emptyDir(resolvedProjectPath);
-                    deleteSpinner.succeed(chalk.green('Existing files removed'));
+                    deleteSpinner.succeed(chalk.green("Existing files removed"));
                 }
                 catch (error) {
-                    deleteSpinner.fail(chalk.red('Failed to remove existing files'));
+                    deleteSpinner.fail(chalk.red("Failed to remove existing files"));
                     logger.error(`Directory cleanup failed: ${error}`);
                     process.exit(1);
                 }
             }
             else {
-                logger.warn('Project creation cancelled.');
+                logger.warn("Project creation cancelled.");
                 process.exit(0);
             }
         }
     }
-    // Select template
+    // Select preset or custom projects
     logger.newLine();
-    const template = await selectTemplate(config, logger, options.template);
+    const selectedProjects = await selectPresetOrProjects(config, logger, presetName, options.projects);
     logger.newLine();
-    logger.step(2, 4, `Using template: ${chalk.cyan(template.name)}`);
-    // Show template features
-    if (options.verbose) {
-        logger.box(template.features.map((f) => `• ${f}`).join('\n'), `✨ ${template.name} template's features`);
-    }
-    // Clone template with sparse checkout for subdirectories
-    const downloadSpinner = ora({
-        text: 'Downloading template...',
-        spinner: 'dots12',
+    logger.step(2, 5, `Selected projects: ${chalk.cyan(selectedProjects.join(", "))}`);
+    // Download base template
+    const baseSpinner = ora({
+        text: "Downloading base template...",
+        spinner: "dots12",
     }).start();
     try {
-        logger.verbose(`Downloading from: ${template.url}`);
-        // Ensure target directory is ready
-        if (targetDir !== '.' && (await fs.pathExists(resolvedProjectPath))) {
-            await fs.remove(resolvedProjectPath);
-        }
-        // Ensure directory exists
         await fs.ensureDir(resolvedProjectPath);
-        // For templates with subdirectories, use degit
-        if (template.url.includes('SumitApp.git')) {
-            const templatePath = getTemplatePath(template);
-            // Extract repo info from URL
-            // https://github.com/sumittttpaul/SumitApp.git -> sumittttpaul/SumitApp
-            const repoMatch = template.url.match(/github\.com[/:]([\w-]+)\/([\w-]+)/);
+        const repoMatch = BASE_TEMPLATE.url.match(/github\.com[\/:]([\w-]+)\/([\w-]+)/);
+        if (!repoMatch) {
+            throw new Error("Invalid GitHub repository URL");
+        }
+        const [, owner, repo] = repoMatch;
+        const repoPath = `${owner}/${repo.replace(".git", "")}/${BASE_TEMPLATE.path}`;
+        const emitter = degit(repoPath, {
+            cache: false,
+            force: true,
+            verbose: options.verbose,
+        });
+        await emitter.clone(resolvedProjectPath);
+        baseSpinner.succeed(chalk.green("Base template downloaded!"));
+    }
+    catch (error) {
+        baseSpinner.fail(chalk.red("Failed to download base template"));
+        logger.error(`Download failed: ${error.message || error}`);
+        process.exit(1);
+    }
+    // Download selected projects
+    logger.newLine();
+    logger.step(3, 5, "Downloading selected projects...");
+    const projectsDir = path.join(resolvedProjectPath, "projects");
+    await fs.ensureDir(projectsDir);
+    for (const projectName of selectedProjects) {
+        const project = PROJECTS[projectName];
+        const projectSpinner = ora({
+            text: `Downloading ${projectName}...`,
+            spinner: "dots",
+        }).start();
+        try {
+            const repoMatch = BASE_TEMPLATE.url.match(/github\.com[\/:]([\w-]+)\/([\w-]+)/);
             if (!repoMatch) {
-                throw new Error('Invalid GitHub repository URL');
+                throw new Error("Invalid GitHub repository URL");
             }
             const [, owner, repo] = repoMatch;
-            const repoPath = `${owner}/${repo.replace('.git', '')}/${templatePath}`;
-            // degit downloads ONLY this specific folder
+            const repoPath = `${owner}/${repo.replace(".git", "")}/${project.path}`;
             const emitter = degit(repoPath, {
                 cache: false,
                 force: true,
                 verbose: options.verbose,
             });
-            // Download directly to target directory
-            await emitter.clone(resolvedProjectPath);
-            logger.verbose(`Downloaded template from: ${repoPath}`);
+            const projectTargetPath = path.join(projectsDir, project.name);
+            await emitter.clone(projectTargetPath);
+            projectSpinner.succeed(chalk.green(`Downloaded ${projectName}`));
         }
-        else {
-            // For standalone repos, still use degit
-            const repoMatch = template.url.match(/github\.com[/:]([\w-]+)\/([\w-]+)/);
-            if (repoMatch) {
-                const [, owner, repo] = repoMatch;
-                const emitter = degit(`${owner}/${repo.replace('.git', '')}`, {
-                    cache: false,
-                    force: true,
-                    verbose: options.verbose,
-                });
-                await emitter.clone(resolvedProjectPath);
-            }
-            else {
-                throw new Error('Invalid repository URL');
-            }
+        catch (error) {
+            projectSpinner.fail(chalk.red(`Failed to download ${projectName}`));
+            logger.error(`Download failed: ${error.message || error}`);
+            process.exit(1);
         }
-        downloadSpinner.succeed(chalk.green('Template downloaded successfully!'));
     }
-    catch (error) {
-        downloadSpinner.fail(chalk.red('Failed to download template'));
-        logger.error(`Download failed: ${error.message || error}`);
-        logger.info('Make sure the repository and template folder exist and are accessible.');
-        // Clean up failed download
-        try {
-            if (await fs.pathExists(resolvedProjectPath)) {
-                await fs.remove(resolvedProjectPath);
+    // Detect/Select package manager (moved before package.json generation)
+    const packageManager = await selectPackageManager(config, logger, options.packageManager);
+    const pmInfo = getPackageManagerInfo(packageManager);
+    // npm Fix: Recursively replace "workspace:" protocol with "*" in all package.json files
+    // because npm doesn't support "workspace:" protocol (it uses "*" or versions directly)
+    if (packageManager === "npm") {
+        logger.verbose("Adjusting workspace dependencies for npm compatibility...");
+        const scanDir = async (dir) => {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
+                    await scanDir(fullPath);
+                }
+                else if (entry.name === "package.json") {
+                    try {
+                        const content = await fs.readFile(fullPath, "utf-8");
+                        if (content.includes("workspace:")) {
+                            logger.verbose(`Fixing workspace protocol in ${path.relative(resolvedProjectPath, fullPath)}`);
+                            // Replace "workspace:^" or "workspace:*" with "*" for npm
+                            const fixedContent = content.replace(/"workspace:\^"/g, '"*"').replace(/"workspace:\*"/g, '"*"');
+                            await fs.writeFile(fullPath, fixedContent);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore read errors
+                    }
+                }
             }
-        }
-        catch (cleanupError) {
-            // Ignore
-        }
-        process.exit(1);
+        };
+        await scanDir(resolvedProjectPath);
     }
+    // Generate package.json based on selected projects and package manager
+    const actualProjectName = targetDir === "." ? path.basename(resolvedProjectPath) : targetDir;
+    const packageJsonContent = generatePackageJson(actualProjectName, selectedProjects, packageManager);
+    await fs.writeJson(path.join(resolvedProjectPath, "package.json"), packageJsonContent, { spaces: 2 });
+    logger.verbose("Generated package.json with correct configuration");
+    // Generate package manager config files to ensure node_modules in root
+    await generatePackageManagerConfig(resolvedProjectPath, packageManager, logger);
     // Clean up git directory
     await cleanupGitDirectory(resolvedProjectPath, logger);
-    logger.verbose('Removed template .git directory');
-    // Detect/Select package manager
-    const packageManager = await selectPackageManager(config, logger, options.packageManager);
-    const pmInfo = getPackageManagerInfo(packageManager);
     logger.newLine();
-    logger.step(3, 4, `Using package manager: ${chalk.cyan(packageManager)}`);
+    logger.step(4, 5, `Using package manager: ${chalk.cyan(packageManager)}`);
     // Install dependencies
     if (!options.skipInstall) {
         const installSpinner = ora({
             text: `Installing dependencies with ${packageManager}...`,
-            spinner: 'bouncingBar',
+            spinner: "bouncingBar",
         }).start();
         try {
             await execa(pmInfo.command, pmInfo.installArgs, {
                 cwd: resolvedProjectPath,
-                stdio: options.verbose ? 'inherit' : 'pipe',
+                stdio: options.verbose ? "inherit" : "pipe",
             });
-            installSpinner.succeed(chalk.green('Dependencies installed successfully!'));
+            installSpinner.succeed(chalk.green("Dependencies installed successfully!"));
         }
         catch (error) {
-            installSpinner.fail(chalk.red('Failed to install dependencies'));
+            installSpinner.fail(chalk.red("Failed to install dependencies"));
             logger.error(`Dependency installation failed: ${error}`);
-            logger.warn('You can install dependencies manually by running:');
-            logger.info(`  cd ${targetDir}`);
-            logger.info(`  ${pmInfo.command} ${pmInfo.installArgs.join(' ')}`);
+            logger.warn("You can install dependencies manually by running:");
+            logger.info(`cd ${targetDir}`);
+            logger.info(`${pmInfo.command} ${pmInfo.installArgs.join(" ")}`);
         }
     }
     else {
-        logger.info('Skipped dependency installation');
-    }
-    // Initialize git repository
-    // logger.step(4, 5, 'Initializing git repository...');
-    // logger.newLine();
-    // if (options.git !== false && config.git !== false) {
-    //   const gitSuccess = await initializeGitRepository(projectPath, logger);
-    //   if (gitSuccess) {
-    //     logger.success('Git repository initialized');
-    //   } else {
-    //     logger.warn(
-    //       'Git initialization failed, but project was created successfully'
-    //     );
-    //   }
-    // } else {
-    //   logger.info('Skipped git initialization');
-    // }
-    // Get the actual project name for display
-    const actualProjectName = targetDir === '.' ? path.basename(resolvedProjectPath) : targetDir;
+        logger.info("Skipped dependency installation");
+    }
     // Success message
     const duration = formatDuration(Date.now() - startTime);
     logger.newLine();
-    logger.step(4, 4, 'Project setup complete!');
+    logger.step(5, 5, "Project setup complete!");
     logger.newLine();
     logger.success(`🎉 Successfully created ${chalk.green(actualProjectName)} in ${chalk.green(duration)}`);
     logger.newLine();
-    // Next steps - show actual commands based on directory
+    // Next steps
     const nextSteps = [];
-    if (targetDir === '.') {
-        // Current directory - no cd command needed
-        nextSteps.push(`${pmInfo.command} ${pmInfo.name === 'npm' ? 'run ' : ''}dev`);
+    if (targetDir === ".") {
+        nextSteps.push(`${pmInfo.command} ${pmInfo.name === "npm" ? "run " : ""}dev`);
     }
     else {
-        // New directory - include cd command
-        nextSteps.push(`cd ${chalk.hex('#FFFFFF')(actualProjectName)}`);
-        nextSteps.push(`${pmInfo.command} ${pmInfo.name === 'npm' ? 'run ' : ''}dev`);
+        nextSteps.push(`cd ${chalk.hex("#FFFFFF")(actualProjectName)}`);
+        nextSteps.push(`${pmInfo.command} ${pmInfo.name === "npm" ? "run " : ""}dev`);
     }
     if (options.skipInstall) {
-        // Insert install command at appropriate position
-        const installCmd = `${pmInfo.command} ${pmInfo.installArgs.join(' ')}`;
-        if (targetDir === '.') {
-            nextSteps.splice(0, 0, installCmd); // Add as first step
+        const installCmd = `${pmInfo.command} ${pmInfo.installArgs.join(" ")}`;
+        if (targetDir === ".") {
+            nextSteps.splice(0, 0, installCmd);
         }
         else {
-            nextSteps.splice(1, 0, installCmd); // Add after cd command
+            nextSteps.splice(1, 0, installCmd);
         }
     }
-    logger.box(nextSteps
-        .map((step, i) => `${i + 1}. ${chalk.hex('#FFE600FF')(step)}`)
-        .join('\n'), '🚀 Get started');
+    logger.box(nextSteps.map((step, i) => `${i + 1}. ${chalk.hex("#FFE600FF")(step)}`).join("\n"), "🚀 Get started");
     logger.newLine();
-    logger.log('Happy coding! 🎨✨');
+    logger.log("Happy coding! 🎨✨");
     logger.newLine();
 }
+async function addProject(projectName, options) {
+    const logger = new Logger(options.verbose);
+    logger.banner();
+    // Validate project name
+    if (!PROJECTS[projectName]) {
+        logger.error(`Invalid project: ${projectName}`);
+        logger.info(`Available projects: ${Object.keys(PROJECTS).join(", ")}`);
+        process.exit(1);
+    }
+    // Check if we're in a SumitApp project
+    const projectsDir = path.join(process.cwd(), "projects");
+    const packagesDir = path.join(process.cwd(), "packages");
+    if (!(await fs.pathExists(projectsDir)) || !(await fs.pathExists(packagesDir))) {
+        logger.error("This does not appear to be a SumitApp project.");
+        logger.info("Run this command from the root of your SumitApp project.");
+        process.exit(1);
+    }
+    // Check if project already exists
+    const targetPath = path.join(projectsDir, projectName);
+    if (await fs.pathExists(targetPath)) {
+        logger.error(`Project "${projectName}" already exists.`);
+        process.exit(1);
+    }
+    // Download the project
+    const spinner = ora({
+        text: `Adding ${projectName} project...`,
+        spinner: "dots12",
+    }).start();
+    try {
+        const project = PROJECTS[projectName];
+        const repoMatch = BASE_TEMPLATE.url.match(/github\.com[\/:]([\w-]+)\/([\w-]+)/);
+        if (!repoMatch) {
+            throw new Error("Invalid GitHub repository URL");
+        }
+        const [, owner, repo] = repoMatch;
+        const repoPath = `${owner}/${repo.replace(".git", "")}/${project.path}`;
+        const emitter = degit(repoPath, {
+            cache: false,
+            force: true,
+            verbose: options.verbose,
+        });
+        await emitter.clone(targetPath);
+        spinner.succeed(chalk.green(`Added ${projectName} project successfully!`));
+        // Update package.json if adding mobile (needs expo-dev-menu resolution)
+        if (projectName === "mobile") {
+            const packageJsonPath = path.join(process.cwd(), "package.json");
+            if (await fs.pathExists(packageJsonPath)) {
+                const packageJson = await fs.readJson(packageJsonPath);
+                if (!packageJson.resolutions) {
+                    packageJson.resolutions = {};
+                }
+                if (!packageJson.resolutions["expo-dev-menu"]) {
+                    packageJson.resolutions["expo-dev-menu"] = "^7.0.10";
+                    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+                    logger.info("Updated package.json with expo-dev-menu resolution");
+                }
+            }
+        }
+        logger.newLine();
+        logger.info("Next steps:");
+        logger.info("  1. Run: bun install");
+        logger.info("  2. Run: bun dev");
+    }
+    catch (error) {
+        spinner.fail(chalk.red(`Failed to add ${projectName} project`));
+        logger.error(error.message);
+        process.exit(1);
+    }
+}
 // CLI Setup
 const program = new Command();
 const require = createRequire(import.meta.url);
-const packageJson = require('../package.json');
+const packageJson = require("../package.json");
 const CLI_VERSION = packageJson.version;
 program
-    .name('create-sumit-app')
+    .name("create-sumit-app")
     .description("✨ A beautiful CLI to bootstrap projects from Sumit.app's project templates")
     .version(CLI_VERSION)
-    .argument('[project-name]', 'The name of the project to create')
-    .option('-t, --template <template>', 'Template to use (default, react-native, nextjs, minimal)')
-    .option('-p, --package-manager <manager>', 'Package manager to use (npm, yarn, pnpm, bun)')
-    .option('-v, --verbose', 'Enable verbose logging')
-    // .option('--no-git', 'Skip git repository initialization')
-    .option('--skip-install', 'Skip dependency installation')
+    .argument("[project-name]", "The name of the project to create")
+    .option("-p, --preset <preset>", "Preset to use (default, mobile-and-backend, website-and-backend, custom)")
+    .option("--projects <projects>", "Comma-separated list of projects (website, mobile, backend)")
+    .option("-m, --package-manager <manager>", "Package manager to use (bun)")
+    .option("-v, --verbose", "Enable verbose logging")
+    .option("--skip-install", "Skip dependency installation")
+    .option("-t, --template <template>", "[DEPRECATED] Use --preset instead")
     .action(async (projectName, options) => {
+    // Parse projects option if provided
+    if (options.projects) {
+        options.projects = options.projects.split(",").map((p) => p.trim());
+    }
     await createProject(projectName, options);
 });
+// Add command for adding projects later
+program
+    .command("add <project>")
+    .description("Add a project to an existing SumitApp setup (website, mobile, backend)")
+    .option("-v, --verbose", "Enable verbose logging")
+    .action(async (projectName, options) => {
+    await addProject(projectName, options);
+});
 // Config command
 program
-    .command('config')
-    .description('Manage CLI configuration')
-    .option('-l, --list', 'List current configuration')
-    .option('-s, --set <key=value>', 'Set configuration value')
-    .option('-r, --reset', 'Reset configuration to defaults')
+    .command("config")
+    .description("Manage CLI configuration")
+    .option("-l, --list", "List current configuration")
+    .option("-s, --set <key=value>", "Set configuration value")
+    .option("-r, --reset", "Reset configuration to defaults")
     .action(async (options) => {
     const logger = new Logger();
     if (options.list) {
@@ -493,67 +691,73 @@ program
     }
     if (options.reset) {
         await resetConfig();
-        logger.success('Configuration reset to defaults');
+        logger.success("Configuration reset to defaults");
         return;
     }
     if (options.set) {
-        const [key, value] = options.set.split('=');
+        const [key, value] = options.set.split("=");
         if (!key || value === undefined) {
-            logger.error('Invalid format. Use: --set key=value');
+            logger.error("Invalid format. Use: --set key=value");
             return;
         }
-        // Validate configuration keys
-        const validKeys = [
-            'defaultTemplate',
-            'packageManager',
-            // 'git',
-            'verbose',
-            'skipUpdateCheck',
-        ];
+        const validKeys = ["defaultPreset", "packageManager", "verbose", "skipUpdateCheck"];
         if (!validKeys.includes(key)) {
             logger.error(`Invalid configuration key: ${key}`);
-            logger.info(`Valid keys: ${validKeys.join(', ')}`);
+            logger.info(`Valid keys: ${validKeys.join(", ")}`);
             return;
         }
-        // Parse boolean values
         let parsedValue = value;
-        if (value === 'true' || value === 'false') {
-            parsedValue = value === 'true';
+        if (value === "true" || value === "false") {
+            parsedValue = value === "true";
         }
         await updateConfig(key, parsedValue);
         logger.success(`Configuration updated: ${chalk.cyan(key)} = ${chalk.green(String(parsedValue))}`);
         logger.info(`Config file: ${chalk.gray(getConfigPath())}`);
     }
 });
-// Templates command
+// Presets command
+program
+    .command("presets")
+    .description("List available presets")
+    .action(() => {
+    listPresets();
+});
+// Projects command
+program
+    .command("projects")
+    .description("List available projects")
+    .action(() => {
+    listProjects();
+});
+// Templates command (legacy, for backward compatibility)
 program
-    .command('templates')
-    .description('List available templates')
+    .command("templates")
+    .description('[DEPRECATED] List available templates (use "presets" instead)')
     .action(() => {
     listTemplates();
 });
 // Info command
 program
-    .command('info')
-    .description('Display environment info')
+    .command("info")
+    .description("Display environment info")
     .action(async () => {
     const logger = new Logger();
-    const packageJson = await fs.readJson(path.join(__dirname, '..', 'package.json'));
+    const packageJson = await fs.readJson(path.join(__dirname, "..", "package.json"));
     logger.banner();
     logger.box(`Version: ${packageJson.version}\n` +
         `Node: ${process.version}\n` +
         `Platform: ${process.platform}\n` +
         `Architecture: ${process.arch}\n` +
-        `Config: ${getConfigPath()}`, '🔍 Environment Info');
+        `Config: ${getConfigPath()}`, "🔍 Environment Info");
 });
 // Handle uncaught errors
-process.on('uncaughtException', (error) => {
+process.on("uncaughtException", (error) => {
     const logger = new Logger();
     logger.error(`Unexpected error: ${error.message}`);
-    logger.debug(error.stack || '');
+    logger.debug(error.stack || "");
     process.exit(1);
 });
-process.on('unhandledRejection', (reason, promise) => {
+process.on("unhandledRejection", (reason, promise) => {
     const logger = new Logger();
     logger.error(`Unhandled rejection at: ${promise}, reason: ${reason}`);
     process.exit(1);