Add streaming diff animation features from bugbash branch

- Add messages.ts with streaming diff animation support
- Add complete diffAnimation module with:
  - Animation queue management
  - Chat processing capabilities
  - Diff analysis and animation control
  - File system management
  - VSCode integration
  - Webview management
  - Streaming diff controller

Author: MarcoWang3

packages/amazonq/src/lsp/chat/diffAnimation/README.md

@@ -0,0 +1,157 @@
+# DiffAnimation Module Refactoring
+
+## Overview
+
+The `diffAnimation` directory has been refactored from 2 large files (~1700 lines total) into 9 smaller, focused modules following the Single Responsibility Principle. This improves maintainability, testability, and code organization while preserving all existing functionality.
+
+## File Structure
+
+### Core Files
+
+-   **`diffAnimationHandler.ts`** - Main orchestrator and public API (reduced from ~800 to ~300 lines)
+-   **`diffAnimationController.ts`** - Animation control and coordination (reduced from ~900 to ~400 lines)
+
+### Supporting Components
+
+-   **`types.ts`** - Shared TypeScript interfaces and types
+-   **`fileSystemManager.ts`** - File system operations, path resolution, and file watching
+-   **`chatProcessor.ts`** - Chat message processing and tool use handling
+-   **`animationQueueManager.ts`** - Animation queuing and coordination logic
+-   **`webviewManager.ts`** - Webview creation, HTML generation, and messaging
+-   **`diffAnalyzer.ts`** - Diff calculation, line parsing, and scan planning
+-   **`vscodeIntegration.ts`** - VS Code API integration and utilities
+
+## Architecture
+
+```
+DiffAnimationHandler (Main Entry Point)
+├── FileSystemManager (File Operations)
+├── ChatProcessor (Message Processing)
+├── AnimationQueueManager (Queue Management)
+└── DiffAnimationController (Animation Control)
+    ├── WebviewManager (UI Management)
+    ├── DiffAnalyzer (Diff Logic)
+    └── VSCodeIntegration (VS Code APIs)
+```
+
+## Key Benefits
+
+### 1. **Improved Maintainability**
+
+-   Each component has a single, clear responsibility
+-   Easier to locate and modify specific functionality
+-   Reduced cognitive load when working on individual features
+
+### 2. **Better Testability**
+
+-   Components can be unit tested in isolation
+-   Dependencies are injected, making mocking easier
+-   Clear interfaces between components
+
+### 3. **Enhanced Reusability**
+
+-   Components can be reused in different contexts
+-   Easier to extract functionality for other features
+-   Clear separation of concerns
+
+### 4. **Preserved Functionality**
+
+-   All existing public APIs remain unchanged
+-   No breaking changes to external consumers
+-   Backward compatibility maintained
+
+## Component Responsibilities
+
+### FileSystemManager
+
+-   File system watching and event handling
+-   Path resolution and normalization
+-   File content capture and preparation
+-   Directory creation and file operations
+
+### ChatProcessor
+
+-   Chat message parsing and processing
+-   Tool use detection and handling
+-   Message deduplication
+-   File write preparation coordination
+
+### AnimationQueueManager
+
+-   Animation queuing for concurrent file changes
+-   Animation state management
+-   Queue processing and coordination
+-   Statistics and monitoring
+
+### WebviewManager
+
+-   Webview panel creation and management
+-   HTML content generation
+-   Message passing between extension and webview
+-   Auto-scroll control and user interaction handling
+
+### DiffAnalyzer
+
+-   Diff calculation and analysis
+-   Changed region detection
+-   Scan plan creation for animations
+-   Animation timing calculations
+-   Complexity analysis for optimization
+
+### VSCodeIntegration
+
+-   VS Code API abstractions
+-   Built-in diff view integration
+-   Editor operations and file management
+-   Status messages and user notifications
+-   Configuration and theme management
+
+## Migration Notes
+
+### For Developers
+
+-   Import paths remain the same for main classes
+-   All public methods and interfaces are preserved
+-   Internal implementation is now modular but transparent to consumers
+
+### For Testing
+
+-   Individual components can now be tested in isolation
+-   Mock dependencies can be easily injected
+-   Test coverage can be more granular and focused
+
+### For Future Development
+
+-   New features can be added to specific components
+-   Components can be enhanced without affecting others
+-   Clear boundaries make refactoring safer and easier
+
+## ESLint Compliance
+
+All files follow the project's ESLint configuration:
+
+-   Proper TypeScript typing
+-   Consistent code formatting
+-   No unused imports or variables
+-   Proper error handling patterns
+
+## Performance Considerations
+
+-   No performance impact from refactoring
+-   Same memory usage patterns
+-   Identical animation behavior
+-   Preserved optimization strategies
+
+## Future Enhancements
+
+The modular structure enables several future improvements:
+
+1. **Enhanced Testing**: Unit tests for individual components
+2. **Performance Monitoring**: Better metrics collection per component
+3. **Feature Extensions**: Easier addition of new animation types
+4. **Configuration**: Component-level configuration options
+5. **Debugging**: Better error isolation and debugging capabilities
+
+## Conclusion
+
+This refactoring successfully breaks down the large `diffAnimation` codebase into manageable, focused components while maintaining full backward compatibility and functionality. The new structure provides a solid foundation for future development and maintenance.

