@nclamvn/vibecode-cli 1.7.0 → 1.8.0

package/bin/vibecode.js

@@ -26,6 +26,13 @@ import {
   gitCommand,
   watchCommand,
   shellCommand,
+  // Phase K Commands
+  testCommand,
+  docsCommand,
+  refactorCommand,
+  securityCommand,
+  askCommand,
+  migrateCommand,
   VERSION
 } from '../src/index.js';
 
@@ -98,6 +105,8 @@ program
   .command('review')
   .description('Review build against acceptance criteria')
   .option('--skip-manual', 'Skip manual verification prompts')
+  .option('--ai', 'AI-powered code review')
+  .option('-p, --path <dir>', 'Specific path to review')
   .action(reviewCommand);
 
 program
@@ -217,6 +226,7 @@ program
   .option('-a, --auto', 'Auto-stage all changes before commit')
   .option('-m, --message <msg>', 'Commit message')
   .option('--staged', 'Show only staged changes (for diff)')
+  .option('--review', 'AI-powered diff review')
   .option('--count <n>', 'Number of commits to show (for log)', parseInt)
   .option('--all', 'Include all files (for add)')
   .action((subcommand, args, options) => {
@@ -250,6 +260,49 @@ program
   .description('Interactive shell with vibecode context and AI assistance')
   .action(shellCommand);
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase K Commands - Maximize Claude Code
+// ─────────────────────────────────────────────────────────────────────────────
+
+program
+  .command('test [path]')
+  .description('🧪 Test generation and running')
+  .option('-g, --generate', 'Generate tests with AI')
+  .option('-r, --run', 'Run tests')
+  .option('-c, --coverage', 'Show coverage')
+  .action(testCommand);
+
+program
+  .command('docs')
+  .description('📚 Generate documentation with AI')
+  .option('-g, --generate', 'Generate docs')
+  .option('-t, --type <type>', 'Doc type: readme, api, architecture, jsdoc, all')
+  .action(docsCommand);
+
+program
+  .command('refactor [path]')
+  .description('🔄 AI-powered code refactoring')
+  .option('-t, --type <type>', 'Type: clean, dry, performance, architecture, modularize, modernize')
+  .option('-d, --description <desc>', 'Custom refactoring description')
+  .action(refactorCommand);
+
+program
+  .command('security')
+  .description('🔒 Security audit with AI analysis')
+  .option('-f, --fix', 'Auto-fix security issues')
+  .action(securityCommand);
+
+program
+  .command('ask [question...]')
+  .description('💬 Ask questions about your codebase')
+  .action(askCommand);
+
+program
+  .command('migrate [description...]')
+  .description('🔄 AI-powered code migration')
+  .option('-p, --path <path>', 'Specific path to migrate')
+  .action(migrateCommand);
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Parse - If no command provided, show interactive wizard
 // ─────────────────────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nclamvn/vibecode-cli",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Build software with discipline - AI coding with guardrails",
   "main": "src/index.js",
   "type": "module",

package/src/commands/ask.js

@@ -0,0 +1,230 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Ask Command
+// Phase K6: Codebase Q&A
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import readline from 'readline';
+
+export async function askCommand(question, options = {}) {
+  const cwd = process.cwd();
+
+  // If no question, enter interactive mode
+  if (!question || question.length === 0) {
+    return interactiveAsk(cwd);
+  }
+
+  const questionText = Array.isArray(question) ? question.join(' ') : question;
+  return answerQuestion(cwd, questionText);
+}
+
+async function interactiveAsk(cwd) {
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  💬 CODEBASE Q&A                                                   │
+│                                                                    │
+│  Ask anything about your codebase.                                │
+│  Type 'exit' to quit.                                             │
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk.green('ask> ')
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+
+    if (input === 'exit' || input === 'quit' || input === 'q') {
+      console.log(chalk.cyan('\n👋 Goodbye!\n'));
+      rl.close();
+      return;
+    }
+
+    await answerQuestion(cwd, input);
+    console.log('');
+    rl.prompt();
+  });
+
+  rl.on('close', () => process.exit(0));
+}
+
+async function answerQuestion(cwd, question) {
+  console.log(chalk.gray('\n  Analyzing codebase...\n'));
+
+  // Build context
+  const projectInfo = await getProjectContext(cwd);
+
+  const prompt = `
+# Codebase Question
+
+## Project: ${path.basename(cwd)}
+## Type: ${projectInfo.type}
+
+## Project Structure:
+${projectInfo.structure}
+
+## Key Files:
+${projectInfo.keyFiles.join('\n')}
+
+## Question:
+${question}
+
+## Instructions:
+1. Analyze the codebase to answer the question
+2. Reference specific files and line numbers when applicable
+3. Provide code examples if helpful
+4. Be concise but thorough
+5. If you need to look at specific files, do so
+
+Answer the question now.
+`;
+
+  await runClaudeCode(prompt, cwd);
+}
+
+async function getProjectContext(cwd) {
+  const context = {
+    type: 'unknown',
+    structure: '',
+    keyFiles: []
+  };
+
+  // Detect project type
+  try {
+    const pkgPath = path.join(cwd, 'package.json');
+    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    if (deps.next) context.type = 'Next.js';
+    else if (deps.nuxt) context.type = 'Nuxt';
+    else if (deps['@angular/core']) context.type = 'Angular';
+    else if (deps.react) context.type = 'React';
+    else if (deps.vue) context.type = 'Vue';
+    else if (deps.svelte) context.type = 'Svelte';
+    else if (deps.express) context.type = 'Express';
+    else if (deps.fastify) context.type = 'Fastify';
+    else if (deps.koa) context.type = 'Koa';
+    else if (deps.nestjs || deps['@nestjs/core']) context.type = 'NestJS';
+    else context.type = 'Node.js';
+  } catch {
+    // Check for other project types
+    try {
+      await fs.access(path.join(cwd, 'Cargo.toml'));
+      context.type = 'Rust';
+    } catch {}
+    try {
+      await fs.access(path.join(cwd, 'go.mod'));
+      context.type = 'Go';
+    } catch {}
+    try {
+      await fs.access(path.join(cwd, 'requirements.txt'));
+      context.type = 'Python';
+    } catch {}
+  }
+
+  // Get directory structure
+  context.structure = await getDirectoryTree(cwd, 3);
+
+  // Get key files
+  context.keyFiles = await findKeyFiles(cwd);
+
+  return context;
+}
+
+async function getDirectoryTree(dir, depth, prefix = '') {
+  if (depth === 0) return '';
+
+  let result = '';
+
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const filtered = entries.filter(e =>
+      !e.name.startsWith('.') &&
+      e.name !== 'node_modules' &&
+      e.name !== 'dist' &&
+      e.name !== 'build' &&
+      e.name !== '.next' &&
+      e.name !== 'coverage' &&
+      e.name !== '__pycache__'
+    );
+
+    for (const entry of filtered.slice(0, 15)) {
+      const icon = entry.isDirectory() ? '📁' : '📄';
+      result += `${prefix}${icon} ${entry.name}\n`;
+
+      if (entry.isDirectory() && depth > 1) {
+        result += await getDirectoryTree(
+          path.join(dir, entry.name),
+          depth - 1,
+          prefix + '  '
+        );
+      }
+    }
+
+    if (filtered.length > 15) {
+      result += `${prefix}... and ${filtered.length - 15} more\n`;
+    }
+  } catch {}
+
+  return result;
+}
+
+async function findKeyFiles(cwd) {
+  const keyFiles = [];
+  const importantFiles = [
+    'package.json',
+    'tsconfig.json',
+    'README.md',
+    'CLAUDE.md',
+    '.env.example',
+    'src/index.ts',
+    'src/index.js',
+    'src/main.ts',
+    'src/main.js',
+    'src/app.ts',
+    'src/app.js',
+    'app/page.tsx',
+    'app/layout.tsx',
+    'pages/index.tsx',
+    'pages/_app.tsx',
+    'prisma/schema.prisma',
+    'drizzle.config.ts',
+    'Dockerfile',
+    'docker-compose.yml'
+  ];
+
+  for (const file of importantFiles) {
+    try {
+      await fs.access(path.join(cwd, file));
+      keyFiles.push(file);
+    } catch {}
+  }
+
+  return keyFiles;
+}
+
+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/docs.js

