@nclamvn/vibecode-cli 2.0.0 → 2.2.0

package/src/commands/templates.js

@@ -0,0 +1,397 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Templates Command
+// Browse and use project templates
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import {
+  TEMPLATES,
+  getCategories,
+  getTemplatesByCategory,
+  searchTemplates,
+  getTemplate,
+  getCategoryIcon
+} from '../templates/index.js';
+
+/**
+ * Templates command entry point
+ */
+export async function templatesCommand(options = {}) {
+  // Show template info
+  if (options.info) {
+    return showTemplateInfo(options.info);
+  }
+
+  // Preview template
+  if (options.preview) {
+    return previewTemplate(options.preview);
+  }
+
+  // Search templates
+  if (options.search) {
+    return searchAndShow(options.search);
+  }
+
+  // Default: List all templates
+  return listTemplates(options);
+}
+
+/**
+ * List all templates grouped by category
+ */
+async function listTemplates(options) {
+  const categories = getCategories();
+  const totalTemplates = Object.keys(TEMPLATES).length;
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  📦 VIBECODE TEMPLATE GALLERY                                      │
+│                                                                    │
+│  ${String(totalTemplates).padEnd(2)} professional templates ready to use                      │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  // Group by category
+  for (const category of categories) {
+    const templates = getTemplatesByCategory(category.id);
+    const icon = getCategoryIcon(category.id);
+
+    console.log(chalk.white.bold(`\n  ${icon} ${category.name.toUpperCase()} (${category.count})`));
+    console.log(chalk.gray('  ' + '─'.repeat(60)));
+
+    for (const template of templates) {
+      const id = chalk.green(template.id.padEnd(22));
+      const desc = chalk.gray(truncate(template.description, 40));
+      console.log(`    ${id} ${desc}`);
+    }
+  }
+
+  console.log(chalk.gray(`
+  ─────────────────────────────────────────────────────────────────────
+
+  Usage:
+    ${chalk.cyan('vibecode templates --info <id>')}        View template details
+    ${chalk.cyan('vibecode templates --search <query>')}   Search templates
+    ${chalk.cyan('vibecode go --template <id>')}           Use a template
+    ${chalk.cyan('vibecode go -t <id> --name "X"')}        With customization
+
+  Example:
+    ${chalk.cyan('vibecode go --template landing-saas')}
+    ${chalk.cyan('vibecode go -t dashboard-admin --name "My Dashboard"')}
+  `));
+
+  // Interactive mode unless quiet
+  if (!options.quiet) {
+    await interactiveMode();
+  }
+}
+
+/**
+ * Interactive template browser
+ */
+async function interactiveMode() {
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: 'What would you like to do?',
+    choices: [
+      { name: '📋 View template details', value: 'info' },
+      { name: '🚀 Use a template', value: 'use' },
+      { name: '🔍 Search templates', value: 'search' },
+      { name: '👋 Exit', value: 'exit' }
+    ]
+  }]);
+
+  if (action === 'exit') {
+    return;
+  }
+
+  if (action === 'info') {
+    const { templateId } = await inquirer.prompt([{
+      type: 'list',
+      name: 'templateId',
+      message: 'Select template to view:',
+      choices: Object.values(TEMPLATES).map(t => ({
+        name: `${getCategoryIcon(t.category)} ${t.name} - ${truncate(t.description, 35)}`,
+        value: t.id
+      })),
+      pageSize: 15
+    }]);
+    return showTemplateInfo(templateId);
+  }
+
+  if (action === 'use') {
+    const { templateId } = await inquirer.prompt([{
+      type: 'list',
+      name: 'templateId',
+      message: 'Select template to use:',
+      choices: Object.values(TEMPLATES).map(t => ({
+        name: `${getCategoryIcon(t.category)} ${t.name}`,
+        value: t.id
+      })),
+      pageSize: 15
+    }]);
+
+    const template = getTemplate(templateId);
+
+    // Ask for customization if template has variables
+    let customOptions = {};
+    if (Object.keys(template.variables).length > 0) {
+      const { customize } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'customize',
+        message: 'Customize template options?',
+        default: false
+      }]);
+
+      if (customize) {
+        customOptions = await promptForVariables(template);
+      }
+    }
+
+    console.log(chalk.cyan(`
+  ─────────────────────────────────────────────────────────────────────
+
+  Run this command to create your project:
+
+    ${chalk.white.bold(`vibecode go --template ${templateId}${formatCustomOptions(customOptions)}`)}
+
+  `));
+  }
+
+  if (action === 'search') {
+    const { query } = await inquirer.prompt([{
+      type: 'input',
+      name: 'query',
+      message: 'Search:'
+    }]);
+
+    const results = searchTemplates(query);
+    if (results.length === 0) {
+      console.log(chalk.yellow('\n  No templates found matching your search.\n'));
+    } else {
+      console.log(chalk.green(`\n  Found ${results.length} template(s):\n`));
+      for (const t of results) {
+        const icon = getCategoryIcon(t.category);
+        console.log(`    ${icon} ${chalk.green(t.id.padEnd(22))} ${chalk.gray(truncate(t.description, 40))}`);
+      }
+      console.log('');
+
+      // Offer to view details
+      const { viewDetails } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'viewDetails',
+        message: 'View template details?',
+        default: true
+      }]);
+
+      if (viewDetails && results.length > 0) {
+        const { templateId } = await inquirer.prompt([{
+          type: 'list',
+          name: 'templateId',
+          message: 'Select template:',
+          choices: results.map(t => ({ name: t.name, value: t.id }))
+        }]);
+        return showTemplateInfo(templateId);
+      }
+    }
+  }
+}
+
+/**
+ * Show detailed template information
+ */
+async function showTemplateInfo(templateId) {
+  const template = getTemplate(templateId);
+
+  if (!template) {
+    console.log(chalk.red(`\n  ❌ Template "${templateId}" not found.\n`));
+    console.log(chalk.gray(`  Run ${chalk.cyan('vibecode templates')} to see available templates.\n`));
+    return;
+  }
+
+  const icon = getCategoryIcon(template.category);
+
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  ${icon} ${template.name.padEnd(56)}│
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  console.log(chalk.white(`  ${template.description}\n`));
+
+  console.log(chalk.gray('  Category:    ') + chalk.white(template.category));
+  console.log(chalk.gray('  Tags:        ') + chalk.cyan(template.tags.join(', ')));
+  console.log(chalk.gray('  Stack:       ') + chalk.yellow(template.stack.join(', ')));
+
+  console.log(chalk.gray('\n  Features:'));
+  for (const feature of template.features) {
+    console.log(chalk.green(`    ✓ ${feature}`));
+  }
+
+  // Show customization options
+  if (Object.keys(template.variables).length > 0) {
+    console.log(chalk.gray('\n  Customization Options:'));
+    for (const [key, config] of Object.entries(template.variables)) {
+      const typeInfo = config.type === 'select'
+        ? `[${config.options.join('|')}]`
+        : `(${config.type})`;
+      console.log(chalk.yellow(`    --${key}`) + chalk.gray(` ${typeInfo}`));
+      console.log(chalk.gray(`      ${config.description}`));
+      console.log(chalk.gray(`      Default: "${config.default}"`));
+    }
+  }
+
+  console.log(chalk.gray(`
+  ─────────────────────────────────────────────────────────────────────
+
+  Use this template:
+    ${chalk.cyan(`vibecode go --template ${templateId}`)}
+
+  With customization:
+    ${chalk.cyan(`vibecode go -t ${templateId} --name "MyProject"`)}
+  `));
+
+  // Prompt to use
+  const { useNow } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'useNow',
+    message: 'Use this template now?',
+    default: false
+  }]);
+
+  if (useNow) {
+    // Ask for customization
+    let customOptions = {};
+    if (Object.keys(template.variables).length > 0) {
+      customOptions = await promptForVariables(template);
+    }
+
+    // Import and call go command
+    const { goCommand } = await import('./go.js');
+    await goCommand('', { template: templateId, ...customOptions });
+  }
+}
+
+/**
+ * Prompt user for template variables
+ */
+async function promptForVariables(template) {
+  const questions = [];
+
+  for (const [key, config] of Object.entries(template.variables)) {
+    if (config.type === 'select') {
+      questions.push({
+        type: 'list',
+        name: key,
+        message: config.description,
+        choices: config.options,
+        default: config.default
+      });
+    } else if (config.type === 'boolean') {
+      questions.push({
+        type: 'confirm',
+        name: key,
+        message: config.description,
+        default: config.default
+      });
+    } else if (config.type === 'number') {
+      questions.push({
+        type: 'number',
+        name: key,
+        message: config.description,
+        default: config.default
+      });
+    } else {
+      questions.push({
+        type: 'input',
+        name: key,
+        message: config.description,
+        default: config.default
+      });
+    }
+  }
+
+  return inquirer.prompt(questions);
+}
+
+/**
+ * Search and display results
+ */
+async function searchAndShow(query) {
+  const results = searchTemplates(query);
+
+  if (results.length === 0) {
+    console.log(chalk.yellow(`\n  No templates found for "${query}".\n`));
+    console.log(chalk.gray(`  Try: landing, dashboard, ecommerce, blog, portfolio, app\n`));
+    return;
+  }
+
+  console.log(chalk.green(`\n  Found ${results.length} template(s) matching "${query}":\n`));
+
+  for (const t of results) {
+    const icon = getCategoryIcon(t.category);
+    console.log(`  ${icon} ${chalk.green(t.id.padEnd(22))} ${chalk.gray(truncate(t.description, 40))}`);
+  }
+
+  console.log(chalk.gray(`
+  ─────────────────────────────────────────────────────────────────────
+
+  View details:
+    ${chalk.cyan(`vibecode templates --info ${results[0].id}`)}
+
+  Use template:
+    ${chalk.cyan(`vibecode go --template ${results[0].id}`)}
+  `));
+}
+
+/**
+ * Preview template (open in browser)
+ */
+async function previewTemplate(templateId) {
+  const template = getTemplate(templateId);
+
+  if (!template) {
+    console.log(chalk.red(`\n  ❌ Template "${templateId}" not found.\n`));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n  🖼️  Preview: ${template.name}`));
+  console.log(chalk.gray(`  URL: ${template.preview}\n`));
+
+  if (template.preview.startsWith('http')) {
+    try {
+      const open = (await import('open')).default;
+      await open(template.preview);
+      console.log(chalk.green('  ✓ Opened preview in browser.\n'));
+    } catch (e) {
+      console.log(chalk.yellow('  ⚠ Could not open browser. Visit URL manually.\n'));
+    }
+  } else {
+    console.log(chalk.gray('  (Preview not available yet)\n'));
+  }
+}
+
+/**
+ * Truncate string to max length
+ */
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + '...';
+}
+
+/**
+ * Format custom options for display
+ */
+function formatCustomOptions(options) {
+  const parts = [];
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === 'string') {
+      parts.push(`--${key} "${value}"`);
+    } else {
+      parts.push(`--${key} ${value}`);
+    }
+  }
+  return parts.length > 0 ? ' ' + parts.join(' ') : '';
+}

package/src/commands/test.js

@@ -0,0 +1,194 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Test Command
+// Phase K2: AI Test 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 testCommand(targetPath, options = {}) {
+  const cwd = process.cwd();
+
+  // Generate tests
+  if (options.generate) {
+    return generateTests(cwd, targetPath, options);
+  }
+
+  // Run tests (pass through to npm test)
+  if (options.run) {
+    const { exec } = await import('child_process');
+    const child = exec('npm test', { cwd });
+    child.stdout?.pipe(process.stdout);
+    child.stderr?.pipe(process.stderr);
+    return new Promise(resolve => child.on('close', resolve));
+  }
+
+  // Coverage
+  if (options.coverage) {
+    const { exec } = await import('child_process');
+    const child = exec('npm run test:coverage || npm test -- --coverage', { cwd });
+    child.stdout?.pipe(process.stdout);
+    child.stderr?.pipe(process.stderr);
+    return new Promise(resolve => child.on('close', resolve));
+  }
+
+  // Default: show menu
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: 'Test options:',
+    choices: [
+      { name: '🧪 Run tests (npm test)', value: 'run' },
+      { name: '✨ Generate tests for file/folder', value: 'generate' },
+      { name: '📊 Show coverage', value: 'coverage' },
+      { name: '👋 Exit', value: 'exit' }
+    ]
+  }]);
+
+  if (action === 'run') {
+    return testCommand(null, { run: true });
+  }
+  if (action === 'generate') {
+    const { target } = await inquirer.prompt([{
+      type: 'input',
+      name: 'target',
+      message: 'Path to generate tests for:',
+      default: 'src/'
+    }]);
+    return generateTests(cwd, target, options);
+  }
+  if (action === 'coverage') {
+    return testCommand(null, { coverage: true });
+  }
+}
+
+async function generateTests(cwd, targetPath, options) {
+  console.log(chalk.cyan(`
+╭────────────────────────────────────────────────────────────────────╮
+│  🧪 TEST GENERATION                                                │
+│                                                                    │
+│  Target: ${(targetPath || 'src/').padEnd(52)}│
+│                                                                    │
+╰────────────────────────────────────────────────────────────────────╯
+  `));
+
+  // Detect test framework
+  const framework = await detectTestFramework(cwd);
+  console.log(chalk.gray(`  Test framework: ${framework}\n`));
+
+  // Get files to generate tests for
+  const files = await getFilesToTest(cwd, targetPath || 'src/');
+
+  if (files.length === 0) {
+    console.log(chalk.yellow('  No files found to generate tests for.\n'));
+    return;
+  }
+
+  console.log(chalk.gray(`  Found ${files.length} files\n`));
+
+  const prompt = `
+# Test Generation Request
+
+## Project: ${path.basename(cwd)}
+## Test Framework: ${framework}
+
+## Files to Generate Tests For:
+${files.map(f => `- ${f}`).join('\n')}
+
+## Instructions:
+1. Read each source file
+2. Generate comprehensive tests including:
+   - Unit tests for each function/method
+   - Edge cases (null, undefined, empty, boundary values)
+   - Error handling tests
+   - Mock external dependencies
+   - Integration tests where appropriate
+
+3. Use ${framework} syntax and conventions
+4. Follow AAA pattern (Arrange, Act, Assert)
+5. Add descriptive test names
+6. Include setup/teardown if needed
+
+## Output:
+Create test files in __tests__/ or *.test.ts/js format.
+For each source file, create corresponding test file.
+
+Generate tests now.
+`;
+
+  const promptFile = path.join(cwd, '.vibecode', 'test-gen-prompt.md');
+  await fs.mkdir(path.dirname(promptFile), { recursive: true });
+  await fs.writeFile(promptFile, prompt);
+
+  console.log(chalk.gray('  Generating tests with Claude Code...\n'));
+
+  await runClaudeCode(prompt, cwd);
+
+  console.log(chalk.green('\n✅ Tests generated!'));
+  console.log(chalk.gray('  Run: npm test\n'));
+}
+
+async function detectTestFramework(cwd) {
+  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.vitest) return 'vitest';
+    if (deps.jest) return 'jest';
+    if (deps.mocha) return 'mocha';
+    if (deps['@testing-library/react']) return 'jest + @testing-library/react';
+    if (deps.ava) return 'ava';
+    if (deps.tap) return 'tap';
+    if (deps.uvu) return 'uvu';
+
+    return 'jest'; // default
+  } catch {
+    return 'jest';
+  }
+}
+
+async function getFilesToTest(cwd, targetPath) {
+  const files = [];
+  const fullPath = path.join(cwd, targetPath);
+
+  async function scan(dir) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue;
+        if (entry.name.includes('.test.') || entry.name.includes('.spec.')) continue;
+        if (entry.name === '__tests__') continue;
+        if (entry.name === 'node_modules') continue;
+        if (entry.name === 'dist' || entry.name === 'build') continue;
+
+        const entryPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          await scan(entryPath);
+        } else if (/\.(js|ts|jsx|tsx)$/.test(entry.name)) {
+          files.push(path.relative(cwd, entryPath));
+        }
+      }
+    } catch {}
+  }
+
+  await scan(fullPath);
+  return files.slice(0, 20); // Limit
+}
+
+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());
+  });
+}