@nclamvn/vibecode-cli 2.0.0 → 2.2.0

package/src/core/fix-generator.js

@@ -0,0 +1,195 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Fix Generator
+// Generate fix prompts for iterative builds
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { formatErrors, createErrorSummary } from './error-analyzer.js';
+
+/**
+ * Generate a fix prompt based on errors from previous iteration
+ * @param {AnalyzedError[]} errors - Analyzed errors from test runner
+ * @param {string} originalPack - Original coder pack content
+ * @param {number} iteration - Current iteration number
+ * @returns {string} - Fix prompt for Claude Code
+ */
+export function generateFixPrompt(errors, originalPack, iteration = 1) {
+  const summary = createErrorSummary(errors);
+
+  const sections = [
+    '# 🔧 FIX REQUIRED - Iteration ' + iteration,
+    '',
+    `The previous build had **${errors.length} error(s)**. Please fix them.`,
+    '',
+    '---',
+    '',
+    '## 📋 Error Summary',
+    '',
+    `- **Total Errors:** ${summary.total}`,
+    `- **Critical:** ${summary.byPriority.critical}`,
+    `- **High:** ${summary.byPriority.high}`,
+    `- **Medium:** ${summary.byPriority.medium}`,
+    `- **Low:** ${summary.byPriority.low}`,
+    '',
+    `**Affected Files:** ${summary.files.length > 0 ? summary.files.join(', ') : 'Unknown'}`,
+    '',
+    '---',
+    '',
+    '## 🚨 Errors to Fix',
+    '',
+  ];
+
+  // Add detailed errors grouped by priority
+  const byPriority = groupByPriority(errors);
+
+  for (const [priority, priorityErrors] of Object.entries(byPriority)) {
+    if (priorityErrors.length === 0) continue;
+
+    const emoji = priority === 'critical' ? '🔴' :
+                  priority === 'high' ? '🟠' :
+                  priority === 'medium' ? '🟡' : '🟢';
+
+    sections.push(`### ${emoji} ${priority.toUpperCase()} Priority`);
+    sections.push('');
+
+    for (const error of priorityErrors) {
+      const location = error.file
+        ? `\`${error.file}${error.line ? ':' + error.line : ''}\``
+        : 'Unknown location';
+
+      sections.push(`**${error.type}** at ${location}`);
+      sections.push(`- Message: ${error.message}`);
+      sections.push(`- Suggestion: ${error.suggestion}`);
+      if (error.raw && error.raw !== error.message) {
+        sections.push(`- Raw output: \`${truncate(error.raw, 200)}\``);
+      }
+      sections.push('');
+    }
+  }
+
+  sections.push('---');
+  sections.push('');
+  sections.push('## 📝 Original Task Reference');
+  sections.push('');
+  sections.push('<details>');
+  sections.push('<summary>Click to expand original task</summary>');
+  sections.push('');
+  sections.push(originalPack);
+  sections.push('');
+  sections.push('</details>');
+  sections.push('');
+  sections.push('---');
+  sections.push('');
+  sections.push('## ⚡ Fix Instructions');
+  sections.push('');
+  sections.push('1. **Fix ONLY the errors listed above** - Do not refactor or change working code');
+  sections.push('2. **Start with CRITICAL errors** - They likely cause cascading failures');
+  sections.push('3. **Run tests after each fix** - Verify the error is resolved');
+  sections.push('4. **Keep changes minimal** - Focus on the specific issue');
+  sections.push('');
+  sections.push('When all errors are fixed, the build will be validated again.');
+  sections.push('');
+
+  return sections.join('\n');
+}
+
+/**
+ * Generate a minimal fix prompt for single error
+ */
+export function generateSingleFixPrompt(error) {
+  const location = error.file
+    ? `${error.file}${error.line ? ':' + error.line : ''}`
+    : 'unknown location';
+
+  return `# Fix Required
+
+**Error Type:** ${error.type}
+**Location:** ${location}
+**Message:** ${error.message}
+
+**Suggestion:** ${error.suggestion}
+
+Please fix this specific error. Keep the change minimal and focused.`;
+}
+
+/**
+ * Generate iteration context for logging
+ */
+export function generateIterationContext(iteration, errors, duration) {
+  return {
+    iteration,
+    timestamp: new Date().toISOString(),
+    errorCount: errors.length,
+    errorTypes: [...new Set(errors.map(e => e.type))],
+    affectedFiles: [...new Set(errors.filter(e => e.file).map(e => e.file))],
+    duration
+  };
+}
+
+/**
+ * Group errors by priority
+ */
+function groupByPriority(errors) {
+  const grouped = {
+    critical: [],
+    high: [],
+    medium: [],
+    low: []
+  };
+
+  for (const error of errors) {
+    const priority = error.priority || 'medium';
+    if (grouped[priority]) {
+      grouped[priority].push(error);
+    } else {
+      grouped.medium.push(error);
+    }
+  }
+
+  return grouped;
+}
+
+/**
+ * Truncate string with ellipsis
+ */
+function truncate(str, maxLen) {
+  if (!str) return '';
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + '...';
+}
+
+/**
+ * Check if errors are fixable (not system/config errors)
+ */
+export function areErrorsFixable(errors) {
+  // If all errors are unknown type with no file info, might be config issue
+  const unknownWithoutFile = errors.filter(e => e.type === 'unknown' && !e.file);
+
+  if (unknownWithoutFile.length === errors.length) {
+    return {
+      fixable: false,
+      reason: 'All errors are unstructured with no file information. This may indicate a configuration or environment issue.'
+    };
+  }
+
+  return { fixable: true };
+}
+
+/**
+ * Estimate fix complexity
+ */
+export function estimateFixComplexity(errors) {
+  let score = 0;
+
+  for (const error of errors) {
+    switch (error.priority) {
+      case 'critical': score += 3; break;
+      case 'high': score += 2; break;
+      case 'medium': score += 1; break;
+      case 'low': score += 0.5; break;
+    }
+  }
+
+  if (score <= 3) return 'simple';
+  if (score <= 8) return 'moderate';
+  return 'complex';
+}

