baseguard 1.0.0 → 1.0.1

package/bin/base.js

@@ -2,7 +2,7 @@
 
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { init, check, fix, config, automation } from '../dist/commands/index.js';
+import { init, check, fix, config, automation, status, diagnostics } from '../dist/commands/index.js';
 import { showTerminalHeader, showVersionInfo, showGlobalHelp } from '../dist/ui/index.js';
 import { StartupOptimizer } from '../dist/core/startup-optimizer.js';
 
@@ -84,6 +84,8 @@ program
   .option('--strict', 'Exit with error code if violations are found (useful for CI/CD)')
   .option('--files <pattern>', 'File pattern to check using glob syntax', '**/*.{js,jsx,ts,tsx,vue,svelte,css,html}')
   .option('--format <format>', 'Output format for results', 'table')
+  .option('--debug', 'Enable debug logging for troubleshooting')
+  .option('--offline', 'Run in offline mode (no network requests)')
   .addHelpText('after', `
 ${chalk.cyan('Output Formats:')}
   ${chalk.white('table')}    Human-readable table format (default)
@@ -280,6 +282,39 @@ ${chalk.cyan('Automation Settings:')}
 `)
   .action(() => config('automation'));
 
+configCmd
+  .command('recover')
+  .description('Attempt automatic recovery of corrupted configuration')
+  .option('--backup', 'Create backup before recovery')
+  .option('--interactive', 'Run interactive recovery wizard')
+  .addHelpText('after', `
+${chalk.cyan('Recovery Features:')}
+  • Automatic detection of configuration issues
+  • Repair of corrupted JSON syntax
+  • Migration from older configuration versions
+  • Validation and structure repair
+  • Backup creation before changes
+
+${chalk.cyan('Recovery Process:')}
+  1. Validates current configuration
+  2. Creates backup if requested
+  3. Attempts automatic repair
+  4. Migrates to current version
+  5. Validates final result
+
+${chalk.cyan('Examples:')}
+  ${chalk.dim('
+</content>
+</file>)} base config recover                ${chalk.gray('# Automatic recovery')}
+  ${chalk.dim('
+</content>
+</file>)} base config recover --backup       ${chalk.gray('# Create backup first')}
+  ${chalk.dim('
+</content>
+</file>)} base config recover --interactive  ${chalk.gray('# Interactive wizard')}
+`)
+  .action((options) => config('recover', options));
+
 // Automation and git hooks
 const autoCmd = program
   .command('automation')
