vako 1.3.0

package/bin/commands/quick-setup.js

@@ -0,0 +1,111 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { createSpinner } = require('nanospinner');
+
+class QuickSetup {
+  constructor(projectName, options = {}) {
+    this.projectName = projectName;
+    this.options = options;
+    this.config = {
+      projectName,
+      template: options.template || 'default',
+      features: ['hotreload', 'layouts'],
+      database: 'sqlite',
+      auth: { enabled: false },
+      plugins: ['logger', 'security'],
+      styling: 'bootstrap',
+      git: true,
+      install: true
+    };
+  }
+
+  async start() {
+    console.log(chalk.blue.bold(`\n🚀 Quick Setup for "${this.projectName}"\n`));
+
+    if (!this.options.template) {
+      await this.selectTemplate();
+    }
+
+    await this.askEssentialQuestions();
+    await this.execute();
+  }
+
+  async selectTemplate() {
+    const { template } = await inquirer.prompt([{
+      type: 'list',
+      name: 'template',
+      message: '🎯 Choose a template:',
+      choices: [
+        { name: '🌟 Default - Full web app', value: 'default' },
+        { name: '🔌 API - REST API only', value: 'api' },
+        { name: '📝 Blog - Content management', value: 'blog' },
+        { name: '👑 Admin - Dashboard', value: 'admin' },
+        { name: '🎭 Portfolio - Showcase', value: 'portfolio' }
+      ]
+    }]);
+
+    this.config.template = template;
+  }
+
+  async askEssentialQuestions() {
+    const questions = [
+      {
+        type: 'confirm',
+        name: 'auth',
+        message: '🔐 Include authentication?',
+        default: ['admin', 'blog'].includes(this.config.template),
+        when: () => this.config.template !== 'api'
+      },
+      {
+        type: 'list',
+        name: 'database',
+        message: '🗄️ Database type:',
+        choices: [
+          { name: '📄 SQLite (easy)', value: 'sqlite' },
+          { name: '🐘 PostgreSQL', value: 'postgresql' },
+          { name: '🍃 MongoDB', value: 'mongodb' },
+          { name: '🚫 None', value: 'none' }
+        ],
+        when: () => ['api', 'blog', 'admin'].includes(this.config.template)
+      },
+      {
+        type: 'list',
+        name: 'styling',
+        message: '🎨 CSS framework:',
+        choices: [
+          { name: '🅱️ Bootstrap', value: 'bootstrap' },
+          { name: '🎯 Tailwind', value: 'tailwind' },
+          { name: '🎭 Custom', value: 'custom' }
+        ],
+        when: () => this.config.template !== 'api'
+      }
+    ];
+
+    const answers = await inquirer.prompt(questions);
+    
+    if (answers.auth) {
+      this.config.auth.enabled = true;
+    }
+    if (answers.database) {
+      this.config.database = answers.database;
+    }
+    if (answers.styling) {
+      this.config.styling = answers.styling;
+    }
+  }
+
+  async execute() {
+    const SetupExecutor = require('./setup-executor');
+    const executor = new SetupExecutor(this.config);
+    
+    console.log(chalk.green('\n🎯 Creating your project...\n'));
+    await executor.execute();
+    
+    console.log(chalk.green.bold('\n✨ Quick setup complete!\n'));
+    console.log(chalk.cyan('Next steps:'));
+    console.log(chalk.white(`  cd ${this.projectName}`));
+    console.log(chalk.white('  npm run dev'));
+  }
+}
+
+module.exports = QuickSetup;

package/bin/commands/setup-executor.js