packages/amazonq/src/lsp/chat/diffAnimation/animationQueueManager.ts

@@ -0,0 +1,178 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { getLogger } from 'aws-core-vscode/shared'
+import { QueuedAnimation, PendingFileWrite } from './types'
+import { FileSystemManager } from './fileSystemManager'
+
+export class AnimationQueueManager {
+    // Track which files are being animated
+    private animatingFiles = new Set<string>()
+    // Animation queue for handling multiple changes
+    private animationQueue = new Map<string, QueuedAnimation[]>()
+
+    constructor(
+        private fileSystemManager: FileSystemManager,
+        private startFullAnimation: (
+            filePath: string,
+            originalContent: string,
+            newContent: string,
+            toolUseId: string
+        ) => Promise<void>,
+        private startPartialAnimation: (
+            filePath: string,
+            originalContent: string,
+            newContent: string,
+            changeLocation: { startLine: number; endLine: number },
+            toolUseId: string
+        ) => Promise<void>
+    ) {}
+
+    /**
+     * Check if a file is currently being animated
+     */
+    public isAnimating(filePath: string): boolean {
+        return this.animatingFiles.has(filePath)
+    }
+
+    /**
+     * Mark file as animating
+     */
+    public markAsAnimating(filePath: string): void {
+        this.animatingFiles.add(filePath)
+    }
+
+    /**
+     * Mark file as no longer animating
+     */
+    public markAsNotAnimating(filePath: string): void {
+        this.animatingFiles.delete(filePath)
+    }
+
+    /**
+     * Queue an animation for later processing
+     */
+    public queueAnimation(filePath: string, animation: QueuedAnimation): void {
+        const queue = this.animationQueue.get(filePath) || []
+        queue.push(animation)
+        this.animationQueue.set(filePath, queue)
+        getLogger().info(`[AnimationQueueManager] 📋 Queued animation for ${filePath} (queue size: ${queue.length})`)
+    }
+
+    /**
+     * Start animation and handle queuing logic
+     */
+    public async startAnimation(filePath: string, pendingWrite: PendingFileWrite, newContent: string): Promise<void> {
+        // If already animating, queue the change
+        if (this.isAnimating(filePath)) {
+            this.queueAnimation(filePath, {
+                originalContent: pendingWrite.originalContent,
+                newContent,
+                toolUseId: pendingWrite.toolUseId,
+                changeLocation: pendingWrite.changeLocation,
+            })
+            return
+        }
+
+        // Mark as animating
+        this.markAsAnimating(filePath)
+
+        try {
+            // Check if we have change location for partial update
+            if (pendingWrite.changeLocation) {
+                // Use partial animation for targeted changes
+                await this.startPartialAnimation(
+                    filePath,
+                    pendingWrite.originalContent,
+                    newContent,
+                    pendingWrite.changeLocation,
+                    pendingWrite.toolUseId
+                )
+            } else {
+                // Use full file animation
+                await this.startFullAnimation(
+                    filePath,
+                    pendingWrite.originalContent,
+                    newContent,
+                    pendingWrite.toolUseId
+                )
+            }
+
+            // Process queued animations
+            await this.processQueuedAnimations(filePath)
+        } finally {
+            // Always mark as not animating when done
+            this.markAsNotAnimating(filePath)
+        }
+    }
+
+    /**
+     * Process queued animations for a file
+     */
+    private async processQueuedAnimations(filePath: string): Promise<void> {
+        const queue = this.animationQueue.get(filePath)
+        if (!queue || queue.length === 0) {
+            return
+        }
+
+        const next = queue.shift()
+        if (!next) {
+            return
+        }
+
+        getLogger().info(
+            `[AnimationQueueManager] 🎯 Processing queued animation for ${filePath} (${queue.length} remaining)`
+        )
+
+        // Use the current file content as the "original" for the next animation
+        const currentContent = await this.fileSystemManager.getCurrentFileContent(filePath)
+
+        // Create a new pending write for the queued animation
+        const queuedPendingWrite: PendingFileWrite = {
+            filePath,
+            originalContent: currentContent,
+            toolUseId: next.toolUseId,
+            timestamp: Date.now(),
+            changeLocation: next.changeLocation,
+        }
+
+        // Recursively start the next animation
+        await this.startAnimation(filePath, queuedPendingWrite, next.newContent)
+    }
+
+    /**
+     * Get animation statistics
+     */
+    public getAnimationStats(): { animatingCount: number; queuedCount: number; filePaths: string[] } {
+        let queuedCount = 0
+        for (const queue of this.animationQueue.values()) {
+            queuedCount += queue.length
+        }
+
+        return {
+            animatingCount: this.animatingFiles.size,
+            queuedCount,
+            filePaths: Array.from(this.animatingFiles),
+        }
+    }
+
+    /**
+     * Clear all queues and reset state
+     */
+    public clearAll(): void {
+        this.animatingFiles.clear()
+        this.animationQueue.clear()
+        getLogger().info('[AnimationQueueManager] 🧹 Cleared all animation queues and state')
+    }
+
+    /**
+     * Clear queue for a specific file
+     */
+    public clearFileQueue(filePath: string): void {
+        this.animationQueue.delete(filePath)
+        this.markAsNotAnimating(filePath)
+        getLogger().info(`[AnimationQueueManager] 🧹 Cleared queue for ${filePath}`)
+    }
+}