@idealyst/cli 1.0.24 → 1.0.26

package/README.md

@@ -1,110 +1,110 @@
-# @idealyst/cli
-
-CLI tool for generating Idealyst Framework projects.
-
-## Installation
-
-Install globally:
-```bash
-npm install -g @idealyst/cli
-# or
-yarn global add @idealyst/cli
-```
-
-## Usage
-
-### Create a new project
-
-```bash
-idealyst create <project-name> [options]
-```
-
-Options:
-- `-t, --type <type>` - Project type: `native`, `web`, or `shared` (default: `native`)
-- `-d, --directory <directory>` - Output directory (default: current directory)
-- `--skip-install` - Skip installing dependencies
-
-### Initialize a new workspace
-
-```bash
-idealyst init [options]
-```
-
-Options:
-- `-d, --directory <directory>` - Output directory (default: current directory)
-- `--skip-install` - Skip installing dependencies
-
-## Examples
-
-Create a React Native app:
-```bash
-idealyst create my-app --type native
-```
-
-Create a React web app:
-```bash
-idealyst create my-web-app --type web
-```
-
-Create a shared library:
-```bash
-idealyst create my-lib --type shared
-```
-
-Initialize a new workspace:
-```bash
-idealyst init
-```
-
-## Project Types
-
-### Native (React Native)
-- React Native 0.80.1
-- Idealyst Components
-- Idealyst Navigation
-- Idealyst Theme
-- TypeScript configuration
-- Metro bundler configuration
-- Babel configuration
-
-### Web (React + Vite)
-- React 19.1
-- Vite build system
-- Idealyst Components (web-compatible)
-- Idealyst Navigation
-- Idealyst Theme
-- TypeScript configuration
-- React Native Web support
-
-### Shared Library
-- Cross-platform components
-- TypeScript definitions
-- Rollup build system
-- Peer dependencies for React/React Native
-- Idealyst Theme integration
-
-### Workspace
-- Yarn workspace configuration
-- Monorepo structure
-- Version management scripts
-- Build scripts for all packages
-
-## Development
-
-Build the CLI:
-```bash
-cd packages/cli
-yarn build
-```
-
-Link for local development:
-```bash
-yarn link
-```
-
-## Learn More
-
-- [Idealyst Framework Documentation](https://github.com/your-username/idealyst-framework)
-- [React Native Documentation](https://reactnative.dev/)
-- [React Documentation](https://react.dev/)
+# @idealyst/cli
+
+CLI tool for generating Idealyst Framework projects.
+
+## Installation
+
+Install globally:
+```bash
+npm install -g @idealyst/cli
+# or
+yarn global add @idealyst/cli
+```
+
+## Usage
+
+### Create a new project
+
+```bash
+idealyst create <project-name> [options]
+```
+
+Options:
+- `-t, --type <type>` - Project type: `native`, `web`, or `shared` (default: `native`)
+- `-d, --directory <directory>` - Output directory (default: current directory)
+- `--skip-install` - Skip installing dependencies
+
+### Initialize a new workspace
+
+```bash
+idealyst init [options]
+```
+
+Options:
+- `-d, --directory <directory>` - Output directory (default: current directory)
+- `--skip-install` - Skip installing dependencies
+
+## Examples
+
+Create a React Native app:
+```bash
+idealyst create my-app --type native
+```
+
+Create a React web app:
+```bash
+idealyst create my-web-app --type web
+```
+
+Create a shared library:
+```bash
+idealyst create my-lib --type shared
+```
+
+Initialize a new workspace:
+```bash
+idealyst init
+```
+
+## Project Types
+
+### Native (React Native)
+- React Native 0.80.1
+- Idealyst Components
+- Idealyst Navigation
+- Idealyst Theme
+- TypeScript configuration
+- Metro bundler configuration
+- Babel configuration
+
+### Web (React + Vite)
+- React 19.1
+- Vite build system
+- Idealyst Components (web-compatible)
+- Idealyst Navigation
+- Idealyst Theme
+- TypeScript configuration
+- React Native Web support
+
+### Shared Library
+- Cross-platform components
+- TypeScript definitions
+- Rollup build system
+- Peer dependencies for React/React Native
+- Idealyst Theme integration
+
+### Workspace
+- Yarn workspace configuration
+- Monorepo structure
+- Version management scripts
+- Build scripts for all packages
+
+## Development
+
+Build the CLI:
+```bash
+cd packages/cli
+yarn build
+```
+
+Link for local development:
+```bash
+yarn link
+```
+
+## Learn More
+
+- [Idealyst Framework Documentation](https://github.com/your-username/idealyst-framework)
+- [React Native Documentation](https://reactnative.dev/)
+- [React Documentation](https://react.dev/)
 - [Vite Documentation](https://vitejs.dev/) 

package/dist/index.js

@@ -16,7 +16,7 @@ function validateProjectName(name) {
 function createPackageName(name) {
     return name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
 }
-async function updateWorkspacePackageJson(projectName, directory) {
+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)) {
@@ -24,11 +24,18 @@ async function updateWorkspacePackageJson(projectName, directory) {
             const packageJson = await fs.readJSON(packageJsonPath);
             // Check if this is a workspace (has workspaces property)
             if (packageJson.workspaces && Array.isArray(packageJson.workspaces)) {
-                // Add the new project to workspaces if not already present
-                if (!packageJson.workspaces.includes(projectName)) {
-                    packageJson.workspaces.push(projectName);
+                // 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 ${projectName} to workspace configuration`));
+                    console.log(chalk.green(`✅ Added ${workspacePath} to workspace configuration`));
+                }
+                else {
+                    console.log(chalk.blue(`📦 Project ${workspacePath} already covered by existing workspace configuration`));
                 }
             }
         }
@@ -78,6 +85,9 @@ async function processTemplateFile(filePath, data) {
         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) {
@@ -133,6 +143,43 @@ function getTemplateData(projectName, description, appName) {
         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;
+}
+/**
+ * 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.`);
+    }
+    // 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}`
+    };
+}
 async function initializeReactNativeProject(projectName, directory, displayName, skipInstall) {
     const spinner = ora('Initializing React Native project...').start();
     try {
@@ -206,6 +253,10 @@ async function mergePackageJsonDependencies(templatePath, projectPath) {
             '@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',
@@ -259,7 +310,8 @@ async function promptForProjectType() {
             choices: [
                 { name: 'React Native App', value: 'native' },
                 { name: 'React Web App', value: 'web' },
-                { name: 'Shared Library', value: 'shared' }
+                { name: 'Shared Library', value: 'shared' },
+                { name: 'API Server (tRPC + Prisma + Zod)', value: 'api' }
             ],
             default: 'native'
         }
@@ -284,6 +336,71 @@ async function promptForAppName(projectName) {
     ]);
     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 {
@@ -323,10 +440,13 @@ var utils = /*#__PURE__*/Object.freeze({
   __proto__: null,
   configureAndroidVectorIcons: configureAndroidVectorIcons,
   copyTemplate: copyTemplate,
+  copyTrpcAppComponent: copyTrpcAppComponent,
+  copyTrpcFiles: copyTrpcFiles,
   createPackageName: createPackageName,
   getTemplateData: getTemplateData,
   initializeReactNativeProject: initializeReactNativeProject,
   installDependencies: installDependencies,
+  isWorkspaceRoot: isWorkspaceRoot,
   mergePackageJsonDependencies: mergePackageJsonDependencies,
   overlayIdealystFiles: overlayIdealystFiles,
   processTemplateFile: processTemplateFile,
@@ -334,34 +454,49 @@ var utils = /*#__PURE__*/Object.freeze({
   promptForAppName: promptForAppName,
   promptForProjectName: promptForProjectName,
   promptForProjectType: promptForProjectType,
+  promptForTrpcIntegration: promptForTrpcIntegration,
+  removeTrpcDependencies: removeTrpcDependencies,
+  resolveProjectPath: resolveProjectPath,
   runCommand: runCommand,
   updateWorkspacePackageJson: updateWorkspacePackageJson,
   validateProjectName: validateProjectName
 });
 
-const __filename$3 = fileURLToPath(import.meta.url);
-const __dirname$3 = path.dirname(__filename$3);
+const __filename$4 = fileURLToPath(import.meta.url);
+const __dirname$4 = path.dirname(__filename$4);
 async function generateNativeProject(options) {
-    const { name, directory, skipInstall, appName } = 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 = path.join(directory, name);
-    const templatePath = path.join(__dirname$3, '..', 'templates', 'native');
+    const { projectPath, workspacePath } = await resolveProjectPath(name, directory);
+    const templatePath = path.join(__dirname$4, '..', 'templates', 'native');
     const templateData = getTemplateData(name, `React Native app built with Idealyst Framework`, displayName);
     try {
         // Step 1: Update workspace configuration FIRST (before React Native CLI)
-        await updateWorkspacePackageJson(name, directory);
+        await updateWorkspacePackageJson(workspacePath, directory);
         // Step 2: Initialize React Native project using CLI with --skip-install
-        await initializeReactNativeProject(name, directory, displayName, true);
+        // Note: For React Native CLI, we need to run it in the parent directory and specify the project name
+        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);
-        // Step 4: Configure Android vector icons
+        // Step 4: Handle tRPC setup
+        if (withTrpc) {
+            await copyTrpcFiles(templatePath, projectPath, templateData);
+            await copyTrpcAppComponent(templatePath, projectPath, templateData);
+        }
+        // Step 5: Configure Android vector icons
         await configureAndroidVectorIcons(projectPath);
-        // Step 5: Install dependencies (including Idealyst packages) after workspace config is updated
+        // Step 6: Remove tRPC dependencies if not requested (after merge but before install)
+        if (!withTrpc) {
+            await removeTrpcDependencies(projectPath);
+        }
+        // Step 7: Install dependencies (including Idealyst packages) after workspace config is updated
         await installDependencies(projectPath, skipInstall);
         console.log(chalk.green('✅ React Native project created successfully!'));
         console.log(chalk.blue('📋 Project includes:'));
@@ -374,6 +509,11 @@ async function generateNativeProject(options) {
         console.log(chalk.white('  • Metro configuration'));
         console.log(chalk.white('  • Babel configuration'));
         console.log(chalk.white('  • Native platform directories (android/, ios/)'));
+        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'));
+        }
     }
     catch (error) {
         console.error(chalk.red('❌ Error creating React Native project:'));
@@ -382,20 +522,29 @@ async function generateNativeProject(options) {
     }
 }
 
-const __filename$2 = fileURLToPath(import.meta.url);
-const __dirname$2 = path.dirname(__filename$2);
+const __filename$3 = fileURLToPath(import.meta.url);
+const __dirname$3 = path.dirname(__filename$3);
 async function generateWebProject(options) {
-    const { name, directory, skipInstall } = 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 = path.join(directory, name);
-    const templatePath = path.join(__dirname$2, '..', 'templates', 'web');
+    const { projectPath, workspacePath } = await resolveProjectPath(name, directory);
+    const templatePath = path.join(__dirname$3, '..', 'templates', 'web');
     const templateData = getTemplateData(name, `React web app built with Idealyst Framework`);
     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(name, directory);
+    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'));
@@ -405,22 +554,27 @@ async function generateWebProject(options) {
     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$1 = fileURLToPath(import.meta.url);
-const __dirname$1 = path.dirname(__filename$1);
+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 = path.join(directory, name);
-    const templatePath = path.join(__dirname$1, '..', 'templates', 'shared');
+    const { projectPath, workspacePath } = await resolveProjectPath(name, directory);
+    const templatePath = path.join(__dirname$2, '..', 'templates', 'shared');
     const templateData = getTemplateData(name, `Shared library built with Idealyst Framework`);
     await copyTemplate(templatePath, projectPath, templateData);
     await installDependencies(projectPath, skipInstall);
-    await updateWorkspacePackageJson(name, directory);
+    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'));
@@ -430,8 +584,8 @@ async function generateSharedLibrary(options) {
     console.log(chalk.white('  • React & React Native support'));
 }
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+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)) {
@@ -439,7 +593,7 @@ async function generateWorkspace(options) {
     }
     console.log(chalk.blue(`🏗️ Creating Idealyst workspace: ${name}`));
     const projectPath = path.join(directory, name);
-    const templatePath = path.join(__dirname, '..', 'templates', 'workspace');
+    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);
@@ -452,6 +606,32 @@ async function generateWorkspace(options) {
     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 } = await resolveProjectPath(name, directory);
+    const templatePath = path.join(__dirname, '..', 'templates', 'api');
+    const templateData = getTemplateData(name, `Clean API server template with tRPC, Prisma, and Zod`);
+    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) {
@@ -467,6 +647,9 @@ async function generateProject(options) {
         case 'workspace':
             await generateWorkspace(options);
             break;
+        case 'api':
+            await generateApiProject(options);
+            break;
         default:
             throw new Error(`Unknown project type: ${type}`);
     }
@@ -480,9 +663,10 @@ program
 program
     .command('create [project-name]')
     .description('Create a new Idealyst project')
-    .option('-t, --type <type>', 'Project type: native, web, or shared')
+    .option('-t, --type <type>', 'Project type: native, web, shared, or api')
     .option('-d, --directory <directory>', 'Output directory', '.')
     .option('-a, --app-name <app-name>', 'Display name for native apps (e.g., "My Awesome App")')
+    .option('--with-trpc', 'Include tRPC boilerplate and setup (for web/native projects)')
     .option('--skip-install', 'Skip installing dependencies')
     .action(async (projectName, options) => {
     try {
@@ -505,7 +689,7 @@ program
         if (!projectType) {
             projectType = await promptForProjectType();
         }
-        const validTypes = ['native', 'web', 'shared'];
+        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(', ')}`));
@@ -516,28 +700,41 @@ program
         if (projectType === 'native' && !appName) {
             appName = await 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();
+        }
         await generateProject({
             name: projectName,
             type: projectType,
             directory: options.directory,
             skipInstall: options.skipInstall || false,
-            appName
+            appName,
+            withTrpc: withTrpc || false
         });
         console.log(chalk.green(`✨ Successfully created ${projectName}!`));
-        console.log(chalk.blue(`📁 Project created in: ${options.directory}/${projectName}`));
+        console.log(chalk.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 ' + projectName));
+            console.log(chalk.white('  cd packages/' + projectName));
             console.log(chalk.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 ' + projectName));
+            console.log(chalk.white('  cd packages/' + projectName));
             console.log(chalk.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'));
+        }
         else {
             console.log(chalk.yellow('\n📦 Next steps for Shared Library:'));
-            console.log(chalk.white('  cd ' + projectName));
+            console.log(chalk.white('  cd packages/' + projectName));
             console.log(chalk.white('  yarn build'));
         }
     }