package/src/core/iteration.js

@@ -0,0 +1,226 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Iteration Tracker
+// Manage and track build-test-fix iterations
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import path from 'path';
+import { ensureDir, writeJson, readJson, pathExists, appendToFile } from '../utils/files.js';
+
+/**
+ * @typedef {Object} IterationRecord
+ * @property {number} iteration - Iteration number
+ * @property {string} timestamp - ISO timestamp
+ * @property {boolean} passed - Whether tests passed
+ * @property {number} errorCount - Number of errors
+ * @property {string[]} errorTypes - Types of errors found
+ * @property {string[]} affectedFiles - Files with errors
+ * @property {number} duration - Duration in ms
+ * @property {string} action - What action was taken (build/fix)
+ */
+
+/**
+ * @typedef {Object} IterationState
+ * @property {string} sessionId - Session identifier
+ * @property {string} startTime - When iteration started
+ * @property {number} currentIteration - Current iteration number
+ * @property {number} maxIterations - Max allowed iterations
+ * @property {IterationRecord[]} history - History of iterations
+ * @property {boolean} completed - Whether iteration loop completed
+ * @property {string} result - Final result (success/max_reached/error)
+ */
+
+/**
+ * Create new iteration state
+ * @param {string} sessionId - Session identifier
+ * @param {number} maxIterations - Maximum iterations allowed
+ * @returns {IterationState}
+ */
+export function createIterationState(sessionId, maxIterations = 3) {
+  return {
+    sessionId,
+    startTime: new Date().toISOString(),
+    currentIteration: 0,
+    maxIterations,
+    history: [],
+    completed: false,
+    result: null
+  };
+}
+
+/**
+ * Record an iteration result
+ * @param {IterationState} state - Current iteration state
+ * @param {Object} result - Iteration result
+ * @returns {IterationState} - Updated state
+ */
+export function recordIteration(state, result) {
+  const record = {
+    iteration: state.currentIteration + 1,
+    timestamp: new Date().toISOString(),
+    passed: result.passed,
+    errorCount: result.errorCount || 0,
+    errorTypes: result.errorTypes || [],
+    affectedFiles: result.affectedFiles || [],
+    duration: result.duration || 0,
+    action: result.action || 'build'
+  };
+
+  return {
+    ...state,
+    currentIteration: state.currentIteration + 1,
+    history: [...state.history, record]
+  };
+}
+
+/**
+ * Check if can continue iterating
+ * @param {IterationState} state - Current state
+ * @returns {{canContinue: boolean, reason: string}}
+ */
+export function canContinue(state) {
+  if (state.completed) {
+    return { canContinue: false, reason: 'Iteration already completed' };
+  }
+
+  if (state.currentIteration >= state.maxIterations) {
+    return { canContinue: false, reason: `Max iterations (${state.maxIterations}) reached` };
+  }
+
+  // Check if last iteration passed
+  const lastRecord = state.history[state.history.length - 1];
+  if (lastRecord && lastRecord.passed) {
+    return { canContinue: false, reason: 'Tests passed - no more iterations needed' };
+  }
+
+  // Check for stuck loop (same errors repeated 3 times)
+  if (state.history.length >= 3) {
+    const last3 = state.history.slice(-3);
+    const errorCounts = last3.map(r => r.errorCount);
+    if (errorCounts.every(c => c === errorCounts[0]) && errorCounts[0] > 0) {
+      return { canContinue: false, reason: 'Stuck in loop - same error count for 3 iterations' };
+    }
+  }
+
+  return { canContinue: true, reason: '' };
+}
+
+/**
+ * Finalize iteration state
+ * @param {IterationState} state - Current state
+ * @param {string} result - Result type (success/max_reached/error/stuck)
+ * @returns {IterationState}
+ */
+export function finalizeIterationState(state, result) {
+  return {
+    ...state,
+    completed: true,
+    result,
+    endTime: new Date().toISOString(),
+    totalDuration: state.history.reduce((sum, r) => sum + r.duration, 0)
+  };
+}
+
+/**
+ * Save iteration state to session directory
+ * @param {string} sessionDir - Session directory path
+ * @param {IterationState} state - Iteration state
+ */
+export async function saveIterationState(sessionDir, state) {
+  const iterationDir = path.join(sessionDir, 'iterations');
+  await ensureDir(iterationDir);
+
+  const stateFile = path.join(iterationDir, 'state.json');
+  await writeJson(stateFile, state, { spaces: 2 });
+
+  // Also write individual iteration files for evidence
+  for (const record of state.history) {
+    const recordFile = path.join(iterationDir, `iteration-${record.iteration}.json`);
+    if (!await pathExists(recordFile)) {
+      await writeJson(recordFile, record, { spaces: 2 });
+    }
+  }
+}
+
+/**
+ * Load iteration state from session directory
+ * @param {string} sessionDir - Session directory path
+ * @returns {Promise<IterationState|null>}
+ */
+export async function loadIterationState(sessionDir) {
+  const stateFile = path.join(sessionDir, 'iterations', 'state.json');
+  if (await pathExists(stateFile)) {
+    return await readJson(stateFile);
+  }
+  return null;
+}
+
+/**
+ * Format iteration summary for display
+ * @param {IterationState} state - Iteration state
+ * @returns {string}
+ */
+export function formatIterationSummary(state) {
+  const lines = [];
+
+  lines.push(`Iteration Summary (${state.sessionId})`);
+  lines.push('═'.repeat(50));
+  lines.push(`Total Iterations: ${state.currentIteration}/${state.maxIterations}`);
+  lines.push(`Result: ${state.result || 'In Progress'}`);
+  lines.push('');
+
+  if (state.history.length > 0) {
+    lines.push('History:');
+    for (const record of state.history) {
+      const status = record.passed ? '✅' : '❌';
+      const errors = record.errorCount > 0 ? ` (${record.errorCount} errors)` : '';
+      lines.push(`  ${record.iteration}. ${status} ${record.action}${errors} - ${formatDuration(record.duration)}`);
+    }
+  }
+
+  if (state.totalDuration) {
+    lines.push('');
+    lines.push(`Total Duration: ${formatDuration(state.totalDuration)}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format duration in human readable format
+ */
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60000)}m ${Math.round((ms % 60000) / 1000)}s`;
+}
+
+/**
+ * Write iteration log entry
+ */
+export async function logIteration(logPath, iteration, message) {
+  const timestamp = new Date().toISOString();
+  const entry = `[${timestamp}] [Iteration ${iteration}] ${message}\n`;
+  await appendToFile(logPath, entry);
+}
+
+/**
+ * Get progress percentage
+ */
+export function getProgressPercent(state) {
+  if (state.completed && state.result === 'success') {
+    return 100;
+  }
+  return Math.round((state.currentIteration / state.maxIterations) * 100);
+}
+
+/**
+ * Check if errors are improving (decreasing)
+ */
+export function isImproving(state) {
+  if (state.history.length < 2) return true;
+
+  const last = state.history[state.history.length - 1];
+  const prev = state.history[state.history.length - 2];
+
+  return last.errorCount < prev.errorCount;
+}

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