@idealyst/cli 1.0.31 → 1.0.33

package/dist/index.js

@@ -1,752 +1,47 @@
 #!/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
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
     };
-}
-/**
- * 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
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
     };
-}
-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}`);
-    }
-}
-
-const program = new Command();
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const index_1 = require("./generators/index");
+const utils_1 = require("./generators/utils");
+const program = new commander_1.Command();
 program
     .name('idealyst')
     .description('CLI tool for generating Idealyst Framework projects')
@@ -763,14 +58,14 @@ program
     try {
         // Prompt for project name if not provided
         if (!projectName) {
-            projectName = await promptForProjectName();
+            projectName = await (0, utils_1.promptForProjectName)();
         }
         else {
             // Validate provided project name
-            const { validateProjectName } = await Promise.resolve().then(function () { return utils; });
+            const { validateProjectName } = await Promise.resolve().then(() => __importStar(require('./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)'));
+                console.error(chalk_1.default.red(`Invalid project name: ${projectName}`));
+                console.error(chalk_1.default.yellow('Project name must be a valid npm package name (lowercase, no spaces)'));
                 process.exit(1);
             }
             projectName = projectName.toLowerCase();
@@ -778,25 +73,25 @@ program
         // Prompt for project type if not provided
         let projectType = options.type;
         if (!projectType) {
-            projectType = await promptForProjectType();
+            projectType = await (0, utils_1.promptForProjectType)();
         }
         const validTypes = ['native', 'web', 'shared', 'api'];
         if (!validTypes.includes(projectType)) {
-            console.error(chalk.red(`Invalid project type: ${projectType}`));
-            console.error(chalk.yellow(`Valid types are: ${validTypes.join(', ')}`));
+            console.error(chalk_1.default.red(`Invalid project type: ${projectType}`));
+            console.error(chalk_1.default.yellow(`Valid types are: ${validTypes.join(', ')}`));
             process.exit(1);
         }
         // Prompt for app name if it's a native project and app name not provided
         let appName = options.appName;
         if (projectType === 'native' && !appName) {
-            appName = await promptForAppName(projectName);
+            appName = await (0, utils_1.promptForAppName)(projectName);
         }
         // Prompt for tRPC integration if it's a web/native project and flag not provided
         let withTrpc = options.withTrpc;
         if ((projectType === 'web' || projectType === 'native') && withTrpc === undefined) {
-            withTrpc = await promptForTrpcIntegration();
+            withTrpc = await (0, utils_1.promptForTrpcIntegration)();
         }
-        await generateProject({
+        await (0, index_1.generateProject)({
             name: projectName,
             type: projectType,
             directory: options.directory,
@@ -804,33 +99,33 @@ program
             appName,
             withTrpc: withTrpc || false
         });
-        console.log(chalk.green(`✨ Successfully created ${projectName}!`));
-        console.log(chalk.blue(`📁 Project created in: ${options.directory}/packages/${projectName}`));
+        console.log(chalk_1.default.green(`✨ Successfully created ${projectName}!`));
+        console.log(chalk_1.default.blue(`📁 Project created in: ${options.directory}/packages/${projectName}`));
         if (projectType === 'native') {
-            console.log(chalk.yellow('\n📱 Next steps for React Native:'));
-            console.log(chalk.white('  cd packages/' + projectName));
-            console.log(chalk.white('  yarn android  # or yarn ios'));
+            console.log(chalk_1.default.yellow('\n📱 Next steps for React Native:'));
+            console.log(chalk_1.default.white('  cd packages/' + projectName));
+            console.log(chalk_1.default.white('  yarn android  # or yarn ios'));
         }
         else if (projectType === 'web') {
-            console.log(chalk.yellow('\n🌐 Next steps for React Web:'));
-            console.log(chalk.white('  cd packages/' + projectName));
-            console.log(chalk.white('  yarn dev'));
+            console.log(chalk_1.default.yellow('\n🌐 Next steps for React Web:'));
+            console.log(chalk_1.default.white('  cd packages/' + projectName));
+            console.log(chalk_1.default.white('  yarn dev'));
         }
         else if (projectType === 'api') {
-            console.log(chalk.yellow('\n🚀 Next steps for API Server:'));
-            console.log(chalk.white('  cd packages/' + projectName));
-            console.log(chalk.white('  yarn dev        # Start development server'));
-            console.log(chalk.white('  yarn db:push    # Push database schema'));
-            console.log(chalk.white('  yarn db:studio  # Open Prisma Studio'));
+            console.log(chalk_1.default.yellow('\n🚀 Next steps for API Server:'));
+            console.log(chalk_1.default.white('  cd packages/' + projectName));
+            console.log(chalk_1.default.white('  yarn dev        # Start development server'));
+            console.log(chalk_1.default.white('  yarn db:push    # Push database schema'));
+            console.log(chalk_1.default.white('  yarn db:studio  # Open Prisma Studio'));
         }
         else {
-            console.log(chalk.yellow('\n📦 Next steps for Shared Library:'));
-            console.log(chalk.white('  cd packages/' + projectName));
-            console.log(chalk.white('  yarn build'));
+            console.log(chalk_1.default.yellow('\n📦 Next steps for Shared Library:'));
+            console.log(chalk_1.default.white('  cd packages/' + projectName));
+            console.log(chalk_1.default.white('  yarn build'));
         }
     }
     catch (error) {
-        console.error(chalk.red('❌ Error creating project:'), error);
+        console.error(chalk_1.default.red('❌ Error creating project:'), error);
         process.exit(1);
     }
 });
@@ -843,34 +138,35 @@ program
     try {
         // Prompt for project name if not provided
         if (!projectName) {
-            projectName = await promptForProjectName();
+            projectName = await (0, utils_1.promptForProjectName)();
         }
         else {
             // Validate provided project name
-            const { validateProjectName } = await Promise.resolve().then(function () { return utils; });
+            const { validateProjectName } = await Promise.resolve().then(() => __importStar(require('./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)'));
+                console.error(chalk_1.default.red(`Invalid project name: ${projectName}`));
+                console.error(chalk_1.default.yellow('Project name must be a valid npm package name (lowercase, no spaces)'));
                 process.exit(1);
             }
             projectName = projectName.toLowerCase();
         }
-        await generateProject({
+        await (0, index_1.generateProject)({
             name: projectName,
             type: 'workspace',
             directory: options.directory,
             skipInstall: options.skipInstall || false
         });
-        console.log(chalk.green('✨ Successfully initialized Idealyst workspace!'));
-        console.log(chalk.blue(`📁 Workspace created in: ${options.directory}/${projectName}`));
-        console.log(chalk.yellow('\n🚀 Next steps:'));
-        console.log(chalk.white(`  cd ${projectName}`));
-        console.log(chalk.white('  idealyst create my-app --type native'));
-        console.log(chalk.white('  idealyst create my-web-app --type web'));
+        console.log(chalk_1.default.green('✨ Successfully initialized Idealyst workspace!'));
+        console.log(chalk_1.default.blue(`📁 Workspace created in: ${options.directory}/${projectName}`));
+        console.log(chalk_1.default.yellow('\n🚀 Next steps:'));
+        console.log(chalk_1.default.white(`  cd ${projectName}`));
+        console.log(chalk_1.default.white('  idealyst create my-app --type native'));
+        console.log(chalk_1.default.white('  idealyst create my-web-app --type web'));
     }
     catch (error) {
-        console.error(chalk.red('❌ Error initializing workspace:'), error);
+        console.error(chalk_1.default.red('❌ Error initializing workspace:'), error);
         process.exit(1);
     }
 });
 program.parse();
+//# sourceMappingURL=index.js.map