@enfyra/create-app 0.1.30

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git checkout:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/README.md

@@ -0,0 +1,116 @@
+# Create Enfyra App
+
+🚀 **The fastest way to create new Enfyra frontend applications**
+
+Create Enfyra App is a CLI tool that instantly scaffolds new Enfyra frontend projects with all the essentials configured for you.
+
+## ⚠️ Prerequisites
+
+**Important:** You need to have an Enfyra backend running before creating your frontend application. The frontend will connect to your backend API.
+
+📋 **Set up your backend first:**
+```bash
+npx @enfyra/create-server my-backend
+```
+
+👉 **[Backend Setup Guide](https://www.npmjs.com/package/@enfyra/create-server)** - Complete instructions for setting up your Enfyra backend
+
+## Quick Start
+
+```bash
+# Using npx (recommended)
+npx @enfyra/create-app my-app
+
+# Using yarn
+yarn create @enfyra/app my-app
+
+# Using pnpm  
+pnpm create @enfyra/app my-app
+
+# Using bun
+bun create @enfyra/app my-app
+
+# Or install globally
+npm install -g @enfyra/create-app
+create-app my-app
+```
+
+## Demo
+
+🌐 **Live Demo**: [https://demo.enfyra.io](https://demo.enfyra.io)
+
+## What You Get
+
+✅ **Nuxt 3** application ready to go  
+✅ **Enfyra SDK** pre-configured  
+✅ **TypeScript** support  
+✅ **Tailwind CSS** styling  
+✅ **Environment** variables setup  
+✅ **Dependencies** installed automatically  
+
+## Requirements
+
+- **Node.js** 20.0.0 or higher
+- **Package manager**: npm (8+), yarn (1.22+), pnpm (7+), or bun (1+)
+
+## Usage
+
+### Create a new project
+```bash
+npx @enfyra/create-app my-project
+```
+
+### Interactive setup
+The CLI will guide you through:
+- Package manager selection
+- API endpoint configuration  
+- Development port setup
+
+### Environment Variables
+After project creation, you can modify the `.env` file at any time to configure:
+- API endpoints
+- Port
+
+The `.env` file is automatically created and can be customized for your specific needs.
+
+### Start developing
+```bash
+cd my-project
+npm run dev
+```
+
+## After Installation
+
+Your new Enfyra app is ready! Here's what to do next:
+
+### Development
+```bash
+npm run dev      # Start development server
+npm run build    # Build for production
+npm run preview  # Preview production build
+```
+
+### Learn More
+
+📖 **[Complete Documentation](https://github.com/dothinh115/enfyra-app#readme)** - Full guide to building with Enfyra  
+🔧 **[API Reference](https://github.com/dothinh115/enfyra-app/blob/main/docs/API.md)** - Backend integration  
+🎨 **[UI Components](https://github.com/dothinh115/enfyra-app/blob/main/docs/COMPONENTS.md)** - Pre-built components  
+⚡ **[Best Practices](https://github.com/dothinh115/enfyra-app/blob/main/docs/BEST_PRACTICES.md)** - Development guidelines  
+
+## Support
+
+Having issues? We're here to help:
+
+- 🐛 [Report bugs](https://github.com/dothinh115/create-enfyra-app/issues)
+- 💬 [Ask questions](https://github.com/dothinh115/enfyra-app/discussions)
+- 📧 [Email support](mailto:dothinh115@gmail.com)
+
+## Related
+
+- **[Enfyra App](https://github.com/dothinh115/enfyra-app)** - The frontend template
+- **[Enfyra BE](https://github.com/dothinh115/enfyra_be)** - Backend framework
+- **[Create Enfyra Server](https://github.com/dothinh115/create-enfyra-server)** - Backend CLI
+
+---
+
+Built by [dothinh115](https://github.com/dothinh115) • MIT License

package/components/env-builder.js

@@ -0,0 +1,22 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+async function generateEnvFile(projectPath, config) {
+  const envContent = buildEnvContent(config);
+  const envPath = path.join(projectPath, '.env');
+  
+  await fs.writeFile(envPath, envContent);
+}
+
+function buildEnvContent(config) {
+  const lines = [
+    `API_URL=${config.apiUrl}`,
+    `PORT=${config.port}`
+  ];
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  generateEnvFile
+};

package/components/project-setup.js

@@ -0,0 +1,297 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { spawn, execSync } = require('child_process');
+const { downloadTemplate } = require('giget');
+const { generateEnvFile } = require('./env-builder');
+
+// Check available package managers with version validation
+function detectPackageManagers() {
+  const managers = [];
+  
+  // Check npm (minimum version 8.0.0)
+  try {
+    const npmVersion = execSync('npm --version', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      shell: true
+    }).trim();
+    const majorVersion = parseInt(npmVersion.split('.')[0]);
+    if (majorVersion >= 8) {
+      managers.push({ name: 'npm', value: 'npm', version: npmVersion });
+    }
+  } catch {}
+  
+  // Check yarn (minimum version 1.22.0)
+  try {
+    const yarnVersion = execSync('yarn --version', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      shell: true
+    }).trim();
+    const [major, minor] = yarnVersion.split('.').map(Number);
+    if (major > 1 || (major === 1 && minor >= 22)) {
+      managers.push({ name: 'yarn', value: 'yarn', version: yarnVersion });
+    }
+  } catch {}
+  
+  // Check pnpm (minimum version 7.0.0)
+  try {
+    const pnpmVersion = execSync('pnpm --version', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      shell: true
+    }).trim();
+    const majorVersion = parseInt(pnpmVersion.split('.')[0]);
+    if (majorVersion >= 7) {
+      managers.push({ name: 'pnpm', value: 'pnpm', version: pnpmVersion });
+    }
+  } catch {}
+  
+  // Note: bun is not supported due to native binding compatibility issues
+  
+  return managers;
+}
+
+async function setupProject(config, projectPath) {
+  const spinner = ora();
+  
+  try {
+    // Download Nuxt template using giget (will create directory)
+    spinner.start(chalk.blue(`Downloading Nuxt template...`));
+    await downloadTemplate('github:enfyra/app', {
+      dir: projectPath,
+      force: true,
+      provider: 'github'
+    });
+    spinner.succeed(chalk.green('Template downloaded successfully'));
+
+    // Update package.json
+    spinner.start(chalk.blue('Updating package.json...'));
+    await updatePackageJson(projectPath, config);
+    spinner.succeed(chalk.green('Package.json updated'));
+
+
+    // Update Nuxt config with API URL
+    spinner.start(chalk.blue('Configuring Nuxt with API URL...'));
+    await updateNuxtConfig(projectPath, config);
+    spinner.succeed(chalk.green('Nuxt configuration updated'));
+
+    // Generate environment file
+    spinner.start(chalk.blue('Generating environment file...'));
+    await generateEnvFile(projectPath, config);
+    spinner.succeed(chalk.green('Environment file created'));
+
+    // Clean package manager restriction files
+    spinner.start(chalk.blue('Cleaning package manager restrictions...'));
+    await cleanPackageManagerRestrictions(projectPath);
+    spinner.succeed(chalk.green('Package manager restrictions cleaned'));
+
+    // Install dependencies
+    spinner.start(chalk.blue(`Installing dependencies with ${config.packageManager}...`));
+    await installDependencies(projectPath, config);
+    spinner.succeed(chalk.green('Dependencies installed successfully'));
+
+    // Initialize git repository
+    spinner.start(chalk.blue('Initializing git repository...'));
+    await initializeGit(projectPath);
+    spinner.succeed(chalk.green('Git repository initialized'));
+
+  } catch (error) {
+    spinner.fail(chalk.red('Setup failed'));
+    
+    // Cleanup on failure
+    if (fs.existsSync(projectPath)) {
+      await fs.remove(projectPath);
+    }
+    
+    throw error;
+  }
+}
+
+
+
+async function updatePackageJson(projectPath, config) {
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error('package.json not found in template');
+  }
+  
+  const packageJson = await fs.readJson(packageJsonPath);
+  
+  // Update project name
+  packageJson.name = config.projectName;
+  
+  // Update version
+  packageJson.version = '0.1.0';
+  
+  // Clear repository info
+  delete packageJson.repository;
+  delete packageJson.bugs;
+  delete packageJson.homepage;
+  
+  await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+
+async function cleanPackageManagerRestrictions(projectPath) {
+  // List of files that can restrict package manager usage
+  const restrictionFiles = [
+    '.npmrc',
+    '.yarnrc',
+    '.yarnrc.yml',
+    'pnpm-workspace.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'bun.lockb'
+  ];
+
+  for (const file of restrictionFiles) {
+    const filePath = path.join(projectPath, file);
+    if (fs.existsSync(filePath)) {
+      await fs.remove(filePath);
+      console.log(chalk.yellow(`Removed ${file}`));
+    }
+  }
+
+  // Also check package.json for packageManager field and engines restrictions
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = await fs.readJson(packageJsonPath);
+
+    // Remove packageManager field that locks to specific manager
+    if (packageJson.packageManager) {
+      delete packageJson.packageManager;
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+      console.log(chalk.yellow('Removed packageManager restriction from package.json'));
+    }
+  }
+}
+
+
+async function updateNuxtConfig(projectPath, config) {
+  const nuxtConfigPath = path.join(projectPath, 'nuxt.config.ts');
+  
+  if (fs.existsSync(nuxtConfigPath)) {
+    let nuxtConfig = await fs.readFile(nuxtConfigPath, 'utf8');
+    
+    // Update enfyraSDK apiUrl
+    if (nuxtConfig.includes('enfyraSDK:')) {
+      nuxtConfig = nuxtConfig.replace(
+        /enfyraSDK:\s*\{[^}]*\}/,
+        `enfyraSDK: {\n    apiUrl: "${config.apiUrl}"\n  }`
+      );
+    } else {
+      // Add enfyraSDK config
+      nuxtConfig = nuxtConfig.replace(
+        /}\);?\s*$/,
+        `  enfyraSDK: {\n    apiUrl: "${config.apiUrl}"\n  },\n});\n`
+      );
+    }
+    
+    
+    await fs.writeFile(nuxtConfigPath, nuxtConfig);
+  }
+}
+
+async function installDependencies(projectPath, config) {
+  const commands = {
+    npm: ['install', '--legacy-peer-deps'],
+    yarn: ['install'],
+    pnpm: ['install']
+  };
+
+  const args = commands[config.packageManager] || commands.npm;
+
+  return new Promise((resolve, reject) => {
+    const install = spawn(config.packageManager, args, {
+      cwd: projectPath,
+      stdio: 'pipe',
+      shell: true
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    install.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    install.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    install.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        const errorMsg = stderr || stdout || 'Unknown error';
+        reject(new Error(`Package installation failed with code ${code}: ${errorMsg}`));
+      }
+    });
+
+    install.on('error', (error) => {
+      reject(new Error(`Package manager spawn error: ${error.message}. Make sure ${config.packageManager} is installed and in PATH`));
+    });
+  });
+}
+
+
+
+async function initializeGit(projectPath) {
+  // Check if git is available
+  try {
+    execSync('git --version', { stdio: 'pipe', shell: true });
+  } catch {
+    // Git is not available, skip initialization
+    return;
+  }
+
+  return new Promise((resolve) => {
+    const gitInit = spawn('git', ['init'], {
+      cwd: projectPath,
+      stdio: 'pipe',
+      shell: true
+    });
+    
+    gitInit.on('close', (code) => {
+      if (code === 0) {
+        // Add initial commit
+        const gitAdd = spawn('git', ['add', '.'], {
+          cwd: projectPath,
+          stdio: 'pipe',
+          shell: true
+        });
+        
+        gitAdd.on('close', (addCode) => {
+          if (addCode === 0) {
+            const gitCommit = spawn('git', ['commit', '-m', 'Initial commit from create-app'], {
+              cwd: projectPath,
+              stdio: 'pipe',
+              shell: true
+            });
+            
+            gitCommit.on('close', () => {
+              resolve();
+            });
+          } else {
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+    
+    gitInit.on('error', () => {
+      resolve();
+    });
+  });
+}
+
+module.exports = {
+  setupProject,
+  detectPackageManagers
+};

package/components/prompts.js

@@ -0,0 +1,58 @@
+const inquirer = require('inquirer');
+const { validateProjectName, validatePort, validateApiUrl } = require('./validators');
+
+function getPrompts(availableManagers) {
+  const questions = [
+    {
+      type: 'list',
+      name: 'packageManager',
+      message: 'Package manager:',
+      choices: availableManagers.map(pm => ({
+        name: `${getPackageManagerIcon(pm.name)} ${pm.name} (v${pm.version})`,
+        value: pm.value,
+        short: pm.name
+      })),
+      default: availableManagers.find(pm => pm.value === 'npm')?.value || availableManagers[0]?.value,
+    },
+    {
+      type: 'input',
+      name: 'apiUrl',
+      message: 'API base URL (must include http:// or https://):',
+      validate: validateApiUrl
+    },
+    {
+      type: 'input',
+      name: 'port',
+      message: 'App port:',
+      default: '3000',
+      validate: validatePort,
+      filter: (value) => parseInt(value, 10)
+    }
+  ];
+
+  return questions;
+}
+
+function getPackageManagerIcon(name) {
+  const icons = {
+    npm: '📦',
+    yarn: '🧶', 
+    pnpm: '⚡',
+    bun: '🚀'
+  };
+  return icons[name] || '📦';
+}
+
+async function promptForConfiguration(initialProjectName, availableManagers) {
+  const prompts = getPrompts(availableManagers);
+  const config = await inquirer.prompt(prompts);
+  
+  // Add project name to config
+  config.projectName = initialProjectName;
+  
+  return config;
+}
+
+module.exports = {
+  promptForConfiguration
+};

package/components/validators.js

@@ -0,0 +1,140 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+function checkNodeVersion() {
+  const currentVersion = process.version;
+  const requiredVersion = '20.0.0';
+  
+  const current = parseVersion(currentVersion.slice(1)); // Remove 'v' prefix
+  const required = parseVersion(requiredVersion);
+  
+  if (compareVersions(current, required) < 0) {
+    console.error(chalk.red.bold('❌ Node.js version error'));
+    console.error(chalk.red(`Current version: ${currentVersion}`));
+    console.error(chalk.red(`Required version: >= v${requiredVersion}`));
+    console.error(chalk.yellow('Please update Node.js to continue.'));
+    process.exit(1);
+  }
+}
+
+function parseVersion(version) {
+  return version.split('.').map(Number);
+}
+
+function compareVersions(a, b) {
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const aPart = a[i] || 0;
+    const bPart = b[i] || 0;
+    
+    if (aPart > bPart) return 1;
+    if (aPart < bPart) return -1;
+  }
+  return 0;
+}
+
+function validateProjectName(name) {
+  if (!name || typeof name !== 'string') {
+    return 'Project name is required';
+  }
+  
+  if (name.length < 1) {
+    return 'Project name cannot be empty';
+  }
+  
+  if (name.length > 214) {
+    return 'Project name cannot exceed 214 characters';
+  }
+  
+  if (!/^[a-z0-9-_]+$/i.test(name)) {
+    return 'Project name can only contain letters, numbers, hyphens, and underscores';
+  }
+  
+  if (/^[.-]/.test(name)) {
+    return 'Project name cannot start with a dot or hyphen';
+  }
+  
+  if (/[.-]$/.test(name)) {
+    return 'Project name cannot end with a dot or hyphen';
+  }
+  
+  // Check for reserved names
+  const reservedNames = [
+    'node_modules', '.git', '.env', 'package.json', 'dist', 'build',
+    'src', 'public', 'assets', 'components', 'pages', 'layouts',
+    'middleware', 'plugins', 'utils', 'server', 'static'
+  ];
+  
+  if (reservedNames.includes(name.toLowerCase())) {
+    return `"${name}" is a reserved name and cannot be used`;
+  }
+  
+  // Check if directory already exists
+  const projectPath = path.resolve(name);
+  if (fs.existsSync(projectPath)) {
+    return `Directory "${name}" already exists`;
+  }
+  
+  return true;
+}
+
+function validatePort(port) {
+  const portNum = parseInt(port, 10);
+  
+  if (isNaN(portNum)) {
+    return 'Port must be a number';
+  }
+  
+  if (portNum < 1 || portNum > 65535) {
+    return 'Port must be between 1 and 65535';
+  }
+  
+  return true;
+}
+
+function validateApiUrl(url) {
+  if (!url || url.trim().length === 0) {
+    return 'API URL is required';
+  }
+  
+  if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    return 'API URL must start with http:// or https:// (e.g., http://localhost:1105)';
+  }
+  
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return 'Please enter a valid URL (e.g., http://localhost:1105)';
+  }
+}
+
+function validateNonEmpty(value, fieldName) {
+  if (!value || value.trim().length === 0) {
+    return `${fieldName} cannot be empty`;
+  }
+  return true;
+}
+
+function validatePositiveNumber(value, fieldName) {
+  const num = parseInt(value, 10);
+  
+  if (isNaN(num)) {
+    return `${fieldName} must be a number`;
+  }
+  
+  if (num < 1) {
+    return `${fieldName} must be a positive number`;
+  }
+  
+  return true;
+}
+
+module.exports = {
+  checkNodeVersion,
+  validateProjectName,
+  validatePort,
+  validateApiUrl,
+  validateNonEmpty,
+  validatePositiveNumber
+};

package/index.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const inquirer = require('inquirer');
+const { checkNodeVersion } = require('./components/validators');
+const { promptForConfiguration } = require('./components/prompts');
+const { setupProject, detectPackageManagers } = require('./components/project-setup');
+
+const program = new Command();
+const packageJson = require('./package.json');
+
+// ASCII Art Banner
+const banner = `
+${chalk.cyan.bold('╔═══════════════════════════════════════╗')}
+${chalk.cyan.bold('║')}  ${chalk.white.bold('🚀 Create Enfyra App')}                ${chalk.cyan.bold('║')}
+${chalk.cyan.bold('║')}  ${chalk.gray('Frontend scaffolding made easy')}      ${chalk.cyan.bold('║')}
+${chalk.cyan.bold('╚═══════════════════════════════════════╝')}
+`;
+
+async function main() {
+  console.log(banner);
+  
+  try {
+    // Check Node.js version
+    checkNodeVersion();
+    
+    // Detect available package managers
+    const availableManagers = detectPackageManagers();
+    
+    if (availableManagers.length === 0) {
+      console.log(chalk.red('❌ No compatible package managers found!'));
+      console.log(chalk.yellow('Please install npm (v8+), yarn (v1.22+), pnpm (v7+), or bun (v1+)'));
+      process.exit(1);
+    }
+    
+    // Show detected package managers with versions
+    console.log(chalk.gray('Detected package managers:'));
+    availableManagers.forEach(pm => {
+      console.log(chalk.gray(`  • ${pm.name} v${pm.version}`));
+    });
+    console.log('');
+    
+    // Get project name from command line or prompt
+    let projectName = program.args[0];
+    
+    if (!projectName) {
+      const { name } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Project name:',
+          validate: (input) => {
+            if (!input || input.trim().length === 0) {
+              return 'Project name is required';
+            }
+            return true;
+          }
+        }
+      ]);
+      projectName = name;
+    }
+
+    // Validate project name and directory
+    const projectPath = path.resolve(projectName);
+    
+    if (fs.existsSync(projectPath)) {
+      console.log(chalk.red(`❌ Directory ${chalk.bold(projectName)} already exists!`));
+      process.exit(1);
+    }
+
+    // Prompt for configuration
+    const config = await promptForConfiguration(projectName, availableManagers);
+
+    // Setup project
+    await setupProject(config, projectPath);
+    
+    // Success message
+    console.log(chalk.green.bold('\n🎉 Project created successfully!'));
+    console.log(chalk.blue('\n📝 Next steps:'));
+    console.log(chalk.gray(`  cd ${projectName}`));
+    console.log(chalk.gray(`  ${config.packageManager} run dev`));
+    console.log();
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n❌ Error creating project:'));
+    console.error(chalk.red(error.message));
+    console.error(chalk.gray(error.stack));
+    
+    process.exit(1);
+  }
+}
+
+// Program setup
+program
+  .name('create-app')
+  .description('Create a new Enfyra frontend application')
+  .version(packageJson.version)
+  .argument('[project-name]', 'Name of the project to create')
+  .action(main);
+
+program.parse();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@enfyra/create-app",
+  "version": "0.1.30",
+  "description": "Create Enfyra frontend applications with ease",
+  "main": "index.js",
+  "bin": {
+    "create-app": "./index.js"
+  },
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "enfyra",
+    "frontend",
+    "nuxt",
+    "vue",
+    "cli",
+    "scaffold",
+    "generator"
+  ],
+  "author": "Enfyra Team",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.1.1",
+    "giget": "^2.0.0",
+    "inquirer": "^8.2.5",
+    "ora": "^5.4.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dothinh115/create-enfyra-app.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dothinh115/create-enfyra-app/issues"
+  },
+  "homepage": "https://github.com/dothinh115/create-enfyra-app#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}