@nclamvn/vibecode-cli 2.0.0 → 2.2.0

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);
+}

package/src/core/error-analyzer.js

@@ -0,0 +1,237 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Error Analyzer
+// Intelligent error analysis for iterative builds
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Analyze test results and extract actionable errors
+ * @param {TestResults} testResult - Results from test runner
+ * @returns {AnalyzedError[]}
+ */
+export function analyzeErrors(testResult) {
+  const errors = [];
+
+  for (const test of testResult.tests) {
+    if (!test.passed) {
+      const testErrors = test.errors || [];
+
+      for (const error of testErrors) {
+        errors.push({
+          source: test.name,
+          type: categorizeError(error),
+          file: error.file || null,
+          line: error.line || null,
+          column: error.column || null,
+          message: error.message,
+          suggestion: generateSuggestion(error),
+          priority: calculatePriority(error),
+          raw: error.raw
+        });
+      }
+
+      // If no specific errors but test failed, add generic error
+      if (testErrors.length === 0) {
+        errors.push({
+          source: test.name,
+          type: 'unknown',
+          message: test.error || `${test.name} failed`,
+          suggestion: `Check ${test.name} output for details`,
+          priority: 'medium',
+          raw: test.output
+        });
+      }
+    }
+  }
+
+  // Sort by priority
+  return errors.sort((a, b) => {
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    return (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2);
+  });
+}
+
+/**
+ * Categorize error type
+ */
+function categorizeError(error) {
+  const message = (error.message || '').toLowerCase();
+  const raw = (error.raw || '').toLowerCase();
+  const combined = message + ' ' + raw;
+
+  if (combined.includes('syntaxerror') || combined.includes('unexpected token')) {
+    return 'syntax';
+  }
+  if (combined.includes('typeerror') || combined.includes('type error') || combined.includes('is not a function')) {
+    return 'type';
+  }
+  if (combined.includes('referenceerror') || combined.includes('is not defined')) {
+    return 'reference';
+  }
+  if (combined.includes('import') || combined.includes('require') || combined.includes('module not found')) {
+    return 'import';
+  }
+  if (combined.includes('eslint') || combined.includes('lint')) {
+    return 'lint';
+  }
+  if (combined.includes('test') || combined.includes('expect') || combined.includes('assert')) {
+    return 'test';
+  }
+  if (combined.includes('typescript') || combined.includes('ts(')) {
+    return 'typescript';
+  }
+  if (combined.includes('build') || combined.includes('compile')) {
+    return 'build';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Generate fix suggestion based on error type
+ */
+function generateSuggestion(error) {
+  const type = categorizeError(error);
+  const message = error.message || '';
+
+  switch (type) {
+    case 'syntax':
+      return 'Check for missing brackets, semicolons, or typos near the error location';
+
+    case 'type':
+      if (message.includes('undefined')) {
+        return 'Check if the variable/property is properly initialized';
+      }
+      if (message.includes('is not a function')) {
+        return 'Verify the function exists and is properly imported';
+      }
+      return 'Check type compatibility and ensure proper type handling';
+
+    case 'reference':
+      return 'Ensure the variable/function is defined or imported before use';
+
+    case 'import':
+      if (message.includes('module not found')) {
+        return 'Install missing package with npm install or fix import path';
+      }
+      return 'Check import path and ensure the module exports correctly';
+
+    case 'lint':
+      return 'Fix the linting issue as specified in the error message';
+
+    case 'test':
+      return 'Update the implementation to match expected behavior, or fix the test assertion';
+
+    case 'typescript':
+      return 'Fix type errors by adding proper types or type guards';
+
+    case 'build':
+      return 'Check build configuration and dependencies';
+
+    default:
+      return 'Review the error message and fix accordingly';
+  }
+}
+
+/**
+ * Calculate error priority
+ */
+function calculatePriority(error) {
+  const type = categorizeError(error);
+
+  // Critical - blocks everything
+  if (type === 'syntax' || type === 'import') {
+    return 'critical';
+  }
+
+  // High - likely causes cascading failures
+  if (type === 'reference' || type === 'type') {
+    return 'high';
+  }
+
+  // Medium - should be fixed
+  if (type === 'typescript' || type === 'build' || type === 'test') {
+    return 'medium';
+  }
+
+  // Low - nice to fix
+  if (type === 'lint') {
+    return 'low';
+  }
+
+  return 'medium';
+}
+
+/**
+ * Group errors by file for better organization
+ */
+export function groupErrorsByFile(errors) {
+  const grouped = {};
+
+  for (const error of errors) {
+    const file = error.file || 'unknown';
+    if (!grouped[file]) {
+      grouped[file] = [];
+    }
+    grouped[file].push(error);
+  }
+
+  return grouped;
+}
+
+/**
+ * Get unique files with errors
+ */
+export function getAffectedFiles(errors) {
+  const files = new Set();
+  for (const error of errors) {
+    if (error.file) {
+      files.add(error.file);
+    }
+  }
+  return Array.from(files);
+}
+
+/**
+ * Format errors for display
+ */
+export function formatErrors(errors) {
+  const lines = [];
+
+  lines.push(`Found ${errors.length} error(s):`);
+  lines.push('');
+
+  const grouped = groupErrorsByFile(errors);
+
+  for (const [file, fileErrors] of Object.entries(grouped)) {
+    lines.push(`📄 ${file}`);
+    for (const error of fileErrors) {
+      const loc = error.line ? `:${error.line}` : '';
+      const priority = error.priority === 'critical' ? '🔴' :
+                       error.priority === 'high' ? '🟠' :
+                       error.priority === 'medium' ? '🟡' : '🟢';
+      lines.push(`   ${priority} ${error.type}: ${error.message?.substring(0, 60) || 'Unknown error'}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Create a summary of errors for logging
+ */
+export function createErrorSummary(errors) {
+  const byType = {};
+  const byPriority = { critical: 0, high: 0, medium: 0, low: 0 };
+
+  for (const error of errors) {
+    byType[error.type] = (byType[error.type] || 0) + 1;
+    byPriority[error.priority] = (byPriority[error.priority] || 0) + 1;
+  }
+
+  return {
+    total: errors.length,
+    byType,
+    byPriority,
+    files: getAffectedFiles(errors)
+  };
+}