@idealyst/cli 1.0.23 → 1.0.25

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 {
@@ -259,7 +306,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'
         }
@@ -327,6 +375,7 @@ var utils = /*#__PURE__*/Object.freeze({
   getTemplateData: getTemplateData,
   initializeReactNativeProject: initializeReactNativeProject,
   installDependencies: installDependencies,
+  isWorkspaceRoot: isWorkspaceRoot,
   mergePackageJsonDependencies: mergePackageJsonDependencies,
   overlayIdealystFiles: overlayIdealystFiles,
   processTemplateFile: processTemplateFile,
@@ -334,13 +383,14 @@ var utils = /*#__PURE__*/Object.freeze({
   promptForAppName: promptForAppName,
   promptForProjectName: promptForProjectName,
   promptForProjectType: promptForProjectType,
+  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;
     if (!validateProjectName(name)) {
@@ -349,14 +399,17 @@ async function generateNativeProject(options) {
     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
@@ -382,20 +435,20 @@ 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;
     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);
     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'));
@@ -407,20 +460,20 @@ async function generateWebProject(options) {
     console.log(chalk.white('  • React Router'));
 }
 
-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 +483,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 +492,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 +505,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 +546,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}`);
     }
@@ -505,7 +587,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(', ')}`));
@@ -524,20 +606,27 @@ program
             appName
         });
         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'));
         }
     }

package/dist/types/generators/api.d.ts

@@ -0,0 +1,2 @@
+import { GenerateProjectOptions } from '../types';
+export declare function generateApiProject(options: GenerateProjectOptions): Promise<void>;

package/dist/types/generators/index.d.ts

@@ -4,3 +4,4 @@ export * from './native';
 export * from './web';
 export * from './shared';
 export * from './workspace';
+export * from './api';

package/dist/types/generators/utils.d.ts

@@ -1,7 +1,7 @@
 import { TemplateData } from '../types';
 export declare function validateProjectName(name: string): boolean;
 export declare function createPackageName(name: string): string;
-export declare function updateWorkspacePackageJson(projectName: string, directory: string): Promise<void>;
+export declare function updateWorkspacePackageJson(workspacePath: string, directory: string): Promise<void>;
 export declare function copyTemplate(templatePath: string, destPath: string, data: TemplateData): Promise<void>;
 export declare function processTemplateFiles(dir: string, data: TemplateData): Promise<void>;
 export declare function processTemplateFile(filePath: string, data: TemplateData): Promise<void>;
@@ -10,6 +10,19 @@ export declare function runCommand(command: string, args: string[], options: {
     cwd: string;
 }): Promise<void>;
 export declare function getTemplateData(projectName: string, description?: string, appName?: string): TemplateData;
+/**
+ * Detects if we're in a workspace root directory
+ */
+export declare function isWorkspaceRoot(directory: string): Promise<boolean>;
+/**
+ * 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.
+ */
+export declare function resolveProjectPath(projectName: string, directory: string): Promise<{
+    projectPath: string;
+    workspacePath: string;
+}>;
 export declare function initializeReactNativeProject(projectName: string, directory: string, displayName?: string, skipInstall?: boolean): Promise<void>;
 export declare function overlayIdealystFiles(templatePath: string, projectPath: string, data: TemplateData): Promise<void>;
 export declare function mergePackageJsonDependencies(templatePath: string, projectPath: string): Promise<void>;

package/dist/types/types.d.ts

@@ -1,4 +1,4 @@
-export type ProjectType = 'native' | 'web' | 'shared' | 'workspace';
+export type ProjectType = 'native' | 'web' | 'shared' | 'workspace' | 'api';
 export interface GenerateProjectOptions {
     name: string;
     type: ProjectType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idealyst/cli",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "CLI tool for generating Idealyst Framework projects",
   "type": "module",
   "main": "dist/index.js",