vibe-code-build/bin/vibe-code.js

Real-time code monitoring with teaching explanations, CLAUDE.md compliance checking, and interactive chat

#!/usr/bin/env node

import { program } from 'commander';
import chalk from 'chalk';
import inquirer from 'inquirer';
import ora from 'ora';
import path from 'path';
import { fileURLToPath } from 'url';
import { startMCPServer } from '../src/mcp-server.js';
import { configureClaudeCode } from '../src/config.js';
import { UnifiedMonitor } from '../src/unified-monitor.js';
import { BuildChecker } from '../src/build-checker.js';
import { DependencyChecker } from '../src/dependency-checker.js';
import { ClaudeChecker } from '../src/claude-checker.js';
import { SecurityChecker } from '../src/security-checker.js';
import { PerformanceOptimizer } from '../src/performance-optimizer.js';
import { CheckFormatter } from '../src/check-formatter.js';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

program
  .name('vibe-code')
  .description('Real-time code monitoring with teaching & analysis')
  .version('7.0.0');

program
  .command('init')
  .description('Initialize Vibe Code in current directory')
  .action(async () => {
    const spinner = ora('Initializing Vibe Code...').start();
    
    try {
      // Configure Claude Code settings
      await configureClaudeCode();
      spinner.succeed('Claude Code configuration updated');
      
      // Start MCP server
      spinner.text = 'Starting MCP server...';
      const server = await startMCPServer();
      spinner.succeed(`MCP server running on port ${server.port}`);
      
      console.log(chalk.green('\n✓ Vibe Code initialized!'));
      console.log(chalk.gray('The teaching agent is now ready to monitor code changes.'));
      console.log(chalk.blue('\nTo stop the server, press Ctrl+C'));
      
    } catch (error) {
      spinner.fail('Initialization failed');
      console.error(chalk.red(error.message));
      process.exit(1);
    }
  });

program
  .command('watch [path]')
  .description('Start unified monitor with mode switching')
  .action(async (watchPath = '.') => {
    const absolutePath = path.resolve(watchPath);
    console.log(chalk.blue(`Starting monitor in: ${absolutePath}`));
    
    const monitor = new UnifiedMonitor(absolutePath);
    await monitor.start();
  });

program
  .command('serve')
  .description('Start MCP server for Claude Code integration')
  .option('-p, --port <port>', 'server port', '3456')
  .action(async (options) => {
    const spinner = ora('Starting MCP server...').start();
    
    try {
      const server = await startMCPServer({ port: parseInt(options.port) });
      spinner.succeed(`MCP server running on port ${server.port}`);
      
      console.log(chalk.gray('\nAdd this to your Claude Code settings:'));
      console.log(chalk.cyan(JSON.stringify({
        "mcp-servers": {
          "teacher": {
            "command": "npx",
            "args": ["vibe-code", "serve"],
            "name": "Vibe Code"
          }
        }
      }, null, 2)));
      
    } catch (error) {
      spinner.fail('Failed to start MCP server');
      console.error(chalk.red(error.message));
      process.exit(1);
    }
  });

program
  .command('check')
  .alias('build')
  .description('Run all code quality checks')
  .option('-b, --build', 'Check if project builds')
  .option('-d, --deps', 'Check dependencies')
  .option('-c, --claude', 'Check CLAUDE.md compliance')
  .option('-s, --security', 'Check security risks')
  .option('-p, --performance', 'Check performance and SEO')
  .option('-a, --all', 'Run all checks (default)')
  .option('--json', 'Output results as JSON')
  .option('--compact', 'Compact output format')
  .action(async (options) => {
    const formatter = new CheckFormatter();
    const results = {};
    
    // If no specific options, run all
    const runAll = options.all || (!options.build && !options.deps && !options.claude && !options.security && !options.performance);
    
    console.log(chalk.bold.cyan('\n🔍 Running Vibe Code Quality Checks...\n'));
    
    try {
      if (runAll || options.build) {
        const spinner = ora('Running build checks...').start();
        const buildChecker = new BuildChecker();
        results.build = await buildChecker.checkAll();
        spinner.succeed('Build checks completed');
      }
      
      if (runAll || options.deps) {
        const spinner = ora('Running dependency checks...').start();
        const depChecker = new DependencyChecker();
        results.dependencies = await depChecker.checkAll();
        spinner.succeed('Dependency checks completed');
      }
      
      if (runAll || options.claude) {
        const spinner = ora('Running CLAUDE.md checks...').start();
        const claudeChecker = new ClaudeChecker();
        results.claude = await claudeChecker.checkAll();
        spinner.succeed('CLAUDE.md checks completed');
      }
      
      if (runAll || options.security) {
        const spinner = ora('Running security checks...').start();
        const securityChecker = new SecurityChecker();
        results.security = await securityChecker.checkAll();
        spinner.succeed('Security checks completed');
      }
      
      if (runAll || options.performance) {
        const spinner = ora('Running performance checks...').start();
        const perfChecker = new PerformanceOptimizer();
        results.performance = await perfChecker.checkAll();
        spinner.succeed('Performance checks completed');
      }
      
      // Format and display results
      if (options.json) {
        console.log(formatter.formatJsonResults(results));
      } else if (options.compact) {
        console.log(formatter.formatCompactResults(results));
      } else {
        console.log(formatter.formatCheckResults(results));
      }
      
      // Exit with error code if there are failures
      const hasFailures = Object.values(results).some(category => 
        Object.values(category || {}).some(result => result?.status === 'failed')
      );
      
      if (hasFailures) {
        process.exit(1);
      }
      
    } catch (error) {
      console.error(chalk.red('\n❌ Check failed:'), error.message);
      process.exit(1);
    }
  });

// Interactive mode when no command specified
if (process.argv.length === 2) {
  (async () => {
    console.log(chalk.bold.cyan('🎓 Vibe Code'));
    console.log(chalk.gray('Real-time code monitoring with teaching & analysis\n'));
    
    const { action } = await inquirer.prompt([
      {
        type: 'list',
        name: 'action',
        message: 'What would you like to do?',
        choices: [
          { name: '🚀 Start Monitoring (with mode switching)', value: 'monitor' },
          { name: '🔍 Run Quality Checks', value: 'check' },
          { name: '⚙️  Configure Claude Code', value: 'configure' },
          { name: '🌐 Start MCP Server', value: 'serve' },
          { name: '❌ Exit', value: 'exit' }
        ]
      }
    ]);
    
    switch (action) {
      case 'monitor':
        program.parse(['', '', 'watch']);
        break;
      case 'check':
        program.parse(['', '', 'check']);
        break;
      case 'configure':
        program.parse(['', '', 'init']);
        break;
      case 'serve':
        program.parse(['', '', 'serve']);
        break;
      case 'exit':
        console.log(chalk.yellow('👋 Goodbye!'));
        process.exit(0);
        break;
    }
  })();
} else {
  program.parse();
}