baseguard 1.0.0 → 1.0.2

package/src/commands/fix.ts

@@ -3,7 +3,7 @@ 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 { UnifiedCodeFixer } from '../ai/unified-code-fixer.js';
 import { GeminiAnalyzer } from '../ai/gemini-analyzer.js';
 import { glob } from 'glob';
 
@@ -34,30 +34,34 @@ export async function fix(options: {
     
     // Initialize services
     const baseGuard = new BaseGuard(config);
-    const julesImplementer = new JulesImplementer(config.apiKeys.jules);
+    const unifiedCodeFixer = new UnifiedCodeFixer(config);
     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);
-      }
+    // Show agent status and recommendations
+    console.log(chalk.cyan('🤖 Coding Agent Status:'));
+    const agentStatus = await unifiedCodeFixer.getAgentStatus();
+    
+    const primaryAvailable = agentStatus.primary === 'jules' ? agentStatus.jules.available : agentStatus.gemini.available;
+    const fallbackAvailable = agentStatus.fallback === 'jules' ? agentStatus.jules.available : agentStatus.gemini.available;
+    
+    console.log(`   Primary: ${agentStatus.primary} ${primaryAvailable ? '✅' : '❌'}`);
+    console.log(`   Fallback: ${agentStatus.fallback} ${fallbackAvailable ? '✅' : '❌'}`);
+    
+    if (!primaryAvailable && !fallbackAvailable) {
+      console.log(chalk.red('\n❌ No coding agents are available'));
+      console.log(chalk.cyan('💡 Configure API keys to enable code fixing:'));
+      console.log(chalk.cyan('   • Run "base config set-keys" to configure API keys'));
+      console.log(chalk.cyan('   • Get Gemini API key: https://aistudio.google.com'));
+      console.log(chalk.cyan('   • Get Jules API key: https://jules.google.com/settings#api'));
+      process.exit(1);
+    }
+    
+    // Show agent-specific information
+    if (agentStatus.primary === 'jules' && agentStatus.jules.repoDetected) {
+      console.log(chalk.cyan('🔗 GitHub repository detected - Jules available for autonomous fixing'));
+    } else if (agentStatus.primary === 'gemini' || !agentStatus.jules.repoDetected) {
+      console.log(chalk.cyan('💎 Using Gemini 2.5 Pro for local file fixing'));
+      console.log(chalk.dim('   This works with any local files, no GitHub required'));
     }
     
     // Step 1: Check for violations
@@ -102,88 +106,88 @@ export async function fix(options: {
       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);
+    // Step 3: Generate fixes with unified code fixer
+    console.log(chalk.cyan(`\n🤖 Generating fixes with ${agentStatus.primary}...`));
     
-    // Show results
-    console.log(chalk.cyan('\n📊 Fix Results:\n'));
+    const fixes = [];
+    let successCount = 0;
+    let failedCount = 0;
     
-    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();
+    for (let i = 0; i < violations.length; i++) {
+      const violation = violations[i];
+      const analysis = analyses[i];
+      
+      if (!violation || !analysis) continue;
+      
+      try {
+        console.log(chalk.cyan(`\n🔧 Fixing ${violation.feature} in ${violation.file}...`));
+        
+        const fix = await unifiedCodeFixer.generateFix(violation, analysis);
+        fixes.push(fix);
+        successCount++;
+        
+        console.log(chalk.green(`✅ Fix generated (confidence: ${Math.round(fix.confidence * 100)}%)`));
+        
+        // Show preview if not in auto mode
+        if (!options.auto) {
+          console.log(chalk.dim('\nPreview:'));
+          console.log(chalk.dim(fix.preview.substring(0, 200) + (fix.preview.length > 200 ? '...' : '')));
+        }
+        
+      } catch (error) {
+        failedCount++;
+        console.log(chalk.red(`❌ Failed to generate fix: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      }
     }
     
-    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 (fixes.length === 0) {
+      console.log(chalk.yellow('\n⚠️ No fixes were generated'));
+      return;
     }
     
-    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 results summary
+    console.log(chalk.cyan('\n📊 Fix Generation Results:\n'));
+    console.log(chalk.green(`✅ Generated ${successCount} fixes`));
+    if (failedCount > 0) {
+      console.log(chalk.red(`❌ Failed to generate ${failedCount} fixes`));
     }
     
-    // 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' }
-            ]
-          }
-        ]);
+    // Show fixes with previews
+    if (!options.auto && fixes.length > 0) {
+      console.log(chalk.cyan('\n🔍 Generated Fixes:\n'));
+      fixes.forEach((fix, index) => {
+        console.log(chalk.white(`${index + 1}. ${fix.violation.feature} in ${fix.filePath}`));
+        console.log(chalk.dim(`   Confidence: ${Math.round(fix.confidence * 100)}%`));
+        console.log(chalk.dim(`   Strategy: ${fix.analysis.fixStrategy}`));
         
-        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`);
-          }
+        // Show a snippet of the explanation
+        const explanation = fix.explanation?.split('\n')[0] || 'No explanation available';
+        if (explanation.length > 80) {
+          console.log(chalk.dim(`   ${explanation.substring(0, 80)}...`));
+        } else {
+          console.log(chalk.dim(`   ${explanation}`));
         }
-      }
+        console.log();
+      });
     }
     
