baseguard 1.0.0

package/src/commands/config.ts

@@ -0,0 +1,365 @@
+import { UIComponents, Prompts } from '../ui/index.js';
+import { ConfigurationManager, ApiKeyManager, GitignoreManager } from '../core/index.js';
+import { ErrorHandler } from '../core/error-handler.js';
+
+/**
+ * Manage BaseGuard configuration
+ */
+export async function config(action: string, options?: {
+  add?: string;
+  remove?: string;
+  preset?: string;
+  file?: string;
+  format?: string;
+}): Promise<void> {
+  try {
+    switch (action) {
+      case 'show':
+        await showConfiguration();
+        break;
+      case 'list':
+        await listConfiguration(options?.format);
+        break;
+      case 'set-keys':
+        await setupApiKeys();
+        break;
+      case 'targets':
+        await updateTargets(options);
+        break;
+      case 'automation':
+        await updateAutomation();
+        break;
+      case 'update':
+        await updateConfiguration();
+        break;
+      case 'validate':
+        await validateConfiguration();
+        break;
+      case 'security':
+        await checkSecurity();
+        break;
+      case 'backup':
+        await backupConfiguration();
+        break;
+      case 'restore':
+        await restoreConfiguration(options?.file);
+        break;
+      default:
+        UIComponents.showErrorBox(`Unknown config action: ${action}`);
+        showConfigHelp();
+        process.exit(1);
+    }
+    
+  } catch (error) {
+    const apiError = ErrorHandler.handleAPIError(error);
+    ErrorHandler.displayError(apiError);
+    
+    // Provide specific help for config command issues
+    console.log('\n💡 Configuration help:');
+    if (action === 'set-keys') {
+      UIComponents.showList([
+        'Get Gemini API key from https://aistudio.google.com',
+        'Get Jules API key from https://jules.google.com',
+        'Ensure API keys are valid and have proper permissions',
+        'Check your internet connection for key validation'
+      ]);
+    } else if (action === 'targets') {
+      UIComponents.showList([
+        'Use format "browser version" (e.g., "chrome 100")',
+        'Available browsers: chrome, safari, firefox, edge',
+        'Use "baseline" for Baseline-only support',
+        'Check available presets with "base config targets --help"'
+      ]);
+    } else if (action === 'validate') {
+      UIComponents.showList([
+        'Check .baseguardrc.json file exists',
+        'Verify JSON syntax is correct',
+        'Run "base init" to recreate configuration if needed'
+      ]);
+    } else {
+      UIComponents.showList([
+        'Run "base config show" to see current configuration',
+        'Use "base config --help" to see available commands',
+        'Check file permissions in the current directory'
+      ]);
+    }
+    
+    process.exit(1);
+  }
+}
+
+async function showConfiguration(): Promise<void> {
+  const display = await ConfigurationManager.getConfigurationDisplay();
+  
+  UIComponents.showConfiguration(display.config);
+  
+  // Show security status
+  if (!display.security.configIgnored) {
+    UIComponents.showWarningBox('Configuration file is not in .gitignore - API keys may be exposed!');
+    
+    if (display.security.recommendations.length > 0) {
+      console.log('\nSecurity recommendations:');
+      UIComponents.showList(display.security.recommendations);
+    }
+  }
+  
+  // Show validation errors if any
+  if (!display.validation.valid) {
+    UIComponents.showErrorBox('Configuration validation failed');
+    UIComponents.showList(display.validation.errors);
+  }
+}
+
+async function listConfiguration(format?: string): Promise<void> {
+  const display = await ConfigurationManager.getConfigurationDisplay();
+  
+  if (format === 'json') {
+    // Output as JSON for programmatic use
+    const output = {
+      configuration: display.config,
+      security: display.security,
+      validation: display.validation,
+      status: {
+        configured: display.config.apiKeys.jules !== null || display.config.apiKeys.gemini !== null,
+        automationEnabled: display.config.automation.enabled,
+        targetCount: display.config.targets.length
+      }
+    };
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  
+  // Default table format
+  UIComponents.showSectionHeader('BaseGuard Configuration Summary');
+  
+  // Configuration overview
+  console.log('📋 Configuration:');
+  console.log(`  Version: ${display.config.version}`);
+  console.log(`  Targets: ${display.config.targets.length} browser(s)`);
+  console.log(`  API Keys: ${display.config.apiKeys.jules ? '✓' : '✗'} Jules, ${display.config.apiKeys.gemini ? '✓' : '✗'} Gemini`);
+  console.log(`  Automation: ${display.config.automation.enabled ? '✓ enabled' : '✗ disabled'}`);
+  
+  // Browser targets
+  console.log('\n🎯 Browser Targets:');
+  display.config.targets.forEach(target => {
+    console.log(`  • ${target.browser} ${target.minVersion}`);
+  });
+  
+  // Automation settings
+  console.log('\n🤖 Automation Settings:');
+  console.log(`  Enabled: ${display.config.automation.enabled ? '✓' : '✗'}`);
+  console.log(`  Trigger: ${display.config.automation.trigger}`);
+  console.log(`  Auto-analyze: ${display.config.automation.autoAnalyze ? '✓' : '✗'}`);
+  console.log(`  Auto-fix: ${display.config.automation.autoFix ? '✓' : '✗'}`);
+  console.log(`  Block commits: ${display.config.automation.blockCommit ? '✓' : '✗'}`);
+  
+  // Security status
+  console.log('\n🔒 Security Status:');
+  console.log(`  .gitignore exists: ${display.security.gitignoreExists ? '✓' : '✗'}`);
+  console.log(`  Config file ignored: ${display.security.configIgnored ? '✓' : '✗'}`);
+  
+  // Validation status
+  console.log('\n✅ Validation Status:');
+  console.log(`  Configuration valid: ${display.validation.valid ? '✓' : '✗'}`);
+  
+  // Show warnings/errors
+  if (!display.security.configIgnored) {
+    UIComponents.showWarningBox('Configuration file is not in .gitignore - API keys may be exposed!');
+  }
+  
+  if (!display.validation.valid) {
+    UIComponents.showErrorBox('Configuration validation failed');
+    UIComponents.showList(display.validation.errors);
+  }
+  
+  if (display.security.recommendations.length > 0) {
+    console.log('\n💡 Recommendations:');
+    UIComponents.showList(display.security.recommendations);
+  }
+}
+
+async function setupApiKeys(): Promise<void> {
+  const apiKeys = await Prompts.setupApiKeys();
+  
+  if (apiKeys.julesApiKey || apiKeys.geminiApiKey) {
+    await ApiKeyManager.storeApiKeys({
+      jules: apiKeys.julesApiKey,
+      gemini: apiKeys.geminiApiKey
+    });
+    
+    UIComponents.showSuccessBox('API keys updated successfully');
+    
+    // Show security reminder
+    const security = await GitignoreManager.isConfigSecure();
+    if (!security.configIgnored) {
+      UIComponents.showWarningBox('Remember to add .baseguardrc.json to .gitignore to protect your API keys');
+    }
+  } else {
+    UIComponents.showInfoBox('No API keys were configured');
+  }
+}
+
+async function updateTargets(options?: { add?: string; remove?: string; preset?: string }): Promise<void> {
+  if (options?.add) {
+    // Add a specific browser target
+    const target = ConfigurationManager.parseBrowserTarget(options.add);
+    if (!target) {
+      UIComponents.showErrorBox(`Invalid browser target format: ${options.add}`);
+      UIComponents.showInfoBox('Format: "browser version" (e.g., "chrome 100", "safari baseline")');
+      return;
+    }
+    
+    await ConfigurationManager.addBrowserTarget(target);
+    UIComponents.showSuccessBox(`Added browser target: ${target.browser} ${target.minVersion}`);
+    return;
+  }
+  
+  if (options?.remove) {
+    // Remove a specific browser target
+    await ConfigurationManager.removeBrowserTarget(options.remove);
+    UIComponents.showSuccessBox(`Removed browser target: ${options.remove}`);
+    return;
+  }
+  
+  if (options?.preset) {
+    // Set preset targets
+    const presetName = options.preset as any;
+    const availablePresets = ConfigurationManager.getAvailablePresets();
+    
+    if (!availablePresets.includes(presetName)) {
+      UIComponents.showErrorBox(`Invalid preset: ${options.preset}`);
+      UIComponents.showInfoBox(`Available presets: ${availablePresets.join(', ')}`);
+      return;
+    }
+    
+    await ConfigurationManager.updateWithPreset(presetName);
+    UIComponents.showSuccessBox(`Updated to ${presetName} preset`);
+    UIComponents.showInfoBox(ConfigurationManager.getPresetDescription(presetName));
+    return;
+  }
+  
+  // Interactive target configuration
+  const targets = await Prompts.promptCustomTargets();
+  await ConfigurationManager.updateWithCustomTargets(targets);
+  UIComponents.showSuccessBox('Browser targets updated successfully');
+}
+
+async function updateAutomation(): Promise<void> {
+  const automation = await Prompts.promptAutomationSettings();
+  const config = await ConfigurationManager.load();
+  config.automation = { ...config.automation, ...automation };
+  await ConfigurationManager.save(config);
+  UIComponents.showSuccessBox('Automation settings updated successfully');
+}
+
+async function updateConfiguration(): Promise<void> {
+  const currentConfig = await ConfigurationManager.load();
+  const updates = await Prompts.promptConfigUpdate(currentConfig);
+  
+  if (Object.keys(updates).length === 0) {
+    UIComponents.showInfoBox('No changes made');
+    return;
+  }
+  
+  let config = currentConfig;
+  
+  // Apply updates
+  for (const [key, value] of Object.entries(updates)) {
+    switch (key) {
+      case 'targets':
+        await ConfigurationManager.updateWithCustomTargets(value as any);
+        config = await ConfigurationManager.load(); // Reload after update
+        break;
+      case 'apiKeys':
+        const apiKeys = value as any;
+        if (apiKeys.julesApiKey) config.apiKeys.jules = apiKeys.julesApiKey;
+        if (apiKeys.geminiApiKey) config.apiKeys.gemini = apiKeys.geminiApiKey;
+        break;
+      case 'automation':
+        config.automation = { ...config.automation, ...(value as any) };
+        break;
+    }
+  }
+  
+  await ConfigurationManager.save(config);
+  UIComponents.showSuccessBox('Configuration updated successfully');
+}
+
+async function validateConfiguration(): Promise<void> {
+  const display = await ConfigurationManager.getConfigurationDisplay();
+  
+  if (display.validation.valid) {
+    UIComponents.showSuccessBox('Configuration is valid');
+  } else {
+    UIComponents.showErrorBox('Configuration validation failed');
+    UIComponents.showList(display.validation.errors);
+    process.exit(1);
+  }
+}
+
+async function checkSecurity(): Promise<void> {
+  const security = await GitignoreManager.isConfigSecure();
+  
+  UIComponents.showSectionHeader('Security Status');
+  
+  console.log(`✓ .gitignore exists: ${security.gitignoreExists ? 'Yes' : 'No'}`);
+  console.log(`✓ Config file ignored: ${security.configIgnored ? 'Yes' : 'No'}`);
+  
+  if (security.recommendations.length > 0) {
+    console.log('\nRecommendations:');
+    UIComponents.showList(security.recommendations);
+  } else {
+    UIComponents.showSuccessBox('Configuration is secure');
+  }
+}
+
+async function backupConfiguration(): Promise<void> {
+  try {
+    const backupFile = await ConfigurationManager.backupConfiguration();
+    UIComponents.showSuccessBox(`Configuration backed up to: ${backupFile}`);
+  } catch (error) {
+    UIComponents.showErrorBox(`Backup failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}
+
+async function restoreConfiguration(backupFile?: string): Promise<void> {
+  if (!backupFile) {
+    UIComponents.showErrorBox('Backup file path is required');
+    console.log('Usage: base config restore --file <backup-file>');
+    process.exit(1);
+  }
+  
+  try {
+    await ConfigurationManager.restoreConfiguration(backupFile);
+    UIComponents.showSuccessBox('Configuration restored successfully');
+  } catch (error) {
+    UIComponents.showErrorBox(`Restore failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}
+
+function showConfigHelp(): void {
+  UIComponents.showSectionHeader('Configuration Commands');
+  UIComponents.showList([
+    'base config show - Display current configuration',
+    'base config list - List configuration summary',
+    'base config list --format json - List configuration as JSON',
+    'base config set-keys - Set up API keys for AI services',
+    'base config targets - Configure browser targets',
+    'base config targets --add "chrome 100" - Add browser target',
+    'base config targets --remove chrome - Remove browser target',
+    'base config targets --preset baseline-widely - Set preset targets',
+    'base config automation - Configure git automation',
+    'base config update - Interactive configuration update',
+    'base config validate - Validate configuration file',
+    'base config security - Check configuration security',
+    'base config backup - Create configuration backup',
+    'base config restore --file <backup> - Restore from backup',
+    '',
+    'Shorthand commands:',
+    'base add "chrome 100" - Add browser target',
+    'base remove chrome - Remove browser target',
+    'base list - List configuration summary'
+  ]);
+}

package/src/commands/fix.ts

@@ -0,0 +1,234 @@
+import chalk from 'chalk';
+import { UIComponents } from '../ui/index.js';
+import { BaseGuard } from '../core/index.js';
+import { ConfigurationManager } from '../core/configuration.js';
+import { ErrorHandler } from '../core/error-handler.js';
+import { JulesImplementer } from '../ai/jules-implementer.js';
+import { GeminiAnalyzer } from '../ai/gemini-analyzer.js';
+import { glob } from 'glob';
+
+/**
+ * Fix violations with AI analysis and implementation
+ */
+export async function fix(options: {
+  auto?: boolean;
+  analyzeOnly?: boolean;
+  files?: string;
+}): Promise<void> {
+  try {
+    console.log(chalk.cyan('🔧 BaseGuard AI Fix\n'));
+    
+    // Load configuration
+    const config = await ConfigurationManager.load();
+    
+    // Check API keys
+    if (!config.apiKeys.jules) {
+      UIComponents.showErrorBox('Jules API key not configured. Run "base init" to set up API keys.');
+      process.exit(1);
+    }
+    
+    if (!config.apiKeys.gemini) {
+      UIComponents.showErrorBox('Gemini API key not configured. Run "base init" to set up API keys.');
+      process.exit(1);
+    }
+    
+    // Initialize services
+    const baseGuard = new BaseGuard(config);
+    const julesImplementer = new JulesImplementer(config.apiKeys.jules);
+    const geminiAnalyzer = new GeminiAnalyzer(config.apiKeys.gemini);
+    
+    // Check GitHub integration
+    const isGitHubSetup = await julesImplementer.isGitHubIntegrationSetup();
+    if (!isGitHubSetup) {
+      console.log(chalk.yellow('⚠️ Jules GitHub integration not set up'));
+      
+      const { default: inquirer } = await import('inquirer');
+      const { setupNow } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'setupNow',
+          message: 'Would you like to set up Jules GitHub integration now?',
+          default: true
+        }
+      ]);
+      
+      if (setupNow) {
+        await julesImplementer.setupGitHubIntegration();
+      } else {
+        console.log(chalk.yellow('GitHub integration required for Jules fixing. Exiting.'));
+        process.exit(0);
+      }
+    }
+    
+    // Step 1: Check for violations
+    console.log(chalk.cyan('🔍 Scanning for compatibility violations...'));
+    
+    // Get files to fix
+    const filePattern = options.files || '**/*.{js,jsx,ts,tsx,vue,svelte,css,html}';
+    const files = await glob(filePattern, {
+      ignore: [
+        'node_modules/**',
+        'dist/**',
+        'build/**',
+        '.git/**',
+        '**/*.min.js',
+        '**/*.min.css'
+      ]
+    });
+    
+    const violations = await baseGuard.checkViolations(files);
+    
+    if (violations.length === 0) {
+      UIComponents.showSuccessBox('No compatibility violations found!');
+      return;
+    }
+    
+    console.log(chalk.yellow(`\n⚠️ Found ${violations.length} compatibility violations\n`));
+    UIComponents.showViolations(violations);
+    
+    // Step 2: Analyze violations with Gemini
+    console.log(chalk.cyan('\n🧠 Analyzing violations with AI...'));
+    const analyses = await geminiAnalyzer.analyzeViolations(violations);
+    
+    // If analyze-only mode, show analysis and exit
+    if (options.analyzeOnly) {
+      console.log(chalk.cyan('\n📋 Analysis Results:\n'));
+      analyses.forEach((analysis, index) => {
+        console.log(chalk.yellow(`${index + 1}. ${analysis.violation.feature} in ${analysis.violation.file}`));
+        console.log(`   Impact: ${analysis.userImpact}`);
+        console.log(`   Strategy: ${analysis.fixStrategy}`);
+        console.log(`   Confidence: ${Math.round(analysis.confidence * 100)}%\n`);
+      });
+      return;
+    }
+    
+    // Step 3: Generate and apply fixes with Jules
+    console.log(chalk.cyan('\n🤖 Generating fixes with Jules AI...'));
+    const results = await julesImplementer.generateAndApplyFixes(violations, analyses);
+    
+    // Show results
+    console.log(chalk.cyan('\n📊 Fix Results:\n'));
+    
+    if (results.applied.length > 0) {
+      console.log(chalk.green(`✅ Applied ${results.applied.length} fixes:`));
+      results.applied.forEach(fix => {
+        console.log(chalk.green(`   • ${fix.filePath} - ${fix.violation.feature}`));
+      });
+      console.log();
+    }
+    
+    if (results.skipped.length > 0) {
+      console.log(chalk.yellow(`⏭️ Skipped ${results.skipped.length} fixes:`));
+      results.skipped.forEach(fix => {
+        console.log(chalk.yellow(`   • ${fix.filePath} - ${fix.violation.feature}`));
+      });
+      console.log();
+    }
+    
+    if (results.failed.length > 0) {
+      console.log(chalk.red(`❌ Failed ${results.failed.length} fixes:`));
+      results.failed.forEach(({ fix, error }) => {
+        console.log(chalk.red(`   • ${fix.filePath} - ${fix.violation.feature}: ${error}`));
+      });
+      console.log();
+    }
+    
+    // Show rollback option if fixes were applied
+    if (results.applied.length > 0) {
+      const { default: inquirer } = await import('inquirer');
+      const { showRollback } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'showRollback',
+          message: 'Would you like to see rollback options?',
+          default: false
+        }
+      ]);
+      
+      if (showRollback) {
+        const { rollbackAction } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'rollbackAction',
+            message: 'Rollback options:',
+            choices: [
+              { name: 'Keep all fixes', value: 'keep' },
+              { name: 'Rollback all fixes', value: 'rollback_all' },
+              { name: 'Rollback specific fixes', value: 'rollback_specific' }
+            ]
+          }
+        ]);
+        
+        if (rollbackAction === 'rollback_all') {
+          await julesImplementer.rollbackAllFixes();
+          UIComponents.showSuccessBox('All fixes have been rolled back');
+        } else if (rollbackAction === 'rollback_specific') {
+          const appliedFiles = julesImplementer.getAppliedFixes();
+          const { filesToRollback } = await inquirer.prompt([
+            {
+              type: 'checkbox',
+              name: 'filesToRollback',
+              message: 'Select fixes to rollback:',
+              choices: appliedFiles.map(file => ({ name: file, value: file }))
+            }
+          ]);
+          
+          for (const file of filesToRollback) {
+            await julesImplementer.rollbackFix(file);
+          }
+          
+          if (filesToRollback.length > 0) {
+            UIComponents.showSuccessBox(`Rolled back ${filesToRollback.length} fixes`);
+          }
+        }
+      }
+    }
+    
+    UIComponents.showSuccessBox('Fix process completed!');
+    
+  } catch (error) {
+    const apiError = ErrorHandler.handleAPIError(error);
+    ErrorHandler.displayError(apiError);
+    
+    // Provide specific help for fix command issues
+    console.log('\n💡 Troubleshooting:');
+    if (apiError.type === 'authentication') {
+      UIComponents.showList([
+        'Check your API keys with "base config show"',
+        'Update API keys with "base config set-keys"',
+        'Verify API keys are valid and not expired',
+        'Ensure you have proper permissions for Jules and Gemini'
+      ]);
+    } else if (apiError.type === 'configuration') {
+      UIComponents.showList([
+        'Run "base init" to set up BaseGuard configuration',
+        'Configure API keys with "base config set-keys"',
+        'Check GitHub integration for Jules fixing'
+      ]);
+    } else if (apiError.type === 'network') {
+      UIComponents.showList([
+        'Check your internet connection',
+        'Verify firewall allows access to AI services',
+        'Try again when network connection is stable'
+      ]);
+    } else {
+      UIComponents.showList([
+        'Try running "base check" for basic violation detection',
+        'Verify your API keys are configured correctly',
+        'Check the documentation for troubleshooting steps'
+      ]);
+    }
+    
+    // Show fallback suggestions
+    if (ErrorHandler.shouldUseFallbackMode(apiError)) {
+      console.log('\n🔄 Alternative options:');
+      UIComponents.showList([
+        'Run "base check" for offline compatibility checking',
+        'Review violations manually using browser compatibility tables',
+        'Try AI features again when services are available'
+      ]);
+    }
+    
+    process.exit(1);
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,6 @@
+// CLI command exports
+export * from './init.js';
+export * from './check.js';
+export * from './fix.js';
+export * from './config.js';
+export * from './automation.js';