@nclamvn/vibecode-cli 1.5.0 → 1.7.0

package/src/commands/wizard.js

@@ -0,0 +1,322 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Interactive Wizard
+// Phase H1: Smart Defaults - No args = Interactive menu
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { VERSION } from '../config/constants.js';
+
+/**
+ * Wizard Command - Interactive menu when no args provided
+ *
+ * Usage:
+ *   vibecode  (no args) → Shows interactive menu
+ */
+export async function wizardCommand() {
+  // Show welcome banner
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│                                                                    │
+│   🏗️  VIBECODE v${VERSION.padEnd(43)}│
+│   Build Software with Discipline                                   │
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Bạn muốn làm gì hôm nay?',
+      choices: [
+        { name: '🚀 Tạo project mới nhanh', value: 'go' },
+        { name: '🤖 Build project phức tạp (nhiều modules)', value: 'agent' },
+        { name: '🔍 Debug/fix lỗi', value: 'debug' },
+        { name: '🤝 Trợ giúp từ AI', value: 'assist' },
+        new inquirer.Separator(),
+        { name: '📊 Xem trạng thái project hiện tại', value: 'status' },
+        { name: '⚙️  Cài đặt', value: 'config' },
+        { name: '📁 Khởi tạo workspace mới', value: 'init' },
+        new inquirer.Separator(),
+        { name: '❓ Xem trợ giúp', value: 'help' },
+        { name: '👋 Thoát', value: 'exit' }
+      ]
+    }
+  ]);
+
+  switch (action) {
+    case 'go':
+      await handleGo();
+      break;
+    case 'agent':
+      await handleAgent();
+      break;
+    case 'debug':
+      await handleDebug();
+      break;
+    case 'assist':
+      await handleAssist();
+      break;
+    case 'status':
+      await handleStatus();
+      break;
+    case 'config':
+      await handleConfig();
+      break;
+    case 'init':
+      await handleInit();
+      break;
+    case 'help':
+      showHelp();
+      break;
+    case 'exit':
+      console.log(chalk.cyan('\n👋 Hẹn gặp lại!\n'));
+      process.exit(0);
+  }
+}
+
+/**
+ * Handle Go command with prompts
+ */
+async function handleGo() {
+  const { goCommand } = await import('./go.js');
+
+  const { description } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Mô tả project bạn muốn tạo:',
+      validate: (input) => input.length > 5 || 'Vui lòng mô tả chi tiết hơn (ít nhất 6 ký tự)'
+    }
+  ]);
+
+  const { template } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'template',
+      message: 'Chọn template (hoặc để trống):',
+      choices: [
+        { name: '🎨 Không dùng template (tự do)', value: null },
+        { name: '🌐 Landing page', value: 'landing' },
+        { name: '💼 SaaS application', value: 'saas' },
+        { name: '⌨️  CLI tool', value: 'cli' },
+        { name: '🔌 REST API', value: 'api' }
+      ]
+    }
+  ]);
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `Tạo project: "${description}"${template ? ` (template: ${template})` : ''}?`,
+      default: true
+    }
+  ]);
+
+  if (confirm) {
+    const options = {};
+    if (template) options.template = template;
+    await goCommand(description, options);
+  } else {
+    console.log(chalk.gray('\n✗ Đã huỷ.\n'));
+  }
+}
+
+/**
+ * Handle Agent command with prompts
+ */
+async function handleAgent() {
+  const { agentCommand } = await import('./agent.js');
+
+  const { description } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Mô tả project phức tạp (VD: SaaS với auth, billing, dashboard):',
+      validate: (input) => input.length > 10 || 'Vui lòng mô tả chi tiết hơn (ít nhất 11 ký tự)'
+    }
+  ]);
+
+  const { createNew } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'createNew',
+      message: 'Tạo thư mục project mới?',
+      default: true
+    }
+  ]);
+
+  const { verbose } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'verbose',
+      message: 'Hiển thị chi tiết quá trình build?',
+      default: false
+    }
+  ]);
+
+  console.log(chalk.blue('\n🤖 Bắt đầu Agent Mode...\n'));
+  await agentCommand(description, { new: createNew, verbose });
+}
+
+/**
+ * Handle Debug command
+ */
+async function handleDebug() {
+  const { debugCommand } = await import('./debug.js');
+
+  const { mode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'mode',
+      message: 'Chọn chế độ debug:',
+      choices: [
+        { name: '🔄 Interactive - Debug trực tiếp', value: 'interactive' },
+        { name: '🔍 Auto-scan - Tự động tìm và fix lỗi', value: 'auto' },
+        { name: '📝 Mô tả lỗi', value: 'describe' }
+      ]
+    }
+  ]);
+
+  if (mode === 'interactive') {
+    await debugCommand([], { interactive: true });
+  } else if (mode === 'auto') {
+    await debugCommand([], { auto: true });
+  } else {
+    const { description } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'description',
+        message: 'Mô tả lỗi bạn gặp phải:',
+        validate: (input) => input.length > 5 || 'Vui lòng mô tả chi tiết hơn'
+      }
+    ]);
+    await debugCommand([description], {});
+  }
+}
+
+/**
+ * Handle Assist command
+ */
+async function handleAssist() {
+  const { assistCommand } = await import('./assist.js');
+
+  const { hasPrompt } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'hasPrompt',
+      message: 'Bạn có câu hỏi cụ thể không?',
+      default: false
+    }
+  ]);
+
+  if (hasPrompt) {
+    const { prompt } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'prompt',
+        message: 'Nhập câu hỏi của bạn:',
+        validate: (input) => input.length > 3 || 'Vui lòng nhập câu hỏi'
+      }
+    ]);
+    await assistCommand([prompt], {});
+  } else {
+    await assistCommand([], {});
+  }
+}
+
+/**
+ * Handle Status command
+ */
+async function handleStatus() {
+  const { statusCommand } = await import('./status.js');
+  await statusCommand({});
+}
+
+/**
+ * Handle Config command
+ */
+async function handleConfig() {
+  const { configCommand } = await import('./config.js');
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Cài đặt:',
+      choices: [
+        { name: '👀 Xem cài đặt hiện tại', value: 'show' },
+        { name: '🔧 Thay đổi provider', value: 'provider' }
+      ]
+    }
+  ]);
+
+  if (action === 'show') {
+    await configCommand({ show: true });
+  } else {
+    const { provider } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'provider',
+        message: 'Chọn AI provider:',
+        choices: [
+          { name: 'Claude Code (mặc định)', value: 'claude-code' }
+        ]
+      }
+    ]);
+    await configCommand({ provider });
+  }
+}
+
+/**
+ * Handle Init command
+ */
+async function handleInit() {
+  const { initCommand } = await import('./init.js');
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `Khởi tạo Vibecode workspace tại ${process.cwd()}?`,
+      default: true
+    }
+  ]);
+
+  if (confirm) {
+    await initCommand({});
+  }
+}
+
+/**
+ * Show help text
+ */
+function showHelp() {
+  console.log(chalk.white(`
+📚 VIBECODE COMMANDS
+
+  ${chalk.cyan('Workflow cơ bản:')}
+    vibecode init          Khởi tạo workspace
+    vibecode start         Bắt đầu intake → blueprint → contract
+    vibecode lock          Khoá contract
+    vibecode plan          Tạo execution plan
+    vibecode build         Build với AI
+    vibecode review        Kiểm tra kết quả
+    vibecode snapshot      Tạo release
+
+  ${chalk.cyan('Power commands:')}
+    vibecode go "..."      Một lệnh, tạo cả project
+    vibecode agent "..."   Build project phức tạp tự động
+    vibecode debug         Debug thông minh 9 bước
+    vibecode assist        Trợ giúp trực tiếp từ AI
+
+  ${chalk.cyan('Khác:')}
+    vibecode status        Xem trạng thái
+    vibecode config        Cài đặt
+    vibecode doctor        Kiểm tra health
+
+📖 Chi tiết: ${chalk.yellow('vibecode <command> --help')}
+  `));
+}

