@nclamvn/vibecode-cli 2.0.0 → 2.2.0

package/src/commands/learn.js

@@ -0,0 +1,294 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Learn Command
+// Phase H5: View and manage AI learnings
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import fs from 'fs/promises';
+import path from 'path';
+import { LearningEngine } from '../core/learning.js';
+
+/**
+ * Learn Command - View and manage AI learnings
+ *
+ * Usage:
+ *   vibecode learn           - Interactive menu
+ *   vibecode learn --stats   - Show learning statistics
+ *   vibecode learn --clear   - Clear all learnings
+ *   vibecode learn --export  - Export learnings to file
+ */
+export async function learnCommand(options = {}) {
+  const learning = new LearningEngine();
+
+  if (options.stats) {
+    await showStats(learning);
+    return;
+  }
+
+  if (options.clear) {
+    await clearLearnings(learning, options.force);
+    return;
+  }
+
+  if (options.export) {
+    await exportLearnings(learning);
+    return;
+  }
+
+  // Default: show interactive menu
+  await interactiveLearn(learning);
+}
+
+/**
+ * Show learning statistics
+ */
+async function showStats(learning) {
+  const stats = await learning.getStats();
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  📊 LEARNING STATISTICS                                            │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  console.log(chalk.white(`  📁 Project Learnings`));
+  console.log(chalk.gray(`     Tổng fixes: ${stats.local.total}`));
+  console.log(chalk.gray(`     Thành công: ${stats.local.success} (${stats.local.rate}%)`));
+  console.log('');
+
+  console.log(chalk.white(`  🌍 Global Learnings`));
+  console.log(chalk.gray(`     Tổng fixes: ${stats.global.total}`));
+  console.log(chalk.gray(`     Thành công: ${stats.global.success} (${stats.global.rate}%)`));
+  console.log('');
+
+  if (Object.keys(stats.byCategory).length > 0) {
+    console.log(chalk.white(`  📂 Theo Error Category`));
+    for (const [cat, data] of Object.entries(stats.byCategory)) {
+      const rate = data.total > 0 ? (data.success / data.total * 100).toFixed(0) : 0;
+      const bar = renderMiniBar(data.success, data.total);
+      console.log(chalk.gray(`     ${cat.padEnd(12)} ${bar} ${data.success}/${data.total} (${rate}%)`));
+    }
+    console.log('');
+  }
+
+  console.log(chalk.white(`  ⚙️  Preferences đã lưu: ${stats.preferences}`));
+
+  if (stats.lastLearning) {
+    const lastDate = new Date(stats.lastLearning).toLocaleString('vi-VN');
+    console.log(chalk.gray(`  📅 Learning gần nhất: ${lastDate}`));
+  }
+
+  console.log('');
+}
+
+/**
+ * Render a mini progress bar
+ */
+function renderMiniBar(value, total) {
+  const width = 10;
+  const filled = total > 0 ? Math.round(width * value / total) : 0;
+  const empty = width - filled;
+  return chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+}
+
+/**
+ * Clear all local learnings
+ */
+async function clearLearnings(learning, force) {
+  const stats = await learning.getStats();
+
+  if (stats.local.total === 0) {
+    console.log(chalk.yellow('\n📭 Không có learnings nào để xoá.\n'));
+    return;
+  }
+
+  if (!force) {
+    console.log(chalk.yellow(`\n⚠️  Sắp xoá ${stats.local.total} learnings của project này.\n`));
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Xác nhận xoá tất cả learnings?',
+        default: false
+      }
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.gray('\n👋 Đã huỷ.\n'));
+      return;
+    }
+  }
+
+  await learning.clearLocal();
+  console.log(chalk.green(`\n✅ Đã xoá ${stats.local.total} learnings.\n`));
+}
+
+/**
+ * Export learnings to file
+ */
+async function exportLearnings(learning) {
+  const stats = await learning.getStats();
+  const fixes = await learning.loadJson(
+    path.join(learning.localPath, 'fixes.json'),
+    []
+  );
+  const prefs = await learning.loadJson(
+    path.join(learning.localPath, 'preferences.json'),
+    {}
+  );
+
+  if (fixes.length === 0 && Object.keys(prefs).length === 0) {
+    console.log(chalk.yellow('\n📭 Không có learnings nào để export.\n'));
+    return;
+  }
+
+  const exportData = {
+    exportedAt: new Date().toISOString(),
+    projectPath: learning.projectPath,
+    stats,
+    fixes: fixes.map(f => ({
+      id: f.id,
+      errorType: f.errorType,
+      errorCategory: f.errorCategory,
+      success: f.success,
+      userFeedback: f.userFeedback,
+      projectType: f.projectType,
+      timestamp: f.timestamp
+    })),
+    preferences: prefs
+  };
+
+  const exportPath = `vibecode-learnings-${Date.now()}.json`;
+  await fs.writeFile(exportPath, JSON.stringify(exportData, null, 2));
+
+  console.log(chalk.green(`\n✅ Đã export ${fixes.length} learnings → ${exportPath}\n`));
+}
+
+/**
+ * Interactive learning menu
+ */
+async function interactiveLearn(learning) {
+  const stats = await learning.getStats();
+
+  const successBar = renderMiniBar(stats.local.success, stats.local.total);
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  🧠 VIBECODE LEARNING                                              │
+│                                                                    │
+│  AI học từ feedback của bạn để cải thiện suggestions.             │
+│                                                                    │
+│  Success rate: ${successBar} ${String(stats.local.rate + '%').padEnd(30)}│
+│  Total learnings: ${String(stats.local.total).padEnd(44)}│
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Bạn muốn làm gì?',
+      choices: [
+        { name: '📊 Xem thống kê chi tiết', value: 'stats' },
+        { name: '📤 Export learnings', value: 'export' },
+        { name: '🗑️  Xoá learnings', value: 'clear' },
+        new inquirer.Separator(),
+        { name: '👋 Thoát', value: 'exit' }
+      ]
+    }
+  ]);
+
+  switch (action) {
+    case 'stats':
+      await showStats(learning);
+      break;
+    case 'export':
+      await exportLearnings(learning);
+      break;
+    case 'clear':
+      await clearLearnings(learning, false);
+      break;
+  }
+}
+
+/**
+ * Ask for feedback after a fix
+ * Called from debug/fix commands
+ */
+export async function askFeedback(fixInfo) {
+  console.log('');
+  const { feedback } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'feedback',
+      message: 'Fix này có đúng không?',
+      choices: [
+        { name: '✅ Đúng, hoạt động tốt', value: 'success' },
+        { name: '❌ Không đúng', value: 'failed' },
+        { name: '🔄 Đúng một phần', value: 'partial' },
+        { name: '⏭️  Bỏ qua', value: 'skip' }
+      ]
+    }
+  ]);
+
+  if (feedback === 'skip') {
+    return null;
+  }
+
+  const learning = new LearningEngine();
+  let userCorrection = null;
+
+  if (feedback === 'failed' || feedback === 'partial') {
+    const { correction } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'correction',
+        message: 'Mô tả ngắn vấn đề hoặc cách fix đúng (Enter để bỏ qua):',
+      }
+    ]);
+    userCorrection = correction || null;
+  }
+
+  await learning.recordFix({
+    errorType: fixInfo.errorType,
+    errorMessage: fixInfo.errorMessage,
+    errorCategory: fixInfo.errorCategory,
+    fixApplied: fixInfo.fixApplied,
+    success: feedback === 'success',
+    userFeedback: feedback,
+    userCorrection
+  });
+
+  if (feedback === 'success') {
+    console.log(chalk.green('  ✅ Đã ghi nhận. Cảm ơn!\n'));
+  } else {
+    console.log(chalk.yellow('  📝 Đã ghi nhận feedback.\n'));
+  }
+
+  return feedback;
+}
+
+/**
+ * Show learning-based suggestion (if available)
+ */
+export async function showLearningSuggestion(errorType, errorCategory) {
+  const learning = new LearningEngine();
+  const suggestion = await learning.getSuggestion(errorType, errorCategory);
+
+  if (suggestion && suggestion.confidence > 0.6) {
+    const confidencePercent = (suggestion.confidence * 100).toFixed(0);
+    console.log(chalk.cyan(`  💡 Dựa trên ${suggestion.basedOn} fixes trước (độ tin cậy: ${confidencePercent}%)`));
+
+    if (suggestion.suggestion) {
+      const shortSuggestion = suggestion.suggestion.substring(0, 100);
+      console.log(chalk.gray(`     Gợi ý: ${shortSuggestion}${suggestion.suggestion.length > 100 ? '...' : ''}`));
+    }
+    console.log('');
+    return suggestion;
+  }
+
+  return null;
+}

