@nclamvn/vibecode-cli 1.3.0 → 1.6.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/learning.js

@@ -0,0 +1,295 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Learning Engine
+// Phase H5: AI learns from user feedback
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+const LEARNING_DIR = '.vibecode/learning';
+const GLOBAL_LEARNING_DIR = path.join(os.homedir(), '.vibecode/learning');
+
+/**
+ * Learning Engine - Records and retrieves learning data
+ *
+ * Features:
+ * - Records fix attempts and outcomes
+ * - Stores user preferences
+ * - Provides suggestions based on past successes
+ * - Anonymizes data for global storage
+ */
+export class LearningEngine {
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+    this.localPath = path.join(projectPath, LEARNING_DIR);
+    this.globalPath = GLOBAL_LEARNING_DIR;
+  }
+
+  /**
+   * Initialize learning directories
+   */
+  async init() {
+    await fs.mkdir(this.localPath, { recursive: true });
+    await fs.mkdir(this.globalPath, { recursive: true });
+  }
+
+  /**
+   * Record a fix attempt and its outcome
+   */
+  async recordFix(fixData) {
+    await this.init();
+
+    const record = {
+      id: Date.now().toString(36),
+      timestamp: new Date().toISOString(),
+      errorType: fixData.errorType,
+      errorMessage: fixData.errorMessage?.substring(0, 200),
+      errorCategory: fixData.errorCategory,
+      fixApplied: fixData.fixApplied?.substring(0, 500),
+      success: fixData.success,
+      userFeedback: fixData.userFeedback,
+      userCorrection: fixData.userCorrection,
+      projectType: await this.detectProjectType(),
+      tags: fixData.tags || []
+    };
+
+    // Save to local project
+    const localFile = path.join(this.localPath, 'fixes.json');
+    const localFixes = await this.loadJson(localFile, []);
+    localFixes.push(record);
+    await this.saveJson(localFile, localFixes.slice(-100)); // Keep last 100
+
+    // Save to global (anonymized)
+    const globalFile = path.join(this.globalPath, 'fixes.json');
+    const globalFixes = await this.loadJson(globalFile, []);
+    globalFixes.push({
+      ...record,
+      errorMessage: this.anonymize(record.errorMessage),
+      fixApplied: this.anonymize(record.fixApplied)
+    });
+    await this.saveJson(globalFile, globalFixes.slice(-500)); // Keep last 500
+
+    return record.id;
+  }
+
+  /**
+   * Record user preference
+   */
+  async recordPreference(key, value, context = {}) {
+    await this.init();
+
+    const prefsFile = path.join(this.localPath, 'preferences.json');
+    const prefs = await this.loadJson(prefsFile, {});
+
+    if (!prefs[key]) {
+      prefs[key] = { values: [], contexts: [] };
+    }
+
+    prefs[key].values.push(value);
+    prefs[key].contexts.push(context);
+    prefs[key].lastUsed = new Date().toISOString();
+
+    // Keep only recent values
+    prefs[key].values = prefs[key].values.slice(-20);
+    prefs[key].contexts = prefs[key].contexts.slice(-20);
+
+    await this.saveJson(prefsFile, prefs);
+  }
+
+  /**
+   * Get suggestion based on learnings
+   */
+  async getSuggestion(errorType, errorCategory) {
+    const localFixes = await this.loadJson(
+      path.join(this.localPath, 'fixes.json'),
+      []
+    );
+    const globalFixes = await this.loadJson(
+      path.join(this.globalPath, 'fixes.json'),
+      []
+    );
+
+    // Find similar successful fixes
+    const allFixes = [...localFixes, ...globalFixes];
+    const similarFixes = allFixes.filter(f =>
+      f.success &&
+      (f.errorType === errorType || f.errorCategory === errorCategory)
+    );
+
+    if (similarFixes.length === 0) {
+      return null;
+    }
+
+    // Calculate confidence based on success rate
+    const totalSimilar = allFixes.filter(f =>
+      f.errorType === errorType || f.errorCategory === errorCategory
+    ).length;
+
+    const successRate = similarFixes.length / totalSimilar;
+
+    // Get most recent successful fix
+    const recentFix = similarFixes.sort((a, b) =>
+      new Date(b.timestamp) - new Date(a.timestamp)
+    )[0];
+
+    return {
+      suggestion: recentFix.fixApplied,
+      confidence: successRate,
+      basedOn: similarFixes.length,
+      lastUsed: recentFix.timestamp
+    };
+  }
+
+  /**
+   * Get user preference
+   */
+  async getPreference(key, defaultValue = null) {
+    const prefsFile = path.join(this.localPath, 'preferences.json');
+    const prefs = await this.loadJson(prefsFile, {});
+
+    if (!prefs[key] || prefs[key].values.length === 0) {
+      return defaultValue;
+    }
+
+    // Return most common value
+    const counts = {};
+    for (const v of prefs[key].values) {
+      counts[v] = (counts[v] || 0) + 1;
+    }
+
+    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    return sorted[0][0];
+  }
+
+  /**
+   * Get learning statistics
+   */
+  async getStats() {
+    const localFixes = await this.loadJson(
+      path.join(this.localPath, 'fixes.json'),
+      []
+    );
+    const globalFixes = await this.loadJson(
+      path.join(this.globalPath, 'fixes.json'),
+      []
+    );
+    const prefs = await this.loadJson(
+      path.join(this.localPath, 'preferences.json'),
+      {}
+    );
+
+    const localSuccess = localFixes.filter(f => f.success).length;
+    const globalSuccess = globalFixes.filter(f => f.success).length;
+
+    // Group by error category
+    const byCategory = {};
+    for (const fix of localFixes) {
+      const cat = fix.errorCategory || 'unknown';
+      if (!byCategory[cat]) {
+        byCategory[cat] = { total: 0, success: 0 };
+      }
+      byCategory[cat].total++;
+      if (fix.success) byCategory[cat].success++;
+    }
+
+    return {
+      local: {
+        total: localFixes.length,
+        success: localSuccess,
+        rate: localFixes.length > 0 ? (localSuccess / localFixes.length * 100).toFixed(1) : '0'
+      },
+      global: {
+        total: globalFixes.length,
+        success: globalSuccess,
+        rate: globalFixes.length > 0 ? (globalSuccess / globalFixes.length * 100).toFixed(1) : '0'
+      },
+      byCategory,
+      preferences: Object.keys(prefs).length,
+      lastLearning: localFixes[localFixes.length - 1]?.timestamp || null
+    };
+  }
+
+  /**
+   * Detect project type
+   */
+  async detectProjectType() {
+    try {
+      const pkgPath = path.join(this.projectPath, 'package.json');
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+
+      if (pkg.dependencies?.next) return 'nextjs';
+      if (pkg.dependencies?.react) return 'react';
+      if (pkg.dependencies?.vue) return 'vue';
+      if (pkg.dependencies?.express) return 'express';
+      if (pkg.dependencies?.['@prisma/client']) return 'prisma';
+
+      return 'node';
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Anonymize sensitive data for global storage
+   */
+  anonymize(text) {
+    if (!text) return text;
+    return text
+      .replace(/\/Users\/[^\/\s]+/g, '/Users/***')
+      .replace(/\/home\/[^\/\s]+/g, '/home/***')
+      .replace(/C:\\Users\\[^\\]+/g, 'C:\\Users\\***')
+      .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '***@***.***')
+      .replace(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, '***.***.***.***')
+      .replace(/api[_-]?key[=:]\s*["']?[\w-]+["']?/gi, 'api_key=***')
+      .replace(/token[=:]\s*["']?[\w-]+["']?/gi, 'token=***')
+      .replace(/password[=:]\s*["']?[^"'\s]+["']?/gi, 'password=***');
+  }
+
+  /**
+   * Clear all local learnings
+   */
+  async clearLocal() {
+    await this.saveJson(path.join(this.localPath, 'fixes.json'), []);
+    await this.saveJson(path.join(this.localPath, 'preferences.json'), {});
+  }
+
+  /**
+   * Load JSON file
+   */
+  async loadJson(filePath, defaultValue) {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Save JSON file
+   */
+  async saveJson(filePath, data) {
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2));
+  }
+}
+
+// Singleton instance
+let learningEngine = null;
+
+/**
+ * Get or create LearningEngine instance
+ */
+export function getLearningEngine(projectPath = process.cwd()) {
+  if (!learningEngine || learningEngine.projectPath !== projectPath) {
+    learningEngine = new LearningEngine(projectPath);
+  }
+  return learningEngine;
+}
+
+/**
+ * Create a new LearningEngine instance
+ */
+export function createLearningEngine(projectPath = process.cwd()) {
+  return new LearningEngine(projectPath);
+}

package/src/core/test-runner.js

@@ -43,9 +43,10 @@ export async function runTests(projectPath) {
       results.tests.push(npmTest);
     }
 
-    // 3. Run npm run lint (if script exists)
+    // 3. Run npm run lint (if script exists) - soft fail (warnings only)
     if (pkg.scripts?.lint) {
       const npmLint = await runCommand('npm run lint', projectPath, 'npm lint');
+      npmLint.softFail = true; // Lint errors are warnings, don't block build
       results.tests.push(npmLint);
     }
 
@@ -70,11 +71,21 @@ export async function runTests(projectPath) {
   }
 
   // 7. Aggregate results
+  // Separate hard tests from soft-fail tests (like lint)
+  const hardTests = results.tests.filter(t => !t.softFail);
+  const softTests = results.tests.filter(t => t.softFail);
+
   results.summary.total = results.tests.length;
   results.summary.passed = results.tests.filter(t => t.passed).length;
   results.summary.failed = results.tests.filter(t => !t.passed).length;
-  results.passed = results.tests.length === 0 || results.tests.every(t => t.passed);
-  results.errors = results.tests.filter(t => !t.passed).flatMap(t => t.errors || []);
+  results.summary.warnings = softTests.filter(t => !t.passed).length;
+
+  // Only hard tests determine pass/fail
+  results.passed = hardTests.length === 0 || hardTests.every(t => t.passed);
+
+  // Collect errors, but mark soft-fail errors as warnings
+  results.errors = results.tests.filter(t => !t.passed && !t.softFail).flatMap(t => t.errors || []);
+  results.warnings = softTests.filter(t => !t.passed).flatMap(t => t.errors || []);
   results.duration = Date.now() - startTime;
 
   return results;
@@ -230,12 +241,17 @@ export function formatTestResults(results) {
   const lines = [];
 
   lines.push(`Tests: ${results.summary.passed}/${results.summary.total} passed`);
+  if (results.summary.warnings > 0) {
+    lines.push(`Warnings: ${results.summary.warnings} (lint)`);
+  }
   lines.push(`Duration: ${(results.duration / 1000).toFixed(1)}s`);
 
-  if (!results.passed) {
+  // Show hard failures
+  const hardFailures = results.tests.filter(t => !t.passed && !t.softFail);
+  if (hardFailures.length > 0) {
     lines.push('');
     lines.push('Failed tests:');
-    for (const test of results.tests.filter(t => !t.passed)) {
+    for (const test of hardFailures) {
       lines.push(`  ❌ ${test.name}`);
       for (const error of test.errors || []) {
         const loc = error.file ? `${error.file}:${error.line || '?'}` : '';
@@ -244,5 +260,22 @@ export function formatTestResults(results) {
     }
   }
 
+  // Show soft failures (warnings)
+  const softFailures = results.tests.filter(t => !t.passed && t.softFail);
+  if (softFailures.length > 0) {
+    lines.push('');
+    lines.push('Warnings (non-blocking):');
+    for (const test of softFailures) {
+      lines.push(`  ⚠️  ${test.name}`);
+      for (const error of (test.errors || []).slice(0, 3)) {
+        const loc = error.file ? `${error.file}:${error.line || '?'}` : '';
+        lines.push(`     ${loc} ${error.message?.substring(0, 80) || ''}`);
+      }
+      if ((test.errors?.length || 0) > 3) {
+        lines.push(`     ... and ${test.errors.length - 3} more`);
+      }
+    }
+  }
+
   return lines.join('\n');
 }