package/src/core/backup.js

@@ -0,0 +1,325 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Backup Manager
+// Phase H4: Undo/Rollback - Auto-backup before every action
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import fs from 'fs-extra';
+import path from 'path';
+import { createHash } from 'crypto';
+
+const BACKUP_DIR = '.vibecode/backups';
+const MAX_BACKUPS = 10;
+
+/**
+ * BackupManager - Creates and manages backups for undo functionality
+ *
+ * Usage:
+ *   const backup = new BackupManager();
+ *   const id = await backup.createBackup('build');
+ *   // ... do stuff ...
+ *   await backup.restore(id);  // Undo!
+ */
+export class BackupManager {
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+    this.backupPath = path.join(projectPath, BACKUP_DIR);
+  }
+
+  /**
+   * Initialize backup directory
+   */
+  async init() {
+    await fs.ensureDir(this.backupPath);
+  }
+
+  /**
+   * Create backup before action
+   * @param {string} actionName - Name of action (build, agent, go, etc.)
+   * @param {string[]} files - Specific files to backup (optional)
+   * @returns {string} Backup ID
+   */
+  async createBackup(actionName, files = null) {
+    await this.init();
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupId = `${timestamp}_${actionName}`;
+    const backupDir = path.join(this.backupPath, backupId);
+
+    await fs.ensureDir(backupDir);
+
+    // If specific files provided, backup only those
+    // Otherwise, backup common source files
+    const filesToBackup = files || await this.getSourceFiles();
+
+    const manifest = {
+      id: backupId,
+      action: actionName,
+      timestamp: new Date().toISOString(),
+      files: []
+    };
+
+    for (const file of filesToBackup) {
+      try {
+        const sourcePath = path.join(this.projectPath, file);
+        const stats = await fs.stat(sourcePath).catch(() => null);
+
+        if (stats && stats.isFile()) {
+          const content = await fs.readFile(sourcePath);
+          const hash = createHash('md5').update(content).digest('hex');
+
+          // Replace slashes with __ for flat storage
+          const backupFileName = file.replace(/[/\\]/g, '__');
+          const backupFilePath = path.join(backupDir, backupFileName);
+
+          await fs.writeFile(backupFilePath, content);
+
+          manifest.files.push({
+            path: file,
+            hash,
+            size: stats.size,
+            backupName: backupFileName
+          });
+        }
+      } catch (error) {
+        // Skip files that can't be backed up
+      }
+    }
+
+    // Save manifest
+    await fs.writeFile(
+      path.join(backupDir, 'manifest.json'),
+      JSON.stringify(manifest, null, 2)
+    );
+
+    // Cleanup old backups
+    await this.cleanupOldBackups();
+
+    return backupId;
+  }
+
+  /**
+   * Get list of source files to backup
+   * @returns {string[]} File paths relative to project
+   */
+  async getSourceFiles() {
+    const files = [];
+    const ignoreDirs = [
+      'node_modules', '.git', '.next', 'dist', 'build',
+      '.vibecode/backups', 'coverage', '.cache', '__pycache__'
+    ];
+    const extensions = [
+      '.js', '.ts', '.tsx', '.jsx', '.json', '.css', '.scss',
+      '.html', '.md', '.vue', '.svelte', '.prisma', '.env'
+    ];
+
+    const scan = async (dir, prefix = '') => {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+          if (entry.isDirectory()) {
+            if (!ignoreDirs.includes(entry.name) && !entry.name.startsWith('.')) {
+              await scan(fullPath, relativePath);
+            }
+          } else if (entry.isFile()) {
+            const ext = path.extname(entry.name);
+            if (extensions.includes(ext)) {
+              files.push(relativePath);
+            }
+          }
+        }
+      } catch (error) {
+        // Skip directories that can't be read
+      }
+    };
+
+    await scan(this.projectPath);
+    return files.slice(0, 100); // Limit to 100 files
+  }
+
+  /**
+   * List available backups
+   * @returns {Object[]} Array of backup manifests
+   */
+  async listBackups() {
+    await this.init();
+
+    try {
+      const entries = await fs.readdir(this.backupPath, { withFileTypes: true });
+      const backups = [];
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const manifestPath = path.join(this.backupPath, entry.name, 'manifest.json');
+          try {
+            const manifest = await fs.readJson(manifestPath);
+            backups.push(manifest);
+          } catch {
+            // Skip invalid backups
+          }
+        }
+      }
+
+      // Sort by timestamp, newest first
+      return backups.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Restore from backup
+   * @param {string} backupId - Backup ID to restore
+   * @returns {Object} Restore result
+   */
+  async restore(backupId) {
+    const backupDir = path.join(this.backupPath, backupId);
+    const manifestPath = path.join(backupDir, 'manifest.json');
+
+    try {
+      const manifest = await fs.readJson(manifestPath);
+      const restored = [];
+
+      for (const file of manifest.files) {
+        const backupFilePath = path.join(backupDir, file.backupName);
+        const targetPath = path.join(this.projectPath, file.path);
+
+        // Ensure directory exists
+        await fs.ensureDir(path.dirname(targetPath));
+
+        // Restore file
+        const content = await fs.readFile(backupFilePath);
+        await fs.writeFile(targetPath, content);
+
+        restored.push(file.path);
+      }
+
+      return {
+        success: true,
+        backupId,
+        action: manifest.action,
+        timestamp: manifest.timestamp,
+        filesRestored: restored.length,
+        files: restored
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Restore to N steps ago
+   * @param {number} steps - Number of steps back
+   * @returns {Object} Restore result
+   */
+  async restoreSteps(steps = 1) {
+    const backups = await this.listBackups();
+
+    if (steps > backups.length) {
+      return {
+        success: false,
+        error: `Only ${backups.length} backups available`
+      };
+    }
+
+    const backup = backups[steps - 1];
+    return await this.restore(backup.id);
+  }
+
+  /**
+   * Get the most recent backup
+   * @returns {Object|null} Latest backup manifest or null
+   */
+  async getLatestBackup() {
+    const backups = await this.listBackups();
+    return backups.length > 0 ? backups[0] : null;
+  }
+
+  /**
+   * Cleanup old backups to maintain MAX_BACKUPS limit
+   */
+  async cleanupOldBackups() {
+    const backups = await this.listBackups();
+
+    if (backups.length > MAX_BACKUPS) {
+      const toDelete = backups.slice(MAX_BACKUPS);
+
+      for (const backup of toDelete) {
+        const backupDir = path.join(this.backupPath, backup.id);
+        await fs.remove(backupDir);
+      }
+    }
+  }
+
+  /**
+   * Delete specific backup
+   * @param {string} backupId - Backup ID to delete
+   */
+  async deleteBackup(backupId) {
+    const backupDir = path.join(this.backupPath, backupId);
+    await fs.remove(backupDir);
+  }
+
+  /**
+   * Clear all backups
+   */
+  async clearAllBackups() {
+    await fs.remove(this.backupPath);
+    await this.init();
+  }
+
+  /**
+   * Get backup size in bytes
+   * @param {string} backupId - Backup ID
+   * @returns {number} Size in bytes
+   */
+  async getBackupSize(backupId) {
+    const backupDir = path.join(this.backupPath, backupId);
+    let totalSize = 0;
+
+    try {
+      const files = await fs.readdir(backupDir);
+      for (const file of files) {
+        const stats = await fs.stat(path.join(backupDir, file));
+        totalSize += stats.size;
+      }
+    } catch {
+      // Ignore errors
+    }
+
+    return totalSize;
+  }
+}
+
+/**
+ * Helper to wrap action with auto-backup
+ * @param {string} actionName - Name of action
+ * @param {Function} fn - Async function to execute
+ * @returns {*} Result of fn()
+ */
+export async function withBackup(actionName, fn) {
+  const backup = new BackupManager();
+  const backupId = await backup.createBackup(actionName);
+
+  try {
+    return await fn();
+  } catch (error) {
+    // Error occurred - backup is available for restore
+    console.log(`\n💾 Backup created: ${backupId}`);
+    console.log(`   Run 'vibecode undo' to restore previous state.\n`);
+    throw error;
+  }
+}
+
+/**
+ * Create backup manager instance
+ */
+export function createBackupManager(projectPath) {
+  return new BackupManager(projectPath);
+}