@idealyst/cli 1.0.30 → 1.0.32

package/dist/index.js

@@ -1,751 +1,8 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk from 'chalk';
-import path from 'path';
-import fs from 'fs-extra';
-import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
-import ora from 'ora';
-import validatePackageName from 'validate-npm-package-name';
-import inquirer from 'inquirer';
-
-function validateProjectName(name) {
-    const validation = validatePackageName(name);
-    return validation.validForNewPackages;
-}
-function createPackageName(name) {
-    return name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-}
-async function updateWorkspacePackageJson(workspacePath, directory) {
-    // Look for package.json in the directory to see if we're in a workspace
-    const packageJsonPath = path.join(directory, 'package.json');
-    if (await fs.pathExists(packageJsonPath)) {
-        try {
-            const packageJson = await fs.readJSON(packageJsonPath);
-            // Check if this is a workspace (has workspaces property)
-            if (packageJson.workspaces && Array.isArray(packageJson.workspaces)) {
-                // Check if workspace already covers this path with a wildcard
-                const workspaceDir = path.dirname(workspacePath);
-                const wildcardPattern = `${workspaceDir}/*`;
-                const isAlreadyCovered = packageJson.workspaces.some((ws) => ws === wildcardPattern || ws === workspacePath);
-                // Add the new project to workspaces if not already present or covered
-                if (!isAlreadyCovered) {
-                    packageJson.workspaces.push(workspacePath);
-                    await fs.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
-                    console.log(chalk.green(`✅ Added ${workspacePath} to workspace configuration`));
-                }
-                else {
-                    console.log(chalk.blue(`📦 Project ${workspacePath} already covered by existing workspace configuration`));
-                }
-            }
-        }
-        catch (error) {
-            // Silently ignore if we can't read/write package.json
-            console.log(chalk.yellow(`⚠️  Could not update workspace configuration: ${error instanceof Error ? error.message : 'Unknown error'}`));
-        }
-    }
-}
-async function copyTemplate(templatePath, destPath, data) {
-    const spinner = ora(`Copying template files...`).start();
-    try {
-        await fs.ensureDir(destPath);
-        await fs.copy(templatePath, destPath, {
-            filter: (src) => {
-                const relativePath = path.relative(templatePath, src);
-                // Skip App-with-trpc.tsx as it's only copied when tRPC is enabled
-                return !relativePath.includes('node_modules') &&
-                    !relativePath.includes('.git') &&
-                    !relativePath.endsWith('App-with-trpc.tsx');
-            }
-        });
-        // Process template files
-        await processTemplateFiles(destPath, data);
-        spinner.succeed('Template files copied successfully');
-    }
-    catch (error) {
-        spinner.fail('Failed to copy template files');
-        throw error;
-    }
-}
-async function processTemplateFiles(dir, data) {
-    const files = await fs.readdir(dir);
-    for (const file of files) {
-        const filePath = path.join(dir, file);
-        const stat = await fs.stat(filePath);
-        if (stat.isDirectory()) {
-            await processTemplateFiles(filePath, data);
-        }
-        else if (file.endsWith('.json') || file.endsWith('.js') || file.endsWith('.ts') || file.endsWith('.tsx') || file.endsWith('.md')) {
-            await processTemplateFile(filePath, data);
-        }
-    }
-}
-async function processTemplateFile(filePath, data) {
-    try {
-        let content = await fs.readFile(filePath, 'utf8');
-        // Replace template variables
-        content = content.replace(/\{\{projectName\}\}/g, data.projectName);
-        content = content.replace(/\{\{packageName\}\}/g, data.packageName);
-        content = content.replace(/\{\{version\}\}/g, data.version);
-        content = content.replace(/\{\{description\}\}/g, data.description);
-        // Handle appName (with fallback to projectName if not provided)
-        const appName = data.appName || data.projectName;
-        content = content.replace(/\{\{appName\}\}/g, appName);
-        await fs.writeFile(filePath, content);
-    }
-    catch (error) {
-        // Skip files that can't be processed
-        console.warn(chalk.yellow(`Warning: Could not process template file ${filePath}`));
-    }
-}
-async function installDependencies(projectPath, skipInstall = false) {
-    if (skipInstall) {
-        console.log(chalk.yellow('Skipping dependency installation'));
-        return;
-    }
-    const spinner = ora('Installing dependencies...').start();
-    try {
-        await runCommand('yarn', ['install'], { cwd: projectPath });
-        spinner.succeed('Dependencies installed successfully');
-    }
-    catch (error) {
-        spinner.fail('Failed to install dependencies with yarn');
-        console.log(chalk.yellow('You can install dependencies manually by running:'));
-        console.log(chalk.white('  cd ' + path.basename(projectPath)));
-        console.log(chalk.white('  yarn install'));
-        console.log(chalk.white('  # or alternatively:'));
-        console.log(chalk.white('  npm install'));
-    }
-}
-function runCommand(command, args, options) {
-    return new Promise((resolve, reject) => {
-        const timeoutMs = options.timeout || 300000; // 5 minutes default timeout
-        const process = spawn(command, args, {
-            cwd: options.cwd,
-            stdio: ['pipe', 'inherit', 'inherit'], // Pipe stdin to prevent hanging on prompts
-            shell: true
-        });
-        // Set up timeout
-        const timeoutId = setTimeout(() => {
-            process.kill('SIGTERM');
-            reject(new Error(`Command timed out after ${timeoutMs / 1000} seconds`));
-        }, timeoutMs);
-        // Close stdin immediately to prevent hanging on interactive prompts
-        if (process.stdin) {
-            process.stdin.end();
-        }
-        process.on('close', (code) => {
-            clearTimeout(timeoutId);
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`Command failed with code ${code}`));
-            }
-        });
-        process.on('error', (error) => {
-            clearTimeout(timeoutId);
-            reject(error);
-        });
-    });
-}
-function getTemplateData(projectName, description, appName, workspaceScope) {
-    let packageName = createPackageName(projectName);
-    // If we have a workspace scope, prefix the package name with it
-    if (workspaceScope) {
-        packageName = `@${workspaceScope}/${packageName}`;
-    }
-    return {
-        projectName,
-        packageName,
-        version: '1.0.0',
-        description: description || `A new Idealyst project: ${projectName}`,
-        appName
-    };
-}
-/**
- * Detects if we're in a workspace root directory
- */
-async function isWorkspaceRoot(directory) {
-    const packageJsonPath = path.join(directory, 'package.json');
-    if (await fs.pathExists(packageJsonPath)) {
-        try {
-            const packageJson = await fs.readJSON(packageJsonPath);
-            return !!(packageJson.workspaces && Array.isArray(packageJson.workspaces));
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    return false;
-}
-/**
- * Gets the workspace name from the workspace root's package.json
- */
-async function getWorkspaceName(directory) {
-    const packageJsonPath = path.join(directory, 'package.json');
-    if (await fs.pathExists(packageJsonPath)) {
-        try {
-            const packageJson = await fs.readJSON(packageJsonPath);
-            return packageJson.name || null;
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    return null;
-}
-/**
- * Resolves the correct project path for individual projects (native, web, shared).
- * Individual projects can ONLY be created within an existing workspace.
- * This enforces proper monorepo structure and prevents scattered individual projects.
- */
-async function resolveProjectPath(projectName, directory) {
-    // Check if we're in a workspace directory
-    const isWorkspace = await isWorkspaceRoot(directory);
-    if (!isWorkspace) {
-        throw new Error(`Individual projects can only be created within a workspace.\n` +
-            `Please first create a workspace with: idealyst init my-workspace\n` +
-            `Then navigate to the workspace directory and create your project.`);
-    }
-    // Get the workspace name to use as scope
-    const workspaceScope = await getWorkspaceName(directory);
-    // Create project in workspace's packages/ folder
-    const packagesDir = path.join(directory, 'packages');
-    await fs.ensureDir(packagesDir);
-    return {
-        projectPath: path.join(packagesDir, projectName),
-        workspacePath: `packages/${projectName}`,
-        workspaceScope
-    };
-}
-async function initializeReactNativeProject(projectName, directory, displayName, skipInstall) {
-    const spinner = ora('Initializing React Native project...').start();
-    try {
-        // Use create-react-native-app for a more reliable setup
-        const cliCommand = 'npx';
-        const args = [
-            'react-native@latest',
-            'init',
-            projectName,
-            '--pm', 'yarn',
-            '--skip-git-init'
-        ];
-        // Add title if displayName is provided
-        if (displayName) {
-            args.push('--title', displayName);
-        }
-        // Skip install if requested (we'll handle it separately for workspace integration)
-        if (skipInstall) {
-            args.push('--skip-install');
-        }
-        spinner.text = 'Initializing React Native project (this may take a few minutes)...';
-        // Run React Native initialization with timeout
-        await runCommand(cliCommand, args, {
-            cwd: directory,
-            timeout: 600000 // 10 minutes timeout for React Native init
-        });
-        spinner.succeed('React Native project initialized successfully');
-    }
-    catch (error) {
-        spinner.fail('Failed to initialize React Native project');
-        if (error instanceof Error && error.message.includes('timed out')) {
-            console.log(chalk.red('❌ React Native initialization timed out'));
-            console.log(chalk.yellow('This can happen due to:'));
-            console.log(chalk.white('  • Slow internet connection'));
-            console.log(chalk.white('  • Network issues downloading dependencies'));
-            console.log(chalk.white('  • React Native CLI hanging on prompts'));
-        }
-        console.log(chalk.yellow('\n💡 Alternative approaches:'));
-        console.log(chalk.white('1. Try manually creating the project:'));
-        console.log(chalk.white(`   npx react-native@latest init ${projectName} --pm yarn --skip-git-init`));
-        console.log(chalk.white('\n2. Use Expo (faster alternative):'));
-        console.log(chalk.white(`   npx create-expo-app@latest ${projectName} --template blank-typescript`));
-        console.log(chalk.white('\n3. Ensure prerequisites:'));
-        console.log(chalk.white('   npm install -g react-native-cli'));
-        console.log(chalk.white('   npm install -g @react-native-community/cli'));
-        throw error;
-    }
-}
-async function overlayIdealystFiles(templatePath, projectPath, data) {
-    const spinner = ora('Applying Idealyst Framework files...').start();
-    try {
-        // Copy Idealyst-specific files over the React Native project
-        await fs.copy(templatePath, projectPath, {
-            overwrite: true,
-            filter: (src) => {
-                const relativePath = path.relative(templatePath, src);
-                // Skip package.json as we'll merge it separately
-                // Skip App-with-trpc.tsx as it's only copied when tRPC is enabled
-                return !relativePath.includes('node_modules') &&
-                    !relativePath.includes('.git') &&
-                    !relativePath.endsWith('package.json') &&
-                    !relativePath.endsWith('App-with-trpc.tsx');
-            }
-        });
-        // Process template files
-        await processTemplateFiles(projectPath, data);
-        // Merge package.json dependencies
-        await mergePackageJsonDependencies(templatePath, projectPath);
-        spinner.succeed('Idealyst Framework files applied successfully');
-    }
-    catch (error) {
-        spinner.fail('Failed to apply Idealyst Framework files');
-        throw error;
-    }
-}
-async function mergePackageJsonDependencies(templatePath, projectPath) {
-    const templatePackageJsonPath = path.join(templatePath, 'package.json');
-    const projectPackageJsonPath = path.join(projectPath, 'package.json');
-    try {
-        // Read both package.json files
-        const templatePackageJson = await fs.readJSON(templatePackageJsonPath);
-        const projectPackageJson = await fs.readJSON(projectPackageJsonPath);
-        // Merge dependencies
-        const idealystDependencies = {
-            '@idealyst/components': '^1.0.3',
-            '@idealyst/navigation': '^1.0.3',
-            '@idealyst/theme': '^1.0.3',
-            '@react-native-vector-icons/common': '^12.0.1',
-            '@react-native-vector-icons/material-design-icons': '^12.0.1',
-            '@react-navigation/bottom-tabs': '^7.4.2',
-            '@react-navigation/drawer': '^7.5.3',
-            '@react-navigation/native': '^7.1.14',
-            '@react-navigation/native-stack': '^7.3.21',
-            '@tanstack/react-query': '^5.83.0',
-            '@trpc/client': '^11.4.3',
-            '@trpc/react-query': '^11.4.3',
-            '@trpc/server': '^11.4.3',
-            'react-native-edge-to-edge': '^1.6.2',
-            'react-native-gesture-handler': '^2.27.1',
-            'react-native-nitro-modules': '^0.26.3',
-            'react-native-reanimated': '^3.18.0',
-            'react-native-safe-area-context': '^5.5.1',
-            'react-native-screens': '^4.11.1',
-            'react-native-unistyles': '^3.0.4',
-            'react-native-vector-icons': '^10.2.0'
-        };
-        // Merge the dependencies
-        projectPackageJson.dependencies = {
-            ...projectPackageJson.dependencies,
-            ...idealystDependencies
-        };
-        // Write back the merged package.json
-        await fs.writeJSON(projectPackageJsonPath, projectPackageJson, { spaces: 2 });
-        console.log(chalk.green('✅ Merged Idealyst dependencies into package.json'));
-    }
-    catch (error) {
-        console.warn(chalk.yellow('⚠️  Could not merge package.json dependencies'));
-        throw error;
-    }
-}
-async function promptForProjectName() {
-    const { projectName } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'projectName',
-            message: 'What is your project name?',
-            validate: (input) => {
-                if (!input || input.trim().length === 0) {
-                    return 'Project name is required';
-                }
-                const lowerName = input.toLowerCase();
-                if (!validateProjectName(lowerName)) {
-                    return 'Project name must be a valid npm package name (lowercase, no spaces)';
-                }
-                return true;
-            },
-            filter: (input) => input.toLowerCase().trim()
-        }
-    ]);
-    return projectName;
-}
-async function promptForProjectType() {
-    const { projectType } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'projectType',
-            message: 'What type of project would you like to create?',
-            choices: [
-                { name: 'React Native App', value: 'native' },
-                { name: 'React Web App', value: 'web' },
-                { name: 'Shared Library', value: 'shared' },
-                { name: 'API Server (tRPC + Prisma + Zod)', value: 'api' }
-            ],
-            default: 'native'
-        }
-    ]);
-    return projectType;
-}
-async function promptForAppName(projectName) {
-    const { appName } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'appName',
-            message: 'What is the display name for your app? (used for native app titles)',
-            default: projectName.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' '),
-            validate: (input) => {
-                if (!input || input.trim().length === 0) {
-                    return 'App name is required';
-                }
-                return true;
-            },
-            filter: (input) => input.trim()
-        }
-    ]);
-    return appName;
-}
-async function promptForTrpcIntegration() {
-    const { withTrpc } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'withTrpc',
-            message: 'Would you like to include tRPC client setup and boilerplate?',
-            default: false
-        }
-    ]);
-    return withTrpc;
-}
-async function copyTrpcFiles(templatePath, projectPath, data) {
-    const spinner = ora('Adding tRPC client utilities...').start();
-    try {
-        const trpcUtilsSource = path.join(templatePath, 'src', 'utils', 'trpc.ts');
-        const trpcUtilsTarget = path.join(projectPath, 'src', 'utils', 'trpc.ts');
-        // Ensure utils directory exists
-        await fs.ensureDir(path.join(projectPath, 'src', 'utils'));
-        // Copy and process the tRPC utils file
-        await fs.copy(trpcUtilsSource, trpcUtilsTarget);
-        await processTemplateFile(trpcUtilsTarget, data);
-        spinner.succeed('tRPC client utilities added');
-    }
-    catch (error) {
-        spinner.fail('Failed to add tRPC client utilities');
-        console.warn(chalk.yellow('⚠️  tRPC utilities could not be copied, but the project was created successfully'));
-    }
-}
-async function copyTrpcAppComponent(templatePath, projectPath, data) {
-    const spinner = ora('Setting up tRPC App component...').start();
-    try {
-        const trpcAppSource = path.join(templatePath, 'src', 'App-with-trpc.tsx');
-        const appTarget = path.join(projectPath, 'src', 'App.tsx');
-        // Copy the tRPC-enabled App component over the default one
-        await fs.copy(trpcAppSource, appTarget, { overwrite: true });
-        await processTemplateFile(appTarget, data);
-        spinner.succeed('tRPC App component configured');
-    }
-    catch (error) {
-        spinner.fail('Failed to configure tRPC App component');
-        console.warn(chalk.yellow('⚠️  tRPC App component could not be configured, but the project was created successfully'));
-    }
-}
-async function removeTrpcDependencies(projectPath) {
-    try {
-        const packageJsonPath = path.join(projectPath, 'package.json');
-        const packageJson = await fs.readJSON(packageJsonPath);
-        // Remove tRPC-related dependencies
-        const trpcDeps = [
-            '@tanstack/react-query',
-            '@trpc/client',
-            '@trpc/react-query',
-            '@trpc/server'
-        ];
-        trpcDeps.forEach(dep => {
-            if (packageJson.dependencies && packageJson.dependencies[dep]) {
-                delete packageJson.dependencies[dep];
-            }
-        });
-        await fs.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
-    }
-    catch (error) {
-        console.warn(chalk.yellow('⚠️  Could not remove tRPC dependencies from package.json'));
-    }
-}
-async function configureAndroidVectorIcons(projectPath) {
-    const buildGradlePath = path.join(projectPath, 'android', 'app', 'build.gradle');
-    try {
-        if (await fs.pathExists(buildGradlePath)) {
-            let content = await fs.readFile(buildGradlePath, 'utf8');
-            // Check if the vector icons line is already present
-            if (content.includes('react-native-vector-icons/fonts.gradle')) {
-                console.log(chalk.yellow('Vector icons configuration already exists in build.gradle'));
-                return;
-            }
-            // Find the line with jscFlavor definition and add the vector icons line after it
-            const jscFlavorRegex = /def jscFlavor = ['"][^'"]*['"]/;
-            const match = content.match(jscFlavorRegex);
-            if (match) {
-                const insertionPoint = content.indexOf(match[0]) + match[0].length;
-                const beforeInsertion = content.substring(0, insertionPoint);
-                const afterInsertion = content.substring(insertionPoint);
-                const vectorIconsLine = '\napply from: file("../../node_modules/react-native-vector-icons/fonts.gradle")';
-                content = beforeInsertion + vectorIconsLine + afterInsertion;
-                await fs.writeFile(buildGradlePath, content);
-                console.log(chalk.green('✅ Added react-native-vector-icons configuration to Android build.gradle'));
-            }
-            else {
-                console.log(chalk.yellow('⚠️  Could not find jscFlavor line in build.gradle, vector icons configuration not added'));
-            }
-        }
-        else {
-            console.log(chalk.yellow('⚠️  Android build.gradle not found, skipping vector icons configuration'));
-        }
-    }
-    catch (error) {
-        console.log(chalk.yellow(`⚠️  Could not configure vector icons in build.gradle: ${error instanceof Error ? error.message : 'Unknown error'}`));
-    }
-}
-
-var utils = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  configureAndroidVectorIcons: configureAndroidVectorIcons,
-  copyTemplate: copyTemplate,
-  copyTrpcAppComponent: copyTrpcAppComponent,
-  copyTrpcFiles: copyTrpcFiles,
-  createPackageName: createPackageName,
-  getTemplateData: getTemplateData,
-  getWorkspaceName: getWorkspaceName,
-  initializeReactNativeProject: initializeReactNativeProject,
-  installDependencies: installDependencies,
-  isWorkspaceRoot: isWorkspaceRoot,
-  mergePackageJsonDependencies: mergePackageJsonDependencies,
-  overlayIdealystFiles: overlayIdealystFiles,
-  processTemplateFile: processTemplateFile,
-  processTemplateFiles: processTemplateFiles,
-  promptForAppName: promptForAppName,
-  promptForProjectName: promptForProjectName,
-  promptForProjectType: promptForProjectType,
-  promptForTrpcIntegration: promptForTrpcIntegration,
-  removeTrpcDependencies: removeTrpcDependencies,
-  resolveProjectPath: resolveProjectPath,
-  runCommand: runCommand,
-  updateWorkspacePackageJson: updateWorkspacePackageJson,
-  validateProjectName: validateProjectName
-});
-
-const __filename$4 = fileURLToPath(import.meta.url);
-const __dirname$4 = path.dirname(__filename$4);
-async function generateNativeProject(options) {
-    const { name, directory, skipInstall, appName, withTrpc } = options;
-    if (!validateProjectName(name)) {
-        throw new Error(`Invalid project name: ${name}`);
-    }
-    const displayName = appName || name.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
-    console.log(chalk.blue(`📱 Creating React Native project: ${name}`));
-    console.log(chalk.gray(`   App display name: ${displayName}`));
-    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
-    const templatePath = path.join(__dirname$4, '..', 'templates', 'native');
-    const templateData = getTemplateData(name, `React Native app built with Idealyst Framework`, displayName, workspaceScope || undefined);
-    try {
-        // Step 1: Update workspace configuration FIRST
-        await updateWorkspacePackageJson(workspacePath, directory);
-        // Step 2: Try React Native CLI initialization, with fallback to template-only
-        const useRnCli = process.env.IDEALYST_USE_RN_CLI !== 'false';
-        if (useRnCli) {
-            try {
-                console.log(chalk.blue('🚀 Attempting React Native CLI initialization...'));
-                console.log(chalk.gray('   (This creates proper Android/iOS native directories)'));
-                // Initialize React Native project using CLI with --skip-install
-                const projectDir = path.dirname(projectPath);
-                const projectName = path.basename(projectPath);
-                await initializeReactNativeProject(projectName, projectDir, displayName, true);
-                // Step 3: Overlay Idealyst-specific files
-                await overlayIdealystFiles(templatePath, projectPath, templateData);
-                console.log(chalk.green('✅ React Native project created with native platform support'));
-            }
-            catch (rnError) {
-                console.log(chalk.yellow('⚠️  React Native CLI failed, falling back to template-only approach...'));
-                await createNativeProjectFromTemplate(templatePath, projectPath, templateData);
-                console.log(chalk.yellow('📝 Template-only project created. You may need to run "npx react-native init" later for native platforms.'));
-            }
-        }
-        else {
-            console.log(chalk.blue('��️  Creating project from template only (IDEALYST_USE_RN_CLI=false)'));
-            await createNativeProjectFromTemplate(templatePath, projectPath, templateData);
-        }
-        // Step 4: Handle tRPC setup
-        if (withTrpc) {
-            await copyTrpcFiles(templatePath, projectPath, templateData);
-            await copyTrpcAppComponent(templatePath, projectPath, templateData);
-        }
-        // Step 5: Configure Android vector icons (only if we have Android directory)
-        const hasAndroid = await fs.pathExists(path.join(projectPath, 'android'));
-        if (hasAndroid) {
-            await configureAndroidVectorIcons(projectPath);
-        }
-        // Step 6: Remove tRPC dependencies if not requested
-        if (!withTrpc) {
-            await removeTrpcDependencies(projectPath);
-        }
-        // Step 7: Install dependencies
-        await installDependencies(projectPath, skipInstall);
-        console.log(chalk.green('✅ React Native project created successfully!'));
-        console.log(chalk.blue('📋 Project includes:'));
-        console.log(chalk.white('  • React Native with TypeScript'));
-        console.log(chalk.white('  • Idealyst Components & Navigation'));
-        console.log(chalk.white('  • Idealyst Theme & Styling'));
-        console.log(chalk.white('  • Jest testing configuration'));
-        console.log(chalk.white('  • Metro & Babel configuration'));
-        if (hasAndroid) {
-            console.log(chalk.white('  • Android native platform setup'));
-            console.log(chalk.white('  • React Native Vector Icons (configured)'));
-        }
-        const hasIos = await fs.pathExists(path.join(projectPath, 'ios'));
-        if (hasIos) {
-            console.log(chalk.white('  • iOS native platform setup'));
-        }
-        if (!hasAndroid && !hasIos) {
-            console.log(chalk.yellow('  ⚠️  No native platforms detected'));
-            console.log(chalk.yellow('     Run "npx react-native init" in project directory for native support'));
-        }
-        if (withTrpc) {
-            console.log(chalk.white('  • tRPC client setup and utilities'));
-            console.log(chalk.white('  • React Query integration'));
-        }
-    }
-    catch (error) {
-        console.error(chalk.red('❌ Error creating React Native project:'));
-        console.error(error);
-        throw error;
-    }
-}
-// Helper function to create project from template only (fallback when RN CLI fails)
-async function createNativeProjectFromTemplate(templatePath, projectPath, templateData) {
-    await copyTemplate(templatePath, projectPath, templateData);
-}
-
-const __filename$3 = fileURLToPath(import.meta.url);
-const __dirname$3 = path.dirname(__filename$3);
-async function generateWebProject(options) {
-    const { name, directory, skipInstall, withTrpc } = options;
-    if (!validateProjectName(name)) {
-        throw new Error(`Invalid project name: ${name}`);
-    }
-    console.log(chalk.blue(`🌐 Creating React Web project: ${name}`));
-    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
-    const templatePath = path.join(__dirname$3, '..', 'templates', 'web');
-    const templateData = getTemplateData(name, `React web app built with Idealyst Framework`, undefined, workspaceScope || undefined);
-    await copyTemplate(templatePath, projectPath, templateData);
-    // Handle tRPC setup
-    if (withTrpc) {
-        await copyTrpcFiles(templatePath, projectPath, templateData);
-        await copyTrpcAppComponent(templatePath, projectPath, templateData);
-    }
-    else {
-        // Remove tRPC dependencies if not requested
-        await removeTrpcDependencies(projectPath);
-    }
-    await installDependencies(projectPath, skipInstall);
-    await updateWorkspacePackageJson(workspacePath, directory);
-    console.log(chalk.green('✅ React Web project created successfully!'));
-    console.log(chalk.blue('📋 Project includes:'));
-    console.log(chalk.white('  • React 19.1'));
-    console.log(chalk.white('  • Vite build system'));
-    console.log(chalk.white('  • Idealyst Components'));
-    console.log(chalk.white('  • Idealyst Navigation'));
-    console.log(chalk.white('  • Idealyst Theme'));
-    console.log(chalk.white('  • TypeScript configuration'));
-    console.log(chalk.white('  • React Router'));
-    if (withTrpc) {
-        console.log(chalk.white('  • tRPC client setup and utilities'));
-        console.log(chalk.white('  • React Query integration'));
-        console.log(chalk.white('  • Pre-configured tRPC provider'));
-    }
-}
-
-const __filename$2 = fileURLToPath(import.meta.url);
-const __dirname$2 = path.dirname(__filename$2);
-async function generateSharedLibrary(options) {
-    const { name, directory, skipInstall } = options;
-    if (!validateProjectName(name)) {
-        throw new Error(`Invalid project name: ${name}`);
-    }
-    console.log(chalk.blue(`📦 Creating shared library: ${name}`));
-    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
-    const templatePath = path.join(__dirname$2, '..', 'templates', 'shared');
-    const templateData = getTemplateData(name, `Shared library built with Idealyst Framework`, undefined, workspaceScope || undefined);
-    await copyTemplate(templatePath, projectPath, templateData);
-    await installDependencies(projectPath, skipInstall);
-    await updateWorkspacePackageJson(workspacePath, directory);
-    console.log(chalk.green('✅ Shared library created successfully!'));
-    console.log(chalk.blue('📋 Project includes:'));
-    console.log(chalk.white('  • Cross-platform components'));
-    console.log(chalk.white('  • Idealyst Theme integration'));
-    console.log(chalk.white('  • TypeScript configuration'));
-    console.log(chalk.white('  • Rollup build system'));
-    console.log(chalk.white('  • React & React Native support'));
-}
-
-const __filename$1 = fileURLToPath(import.meta.url);
-const __dirname$1 = path.dirname(__filename$1);
-async function generateWorkspace(options) {
-    const { name, directory, skipInstall } = options;
-    if (!validateProjectName(name)) {
-        throw new Error(`Invalid project name: ${name}`);
-    }
-    console.log(chalk.blue(`🏗️ Creating Idealyst workspace: ${name}`));
-    const projectPath = path.join(directory, name);
-    const templatePath = path.join(__dirname$1, '..', 'templates', 'workspace');
-    const templateData = getTemplateData(name, `Idealyst Framework monorepo workspace`);
-    await copyTemplate(templatePath, projectPath, templateData);
-    await installDependencies(projectPath, skipInstall);
-    console.log(chalk.green('✅ Workspace created successfully!'));
-    console.log(chalk.blue('📋 Workspace includes:'));
-    console.log(chalk.white('  • Yarn workspace configuration'));
-    console.log(chalk.white('  • Idealyst packages (theme, components, navigation)'));
-    console.log(chalk.white('  • TypeScript configuration'));
-    console.log(chalk.white('  • Build scripts'));
-    console.log(chalk.white('  • Version management scripts'));
-}
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-async function generateApiProject(options) {
-    const { name, directory, skipInstall } = options;
-    if (!validateProjectName(name)) {
-        throw new Error(`Invalid project name: ${name}`);
-    }
-    console.log(chalk.blue(`🚀 Creating API project: ${name}`));
-    const { projectPath, workspacePath, workspaceScope } = await resolveProjectPath(name, directory);
-    const templatePath = path.join(__dirname, '..', 'templates', 'api');
-    const templateData = getTemplateData(name, `Clean API server template with tRPC, Prisma, and Zod`, undefined, workspaceScope || undefined);
-    await copyTemplate(templatePath, projectPath, templateData);
-    await installDependencies(projectPath, skipInstall);
-    await updateWorkspacePackageJson(workspacePath, directory);
-    console.log(chalk.green('✅ API project created successfully!'));
-    console.log(chalk.blue('📋 Project includes:'));
-    console.log(chalk.white('  • tRPC for type-safe APIs'));
-    console.log(chalk.white('  • Prisma for database management'));
-    console.log(chalk.white('  • Zod for schema validation'));
-    console.log(chalk.white('  • Express.js server'));
-    console.log(chalk.white('  • TypeScript configuration'));
-    console.log(chalk.white('  • CORS and middleware setup'));
-    console.log(chalk.white('  • Database migration scripts'));
-    console.log(chalk.white('  • Clean template ready for your models'));
-}
-
-async function generateProject(options) {
-    const { type } = options;
-    switch (type) {
-        case 'native':
-            await generateNativeProject(options);
-            break;
-        case 'web':
-            await generateWebProject(options);
-            break;
-        case 'shared':
-            await generateSharedLibrary(options);
-            break;
-        case 'workspace':
-            await generateWorkspace(options);
-            break;
-        case 'api':
-            await generateApiProject(options);
-            break;
-        default:
-            throw new Error(`Unknown project type: ${type}`);
-    }
-}
-
+import { generateProject } from './generators';
+import { promptForProjectName, promptForProjectType, promptForAppName, promptForTrpcIntegration } from './generators/utils';
 const program = new Command();
 program
     .name('idealyst')
@@ -767,7 +24,7 @@ program
         }
         else {
             // Validate provided project name
-            const { validateProjectName } = await Promise.resolve().then(function () { return utils; });
+            const { validateProjectName } = await import('./generators/utils');
             if (!validateProjectName(projectName.toLowerCase())) {
                 console.error(chalk.red(`Invalid project name: ${projectName}`));
                 console.error(chalk.yellow('Project name must be a valid npm package name (lowercase, no spaces)'));
@@ -847,7 +104,7 @@ program
         }
         else {
             // Validate provided project name
-            const { validateProjectName } = await Promise.resolve().then(function () { return utils; });
+            const { validateProjectName } = await import('./generators/utils');
             if (!validateProjectName(projectName.toLowerCase())) {
                 console.error(chalk.red(`Invalid project name: ${projectName}`));
                 console.error(chalk.yellow('Project name must be a valid npm package name (lowercase, no spaces)'));
@@ -874,3 +131,4 @@ program
     }
 });
 program.parse();
+//# sourceMappingURL=index.js.map