@nclamvn/vibecode-cli 1.5.0 → 1.7.0

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/debug/image-analyzer.js

@@ -0,0 +1,304 @@
+/**
+ * Image Analyzer for Vibecode CLI
+ * Analyze screenshots of errors using AI vision
+ */
+
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn } from 'child_process';
+import { imageToBase64, saveClipboardImage, formatFileSize } from '../utils/image.js';
+
+/**
+ * ImageAnalyzer class for screenshot error analysis
+ */
+export class ImageAnalyzer {
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+  }
+
+  /**
+   * Analyze image file for errors
+   */
+  async analyzeImage(imagePath) {
+    console.log(chalk.cyan('\n  Analyzing screenshot...\n'));
+
+    try {
+      // Read and validate image
+      const imageInfo = await imageToBase64(imagePath);
+
+      console.log(chalk.gray(`  File: ${path.basename(imageInfo.path)}`));
+      console.log(chalk.gray(`  Size: ${formatFileSize(imageInfo.size)}\n`));
+
+      // Run AI analysis
+      const analysis = await this.runImageAnalysis(imageInfo);
+
+      return analysis;
+    } catch (error) {
+      throw new Error(`Failed to analyze image: ${error.message}`);
+    }
+  }
+
+  /**
+   * Analyze image from clipboard
+   */
+  async analyzeClipboard() {
+    console.log(chalk.cyan('\n  Getting image from clipboard...\n'));
+
+    try {
+      const tempFile = await saveClipboardImage();
+      console.log(chalk.green(`  Image captured\n`));
+
+      const result = await this.analyzeImage(tempFile);
+
+      // Cleanup temp file
+      try {
+        await fs.unlink(tempFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+
+      return result;
+    } catch (error) {
+      throw new Error(`Clipboard error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Run AI analysis on image
+   */
+  async runImageAnalysis(imageInfo) {
+    // Create analysis prompt
+    const prompt = this.buildAnalysisPrompt(imageInfo);
+
+    // Save prompt to temp file
+    const tempDir = path.join(this.projectPath, '.vibecode', 'debug');
+    await fs.mkdir(tempDir, { recursive: true });
+
+    const promptFile = path.join(tempDir, 'image-analysis.md');
+    await fs.writeFile(promptFile, prompt);
+
+    // Also save image reference
+    const imageRef = path.join(tempDir, 'screenshot-ref.txt');
+    await fs.writeFile(imageRef, imageInfo.path);
+
+    // Run Claude Code with image
+    const result = await this.runClaudeWithImage(imageInfo, promptFile);
+
+    return this.parseAnalysisResult(result);
+  }
+
+  /**
+   * Build analysis prompt
+   */
+  buildAnalysisPrompt(imageInfo) {
+    return `# Screenshot Error Analysis
+
+Analyze this screenshot and extract any error information.
+
+## Instructions
+1. Look for error messages, stack traces, console errors, or warnings
+2. Identify the error type (TypeError, SyntaxError, Build Error, etc.)
+3. Extract file names and line numbers if visible
+4. Note any relevant context visible in the screenshot
+5. Provide specific fix suggestions
+
+## Response Format
+Respond in this exact format:
+
+**Error Type**: [type of error or "None detected"]
+**Error Message**: [main error text]
+**Location**: [file:line if visible]
+**Root Cause**: [explanation of what's wrong]
+**Suggested Fix**: [how to fix it]
+**Confidence**: [High/Medium/Low]
+
+If no error is visible, respond with:
+**Error Type**: None detected
+**Error Message**: No error visible in screenshot
+`;
+  }
+
+  /**
+   * Run Claude Code with image input
+   */
+  async runClaudeWithImage(imageInfo, promptFile) {
+    return new Promise((resolve) => {
+      let output = '';
+      let errorOutput = '';
+
+      // Use claude with image path
+      // Claude Code can read images directly
+      const args = [
+        '--print',
+        '-p', `Analyze this image for errors: ${imageInfo.path}
+
+Look for:
+- Error messages
+- Stack traces
+- Console errors
+- Type errors
+- Build failures
+
+Respond with:
+**Error Type**:
+**Error Message**:
+**Location**:
+**Root Cause**:
+**Suggested Fix**:
+**Confidence**:
+
+If no error found, say "No error detected"`
+      ];
+
+      const child = spawn('claude', args, {
+        cwd: this.projectPath,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      child.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      child.on('close', (code) => {
+        resolve({
+          success: code === 0,
+          output: output.trim(),
+          error: errorOutput.trim()
+        });
+      });
+
+      child.on('error', (error) => {
+        resolve({
+          success: false,
+          output: '',
+          error: error.message
+        });
+      });
+
+      // Timeout after 60 seconds
+      setTimeout(() => {
+        child.kill();
+        resolve({
+          success: false,
+          output: '',
+          error: 'Analysis timed out'
+        });
+      }, 60000);
+    });
+  }
+
+  /**
+   * Parse AI analysis result
+   */
+  parseAnalysisResult(result) {
+    const analysis = {
+      errorType: null,
+      errorMessage: null,
+      location: null,
+      rootCause: null,
+      suggestedFix: null,
+      confidence: 'Low',
+      raw: result?.output || '',
+      success: result?.success || false
+    };
+
+    const output = result?.output || '';
+
+    // Extract fields using regex
+    const patterns = {
+      errorType: /\*\*Error Type\*\*:\s*(.+?)(?:\n|$)/i,
+      errorMessage: /\*\*Error Message\*\*:\s*(.+?)(?:\n|$)/i,
+      location: /\*\*Location\*\*:\s*(.+?)(?:\n|$)/i,
+      rootCause: /\*\*Root Cause\*\*:\s*(.+?)(?:\n|$)/i,
+      suggestedFix: /\*\*Suggested Fix\*\*:\s*(.+?)(?:\n|$)/i,
+      confidence: /\*\*Confidence\*\*:\s*(.+?)(?:\n|$)/i
+    };
+
+    for (const [key, pattern] of Object.entries(patterns)) {
+      const match = output.match(pattern);
+      if (match && match[1]) {
+        const value = match[1].trim();
+        if (value && value.toLowerCase() !== 'none' && value.toLowerCase() !== 'n/a') {
+          analysis[key] = value;
+        }
+      }
+    }
+
+    // Check if error was actually detected
+    if (analysis.errorType?.toLowerCase().includes('none detected') ||
+        analysis.errorMessage?.toLowerCase().includes('no error')) {
+      analysis.errorType = null;
+      analysis.errorMessage = null;
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Format analysis for display
+   */
+  formatAnalysis(analysis) {
+    // No error case
+    if (!analysis.errorType && !analysis.errorMessage) {
+      return chalk.yellow('\n  No error detected in screenshot.\n');
+    }
+
+    let output = chalk.cyan(`
++----------------------------------------------------------------------+
+|  SCREENSHOT ANALYSIS                                                 |
++----------------------------------------------------------------------+
+`);
+
+    if (analysis.errorType) {
+      output += `\n  ${chalk.white('Error Type:')} ${chalk.red(analysis.errorType)}`;
+    }
+
+    if (analysis.errorMessage) {
+      output += `\n  ${chalk.white('Message:')}    ${chalk.yellow(analysis.errorMessage)}`;
+    }
+
+    if (analysis.location) {
+      output += `\n  ${chalk.white('Location:')}   ${chalk.gray(analysis.location)}`;
+    }
+
+    if (analysis.confidence) {
+      const confColor = analysis.confidence === 'High' ? chalk.green :
+                        analysis.confidence === 'Medium' ? chalk.yellow : chalk.gray;
+      output += `\n  ${chalk.white('Confidence:')} ${confColor(analysis.confidence)}`;
+    }
+
+    if (analysis.rootCause) {
+      output += `\n\n  ${chalk.cyan('Root Cause:')}`;
+      output += `\n  ${chalk.gray(analysis.rootCause)}`;
+    }
+
+    if (analysis.suggestedFix) {
+      output += `\n\n  ${chalk.green('Suggested Fix:')}`;
+      output += `\n  ${chalk.white(analysis.suggestedFix)}`;
+    }
+
+    output += '\n';
+
+    return output;
+  }
+}
+
+/**
+ * Helper function for direct use
+ */
+export async function analyzeScreenshot(imagePathOrClipboard, options = {}) {
+  const analyzer = new ImageAnalyzer(options.projectPath || process.cwd());
+
+  if (imagePathOrClipboard === 'clipboard') {
+    return await analyzer.analyzeClipboard();
+  } else {
+    return await analyzer.analyzeImage(imagePathOrClipboard);
+  }
+}
+
+export default ImageAnalyzer;

package/src/debug/index.js

@@ -27,6 +27,9 @@ import { RootCauseAnalyzer } from './analyzer.js';
 import { FixGenerator } from './fixer.js';
 import { FixVerifier } from './verifier.js';
 import { spawnClaudeCode, isClaudeCodeAvailable } from '../providers/index.js';
+import { translateError, formatTranslatedError } from '../ui/error-translator.js';
+import { getLearningEngine } from '../core/learning.js';
+import { askFeedback, showLearningSuggestion } from '../commands/learn.js';
 
 const execAsync = promisify(exec);
 
@@ -103,6 +106,9 @@ export class DebugEngine {
         return this.createResult('no_hypothesis', 'Could not generate fix hypotheses');
       }
 
+      // Check for learning-based suggestions
+      await showLearningSuggestion(evidence.type, evidence.category);
+
       // Step 5-7: TEST, FIX, VERIFY - Attempt fixes
       let fixResult = null;
       for (let attempt = 0; attempt < this.options.maxAttempts && !this.session.resolved; attempt++) {
@@ -145,6 +151,16 @@ export class DebugEngine {
           await this.fixer.updateClaudeMd(fixAttempt);
 
           console.log(chalk.green.bold('\n✅ Bug fixed and documented!\n'));
+
+          // Ask for feedback to improve future suggestions
+          if (this.options.interactive) {
+            await askFeedback({
+              errorType: evidence.type,
+              errorMessage: evidence.message,
+              errorCategory: evidence.category,
+              fixApplied: fixAttempt.description || hypothesis.description
+            });
+          }
         } else {
           console.log(chalk.yellow('  ⚠ Verification failed, trying next approach...'));
         }
@@ -275,9 +291,22 @@ export class DebugEngine {
   logEvidence(evidence) {
     console.log(chalk.gray(`  Type: ${evidence.type || 'Unknown'}`));
     console.log(chalk.gray(`  Category: ${evidence.category}`));
+
     if (evidence.message) {
-      console.log(chalk.gray(`  Message: ${evidence.message.substring(0, 100)}${evidence.message.length > 100 ? '...' : ''}`));
+      // Translate error for human-friendly display
+      const translated = translateError(evidence.message);
+      console.log(chalk.yellow(`  Error: ${translated.title}`));
+      console.log(chalk.gray(`  → ${translated.description.substring(0, 80)}${translated.description.length > 80 ? '...' : ''}`));
+
+      // Show suggestions
+      if (translated.suggestions && translated.suggestions.length > 0) {
+        console.log(chalk.gray(`  Suggestions:`));
+        for (const s of translated.suggestions.slice(0, 2)) {
+          console.log(chalk.gray(`    • ${s}`));
+        }
+      }
     }
+
     if (evidence.files.length > 0) {
       console.log(chalk.gray(`  Files: ${evidence.files.slice(0, 3).join(', ')}${evidence.files.length > 3 ? '...' : ''}`));
     }