baseguard 1.0.0

package/dist/ui/terminal-header.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+/**
+ * Display beautiful Baseguard terminal header with ASCII art and tagline
+ */
+export function showTerminalHeader() {
+    console.clear();
+    // Well-spaced ASCII art for "Baseguard" - monochrome for good contrast
+    const logo = `
+██████╗   █████╗  ███████╗ ███████╗  ██████╗  ██╗   ██╗  █████╗  ██████╗  ██████╗ 
+██╔══██╗ ██╔══██╗ ██╔════╝ ██╔════╝ ██╔════╝  ██║   ██║ ██╔══██╗ ██╔══██╗ ██╔══██╗
+██████╔╝ ███████║ ███████╗ █████╗   ██║  ███╗ ██║   ██║ ███████║ ██████╔╝ ██║  ██║
+██╔══██╗ ██╔══██║ ╚════██║ ██╔══╝   ██║   ██║ ██║   ██║ ██╔══██║ ██╔══██╗ ██║  ██║
+██████╔╝ ██║  ██║ ███████║ ███████╗ ╚██████╔╝ ╚██████╔╝ ██║  ██║ ██║  ██║ ██████╔╝
+╚═════╝  ╚═╝  ╚═╝ ╚══════╝ ╚══════╝  ╚═════╝   ╚═════╝  ╚═╝  ╚═╝ ╚═╝  ╚═╝ ╚═════╝ 
+  `;
+    // Use a single color that contrasts well with both light and dark terminals
+    console.log(chalk.bold.white(logo));
+    // Tagline with styling
+    console.log(chalk.bold.white('                    Ship Modern Code') +
+        chalk.dim(' ✨\n'));
+}
+/**
+ * Display compact header for command output
+ */
+export function showCompactHeader() {
+    console.log(chalk.bold.white('🛡️  Baseguard') +
+        chalk.dim(' - Ship Modern Code ✨\n'));
+}
+/**
+ * Simple fallback header without external dependencies
+ */
+export function showSimpleHeader() {
+    console.clear();
+    const logo = `
+██████╗   █████╗  ███████╗ ███████╗  ██████╗  ██╗   ██╗  █████╗  ██████╗  ██████╗ 
+██╔══██╗ ██╔══██╗ ██╔════╝ ██╔════╝ ██╔════╝  ██║   ██║ ██╔══██╗ ██╔══██╗ ██╔══██╗
+██████╔╝ ███████║ ███████╗ █████╗   ██║  ███╗ ██║   ██║ ███████║ ██████╔╝ ██║  ██║
+██╔══██╗ ██╔══██║ ╚════██║ ██╔══╝   ██║   ██║ ██║   ██║ ██╔══██║ ██╔══██╗ ██║  ██║
+██████╔╝ ██║  ██║ ███████║ ███████╗ ╚██████╔╝ ╚██████╔╝ ██║  ██║ ██║  ██║ ██████╔╝
+╚═════╝  ╚═╝  ╚═╝ ╚══════╝ ╚══════╝  ╚═════╝   ╚═════╝  ╚═╝  ╚═╝ ╚═╝  ╚═╝ ╚═════╝ 
+  `;
+    console.log(chalk.bold.white(logo));
+    console.log(chalk.bold.white('                    Ship Modern Code') +
+        chalk.dim(' ✨\n'));
+}
+//# sourceMappingURL=terminal-header.js.map

