@idealyst/cli 1.0.2

package/README.md

@@ -0,0 +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/)
+- [Vite Documentation](https://vitejs.dev/) 

package/dist/index.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs-extra';
+import { spawn } from 'child_process';
+import ora from 'ora';
+import validatePackageName from 'validate-npm-package-name';
+
+function validateProjectName(name) {
+    const validation = validatePackageName(name);
+    return validation.validForNewPackages;
+}
+function createPackageName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+}
+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);
+                return !relativePath.includes('node_modules') && !relativePath.includes('.git');
+            }
+        });
+        // 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);
+        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');
+        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'));
+    }
+}
+function runCommand(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const process = spawn(command, args, {
+            cwd: options.cwd,
+            stdio: 'inherit',
+            shell: true
+        });
+        process.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command failed with code ${code}`));
+            }
+        });
+        process.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+function getTemplateData(projectName, description) {
+    return {
+        projectName,
+        packageName: createPackageName(projectName),
+        version: '1.0.0',
+        description: description || `A new Idealyst project: ${projectName}`
+    };
+}
+
+async function generateNativeProject(options) {
+    const { name, directory, skipInstall } = options;
+    if (!validateProjectName(name)) {
+        throw new Error(`Invalid project name: ${name}`);
+    }
+    console.log(chalk.blue(`📱 Creating React Native project: ${name}`));
+    const projectPath = path.join(directory, name);
+    const templatePath = path.join(__dirname, '..', '..', 'templates', 'native');
+    const templateData = getTemplateData(name, `React Native app built with Idealyst Framework`);
+    await copyTemplate(templatePath, projectPath, templateData);
+    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 0.80.1'));
+    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('  • Metro configuration'));
+    console.log(chalk.white('  • Babel configuration'));
+}
+
+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, '..', '..', 'templates', 'web');
+    const templateData = getTemplateData(name, `React web app built with Idealyst Framework`);
+    await copyTemplate(templatePath, projectPath, templateData);
+    await installDependencies(projectPath, skipInstall);
+    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'));
+}
+
+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, '..', '..', 'templates', 'shared');
+    const templateData = getTemplateData(name, `Shared library built with Idealyst Framework`);
+    await copyTemplate(templatePath, projectPath, templateData);
+    await installDependencies(projectPath, skipInstall);
+    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'));
+}
+
+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, '..', '..', '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'));
+}
+
+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;
+        default:
+            throw new Error(`Unknown project type: ${type}`);
+    }
+}
+
+const program = new Command();
+program
+    .name('idealyst')
+    .description('CLI tool for generating Idealyst Framework projects')
+    .version('1.0.1');
+program
+    .command('create <project-name>')
+    .description('Create a new Idealyst project')
+    .option('-t, --type <type>', 'Project type: native, web, or shared', 'native')
+    .option('-d, --directory <directory>', 'Output directory', '.')
+    .option('--skip-install', 'Skip installing dependencies')
+    .action(async (projectName, options) => {
+    const validTypes = ['native', 'web', 'shared'];
+    if (!validTypes.includes(options.type)) {
+        console.error(chalk.red(`Invalid project type: ${options.type}`));
+        console.error(chalk.yellow(`Valid types are: ${validTypes.join(', ')}`));
+        process.exit(1);
+    }
+    try {
+        await generateProject({
+            name: projectName,
+            type: options.type,
+            directory: options.directory,
+            skipInstall: options.skipInstall || false
+        });
+        console.log(chalk.green(`✨ Successfully created ${projectName}!`));
+        console.log(chalk.blue(`📁 Project created in: ${options.directory}/${projectName}`));
+        if (options.type === 'native') {
+            console.log(chalk.yellow('\n📱 Next steps for React Native:'));
+            console.log(chalk.white('  cd ' + projectName));
+            console.log(chalk.white('  yarn android  # or yarn ios'));
+        }
+        else if (options.type === 'web') {
+            console.log(chalk.yellow('\n🌐 Next steps for React Web:'));
+            console.log(chalk.white('  cd ' + projectName));
+            console.log(chalk.white('  yarn dev'));
+        }
+        else {
+            console.log(chalk.yellow('\n📦 Next steps for Shared Library:'));
+            console.log(chalk.white('  cd ' + projectName));
+            console.log(chalk.white('  yarn build'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Error creating project:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('init')
+    .description('Initialize a new Idealyst monorepo workspace')
+    .option('-d, --directory <directory>', 'Output directory', '.')
+    .option('--skip-install', 'Skip installing dependencies')
+    .action(async (options) => {
+    try {
+        await generateProject({
+            name: 'idealyst-workspace',
+            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}/idealyst-workspace`));
+        console.log(chalk.yellow('\n🚀 Next steps:'));
+        console.log(chalk.white('  cd idealyst-workspace'));
+        console.log(chalk.white('  idealyst create my-app --type native'));
+        console.log(chalk.white('  idealyst create my-web-app --type web'));
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Error initializing workspace:'), error);
+        process.exit(1);
+    }
+});
+program.parse();

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