@@ -0,0 +1,167 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Docs Command
+// Phase K3: AI Documentation Generation
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+export async function docsCommand(options = {}) {
+  const cwd = process.cwd();
+
+  if (options.generate || options.type) {
+    return generateDocs(cwd, options);
+  }
+
+  // Interactive menu
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: 'Documentation options:',
+    choices: [
+      { name: '📝 Generate README.md', value: 'readme' },
+      { name: '📚 Generate API docs', value: 'api' },
+      { name: '🏗️  Generate Architecture docs', value: 'architecture' },
+      { name: '💬 Add JSDoc comments', value: 'jsdoc' },
+      { name: '📦 Generate all docs', value: 'all' },
+      { name: '👋 Exit', value: 'exit' }
+    ]
+  }]);
+
+  if (action === 'exit') return;
+
+  return generateDocs(cwd, { ...options, type: action });
+}
+
+async function generateDocs(cwd, options) {
+  const docType = options.type || 'all';
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  📚 DOCUMENTATION GENERATION                                       │
+│                                                                    │
+│  Type: ${docType.padEnd(56)}│
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  const prompts = {
+    readme: `
+# Generate README.md
+
+Analyze this project and generate a comprehensive README.md:
+
+1. **Project Title & Description**: What does this project do?
+2. **Features**: Key features list with brief descriptions
+3. **Installation**: Step-by-step installation guide
+4. **Usage**: Basic usage examples with code snippets
+5. **API Reference**: Main functions/endpoints (brief overview)
+6. **Configuration**: Environment variables, config files
+7. **Contributing**: How to contribute
+8. **License**: MIT or detected license
+
+Make it professional, clear, and helpful. Include badges if appropriate.
+`,
+    api: `
+# Generate API Documentation
+
+Analyze the codebase and generate API documentation:
+
+1. For each public function/method:
+   - Name, description
+   - Parameters with types
+   - Return value
+   - Example usage
+   - Throws/errors
+
+2. For REST endpoints (if any):
+   - Method, path
+   - Request body
+   - Response format
+   - Status codes
+   - Example requests/responses
+
+3. For React components (if any):
+   - Props with types
+   - Usage examples
+
+Output in Markdown format suitable for docs site.
+Create docs/API.md
+`,
+    architecture: `
+# Generate Architecture Documentation
+
+Analyze and document the architecture:
+
+1. **System Overview**: High-level description
+2. **Directory Structure**: Explain each folder's purpose
+3. **Core Components**: Main modules and their responsibilities
+4. **Data Flow**: How data moves through the system
+5. **Dependencies**: Key dependencies and why they're used
+6. **Diagrams**: Generate Mermaid diagrams for:
+   - Component diagram
+   - Sequence diagram for main flows
+   - Data model (if applicable)
+
+Output in Markdown with Mermaid blocks.
+Create docs/ARCHITECTURE.md
+`,
+    jsdoc: `
+# Add JSDoc Comments
+
+For each function, class, and method in the codebase:
+
+1. Add JSDoc comments with:
+   - @description - What it does
+   - @param for each parameter with type and description
+   - @returns - Return value with type
+   - @throws (if applicable)
+   - @example - Usage example
+
+2. Add type annotations where missing
+3. Don't modify function logic, only add comments
+4. Use TypeScript types in JSDoc if .ts files
+
+Apply to all .js/.ts files in src/
+`,
+    all: `
+# Generate Complete Documentation
+
+Create comprehensive documentation:
+
+1. **README.md** - Project overview, installation, usage
+2. **docs/API.md** - API reference
+3. **docs/ARCHITECTURE.md** - System architecture with diagrams
+4. Add JSDoc comments to key source files
+
+Make documentation professional and thorough.
+`
+  };
+
+  const prompt = prompts[docType] || prompts.all;
+
+  const promptFile = path.join(cwd, '.vibecode', 'docs-prompt.md');
+  await fs.mkdir(path.dirname(promptFile), { recursive: true });
+  await fs.writeFile(promptFile, prompt);
+
+  console.log(chalk.gray('  Generating documentation with Claude Code...\n'));
+
+  await runClaudeCode(prompt, cwd);
+
+  console.log(chalk.green('\n✅ Documentation generated!\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/git.js

@@ -1,10 +1,13 @@
 /**
  * Git Integration for Vibecode CLI
  * Native git commands with enhanced UI and AI-powered commit messages
+ * Phase K7: AI Diff Review
  */
 
-import { exec } from 'child_process';
+import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 
@@ -435,11 +438,16 @@ async function generateCommitMessage(files) {
  * Show diff with syntax highlighting
  */
 async function gitDiff(args, options) {
+  // K7: AI diff review
+  if (options.review || args.includes('--review')) {
+    return aiDiffReview();
+  }
+
   try {
     const file = args[0];
     let cmd = 'git diff';
 
-    if (file) {
+    if (file && file !== '--review') {
       cmd = `git diff -- "${file}"`;
     } else if (options.staged) {
       cmd = 'git diff --cached';
@@ -480,6 +488,99 @@ async function gitDiff(args, options) {
   }
 }
 
+/**
+ * K7: AI Diff Review
+ */
+async function aiDiffReview() {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  🔍 AI DIFF REVIEW                                                 │
+│                                                                    │
+│  Reviewing staged changes...                                      │
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  // Get diff
+  let diff = '';
+  try {
+    const { stdout: stagedDiff } = await execAsync('git diff --staged', { cwd });
+    diff = stagedDiff;
+  } catch {}
+
+  if (!diff.trim()) {
+    // Try unstaged
+    try {
+      const { stdout: unstagedDiff } = await execAsync('git diff', { cwd });
+      diff = unstagedDiff;
+    } catch {}
+  }
+
+  if (!diff.trim()) {
+    console.log(chalk.yellow('\n  No changes to review.\n'));
+    return;
+  }
+
+  // Truncate diff if too long
+  const maxDiffLength = 8000;
+  const truncatedDiff = diff.length > maxDiffLength
+    ? diff.substring(0, maxDiffLength) + '\n... (truncated)'
+    : diff;
+
+  const prompt = `
+# Git Diff Review
+
+Review these code changes:
+
+\`\`\`diff
+${truncatedDiff}
+\`\`\`
+
+## Review Criteria:
+1. **Correctness**: Are there any bugs or logic errors?
+2. **Best Practices**: Does it follow conventions and patterns?
+3. **Security**: Any security concerns introduced?
+4. **Performance**: Any performance issues?
+5. **Tests**: Should tests be added/updated?
+6. **Edge Cases**: Any edge cases not handled?
+
+## Output Format:
+1. **Overall Assessment**: (Good / Concerns / Issues)
+2. **Specific Feedback**: Per file/change feedback
+3. **Suggested Improvements**: What could be better
+4. **Recommended Commit Message**: A conventional commit message for these changes
+
+Review the diff now.
+`;
+
+  const promptFile = path.join(cwd, '.vibecode', 'diff-review-prompt.md');
+  await fs.mkdir(path.dirname(promptFile), { recursive: true });
+  await fs.writeFile(promptFile, prompt);
+
+  console.log(chalk.gray('  Reviewing with Claude Code...\n'));
+
+  await runClaudeCode(prompt, cwd);
+
+  console.log(chalk.green('\n✅ Diff review complete!\n'));
+}
+
+/**
+ * Run Claude Code with prompt
+ */
+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());
+  });
+}
+
 /**
  * Branch management
  */