package/dist/ui/terminal-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-header.js","sourceRoot":"","sources":["../../src/ui/terminal-header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAChC,OAAO,CAAC,KAAK,EAAE,CAAC;IAEhB,uEAAuE;IACvE,MAAM,IAAI,GAAG;;;;;;;GAOZ,CAAC;IAEF,4EAA4E;IAC5E,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAEpC,uBAAuB;IACvB,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,sCAAsC,CAAC;QACxD,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAClB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC;QAClC,KAAK,CAAC,GAAG,CAAC,yBAAyB,CAAC,CACrC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,CAAC,KAAK,EAAE,CAAC;IAEhB,MAAM,IAAI,GAAG;;;;;;;GAOZ,CAAC;IAEF,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,sCAAsC,CAAC;QACxD,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAClB,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "baseguard",
+  "version": "1.0.0",
+  "description": "BaseGuard - Never ship incompatible code again. Intelligent browser compatibility enforcement with AI-powered analysis and autonomous fixing.",
+  "main": "dist/index.js",
+  "bin": {
+    "base": "bin/base.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts"
+  },
+  "keywords": [
+    "browser-compatibility",
+    "baseline",
+    "web-standards",
+    "cli",
+    "ai",
+    "automation",
+    "git-hooks"
+  ],
+  "author": "BaseGuard Team",
+  "license": "MIT",
+  "dependencies": {
+    "@babel/parser": "^7.23.6",
+    "@babel/traverse": "^7.23.6",
+    "@babel/types": "^7.23.6",
+    "@vue/compiler-sfc": "^3.3.13",
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.3",
+    "commander": "^11.1.0",
+    "figlet": "^1.9.3",
+    "glob": "^10.3.10",
+    "gradient-string": "^2.0.2",
+    "husky": "^8.0.3",
+    "inquirer": "^9.2.12",
+    "node-fetch": "^3.3.2",
+    "open": "^9.1.0",
+    "ora": "^7.0.1",
+    "postcss": "^8.4.32",
+    "postcss-selector-parser": "^6.0.13",
+    "svelte": "^4.2.8",
+    "web-features": "^0.8.4"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.28.0",
+    "@types/figlet": "^1.7.0",
+    "@types/glob": "^8.1.0",
+    "@types/gradient-string": "^1.1.6",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.5",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
+    "eslint": "^8.56.0",
+    "prettier": "^3.1.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ebuka1017/baseguard.git"
+  },
+  "types": "./dist/index.d.ts",
+  "bugs": {
+    "url": "https://github.com/ebuka1017/baseguard/issues"
+  },
+  "homepage": "https://github.com/ebuka1017/baseguard#readme"
+}

package/src/ai/__tests__/gemini-analyzer.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GeminiAnalyzer } from '../gemini-analyzer.js';
+import type { Violation } from '../../types/index.js';
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe('GeminiAnalyzer', () => {
+  let analyzer: GeminiAnalyzer;
+  const mockApiKey = 'AIzaSyDummyKeyForTesting1234567890123456789';
+
+  beforeEach(() => {
+    analyzer = new GeminiAnalyzer(mockApiKey);
+    vi.clearAllMocks();
+  });
+
+  const mockViolation: Violation = {
+    feature: 'container-type',
+    featureId: 'container-queries',
+    file: 'src/Card.css',
+    line: 15,
+    column: 5,
+    context: '  container-type: inline-size;',
+    browser: 'safari',
+    required: '15',
+    actual: false,
+    baselineStatus: 'newly',
+    reason: 'Not supported in Safari 15'
+  };
+
+  describe('API Key Validation', () => {
+    it('should validate correct API key format', () => {
+      expect(GeminiAnalyzer.validateApiKey(mockApiKey)).toBe(true);
+    });
+
+    it('should reject invalid API key format', () => {
+      expect(GeminiAnalyzer.validateApiKey('invalid-key')).toBe(false);
+      expect(GeminiAnalyzer.validateApiKey('AIza123')).toBe(false); // too short
+    });
+  });
+
+  describe('Cache Management', () => {
+    it('should cache analysis results', async () => {
+      const mockResponse = {
+        ok: true,
+        json: () => Promise.resolve({
+          candidates: [{
+            content: {
+              parts: [{ text: 'Test analysis response with 5% market share impact.' }]
+            },
+            groundingMetadata: {
+              groundingChunks: [
+                { web: { uri: 'https://web.dev/container-queries' } }
+              ]
+            }
+          }]
+        })
+      };
+
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      // First call should hit the API
+      const analysis1 = await analyzer.analyzeViolation(mockViolation);
+      expect(fetch).toHaveBeenCalledTimes(1);
+
+      // Second call should use cache
+      const analysis2 = await analyzer.analyzeViolation(mockViolation);
+      expect(fetch).toHaveBeenCalledTimes(1); // Still only 1 call
+      
+      expect(analysis1.violation.feature).toBe(analysis2.violation.feature);
+    });
+
+    it('should clear cache when requested', async () => {
+      analyzer.clearCache();
+      const stats = analyzer.getCacheStats();
+      expect(stats.size).toBe(0);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle API errors gracefully', async () => {
+      (global.fetch as any).mockRejectedValue(new Error('Network error'));
+
+      const analysis = await analyzer.analyzeViolation(mockViolation);
+      
+      expect(analysis.confidence).toBe(0.3); // Fallback confidence
+      expect(analysis.plainEnglish).toContain('API error');
+      expect(analysis.fixStrategy).toBe('progressive enhancement');
+    });
+
+    it('should handle invalid API responses', async () => {
+      const mockResponse = {
+        ok: true,
+        json: () => Promise.resolve({ candidates: [] })
+      };
+
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const analysis = await analyzer.analyzeViolation(mockViolation);
+      
+      expect(analysis.confidence).toBe(0.3);
+      expect(analysis.plainEnglish).toContain('API error');
+    });
+  });
+
+  describe('Response Parsing', () => {
+    it('should extract market share from response', async () => {
+      const mockResponse = {
+        ok: true,
+        json: () => Promise.resolve({
+          candidates: [{
+            content: {
+              parts: [{ text: 'This affects approximately 8.5% of users on Safari 15.' }]
+            },
+            groundingMetadata: {
+              groundingChunks: [
+                { web: { uri: 'https://caniuse.com/css-container-queries' } }
+              ]
+            }
+          }]
+        })
+      };
+
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const analysis = await analyzer.analyzeViolation(mockViolation);
+      
+      expect(analysis.marketShare).toBe(0.085);
+      expect(analysis.sources).toContain('https://caniuse.com/css-container-queries');
+    });
+
+    it('should extract best practices from response', async () => {
+      const mockResponse = {
+        ok: true,
+        json: () => Promise.resolve({
+          candidates: [{
+            content: {
+              parts: [{ 
+                text: 'Use @supports for feature detection. Consider using polyfills. Test across target browsers.' 
+              }]
+            },
+            groundingMetadata: { groundingChunks: [] }
+          }]
+        })
+      };
+
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const analysis = await analyzer.analyzeViolation(mockViolation);
+      
+      expect(analysis.bestPractices).toContain('Use @supports for feature detection');
+      expect(analysis.bestPractices).toContain('Consider using polyfills');
+      expect(analysis.bestPractices).toContain('Test across target browsers');
+    });
+  });
+
+  describe('Batch Processing', () => {
+    it('should process multiple violations with concurrency control', async () => {
+      const mockResponse = {
+        ok: true,
+        json: () => Promise.resolve({
+          candidates: [{
+            content: {
+              parts: [{ text: 'Test analysis response.' }]
+            },
+            groundingMetadata: { groundingChunks: [] }
+          }]
+        })
+      };
+
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const violations = [mockViolation, { ...mockViolation, feature: 'dialog' }];
+      const analyses = await analyzer.analyzeViolations(violations, 2);
+      
+      expect(analyses).toHaveLength(2);
+      expect(analyses[0].violation.feature).toBe('container-type');
+      expect(analyses[1].violation.feature).toBe('dialog');
+    });
+  });
+});

