baseguard 1.0.0

package/src/commands/automation.ts

@@ -0,0 +1,344 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { UIComponents } from '../ui/index.js';
+import { ConfigurationManager } from '../core/configuration.js';
+import { ErrorHandler } from '../core/error-handler.js';
+import { GitHookManager } from '../git/hook-manager.js';
+import { AutomationEngine } from '../git/automation-engine.js';
+import type { AutomationOptions } from '../types/index.js';
+
+/**
+ * Manage git automation and hooks
+ */
+export async function automation(action: string, options?: any): Promise<void> {
+  try {
+    switch (action) {
+      case 'enable':
+        await enableAutomation(options);
+        break;
+      case 'disable':
+        await disableAutomation();
+        break;
+      case 'status':
+        await showAutomationStatus();
+        break;
+      case 'configure':
+        await configureAutomation();
+        break;
+      case 'run':
+        await runAutomation(options);
+        break;
+      default:
+        await showAutomationHelp();
+    }
+  } catch (error) {
+    const apiError = ErrorHandler.handleAPIError(error);
+    ErrorHandler.displayError(apiError);
+    
+    // Provide specific help for automation command issues
+    console.log('\n💡 Automation troubleshooting:');
+    if (action === 'enable') {
+      UIComponents.showList([
+        'Ensure you\'re in a git repository (run "git init" if needed)',
+        'Check that you have a package.json file',
+        'Verify write permissions for .husky directory',
+        'Make sure Husky is installed (npm install husky)'
+      ]);
+    } else if (action === 'run') {
+      UIComponents.showList([
+        'This command is typically called by git hooks automatically',
+        'Check that BaseGuard configuration exists (.baseguardrc.json)',
+        'Verify git hooks are properly installed',
+        'Run "base automation status" to check setup'
+      ]);
+    } else if (action === 'disable') {
+      UIComponents.showList([
+        'Check file permissions for .husky directory',
+        'Verify git repository is properly initialized',
+        'Run "base automation status" to check current state'
+      ]);
+    } else {
+      UIComponents.showList([
+        'Run "base automation status" to check current setup',
+        'Use "base automation --help" to see available commands',
+        'Ensure you\'re in a git repository with BaseGuard configured'
+      ]);
+    }
+    
+    process.exit(1);
+  }
+}
+
+/**
+ * Enable automation with optional configuration
+ */
+async function enableAutomation(options?: { trigger?: string; autoFix?: boolean; autoAnalyze?: boolean }): Promise<void> {
+  console.log(chalk.cyan('🤖 Enabling BaseGuard automation...'));
+  
+  const config = await ConfigurationManager.load();
+  const hookManager = new GitHookManager();
+  
+  // Configure automation settings
+  let trigger: 'pre-commit' | 'pre-push' = config.automation.trigger;
+  let autoFix = config.automation.autoFix;
+  let autoAnalyze = config.automation.autoAnalyze;
+  
+  // Use provided options or prompt for configuration
+  if (options?.trigger) {
+    if (options.trigger === 'pre-commit' || options.trigger === 'pre-push') {
+      trigger = options.trigger;
+    } else {
+      throw new Error('Invalid trigger. Must be "pre-commit" or "pre-push"');
+    }
+  } else if (!config.automation.enabled) {
+    // First time setup - prompt for configuration
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'trigger',
+        message: 'When should BaseGuard check for violations?',
+        choices: [
+          { name: 'Before each commit (pre-commit)', value: 'pre-commit' },
+          { name: 'Before each push (pre-push)', value: 'pre-push' }
+        ],
+        default: trigger
+      },
+      {
+        type: 'confirm',
+        name: 'autoAnalyze',
+        message: 'Enable automatic AI analysis of violations?',
+        default: autoAnalyze,
+        when: () => !!config.apiKeys.gemini
+      },
+      {
+        type: 'confirm',
+        name: 'autoFix',
+        message: 'Enable automatic AI fixing of violations?',
+        default: autoFix,
+        when: () => !!config.apiKeys.jules && !!config.apiKeys.gemini
+      }
+    ]);
+    
+    trigger = answers.trigger;
+    autoAnalyze = answers.autoAnalyze ?? autoAnalyze;
+    autoFix = answers.autoFix ?? autoFix;
+  }
+  
+  if (options?.autoFix !== undefined) {
+    autoFix = options.autoFix;
+  }
+  
+  if (options?.autoAnalyze !== undefined) {
+    autoAnalyze = options.autoAnalyze;
+  }
+  
+  // Update configuration
+  config.automation.enabled = true;
+  config.automation.trigger = trigger;
+  config.automation.autoAnalyze = autoAnalyze;
+  config.automation.autoFix = autoFix;
+  
+  await ConfigurationManager.save(config);
+  
+  // Install git hooks
+  await hookManager.installHooks(trigger);
+  
+  UIComponents.showSuccessBox(`Automation enabled with ${trigger} trigger`);
+  
+  // Show configuration summary
+  console.log(chalk.cyan('\n📋 Automation Configuration:'));
+  console.log(`  Trigger: ${chalk.white(trigger)}`);
+  console.log(`  Auto-analyze: ${autoAnalyze ? chalk.green('enabled') : chalk.red('disabled')}`);
+  console.log(`  Auto-fix: ${autoFix ? chalk.green('enabled') : chalk.red('disabled')}`);
+  console.log(`  Block commits: ${config.automation.blockCommit ? chalk.green('enabled') : chalk.red('disabled')}`);
+  
+  if (!config.apiKeys.gemini) {
+    console.log(chalk.yellow('\n⚠️ Gemini API key not configured. Run "base config" to set up AI features.'));
+  }
+  
+  if (!config.apiKeys.jules) {
+    console.log(chalk.yellow('⚠️ Jules API key not configured. Run "base config" to set up AI fixing.'));
+  }
+}
+
+/**
+ * Disable automation
+ */
+async function disableAutomation(): Promise<void> {
+  console.log(chalk.cyan('🤖 Disabling BaseGuard automation...'));
+  
+  const config = await ConfigurationManager.load();
+  const hookManager = new GitHookManager();
+  
+  // Update configuration
+  config.automation.enabled = false;
+  await ConfigurationManager.save(config);
+  
+  // Uninstall git hooks
+  await hookManager.uninstallHooks();
+  
+  UIComponents.showSuccessBox('Automation disabled');
+}
+
+/**
+ * Show automation status
+ */
+async function showAutomationStatus(): Promise<void> {
+  const config = await ConfigurationManager.load();
+  const hookManager = new GitHookManager();
+  
+  console.log(chalk.cyan('🤖 BaseGuard Automation Status\n'));
+  
+  // Configuration status
+  console.log(chalk.white('Configuration:'));
+  console.log(`  Enabled: ${config.automation.enabled ? chalk.green('✓') : chalk.red('✗')}`);
+  console.log(`  Trigger: ${chalk.white(config.automation.trigger)}`);
+  console.log(`  Auto-analyze: ${config.automation.autoAnalyze ? chalk.green('✓') : chalk.red('✗')}`);
+  console.log(`  Auto-fix: ${config.automation.autoFix ? chalk.green('✓') : chalk.red('✗')}`);
+  console.log(`  Block commits: ${config.automation.blockCommit ? chalk.green('✓') : chalk.red('✗')}`);
+  
+  // Git hooks status
+  const hooksInstalled = await hookManager.areHooksInstalled();
+  const installedHooks = await hookManager.getInstalledHooks();
+  
+  console.log(chalk.white('\nGit Hooks:'));
+  console.log(`  Installed: ${hooksInstalled ? chalk.green('✓') : chalk.red('✗')}`);
+  if (installedHooks.length > 0) {
+    console.log(`  Active hooks: ${chalk.white(installedHooks.join(', '))}`);
+  }
+  
+  // API keys status
+  console.log(chalk.white('\nAPI Keys:'));
+  console.log(`  Gemini: ${config.apiKeys.gemini ? chalk.green('✓ configured') : chalk.red('✗ not configured')}`);
+  console.log(`  Jules: ${config.apiKeys.jules ? chalk.green('✓ configured') : chalk.red('✗ not configured')}`);
+  
+  // Recommendations
+  if (config.automation.enabled && !hooksInstalled) {
+    console.log(chalk.yellow('\n⚠️ Automation is enabled but git hooks are not installed. Run "base automation enable" to fix this.'));
+  }
+  
+  if (config.automation.autoAnalyze && !config.apiKeys.gemini) {
+    console.log(chalk.yellow('⚠️ Auto-analyze is enabled but Gemini API key is not configured.'));
+  }
+  
+  if (config.automation.autoFix && (!config.apiKeys.jules || !config.apiKeys.gemini)) {
+    console.log(chalk.yellow('⚠️ Auto-fix is enabled but API keys are not configured.'));
+  }
+}
+
+/**
+ * Configure automation settings
+ */
+async function configureAutomation(): Promise<void> {
+  console.log(chalk.cyan('🤖 Configuring BaseGuard automation...\n'));
+  
+  const config = await ConfigurationManager.load();
+  const hookManager = new GitHookManager();
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'enabled',
+      message: 'Enable automation?',
+      default: config.automation.enabled
+    },
+    {
+      type: 'list',
+      name: 'trigger',
+      message: 'When should BaseGuard check for violations?',
+      choices: [
+        { name: 'Before each commit (pre-commit)', value: 'pre-commit' },
+        { name: 'Before each push (pre-push)', value: 'pre-push' }
+      ],
+      default: config.automation.trigger,
+      when: (answers) => answers.enabled
+    },
+    {
+      type: 'confirm',
+      name: 'autoAnalyze',
+      message: 'Enable automatic AI analysis of violations?',
+      default: config.automation.autoAnalyze,
+      when: (answers) => answers.enabled && !!config.apiKeys.gemini
+    },
+    {
+      type: 'confirm',
+      name: 'autoFix',
+      message: 'Enable automatic AI fixing of violations?',
+      default: config.automation.autoFix,
+      when: (answers) => answers.enabled && !!config.apiKeys.jules && !!config.apiKeys.gemini
+    },
+    {
+      type: 'confirm',
+      name: 'blockCommit',
+      message: 'Block commits when violations are found?',
+      default: config.automation.blockCommit,
+      when: (answers) => answers.enabled
+    }
+  ]);
+  
+  // Update configuration
+  const oldTrigger = config.automation.trigger;
+  
+  config.automation.enabled = answers.enabled ?? config.automation.enabled;
+  config.automation.trigger = answers.trigger ?? config.automation.trigger;
+  config.automation.autoAnalyze = answers.autoAnalyze ?? config.automation.autoAnalyze;
+  config.automation.autoFix = answers.autoFix ?? config.automation.autoFix;
+  config.automation.blockCommit = answers.blockCommit ?? config.automation.blockCommit;
+  
+  await ConfigurationManager.save(config);
+  
+  // Update git hooks if needed
+  if (config.automation.enabled) {
+    if (oldTrigger !== config.automation.trigger) {
+      await hookManager.updateHookConfiguration(oldTrigger, config.automation.trigger);
+    } else {
+      await hookManager.installHooks(config.automation.trigger);
+    }
+  } else {
+    await hookManager.uninstallHooks();
+  }
+  
+  UIComponents.showSuccessBox('Automation configuration updated');
+  
+  // Show updated status
+  await showAutomationStatus();
+}
+
+/**
+ * Run automation manually (used by git hooks)
+ */
+async function runAutomation(options: { trigger?: string; strict?: boolean } = {}): Promise<void> {
+  const trigger = options.trigger as 'pre-commit' | 'pre-push' || 'pre-commit';
+  
+  const automationOptions: AutomationOptions = {
+    trigger,
+    strict: options.strict
+  };
+  
+  const engine = new AutomationEngine();
+  await engine.run(automationOptions);
+}
+
+/**
+ * Show automation help
+ */
+async function showAutomationHelp(): Promise<void> {
+  console.log(chalk.cyan('🤖 BaseGuard Automation Commands\n'));
+  
+  console.log(chalk.white('Usage:'));
+  console.log('  base automation <command> [options]\n');
+  
+  console.log(chalk.white('Commands:'));
+  console.log('  enable     Enable automation with git hooks');
+  console.log('  disable    Disable automation and remove git hooks');
+  console.log('  status     Show current automation status');
+  console.log('  configure  Interactive configuration of automation settings');
+  console.log('  run        Run automation manually (used by git hooks)\n');
+  
+  console.log(chalk.white('Examples:'));
+  console.log('  base automation enable');
+  console.log('  base automation enable --trigger pre-push');
+  console.log('  base automation disable');
+  console.log('  base automation status');
+  console.log('  base automation configure');
+}