@@ -0,0 +1,203 @@
+const { createSpinner } = require('nanospinner');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class SetupExecutor {
+  constructor(config) {
+    this.config = config;
+    this.projectPath = path.resolve(process.cwd(), config.projectName);
+  }
+
+  async execute() {
+    const totalSteps = 8;
+    let currentStep = 0;
+
+    try {
+      // Step 1: Create directory
+      currentStep++;
+      const spinner1 = createSpinner(`[${currentStep}/${totalSteps}] 📁 Creating project directory...`).start();
+      await this.sleep(800);
+      await this.createDirectory();
+      spinner1.success({ text: `📁 Project directory created` });
+
+      // Step 2: Generate project structure
+      currentStep++;
+      const spinner2 = createSpinner(`[${currentStep}/${totalSteps}] 🏗️ Generating project structure...`).start();
+      await this.sleep(1200);
+      await this.createProjectStructure();
+      spinner2.success({ text: `🏗️ Project structure created` });
+
+      // Step 3: Generate templates and files
+      currentStep++;
+      const spinner3 = createSpinner(`[${currentStep}/${totalSteps}] 📄 Generating template files...`).start();
+      await this.sleep(1500);
+      await this.generateTemplateFiles();
+      spinner3.success({ text: `📄 Template files generated` });
+
+      // Step 4: Configure features and plugins
+      currentStep++;
+      const spinner4 = createSpinner(`[${currentStep}/${totalSteps}] ⚡ Configuring features and plugins...`).start();
+      await this.sleep(1000);
+      await this.configureFeatures();
+      spinner4.success({ text: `⚡ Features and plugins configured` });
+
+      // Step 5: Setup authentication
+      if (this.config.auth.enabled) {
+        currentStep++;
+        const spinner5 = createSpinner(`[${currentStep}/${totalSteps}] 🔐 Setting up authentication...`).start();
+        await this.sleep(1300);
+        await this.setupAuthentication();
+        spinner5.success({ text: `🔐 Authentication system configured` });
+      }
+
+      // Step 6: Setup database
+      if (this.config.database !== 'none') {
+        currentStep++;
+        const spinner6 = createSpinner(`[${currentStep}/${totalSteps}] 🗄️ Configuring database...`).start();
+        await this.sleep(900);
+        await this.setupDatabase();
+        spinner6.success({ text: `🗄️ Database configured` });
+      }
+
+      // Step 7: Initialize Git
+      if (this.config.git) {
+        currentStep++;
+        const spinner7 = createSpinner(`[${currentStep}/${totalSteps}] 📦 Initializing Git repository...`).start();
+        await this.sleep(600);
+        await this.initializeGit();
+        spinner7.success({ text: `📦 Git repository initialized` });
+      }
+
+      // Step 8: Install dependencies
+      if (this.config.install) {
+        currentStep++;
+        const spinner8 = createSpinner(`[${currentStep}/${totalSteps}] 📥 Installing dependencies...`).start();
+        await this.installDependencies();
+        spinner8.success({ text: `📥 Dependencies installed successfully` });
+      }
+
+    } catch (error) {
+      console.error(chalk.red('\n❌ Setup failed:'), error.message);
+      throw error;
+    }
+  }
+
+  async createDirectory() {
+    if (fs.existsSync(this.projectPath)) {
+      throw new Error(`Directory ${this.config.projectName} already exists`);
+    }
+    fs.mkdirSync(this.projectPath, { recursive: true });
+  }
+
+  async createProjectStructure() {
+    const directories = this.getDirectoriesForTemplate();
+    
+    for (const dir of directories) {
+      const fullPath = path.join(this.projectPath, dir);
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+  }
+
+  getDirectoriesForTemplate() {
+    const baseDirectories = [
+      'views',
+      'views/layouts',
+      'views/partials',
+      'views/components',
+      'routes',
+      'routes/api',
+      'public',
+      'public/css',
+      'public/js',
+      'public/images',
+      'config',
+      'middleware',
+      'plugins',
+      'data',
+      'utils'
+    ];
+
+    const templateDirectories = {
+      blog: ['content', 'content/posts', 'admin', 'uploads'],
+      admin: ['admin', 'admin/views', 'dashboard'],
+      ecommerce: ['shop', 'products', 'orders', 'cart'],
+      portfolio: ['portfolio', 'projects', 'gallery'],
+      pwa: ['pwa', 'sw', 'manifest', 'offline']
+    };
+
+    return [
+      ...baseDirectories,
+      ...(templateDirectories[this.config.template] || [])
+    ];
+  }
+
+  async generateTemplateFiles() {
+    const TemplateGenerator = require('./template-generator');
+    const generator = new TemplateGenerator(this.config);
+    const files = generator.generateFiles();
+
+    for (const [filePath, content] of Object.entries(files)) {
+      const fullPath = path.join(this.projectPath, filePath);
+      const dir = path.dirname(fullPath);
+      
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      fs.writeFileSync(fullPath, content, 'utf8');
+    }
+  }
+
+  async configureFeatures() {
+    const FeatureConfigurer = require('./feature-configurer');
+    const configurer = new FeatureConfigurer(this.config, this.projectPath);
+    await configurer.configure();
+  }
+
+  async setupAuthentication() {
+    if (this.config.auth.enabled) {
+      const AuthSetup = require('./auth-setup');
+      const authSetup = new AuthSetup(this.config, this.projectPath);
+      await authSetup.configure();
+    }
+  }
+
+  async setupDatabase() {
+    const DatabaseSetup = require('./database-setup');
+    const dbSetup = new DatabaseSetup(this.config, this.projectPath);
+    await dbSetup.configure();
+  }
+
+  async initializeGit() {
+    try {
+      execSync('git init', { cwd: this.projectPath, stdio: 'pipe' });
+      execSync('git add .', { cwd: this.projectPath, stdio: 'pipe' });
+      execSync('git commit -m "🎉 Initial commit - Created with Veko.js"', { 
+        cwd: this.projectPath, 
+        stdio: 'pipe' 
+      });
+    } catch (error) {
+      // Git initialization is optional
+      console.log(chalk.yellow('   ⚠ Git initialization failed (optional)'));
+    }
+  }
+
+  async installDependencies() {
+    try {
+      execSync('npm install', { 
+        cwd: this.projectPath, 
+        stdio: 'pipe'
+      });
+    } catch (error) {
+      throw new Error('Failed to install dependencies. Run "npm install" manually.');
+    }
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+module.exports = SetupExecutor;