@nclamvn/vibecode-cli 1.1.0 → 1.2.0

package/src/commands/config.js

@@ -0,0 +1,149 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Config Command
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import path from 'path';
+import { workspaceExists, getWorkspacePath } from '../core/workspace.js';
+import { pathExists, readJson, writeJson } from '../utils/files.js';
+import { PROVIDERS, getDefaultProvider } from '../providers/index.js';
+import { printBox, printError, printSuccess, printInfo } from '../ui/output.js';
+
+const CONFIG_FILE = 'config.json';
+
+/**
+ * Get config file path
+ */
+function getConfigPath() {
+  return path.join(getWorkspacePath(), CONFIG_FILE);
+}
+
+/**
+ * Load config
+ */
+async function loadConfig() {
+  const configPath = getConfigPath();
+  if (await pathExists(configPath)) {
+    return await readJson(configPath);
+  }
+  return getDefaultConfig();
+}
+
+/**
+ * Save config
+ */
+async function saveConfig(config) {
+  const configPath = getConfigPath();
+  await writeJson(configPath, config);
+}
+
+/**
+ * Get default config
+ */
+function getDefaultConfig() {
+  return {
+    provider: 'claude-code',
+    claudeCode: {
+      flags: ['--dangerously-skip-permissions'],
+      timeout: 30 // minutes
+    },
+    autoEvidence: true,
+    verbose: false
+  };
+}
+
+export async function configCommand(options = {}) {
+  try {
+    // Check workspace for set operations
+    if (options.provider || options.set) {
+      if (!await workspaceExists()) {
+        printError('No Vibecode workspace found. Run `vibecode init` first.');
+        process.exit(1);
+      }
+    }
+
+    // Show current config
+    if (options.show || (!options.provider && !options.set)) {
+      await showConfig();
+      return;
+    }
+
+    // Set provider
+    if (options.provider) {
+      await setProvider(options.provider);
+      return;
+    }
+
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+}
+
+async function showConfig() {
+  console.log();
+
+  // Check if workspace exists
+  if (!await workspaceExists()) {
+    // Show default config
+    console.log(chalk.cyan('Default Configuration (no workspace):'));
+    console.log();
+    const defaultConfig = getDefaultConfig();
+    console.log(chalk.gray('Provider: ') + chalk.white(defaultConfig.provider));
+    console.log(chalk.gray('Flags: ') + chalk.white(defaultConfig.claudeCode.flags.join(', ')));
+    console.log(chalk.gray('Timeout: ') + chalk.white(`${defaultConfig.claudeCode.timeout} minutes`));
+    console.log();
+    console.log(chalk.gray('Run `vibecode init` to create a workspace.'));
+    return;
+  }
+
+  const config = await loadConfig();
+
+  const content = `Current Configuration
+
+Provider: ${config.provider}
+Flags: ${config.claudeCode?.flags?.join(', ') || 'none'}
+Timeout: ${config.claudeCode?.timeout || 30} minutes
+Auto Evidence: ${config.autoEvidence ? 'enabled' : 'disabled'}
+Verbose: ${config.verbose ? 'enabled' : 'disabled'}`;
+
+  printBox(content, { borderColor: 'cyan' });
+
+  // Show available providers
+  console.log();
+  console.log(chalk.cyan('Available Providers:'));
+  Object.entries(PROVIDERS).forEach(([key, provider]) => {
+    const status = provider.available ? chalk.green('available') : chalk.gray('coming soon');
+    const current = key === config.provider ? chalk.yellow(' (current)') : '';
+    console.log(chalk.gray(`  • ${key}: ${provider.description} [${status}]${current}`));
+  });
+
+  console.log();
+  console.log(chalk.gray('To change: vibecode config --provider <name>'));
+}
+
+async function setProvider(providerName) {
+  // Validate provider
+  if (!PROVIDERS[providerName]) {
+    printError(`Unknown provider: ${providerName}`);
+    console.log();
+    console.log(chalk.cyan('Available providers:'));
+    Object.keys(PROVIDERS).forEach(key => {
+      console.log(chalk.gray(`  • ${key}`));
+    });
+    process.exit(1);
+  }
+
+  if (!PROVIDERS[providerName].available) {
+    printError(`Provider "${providerName}" is not yet available.`);
+    process.exit(1);
+  }
+
+  // Load and update config
+  const config = await loadConfig();
+  config.provider = providerName;
+  await saveConfig(config);
+
+  printSuccess(`Provider set to: ${providerName}`);
+  console.log(chalk.gray(`Config saved to: ${getConfigPath()}`));
+}

package/src/config/constants.js

@@ -3,7 +3,7 @@
 // Spec Hash: 0fe43335f5a325e3279a079ce616c052
 // ═══════════════════════════════════════════════════════════════════════════════
 
-export const VERSION = '1.1.0';
+export const VERSION = '1.0.1';
 export const SPEC_HASH = '0fe43335f5a325e3279a079ce616c052';
 
 // ─────────────────────────────────────────────────────────────────────────────

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

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