baseguard 1.0.3 → 1.0.5

package/src/ai/jules-implementer.ts

@@ -1,460 +1,504 @@
-import type { Violation, Analysis, Fix, JulesSession, JulesActivity } from '../types/index.js';
-import { GitHubManager } from '../git/github-manager.js';
-import { FixManager } from './fix-manager.js';
-import { ErrorHandler, APIError, ErrorType } from '../core/error-handler.js';
-import chalk from 'chalk';
-
-/**
- * Jules AI implementer for autonomous code fixing
- * Note: Jules requires GitHub repositories and cannot work with local files
- */
-export class JulesImplementer {
-  private apiKey: string;
-  private baseUrl = 'https://jules.googleapis.com/v1alpha';
-  private githubManager: GitHubManager;
-  private fixManager: FixManager;
-
-  constructor(apiKey: string) {
-    this.apiKey = apiKey;
-    this.githubManager = new GitHubManager();
-    this.fixManager = new FixManager();
-  }
-
-  /**
-   * Generate a fix using Jules AI
-   */
-  async generateFix(violation: Violation, analysis: Analysis, repoSource?: string): Promise<Fix> {
-    const context = ErrorHandler.createContext('jules_fix_generation', {
-      feature: violation.feature,
-      file: violation.file,
-      browser: violation.browser
-    });
-
-    try {
-      // Get repository source if not provided
-      const source = repoSource || await this.githubManager.getCurrentSourceIdentifier();
-      
-      // Create a session for this specific fix with retry logic
-      const session = await ErrorHandler.withRetry(
-        () => this.createSession(violation, analysis, source),
-        {
-          maxRetries: 2,
-          retryableErrors: [ErrorType.NETWORK, ErrorType.TIMEOUT, ErrorType.RATE_LIMIT, ErrorType.SERVER_ERROR]
-        }
-      );
-      
-      // Monitor session activities until completion
-      const activities = await this.waitForCompletion(session.id);
-      
-      // Extract the generated code changes
-      const fix = await this.extractFix(session.id, activities, violation, analysis);
-      
-      return fix;
-    } catch (error) {
-      const apiError = ErrorHandler.handleAPIError(error, context);
-      
-      // Log error for debugging
-      console.error('Jules fix generation failed:', {
-        feature: violation.feature,
-        error: apiError.message,
-        type: apiError.type
-      });
-      
-      // Re-throw with proper error handling
-      throw apiError;
-    }
-  }
-
-  /**
-   * Create a Jules session for fixing
-   */
-  private async createSession(violation: Violation, analysis: Analysis, source: string): Promise<JulesSession> {
-    const prompt = this.buildFixPrompt(violation, analysis);
-    
-    const response = await fetch(`${this.baseUrl}/sessions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Goog-Api-Key': this.apiKey
-      },
-      body: JSON.stringify({
-        prompt: prompt,
-        sourceContext: {
-          source: source, // e.g., "sources/github/user/repo"
-          githubRepoContext: {
-            startingBranch: "main"
-          }
-        },
-        title: `Fix ${violation.feature} compatibility in ${violation.file}`,
-        requirePlanApproval: false // Auto-approve for BaseGuard automation
-      })
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      const error = new Error(`Jules API error: ${response.status} ${response.statusText} - ${errorText}`);
-      (error as any).response = response;
-      throw error;
-    }
-    
-    const sessionData = await response.json();
-    
-    // Validate session response
-    ErrorHandler.validateAPIResponse(sessionData, ['id']);
-    
-    return sessionData;
-  }
-
-  /**
-   * Wait for Jules session completion
-   */
-  private async waitForCompletion(sessionId: string): Promise<JulesActivity[]> {
-    let attempts = 0;
-    const maxAttempts = 30; // 5 minutes max (10 seconds * 30)
-    
-    while (attempts < maxAttempts) {
-      const activities = await this.getActivities(sessionId);
-      const lastActivity = activities[activities.length - 1];
-      
-      // Check if session is complete
-      if (lastActivity?.status === 'completed' || lastActivity?.type === 'agent_finished') {
-        return activities;
-      }
-      
-      // Check for failure states
-      if (lastActivity?.status === 'failed' || lastActivity?.status === 'error') {
-        throw new Error(`Jules session failed: ${lastActivity.status}`);
-      }
-      
-      // Wait 10 seconds before checking again
-      await new Promise(resolve => setTimeout(resolve, 10000));
-      attempts++;
-    }
-    
-    throw new Error('Jules session timed out after 5 minutes');
-  }
-
-  /**
-   * Get activities for a Jules session
-   */
-  private async getActivities(sessionId: string): Promise<JulesActivity[]> {
-    const response = await fetch(`${this.baseUrl}/sessions/${sessionId}/activities`, {
-      headers: {
-        'X-Goog-Api-Key': this.apiKey
-      }
-    });
-
-    if (!response.ok) {
-      const error = new Error(`Failed to get activities: ${response.status} ${response.statusText}`);
-      (error as any).response = response;
-      throw error;
-    }
-
-    const data = await response.json();
-    
-    // Validate response structure
-    if (!data || typeof data !== 'object') {
-      throw new APIError(
-        'Invalid activities response from Jules API',
-        ErrorType.VALIDATION,
-        {
-          suggestions: [
-            'Check Jules API service status',
-            'Verify session ID is valid',
-            'Try the request again'
-          ]
-        }
-      );
-    }
-    
-    return data.activities || [];
-  }
-
-  /**
-   * Extract fix from completed Jules session
-   */
-  private async extractFix(sessionId: string, activities: JulesActivity[], violation: Violation, analysis: Analysis): Promise<Fix> {
-    // Get the final session state to extract code changes
-    const sessionResponse = await fetch(`${this.baseUrl}/sessions/${sessionId}`, {
-      headers: {
-        'X-Goog-Api-Key': this.apiKey
-      }
-    });
-
-    if (!sessionResponse.ok) {
-      throw new Error(`Failed to get session details: ${sessionResponse.status}`);
-    }
-
-    const sessionData = await sessionResponse.json();
-    
-    // Extract code changes from activities or session data
-    const codeChanges = this.extractCodeChanges(activities, sessionData);
-    
-    // Generate unified diff patch
-    const patch = this.generateUnifiedDiff(violation.file, codeChanges);
-    
-    return {
-      violation,
-      analysis,
-      patch,
-      explanation: this.generateFixExplanation(violation, analysis, codeChanges),
-      filePath: violation.file,
-      preview: this.generatePreview(codeChanges),
-      confidence: 0.8, // Jules confidence score
-      testable: true
-    };
-  }
-
-  /**
-   * Extract code changes from Jules activities and session data
-   */
-  private extractCodeChanges(activities: JulesActivity[], sessionData: any): { original: string; modified: string } {
-    // Look for code changes in activities
-    const codeActivity = activities.find(activity => 
-      activity.type === 'code_change' || activity.type === 'file_edit'
-    );
-
-    if (codeActivity) {
-      // Extract from activity data (implementation depends on Jules API response format)
-      return {
-        original: sessionData.originalCode || '',
-        modified: sessionData.modifiedCode || ''
-      };
-    }
-
-    // Fallback: extract from session data
-    return {
-      original: sessionData.originalCode || '',
-      modified: sessionData.modifiedCode || ''
-    };
-  }
-
-  /**
-   * Generate unified diff patch
-   */
-  private generateUnifiedDiff(filePath: string, changes: { original: string; modified: string }): string {
-    const originalLines = changes.original.split('\n');
-    const modifiedLines = changes.modified.split('\n');
-    
-    // Simple diff generation (in production, use a proper diff library)
-    let patch = `--- a/${filePath}\n+++ b/${filePath}\n`;
-    
-    // Find differences and generate patch format
-    for (let i = 0; i < Math.max(originalLines.length, modifiedLines.length); i++) {
-      const originalLine = originalLines[i] || '';
-      const modifiedLine = modifiedLines[i] || '';
-      
-      if (originalLine !== modifiedLine) {
-        if (originalLine) {
-          patch += `-${originalLine}\n`;
-        }
-        if (modifiedLine) {
-          patch += `+${modifiedLine}\n`;
-        }
-      }
-    }
-    
-    return patch;
-  }
-
-  /**
-   * Generate fix explanation
-   */
-  private generateFixExplanation(violation: Violation, analysis: Analysis, changes: { original: string; modified: string }): string {
-    return `Fixed ${violation.feature} compatibility issue in ${violation.file}:\n\n` +
-           `- Added progressive enhancement using ${analysis.fixStrategy}\n` +
-           `- Implemented fallback for ${violation.browser} ${violation.required}\n` +
-           `- Applied best practices: ${analysis.bestPractices.join(', ')}\n\n` +
-           `This fix ensures the feature works across all target browsers while maintaining the original functionality.`;
-  }
-
-  /**
-   * Generate human-readable preview
-   */
-  private generatePreview(changes: { original: string; modified: string }): string {
-    const originalLines = changes.original.split('\n');
-    const modifiedLines = changes.modified.split('\n');
-    
-    let preview = 'Changes:\n';
-    
-    for (let i = 0; i < Math.max(originalLines.length, modifiedLines.length); i++) {
-      const originalLine = originalLines[i];
-      const modifiedLine = modifiedLines[i];
-      
-      if (originalLine !== modifiedLine) {
-        if (originalLine) {
-          preview += `- ${originalLine}\n`;
-        }
-        if (modifiedLine) {
-          preview += `+ ${modifiedLine}\n`;
-        }
-      }
-    }
-    
-    return preview;
-  }
-
-  /**
-   * Build fix prompt for Jules
-   */
-  private buildFixPrompt(violation: Violation, analysis: Analysis): string {
-    return `Fix browser compatibility issue in ${violation.file}:
-
-ISSUE:
-- Feature: ${violation.feature} (line ${violation.line})
-- Unsupported in: ${violation.browser} ${violation.required}
-- Baseline Status: ${violation.baselineStatus}
-- Current code: ${violation.context}
-
-ANALYSIS:
-${analysis.plainEnglish}
-
-FIX STRATEGY:
-${analysis.fixStrategy}
-
-REQUIREMENTS:
-1. Implement progressive enhancement using @supports for CSS features
-2. Use feature detection for JavaScript APIs  
-3. Add appropriate fallbacks for older browsers
-4. Preserve all original functionality
-5. Follow best practices: ${analysis.bestPractices.join(', ')}
-6. Ensure the fix works in ${violation.browser} ${violation.required} and newer versions
-
-Please fix this compatibility issue while maintaining the existing functionality. The fix should be production-ready and follow web standards.`;
-  }
-
-  /**
-   * Test Jules API connectivity
-   */
-  async testConnection(): Promise<{ success: boolean; error?: string; errorType?: ErrorType }> {
-    try {
-      const response = await fetch(`${this.baseUrl}/sessions`, {
-        method: 'GET',
-        headers: {
-          'X-Goog-Api-Key': this.apiKey
-        }
-      });
-      
-      if (response.ok || response.status === 404) {
-        // 404 is acceptable for sessions endpoint when no sessions exist
-        return { success: true };
-      } else {
-        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
-        (error as any).response = response;
-        throw error;
-      }
-    } catch (error) {
-      const apiError = ErrorHandler.handleAPIError(error);
-      
-      return { 
-        success: false, 
-        error: apiError.message,
-        errorType: apiError.type
-      };
-    }
-  }
-
-  /**
-   * Get repository source identifier (GitHub integration is handled on Jules dashboard)
-   */
-  async getRepositorySource(): Promise<string> {
-    return await this.githubManager.getSourceIdentifier();
-  }
-
-  /**
-   * Check if repository information is available (GitHub integration is handled on Jules dashboard)
-   */
-  async isRepositoryDetected(): Promise<boolean> {
-    return await this.githubManager.isJulesIntegrationSetup();
-  }
-
-  /**
-   * Verify GitHub connection and permissions
-   */
-  async verifyGitHubConnection(): Promise<boolean> {
-    return await this.githubManager.verifyGitHubConnection();
-  }
-
-  /**
-   * Get repository information
-   */
-  getRepositoryInfo(): { owner: string | null; name: string | null } {
-    return this.githubManager.getRepositoryInfo();
-  }
-
-  /**
-   * Get current source identifier
-   */
-  async getSourceIdentifier(): Promise<string> {
-    return await this.githubManager.getCurrentSourceIdentifier();
-  }
-
-  /**
-   * Generate and apply fixes with interactive preview
-   */
-  async generateAndApplyFixes(violations: Violation[], analyses: Analysis[]): Promise<{ applied: Fix[]; skipped: Fix[]; failed: { fix: Fix; error: string }[] }> {
-    const fixes: Fix[] = [];
-    
-    // Generate fixes for each violation
-    for (let i = 0; i < violations.length; i++) {
-      const violation = violations[i];
-      const analysis = analyses[i];
-      
-      if (!violation || !analysis) {
-        console.log(chalk.red(`❌ Missing violation or analysis data for index ${i}`));
-        continue;
-      }
-      
-      try {
-        console.log(chalk.cyan(`\n🔧 Generating fix ${i + 1}/${violations.length} for ${violation.feature}...`));
-        const fix = await this.generateFix(violation, analysis);
-        fixes.push(fix);
-      } catch (error) {
-        console.log(chalk.red(`❌ Failed to generate fix for ${violation.feature}: ${error instanceof Error ? error.message : 'Unknown error'}`));
-      }
-    }
-    
-    if (fixes.length === 0) {
-      console.log(chalk.yellow('⚠️ No fixes were generated'));
-      return { applied: [], skipped: [], failed: [] };
-    }
-    
-    // Apply fixes with interactive preview
-    return await this.fixManager.applyFixes(fixes);
-  }
-
-  /**
-   * Preview a single fix
-   */
-  async previewFix(fix: Fix): Promise<string> {
-    return await this.fixManager.generatePreview(fix);
-  }
-
-  /**
-   * Apply a single fix
-   */
-  async applySingleFix(fix: Fix): Promise<void> {
-    await this.fixManager.applyFix(fix);
-  }
-
-  /**
-   * Rollback applied fixes
-   */
-  async rollbackFix(filePath: string): Promise<void> {
-    await this.fixManager.rollbackFix(filePath);
-  }
-
-  /**
-   * Rollback all applied fixes
-   */
-  async rollbackAllFixes(): Promise<void> {
-    await this.fixManager.rollbackAllFixes();
-  }
-
-  /**
-   * Get list of applied fixes
-   */
-  getAppliedFixes(): string[] {
-    return this.fixManager.getAppliedFixes();
-  }
-}
+import type { Violation, Analysis, Fix, JulesSession, JulesActivity } from '../types/index.js';
+import { GitHubManager } from '../git/github-manager.js';
+import { FixManager } from './fix-manager.js';
+import { ErrorHandler, APIError, ErrorType } from '../core/error-handler.js';
+import chalk from 'chalk';
+
+/**
+ * Jules AI implementer for autonomous code fixing
+ * Note: Jules requires GitHub repositories and cannot work with local files
+ */
+export class JulesImplementer {
+  private apiKey: string;
+  private baseUrl = 'https://jules.googleapis.com/v1alpha';
+  private githubManager: GitHubManager;
+  private fixManager: FixManager;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+    this.githubManager = new GitHubManager();
+    this.fixManager = new FixManager();
+  }
+
+  /**
+   * Generate a fix using Jules AI
+   */
+  async generateFix(violation: Violation, analysis: Analysis, repoSource?: string): Promise<Fix> {
+    const context = ErrorHandler.createContext('jules_fix_generation', {
+      feature: violation.feature,
+      file: violation.file,
+      browser: violation.browser
+    });
+
+    try {
+      // Get repository source if not provided
+      const source = repoSource || await this.githubManager.getCurrentSourceIdentifier();
+      
+      // Create a session for this specific fix with retry logic
+      const session = await ErrorHandler.withRetry(
+        () => this.createSession(violation, analysis, source),
+        {
+          maxRetries: 2,
+          retryableErrors: [ErrorType.NETWORK, ErrorType.TIMEOUT, ErrorType.RATE_LIMIT, ErrorType.SERVER_ERROR]
+        }
+      );
+      
+      // Monitor session activities until completion
+      const activities = await this.waitForCompletion(session.id);
+      
+      // Extract the generated code changes
+      const fix = await this.extractFix(session.id, activities, violation, analysis);
+      
+      return fix;
+    } catch (error) {
+      const apiError = ErrorHandler.handleAPIError(error, context);
+      
+      // Log error for debugging
+      console.error('Jules fix generation failed:', {
+        feature: violation.feature,
+        error: apiError.message,
+        type: apiError.type
+      });
+      
+      // Re-throw with proper error handling
+      throw apiError;
+    }
+  }
+
+  /**
+   * Create a Jules session for fixing
+   */
+  private async createSession(violation: Violation, analysis: Analysis, source: string): Promise<JulesSession> {
+    const prompt = this.buildFixPrompt(violation, analysis);
+    
+    const response = await fetch(`${this.baseUrl}/sessions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Goog-Api-Key': this.apiKey
+      },
+      body: JSON.stringify({
+        prompt: prompt,
+        sourceContext: {
+          source: source, // e.g., "sources/github/user/repo"
+          githubRepoContext: {
+            startingBranch: "main"
+          }
+        },
+        title: `Fix ${violation.feature} compatibility in ${violation.file}`,
+        requirePlanApproval: false // Auto-approve for BaseGuard automation
+      })
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      const error = new Error(`Jules API error: ${response.status} ${response.statusText} - ${errorText}`);
+      (error as any).response = response;
+      throw error;
+    }
+    
+    const sessionData = await response.json();
+    
+    // Validate session response
+    ErrorHandler.validateAPIResponse(sessionData, ['id']);
+    
+    return sessionData;
+  }
+
+  /**
+   * Wait for Jules session completion
+   */
+  private async waitForCompletion(sessionId: string): Promise<JulesActivity[]> {
+    let attempts = 0;
+    const maxAttempts = 30; // 5 minutes max (10 seconds * 30)
+    
+    while (attempts < maxAttempts) {
+      const activities = await this.getActivities(sessionId);
+      const lastActivity = activities[activities.length - 1];
+      
+      // Check if session is complete
+      if (lastActivity && this.isCompletionActivity(lastActivity)) {
+        return activities;
+      }
+      
+      // Check for failure states
+      if (lastActivity && this.isFailureActivity(lastActivity)) {
+        throw new Error(`Jules session failed: ${JSON.stringify(lastActivity)}`);
+      }
+      
+      // Wait 10 seconds before checking again
+      await new Promise(resolve => setTimeout(resolve, 10000));
+      attempts++;
+    }
+    
+    throw new Error('Jules session timed out after 5 minutes');
+  }
+
+  private isCompletionActivity(activity: any): boolean {
+    return (
+      activity?.type === 'sessionCompleted' ||
+      activity?.type === 'agent_finished' ||
+      activity?.status === 'completed' ||
+      Boolean(activity?.sessionCompleted)
+    );
+  }
+
+  private isFailureActivity(activity: any): boolean {
+    return (
+      activity?.type === 'sessionFailed' ||
+      activity?.status === 'failed' ||
+      activity?.status === 'error' ||
+      Boolean(activity?.sessionFailed)
+    );
+  }
+
+  /**
+   * Get activities for a Jules session
+   */
+  private async getActivities(sessionId: string): Promise<JulesActivity[]> {
+    const response = await fetch(`${this.baseUrl}/sessions/${sessionId}/activities`, {
+      headers: {
+        'X-Goog-Api-Key': this.apiKey
+      }
+    });
+
+    if (!response.ok) {
+      const error = new Error(`Failed to get activities: ${response.status} ${response.statusText}`);
+      (error as any).response = response;
+      throw error;
+    }
+
+    const data = await response.json();
+    
+    // Validate response structure
+    if (!data || typeof data !== 'object') {
+      throw new APIError(
+        'Invalid activities response from Jules API',
+        ErrorType.VALIDATION,
+        {
+          suggestions: [
+            'Check Jules API service status',
+            'Verify session ID is valid',
+            'Try the request again'
+          ]
+        }
+      );
+    }
+    
+    return data.activities || [];
+  }
+
+  /**
+   * Extract fix from completed Jules session
+   */
+  private async extractFix(sessionId: string, activities: JulesActivity[], violation: Violation, analysis: Analysis): Promise<Fix> {
+    // Get the final session state to extract code changes
+    const sessionResponse = await fetch(`${this.baseUrl}/sessions/${sessionId}`, {
+      headers: {
+        'X-Goog-Api-Key': this.apiKey
+      }
+    });
+
+    if (!sessionResponse.ok) {
+      throw new Error(`Failed to get session details: ${sessionResponse.status}`);
+    }
+
+    const sessionData = await sessionResponse.json();
+    
+    // Prefer official Jules patch artifact when available
+    const patch = this.extractPatchFromActivities(activities, sessionData);
+    const codeChanges = this.extractCodeChanges(activities, sessionData);
+    const finalPatch = patch || this.generateUnifiedDiff(violation.file, codeChanges);
+    
+    return {
+      violation,
+      analysis,
+      patch: finalPatch,
+      explanation: this.generateFixExplanation(violation, analysis, codeChanges),
+      filePath: violation.file,
+      preview: this.generatePreview(codeChanges, finalPatch),
+      confidence: 0.8, // Jules confidence score
+      testable: true
+    };
+  }
+
+  private extractPatchFromActivities(activities: JulesActivity[], sessionData: any): string {
+    const activityPatch = activities
+      .map((activity: any) =>
+        activity?.changeSet?.gitPatch?.unidiffPatch ||
+        activity?.changeSet?.gitPatch?.patch ||
+        activity?.gitPatch?.unidiffPatch ||
+        activity?.gitPatch?.patch
+      )
+      .find((patch: string | undefined) => typeof patch === 'string' && patch.length > 0);
+
+    if (activityPatch) {
+      return activityPatch;
+    }
+
+    return (
+      sessionData?.changeSet?.gitPatch?.unidiffPatch ||
+      sessionData?.changeSet?.gitPatch?.patch ||
+      sessionData?.latestChangeSet?.gitPatch?.unidiffPatch ||
+      sessionData?.latestChangeSet?.gitPatch?.patch ||
+      ''
+    );
+  }
+
+  /**
+   * Extract code changes from Jules activities and session data
+   */
+  private extractCodeChanges(activities: JulesActivity[], sessionData: any): { original: string; modified: string } {
+    // Look for code changes in activities
+    const codeActivity = activities.find(activity => 
+      activity.type === 'code_change' || activity.type === 'file_edit'
+    );
+
+    if (codeActivity) {
+      // Extract from activity data (implementation depends on Jules API response format)
+      return {
+        original: sessionData.originalCode || '',
+        modified: sessionData.modifiedCode || ''
+      };
+    }
+
+    // Fallback: extract from session data
+    return {
+      original: sessionData.originalCode || '',
+      modified: sessionData.modifiedCode || ''
+    };
+  }
+
+  /**
+   * Generate unified diff patch
+   */
+  private generateUnifiedDiff(filePath: string, changes: { original: string; modified: string }): string {
+    const originalLines = changes.original.split('\n');
+    const modifiedLines = changes.modified.split('\n');
+    
+    // Simple diff generation (in production, use a proper diff library)
+    let patch = `--- a/${filePath}\n+++ b/${filePath}\n`;
+    
+    // Find differences and generate patch format
+    for (let i = 0; i < Math.max(originalLines.length, modifiedLines.length); i++) {
+      const originalLine = originalLines[i] || '';
+      const modifiedLine = modifiedLines[i] || '';
+      
+      if (originalLine !== modifiedLine) {
+        if (originalLine) {
+          patch += `-${originalLine}\n`;
+        }
+        if (modifiedLine) {
+          patch += `+${modifiedLine}\n`;
+        }
+      }
+    }
+    
+    return patch;
+  }
+
+  /**
+   * Generate fix explanation
+   */
+  private generateFixExplanation(violation: Violation, analysis: Analysis, _changes: { original: string; modified: string }): string {
+    return `Fixed ${violation.feature} compatibility issue in ${violation.file}:\n\n` +
+           `- Added progressive enhancement using ${analysis.fixStrategy}\n` +
+           `- Implemented fallback for ${violation.browser} ${violation.required}\n` +
+           `- Applied best practices: ${analysis.bestPractices.join(', ')}\n\n` +
+           `This fix ensures the feature works across all target browsers while maintaining the original functionality.`;
+  }
+
+  /**
+   * Generate human-readable preview
+   */
+  private generatePreview(changes: { original: string; modified: string }, patch: string): string {
+    if (patch) {
+      return patch.split('\n').slice(0, 40).join('\n');
+    }
+
+    const originalLines = changes.original.split('\n');
+    const modifiedLines = changes.modified.split('\n');
+    
+    let preview = 'Changes:\n';
+    
+    for (let i = 0; i < Math.max(originalLines.length, modifiedLines.length); i++) {
+      const originalLine = originalLines[i];
+      const modifiedLine = modifiedLines[i];
+      
+      if (originalLine !== modifiedLine) {
+        if (originalLine) {
+          preview += `- ${originalLine}\n`;
+        }
+        if (modifiedLine) {
+          preview += `+ ${modifiedLine}\n`;
+        }
+      }
+    }
+    
+    return preview;
+  }
+
+  /**
+   * Build fix prompt for Jules
+   */
+  private buildFixPrompt(violation: Violation, analysis: Analysis): string {
+    return `Fix browser compatibility issue in ${violation.file}:
+
+ISSUE:
+- Feature: ${violation.feature} (line ${violation.line})
+- Unsupported in: ${violation.browser} ${violation.required}
+- Baseline Status: ${violation.baselineStatus}
+- Current code: ${violation.context}
+
+ANALYSIS:
+${analysis.plainEnglish}
+
+FIX STRATEGY:
+${analysis.fixStrategy}
+
+REQUIREMENTS:
+1. Implement progressive enhancement using @supports for CSS features
+2. Use feature detection for JavaScript APIs  
+3. Add appropriate fallbacks for older browsers
+4. Preserve all original functionality
+5. Follow best practices: ${analysis.bestPractices.join(', ')}
+6. Ensure the fix works in ${violation.browser} ${violation.required} and newer versions
+
+Please fix this compatibility issue while maintaining the existing functionality. The fix should be production-ready and follow web standards.`;
+  }
+
+  /**
+   * Test Jules API connectivity
+   */
+  async testConnection(): Promise<{ success: boolean; error?: string; errorType?: ErrorType }> {
+    try {
+      const response = await fetch(`${this.baseUrl}/sessions`, {
+        method: 'GET',
+        headers: {
+          'X-Goog-Api-Key': this.apiKey
+        }
+      });
+      
+      if (response.ok || response.status === 404) {
+        // 404 is acceptable for sessions endpoint when no sessions exist
+        return { success: true };
+      } else {
+        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+        (error as any).response = response;
+        throw error;
+      }
+    } catch (error) {
+      const apiError = ErrorHandler.handleAPIError(error);
+      
+      return { 
+        success: false, 
+        error: apiError.message,
+        errorType: apiError.type
+      };
+    }
+  }
+
+  /**
+   * Get repository source identifier (GitHub integration is handled on Jules dashboard)
+   */
+  async getRepositorySource(): Promise<string> {
+    return await this.githubManager.getSourceIdentifier();
+  }
+
+  /**
+   * Check if repository information is available (GitHub integration is handled on Jules dashboard)
+   */
+  async isRepositoryDetected(): Promise<boolean> {
+    return await this.githubManager.isJulesIntegrationSetup();
+  }
+
+  /**
+   * Verify GitHub connection and permissions
+   */
+  async verifyGitHubConnection(): Promise<boolean> {
+    return await this.githubManager.verifyGitHubConnection();
+  }
+
+  /**
+   * Get repository information
+   */
+  getRepositoryInfo(): { owner: string | null; name: string | null } {
+    return this.githubManager.getRepositoryInfo();
+  }
+
+  /**
+   * Get current source identifier
+   */
+  async getSourceIdentifier(): Promise<string> {
+    return await this.githubManager.getCurrentSourceIdentifier();
+  }
+
+  /**
+   * Generate and apply fixes with interactive preview
+   */
+  async generateAndApplyFixes(violations: Violation[], analyses: Analysis[]): Promise<{ applied: Fix[]; skipped: Fix[]; failed: { fix: Fix; error: string }[] }> {
+    const fixes: Fix[] = [];
+    
+    // Generate fixes for each violation
+    for (let i = 0; i < violations.length; i++) {
+      const violation = violations[i];
+      const analysis = analyses[i];
+      
+      if (!violation || !analysis) {
+        console.log(chalk.red(`❌ Missing violation or analysis data for index ${i}`));
+        continue;
+      }
+      
+      try {
+        console.log(chalk.cyan(`\n🔧 Generating fix ${i + 1}/${violations.length} for ${violation.feature}...`));
+        const fix = await this.generateFix(violation, analysis);
+        fixes.push(fix);
+      } catch (error) {
+        console.log(chalk.red(`❌ Failed to generate fix for ${violation.feature}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      }
+    }
+    
+    if (fixes.length === 0) {
+      console.log(chalk.yellow('⚠️ No fixes were generated'));
+      return { applied: [], skipped: [], failed: [] };
+    }
+    
+    // Apply fixes with interactive preview
+    return await this.fixManager.applyFixes(fixes);
+  }
+
+  /**
+   * Preview a single fix
+   */
+  async previewFix(fix: Fix): Promise<string> {
+    return await this.fixManager.generatePreview(fix);
+  }
+
+  /**
+   * Apply a single fix
+   */
+  async applySingleFix(fix: Fix): Promise<void> {
+    await this.fixManager.applyFix(fix);
+  }
+
+  /**
+   * Rollback applied fixes
+   */
+  async rollbackFix(filePath: string): Promise<void> {
+    await this.fixManager.rollbackFix(filePath);
+  }
+
+  /**
+   * Rollback all applied fixes
+   */
+  async rollbackAllFixes(): Promise<void> {
+    await this.fixManager.rollbackAllFixes();
+  }
+
+  /**
+   * Get list of applied fixes
+   */
+  getAppliedFixes(): string[] {
+    return this.fixManager.getAppliedFixes();
+  }
+}