@@ -0,0 +1,6 @@
+import { GenerateProjectOptions } from '../types';
+export declare function generateProject(options: GenerateProjectOptions): Promise<void>;
+export * from './native';
+export * from './web';
+export * from './shared';
+export * from './workspace';

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { TemplateData } from '../types';
+export declare function validateProjectName(name: string): boolean;
+export declare function createPackageName(name: string): string;
+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>;
+export declare function installDependencies(projectPath: string, skipInstall?: boolean): Promise<void>;
+export declare function runCommand(command: string, args: string[], options: {
+    cwd: string;
+}): Promise<void>;
+export declare function getTemplateData(projectName: string, description?: string): TemplateData;

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

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

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

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

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,13 @@
+export type ProjectType = 'native' | 'web' | 'shared' | 'workspace';
+export interface GenerateProjectOptions {
+    name: string;
+    type: ProjectType;
+    directory: string;
+    skipInstall: boolean;
+}
+export interface TemplateData {
+    projectName: string;
+    packageName: string;
+    version: string;
+    description: string;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@idealyst/cli",
+  "version": "1.0.2",
+  "description": "CLI tool for generating Idealyst Framework projects",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "idealyst": "dist/index.js",
+    "idealyst-cli": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/idealyst-framework.git",
+    "directory": "packages/cli"
+  },
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "prepublishOnly": "yarn build",
+    "publish:npm": "npm publish"
+  },
+  "dependencies": {
+    "chalk": "^5.0.0",
+    "commander": "^11.0.0",
+    "fs-extra": "^11.0.0",
+    "inquirer": "^9.0.0",
+    "ora": "^7.0.0",
+    "validate-npm-package-name": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.0",
+    "@types/inquirer": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "@types/validate-npm-package-name": "^4.0.0",
+    "rollup": "^3.20.0",
+    "rollup-plugin-commonjs": "^10.1.0",
+    "rollup-plugin-json": "^4.0.0",
+    "rollup-plugin-node-resolve": "^5.2.0",
+    "rollup-plugin-typescript2": "^0.34.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "keywords": [
+    "cli",
+    "generator",
+    "react",
+    "react-native",
+    "cross-platform",
+    "idealyst"
+  ]
+}

package/templates/native/README.md

@@ -0,0 +1,86 @@
+# {{projectName}}
+
+{{description}}
+
+## Getting Started
+
+This is a React Native application built with the Idealyst Framework.
+
+### Prerequisites
+
+- Node.js 18+
+- Yarn
+- React Native development environment
+- Android Studio (for Android development)
+- Xcode (for iOS development)
+
+### Installation
+
+Install dependencies:
+```bash
+yarn install
+```
+
+### Running the App
+
+Start the Metro bundler:
+```bash
+yarn start
+```
+
+Run on Android:
+```bash
+yarn android
+```
+
+Run on iOS:
+```bash
+yarn ios
+```
+
+### Project Structure
+
+```
+{{projectName}}/
+├── src/
+│   └── App.tsx        # Main app component
+├── android/           # Android-specific code
+├── ios/               # iOS-specific code
+├── babel.config.js    # Babel configuration
+├── metro.config.js    # Metro configuration
+└── tsconfig.json      # TypeScript configuration
+```
+
+### Features
+
+- **Idealyst Components**: Pre-built UI components
+- **Idealyst Navigation**: Cross-platform navigation
+- **Idealyst Theme**: Consistent theming system
+- **TypeScript**: Full type safety
+- **React Native 0.80.1**: Latest stable version
+
+### Development
+
+The app uses the Idealyst Framework for consistent UI and navigation across platforms.
+
+Edit `src/App.tsx` to start building your application.
+
+### Building for Production
+
+Build Android APK:
+```bash
+yarn build:android
+```
+
+### Testing
+
+Run tests:
+```bash
+yarn test
+```
+
+### Learn More
+
+- [Idealyst Framework Documentation](https://github.com/your-username/idealyst-framework)
+- [React Native Documentation](https://reactnative.dev/)
+- [TypeScript Documentation](https://www.typescriptlang.org/) 

package/templates/native/app.json

@@ -0,0 +1,5 @@
+{
+  "name": "{{projectName}}",
+  "displayName": "{{projectName}}",
+  "react-native-version": "0.80.1"
+} 

package/templates/native/babel.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  presets: ['@react-native/babel-preset'],
+  plugins: [
+    [
+      'module-resolver',
+      {
+        root: ['./src'],
+        alias: {
+          '@': './src',
+        },
+      },
+    ],
+  ],
+}; 

package/templates/native/index.js

@@ -0,0 +1,9 @@
+/**
+ * @format
+ */
+
+import { AppRegistry } from 'react-native';
+import App from './src/App';
+import { name as appName } from './app.json';
+
+AppRegistry.registerComponent(appName, () => App); 

package/templates/native/metro.config.js

@@ -0,0 +1,11 @@
+const { getDefaultConfig } = require('@react-native/metro-config');
+
+/**
+ * Metro configuration
+ * https://reactnative.dev/docs/metro
+ *
+ * @type {import('metro-config').MetroConfig}
+ */
+const config = getDefaultConfig(__dirname);
+
+module.exports = config;