package/src/ai/fix-manager.ts

@@ -0,0 +1,362 @@
+import { readFile, writeFile, copyFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { mkdir } from 'fs/promises';
+import chalk from 'chalk';
+import type { Fix, Violation } from '../types/index.js';
+
+/**
+ * Fix manager for previewing and applying code fixes
+ */
+export class FixManager {
+  private appliedFixes: Map<string, { original: string; backup: string }> = new Map();
+
+  /**
+   * Generate unified diff preview of proposed changes
+   */
+  async generatePreview(fix: Fix): Promise<string> {
+    try {
+      const originalContent = await readFile(fix.filePath, 'utf8');
+      const modifiedContent = this.applyPatchToContent(originalContent, fix.patch);
+      
+      return this.createUnifiedDiff(fix.filePath, originalContent, modifiedContent);
+    } catch (error) {
+      throw new Error(`Failed to generate preview: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Show interactive fix approval with clear change descriptions
+   */
+  async showFixPreview(fix: Fix): Promise<boolean> {
+    console.log(chalk.cyan(`\n🔧 Fix Preview for ${fix.violation.feature} in ${fix.filePath}\n`));
+    
+    // Show fix explanation
+    console.log(chalk.white('📋 Fix Description:'));
+    console.log(chalk.dim(fix.explanation));
+    console.log();
+    
+    // Show confidence score
+    const confidenceColor = fix.confidence >= 0.8 ? 'green' : fix.confidence >= 0.6 ? 'yellow' : 'red';
+    console.log(chalk.white('🎯 Confidence: ') + chalk[confidenceColor](`${Math.round(fix.confidence * 100)}%`));
+    console.log();
+    
+    // Show unified diff
+    console.log(chalk.white('📝 Changes:'));
+    const preview = await this.generatePreview(fix);
+    console.log(this.colorizeUnifiedDiff(preview));
+    console.log();
+    
+    // Show human-readable preview
+    if (fix.preview) {
+      console.log(chalk.white('👀 Summary:'));
+      console.log(chalk.dim(fix.preview));
+      console.log();
+    }
+    
+    // Interactive approval
+    const { default: inquirer } = await import('inquirer');
+    
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do with this fix?',
+        choices: [
+          { name: '✅ Apply this fix', value: 'apply' },
+          { name: '👀 Show detailed diff', value: 'detail' },
+          { name: '❌ Skip this fix', value: 'skip' },
+          { name: '🚫 Cancel all fixes', value: 'cancel' }
+        ]
+      }
+    ]);
+    
+    switch (action) {
+      case 'apply':
+        return true;
+      case 'detail':
+        await this.showDetailedDiff(fix);
+        return await this.showFixPreview(fix); // Show preview again
+      case 'skip':
+        return false;
+      case 'cancel':
+        throw new Error('Fix application cancelled by user');
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Apply fixes to original files while preserving formatting and structure
+   */
+  async applyFix(fix: Fix): Promise<void> {
+    try {
+      // Create backup before applying fix
+      await this.createBackup(fix.filePath);
+      
+      // Read original content
+      const originalContent = await readFile(fix.filePath, 'utf8');
+      
+      // Apply patch to content
+      const modifiedContent = this.applyPatchToContent(originalContent, fix.patch);
+      
+      // Write modified content back to file
+      await writeFile(fix.filePath, modifiedContent, 'utf8');
+      
+      // Store fix information for potential rollback
+      this.appliedFixes.set(fix.filePath, {
+        original: originalContent,
+        backup: this.getBackupPath(fix.filePath)
+      });
+      
+      console.log(chalk.green(`✅ Applied fix to ${fix.filePath}`));
+    } catch (error) {
+      throw new Error(`Failed to apply fix: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Apply multiple fixes with batch processing
+   */
+  async applyFixes(fixes: Fix[]): Promise<{ applied: Fix[]; skipped: Fix[]; failed: { fix: Fix; error: string }[] }> {
+    const results = {
+      applied: [] as Fix[],
+      skipped: [] as Fix[],
+      failed: [] as { fix: Fix; error: string }[]
+    };
+    
+    console.log(chalk.cyan(`\n🔧 Applying ${fixes.length} fixes...\n`));
+    
+    for (const fix of fixes) {
+      try {
+        const shouldApply = await this.showFixPreview(fix);
+        
+        if (shouldApply) {
+          await this.applyFix(fix);
+          results.applied.push(fix);
+        } else {
+          results.skipped.push(fix);
+          console.log(chalk.yellow(`⏭️ Skipped fix for ${fix.filePath}`));
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        results.failed.push({ fix, error: errorMessage });
+        console.log(chalk.red(`❌ Failed to apply fix for ${fix.filePath}: ${errorMessage}`));
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Rollback applied fixes
+   */
+  async rollbackFix(filePath: string): Promise<void> {
+    const fixInfo = this.appliedFixes.get(filePath);
+    
+    if (!fixInfo) {
+      throw new Error(`No applied fix found for ${filePath}`);
+    }
+    
+    try {
+      // Restore original content
+      await writeFile(filePath, fixInfo.original, 'utf8');
+      
+      // Remove from applied fixes
+      this.appliedFixes.delete(filePath);
+      
+      console.log(chalk.green(`✅ Rolled back fix for ${filePath}`));
+    } catch (error) {
+      throw new Error(`Failed to rollback fix: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Rollback all applied fixes
+   */
+  async rollbackAllFixes(): Promise<void> {
+    const filePaths = Array.from(this.appliedFixes.keys());
+    
+    console.log(chalk.cyan(`\n🔄 Rolling back ${filePaths.length} fixes...\n`));
+    
+    for (const filePath of filePaths) {
+      try {
+        await this.rollbackFix(filePath);
+      } catch (error) {
+        console.log(chalk.red(`❌ Failed to rollback ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+      }
+    }
+  }
+
+  /**
+   * Get list of applied fixes
+   */
+  getAppliedFixes(): string[] {
+    return Array.from(this.appliedFixes.keys());
+  }
+
+  /**
+   * Create backup of original file
+   */
+  private async createBackup(filePath: string): Promise<void> {
+    const backupPath = this.getBackupPath(filePath);
+    const backupDir = dirname(backupPath);
+    
+    // Ensure backup directory exists
+    if (!existsSync(backupDir)) {
+      await mkdir(backupDir, { recursive: true });
+    }
+    
+    // Copy original file to backup location
+    await copyFile(filePath, backupPath);
+  }
+
+  /**
+   * Get backup file path
+   */
+  private getBackupPath(filePath: string): string {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return join('.baseguard', 'backups', `${filePath.replace(/[/\\]/g, '_')}.${timestamp}.backup`);
+  }
+
+  /**
+   * Apply patch to file content
+   */
+  private applyPatchToContent(originalContent: string, patch: string): string {
+    const lines = originalContent.split('\n');
+    const patchLines = patch.split('\n');
+    
+    let result = [...lines];
+    let currentLine = 0;
+    
+    for (const patchLine of patchLines) {
+      if (patchLine.startsWith('@@')) {
+        // Parse hunk header to get line numbers
+        const match = patchLine.match(/@@ -(\d+),?\d* \+(\d+),?\d* @@/);
+        if (match && match[2]) {
+          currentLine = parseInt(match[2]) - 1;
+        }
+      } else if (patchLine.startsWith('-')) {
+        // Remove line
+        const lineToRemove = patchLine.substring(1);
+        const index = result.findIndex((line, i) => i >= currentLine && line.trim() === lineToRemove.trim());
+        if (index !== -1) {
+          result.splice(index, 1);
+        }
+      } else if (patchLine.startsWith('+')) {
+        // Add line
+        const lineToAdd = patchLine.substring(1);
+        result.splice(currentLine, 0, lineToAdd);
+        currentLine++;
+      } else if (patchLine.startsWith(' ')) {
+        // Context line - advance current line
+        currentLine++;
+      }
+    }
+    
+    return result.join('\n');
+  }
+
+  /**
+   * Create unified diff between original and modified content
+   */
+  private createUnifiedDiff(filePath: string, original: string, modified: string): string {
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+    
+    let diff = `--- a/${filePath}\n+++ b/${filePath}\n`;
+    
+    // Simple diff algorithm (in production, use a proper diff library)
+    let i = 0, j = 0;
+    while (i < originalLines.length || j < modifiedLines.length) {
+      const originalLine = originalLines[i] || '';
+      const modifiedLine = modifiedLines[j] || '';
+      
+      if (originalLine === modifiedLine) {
+        diff += ` ${originalLine}\n`;
+        i++;
+        j++;
+      } else {
+        // Find next matching line
+        let nextMatch = -1;
+        for (let k = j + 1; k < modifiedLines.length; k++) {
+          if (modifiedLines[k] === originalLine) {
+            nextMatch = k;
+            break;
+          }
+        }
+        
+        if (nextMatch !== -1) {
+          // Lines were added
+          for (let k = j; k < nextMatch; k++) {
+            diff += `+${modifiedLines[k]}\n`;
+          }
+          j = nextMatch;
+        } else {
+          // Line was removed or changed
+          if (i < originalLines.length) {
+            diff += `-${originalLine}\n`;
+            i++;
+          }
+          if (j < modifiedLines.length) {
+            diff += `+${modifiedLine}\n`;
+            j++;
+          }
+        }
+      }
+    }
+    
+    return diff;
+  }
+
+  /**
+   * Colorize unified diff for better readability
+   */
+  private colorizeUnifiedDiff(diff: string): string {
+    return diff
+      .split('\n')
+      .map(line => {
+        if (line.startsWith('+++') || line.startsWith('---')) {
+          return chalk.bold(line);
+        } else if (line.startsWith('@@')) {
+          return chalk.cyan(line);
+        } else if (line.startsWith('+')) {
+          return chalk.green(line);
+        } else if (line.startsWith('-')) {
+          return chalk.red(line);
+        } else {
+          return chalk.dim(line);
+        }
+      })
+      .join('\n');
+  }
+
+  /**
+   * Show detailed diff with more context
+   */
+  private async showDetailedDiff(fix: Fix): Promise<void> {
+    console.log(chalk.cyan(`\n📋 Detailed Diff for ${fix.filePath}\n`));
+    
+    try {
+      const originalContent = await readFile(fix.filePath, 'utf8');
+      const modifiedContent = this.applyPatchToContent(originalContent, fix.patch);
+      
+      const originalLines = originalContent.split('\n');
+      const modifiedLines = modifiedContent.split('\n');
+      
+      console.log(chalk.white('Original:'));
+      originalLines.forEach((line, i) => {
+        console.log(chalk.dim(`${(i + 1).toString().padStart(3)} | `) + line);
+      });
+      
+      console.log(chalk.white('\nModified:'));
+      modifiedLines.forEach((line, i) => {
+        console.log(chalk.dim(`${(i + 1).toString().padStart(3)} | `) + line);
+      });
+      
+      console.log();
+    } catch (error) {
+      console.log(chalk.red(`Failed to show detailed diff: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+  }
+}