package/src/commands/check.ts

@@ -0,0 +1,299 @@
+import { UIComponents } from '../ui/index.js';
+import { BaseGuard } from '../core/baseguard.js';
+import { ConfigurationManager } from '../core/configuration.js';
+import { ConfigurationRecovery } from '../core/configuration-recovery.js';
+import { GracefulDegradationManager } from '../core/graceful-degradation-manager.js';
+import { SystemErrorHandler } from '../core/system-error-handler.js';
+import { ErrorHandler } from '../core/error-handler.js';
+import { logger } from '../core/debug-logger.js';
+import { glob } from 'glob';
+import chalk from 'chalk';
+import type { Violation } from '../types/index.js';
+
+/**
+ * Check for compatibility violations with enhanced error recovery
+ */
+export async function check(options: {
+  strict?: boolean;
+  files?: string;
+  format?: 'table' | 'json' | 'junit';
+  debug?: boolean;
+  offline?: boolean;
+}): Promise<void> {
+  const categoryLogger = logger.createCategoryLogger('check-command');
+  const sessionId = logger.startSession('check-command');
+  
+  try {
+    // Enable debug logging if requested
+    if (options.debug) {
+      logger.enableDebug();
+    }
+    
+    // Set offline mode if requested
+    if (options.offline) {
+      SystemErrorHandler.setOfflineMode(true);
+    }
+    
+    UIComponents.showHeader();
+    categoryLogger.info('Starting compatibility check', { options });
+    
+    // Load configuration with recovery
+    const config = await SystemErrorHandler.withRetry(
+      async () => {
+        try {
+          return await ConfigurationManager.load();
+        } catch (error) {
+          categoryLogger.warn('Configuration load failed, attempting recovery', { error });
+          
+          // Attempt configuration recovery
+          const recoveryResult = await ConfigurationRecovery.recoverConfiguration({
+            createBackup: true,
+            validateConfig: true,
+            migrateVersion: true,
+            repairCorruption: true,
+            useDefaults: true
+          });
+          
+          if (recoveryResult.success && recoveryResult.config) {
+            if (recoveryResult.warnings.length > 0) {
+              console.log(chalk.yellow('⚠️ Configuration was recovered with warnings:'));
+              recoveryResult.warnings.forEach(warning => {
+                console.log(chalk.yellow(`   • ${warning}`));
+              });
+            }
+            return recoveryResult.config;
+          } else {
+            throw new Error(`Configuration recovery failed: ${recoveryResult.errors.join(', ')}`);
+          }
+        }
+      },
+      { operation: 'load_configuration' },
+      2 // max retries
+    );
+    
+    // Initialize BaseGuard with error handling
+    const baseGuard = await SystemErrorHandler.handleGracefully(
+      async () => new BaseGuard(config),
+      null,
+      { operation: 'initialize_baseguard' }
+    );
+    
+    if (!baseGuard) {
+      throw new Error('Failed to initialize BaseGuard');
+    }
+    
+    const spinner = UIComponents.createSpinner('Scanning files for compatibility issues...');
+    spinner.start();
+    
+    // Get files to check with error recovery
+    const filePattern = options.files || '**/*.{js,jsx,ts,tsx,vue,svelte,css,html}';
+    const files = await SystemErrorHandler.handleGracefully(
+      async () => {
+        return await glob(filePattern, {
+          ignore: [
+            'node_modules/**',
+            'dist/**',
+            'build/**',
+            '.git/**',
+            '**/*.min.js',
+            '**/*.min.css'
+          ]
+        });
+      },
+      [], // fallback to empty array
+      { operation: 'find_files', details: { pattern: filePattern } }
+    );
+    
+    if (files.length === 0) {
+      spinner.fail('No files found to check');
+      
+      // Show degradation status if in limited mode
+      const mode = GracefulDegradationManager.getCurrentMode();
+      if (mode && mode.name !== 'Full Functionality') {
+        console.log(chalk.yellow(`\n⚠️ Currently in ${mode.name} mode`));
+        if (mode.limitations.length > 0) {
+          console.log(chalk.yellow('Limitations:'));
+          mode.limitations.forEach(limitation => {
+            console.log(chalk.yellow(`   • ${limitation}`));
+          });
+        }
+      }
+      
+      UIComponents.showWarningBox('No files matched the pattern. Try adjusting the --files option.');
+      return;
+    }
+    
+    spinner.text = `Analyzing ${files.length} files...`;
+    categoryLogger.info(`Found ${files.length} files to analyze`);
+    
+    // Scan for violations with enhanced error handling
+    const violations = await SystemErrorHandler.handleGracefully(
+      async () => {
+        return await baseGuard.checkViolations(files);
+      },
+      [], // fallback to empty violations
+      { operation: 'check_violations', details: { fileCount: files.length } },
+      {
+        logError: true,
+        showWarning: true,
+        attemptRecovery: true
+      }
+    );
+    
+    spinner.stop();
+    categoryLogger.info(`Scan completed, found ${violations.length} violations`);
+    
+    // Display results based on format with error handling
+    await SystemErrorHandler.handleGracefully(
+      async () => {
+        switch (options.format) {
+          case 'json':
+            console.log(JSON.stringify(violations, null, 2));
+            break;
+          case 'junit':
+            UIComponents.showJUnitReport(violations);
+            break;
+          default:
+            UIComponents.showViolations(violations);
+            break;
+        }
+      },
+      undefined,
+      { operation: 'display_results', details: { format: options.format, violationCount: violations.length } },
+      { logError: true, showWarning: false }
+    );
+    
+    // Show summary with degradation mode info
+    if (violations.length === 0) {
+      UIComponents.showSuccessBox('🎉 No compatibility violations found!');
+      
+      // Show mode info if not in full functionality
+      const mode = GracefulDegradationManager.getCurrentMode();
+      if (mode && mode.name !== 'Full Functionality') {
+        console.log(chalk.dim(`\nScan completed in ${mode.name} mode`));
+      }
+    } else {
+      const summary = {
+        total: violations.length,
+        byBrowser: violations.reduce((acc, v) => {
+          acc[v.browser] = (acc[v.browser] || 0) + 1;
+          return acc;
+        }, {} as Record<string, number>),
+        byFile: violations.reduce((acc, v) => {
+          acc[v.file] = (acc[v.file] || 0) + 1;
+          return acc;
+        }, {} as Record<string, number>)
+      };
+      
+      console.log(chalk.yellow('\n📊 Summary:'));
+      console.log(`  Total violations: ${summary.total}`);
+      console.log(`  Files affected: ${Object.keys(summary.byFile).length}`);
+      console.log(`  Browsers affected: ${Object.keys(summary.byBrowser).join(', ')}`);
+      
+      // Show appropriate next steps based on current mode
+      const mode = GracefulDegradationManager.getCurrentMode();
+      if (mode?.capabilities.autoFix) {
+        UIComponents.showInfoBox('Run "base fix" to automatically fix these issues with AI assistance.');
+      } else {
+        UIComponents.showInfoBox('AI fixing is not available in current mode. Review violations manually or restore full functionality.');
+      }
+      
+      if (mode && mode.name !== 'Full Functionality') {
+        console.log(chalk.dim(`\nScan completed in ${mode.name} mode`));
+        if (mode.limitations.length > 0) {
+          console.log(chalk.yellow('Current limitations:'));
+          mode.limitations.forEach(limitation => {
+            console.log(chalk.yellow(`   • ${limitation}`));
+          });
+        }
+      }
+    }
+    
+    // Create auto-backup if violations found
+    if (violations.length > 0) {
+      await SystemErrorHandler.handleGracefully(
+        async () => {
+          const backup = await baseGuard.createConfigBackup();
+          if (backup) {
+            categoryLogger.debug('Created configuration backup', { backup });
+          }
+        },
+        undefined,
+        { operation: 'create_backup' },
+        { logError: false, showWarning: false }
+      );
+    }
+    
+    // Exit with error code if violations found and strict mode
+    if (options.strict && violations.length > 0) {
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    categoryLogger.error('Check command failed', { error });
+    
+    const apiError = ErrorHandler.handleAPIError(error);
+    ErrorHandler.displayError(apiError);
+    
+    // Handle service failures gracefully
+    if (ErrorHandler.shouldUseFallbackMode(apiError)) {
+      await GracefulDegradationManager.handleServiceFailure('check', apiError.type);
+    }
+    
+    // Provide specific help for check command issues
+    console.log('\n💡 Troubleshooting:');
+    if (apiError.type === 'configuration') {
+      UIComponents.showList([
+        'Run "base init" to set up BaseGuard configuration',
+        'Run "base config recover" to attempt automatic recovery',
+        'Check that .baseguardrc.json exists and is valid',
+        'Run "base config validate" to check configuration'
+      ]);
+    } else if (options.files) {
+      UIComponents.showList([
+        `No files found matching pattern: ${options.files}`,
+        'Try a different file pattern (e.g., "src/**/*.ts")',
+        'Check that files exist in the specified locations',
+        'Use --debug flag for detailed logging'
+      ]);
+    } else {
+      UIComponents.showList([
+        'Check that you\'re in a project directory',
+        'Verify file permissions for reading project files',
+        'Try running with a specific file pattern: --files "src/**/*.js"',
+        'Use --offline flag if network issues are suspected',
+        'Use --debug flag for detailed error information'
+      ]);
+    }
+    
+    // Show fallback suggestions
+    if (ErrorHandler.shouldUseFallbackMode(apiError)) {
+      console.log('\n🔄 Fallback options:');
+      UIComponents.showList(ErrorHandler.getFallbackSuggestions(apiError.type));
+    }
+    
+    // Show recovery options
+    console.log('\n🔧 Recovery options:');
+    UIComponents.showList([
+      'Run "base status" to check system health',
+      'Run "base config recover" to fix configuration issues',
+      'Run with --debug flag to get detailed error information',
+      'Check logs in .baseguard/logs/ for more details'
+    ]);
+    
+    // Generate debug report if in debug mode
+    if (options.debug) {
+      try {
+        const reportFile = await logger.generateDebugReport();
+        console.log(chalk.dim(`\nDebug report saved to: ${reportFile}`));
+      } catch (reportError) {
+        // Ignore report generation errors
+      }
+    }
+    
+    process.exit(1);
+  } finally {
+    // End logging session
+    await logger.endSession();
+  }
+}