@@ -421,6 +456,85 @@ ${chalk.cyan('Examples:')}
 `)
   .action((options) => config('list', options));
 
+// System status and health
+program
+  .command('status')
+  .description('Show BaseGuard system status and health information')
+  .option('--verbose', 'Show detailed status information')
+  .option('--services', 'Check external service availability')
+  .option('--config', 'Show configuration status and validation')
+  .option('--errors', 'Show error summary and recent issues')
+  .addHelpText('after', `
+${chalk.cyan('Status Information:')}
+  • Overall system health (healthy/degraded/critical)
+  • Component status (configuration, services, errors)
+  • Current degradation mode and limitations
+  • Service availability (network, APIs)
+  • Configuration validation results
+  • Error summary and recent issues
+  • Performance information
+  • Recovery recommendations
+
+${chalk.cyan('Examples:')}
+  ${chalk.dim('
+</content>
+</file>)} base status                    ${chalk.gray('# Show basic system status')}
+  ${chalk.dim('
+</content>
+</file>)} base status --verbose          ${chalk.gray('# Show detailed information')}
+  ${chalk.dim('
+</content>
+</file>)} base status --services         ${chalk.gray('# Check service availability')}
+  ${chalk.dim('
+</content>
+</file>)} base status --config           ${chalk.gray('# Show configuration status')}
+  ${chalk.dim('
+</content>
+</file>)} base status --errors           ${chalk.gray('# Show error information')}
+
+${chalk.cyan('Health Levels:')}
+  ${chalk.green('✅ Healthy')}    All systems operational
+  ${chalk.yellow('⚠️ Degraded')}   Some features limited
+  ${chalk.red('❌ Critical')}   Major issues detected
+`)
+  .action(async (options) => {
+    await startupPromise;
+    return status(options);
+  });
+
+// System diagnostics
+program
+  .command('diagnostics')
+  .alias('diag')
+  .description('Run comprehensive system diagnostics and recovery')
+  .addHelpText('after', `
+${chalk.cyan('Diagnostic Features:')}
+  • Generate detailed debug report
+  • Run configuration recovery wizard
+  • Check service availability
+  • Show error log summary
+  • Clean up old files and caches
+  • Provide recovery recommendations
+
+${chalk.cyan('What this does:')}
+  1. Creates comprehensive debug report
+  2. Attempts automatic configuration recovery
+  3. Checks all external services
+  4. Analyzes error logs for patterns
+  5. Cleans up temporary files
+  6. Provides actionable recommendations
+
+${chalk.cyan('Use when:')}
+  • BaseGuard is not working correctly
+  • You're experiencing frequent errors
+  • Need to troubleshoot issues
+  • Want to optimize performance
+`)
+  .action(async () => {
+    await startupPromise;
+    return diagnostics();
+  });
+
 // Add version command with detailed info
 program
   .command('version')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baseguard",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "BaseGuard - Never ship incompatible code again. Intelligent browser compatibility enforcement with AI-powered analysis and autonomous fixing.",
   "main": "dist/index.js",
   "bin": {
@@ -77,4 +77,4 @@
     "url": "https://github.com/ebuka1017/baseguard/issues"
   },
   "homepage": "https://github.com/ebuka1017/baseguard#readme"
-}
+}

package/src/commands/config.ts

@@ -1,6 +1,8 @@
 import { UIComponents, Prompts } from '../ui/index.js';
 import { ConfigurationManager, ApiKeyManager, GitignoreManager } from '../core/index.js';
+import { ConfigurationRecovery } from '../core/configuration-recovery.js';
 import { ErrorHandler } from '../core/error-handler.js';
+import chalk from 'chalk';
 
 /**
  * Manage BaseGuard configuration
@@ -11,6 +13,8 @@ export async function config(action: string, options?: {
   preset?: string;
   file?: string;
   format?: string;
+  backup?: boolean;
+  interactive?: boolean;
 }): Promise<void> {
   try {
     switch (action) {
@@ -44,6 +48,9 @@ export async function config(action: string, options?: {
       case 'restore':
         await restoreConfiguration(options?.file);
         break;
+      case 'recover':
+        await recoverConfiguration(options);
+        break;
       default:
         UIComponents.showErrorBox(`Unknown config action: ${action}`);
         showConfigHelp();
@@ -339,6 +346,89 @@ async function restoreConfiguration(backupFile?: string): Promise<void> {
   }
 }
 
+async function recoverConfiguration(options?: { backup?: boolean; interactive?: boolean }): Promise<void> {
+  try {
+    console.log(chalk.cyan('🔧 BaseGuard Configuration Recovery\n'));
+    
+    if (options?.interactive) {
+      // Run interactive recovery wizard
+      await ConfigurationRecovery.runRecoveryWizard();
+      return;
+    }
+    
+    // Automatic recovery
+    console.log(chalk.cyan('Attempting automatic configuration recovery...'));
+    
+    const recoveryResult = await ConfigurationRecovery.recoverConfiguration({
+      createBackup: options?.backup ?? true,
+      validateConfig: true,
+      migrateVersion: true,
+      repairCorruption: true,
+      useDefaults: true
+    });
+    
+    if (recoveryResult.success) {
+      UIComponents.showSuccessBox('Configuration recovered successfully');
+      
+      if (recoveryResult.backupCreated) {
+        console.log(chalk.dim(`Backup created: ${recoveryResult.backupCreated}`));
+      }
+      
+      if (recoveryResult.warnings.length > 0) {
+        console.log(chalk.yellow('\n⚠️ Recovery warnings:'));
+        recoveryResult.warnings.forEach(warning => {
+          console.log(chalk.yellow(`   • ${warning}`));
+        });
+      }
+      
+      // Show recovered configuration
+      console.log(chalk.cyan('\n📋 Recovered Configuration:'));
+      if (recoveryResult.config) {
+        console.log(`   Version: ${recoveryResult.config.version}`);
+        console.log(`   Targets: ${recoveryResult.config.targets.length} browser(s)`);
+        console.log(`   API Keys: Jules ${recoveryResult.config.apiKeys.jules ? '✓' : '✗'}, Gemini ${recoveryResult.config.apiKeys.gemini ? '✓' : '✗'}`);
+        console.log(`   Automation: ${recoveryResult.config.automation.enabled ? 'Enabled' : 'Disabled'}`);
+      }
+      
+    } else {
+      UIComponents.showErrorBox('Configuration recovery failed');
+      
+      console.log(chalk.red('\n❌ Recovery errors:'));
+      recoveryResult.errors.forEach(error => {
+        console.log(chalk.red(`   • ${error}`));
+      });
+      
+      console.log(chalk.cyan('\n💡 Manual recovery options:'));
+      console.log(chalk.cyan('   • Run "base config recover --interactive" for guided recovery'));
+      console.log(chalk.cyan('   • Run "base init" to create a fresh configuration'));
+      console.log(chalk.cyan('   • Manually edit .baseguardrc.json file'));
+      console.log(chalk.cyan('   • Restore from backup if available'));
+      
+      // Show available backups
+      const backups = await ConfigurationRecovery.listBackups();
+      if (backups.length > 0) {
+        console.log(chalk.cyan('\n📦 Available backups:'));
+        backups.slice(0, 3).forEach(backup => {
+          console.log(chalk.cyan(`   • ${backup.timestamp.toLocaleString()} (${backup.source})`));
+        });
+        console.log(chalk.cyan('\n   Use "base config restore --file <backup-file>" to restore'));
+      }
+      
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    UIComponents.showErrorBox(`Recovery process failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    
+    console.log(chalk.cyan('\n🆘 Emergency recovery options:'));
+    console.log(chalk.cyan('   • Delete .baseguardrc.json and run "base init"'));
+    console.log(chalk.cyan('   • Check file permissions in your project directory'));
+    console.log(chalk.cyan('   • Run "base diagnostics" for comprehensive troubleshooting'));
+    
+    process.exit(1);
+  }
+}
+
 function showConfigHelp(): void {
   UIComponents.showSectionHeader('Configuration Commands');
   UIComponents.showList([
@@ -356,6 +446,8 @@ function showConfigHelp(): void {
     'base config security - Check configuration security',
     'base config backup - Create configuration backup',
     'base config restore --file <backup> - Restore from backup',
+    'base config recover - Attempt automatic configuration recovery',
+    'base config recover --interactive - Run interactive recovery wizard',
     '',
     'Shorthand commands:',
     'base add "chrome 100" - Add browser target',

package/src/commands/index.ts

@@ -3,4 +3,5 @@ export * from './init.js';
 export * from './check.js';
 export * from './fix.js';
 export * from './config.js';
-export * from './automation.js';
+export * from './automation.js';
+export { status, diagnostics } from './status.js';

package/src/commands/status.ts

@@ -0,0 +1,307 @@
+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 { logger } from '../core/debug-logger.js';
+import { UIComponents } from '../ui/components.js';
+import chalk from 'chalk';
+
+/**
+ * Show BaseGuard system status and health
+ */
+export async function status(options: {
+  verbose?: boolean;
+  services?: boolean;
+  config?: boolean;
+  errors?: boolean;
+}): Promise<void> {
+  const categoryLogger = logger.createCategoryLogger('status-command');
+  
+  try {
+    UIComponents.showHeader();
+    console.log(chalk.cyan('🔍 BaseGuard System Status\n'));
+    
+    // Load configuration with recovery if needed
+    let config;
+    try {
+      config = await ConfigurationManager.load();
+    } catch (error) {
+      console.log(chalk.red('❌ Configuration Error'));
+      console.log(chalk.dim(`   ${error instanceof Error ? error.message : 'Unknown error'}`));
+      
+      if (options.config) {
+        console.log(chalk.cyan('\n🔧 Configuration Recovery Options:'));
+        console.log(chalk.cyan('   • Run "base config recover" to attempt automatic recovery'));
+        console.log(chalk.cyan('   • Run "base init" to create a new configuration'));
+        console.log(chalk.cyan('   • Check .baseguardrc.json file manually'));
+      }
+      
+      return;
+    }
+    
+    // Initialize BaseGuard
+    const baseGuard = new BaseGuard(config);
+    
+    // Show system health
+    const health = await baseGuard.getHealthStatus();
+    
+    // Overall status
+    const statusIcon = health.overall === 'healthy' ? '✅' : health.overall === 'degraded' ? '⚠️' : '❌';
+    const statusColor = health.overall === 'healthy' ? chalk.green : health.overall === 'degraded' ? chalk.yellow : chalk.red;
+    
+    console.log(statusColor(`${statusIcon} Overall Status: ${health.overall.toUpperCase()}`));
+    console.log(chalk.dim(`   Degradation Mode: ${health.degradationMode}`));
+    
+    // Component status
+    console.log(chalk.cyan('\n📊 Component Status:'));
+    for (const [component, status] of Object.entries(health.components)) {
+      const componentIcon = status.status === 'healthy' ? '✅' : status.status === 'degraded' ? '⚠️' : '❌';
+      console.log(`   ${componentIcon} ${component}: ${status.status}`);
+      
+      if (options.verbose && status.details) {
+        if (status.details.errors?.length > 0) {
+          console.log(chalk.dim(`      Errors: ${status.details.errors.slice(0, 3).join(', ')}`));
+        }
+        if (status.details.error) {
+          console.log(chalk.dim(`      Error: ${status.details.error}`));
+        }
+        if (status.details.lastCheck) {
+          const age = Math.round((Date.now() - status.details.lastCheck) / 1000);
+          console.log(chalk.dim(`      Last Check: ${age}s ago`));
+        }
+      }
+    }
+    
+    // Service status (if requested)
+    if (options.services) {
+      console.log(chalk.cyan('\n🌐 Service Status:'));
+      const serviceStatus = GracefulDegradationManager.getServiceStatus();
+      
+      for (const [service, info] of serviceStatus) {
+        const serviceIcon = info.available ? '✅' : '❌';
+        const age = Math.round((Date.now() - info.lastCheck) / 1000);
+        console.log(`   ${serviceIcon} ${service}: ${info.available ? 'Available' : 'Unavailable'} (${age}s ago)`);
+        
+        if (!info.available && info.error && options.verbose) {
+          console.log(chalk.dim(`      Error: ${info.error}`));
+        }
+      }
+      
+      // Refresh service status
+      console.log(chalk.dim('\n🔄 Refreshing service status...'));
+      await GracefulDegradationManager.refreshServiceStatus();
+    }
+    
+    // Configuration status (if requested)
+    if (options.config) {
+      console.log(chalk.cyan('\n⚙️ Configuration Status:'));
+      
+      const configIntegrity = await ConfigurationRecovery.validateIntegrity();
+      const configIcon = configIntegrity.valid ? '✅' : '❌';
+      console.log(`   ${configIcon} Configuration File: ${configIntegrity.valid ? 'Valid' : 'Invalid'}`);
+      
+      if (!configIntegrity.valid) {
+        console.log(chalk.red('   Errors:'));
+        configIntegrity.errors.forEach(error => {
+          console.log(chalk.red(`      • ${error}`));
+        });
+        
+        console.log(chalk.cyan('   Suggestions:'));
+        configIntegrity.suggestions.forEach(suggestion => {
+          console.log(chalk.cyan(`      • ${suggestion}`));
+        });
+      }
+      
+      // Show configuration details
+      if (options.verbose) {
+        console.log(chalk.dim('\n   Configuration Details:'));
+        console.log(chalk.dim(`      Version: ${config.version}`));
+        console.log(chalk.dim(`      Targets: ${config.targets.length} browser(s)`));
+        console.log(chalk.dim(`      API Keys: Jules ${config.apiKeys.jules ? '✓' : '✗'}, Gemini ${config.apiKeys.gemini ? '✓' : '✗'}`));
+        console.log(chalk.dim(`      Automation: ${config.automation.enabled ? 'Enabled' : 'Disabled'}`));
+      }
+      
+      // Show available backups
+      const backups = await ConfigurationRecovery.listBackups();
+      if (backups.length > 0) {
+        console.log(chalk.dim(`\n   Available Backups: ${backups.length}`));
+        if (options.verbose) {
+          backups.slice(0, 3).forEach(backup => {
+            console.log(chalk.dim(`      • ${backup.timestamp.toLocaleString()} (${backup.source})`));
+          });
+        }
+      }
+    }
+    
+    // Error summary (if requested)
+    if (options.errors) {
+      console.log(chalk.cyan('\n🚨 Error Summary:'));
+      
+      const errorSummary = logger.getErrorSummary();
+      console.log(`   Total Errors: ${errorSummary.totalErrors}`);
+      console.log(`   Total Warnings: ${errorSummary.totalWarnings}`);
+      
+      if (errorSummary.totalErrors > 0) {
+        console.log(chalk.red('\n   Error Categories:'));
+        for (const [category, count] of Object.entries(errorSummary.errorsByCategory)) {
+          console.log(chalk.red(`      ${category}: ${count}`));
+        }
+        
+        if (options.verbose && errorSummary.recentErrors.length > 0) {
+          console.log(chalk.red('\n   Recent Errors:'));
+          errorSummary.recentErrors.slice(0, 3).forEach(error => {
+            console.log(chalk.red(`      • ${error.message} (${error.category})`));
+          });
+        }
+      }
+      
+      // System error handler status
+      const systemErrorSummary = SystemErrorHandler.getErrorSummary();
+      if (systemErrorSummary.total > 0) {
+        console.log(chalk.yellow('\n   System Errors:'));
+        console.log(`      Total: ${systemErrorSummary.total}`);
+        console.log(`      Critical: ${systemErrorSummary.critical}`);
+        console.log(`      Recoverable: ${systemErrorSummary.recoverable}`);
+        
+        if (options.verbose) {
+          console.log(chalk.yellow('\n   By Severity:'));
+          for (const [severity, count] of Object.entries(systemErrorSummary.bySeverity)) {
+            if (count > 0) {
+              console.log(`      ${severity}: ${count}`);
+            }
+          }
+        }
+      }
+    }
+    
+    // Recommendations
+    if (health.recommendations.length > 0) {
+      console.log(chalk.cyan('\n💡 Recommendations:'));
+      health.recommendations.forEach(rec => {
+        console.log(chalk.cyan(`   • ${rec}`));
+      });
+    }
+    
+    // Show degradation mode details
+    const mode = GracefulDegradationManager.getCurrentMode();
+    if (mode && mode.name !== 'Full Functionality') {
+      console.log(chalk.yellow(`\n⚠️ Currently in ${mode.name} Mode`));
+      console.log(chalk.dim(`   ${mode.description}`));
+      
+      if (mode.limitations.length > 0) {
+        console.log(chalk.yellow('\n   Limitations:'));
+        mode.limitations.forEach(limitation => {
+          console.log(chalk.yellow(`      • ${limitation}`));
+        });
+      }
+      
+      console.log(chalk.cyan('\n   Available Features:'));
+      if (mode.capabilities.baselineChecking) {
+        console.log(chalk.green('      ✅ Baseline compatibility checking'));
+      }
+      if (mode.capabilities.caching) {
+        console.log(chalk.green('      ✅ Result caching'));
+      }
+      if (!mode.capabilities.aiAnalysis) {
+        console.log(chalk.yellow('      ⚠️ AI analysis disabled'));
+      }
+      if (!mode.capabilities.autoFix) {
+        console.log(chalk.yellow('      ⚠️ Auto-fixing disabled'));
+      }
+    }
+    
+    // Performance info
+    if (options.verbose) {
+      const memoryUsage = process.memoryUsage();
+      const uptime = process.uptime();
+      
+      console.log(chalk.cyan('\n📈 Performance Info:'));
+      console.log(`   Uptime: ${Math.round(uptime)}s`);
+      console.log(`   Memory: ${Math.round(memoryUsage.heapUsed / 1024 / 1024)}MB used / ${Math.round(memoryUsage.heapTotal / 1024 / 1024)}MB total`);
+      console.log(`   Platform: ${process.platform} ${process.arch}`);
+      console.log(`   Node.js: ${process.version}`);
+    }
+    
+    // Quick actions
+    console.log(chalk.cyan('\n🔧 Quick Actions:'));
+    const actions = [];
+    
+    if (health.overall !== 'healthy') {
+      actions.push('Run "base config recover" to attempt automatic recovery');
+    }
+    
+    if (!mode?.capabilities.aiAnalysis) {
+      actions.push('Check network connectivity to restore AI features');
+    }
+    
+    const errorSummary = logger.getErrorSummary();
+    if (errorSummary.totalErrors > 5) {
+      actions.push('Run with --errors flag to see detailed error information');
+    }
+    
+    actions.push('Run "base check" to scan for compatibility issues');
+    actions.push('Run "base status --verbose" for detailed information');
+    
+    actions.forEach(action => {
+      console.log(chalk.cyan(`   • ${action}`));
+    });
+    
+  } catch (error) {
+    categoryLogger.error('Status command failed', { error });
+    
+    console.log(chalk.red('\n❌ Failed to get system status'));
+    console.log(chalk.red(`   Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    
+    console.log(chalk.cyan('\n🔧 Recovery Options:'));
+    console.log(chalk.cyan('   • Run "base init" to reinitialize BaseGuard'));
+    console.log(chalk.cyan('   • Check file permissions in your project directory'));
+    console.log(chalk.cyan('   • Verify BaseGuard installation: npm list baseguard'));
+    
+    process.exit(1);
+  }
+}
+
+/**
+ * Show detailed system diagnostics
+ */
+export async function diagnostics(): Promise<void> {
+  const categoryLogger = logger.createCategoryLogger('diagnostics');
+  
+  try {
+    console.log(chalk.cyan('🔬 BaseGuard System Diagnostics\n'));
+    
+    // Generate comprehensive debug report
+    const reportFile = await logger.generateDebugReport();
+    console.log(chalk.green(`✅ Debug report generated: ${reportFile}`));
+    
+    // Show configuration recovery wizard
+    console.log(chalk.cyan('\n🔧 Running Configuration Recovery Wizard...'));
+    await ConfigurationRecovery.runRecoveryWizard();
+    
+    // Show service status
+    console.log(chalk.cyan('\n🌐 Checking Service Availability...'));
+    await GracefulDegradationManager.refreshServiceStatus();
+    
+    // Show error log summary
+    const loggerErrorSummary = logger.getErrorSummary();
+    if (loggerErrorSummary.totalErrors > 0) {
+      console.log(chalk.yellow(`\n⚠️ Found ${loggerErrorSummary.totalErrors} errors in logs`));
+      console.log(chalk.cyan('Recent errors:'));
+      loggerErrorSummary.recentErrors.slice(0, 5).forEach(error => {
+        console.log(chalk.red(`   • ${error.message} (${error.category})`));
+      });
+    }
+    
+    // Cleanup old files
+    console.log(chalk.cyan('\n🧹 Cleaning up old files...'));
+    await logger.cleanupOldLogs();
+    await GracefulDegradationManager.cleanupCache();
+    
+    console.log(chalk.green('\n✅ Diagnostics completed'));
+    
+  } catch (error) {
+    categoryLogger.error('Diagnostics failed', { error });
+    console.log(chalk.red(`\n❌ Diagnostics failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
+  }
+}

package/src/core/baseguard.ts

@@ -16,11 +16,11 @@ import chalk from 'chalk';
  */
 export class BaseGuard {
   private config: Configuration;
-  private parserManager: ParserManager;
-  private baselineChecker: BaselineChecker;
-  private fileProcessor: FileProcessor;
-  private directoryFilter: DirectoryFilter;
-  private cacheManager: CacheManager;
+  private parserManager!: ParserManager;
+  private baselineChecker!: BaselineChecker;
+  private fileProcessor!: FileProcessor;
+  private directoryFilter!: DirectoryFilter;
+  private cacheManager!: CacheManager;
   private categoryLogger: ReturnType<typeof logger.createCategoryLogger>;
   private initialized = false;
 
@@ -28,8 +28,10 @@ export class BaseGuard {
     this.config = config;
     this.categoryLogger = logger.createCategoryLogger('baseguard');
     
-    // Initialize with error handling
-    this.initializeComponents();
+    // Initialize with error handling (async initialization)
+    this.initializeComponents().catch(error => {
+      this.categoryLogger.error('Failed to initialize BaseGuard', { error });
+    });
   }
 
   /**
@@ -43,9 +45,9 @@ export class BaseGuard {
       await GracefulDegradationManager.initialize();
       
       // Initialize components with error handling
-      await SystemErrorHandler.handleGracefully(
+      this.cacheManager = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.cacheManager = new CacheManager({
+          return new CacheManager({
             maxCacheSize: parseInt(process.env.BASEGUARD_CACHE_SIZE || '2000'),
             cacheValidityMs: 10 * 60 * 1000 // 10 minutes
           });
@@ -54,17 +56,17 @@ export class BaseGuard {
         { operation: 'cache_manager_init' }
       );
 
-      await SystemErrorHandler.handleGracefully(
+      this.parserManager = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.parserManager = new ParserManager();
+          return new ParserManager();
         },
         new ParserManager(),
         { operation: 'parser_manager_init' }
       );
 
-      await SystemErrorHandler.handleGracefully(
+      this.baselineChecker = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.baselineChecker = new BaselineChecker();
+          return new BaselineChecker();
         },
         new BaselineChecker(),
         { operation: 'baseline_checker_init' }
@@ -73,9 +75,9 @@ export class BaseGuard {
       const maxWorkers = parseInt(process.env.BASEGUARD_MAX_WORKERS || '8');
       const maxFiles = parseInt(process.env.BASEGUARD_MAX_FILES || '5000');
 
-      await SystemErrorHandler.handleGracefully(
+      this.fileProcessor = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.fileProcessor = new FileProcessor({
+          return new FileProcessor({
             maxWorkers,
             cacheManager: this.cacheManager
           });
@@ -84,9 +86,9 @@ export class BaseGuard {
         { operation: 'file_processor_init' }
       );
 
-      await SystemErrorHandler.handleGracefully(
+      this.directoryFilter = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.directoryFilter = new DirectoryFilter({
+          return new DirectoryFilter({
             maxDepth: 8,
             maxFiles
           });
@@ -167,7 +169,7 @@ export class BaseGuard {
         try {
           const compatibilityResult = await SystemErrorHandler.handleGracefully(
             () => this.baselineChecker.checkCompatibility(feature, this.config.targets),
-            { violations: [] }, // fallback result
+            { violations: [], featureData: null }, // fallback result
             { 
               operation: 'check_compatibility', 
               file: feature.file,
@@ -340,7 +342,10 @@ export class BaseGuard {
     try {
       // Cleanup file processor
       await SystemErrorHandler.handleGracefully(
-        () => this.fileProcessor.cleanup(),
+        async () => {
+          await this.fileProcessor.cleanup();
+          return undefined;
+        },
         undefined,
         { operation: 'file_processor_cleanup' },
         { logError: false, showWarning: false }
@@ -348,7 +353,10 @@ export class BaseGuard {
       
       // Clear caches
       await SystemErrorHandler.handleGracefully(
-        () => this.cacheManager.clearAll(),
+        async () => {
+          this.cacheManager.clearAll();
+          return undefined;
+        },
         undefined,
         { operation: 'cache_cleanup' },
         { logError: false, showWarning: false }
@@ -356,7 +364,10 @@ export class BaseGuard {
       
       // Cleanup graceful degradation manager
       await SystemErrorHandler.handleGracefully(
-        () => GracefulDegradationManager.cleanupCache(),
+        async () => {
+          await GracefulDegradationManager.cleanupCache();
+          return undefined;
+        },
         undefined,
         { operation: 'degradation_cleanup' },
         { logError: false, showWarning: false }
@@ -364,7 +375,10 @@ export class BaseGuard {
       
       // Cleanup old logs
       await SystemErrorHandler.handleGracefully(
-        () => logger.cleanupOldLogs(),
+        async () => {
+          await logger.cleanupOldLogs();
+          return undefined;
+        },
         undefined,
         { operation: 'log_cleanup' },
         { logError: false, showWarning: false }

package/src/core/configuration-recovery.ts

@@ -131,9 +131,8 @@ export class ConfigurationRecovery {
       // Step 6: Final validation and save
       if (currentConfig) {
         try {
-          const finalConfig = ConfigurationManager.validateAndMigrate ? 
-            ConfigurationManager.validateAndMigrate(currentConfig) : 
-            currentConfig as Configuration;
+          // Use the public migrateConfiguration method instead
+          const finalConfig = ConfigurationManager.migrateConfiguration(currentConfig);
           
           await ConfigurationManager.save(finalConfig);
           result.config = finalConfig;
@@ -454,9 +453,7 @@ export class ConfigurationRecovery {
     }
 
     // Perform migration
-    const migratedConfig = ConfigurationManager.migrateConfiguration ? 
-      ConfigurationManager.migrateConfiguration(config) : 
-      config;
+    const migratedConfig = ConfigurationManager.migrateConfiguration(config);
 
     return {
       migrated: true,

package/src/core/system-error-handler.ts

@@ -30,8 +30,12 @@ export class SystemError extends Error {
     super(message);
     this.name = 'SystemError';
     this.context = {
-      ...context,
-      timestamp: new Date()
+      operation: context?.operation || 'unknown',
+      file: context?.file,
+      line: context?.line,
+      details: context?.details,
+      timestamp: new Date(),
+      userId: context?.userId
     };
   }
 }
@@ -110,7 +114,7 @@ export class SystemErrorHandler {
       }
 
       if (showWarning) {
-        console.warn(chalk.yellow(`⚠️ ${context.operation} failed: ${error.message}`));
+        console.warn(chalk.yellow(`⚠️ ${context.operation} failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
       }
 
       // Attempt recovery if enabled
@@ -254,7 +258,7 @@ export class SystemErrorHandler {
           return true;
         }
       } catch (recoveryError) {
-        console.log(chalk.dim(`   Recovery failed: ${recoveryError.message}`));
+        console.log(chalk.dim(`   Recovery failed: ${recoveryError instanceof Error ? recoveryError.message : 'Unknown error'}`));
       }
     }
 
@@ -414,7 +418,7 @@ export class SystemErrorHandler {
       await fs.writeFile(logPath, JSON.stringify(logData, null, 2));
       console.log(chalk.dim(`Error log saved to: ${logPath}`));
     } catch (writeError) {
-      console.warn(chalk.yellow(`Failed to save error log: ${writeError.message}`));
+      console.warn(chalk.yellow(`Failed to save error log: ${writeError instanceof Error ? writeError.message : 'Unknown error'}`));
     }
   }