@nclamvn/vibecode-cli 1.6.0 → 1.8.0

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/refactor.js

@@ -0,0 +1,205 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Refactor Command
+// Phase K4: AI-Powered Refactoring
+// ═══════════════════════════════════════════════════════════════════════════════
+
+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 refactorCommand(targetPath, options = {}) {
+  const cwd = process.cwd();
+
+  // Interactive mode
+  if (!targetPath && !options.type) {
+    return interactiveRefactor(cwd);
+  }
+
+  return performRefactor(cwd, targetPath || 'src/', options);
+}
+
+async function interactiveRefactor(cwd) {
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  🔄 AI REFACTORING                                                 │
+│                                                                    │
+│  Improve code quality with AI-powered refactoring                 │
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  const { refactorType } = await inquirer.prompt([{
+    type: 'list',
+    name: 'refactorType',
+    message: 'What type of refactoring?',
+    choices: [
+      { name: '🧹 Clean Code - Improve readability', value: 'clean' },
+      { name: '🔄 DRY - Remove duplication', value: 'dry' },
+      { name: '⚡ Performance - Optimize slow code', value: 'performance' },
+      { name: '🏗️  Architecture - Better structure', value: 'architecture' },
+      { name: '📦 Modularize - Split large files', value: 'modularize' },
+      { name: '🆕 Modernize - Update to modern syntax', value: 'modernize' },
+      { name: '🎯 Custom - Describe your own', value: 'custom' },
+      { name: '👋 Exit', value: 'exit' }
+    ]
+  }]);
+
+  if (refactorType === 'exit') return;
+
+  const { targetPath } = await inquirer.prompt([{
+    type: 'input',
+    name: 'targetPath',
+    message: 'Path to refactor:',
+    default: 'src/'
+  }]);
+
+  let customDescription = '';
+  if (refactorType === 'custom') {
+    const { desc } = await inquirer.prompt([{
+      type: 'input',
+      name: 'desc',
+      message: 'Describe the refactoring:'
+    }]);
+    customDescription = desc;
+  }
+
+  return performRefactor(cwd, targetPath, { type: refactorType, description: customDescription });
+}
+
+async function performRefactor(cwd, targetPath, options) {
+  const refactorType = options.type || 'clean';
+
+  // Create backup first
+  console.log(chalk.gray('\n  Creating backup before refactoring...\n'));
+  const backup = new BackupManager(cwd);
+  await backup.createBackup(`refactor-${refactorType}`);
+
+  const prompts = {
+    clean: `
+# Clean Code Refactoring
+
+Improve code readability:
+- Better variable/function names (descriptive, consistent)
+- Simplify complex conditions (extract to named variables/functions)
+- Extract magic numbers to named constants
+- Add meaningful comments where logic is complex
+- Improve code formatting and consistency
+- Follow language conventions and style guides
+- Remove dead code and unused imports
+`,
+    dry: `
+# DRY Refactoring (Don't Repeat Yourself)
+
+Remove code duplication:
+- Identify repeated code patterns (3+ occurrences)
+- Extract common logic to reusable functions
+- Create utility modules for shared functionality
+- Use generics/templates where appropriate
+- Consolidate similar functions with parameters
+- Create higher-order functions for common patterns
+`,
+    performance: `
+# Performance Optimization
+
+Optimize for speed and efficiency:
+- Replace O(n²) with O(n) where possible
+- Add memoization for expensive computations
+- Optimize database queries (N+1 problem)
+- Implement lazy loading for large data
+- Use efficient data structures (Map/Set vs Array)
+- Remove unnecessary re-renders (React)
+- Add proper caching strategies
+- Optimize loops and iterations
+`,
+    architecture: `
+# Architecture Refactoring
+
+Improve code structure:
+- Apply SOLID principles
+- Implement proper separation of concerns
+- Use dependency injection where appropriate
+- Apply appropriate design patterns
+- Improve module boundaries
+- Better error handling structure
+- Create clear interfaces between modules
+- Reduce coupling, increase cohesion
+`,
+    modularize: `
+# Modularization
+
+Split large files and improve organization:
+- Break large files (>300 lines) into smaller modules
+- One component/class per file
+- Group related functionality in folders
+- Create proper index files for exports
+- Improve import structure
+- Separate concerns (UI, logic, data)
+- Create feature-based folder structure
+`,
+    modernize: `
+# Modernize Code
+
+Update to modern syntax and practices:
+- ES6+ features (arrow functions, destructuring, spread)
+- async/await instead of callbacks/Promise chains
+- Optional chaining (?.) and nullish coalescing (??)
+- Modern array methods (map, filter, reduce)
+- Template literals instead of string concatenation
+- const/let instead of var
+- TypeScript improvements (if TS project)
+- Modern React patterns (hooks, functional components)
+`,
+    custom: `
+# Custom Refactoring
+
+${options.description || 'Improve the code based on best practices.'}
+`
+  };
+
+  const prompt = `
+${prompts[refactorType]}
+
+## Target Path: ${targetPath}
+
+## Instructions:
+1. Analyze the code in the target path
+2. Apply the refactoring described above
+3. Preserve all functionality (don't break anything!)
+4. Make minimal changes to achieve the goal
+5. Add comments explaining significant changes
+
+## Safety:
+- Run tests after refactoring if available
+- Keep backward compatibility
+- Don't change public APIs without good reason
+
+Perform the refactoring now.
+`;
+
+  const promptFile = path.join(cwd, '.vibecode', 'refactor-prompt.md');
+  await fs.mkdir(path.dirname(promptFile), { recursive: true });
+  await fs.writeFile(promptFile, prompt);
+
+  console.log(chalk.yellow(`  Refactoring (${refactorType})...\n`));
+
+  await runClaudeCode(prompt, cwd);
+
+  console.log(chalk.green('\n✅ Refactoring complete!'));
+  console.log(chalk.gray('  • Run tests to verify changes'));
+  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/review.js

@@ -1,11 +1,13 @@
 // ═══════════════════════════════════════════════════════════════════════════════
 // VIBECODE CLI - Review Command
+// Phase K1: AI Code Review
 // ═══════════════════════════════════════════════════════════════════════════════
 
 import chalk from 'chalk';
 import ora from 'ora';
 import path from 'path';
-import { exec } from 'child_process';
+import fs from 'fs/promises';
+import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import inquirer from 'inquirer';
 import { workspaceExists, getProjectName } from '../core/workspace.js';
@@ -26,6 +28,10 @@ import { printBox, printError, printSuccess, printWarning, printNextStep } from
 const execAsync = promisify(exec);
 
 export async function reviewCommand(options = {}) {
+  // K1: AI-powered code review
+  if (options.ai) {
+    return aiCodeReview(options);
+  }
   const spinner = ora('Starting review...').start();
 
   try {
@@ -288,3 +294,122 @@ async function checkGitStatus() {
     return { clean: true, message: 'Git not available' };
   }
 }
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// K1: AI CODE REVIEW
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function aiCodeReview(options) {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  🔍 AI CODE REVIEW                                                 │
+│                                                                    │
+│  Analyzing codebase for:                                          │
+│  • Code quality & best practices                                  │
+│  • Potential bugs & edge cases                                    │
+│  • Performance concerns                                           │
+│  • Security vulnerabilities                                       │
+│  • Maintainability issues                                         │
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  // Gather codebase context
+  const files = await gatherSourceFiles(cwd, options.path);
+
+  console.log(chalk.gray(`  Found ${files.length} files to review\n`));
+
+  const prompt = `
+# AI Code Review Request
+
+## Project: ${path.basename(cwd)}
+
+## Files to Review:
+${files.map(f => `- ${f}`).join('\n')}
+
+## Review Criteria:
+1. **Code Quality**: Clean code, readability, naming conventions
+2. **Best Practices**: Design patterns, DRY, SOLID principles
+3. **Potential Bugs**: Edge cases, null checks, error handling
+4. **Performance**: Inefficient loops, memory leaks, N+1 queries
+5. **Security**: Input validation, XSS, SQL injection, auth issues
+6. **Maintainability**: Modularity, testability, documentation
+
+## Output Format:
+For each issue found, provide:
+- **Severity**: Critical / High / Medium / Low
+- **Category**: Bug / Performance / Security / Quality / Maintainability
+- **File**: path/to/file.ts
+- **Line**: (if applicable)
+- **Issue**: Description
+- **Suggestion**: How to fix
+
+## Summary:
+End with overall score (A-F) and top 3 priorities.
+
+Review the codebase now.
+`;
+
+  // Write prompt
+  const promptFile = path.join(cwd, '.vibecode', 'review-prompt.md');
+  await fs.mkdir(path.dirname(promptFile), { recursive: true });
+  await fs.writeFile(promptFile, prompt);
+
+  // Run Claude Code
+  console.log(chalk.gray('  Analyzing with Claude Code...\n'));
+
+  await runClaudeCode(prompt, cwd);
+
+  // Save report
+  const reportDir = path.join(cwd, '.vibecode', 'reports');
+  await fs.mkdir(reportDir, { recursive: true });
+  const reportFile = path.join(reportDir, `review-${Date.now()}.md`);
+
+  console.log(chalk.green(`\n✅ Review complete!`));
+  console.log(chalk.gray(`  Report saved to: .vibecode/reports/\n`));
+}
+
+async function gatherSourceFiles(cwd, targetPath) {
+  const files = [];
+  const extensions = ['.js', '.ts', '.tsx', '.jsx', '.py', '.go', '.rs', '.vue', '.svelte'];
+  const ignoreDirs = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.vibecode', '__pycache__'];
+
+  const scanDir = targetPath ? path.join(cwd, targetPath) : cwd;
+
+  async function scan(dir) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue;
+        if (ignoreDirs.includes(entry.name)) continue;
+
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(cwd, fullPath);
+
+        if (entry.isDirectory()) {
+          await scan(fullPath);
+        } else if (extensions.some(ext => entry.name.endsWith(ext))) {
+          files.push(relativePath);
+        }
+      }
+    } catch {}
+  }
+
+  await scan(scanDir);
+  return files.slice(0, 50); // Limit files
+}
+
+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());
+  });
+}