package/src/commands/migrate.js

@@ -0,0 +1,341 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Migrate Command
+// Phase K8: AI-Powered Code Migration
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { BackupManager } from '../core/backup.js';
+
+export async function migrateCommand(description, options = {}) {
+  const cwd = process.cwd();
+
+  // Interactive mode
+  if (!description || description.length === 0) {
+    return interactiveMigrate(cwd);
+  }
+
+  const migrationDesc = Array.isArray(description) ? description.join(' ') : description;
+  return performMigration(cwd, migrationDesc, options);
+}
+
+async function interactiveMigrate(cwd) {
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  🔄 CODE MIGRATION                                                 │
+│                                                                    │
+│  AI-powered code migration and transformation                     │
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  const { migrationType } = await inquirer.prompt([{
+    type: 'list',
+    name: 'migrationType',
+    message: 'What migration do you need?',
+    choices: [
+      { name: '📘 JavaScript → TypeScript', value: 'js-to-ts' },
+      { name: '⚛️  Class Components → Hooks', value: 'class-to-hooks' },
+      { name: '🔄 CommonJS → ESM', value: 'cjs-to-esm' },
+      { name: '📦 REST → GraphQL', value: 'rest-to-graphql' },
+      { name: '🎨 CSS → Tailwind', value: 'css-to-tailwind' },
+      { name: '🗄️  Mongoose → Prisma', value: 'mongoose-to-prisma' },
+      { name: '⚡ Express → Fastify', value: 'express-to-fastify' },
+      { name: '📱 Pages Router → App Router', value: 'pages-to-app' },
+      { name: '🧪 Jest → Vitest', value: 'jest-to-vitest' },
+      { name: '✏️  Custom migration', value: 'custom' },
+      { name: '👋 Exit', value: 'exit' }
+    ]
+  }]);
+
+  if (migrationType === 'exit') return;
+
+  let migrationDesc = migrationType;
+
+  if (migrationType === 'custom') {
+    const { desc } = await inquirer.prompt([{
+      type: 'input',
+      name: 'desc',
+      message: 'Describe your migration:'
+    }]);
+    migrationDesc = desc;
+  }
+
+  const { targetPath } = await inquirer.prompt([{
+    type: 'input',
+    name: 'targetPath',
+    message: 'Path to migrate (leave empty for entire project):',
+    default: ''
+  }]);
+
+  return performMigration(cwd, migrationDesc, { path: targetPath });
+}
+
+async function performMigration(cwd, migrationDesc, options) {
+  // Create backup
+  console.log(chalk.gray('\n  Creating backup before migration...\n'));
+  const backup = new BackupManager(cwd);
+  await backup.createBackup(`migrate-${Date.now()}`);
+
+  const migrations = {
+    'js-to-ts': `
+# JavaScript to TypeScript Migration
+
+Convert JavaScript files to TypeScript:
+
+1. **Setup**
+   - Create/update tsconfig.json with appropriate settings
+   - Install TypeScript and @types packages
+
+2. **File Conversion**
+   - Rename .js files to .ts/.tsx (for React components)
+   - Add type annotations to variables, parameters, return values
+   - Define interfaces/types for objects and props
+   - Fix any TypeScript errors
+
+3. **Best Practices**
+   - Use strict mode
+   - Avoid 'any' where possible
+   - Use enums for constants
+   - Add proper generics
+
+4. **Cleanup**
+   - Update imports
+   - Remove JSDoc type annotations (now in code)
+`,
+    'class-to-hooks': `
+# React Class to Hooks Migration
+
+Convert React class components to functional components with hooks:
+
+1. **Component Conversion**
+   - Convert class to function component
+   - Replace this.state with useState
+   - Replace lifecycle methods:
+     - componentDidMount → useEffect(..., [])
+     - componentDidUpdate → useEffect
+     - componentWillUnmount → useEffect cleanup
+
+2. **Methods & Bindings**
+   - Convert class methods to functions
+   - Remove .bind(this) calls
+   - Use useCallback for memoized callbacks
+
+3. **Refs & Context**
+   - Replace createRef with useRef
+   - Replace this.context with useContext
+
+4. **State Management**
+   - Use useReducer for complex state
+   - Lift state or use context where appropriate
+`,
+    'cjs-to-esm': `
+# CommonJS to ES Modules Migration
+
+Convert CommonJS to ESM:
+
+1. **Syntax Changes**
+   - Replace require() with import
+   - Replace module.exports with export
+   - Replace exports.x with export const x
+
+2. **Package.json**
+   - Add "type": "module"
+   - Update main/exports fields
+
+3. **File Extensions**
+   - Ensure .js extensions in imports (or configure bundler)
+
+4. **Dynamic Imports**
+   - Replace require() in conditionals with import()
+   - Handle __dirname, __filename with import.meta.url
+`,
+    'rest-to-graphql': `
+# REST to GraphQL Migration
+
+Convert REST API to GraphQL:
+
+1. **Schema Design**
+   - Create GraphQL types from REST response shapes
+   - Design queries for GET endpoints
+   - Design mutations for POST/PUT/DELETE
+
+2. **Server Setup**
+   - Set up Apollo Server or similar
+   - Create resolvers for each query/mutation
+   - Connect to existing data sources
+
+3. **Client Migration**
+   - Replace fetch/axios calls with GraphQL queries
+   - Set up Apollo Client or urql
+   - Use generated types if TypeScript
+`,
+    'css-to-tailwind': `
+# CSS to Tailwind Migration
+
+Convert CSS/SCSS to Tailwind classes:
+
+1. **Setup**
+   - Install and configure Tailwind CSS
+   - Set up tailwind.config.js
+
+2. **Conversion**
+   - Replace CSS properties with Tailwind utilities
+   - Convert custom values to Tailwind config
+   - Handle responsive designs with breakpoint prefixes
+
+3. **Components**
+   - Use @apply for repeated patterns
+   - Create component classes where needed
+   - Remove unused CSS
+
+4. **Cleanup**
+   - Remove old CSS files
+   - Update build process
+`,
+    'mongoose-to-prisma': `
+# Mongoose to Prisma Migration
+
+Convert Mongoose ODM to Prisma ORM:
+
+1. **Schema Migration**
+   - Create Prisma schema from Mongoose models
+   - Convert types (ObjectId → String with @id)
+   - Define relations explicitly
+
+2. **Query Migration**
+   - Replace Model.find() with prisma.model.findMany()
+   - Replace Model.findById() with prisma.model.findUnique()
+   - Update create/update/delete operations
+
+3. **Setup**
+   - Configure Prisma client
+   - Set up migrations
+   - Handle connection pooling
+`,
+    'express-to-fastify': `
+# Express to Fastify Migration
+
+Convert Express.js to Fastify:
+
+1. **App Setup**
+   - Replace express() with fastify()
+   - Update middleware to plugins
+   - Configure async handlers (native in Fastify)
+
+2. **Routes**
+   - Update route syntax
+   - Replace req/res patterns
+   - Use schema validation
+
+3. **Middleware**
+   - Convert Express middleware to Fastify plugins
+   - Update error handling
+   - Replace body-parser (built into Fastify)
+`,
+    'pages-to-app': `
+# Next.js Pages to App Router Migration
+
+Convert Pages Router to App Router:
+
+1. **Directory Structure**
+   - Move pages/ to app/
+   - Create layout.tsx files
+   - Convert _app.tsx to root layout
+
+2. **Data Fetching**
+   - Replace getServerSideProps with server components
+   - Replace getStaticProps with fetch + cache
+   - Use generateStaticParams for dynamic routes
+
+3. **Components**
+   - Mark client components with 'use client'
+   - Keep server components as default
+   - Update metadata handling
+
+4. **API Routes**
+   - Move to app/api/[route]/route.ts
+   - Update to new Route Handlers format
+`,
+    'jest-to-vitest': `
+# Jest to Vitest Migration
+
+Convert Jest tests to Vitest:
+
+1. **Configuration**
+   - Create vitest.config.ts
+   - Remove jest.config.js
+   - Update package.json scripts
+
+2. **Test Files**
+   - Update imports from 'vitest'
+   - Replace jest.fn() with vi.fn()
+   - Replace jest.mock() with vi.mock()
+   - Replace jest.spyOn() with vi.spyOn()
+
+3. **Assertions**
+   - Most expect() syntax is compatible
+   - Update any Jest-specific matchers
+`
+  };
+
+  const migrationGuide = migrations[migrationDesc] || `
+# Custom Migration: ${migrationDesc}
+
+Perform this migration following best practices:
+1. Analyze current code structure
+2. Plan the migration steps
+3. Apply changes incrementally
+4. Verify each step works
+5. Run tests after migration
+`;
+
+  const targetInfo = options.path ? `\n## Target Path: ${options.path}` : '\n## Target: Entire project';
+
+  const prompt = `
+${migrationGuide}
+${targetInfo}
+
+## Safety Requirements:
+1. Preserve all existing functionality
+2. Don't lose any data or configuration
+3. Make incremental changes when possible
+4. Add comments for complex changes
+5. Run tests if available
+
+## Instructions:
+1. Analyze the codebase
+2. Create a migration plan
+3. Execute the migration step by step
+4. Verify the changes work
+
+Perform the migration now.
+`;
+
+  const promptFile = path.join(cwd, '.vibecode', 'migrate-prompt.md');
+  await fs.mkdir(path.dirname(promptFile), { recursive: true });
+  await fs.writeFile(promptFile, prompt);
+
+  console.log(chalk.yellow(`  Performing migration: ${migrationDesc}\n`));
+
+  await runClaudeCode(prompt, cwd);
+
+  console.log(chalk.green('\n✅ Migration complete!'));
+  console.log(chalk.gray('  • Run tests to verify'));
+  console.log(chalk.gray('  • Use `vibecode undo` to revert if needed\n'));
+}
+
+async function runClaudeCode(prompt, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn('claude', ['-p', prompt, '--dangerously-skip-permissions'], {
+      cwd,
+      stdio: 'inherit'
+    });
+
+    child.on('close', resolve);
+    child.on('error', () => resolve());
+  });
+}

package/src/commands/plan.js

@@ -45,7 +45,7 @@ export async function planCommand(options = {}) {
     const sessionPath = await getCurrentSessionPath();
     const specHash = await getSpecHash();
 
-    // Read contract and blueprint
+    // Read contract, blueprint, and intake
     spinner.text = 'Reading contract...';
     const contractContent = await readSessionFile('contract.md');
 
@@ -54,6 +54,11 @@ export async function planCommand(options = {}) {
       blueprintContent = await readSessionFile('blueprint.md');
     }
 
+    let intakeContent = '';
+    if (await sessionFileExists('intake.md')) {
+      intakeContent = await readSessionFile('intake.md');
+    }
+
     // Generate plan
     spinner.text = 'Generating plan...';
     const planContent = getPlanTemplate(projectName, sessionId, specHash, contractContent);
@@ -66,7 +71,8 @@ export async function planCommand(options = {}) {
       sessionId,
       specHash,
       contractContent,
-      blueprintContent
+      blueprintContent,
+      intakeContent
     );
     await writeSessionFile('coder_pack.md', coderPackContent);