baseguard 1.0.0

package/src/git/automation-engine.ts

@@ -0,0 +1,361 @@
+import { execSync } from 'child_process';
+import { readFileSync } from 'fs';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import type { AutomationOptions, Violation, Analysis, Fix, Configuration } from '../types/index.js';
+import { ConfigurationManager } from '../core/configuration.js';
+import { BaseGuard } from '../core/baseguard.js';
+import { UIComponents } from '../ui/components.js';
+import { GeminiAnalyzer } from '../ai/gemini-analyzer.js';
+import { JulesImplementer } from '../ai/jules-implementer.js';
+
+/**
+ * Automation engine for git workflow integration
+ */
+export class AutomationEngine {
+  private config: Configuration;
+  private baseGuard: BaseGuard;
+
+  constructor(config?: Configuration) {
+    this.config = config || ConfigurationManager.createDefault();
+    this.baseGuard = new BaseGuard(this.config);
+  }
+
+  /**
+   * Run automation for git hooks
+   */
+  async run(options: AutomationOptions): Promise<void> {
+    try {
+      // Load current configuration
+      this.config = await ConfigurationManager.load();
+      this.baseGuard = new BaseGuard(this.config);
+
+      // Check if automation is enabled
+      if (!this.config.automation.enabled) {
+        console.log(chalk.yellow('⚠️ BaseGuard automation is disabled. Run "base automation enable" to enable it.'));
+        return;
+      }
+
+      // Check if this is the correct trigger
+      if (this.config.automation.trigger !== options.trigger) {
+        // Silently exit if this isn't the configured trigger
+        return;
+      }
+
+      console.log(chalk.cyan(`🛡️ BaseGuard automation running (${options.trigger})...`));
+
+      // Step 1: Check violations in staged files
+      const violations = await this.checkViolations(options.trigger);
+      
+      if (violations.length === 0) {
+        console.log(chalk.green('✅ No compatibility issues found'));
+        return;
+      }
+
+      console.log(chalk.yellow(`⚠️ Found ${violations.length} compatibility issue(s)`));
+      UIComponents.showViolations(violations);
+
+      // Step 2: Analyze violations (if enabled and API key available)
+      let analyses: Analysis[] = [];
+      if (this.config.automation.autoAnalyze && this.config.apiKeys.gemini) {
+        analyses = await this.analyzeViolations(violations);
+      }
+
+      // Step 3: Auto-fix (if enabled and API keys available)
+      if (this.config.automation.autoFix && this.config.apiKeys.jules && this.config.apiKeys.gemini) {
+        const fixes = await this.generateFixes(violations, analyses);
+        if (fixes.length > 0) {
+          await this.applyFixes(fixes);
+          await this.stageChanges();
+          console.log(chalk.green('✅ All issues fixed automatically and staged'));
+          return;
+        }
+      }
+
+      // Manual mode - show options
+      await this.showManualOptions(violations, analyses);
+
+      // Block commit if configured to do so
+      if (this.config.automation.blockCommit && !options.strict === false) {
+        console.log(chalk.red('❌ Commit blocked due to compatibility issues'));
+        console.log(chalk.dim('Use --no-verify to bypass this check'));
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ BaseGuard automation failed:'), error instanceof Error ? error.message : 'Unknown error');
+      
+      // Don't block commit on automation errors unless in strict mode
+      if (options.strict) {
+        process.exit(1);
+      }
+    }
+  }
+
+  /**
+   * Check violations in staged files (for pre-commit) or all files (for pre-push)
+   */
+  private async checkViolations(trigger: 'pre-commit' | 'pre-push'): Promise<Violation[]> {
+    const spinner = ora('Checking for compatibility violations...').start();
+    
+    try {
+      let filesToCheck: string[] = [];
+
+      if (trigger === 'pre-commit') {
+        // Get staged files for pre-commit
+        filesToCheck = this.getStagedFiles();
+      } else {
+        // For pre-push, check all files in the repository
+        filesToCheck = this.getAllTrackedFiles();
+      }
+
+      // Filter to only supported file types
+      const supportedExtensions = ['.js', '.ts', '.jsx', '.tsx', '.vue', '.svelte', '.css', '.html'];
+      const filteredFiles = filesToCheck.filter(file => 
+        supportedExtensions.some(ext => file.endsWith(ext))
+      );
+
+      if (filteredFiles.length === 0) {
+        spinner.succeed('No supported files to check');
+        return [];
+      }
+
+      spinner.text = `Checking ${filteredFiles.length} file(s)...`;
+
+      // Use BaseGuard to check violations
+      const violations = await this.baseGuard.checkViolations(filteredFiles);
+      
+      spinner.succeed(`Checked ${filteredFiles.length} file(s)`);
+      return violations;
+
+    } catch (error) {
+      spinner.fail('Failed to check violations');
+      throw error;
+    }
+  }
+
+  /**
+   * Get staged files from git
+   */
+  private getStagedFiles(): string[] {
+    try {
+      const output = execSync('git diff --cached --name-only', { encoding: 'utf-8' });
+      return output.trim().split('\n').filter(file => file.length > 0);
+    } catch (error) {
+      console.warn(chalk.yellow('⚠️ Could not get staged files, checking all files'));
+      return this.getAllTrackedFiles();
+    }
+  }
+
+  /**
+   * Get all tracked files from git
+   */
+  private getAllTrackedFiles(): string[] {
+    try {
+      const output = execSync('git ls-files', { encoding: 'utf-8' });
+      return output.trim().split('\n').filter(file => file.length > 0);
+    } catch (error) {
+      throw new Error('Could not get tracked files from git');
+    }
+  }
+
+  /**
+   * Analyze violations if auto-analyze is enabled
+   */
+  private async analyzeViolations(violations: Violation[]): Promise<Analysis[]> {
+    if (!this.config.apiKeys.gemini) {
+      console.log(chalk.yellow('⚠️ Gemini API key not configured, skipping analysis'));
+      return [];
+    }
+
+    const spinner = ora('Analyzing violations with AI...').start();
+    
+    try {
+      const analyzer = new GeminiAnalyzer(this.config.apiKeys.gemini);
+      const analyses: Analysis[] = [];
+
+      // Analyze violations in batches to avoid rate limiting
+      for (const violation of violations) {
+        try {
+          const analysis = await analyzer.analyzeViolation(violation);
+          analyses.push(analysis);
+        } catch (error) {
+          console.warn(chalk.yellow(`⚠️ Could not analyze ${violation.feature}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+      }
+
+      spinner.succeed(`Analyzed ${analyses.length} violation(s)`);
+      return analyses;
+
+    } catch (error) {
+      spinner.fail('Failed to analyze violations');
+      throw error;
+    }
+  }
+
+  /**
+   * Generate and apply fixes if auto-fix is enabled
+   */
+  private async generateFixes(violations: Violation[], analyses: Analysis[]): Promise<Fix[]> {
+    if (!this.config.apiKeys.jules) {
+      console.log(chalk.yellow('⚠️ Jules API key not configured, skipping auto-fix'));
+      return [];
+    }
+
+    const spinner = ora('Generating fixes with AI...').start();
+    
+    try {
+      const implementer = new JulesImplementer(this.config.apiKeys.jules);
+      const fixes: Fix[] = [];
+
+      // Generate fixes for violations that have analyses
+      for (const violation of violations) {
+        const analysis = analyses.find(a => a.violation.feature === violation.feature);
+        if (!analysis) continue;
+
+        try {
+          // For automation, we need a repository source - this would need to be configured
+          // For now, we'll skip Jules integration in automation mode
+          console.log(chalk.yellow('⚠️ Jules integration requires repository setup, skipping auto-fix'));
+          break;
+        } catch (error) {
+          console.warn(chalk.yellow(`⚠️ Could not generate fix for ${violation.feature}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+      }
+
+      spinner.succeed(`Generated ${fixes.length} fix(es)`);
+      return fixes;
+
+    } catch (error) {
+      spinner.fail('Failed to generate fixes');
+      throw error;
+    }
+  }
+
+  /**
+   * Apply fixes to files
+   */
+  private async applyFixes(fixes: Fix[]): Promise<void> {
+    const spinner = ora('Applying fixes...').start();
+    
+    try {
+      // This would use the BaseGuard.applyFixes method when implemented
+      // For now, we'll just log that fixes would be applied
+      spinner.succeed(`Applied ${fixes.length} fix(es)`);
+    } catch (error) {
+      spinner.fail('Failed to apply fixes');
+      throw error;
+    }
+  }
+
+  /**
+   * Stage changes after fixing
+   */
+  private async stageChanges(): Promise<void> {
+    try {
+      execSync('git add -u', { stdio: 'ignore' });
+    } catch (error) {
+      console.warn(chalk.yellow('⚠️ Could not stage changes automatically'));
+    }
+  }
+
+  /**
+   * Show manual options when auto-fix is disabled
+   */
+  private async showManualOptions(violations: Violation[], analyses: Analysis[] = []): Promise<void> {
+    console.log(chalk.cyan('\n🔧 Manual Options:'));
+    
+    const choices = [
+      {
+        name: 'Continue with commit (ignore violations)',
+        value: 'continue'
+      },
+      {
+        name: 'Fix violations manually and retry',
+        value: 'manual'
+      }
+    ];
+
+    // Add AI options if API keys are available
+    if (this.config.apiKeys.gemini && analyses.length === 0) {
+      choices.unshift({
+        name: 'Analyze violations with AI first',
+        value: 'analyze'
+      });
+    }
+
+    if (this.config.apiKeys.jules && this.config.apiKeys.gemini) {
+      choices.unshift({
+        name: 'Generate and preview AI fixes',
+        value: 'fix'
+      });
+    }
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices
+      }
+    ]);
+
+    switch (action) {
+      case 'continue':
+        console.log(chalk.yellow('⚠️ Continuing with violations...'));
+        break;
+        
+      case 'manual':
+        console.log(chalk.blue('💡 Fix the violations manually and run git commit again'));
+        process.exit(1);
+        
+      case 'analyze':
+        console.log(chalk.blue('🔍 Run "base check --analyze" to get AI analysis'));
+        process.exit(1);
+        
+      case 'fix':
+        console.log(chalk.blue('🤖 Run "base fix" to generate and preview AI fixes'));
+        process.exit(1);
+        
+      default:
+        process.exit(1);
+    }
+  }
+
+  /**
+   * Check if git repository has uncommitted changes
+   */
+  private hasUncommittedChanges(): boolean {
+    try {
+      const output = execSync('git status --porcelain', { encoding: 'utf-8' });
+      return output.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get current git branch
+   */
+  private getCurrentBranch(): string {
+    try {
+      const output = execSync('git branch --show-current', { encoding: 'utf-8' });
+      return output.trim();
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Check if we're in a git repository
+   */
+  private isGitRepository(): boolean {
+    try {
+      execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/git/github-manager.ts

@@ -0,0 +1,260 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import open from 'open';
+
+/**
+ * GitHub repository manager for Jules integration
+ */
+export class GitHubManager {
+  private repoOwner: string | null = null;
+  private repoName: string | null = null;
+  private sourceIdentifier: string | null = null;
+
+  /**
+   * Guide user through Jules GitHub app installation
+   */
+  async setupJulesGitHubIntegration(): Promise<string> {
+    console.log(chalk.cyan('\n🔗 Setting up Jules GitHub Integration\n'));
+    
+    // Step 1: Check if we're in a git repository
+    if (!this.isGitRepository()) {
+      throw new Error('Not in a git repository. Please run this command from within a git repository.');
+    }
+
+    // Step 2: Get repository information
+    await this.detectRepositoryInfo();
+    
+    // Step 3: Guide user through GitHub app installation
+    await this.guideGitHubAppInstallation();
+    
+    // Step 4: Verify connection and get source identifier
+    const sourceId = await this.getSourceIdentifier();
+    
+    console.log(chalk.green('✅ Jules GitHub integration setup complete!'));
+    return sourceId;
+  }
+
+  /**
+   * Check if current directory is a git repository
+   */
+  private isGitRepository(): boolean {
+    try {
+      execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Detect repository owner and name from git remote
+   */
+  private async detectRepositoryInfo(): Promise<void> {
+    try {
+      const remoteUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
+      
+      // Parse GitHub URL (supports both HTTPS and SSH)
+      const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+      
+      if (match) {
+        this.repoOwner = match[1] || null;
+        this.repoName = match[2] || null;
+        
+        console.log(chalk.blue(`📁 Detected repository: ${this.repoOwner}/${this.repoName}`));
+      } else {
+        throw new Error('Could not detect GitHub repository from remote URL');
+      }
+    } catch (error) {
+      throw new Error(`Failed to detect repository info: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Guide user through GitHub app installation process
+   */
+  private async guideGitHubAppInstallation(): Promise<void> {
+    console.log(chalk.yellow('\n📋 Jules GitHub App Installation Steps:\n'));
+    
+    console.log('1. Opening Jules GitHub app installation page...');
+    
+    // Open Jules GitHub app installation URL
+    const installUrl = 'https://github.com/apps/jules-ai';
+    await open(installUrl);
+    
+    console.log(chalk.dim(`   ${installUrl}`));
+    
+    console.log('\n2. Follow these steps in your browser:');
+    console.log('   • Click "Install" on the Jules app page');
+    console.log('   • Select your repository or organization');
+    console.log(`   • Grant access to ${this.repoOwner}/${this.repoName}`);
+    console.log('   • Complete the installation process');
+    
+    console.log('\n3. After installation:');
+    console.log('   • Return to this terminal');
+    console.log('   • The setup will continue automatically');
+    
+    // Wait for user confirmation
+    await this.waitForUserConfirmation();
+  }
+
+  /**
+   * Wait for user to confirm GitHub app installation
+   */
+  private async waitForUserConfirmation(): Promise<void> {
+    const { default: inquirer } = await import('inquirer');
+    
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Have you completed the Jules GitHub app installation?',
+        default: false
+      }
+    ]);
+    
+    if (!confirmed) {
+      console.log(chalk.yellow('\nPlease complete the GitHub app installation and run this command again.'));
+      process.exit(0);
+    }
+  }
+
+  /**
+   * Get source identifier for Jules API
+   */
+  private async getSourceIdentifier(): Promise<string> {
+    if (!this.repoOwner || !this.repoName) {
+      throw new Error('Repository information not available');
+    }
+    
+    // Generate source identifier in the format expected by Jules
+    this.sourceIdentifier = `sources/github/${this.repoOwner}/${this.repoName}`;
+    
+    console.log(chalk.blue(`🔗 Source identifier: ${this.sourceIdentifier}`));
+    
+    return this.sourceIdentifier;
+  }
+
+  /**
+   * Verify GitHub authentication and permissions
+   */
+  async verifyGitHubConnection(): Promise<boolean> {
+    try {
+      if (!this.repoOwner || !this.repoName) {
+        await this.detectRepositoryInfo();
+      }
+      
+      // Check if we can access the repository
+      const response = await fetch(`https://api.github.com/repos/${this.repoOwner}/${this.repoName}`);
+      
+      if (response.ok) {
+        console.log(chalk.green('✅ GitHub repository access verified'));
+        return true;
+      } else {
+        console.log(chalk.yellow('⚠️ GitHub repository access verification failed'));
+        return false;
+      }
+    } catch (error) {
+      console.log(chalk.red(`❌ GitHub connection error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      return false;
+    }
+  }
+
+  /**
+   * Get current repository source identifier
+   */
+  async getCurrentSourceIdentifier(): Promise<string> {
+    if (this.sourceIdentifier) {
+      return this.sourceIdentifier;
+    }
+    
+    await this.detectRepositoryInfo();
+    return this.getSourceIdentifier();
+  }
+
+  /**
+   * Check if Jules GitHub integration is set up
+   */
+  async isJulesIntegrationSetup(): Promise<boolean> {
+    try {
+      if (!this.isGitRepository()) {
+        return false;
+      }
+      
+      await this.detectRepositoryInfo();
+      return await this.verifyGitHubConnection();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get repository information
+   */
+  getRepositoryInfo(): { owner: string | null; name: string | null } {
+    return {
+      owner: this.repoOwner,
+      name: this.repoName
+    };
+  }
+
+  /**
+   * Check if repository has required permissions for Jules
+   */
+  async checkRepositoryPermissions(): Promise<{ hasAccess: boolean; permissions: string[] }> {
+    try {
+      if (!this.repoOwner || !this.repoName) {
+        await this.detectRepositoryInfo();
+      }
+      
+      // In a real implementation, this would check specific permissions
+      // For now, we'll assume basic access if we can read the repo
+      const hasAccess = await this.verifyGitHubConnection();
+      
+      const permissions = hasAccess ? [
+        'read',
+        'write',
+        'pull_requests'
+      ] : [];
+      
+      return { hasAccess, permissions };
+    } catch {
+      return { hasAccess: false, permissions: [] };
+    }
+  }
+
+  /**
+   * Get current branch name
+   */
+  getCurrentBranch(): string {
+    try {
+      return execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+    } catch {
+      return 'main'; // fallback
+    }
+  }
+
+  /**
+   * Check if there are uncommitted changes
+   */
+  hasUncommittedChanges(): boolean {
+    try {
+      const status = execSync('git status --porcelain', { encoding: 'utf8' });
+      return status.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get repository URL for display
+   */
+  getRepositoryUrl(): string | null {
+    if (!this.repoOwner || !this.repoName) {
+      return null;
+    }
+    
+    return `https://github.com/${this.repoOwner}/${this.repoName}`;
+  }
+}