+    // Show summary
+    console.log(chalk.cyan(`\n📈 Summary: ${successCount}/${violations.length} fixes generated successfully`));
+    
+    if (failedCount > 0) {
+      console.log(chalk.yellow(`\n⚠️ ${failedCount} fixes failed to generate. This may be due to:`));
+      console.log(chalk.yellow('   • Complex compatibility issues requiring manual review'));
+      console.log(chalk.yellow('   • API rate limits or temporary service issues'));
+      console.log(chalk.yellow('   • Files that couldn\'t be read or analyzed'));
+    }
+    
+    // Show next steps
+    console.log(chalk.cyan('\n💡 Next Steps:'));
+    console.log(chalk.cyan('   • Review the generated fixes above'));
+    console.log(chalk.cyan('   • Apply fixes manually to your code'));
+    console.log(chalk.cyan('   • Test your application after applying fixes'));
+    console.log(chalk.cyan('   • Run "base check" to verify fixes resolve violations'));
+    
     UIComponents.showSuccessBox('Fix process completed!');
     
   } catch (error) {
@@ -203,7 +207,7 @@ export async function fix(options: {
       UIComponents.showList([
         'Run "base init" to set up BaseGuard configuration',
         'Configure API keys with "base config set-keys"',
-        'Check GitHub integration for Jules fixing'
+        'Ensure you are in a GitHub repository for Jules fixing'
       ]);
     } else if (apiError.type === 'network') {
       UIComponents.showList([

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/init.ts

@@ -69,11 +69,10 @@ export async function init(options: {
       }
     }
     
-    // Set up API keys if not skipped
+    // Set up API keys and coding agent if not skipped
     if (!options.skipApiKeys) {
       spinner.stop();
       const apiKeys = await Prompts.setupApiKeys();
-      spinner.start();
       
       if (apiKeys.julesApiKey) {
         config.apiKeys.jules = apiKeys.julesApiKey;
@@ -81,6 +80,21 @@ export async function init(options: {
       if (apiKeys.geminiApiKey) {
         config.apiKeys.gemini = apiKeys.geminiApiKey;
       }
+      
+      // Configure coding agent based on available keys
+      if (apiKeys.julesApiKey && apiKeys.geminiApiKey) {
+        const codingAgentChoice = await Prompts.chooseCodingAgent();
+        config.codingAgent.primary = codingAgentChoice.primary;
+        config.codingAgent.fallback = codingAgentChoice.fallback;
+      } else if (apiKeys.julesApiKey) {
+        config.codingAgent.primary = 'jules';
+        config.codingAgent.fallback = 'jules';
+      } else if (apiKeys.geminiApiKey) {
+        config.codingAgent.primary = 'gemini';
+        config.codingAgent.fallback = 'gemini';
+      }
+      
+      spinner.start();
     }
     
     await ConfigurationManager.save(config);

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'}`));
+  }
+}