diff --git a/.eslintrc.json b/.eslintrc.json
new file mode 100644
index 0000000..6f7485e
--- /dev/null
+++ b/.eslintrc.json
@@ -0,0 +1,26 @@
+{
+  "env": {
+    "browser": true,
+    "es2021": true,
+    "node": true
+  },
+  "extends": [
+    "eslint:recommended"
+  ],
+  "parserOptions": {
+    "ecmaVersion": 12,
+    "sourceType": "module"
+  },
+  "rules": {
+    "prefer-const": "warn",
+    "no-var": "error",
+    "no-unused-vars": "warn"
+  },
+  "ignorePatterns": [
+    "out/**",
+    "dist/**",
+    "**/*.d.ts",
+    "node_modules/**",
+    "webviewUi/**"
+  ]
+}
\ No newline at end of file
diff --git a/DOCUMENTATION_GENERATOR_GUIDE.md b/DOCUMENTATION_GENERATOR_GUIDE.md
deleted file mode 100644
index 7cb3cbc..0000000
--- a/DOCUMENTATION_GENERATOR_GUIDE.md
+++ /dev/null
@@ -1,147 +0,0 @@
-# 📚 Intelligent Documentation Generator - New Feature
-
-## Overview
-The **Intelligent Documentation Generator** is a powerful new feature in CodeBuddy that automatically analyzes your codebase and generates comprehensive, professional documentation. This feature combines AI-powered analysis with pattern-based extraction to create accurate, up-to-date documentation for any project.
-
-## 🌟 Key Features
-
-### 1. **Smart README Generation**
-- Automatically generates professional README.md files
-- Includes project overview, installation instructions, and usage examples
-- Adapts content based on detected frameworks and technologies
-- Maintains consistent formatting and structure
-
-### 2. **API Documentation**
-- Extracts REST endpoints, GraphQL schemas, and database models
-- Documents request/response formats and parameters
-- Provides example usage for each endpoint
-- Supports multiple frameworks (Express.js, Fastify, NestJS, etc.)
-
-### 3. **Architecture Analysis**
-- Analyzes codebase structure and patterns
-- Generates Mermaid architecture diagrams
-- Identifies design patterns and technologies used
-- Documents component relationships and data flow
-
-### 4. **Component Documentation**
-- Auto-generates documentation for classes, interfaces, and modules
-- Documents methods, properties, and their purposes
-- Extracts JSDoc comments and type information
-- Creates comprehensive API references
-
-### 5. **AI-Enhanced Analysis**
-- Uses advanced LLM capabilities for deeper code understanding
-- Fallback to pattern-based analysis for reliability
-- Supports multiple AI models (Gemini, Anthropic, Groq, etc.)
-- Continuously improves accuracy over time
-
-## 🚀 How to Use
-
-### Via Command Palette
-1. Open VS Code Command Palette (`Ctrl+Shift+P` / `Cmd+Shift+P`)
-2. Type "CodeBuddy: Generate Documentation"
-3. Select the command and wait for analysis to complete
-4. Documentation will be created in the `docs/` folder
-
-### Via Explorer Context Menu
-1. Right-click on any folder in the Explorer panel
-2. Select "📚 CodeBuddy. Generate Documentation"
-3. The feature will analyze the selected folder and generate docs
-
-### Available Commands
-- **📚 Generate Documentation**: Create new documentation for your project
-- **🔄 Regenerate Documentation**: Update existing documentation
-- **📖 Open Documentation**: Quick access to view generated docs
-
-## 📁 Generated Documentation Structure
-
-```
-docs/
-├── README.md                 # Enhanced project README
-├── API.md                   # API endpoints and schemas
-├── ARCHITECTURE.md          # System architecture overview
-├── COMPONENTS.md            # Component documentation
-└── diagrams/
-    ├── architecture.md      # Mermaid architecture diagrams
-    └── data-flow.md         # Data flow diagrams
-```
-
-## 🔧 Configuration
-
-The documentation generator respects your AI model preferences:
-
-1. **Configure AI Model**: Use the existing CodeBuddy settings to select your preferred AI model (Gemini, Anthropic, Groq, etc.)
-2. **API Keys**: Ensure your API keys are configured in VS Code settings
-3. **Fallback Mode**: If no AI model is available, the feature uses pattern-based analysis
-
-## ✨ Example Output
-
-### Generated README.md
-```markdown
-# Project Name
-
-> Automatically generated documentation by CodeBuddy
-
-## Overview
-This project is a modern web application built with Express.js and React...
-
-## Installation
-```bash
-npm install
-```
-
-## API Endpoints
-- GET /api/users - Retrieve user list
-- POST /api/users - Create new user
-...
-```
-
-### Generated API.md
-```markdown
-# API Documentation
-
-## Endpoints
-
-### GET /api/users
-Retrieves a paginated list of users.
-
-**Parameters:**
-- `page` (number, optional): Page number for pagination
-- `limit` (number, optional): Items per page (default: 10)
-
-**Response:**
-```json
-{
-  "users": [...],
-  "pagination": {...}
-}
-```
-```
-
-## 🎯 Benefits
-
-1. **Time Saving**: Automatically generate documentation in minutes, not hours
-2. **Consistency**: Maintain consistent documentation format across projects
-3. **Accuracy**: AI-powered analysis ensures comprehensive coverage
-4. **Up-to-date**: Easy regeneration keeps docs current with code changes
-5. **Professional**: Creates documentation that follows best practices
-
-## 🔮 Future Enhancements
-
-- **Multi-language Support**: Documentation generation for Python, Java, C#
-- **Interactive Docs**: Generate interactive API documentation with try-it features  
-- **Team Collaboration**: Share and synchronize documentation across teams
-- **Custom Templates**: Configurable documentation templates
-- **Integration**: Direct integration with documentation platforms
-
-## 💡 Tips for Best Results
-
-1. **Clean Code**: Well-structured code with clear naming produces better docs
-2. **Comments**: Include JSDoc comments for richer generated content
-3. **Type Definitions**: Use TypeScript interfaces for better API documentation
-4. **Regular Updates**: Regenerate docs when making significant code changes
-5. **Review**: Always review and customize generated docs as needed
-
----
-
-Ready to revolutionize your documentation workflow? Install the latest CodeBuddy extension and start generating professional documentation today! 🚀
diff --git a/IMPLEMENTATION_SUMMARY.md b/IMPLEMENTATION_SUMMARY.md
deleted file mode 100644
index 15a38c9..0000000
--- a/IMPLEMENTATION_SUMMARY.md
+++ /dev/null
@@ -1,222 +0,0 @@
-# CodeBuddy Enhancement Implementation Summary
-
-## Overview
-This document summarizes the major enhancements implemented to address the code review feedback, focusing on security, performance, reliability, and code quality improvements.
-
-## 🛡️ Security Enhancements
-
-### Input Validation & Prompt Injection Protection
-- **File**: `src/services/input-validator.ts`
-- **Integration**: `src/webview-providers/base.ts`
-- **Features**:
-  - SQL injection detection and blocking
-  - XSS protection with HTML entity encoding
-  - Prompt injection pattern detection
-  - Control character sanitization
-  - Command injection prevention
-  - Configurable security levels (block vs sanitize)
-
-### Key Security Measures
-```typescript
-// Example usage in chat flow
-const validationResult = await this.inputValidator.validateAndSanitize(userInput);
-if (validationResult.blocked) {
-  return { response: "⚠️ Input blocked for security reasons", isError: true };
-}
-```
-
-## ⚡ Performance Optimizations
-
-### Intelligent Caching System
-- **File**: `src/services/codebase-analysis-cache.ts`
-- **Integration**: `src/services/codebase-understanding.service.ts`
-- **Features**:
-  - Workspace-aware cache invalidation
-  - Automatic cleanup of expired entries
-  - TTL-based expiration (30 minutes default)
-  - Memory-efficient storage
-  - Cache statistics and monitoring
-
-### Performance Benefits
-- **30-minute cache**: Avoids expensive re-analysis of unchanged codebases
-- **Batch processing**: Reduces I/O overhead for file operations
-- **Smart invalidation**: Only invalidates when workspace actually changes
-
-## 🏗️ Architecture Improvements
-
-### Strategy Pattern Implementation
-- **Directory**: `src/services/analysis-strategies/`
-- **Files**:
-  - `base-analysis-strategy.ts` - Abstract base for all strategies
-  - `api-endpoint-strategy.ts` - Specialized API endpoint detection
-  - `data-model-strategy.ts` - Advanced data model analysis
-  - `analysis-strategy-factory.ts` - Strategy instantiation
-
-### Benefits of Strategy Pattern
-- **Separation of Concerns**: Each analysis type has its own class
-- **Testability**: Individual strategies can be unit tested
-- **Extensibility**: Easy to add new analysis types
-- **Performance**: Optimized processing per analysis type
-
-## 🔧 Reliability & Error Handling
-
-### Robust Response Processing
-- **File**: `src/utils/utils.ts` (formatText function)
-- **Features**:
-  - Markdown formatting fixes
-  - Incomplete response detection
-  - Header normalization
-  - Bold text handling
-  - Code block preservation
-
-### Enhanced LLM Configuration
-- **File**: `src/llms/gemini/gemini.ts`
-- **Improvements**:
-  - Increased output tokens (8192 → 32768)
-  - Reduced stop sequences for better completion
-  - Temperature optimization (0.3)
-
-### Truncation Detection & Retry Logic
-- **File**: `src/webview-providers/gemini.ts`
-- **Features**:
-  - Pattern-based truncation detection
-  - Automatic retry with adjusted parameters
-  - Comprehensive debug logging
-  - Fallback error messages
-
-## 📈 Code Quality Improvements
-
-### Comprehensive Unit Testing
-- **Files**:
-  - `src/test/suite/codebase-analysis-cache.test.ts`
-  - `src/test/suite/codebase-understanding-cache.test.ts`
-  - `src/test/suite/input-validator.test.ts`
-
-### Test Coverage Areas
-- ✅ Cache operations (set, get, expiration)
-- ✅ Workspace hash validation
-- ✅ Input validation scenarios
-- ✅ Error handling and edge cases
-- ✅ Performance benchmarking
-- ✅ Strategy pattern functionality
-
-## 🔍 Enhanced PR Review System
-
-### Git Integration Improvements
-- **File**: `src/commands/review-pr.ts`
-- **Enhancements**:
-  - VS Code git API integration
-  - Fallback to recent file detection
-  - Improved file content reading
-  - Better error handling
-  - Support for various git states
-
-## 🚀 Feature Enhancements
-
-### Codebase Q&A System
-- **Deep architectural understanding**
-- **Framework detection and analysis**
-- **API recommendation engine**
-- **Authentication pattern recognition**
-- **Smart context retrieval**
-
-### Key Capabilities
-```typescript
-// Example: Building admin dashboard recommendations
-const analysis = await service.analyzeWorkspace();
-// Returns: frameworks, endpoints, models, relationships
-```
-
-## 📊 Metrics & Monitoring
-
-### Cache Performance Metrics
-```typescript
-const stats = service.getCacheStats();
-// Returns: totalEntries, totalSize, hitRate, oldestEntry
-```
-
-### Debug Logging
-- Comprehensive logging throughout all services
-- Performance timing measurements
-- Error context preservation
-- User action tracking
-
-## 🛠️ Developer Experience
-
-### Easy Cache Management
-```typescript
-service.clearCache();              // Clear all
-service.clearCachePattern("user-"); // Clear specific pattern
-const stats = service.getCacheStats(); // Monitor performance
-```
-
-### Flexible Input Validation
-```typescript
-// Different validation modes
-await validator.validateAndSanitize(input, { 
-  level: SecurityLevel.STRICT,
-  blockMalicious: true 
-});
-```
-
-## 📝 Configuration & Customization
-
-### Configurable Security Levels
-- **PERMISSIVE**: Basic sanitization
-- **STRICT**: Aggressive blocking
-- **CUSTOM**: User-defined rules
-
-### Adjustable Cache Settings
-- TTL customization per cache type
-- Workspace dependency configuration
-- Automatic cleanup intervals
-
-## 🧪 Testing Strategy
-
-### Test Categories Implemented
-1. **Unit Tests**: Individual component testing
-2. **Integration Tests**: Service interaction testing  
-3. **Performance Tests**: Cache effectiveness measurement
-4. **Error Handling Tests**: Edge case validation
-5. **Security Tests**: Validation bypass attempts
-
-## 🔮 Future Enhancements
-
-### Planned Improvements
-- [ ] Machine learning-based code pattern recognition
-- [ ] Advanced caching with Redis support
-- [ ] Real-time collaboration features
-- [ ] Extended language support beyond TypeScript/JavaScript
-- [ ] Custom rule engine for validation
-
-## 📋 Implementation Checklist
-
-### ✅ Completed Tasks
-- ✅ Input validation and security hardening
-- ✅ Performance caching implementation  
-- ✅ Strategy pattern architecture
-- ✅ Comprehensive unit testing
-- ✅ Enhanced error handling
-- ✅ PR review improvements
-- ✅ Markdown formatting fixes
-- ✅ LLM configuration optimization
-- ✅ Code complexity reduction
-
-### 🎯 Impact Assessment
-- **Security**: 🛡️ High - Prevents prompt injection and XSS attacks
-- **Performance**: ⚡ High - 50-80% reduction in analysis time for cached results
-- **Reliability**: 🔧 High - Robust error handling and retry mechanisms
-- **Maintainability**: 📚 High - Modular architecture with clear separation
-- **User Experience**: 🚀 High - Faster responses and better error messages
-
-## 🏆 Code Review Resolution
-
-### Original Issues → Solutions
-1. **"Must Fix: Input Validation"** → ✅ Comprehensive InputValidator service
-2. **"Must Fix: Response Truncation"** → ✅ Detection, retry, and formatting fixes  
-3. **"Must Fix: Error Handling"** → ✅ Layered error handling throughout
-4. **"Should Fix: Performance"** → ✅ Intelligent caching system
-5. **"Should Fix: Code Complexity"** → ✅ Strategy pattern refactoring
-6. **"Should Fix: Unit Tests"** → ✅ Comprehensive test suite
-
-This implementation transforms CodeBuddy from a functional prototype into a production-ready, secure, and performant VS Code extension that provides intelligent codebase analysis and recommendations.
diff --git a/PR_REVIEW_IMPLEMENTATION.md b/PR_REVIEW_IMPLEMENTATION.md
deleted file mode 100644
index 8e56092..0000000
--- a/PR_REVIEW_IMPLEMENTATION.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# PR Review Implementation Summary
-
-## ✅ All Improvements Successfully Implemented
-
-### 🛡️ **MUST FIX - Security Enhancements**
-
-#### 1. XSS Vulnerability Fixed ✅
-- **Created**: `src/utils/llm-output-sanitizer.ts`
-- **Updated**: `src/commands/architectural-recommendation.ts`
-- **Implementation**:
-  - Comprehensive HTML sanitization for LLM outputs
-  - Removes dangerous script tags, event handlers, and malicious URLs  
-  - Handles markdown content sanitization
-  - Provides fallback for plain text with HTML entity encoding
-  - Integrated into architectural recommendation command with secure webview creation
-
-#### 2. Webview Security Policy Fixed ✅
-- **Updated**: `src/webview/chat_html.ts`
-- **Implementation**:
-  - Added comprehensive Content Security Policy (CSP)
-  - Allows `vscode-resource:` protocol for static resources
-  - Restricts script sources to nonce-based and whitelisted CDNs
-  - Enables safe loading of fonts, styles, and images
-
----
-
-### ⚡ **SHOULD FIX - Performance & Reliability**
-
-#### 3. File Filtering Optimization ✅
-- **Updated**: `src/commands/review-pr.ts`
-- **Implementation**:
-  - Reduced initial file fetch limit from 100 to 50
-  - Added efficient batch processing (10 files per batch)
-  - Time-based filtering (last 24 hours) with proper date validation
-  - Promise.allSettled for concurrent file stat operations
-  - Early termination when sufficient files found (max 10)
-
-#### 4. Enhanced Error Handling ✅
-- **Updated**: `src/commands/review-pr.ts`
-- **Implementation**:
-  - User-friendly error messages via `vscode.window.showErrorMessage`
-  - Contextual error information with actionable guidance
-  - Optional "View Output" button for detailed debugging
-  - Graceful fallback when both git methods fail
-
----
-
-### 💡 **CONSIDER - Advanced Features**
-
-#### 5. Cancellation Token & Progress Updates ✅
-- **Updated**: `src/services/codebase-understanding.service.ts`
-- **Updated**: `src/commands/architectural-recommendation.ts`
-- **Implementation**:
-  - Added `CancellationToken` support to `analyzeWorkspace()` and `getCodebaseContext()`
-  - Comprehensive progress reporting with meaningful messages:
-    - "Checking cache..." (5%)
-    - "Reading package.json..." (10%)
-    - "Identifying frameworks..." (20%)
-    - "Analyzing API endpoints..." (40%)
-    - "Analyzing data models..." (60%)
-    - "Analyzing database schema..." (75%)
-    - "Mapping domain relationships..." (85%)
-    - "Finalizing analysis..." (95%)
-  - Cancellation checks between expensive operations
-  - Enhanced architectural recommendation command with cancellable progress
-
-#### 6. Robust Markdown Parsing ✅
-- **Updated**: `src/utils/utils.ts`
-- **Implementation**:
-  - Enhanced `formatText()` with comprehensive try/catch
-  - Smart HTML-safe fallback when markdown parsing fails
-  - Preserves basic formatting (bold, italic, headers, code) in fallback
-  - Proper HTML entity encoding for security
-  - Maintains readable output even with parsing errors
-
----
-
-## 📊 **Performance Improvements**
-
-### File Processing Optimization
-- **Before**: Sequential processing of up to 100 files
-- **After**: Batch processing (10 files) with early termination at 10 results
-- **Improvement**: ~80% reduction in I/O operations for large workspaces
-
-### Concurrent Operations
-- **Before**: Serial file stat operations
-- **After**: `Promise.allSettled` for concurrent file processing
-- **Improvement**: Significantly faster file filtering
-
-### Progress Feedback
-- **Before**: Single "Analyzing..." message
-- **After**: 8 distinct progress stages with cancellation
-- **Improvement**: Better user experience and ability to cancel long operations
-
----
-
-## 🔒 **Security Enhancements**
-
-### Input/Output Sanitization
-- **HTML Content**: Complete sanitization with whitelist-based approach
-- **Script Tags**: Completely removed (`<script>`, `<iframe>`, `<object>`, `<embed>`)
-- **Event Handlers**: Stripped all `on*` attributes and JavaScript protocols
-- **URLs**: Safe protocol validation (http/https/relative only)
-- **Fallback Safety**: HTML entity encoding for plain text fallback
-
-### Content Security Policy
-- **Default**: `default-src 'none'` (deny all by default)
-- **Scripts**: Nonce-based execution + whitelisted CDNs only
-- **Styles**: Inline styles allowed for VS Code theming + webview resources
-- **Images**: VS Code resources + safe external protocols
-- **Resources**: `vscode-resource:` protocol enabled for static assets
-
----
-
-## 🧪 **Error Handling Improvements**
-
-### User Experience
-- **Before**: Silent failures or console-only errors
-- **After**: User-facing error messages with actionable guidance
-- **Context**: Clear explanation of what went wrong and how to fix it
-
-### Graceful Degradation
-- **Git Failures**: Fallback to recent file detection
-- **Markdown Failures**: HTML-safe text rendering
-- **Analysis Failures**: Meaningful error messages instead of crashes
-
-### Debug Support
-- **Developer Tools**: Option to view detailed errors
-- **Logging**: Comprehensive error context preservation
-- **Fallback Chains**: Multiple recovery strategies
-
----
-
-## 🏗️ **Architecture Benefits**
-
-### Code Organization
-- **Separation of Concerns**: Sanitization logic in dedicated utility
-- **Reusability**: Sanitizer can be used across multiple commands
-- **Testability**: Each component is independently testable
-- **Maintainability**: Clear function boundaries and responsibilities
-
-### Performance Architecture
-- **Lazy Loading**: Only process files when needed
-- **Batch Processing**: Prevents UI blocking
-- **Early Termination**: Stops processing when enough data is found
-- **Concurrent Operations**: Maximizes I/O efficiency
-
-### Security Architecture
-- **Defense in Depth**: Multiple layers of sanitization
-- **Principle of Least Privilege**: Restrictive CSP with minimal permissions
-- **Input Validation**: Comprehensive content filtering
-- **Safe Defaults**: Secure fallback behaviors
-
----
-
-## ✅ **Implementation Status**
-
-| Item | Priority | Status | Impact |
-|------|----------|---------|--------|
-| XSS Sanitization | Must Fix | ✅ Complete | High Security |
-| CSP Update | Must Fix | ✅ Complete | High Security |
-| File Filtering | Should Fix | ✅ Complete | High Performance |
-| Error Handling | Should Fix | ✅ Complete | High UX |
-| Progress Updates | Consider | ✅ Complete | Medium UX |
-| Markdown Robustness | Consider | ✅ Complete | Medium Reliability |
-
-## 🚀 **Ready for Production**
-
-All critical security vulnerabilities have been addressed, performance optimizations implemented, and user experience significantly improved. The codebase now follows security best practices and provides robust error handling with graceful degradation.
-
-**Key Benefits:**
-- ✅ **Secure**: XSS protection and comprehensive input sanitization
-- ✅ **Fast**: Optimized file processing and concurrent operations
-- ✅ **Reliable**: Robust error handling and fallback mechanisms  
-- ✅ **User-Friendly**: Clear progress reporting and cancellation support
-- ✅ **Maintainable**: Well-structured code with clear separation of concerns
-
-The implementation addresses all items from the PR review and exceeds the requirements by providing comprehensive security, performance, and reliability improvements.
diff --git a/REFACTORING_SUMMARY.md b/REFACTORING_SUMMARY.md
deleted file mode 100644
index 424a2d0..0000000
--- a/REFACTORING_SUMMARY.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# CodeBuddy PR Review Response & Implementation
-
-## ✅ All "Must Fix" Items Completed:
-
-### 1. **Security: Prompt Injection Prevention** 
-   - ✅ **FIXED**: Added input sanitization in `architectural-recommendation.ts`
-   - ✅ Sanitized both context and user question to prevent backtick and template literal injection
-   - ✅ Escapes `\`backticks\`` and `${template}` expressions to prevent code execution
-
-### 2. **Error Handling in CodebaseAnalysisWorker**
-   - ✅ **ENHANCED**: Added specific error handling for file operations (ENOENT, EACCES, EISDIR)
-   - ✅ Improved error context and messaging throughout the worker
-   - ✅ Added granular try-catch blocks with meaningful error messages
-
-### 3. **Persistent Chat History with SQL.js**
-   - ✅ **IMPLEMENTED**: Replaced in-memory chat history with persistent SQLite storage
-   - ✅ Added comprehensive chat history schema with indexes
-   - ✅ Implemented full CRUD operations: get, set, addMessage, clear, cleanup
-   - ✅ Added methods for recent history retrieval and automatic cleanup
-
-## ✅ All "Should Fix" Items Completed:
-
-### 4. **Code Quality: Extract Cache Handling Logic**
-   - ✅ **REFACTORED**: Extracted `shouldRefreshAnalysis()` and `getUserCacheDecision()` helper functions
-   - ✅ Improved readability and maintainability of cache decision logic
-   - ✅ Made cache handling logic reusable and testable
-
-### 5. **Performance: Static Regex Patterns**
-   - ✅ **OPTIMIZED**: Made all regex patterns static in analyzers (TypeScript, JavaScript, Python)
-   - ✅ Reduced object creation overhead by caching regex patterns at class level
-   - ✅ Improved performance for large codebases with many file analyses
-
-### 6. **Database: Table Name Constants**
-   - ✅ **IMPROVED**: Added `CODEBASE_SNAPSHOTS_TABLE` constant for better maintainability
-   - ✅ Reduced risk of typos and inconsistencies in database schema management
-   - ✅ Follows DRY principle for database table naming
-
-### 7. **Database Service: SQL Execution Methods**
-   - ✅ **ADDED**: Implemented `executeSql()`, `executeSqlCommand()`, and `executeSqlAll()` methods
-   - ✅ Proper separation between queries that return results vs commands
-   - ✅ Comprehensive error handling and logging for all SQL operations
-
-## 🏗️ Architecture Improvements Implemented:
-
-### **Enhanced SqliteDatabaseService**
-```typescript
-// New SQL execution methods for extensibility
-executeSql(query: string, params: any[]): any[]           // For SELECT queries
-executeSqlCommand(query: string, params: any[]): object   // For INSERT/UPDATE/DELETE
-executeSqlAll(query: string, params: any[]): any[]        // For comprehensive results
-```
-
-### **Persistent Chat History Repository**
-```typescript
-// Full CRUD operations with SQLite persistence
-get(agentId: string): any[]                    // Get all history
-getRecent(agentId: string, limit: number): any[] // Get recent with limit
-addMessage(agentId: string, message: object): void // Add single message
-set(agentId: string, history: any[]): void     // Replace all history
-clear(agentId: string): void                   // Clear agent history
-clearAll(): void                               // Clear all history
-cleanup(daysToKeep: number): void             // Automatic cleanup
-```
-
-### **Security-Enhanced Prompt Construction**
-```typescript
-// Input sanitization prevents prompt injection
-const sanitizedContext = context.replace(/`/g, '\\`').replace(/\${/g, '\\${');
-const sanitizedQuestion = question.replace(/`/g, '\\`').replace(/\${/g, '\\${');
-```
-
-### **Performance-Optimized File Analyzers**
-```typescript
-// Static regex patterns cached at class level
-private static readonly importRegex = /pattern/gi;
-private static readonly exportRegex = /pattern/gi;
-// Used as: TypeScriptAnalyzer.importRegex.exec(content)
-```
-
-## 🔒 Security Enhancements:
-- **Prompt Injection Prevention**: All user inputs and context data are sanitized
-- **SQL Injection Prevention**: All database queries use parameterized statements
-- **Error Information Disclosure**: Controlled error messages prevent sensitive data leakage
-
-## 🚀 Performance Improvements:
-- **Static Regex Caching**: ~30% reduction in regex object creation overhead
-- **Efficient Database Queries**: Indexed lookups with composite keys
-- **Persistent Storage**: Cross-session data retention without memory overhead
-
-## ✅ Build Status: **PASSING**
-- All TypeScript compilation successful ✅
-- No lint errors in production code ✅
-- All security fixes implemented ✅
-- All performance optimizations applied ✅
-
-## 🎯 Implementation Summary:
-
-**Files Modified/Enhanced:**
-- `src/commands/architectural-recommendation.ts` - Security & code quality
-- `src/services/sqlite-database.service.ts` - SQL methods & constants
-- `src/infrastructure/repository/db-chat-history.ts` - Persistent storage
-- `src/services/analyzers/typescript-analyzer.ts` - Static regex optimization
-- `src/services/analyzers/javascript-analyzer.ts` - Static regex optimization  
-- `src/services/analyzers/python-analyzer.ts` - Static regex optimization
-
-**All PR Review Action Items: ✅ COMPLETED**
-- **Must Fix**: Security, Error Handling, Persistent Chat History ✅
-- **Should Fix**: Code Quality, Performance, Database Improvements ✅
-- **Consider**: Enhanced architecture patterns implemented ✅
-
-The codebase now provides a robust, secure, and performant foundation for persistent codebase understanding with comprehensive chat history management.
diff --git a/debug-truncation-test.md b/debug-truncation-test.md
deleted file mode 100644
index 959c212..0000000
--- a/debug-truncation-test.md
+++ /dev/null
@@ -1,74 +0,0 @@
-# Response Truncation Fix - Testing Guide
-
-## 🛠️ What Was Implemented
-
-### 1. Enhanced Truncation Detection
-- Detects responses ending with `**API`, `**API `, or similar patterns
-- Identifies incomplete numbered lists, headers, and markdown formatting
-- Catches suspiciously short responses (< 50 chars) or short responses with bold formatting
-
-### 2. Intelligent Retry Mechanism
-- Automatically retries when truncation is detected
-- Uses fresh chat session to avoid context issues
-- Returns the longer response if both are incomplete
-- Fallback to original response if retry fails
-
-### 3. Improved Generation Configuration
-- Increased `maxOutputTokens` to 8192 (doubled)
-- Removed aggressive stop sequences that might cause premature truncation
-- Optimized temperature and other parameters for completeness
-
-### 4. Explicit Completion Instructions
-- Added clear instructions to AI about completing responses
-- Enhanced prompts in both chat interface and command palette
-
-## 🧪 Testing the Fix
-
-### Test Case 1: Chat Interface
-Ask a question that previously caused truncation:
-```
-"Can you explain the API design patterns used in this codebase?"
-```
-
-### Test Case 2: Command Palette
-1. Press `Cmd+Shift+P` (Mac)
-2. Type "CodeBuddy: Analyze Codebase"
-3. Ask: "What are the main API endpoints and their structures?"
-
-### Test Case 3: Specific Truncation Pattern
-Ask questions that might trigger the `**API` truncation:
-```
-"Show me all the API endpoints and explain their functionality"
-"What are the main API patterns and best practices used?"
-```
-
-## 📊 Debug Information
-
-The system now logs detailed debug information in the Developer Console:
-
-1. **Open VS Code Developer Console**: 
-   - Help → Toggle Developer Tools → Console tab
-
-2. **Look for these debug messages**:
-   - `[DEBUG] Response length: X characters`
-   - `[DEBUG] Response ends with: "..."`
-   - `[DEBUG] Response seems incomplete, attempting retry...`
-   - `[DEBUG] Retry response length: X characters`
-
-## 🎯 Expected Behavior
-
-✅ **Before Fix**: Responses cutting off at `**API`  
-✅ **After Fix**: Complete responses with automatic retry if truncation detected
-
-## 🔍 If Issues Persist
-
-If you still see truncation:
-1. Check the Developer Console for debug logs
-2. Note the exact pattern where truncation occurs
-3. The system should automatically retry and provide a complete response
-
-## 📝 Additional Notes
-
-- The retry mechanism adds ~2-3 seconds to response time when truncation is detected
-- Debug logging can be removed once the issue is confirmed fixed
-- The enhanced detection covers multiple truncation patterns beyond just `**API`
diff --git a/src/services/embedding-configuration.ts b/src/services/embedding-configuration.ts
new file mode 100644
index 0000000..027786f
--- /dev/null
+++ b/src/services/embedding-configuration.ts
@@ -0,0 +1,446 @@
+import * as vscode from "vscode";
+import { LanguageUtils } from "../utils/common-utils";
+
+export interface EmbeddingPhaseConfig {
+  enabled: boolean;
+  batchSize: number;
+  maxFiles: number;
+  delayBetweenBatches: number;
+  timeoutMs: number;
+  retryAttempts: number;
+  lowPriority: boolean;
+}
+
+export interface VectorDbSyncConfig {
+  enabled: boolean;
+  filePatterns: string[];
+  excludePatterns: string[];
+  syncDelayMs: number;
+  batchSize: number;
+  maxBatchSize: number;
+  enableBackgroundSync: boolean;
+  enableFileWatching: boolean;
+}
+
+export interface SmartEmbeddingConfig {
+  immediate: EmbeddingPhaseConfig;
+  onDemand: EmbeddingPhaseConfig;
+  background: EmbeddingPhaseConfig;
+  bulk: EmbeddingPhaseConfig;
+  sync: VectorDbSyncConfig;
+  general: {
+    maxConcurrentOperations: number;
+    enableProgressReporting: boolean;
+    enableDetailedLogging: boolean;
+    workspaceAnalysisDepth: "shallow" | "medium" | "deep";
+    embeddingModel: string;
+    embeddingProvider: "gemini" | "openai" | "local";
+  };
+}
+
+/**
+ * Configuration manager for smart embedding phases.
+ * Provides centralized configuration with defaults and user overrides.
+ */
+export class EmbeddingConfigurationManager {
+  private static instance: EmbeddingConfigurationManager;
+  private config: SmartEmbeddingConfig;
+
+  private constructor() {
+    this.config = this.loadConfiguration();
+  }
+
+  static getInstance(): EmbeddingConfigurationManager {
+    if (!EmbeddingConfigurationManager.instance) {
+      EmbeddingConfigurationManager.instance =
+        new EmbeddingConfigurationManager();
+    }
+    return EmbeddingConfigurationManager.instance;
+  }
+
+  /**
+   * Get complete configuration
+   */
+  getConfig(): SmartEmbeddingConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Get configuration for specific embedding phase
+   */
+  getPhaseConfig(
+    phase: "immediate" | "onDemand" | "background" | "bulk",
+  ): EmbeddingPhaseConfig {
+    return { ...this.config[phase] };
+  }
+
+  /**
+   * Get sync configuration
+   */
+  getSyncConfig(): VectorDbSyncConfig {
+    return { ...this.config.sync };
+  }
+
+  /**
+   * Update configuration (persists to VS Code settings)
+   */
+  async updateConfig(updates: Partial<SmartEmbeddingConfig>): Promise<void> {
+    this.config = { ...this.config, ...updates };
+    await this.saveConfiguration();
+  }
+
+  /**
+   * Update specific phase configuration
+   */
+  async updatePhaseConfig(
+    phase: "immediate" | "onDemand" | "background" | "bulk",
+    updates: Partial<EmbeddingPhaseConfig>,
+  ): Promise<void> {
+    this.config[phase] = { ...this.config[phase], ...updates };
+    await this.saveConfiguration();
+  }
+
+  /**
+   * Reset to default configuration
+   */
+  async resetToDefaults(): Promise<void> {
+    this.config = this.getDefaultConfiguration();
+    await this.saveConfiguration();
+  }
+
+  /**
+   * Get file patterns for monitoring
+   */
+  getFilePatterns(): string[] {
+    return this.config.sync.filePatterns;
+  }
+
+  /**
+   * Get exclude patterns
+   */
+  getExcludePatterns(): string[] {
+    return this.config.sync.excludePatterns;
+  }
+
+  /**
+   * Check if background processing should be enabled based on workspace size
+   */
+  shouldEnableBackgroundProcessing(): boolean {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      return false;
+    }
+
+    // Enable background processing based on configuration and workspace size
+    return (
+      this.config.background.enabled && this.config.sync.enableBackgroundSync
+    );
+  }
+
+  /**
+   * Get optimal batch size based on system resources and configuration
+   */
+  getOptimalBatchSize(
+    phase: "immediate" | "onDemand" | "background" | "bulk",
+  ): number {
+    const baseSize = this.config[phase].batchSize;
+
+    // Adjust based on system capabilities (simplified)
+    const memoryGB =
+      Math.round((process.memoryUsage().heapTotal / 1024 / 1024 / 1024) * 10) /
+      10;
+
+    if (memoryGB < 1) {
+      return Math.max(1, Math.floor(baseSize * 0.5));
+    } else if (memoryGB > 4) {
+      return Math.floor(baseSize * 1.5);
+    }
+
+    return baseSize;
+  }
+
+  private loadConfiguration(): SmartEmbeddingConfig {
+    const vsCodeConfig = vscode.workspace.getConfiguration(
+      "codebuddy.smartEmbedding",
+    );
+    const defaults = this.getDefaultConfiguration();
+
+    return {
+      immediate: {
+        enabled: vsCodeConfig.get(
+          "immediate.enabled",
+          defaults.immediate.enabled,
+        ),
+        batchSize: vsCodeConfig.get(
+          "immediate.batchSize",
+          defaults.immediate.batchSize,
+        ),
+        maxFiles: vsCodeConfig.get(
+          "immediate.maxFiles",
+          defaults.immediate.maxFiles,
+        ),
+        delayBetweenBatches: vsCodeConfig.get(
+          "immediate.delayBetweenBatches",
+          defaults.immediate.delayBetweenBatches,
+        ),
+        timeoutMs: vsCodeConfig.get(
+          "immediate.timeoutMs",
+          defaults.immediate.timeoutMs,
+        ),
+        retryAttempts: vsCodeConfig.get(
+          "immediate.retryAttempts",
+          defaults.immediate.retryAttempts,
+        ),
+        lowPriority: vsCodeConfig.get(
+          "immediate.lowPriority",
+          defaults.immediate.lowPriority,
+        ),
+      },
+      onDemand: {
+        enabled: vsCodeConfig.get(
+          "onDemand.enabled",
+          defaults.onDemand.enabled,
+        ),
+        batchSize: vsCodeConfig.get(
+          "onDemand.batchSize",
+          defaults.onDemand.batchSize,
+        ),
+        maxFiles: vsCodeConfig.get(
+          "onDemand.maxFiles",
+          defaults.onDemand.maxFiles,
+        ),
+        delayBetweenBatches: vsCodeConfig.get(
+          "onDemand.delayBetweenBatches",
+          defaults.onDemand.delayBetweenBatches,
+        ),
+        timeoutMs: vsCodeConfig.get(
+          "onDemand.timeoutMs",
+          defaults.onDemand.timeoutMs,
+        ),
+        retryAttempts: vsCodeConfig.get(
+          "onDemand.retryAttempts",
+          defaults.onDemand.retryAttempts,
+        ),
+        lowPriority: vsCodeConfig.get(
+          "onDemand.lowPriority",
+          defaults.onDemand.lowPriority,
+        ),
+      },
+      background: {
+        enabled: vsCodeConfig.get(
+          "background.enabled",
+          defaults.background.enabled,
+        ),
+        batchSize: vsCodeConfig.get(
+          "background.batchSize",
+          defaults.background.batchSize,
+        ),
+        maxFiles: vsCodeConfig.get(
+          "background.maxFiles",
+          defaults.background.maxFiles,
+        ),
+        delayBetweenBatches: vsCodeConfig.get(
+          "background.delayBetweenBatches",
+          defaults.background.delayBetweenBatches,
+        ),
+        timeoutMs: vsCodeConfig.get(
+          "background.timeoutMs",
+          defaults.background.timeoutMs,
+        ),
+        retryAttempts: vsCodeConfig.get(
+          "background.retryAttempts",
+          defaults.background.retryAttempts,
+        ),
+        lowPriority: vsCodeConfig.get(
+          "background.lowPriority",
+          defaults.background.lowPriority,
+        ),
+      },
+      bulk: {
+        enabled: vsCodeConfig.get("bulk.enabled", defaults.bulk.enabled),
+        batchSize: vsCodeConfig.get("bulk.batchSize", defaults.bulk.batchSize),
+        maxFiles: vsCodeConfig.get("bulk.maxFiles", defaults.bulk.maxFiles),
+        delayBetweenBatches: vsCodeConfig.get(
+          "bulk.delayBetweenBatches",
+          defaults.bulk.delayBetweenBatches,
+        ),
+        timeoutMs: vsCodeConfig.get("bulk.timeoutMs", defaults.bulk.timeoutMs),
+        retryAttempts: vsCodeConfig.get(
+          "bulk.retryAttempts",
+          defaults.bulk.retryAttempts,
+        ),
+        lowPriority: vsCodeConfig.get(
+          "bulk.lowPriority",
+          defaults.bulk.lowPriority,
+        ),
+      },
+      sync: {
+        enabled: vsCodeConfig.get("sync.enabled", defaults.sync.enabled),
+        filePatterns: vsCodeConfig.get(
+          "sync.filePatterns",
+          defaults.sync.filePatterns,
+        ),
+        excludePatterns: vsCodeConfig.get(
+          "sync.excludePatterns",
+          defaults.sync.excludePatterns,
+        ),
+        syncDelayMs: vsCodeConfig.get(
+          "sync.syncDelayMs",
+          defaults.sync.syncDelayMs,
+        ),
+        batchSize: vsCodeConfig.get("sync.batchSize", defaults.sync.batchSize),
+        maxBatchSize: vsCodeConfig.get(
+          "sync.maxBatchSize",
+          defaults.sync.maxBatchSize,
+        ),
+        enableBackgroundSync: vsCodeConfig.get(
+          "sync.enableBackgroundSync",
+          defaults.sync.enableBackgroundSync,
+        ),
+        enableFileWatching: vsCodeConfig.get(
+          "sync.enableFileWatching",
+          defaults.sync.enableFileWatching,
+        ),
+      },
+      general: {
+        maxConcurrentOperations: vsCodeConfig.get(
+          "general.maxConcurrentOperations",
+          defaults.general.maxConcurrentOperations,
+        ),
+        enableProgressReporting: vsCodeConfig.get(
+          "general.enableProgressReporting",
+          defaults.general.enableProgressReporting,
+        ),
+        enableDetailedLogging: vsCodeConfig.get(
+          "general.enableDetailedLogging",
+          defaults.general.enableDetailedLogging,
+        ),
+        workspaceAnalysisDepth: vsCodeConfig.get(
+          "general.workspaceAnalysisDepth",
+          defaults.general.workspaceAnalysisDepth,
+        ),
+        embeddingModel: vsCodeConfig.get(
+          "general.embeddingModel",
+          defaults.general.embeddingModel,
+        ),
+        embeddingProvider: vsCodeConfig.get(
+          "general.embeddingProvider",
+          defaults.general.embeddingProvider,
+        ),
+      },
+    };
+  }
+
+  private async saveConfiguration(): Promise<void> {
+    const vsCodeConfig = vscode.workspace.getConfiguration(
+      "codebuddy.smartEmbedding",
+    );
+
+    // Save immediate phase config
+    await vsCodeConfig.update(
+      "immediate",
+      this.config.immediate,
+      vscode.ConfigurationTarget.Workspace,
+    );
+    await vsCodeConfig.update(
+      "onDemand",
+      this.config.onDemand,
+      vscode.ConfigurationTarget.Workspace,
+    );
+    await vsCodeConfig.update(
+      "background",
+      this.config.background,
+      vscode.ConfigurationTarget.Workspace,
+    );
+    await vsCodeConfig.update(
+      "bulk",
+      this.config.bulk,
+      vscode.ConfigurationTarget.Workspace,
+    );
+    await vsCodeConfig.update(
+      "sync",
+      this.config.sync,
+      vscode.ConfigurationTarget.Workspace,
+    );
+    await vsCodeConfig.update(
+      "general",
+      this.config.general,
+      vscode.ConfigurationTarget.Workspace,
+    );
+  }
+
+  private getDefaultConfiguration(): SmartEmbeddingConfig {
+    const codeExtensions = LanguageUtils.getCodeFileExtensions();
+    const filePatterns = codeExtensions.map((ext) => `**/*.${ext}`);
+
+    return {
+      immediate: {
+        enabled: true,
+        batchSize: 5,
+        maxFiles: 20,
+        delayBetweenBatches: 100,
+        timeoutMs: 30000,
+        retryAttempts: 3,
+        lowPriority: false,
+      },
+      onDemand: {
+        enabled: true,
+        batchSize: 3,
+        maxFiles: 15,
+        delayBetweenBatches: 200,
+        timeoutMs: 20000,
+        retryAttempts: 2,
+        lowPriority: false,
+      },
+      background: {
+        enabled: true,
+        batchSize: 10,
+        maxFiles: 100,
+        delayBetweenBatches: 1000,
+        timeoutMs: 60000,
+        retryAttempts: 1,
+        lowPriority: true,
+      },
+      bulk: {
+        enabled: true,
+        batchSize: 20,
+        maxFiles: -1, // No limit
+        delayBetweenBatches: 500,
+        timeoutMs: 120000,
+        retryAttempts: 2,
+        lowPriority: true,
+      },
+      sync: {
+        enabled: true,
+        filePatterns,
+        excludePatterns: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/out/**",
+          "**/.git/**",
+          "**/coverage/**",
+          "**/.vscode-test/**",
+          "**/*.min.js",
+          "**/*.bundle.js",
+          "**/*.d.ts",
+          "**/.DS_Store",
+          "**/Thumbs.db",
+        ],
+        syncDelayMs: 1000,
+        batchSize: 10,
+        maxBatchSize: 50,
+        enableBackgroundSync: true,
+        enableFileWatching: true,
+      },
+      general: {
+        maxConcurrentOperations: 3,
+        enableProgressReporting: true,
+        enableDetailedLogging: false,
+        workspaceAnalysisDepth: "medium",
+        embeddingModel: "gemini-2.0-flash",
+        embeddingProvider: "gemini",
+      },
+    };
+  }
+}
diff --git a/src/services/embedding-phase-factory.ts b/src/services/embedding-phase-factory.ts
new file mode 100644
index 0000000..e1a1f1d
--- /dev/null
+++ b/src/services/embedding-phase-factory.ts
@@ -0,0 +1,328 @@
+import * as vscode from "vscode";
+import { VectorDatabaseService } from "./vector-database.service";
+import { VectorDbWorkerManager } from "./vector-db-worker-manager";
+import { EmbeddingService } from "./embedding-service";
+import { FileService } from "./file-service";
+import { EmbeddingConfigurationManager } from "./embedding-configuration";
+import {
+  ImmediateEmbeddingPhase,
+  OnDemandEmbeddingPhase,
+  BackgroundEmbeddingPhase,
+  BulkEmbeddingPhase,
+} from "./smart-embedding-phases";
+import { Logger, LogLevel } from "../infrastructure/logger/logger";
+
+export interface EmbeddingPhaseFactoryOptions {
+  vectorDb: VectorDatabaseService;
+  workerManager: VectorDbWorkerManager;
+  context: vscode.ExtensionContext;
+  enableBackgroundProcessing?: boolean;
+  enableProgressReporting?: boolean;
+}
+
+export interface EmbeddingPhaseServices {
+  embeddingService: EmbeddingService;
+  fileService: FileService;
+  configManager: EmbeddingConfigurationManager;
+  logger: Logger;
+}
+
+export interface CreatedPhases {
+  immediate: ImmediateEmbeddingPhase;
+  onDemand: OnDemandEmbeddingPhase;
+  background: BackgroundEmbeddingPhase;
+  bulk: BulkEmbeddingPhase;
+  services: EmbeddingPhaseServices;
+}
+
+/**
+ * Factory for creating embedding phase instances with proper dependency injection.
+ * Implements the Factory pattern to simplify object creation and configuration.
+ */
+export class EmbeddingPhaseFactory {
+  private static instance: EmbeddingPhaseFactory;
+  private logger: Logger;
+
+  private constructor() {
+    this.logger = Logger.initialize("EmbeddingPhaseFactory", {
+      minLevel: LogLevel.INFO,
+    });
+  }
+
+  static getInstance(): EmbeddingPhaseFactory {
+    if (!EmbeddingPhaseFactory.instance) {
+      EmbeddingPhaseFactory.instance = new EmbeddingPhaseFactory();
+    }
+    return EmbeddingPhaseFactory.instance;
+  }
+
+  /**
+   * Create all embedding phases with shared services
+   */
+  async createAllPhases(
+    options: EmbeddingPhaseFactoryOptions,
+  ): Promise<CreatedPhases> {
+    this.logger.info("Creating embedding phases with factory");
+
+    // Validate required dependencies
+    this.validateDependencies(options);
+
+    // Create shared services
+    const services = await this.createSharedServices(options);
+
+    // Create individual phases
+    const phases = await this.createIndividualPhases(services, options);
+
+    this.logger.info("All embedding phases created successfully");
+
+    return {
+      ...phases,
+      services,
+    };
+  }
+
+  /**
+   * Create a specific embedding phase
+   */
+  async createPhase<T extends keyof CreatedPhases>(
+    phaseType: T,
+    options: EmbeddingPhaseFactoryOptions,
+  ): Promise<CreatedPhases[T]> {
+    const services = await this.createSharedServices(options);
+
+    switch (phaseType) {
+      case "immediate":
+        return this.createImmediatePhase(services, options) as CreatedPhases[T];
+      case "onDemand":
+        return this.createOnDemandPhase(services, options) as CreatedPhases[T];
+      case "background":
+        return this.createBackgroundPhase(
+          services,
+          options,
+        ) as CreatedPhases[T];
+      case "bulk":
+        return this.createBulkPhase(services, options) as CreatedPhases[T];
+      default:
+        throw new Error(`Unknown phase type: ${phaseType}`);
+    }
+  }
+
+  /**
+   * Create phases with custom configuration
+   */
+  async createPhasesWithConfig(
+    options: EmbeddingPhaseFactoryOptions,
+    customConfig?: Partial<
+      import("./embedding-configuration").SmartEmbeddingConfig
+    >,
+  ): Promise<CreatedPhases> {
+    const services = await this.createSharedServices(options);
+
+    // Apply custom configuration if provided
+    if (customConfig) {
+      await services.configManager.updateConfig(customConfig);
+    }
+
+    const phases = await this.createIndividualPhases(services, options);
+
+    return {
+      ...phases,
+      services,
+    };
+  }
+
+  /**
+   * Create minimal phase setup for testing
+   */
+  async createTestPhases(
+    options: EmbeddingPhaseFactoryOptions,
+  ): Promise<CreatedPhases> {
+    // Override configuration for testing
+    const testConfig: Partial<
+      import("./embedding-configuration").SmartEmbeddingConfig
+    > = {
+      immediate: {
+        enabled: true,
+        batchSize: 2,
+        maxFiles: 5,
+        delayBetweenBatches: 0,
+        timeoutMs: 5000,
+        retryAttempts: 1,
+        lowPriority: false,
+      },
+      onDemand: {
+        enabled: true,
+        batchSize: 2,
+        maxFiles: 5,
+        delayBetweenBatches: 0,
+        timeoutMs: 5000,
+        retryAttempts: 1,
+        lowPriority: false,
+      },
+      background: {
+        enabled: false,
+        batchSize: 2,
+        maxFiles: 5,
+        delayBetweenBatches: 0,
+        timeoutMs: 5000,
+        retryAttempts: 1,
+        lowPriority: true,
+      },
+      bulk: {
+        enabled: true,
+        batchSize: 5,
+        maxFiles: 10,
+        delayBetweenBatches: 0,
+        timeoutMs: 10000,
+        retryAttempts: 1,
+        lowPriority: true,
+      },
+      general: {
+        maxConcurrentOperations: 1,
+        enableProgressReporting: false,
+        enableDetailedLogging: true,
+        workspaceAnalysisDepth: "shallow" as const,
+        embeddingModel: "gemini-2.0-flash",
+        embeddingProvider: "gemini" as const,
+      },
+    };
+
+    return this.createPhasesWithConfig(options, testConfig);
+  }
+
+  private async createSharedServices(
+    options: EmbeddingPhaseFactoryOptions,
+  ): Promise<EmbeddingPhaseServices> {
+    const embeddingService = new EmbeddingService(
+      options.vectorDb,
+      options.workerManager,
+    );
+    const fileService = new FileService();
+    const configManager = EmbeddingConfigurationManager.getInstance();
+    const logger = Logger.initialize("EmbeddingPhases", {
+      minLevel: LogLevel.INFO,
+    });
+
+    this.logger.debug("Shared services created");
+
+    return {
+      embeddingService,
+      fileService,
+      configManager,
+      logger,
+    };
+  }
+
+  private async createIndividualPhases(
+    services: EmbeddingPhaseServices,
+    options: EmbeddingPhaseFactoryOptions,
+  ): Promise<Omit<CreatedPhases, "services">> {
+    const immediate = this.createImmediatePhase(services, options);
+    const onDemand = this.createOnDemandPhase(services, options);
+    const background = this.createBackgroundPhase(services, options);
+    const bulk = this.createBulkPhase(services, options);
+
+    return {
+      immediate,
+      onDemand,
+      background,
+      bulk,
+    };
+  }
+
+  private createImmediatePhase(
+    services: EmbeddingPhaseServices,
+    options: EmbeddingPhaseFactoryOptions,
+  ): ImmediateEmbeddingPhase {
+    return new ImmediateEmbeddingPhase(options.workerManager);
+  }
+
+  private createOnDemandPhase(
+    services: EmbeddingPhaseServices,
+    options: EmbeddingPhaseFactoryOptions,
+  ): OnDemandEmbeddingPhase {
+    return new OnDemandEmbeddingPhase(options.workerManager);
+  }
+
+  private createBackgroundPhase(
+    services: EmbeddingPhaseServices,
+    options: EmbeddingPhaseFactoryOptions,
+  ): BackgroundEmbeddingPhase {
+    return new BackgroundEmbeddingPhase(options.workerManager);
+  }
+
+  private createBulkPhase(
+    services: EmbeddingPhaseServices,
+    options: EmbeddingPhaseFactoryOptions,
+  ): BulkEmbeddingPhase {
+    return new BulkEmbeddingPhase(options.workerManager);
+  }
+
+  private validateDependencies(options: EmbeddingPhaseFactoryOptions): void {
+    if (!options.vectorDb) {
+      throw new Error("VectorDatabaseService is required");
+    }
+
+    if (!options.workerManager) {
+      throw new Error("VectorDbWorkerManager is required");
+    }
+
+    if (!options.context) {
+      throw new Error("VS Code ExtensionContext is required");
+    }
+
+    if (!options.vectorDb.isReady()) {
+      throw new Error(
+        "VectorDatabaseService must be initialized before creating phases",
+      );
+    }
+
+    if (!options.workerManager.isReady()) {
+      throw new Error(
+        "VectorDbWorkerManager must be initialized before creating phases",
+      );
+    }
+
+    this.logger.debug("Dependencies validated successfully");
+  }
+
+  /**
+   * Create a lightweight phase configuration for specific use cases
+   */
+  createPhaseConfiguration(
+    phaseType: "immediate" | "onDemand" | "background" | "bulk",
+  ): {
+    enabled: boolean;
+    batchSize: number;
+    maxFiles: number;
+    priority: "high" | "normal" | "low";
+  } {
+    const configManager = EmbeddingConfigurationManager.getInstance();
+    const config = configManager.getPhaseConfig(phaseType);
+
+    return {
+      enabled: config.enabled,
+      batchSize: configManager.getOptimalBatchSize(phaseType),
+      maxFiles: config.maxFiles,
+      priority: config.lowPriority
+        ? "low"
+        : phaseType === "immediate"
+          ? "high"
+          : "normal",
+    };
+  }
+
+  /**
+   * Dispose all created phases
+   */
+  static disposePhases(phases: CreatedPhases): void {
+    try {
+      phases.immediate.dispose();
+      phases.onDemand.dispose();
+      phases.background.dispose();
+      phases.bulk.dispose();
+    } catch (error) {
+      console.warn("Error disposing embedding phases:", error);
+    }
+  }
+}
diff --git a/src/services/embedding-service.ts b/src/services/embedding-service.ts
new file mode 100644
index 0000000..ebba1de
--- /dev/null
+++ b/src/services/embedding-service.ts
@@ -0,0 +1,318 @@
+import { Logger, LogLevel } from "../infrastructure/logger/logger";
+import { VectorDatabaseService, CodeSnippet } from "./vector-database.service";
+import {
+  VectorDbWorkerManager,
+  VECTOR_OPERATIONS,
+} from "./vector-db-worker-manager";
+import { FileUtils, AsyncUtils } from "../utils/common-utils";
+import { IFunctionData } from "../application/interfaces";
+import * as path from "path";
+import * as vscode from "vscode";
+
+export interface EmbeddingOptions {
+  retryCount?: number;
+  timeout?: number;
+  priority?: "high" | "normal" | "low";
+}
+
+export interface EmbeddingResult {
+  success: boolean;
+  filePath: string;
+  snippetsCreated: number;
+  error?: string;
+  duration: number;
+}
+
+/**
+ * Dedicated service for handling file embedding operations.
+ * Eliminates duplication across embedding phases and provides centralized embedding logic.
+ */
+export class EmbeddingService {
+  private logger: Logger;
+
+  constructor(
+    private vectorDb: VectorDatabaseService,
+    private workerManager: VectorDbWorkerManager,
+  ) {
+    this.logger = Logger.initialize("EmbeddingService", {
+      minLevel: LogLevel.INFO,
+    });
+  }
+
+  /**
+   * Embed a single file with comprehensive error handling and retry logic
+   */
+  async embedFile(
+    filePath: string,
+    options: EmbeddingOptions = {},
+  ): Promise<EmbeddingResult> {
+    const startTime = Date.now();
+    const { retryCount = 3, timeout = 30000, priority = "normal" } = options;
+
+    this.logger.debug(`Starting embedding for: ${path.basename(filePath)}`);
+
+    try {
+      // Validate file exists and is readable
+      if (!(await FileUtils.fileExists(filePath))) {
+        throw new Error(`File does not exist: ${filePath}`);
+      }
+
+      // Read file content
+      const content = await this.readFileWithTimeout(filePath, timeout);
+      if (!content || content.trim().length === 0) {
+        this.logger.debug(`Skipping empty file: ${path.basename(filePath)}`);
+        return {
+          success: true,
+          filePath,
+          snippetsCreated: 0,
+          duration: Date.now() - startTime,
+        };
+      }
+
+      // Generate embeddings using worker
+      const embeddings = await this.generateEmbeddingsWithRetry(
+        filePath,
+        content,
+        retryCount,
+      );
+
+      // Create code snippets
+      const snippets = await this.createCodeSnippets(
+        filePath,
+        content,
+        embeddings,
+      );
+
+      // Index in vector database
+      if (snippets.length > 0) {
+        await this.vectorDb.indexCodeSnippets(snippets);
+        this.logger.debug(
+          `Embedded ${snippets.length} snippets from ${path.basename(filePath)}`,
+        );
+      }
+
+      return {
+        success: true,
+        filePath,
+        snippetsCreated: snippets.length,
+        duration: Date.now() - startTime,
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.logger.error(`Failed to embed file ${filePath}:`, error);
+
+      return {
+        success: false,
+        filePath,
+        snippetsCreated: 0,
+        error: error instanceof Error ? error.message : String(error),
+        duration,
+      };
+    }
+  }
+
+  /**
+   * Embed multiple files in batches with progress tracking
+   */
+  async embedFiles(
+    filePaths: string[],
+    options: EmbeddingOptions & {
+      batchSize?: number;
+      progressCallback?: (progress: number, details: string) => void;
+    } = {},
+  ): Promise<EmbeddingResult[]> {
+    const { batchSize = 5, progressCallback } = options;
+    const results: EmbeddingResult[] = [];
+
+    this.logger.info(`Starting batch embedding of ${filePaths.length} files`);
+
+    await AsyncUtils.processBatchesWithProgress(
+      filePaths,
+      async (filePath, index) => {
+        const result = await this.embedFile(filePath, options);
+        results.push(result);
+
+        if (progressCallback) {
+          const progress = ((index + 1) / filePaths.length) * 100;
+          const status = result.success
+            ? `Embedded ${path.basename(filePath)}`
+            : `Failed: ${path.basename(filePath)}`;
+          progressCallback(progress, status);
+        }
+      },
+      batchSize,
+    );
+
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+
+    this.logger.info(
+      `Batch embedding completed: ${successful} succeeded, ${failed} failed`,
+    );
+
+    return results;
+  }
+
+  /**
+   * Remove embeddings for a file (when file is deleted or modified)
+   */
+  async removeFileEmbeddings(filePath: string): Promise<boolean> {
+    try {
+      await this.vectorDb.deleteByFile(filePath);
+      this.logger.debug(`Removed embeddings for: ${path.basename(filePath)}`);
+      return true;
+    } catch (error) {
+      this.logger.error(`Failed to remove embeddings for ${filePath}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if file has embeddings in the vector database
+   */
+  async hasEmbeddings(filePath: string): Promise<boolean> {
+    try {
+      // This would need to be implemented in VectorDatabaseService
+      // For now, assume we need to check by searching
+      const results = await this.vectorDb.semanticSearch(`file:${filePath}`, 1);
+      return results.length > 0;
+    } catch (error) {
+      this.logger.warn(`Could not check embeddings for ${filePath}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Get embedding statistics for a file or all files
+   */
+  async getEmbeddingStats(filePath?: string): Promise<{
+    totalSnippets: number;
+    lastUpdated?: string;
+    fileCount: number;
+  }> {
+    const stats = this.vectorDb.getStats();
+
+    return {
+      totalSnippets: stats.documentCount,
+      lastUpdated: stats.lastSync || undefined,
+      fileCount: stats.documentCount, // Approximate
+    };
+  }
+
+  private async readFileWithTimeout(
+    filePath: string,
+    timeout: number,
+  ): Promise<string> {
+    return AsyncUtils.safeExecute(
+      async () => {
+        const uri = vscode.Uri.file(filePath);
+        const bytes = await vscode.workspace.fs.readFile(uri);
+        return new TextDecoder().decode(bytes);
+      },
+      "",
+      (error) => this.logger.warn(`Could not read file ${filePath}:`, error),
+    );
+  }
+
+  private async generateEmbeddingsWithRetry(
+    filePath: string,
+    content: string,
+    maxRetries: number,
+  ): Promise<number[]> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        // Use worker manager to generate embeddings
+        // Create IFunctionData for the file content
+        const functionData: IFunctionData = {
+          className: path.dirname(filePath),
+          path: filePath,
+          name: path.basename(filePath, path.extname(filePath)),
+          compositeText: content,
+          content: content,
+          description: `File: ${path.basename(filePath)}`,
+          processedAt: new Date().toISOString(),
+        };
+
+        // Use worker manager to process the function data
+        await this.workerManager.indexFunctionData([functionData]);
+
+        // For now, return a mock embedding array - in actual implementation
+        // this would be handled by the worker manager internally
+        return Array.from({ length: 1536 }, () => Math.random());
+      } catch (error) {
+        lastError = error as Error;
+        this.logger.warn(
+          `Embedding attempt ${attempt}/${maxRetries} failed for ${filePath}:`,
+          error,
+        );
+
+        if (attempt < maxRetries) {
+          // Exponential backoff
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+          await AsyncUtils.delay(delay);
+        }
+      }
+    }
+
+    throw lastError || new Error("Failed to generate embeddings after retries");
+  }
+
+  private async createCodeSnippets(
+    filePath: string,
+    content: string,
+    embeddings: number[],
+  ): Promise<CodeSnippet[]> {
+    // For now, create a single snippet for the entire file
+    // In the future, this could be enhanced to parse functions/classes
+    const lines = content.split("\n");
+
+    return [
+      {
+        id: `file::${filePath}::${Date.now()}`,
+        filePath,
+        type: "module" as const,
+        name: FileUtils.getRelativePath(filePath),
+        content:
+          content.length > 2000 ? content.substring(0, 2000) + "..." : content,
+        metadata: {
+          language: this.getLanguageFromPath(filePath),
+          fileSize: content.length,
+          lineCount: lines.length,
+          startLine: 1,
+          endLine: lines.length,
+          embedding: embeddings,
+          lastModified: new Date().toISOString(),
+        },
+      },
+    ];
+  }
+
+  private getLanguageFromPath(filePath: string): string {
+    const extension = path.extname(filePath).toLowerCase();
+    const languageMap: Record<string, string> = {
+      ".ts": "typescript",
+      ".js": "javascript",
+      ".tsx": "tsx",
+      ".jsx": "jsx",
+      ".py": "python",
+      ".java": "java",
+      ".cpp": "cpp",
+      ".c": "c",
+      ".cs": "csharp",
+      ".php": "php",
+      ".rb": "ruby",
+      ".go": "go",
+      ".rs": "rust",
+      ".swift": "swift",
+      ".kt": "kotlin",
+      ".scala": "scala",
+      ".r": "r",
+      ".m": "objective-c",
+      ".vue": "vue",
+    };
+
+    return languageMap[extension] || "plaintext";
+  }
+}
diff --git a/src/services/file-service.ts b/src/services/file-service.ts
new file mode 100644
index 0000000..50acda4
--- /dev/null
+++ b/src/services/file-service.ts
@@ -0,0 +1,405 @@
+import * as vscode from "vscode";
+import * as path from "path";
+import { Logger, LogLevel } from "../infrastructure/logger/logger";
+import { LanguageUtils, AsyncUtils } from "../utils/common-utils";
+
+export interface FileMetadata {
+  size: number;
+  lastModified: Date;
+  language: string;
+  isCode: boolean;
+  lineCount?: number;
+}
+
+export interface FileReadOptions {
+  timeout?: number;
+  encoding?: string;
+  maxSize?: number;
+}
+
+export interface FileSystemWatchOptions {
+  patterns: string[];
+  ignorePatterns?: string[];
+  recursive?: boolean;
+}
+
+/**
+ * FileService abstracts file system operations to improve testability
+ * and decouple embedding phases from direct VS Code API calls.
+ */
+export class FileService {
+  private logger: Logger;
+
+  constructor() {
+    this.logger = Logger.initialize("FileService", {
+      minLevel: LogLevel.INFO,
+    });
+  }
+
+  /**
+   * Check if a file exists
+   */
+  async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await vscode.workspace.fs.stat(vscode.Uri.file(filePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Read file content with options and error handling
+   */
+  async readFile(
+    filePath: string,
+    options: FileReadOptions = {},
+  ): Promise<string> {
+    const {
+      timeout = 30000,
+      encoding = "utf8",
+      maxSize = 10 * 1024 * 1024,
+    } = options;
+
+    try {
+      const uri = vscode.Uri.file(filePath);
+
+      // Check file size first
+      const stat = await vscode.workspace.fs.stat(uri);
+      if (stat.size > maxSize) {
+        throw new Error(`File too large: ${stat.size} bytes (max: ${maxSize})`);
+      }
+
+      // Read with timeout
+      const bytes = await AsyncUtils.safeExecute(
+        async () => vscode.workspace.fs.readFile(uri),
+        new Uint8Array(),
+        (error) => this.logger.warn(`Failed to read file ${filePath}:`, error),
+      );
+
+      return new TextDecoder(encoding).decode(bytes);
+    } catch (error) {
+      this.logger.error(`Error reading file ${filePath}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Write file content
+   */
+  async writeFile(
+    filePath: string,
+    content: string,
+    encoding: string = "utf8",
+  ): Promise<void> {
+    try {
+      const uri = vscode.Uri.file(filePath);
+      const bytes = new TextEncoder().encode(content);
+      await vscode.workspace.fs.writeFile(uri, bytes);
+      this.logger.debug(`File written: ${path.basename(filePath)}`);
+    } catch (error) {
+      this.logger.error(`Error writing file ${filePath}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get file metadata with safe error handling
+   */
+  async getFileMetadata(filePath: string): Promise<FileMetadata | null> {
+    try {
+      const uri = vscode.Uri.file(filePath);
+      const stat = await vscode.workspace.fs.stat(uri);
+      const content = await this.readFile(filePath, { maxSize: 1024 * 1024 }); // Read up to 1MB for line count
+
+      return {
+        size: stat.size,
+        lastModified: new Date(stat.mtime),
+        language: LanguageUtils.getLanguageFromPath(filePath),
+        isCode: LanguageUtils.isCodeFileByPath(filePath),
+        lineCount: content ? content.split("\n").length : undefined,
+      };
+    } catch (error) {
+      this.logger.warn(`Could not get metadata for ${filePath}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Find files matching patterns with filtering
+   */
+  async findFiles(
+    includePatterns: string[],
+    excludePatterns: string[] = [],
+    workspaceFolder?: vscode.WorkspaceFolder,
+  ): Promise<string[]> {
+    const folders = workspaceFolder
+      ? [workspaceFolder]
+      : vscode.workspace.workspaceFolders || [];
+    const allFiles: string[] = [];
+
+    for (const folder of folders) {
+      for (const pattern of includePatterns) {
+        try {
+          const excludePattern =
+            excludePatterns.length > 0
+              ? `{${excludePatterns.join(",")}}`
+              : undefined;
+
+          const files = await vscode.workspace.findFiles(
+            new vscode.RelativePattern(folder, pattern),
+            excludePattern,
+          );
+
+          allFiles.push(...files.map((uri) => uri.fsPath));
+        } catch (error) {
+          this.logger.warn(
+            `Error finding files with pattern ${pattern}:`,
+            error,
+          );
+        }
+      }
+    }
+
+    // Remove duplicates
+    return [...new Set(allFiles)];
+  }
+
+  /**
+   * Get recently modified files within a time range
+   */
+  async getRecentlyModifiedFiles(
+    patterns: string[],
+    daysBack: number = 7,
+    excludePatterns: string[] = [],
+  ): Promise<string[]> {
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysBack);
+
+    const allFiles = await this.findFiles(patterns, excludePatterns);
+    const recentFiles: string[] = [];
+
+    for (const filePath of allFiles) {
+      try {
+        const stat = await vscode.workspace.fs.stat(vscode.Uri.file(filePath));
+        const modifiedDate = new Date(stat.mtime);
+
+        if (modifiedDate > cutoffDate) {
+          recentFiles.push(filePath);
+        }
+      } catch (error) {
+        this.logger.warn(`Could not get stats for file ${filePath}:`, error);
+        continue;
+      }
+    }
+
+    // Sort by modification time (newest first)
+    recentFiles.sort((a, b) => {
+      try {
+        // This is a simplified sort - in production you'd want to cache the stats
+        return b.localeCompare(a); // Sort by path as proxy for recency
+      } catch {
+        return 0;
+      }
+    });
+
+    return recentFiles;
+  }
+
+  /**
+   * Get entry point files (main files of the project)
+   */
+  async findEntryPoints(): Promise<string[]> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const entryPoints: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      try {
+        // Check package.json for main entry
+        const packageJsonPath = path.join(folder.uri.fsPath, "package.json");
+        if (await this.fileExists(packageJsonPath)) {
+          const packageContent = await this.readFile(packageJsonPath);
+          const packageJson = JSON.parse(packageContent);
+
+          if (packageJson.main) {
+            const mainPath = path.resolve(folder.uri.fsPath, packageJson.main);
+            if (await this.fileExists(mainPath)) {
+              entryPoints.push(mainPath);
+            }
+          }
+        }
+
+        // Check common entry points
+        const commonEntries = [
+          "src/index.ts",
+          "src/main.ts",
+          "src/app.ts",
+          "index.ts",
+          "main.ts",
+          "app.ts",
+          "src/index.js",
+          "src/main.js",
+          "src/app.js",
+          "index.js",
+          "main.js",
+          "app.js",
+        ];
+
+        for (const entry of commonEntries) {
+          const entryPath = path.join(folder.uri.fsPath, entry);
+          if (await this.fileExists(entryPath)) {
+            entryPoints.push(entryPath);
+          }
+        }
+      } catch (error) {
+        this.logger.debug(
+          `No package.json found in ${folder.uri.fsPath}:`,
+          error,
+        );
+      }
+    }
+
+    return [...new Set(entryPoints)]; // Remove duplicates
+  }
+
+  /**
+   * Get all code files in workspace
+   */
+  async getAllCodeFiles(excludePatterns: string[] = []): Promise<string[]> {
+    const codePatterns = [LanguageUtils.getCodeFileGlobPattern()];
+    const defaultExcludes = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/out/**",
+      "**/.git/**",
+      "**/coverage/**",
+      "**/*.min.js",
+      "**/*.bundle.js",
+      "**/*.d.ts",
+      ...excludePatterns,
+    ];
+
+    return this.findFiles(codePatterns, defaultExcludes);
+  }
+
+  /**
+   * Check if file is a test file
+   */
+  isTestFile(filePath: string): boolean {
+    const fileName = path.basename(filePath).toLowerCase();
+    const dirName = path.dirname(filePath).toLowerCase();
+
+    return (
+      fileName.includes("test") ||
+      fileName.includes("spec") ||
+      dirName.includes("test") ||
+      dirName.includes("spec") ||
+      fileName.endsWith(".test.ts") ||
+      fileName.endsWith(".test.js") ||
+      fileName.endsWith(".spec.ts") ||
+      fileName.endsWith(".spec.js")
+    );
+  }
+
+  /**
+   * Get related files (files in same directory or with similar names)
+   */
+  async getRelatedFiles(
+    filePath: string,
+    maxResults: number = 10,
+  ): Promise<string[]> {
+    const directory = path.dirname(filePath);
+    const baseName = path.basename(filePath, path.extname(filePath));
+
+    try {
+      // Get files in same directory
+      const directoryFiles = await this.findFiles(
+        [path.join(directory, "*")],
+        [],
+      );
+
+      // Filter and score by relevance
+      const relatedFiles = directoryFiles
+        .filter((f) => f !== filePath) // Exclude the original file
+        .map((f) => ({
+          path: f,
+          score: this.calculateRelatedScore(baseName, path.basename(f)),
+        }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxResults)
+        .map((f) => f.path);
+
+      return relatedFiles;
+    } catch (error) {
+      this.logger.warn(`Could not get related files for ${filePath}:`, error);
+      return [];
+    }
+  }
+
+  /**
+   * Create file system watcher with configurable options
+   */
+  createWatcher(
+    options: FileSystemWatchOptions,
+    onCreated?: (uri: vscode.Uri) => void,
+    onChanged?: (uri: vscode.Uri) => void,
+    onDeleted?: (uri: vscode.Uri) => void,
+  ): vscode.Disposable[] {
+    const disposables: vscode.Disposable[] = [];
+    const workspaceFolders = vscode.workspace.workspaceFolders || [];
+
+    for (const folder of workspaceFolders) {
+      for (const pattern of options.patterns) {
+        try {
+          const watcher = vscode.workspace.createFileSystemWatcher(
+            new vscode.RelativePattern(folder, pattern),
+          );
+
+          if (onCreated) watcher.onDidCreate(onCreated);
+          if (onChanged) watcher.onDidChange(onChanged);
+          if (onDeleted) watcher.onDidDelete(onDeleted);
+
+          disposables.push(watcher);
+        } catch (error) {
+          this.logger.error(
+            `Failed to create watcher for pattern ${pattern}:`,
+            error,
+          );
+        }
+      }
+    }
+
+    this.logger.info(`Created ${disposables.length} file watchers`);
+    return disposables;
+  }
+
+  private calculateRelatedScore(baseName: string, fileName: string): number {
+    const baseNameLower = baseName.toLowerCase();
+    const fileNameLower = fileName.toLowerCase();
+
+    let score = 0;
+
+    // Exact match bonus
+    if (fileNameLower.includes(baseNameLower)) {
+      score += 10;
+    }
+
+    // Test file bonus
+    if (
+      this.isTestFile(fileName) &&
+      baseNameLower === fileNameLower.replace(/\.(test|spec)/, "")
+    ) {
+      score += 15;
+    }
+
+    // Same extension bonus
+    if (path.extname(fileName) === path.extname(baseName)) {
+      score += 5;
+    }
+
+    return score;
+  }
+}
diff --git a/src/services/smart-embedding-phases.ts b/src/services/smart-embedding-phases.ts
new file mode 100644
index 0000000..980d5be
--- /dev/null
+++ b/src/services/smart-embedding-phases.ts
@@ -0,0 +1,984 @@
+import * as vscode from "vscode";
+import * as path from "path";
+import {
+  VectorDbWorkerManager,
+  VECTOR_OPERATIONS,
+} from "./vector-db-worker-manager";
+import { CodeIndexingService } from "./code-indexing";
+import { Logger, LogLevel } from "../infrastructure/logger/logger";
+import { IFunctionData } from "../application/interfaces";
+import {
+  LanguageUtils,
+  FileUtils,
+  AsyncUtils,
+  DisposableUtils,
+} from "../utils/common-utils";
+import { EmbeddingService } from "./embedding-service";
+import { FileService } from "./file-service";
+import { VectorDatabaseService } from "./vector-database.service";
+
+export interface EmbeddingPhaseOptions {
+  batchSize?: number;
+  maxFiles?: number;
+  silent?: boolean;
+  lowPriority?: boolean;
+}
+
+export interface EmbeddingProgressCallback {
+  (phase: string, progress: number, details: string): void;
+}
+
+/**
+ * Phase 1: Immediate Embedding - Essential files for instant productivity
+ * Embeds open files, entry points, and recently modified files
+ */
+export class ImmediateEmbeddingPhase implements vscode.Disposable {
+  private logger: Logger;
+  private disposables: vscode.Disposable[] = [];
+  private embeddingService: EmbeddingService | null = null;
+  private fileService: FileService;
+
+  constructor(
+    private workerManager: VectorDbWorkerManager,
+    private vectorDb?: VectorDatabaseService,
+  ) {
+    this.logger = Logger.initialize("ImmediateEmbeddingPhase", {
+      minLevel: LogLevel.INFO,
+    });
+
+    this.fileService = new FileService();
+
+    // Initialize embedding service if vector DB is provided
+    if (vectorDb) {
+      this.embeddingService = new EmbeddingService(vectorDb, workerManager);
+    }
+  }
+
+  dispose(): void {
+    DisposableUtils.safeDispose(this.disposables);
+    this.disposables = [];
+  }
+
+  async embedEssentials(
+    context: vscode.ExtensionContext,
+    progressCallback?: EmbeddingProgressCallback,
+  ): Promise<void> {
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: "Preparing CodeBuddy context...",
+        cancellable: false,
+      },
+      async (progress) => {
+        const essentialFiles = await this.identifyEssentialFiles();
+
+        if (essentialFiles.length === 0) {
+          this.logger.info("No essential files found to embed");
+          return;
+        }
+
+        this.logger.info(`Embedding ${essentialFiles.length} essential files`);
+
+        // Parallelize the embedding process for better performance
+        await AsyncUtils.processBatchesWithProgress(
+          essentialFiles,
+          async (file, index) => {
+            try {
+              await this.embedFile(file);
+              const currentProgress =
+                ((index + 1) / essentialFiles.length) * 100;
+              const increment = 100 / essentialFiles.length;
+              progress.report({
+                increment,
+                message: `Indexed ${path.basename(file)} (${index + 1}/${essentialFiles.length})`,
+              });
+              if (progressCallback) {
+                progressCallback(
+                  "immediate",
+                  currentProgress,
+                  `Indexed ${path.basename(file)}`,
+                );
+              }
+            } catch (error) {
+              this.logger.error(`Failed to embed file ${file}:`, error);
+            }
+          },
+          5, // Process 5 files at a time to avoid overwhelming the system
+        );
+
+        this.logger.info("Essential files embedding completed");
+      },
+    );
+  }
+
+  private async identifyEssentialFiles(): Promise<string[]> {
+    try {
+      // Collect files from different priority categories
+      const fileSources = await this.gatherEssentialFileSources();
+
+      // Combine and prioritize files
+      return this.prioritizeAndLimitFiles(fileSources);
+    } catch (error) {
+      this.logger.error("Error identifying essential files:", error);
+      return [];
+    }
+  }
+
+  private async gatherEssentialFileSources(): Promise<{
+    openFiles: string[];
+    entryPoints: string[];
+    recentFiles: string[];
+    mostImported: string[];
+    indexFiles: string[];
+  }> {
+    // Gather files from different sources in parallel for better performance
+    const [entryPoints, recentFiles, mostImported, indexFiles] =
+      await Promise.all([
+        this.findEntryPoints(),
+        this.getRecentlyModified(7),
+        this.getMostImportedFiles(10),
+        this.findIndexFiles(),
+      ]);
+
+    // Currently open files (highest priority)
+    const openFiles = vscode.workspace.textDocuments
+      .filter(
+        (doc) => LanguageUtils.isCodeFile(doc.languageId) && !doc.isUntitled,
+      )
+      .map((doc) => doc.fileName);
+
+    return {
+      openFiles,
+      entryPoints,
+      recentFiles,
+      mostImported,
+      indexFiles,
+    };
+  }
+
+  private prioritizeAndLimitFiles(sources: {
+    openFiles: string[];
+    entryPoints: string[];
+    recentFiles: string[];
+    mostImported: string[];
+    indexFiles: string[];
+  }): string[] {
+    // Combine files with priority weighting
+    const allEssentials = [
+      ...sources.openFiles, // Highest priority
+      ...sources.entryPoints, // High priority
+      ...sources.recentFiles.slice(0, 5), // Recent activity
+      ...sources.mostImported, // Dependency importance
+      ...sources.indexFiles, // Structural importance
+    ];
+
+    // Remove duplicates and limit to reasonable number
+    return [...new Set(allEssentials)].slice(0, 20);
+  }
+
+  private async findEntryPoints(): Promise<string[]> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const entryPoints: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      try {
+        const packageJsonPath = path.join(folder.uri.fsPath, "package.json");
+        const packageJsonUri = vscode.Uri.file(packageJsonPath);
+
+        const packageJson = JSON.parse(
+          Buffer.from(
+            await vscode.workspace.fs.readFile(packageJsonUri),
+          ).toString(),
+        );
+
+        // Add main entry point
+        if (packageJson.main) {
+          const mainPath = path.resolve(folder.uri.fsPath, packageJson.main);
+          if (await this.fileExists(mainPath)) {
+            entryPoints.push(mainPath);
+          }
+        }
+
+        // Add TypeScript entry points
+        const commonEntries = [
+          "src/index.ts",
+          "src/main.ts",
+          "index.ts",
+          "main.ts",
+        ];
+        for (const entry of commonEntries) {
+          const entryPath = path.join(folder.uri.fsPath, entry);
+          if (await this.fileExists(entryPath)) {
+            entryPoints.push(entryPath);
+          }
+        }
+      } catch (error) {
+        // Continue if package.json doesn't exist
+        this.logger.debug(`No package.json found in ${folder.uri.fsPath}`);
+      }
+    }
+
+    return entryPoints;
+  }
+
+  private async getRecentlyModified(days: number): Promise<string[]> {
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - days);
+
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const recentFiles: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      const pattern = "**/*.{ts,js,tsx,jsx,py,java,cpp,c,cs}";
+      const files = await vscode.workspace.findFiles(
+        new vscode.RelativePattern(folder, pattern),
+        "**/node_modules/**",
+      );
+
+      for (const file of files) {
+        try {
+          const stat = await FileUtils.safeGetStats(file);
+          if (stat) {
+            const modifiedDate = new Date(stat.mtime);
+            if (modifiedDate > cutoffDate) {
+              recentFiles.push(file.fsPath);
+            }
+          }
+        } catch (error) {
+          this.logger.warn(
+            `Could not get stats for file ${file.fsPath}:`,
+            error,
+          );
+          // Skip files that can't be read
+        }
+      }
+    }
+
+    // Sort by modification time (newest first)
+    // Note: Since we can't sort asynchronously, we'll sort by file path for now
+    // In a full implementation, you'd collect modification times first, then sort
+    recentFiles.sort((a, b) => b.localeCompare(a));
+
+    return recentFiles;
+  }
+
+  private async getMostImportedFiles(limit: number): Promise<string[]> {
+    // This is a simplified implementation
+    // In a full implementation, you'd analyze import statements
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const importantFiles: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      // Look for common important files
+      const importantPatterns = [
+        "src/utils/**/*.ts",
+        "src/lib/**/*.ts",
+        "src/types/**/*.ts",
+        "src/interfaces/**/*.ts",
+        "src/constants/**/*.ts",
+      ];
+
+      for (const pattern of importantPatterns) {
+        const files = await vscode.workspace.findFiles(
+          new vscode.RelativePattern(folder, pattern),
+          "**/node_modules/**",
+        );
+
+        importantFiles.push(...files.map((f) => f.fsPath));
+      }
+    }
+
+    return importantFiles.slice(0, limit);
+  }
+
+  private async findIndexFiles(): Promise<string[]> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const indexFiles: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      const patterns = ["**/index.ts", "**/index.js"];
+
+      for (const pattern of patterns) {
+        const files = await vscode.workspace.findFiles(
+          new vscode.RelativePattern(folder, pattern),
+          "**/node_modules/**",
+        );
+
+        indexFiles.push(...files.map((f) => f.fsPath));
+      }
+    }
+
+    return indexFiles;
+  }
+
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await vscode.workspace.fs.stat(vscode.Uri.file(filePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async embedFile(filePath: string): Promise<void> {
+    if (this.embeddingService) {
+      // Use the dedicated embedding service for actual vector DB integration
+      const result = await this.embeddingService.embedFile(filePath, {
+        priority: "high",
+        retryCount: 2,
+        timeout: 30000,
+      });
+
+      if (!result.success) {
+        this.logger.error(
+          `Failed to embed ${path.basename(filePath)}: ${result.error}`,
+        );
+        throw new Error(result.error);
+      }
+
+      this.logger.debug(
+        `Successfully embedded ${path.basename(filePath)} (${result.snippetsCreated} snippets)`,
+      );
+    } else {
+      // Fallback: use worker manager directly
+      this.logger.debug(`Embedding file: ${path.basename(filePath)}`);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+}
+
+/**
+ * Phase 2: Context-Aware On-Demand - Files based on user behavior
+ * Triggered by user questions, file navigation, and editing
+ */
+export class OnDemandEmbeddingPhase implements vscode.Disposable {
+  private logger: Logger;
+  private disposables: vscode.Disposable[] = [];
+
+  constructor(private workerManager: VectorDbWorkerManager) {
+    this.logger = Logger.initialize("OnDemandEmbeddingPhase", {
+      minLevel: LogLevel.INFO,
+    });
+  }
+
+  setupTriggers(): void {
+    // Trigger 2: File navigation
+    const activeEditorDisposable = vscode.window.onDidChangeActiveTextEditor(
+      async (editor) => {
+        if (
+          editor?.document.languageId &&
+          LanguageUtils.isCodeFile(editor.document.languageId)
+        ) {
+          await this.onFileOpened(editor.document.fileName);
+        }
+      },
+    );
+
+    // Trigger 3: File editing
+    const textDocumentDisposable = vscode.workspace.onDidChangeTextDocument(
+      async (event) => {
+        if (LanguageUtils.isCodeFile(event.document.languageId)) {
+          await this.onFileEdited(event.document.fileName);
+        }
+      },
+    );
+
+    this.disposables.push(activeEditorDisposable, textDocumentDisposable);
+    this.logger.info("On-demand embedding triggers set up");
+  }
+
+  async onUserQuestion(question: string): Promise<void> {
+    try {
+      const relevantFiles = await this.identifyRelevantFiles(question);
+      const unembedded = await this.filterUnembedded(relevantFiles);
+
+      if (unembedded.length > 0) {
+        vscode.window.setStatusBarMessage(
+          `🔍 Finding context for: "${question.substring(0, 30)}..."`,
+          this.embedFilesQuietly(unembedded),
+        );
+      }
+    } catch (error) {
+      this.logger.error("Error processing user question:", error);
+    }
+  }
+
+  async onFileOpened(filePath: string): Promise<void> {
+    try {
+      const relatedFiles = await this.findRelatedFiles(filePath);
+      this.queueForBackgroundEmbedding(relatedFiles);
+    } catch (error) {
+      this.logger.error("Error processing file opened:", error);
+    }
+  }
+
+  async onFileEdited(filePath: string): Promise<void> {
+    try {
+      // File was edited, it might need re-embedding
+      await this.queueForReembedding(filePath);
+    } catch (error) {
+      this.logger.error("Error processing file edited:", error);
+    }
+  }
+
+  private async identifyRelevantFiles(question: string): Promise<string[]> {
+    const keywords = this.extractTechnicalKeywords(question);
+
+    // Collect candidates from multiple sources
+    const candidates = await this.collectRelevantCandidates(keywords);
+
+    // Rank and return the most relevant files
+    return this.rankByRelevance(candidates, question);
+  }
+
+  private async collectRelevantCandidates(
+    keywords: string[],
+  ): Promise<string[]> {
+    const candidates: string[] = [];
+
+    // Collect files by filename patterns
+    const filenameMatches = await this.findFilesByPatterns(keywords);
+    candidates.push(...filenameMatches);
+
+    // Collect files by content patterns (without full embedding)
+    const contentMatches = await this.findFilesByContentKeywords(keywords);
+    candidates.push(...contentMatches);
+
+    // Remove duplicates
+    return [...new Set(candidates)];
+  }
+
+  private async findFilesByPatterns(keywords: string[]): Promise<string[]> {
+    const allMatches = await Promise.all(
+      keywords.map((keyword) => this.findFilesByPattern(keyword)),
+    );
+
+    return allMatches.flat();
+  }
+
+  private extractTechnicalKeywords(question: string): string[] {
+    // Simple keyword extraction - in practice, this would be more sophisticated
+    const words = question.toLowerCase().split(/\s+/);
+    const technicalWords = words.filter(
+      (word) =>
+        word.length > 3 &&
+        ![
+          "the",
+          "and",
+          "that",
+          "this",
+          "with",
+          "from",
+          "they",
+          "have",
+          "been",
+        ].includes(word),
+    );
+
+    return technicalWords.slice(0, 5); // Limit to top 5 keywords
+  }
+
+  private async findFilesByPattern(keyword: string): Promise<string[]> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const matchingFiles: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      const pattern = `**/*${keyword}*.{ts,js,tsx,jsx,py,java,cpp,c,cs}`;
+      const files = await vscode.workspace.findFiles(
+        new vscode.RelativePattern(folder, pattern),
+        "**/node_modules/**",
+      );
+
+      matchingFiles.push(...files.map((f) => f.fsPath));
+    }
+
+    return matchingFiles;
+  }
+
+  private async findFilesByContentKeywords(
+    keywords: string[],
+  ): Promise<string[]> {
+    // This would require content analysis - simplified implementation
+    return [];
+  }
+
+  private rankByRelevance(candidates: string[], question: string): string[] {
+    // Simple ranking based on filename relevance
+    const questionWords = question.toLowerCase().split(/\s+/);
+
+    return candidates
+      .map((file) => ({
+        file,
+        score: this.calculateRelevanceScore(file, questionWords),
+      }))
+      .sort((a, b) => b.score - a.score)
+      .map((item) => item.file)
+      .slice(0, 10); // Top 10 most relevant
+  }
+
+  private calculateRelevanceScore(
+    filePath: string,
+    questionWords: string[],
+  ): number {
+    const fileName = path.basename(filePath).toLowerCase();
+    let score = 0;
+
+    for (const word of questionWords) {
+      if (fileName.includes(word)) {
+        score += word.length; // Longer words get higher scores
+      }
+    }
+
+    return score;
+  }
+
+  private async findRelatedFiles(filePath: string): Promise<string[]> {
+    const related: string[] = [];
+
+    try {
+      // 1. Same directory files
+      const siblings = await this.getSiblingFiles(filePath);
+      related.push(...siblings);
+
+      // 2. Test files
+      const testFiles = await this.findTestFiles(filePath);
+      related.push(...testFiles);
+
+      return [...new Set(related)]; // Remove duplicates
+    } catch (error) {
+      this.logger.error("Error finding related files:", error);
+      return [];
+    }
+  }
+
+  private async getSiblingFiles(filePath: string): Promise<string[]> {
+    const directory = path.dirname(filePath);
+    const pattern = "*.{ts,js,tsx,jsx}";
+
+    try {
+      const files = await vscode.workspace.findFiles(
+        new vscode.RelativePattern(directory, pattern),
+      );
+
+      return files.map((f) => f.fsPath).filter((f) => f !== filePath); // Exclude the original file
+    } catch {
+      return [];
+    }
+  }
+
+  private async findTestFiles(filePath: string): Promise<string[]> {
+    const baseName = path.basename(filePath, path.extname(filePath));
+    const directory = path.dirname(filePath);
+
+    const testPatterns = [
+      `${baseName}.test.*`,
+      `${baseName}.spec.*`,
+      `**/${baseName}.test.*`,
+      `**/${baseName}.spec.*`,
+    ];
+
+    const testFiles: string[] = [];
+
+    for (const pattern of testPatterns) {
+      try {
+        const files = await vscode.workspace.findFiles(
+          new vscode.RelativePattern(
+            vscode.workspace.workspaceFolders![0],
+            pattern,
+          ),
+        );
+
+        testFiles.push(...files.map((f) => f.fsPath));
+      } catch {
+        // Continue with next pattern
+      }
+    }
+
+    return testFiles;
+  }
+
+  private async filterUnembedded(files: string[]): Promise<string[]> {
+    // This would check against the vector database to see which files are already embedded
+    // For now, return all files as potentially unembedded
+    return files;
+  }
+
+  private async embedFilesQuietly(files: string[]): Promise<void> {
+    for (const file of files) {
+      try {
+        await this.embedFile(file);
+      } catch (error) {
+        this.logger.error(`Failed to embed file ${file}:`, error);
+      }
+    }
+  }
+
+  private queueForBackgroundEmbedding(files: string[]): void {
+    // This would add files to a background processing queue
+    this.logger.debug(`Queued ${files.length} files for background embedding`);
+  }
+
+  private async queueForReembedding(filePath: string): Promise<void> {
+    // This would mark a file for re-embedding
+    this.logger.debug(`Queued ${filePath} for re-embedding`);
+  }
+
+  private async embedFile(filePath: string): Promise<void> {
+    this.logger.debug(`Embedding file: ${path.basename(filePath)}`);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  dispose(): void {
+    DisposableUtils.safeDispose(this.disposables);
+    this.disposables = [];
+  }
+}
+
+/**
+ * Phase 3: Background Processing - Gradual processing during idle time
+ * Processes remaining files when user is idle
+ */
+export class BackgroundEmbeddingPhase implements vscode.Disposable {
+  private logger: Logger;
+  private isUserIdle = false;
+  private readonly IDLE_THRESHOLD = 3000; // 3 seconds
+  private readonly BATCH_SIZE = 8; // Files per batch
+  private idleTimer?: NodeJS.Timeout;
+  private isProcessing = false;
+  private disposables: vscode.Disposable[] = [];
+
+  constructor(private workerManager: VectorDbWorkerManager) {
+    this.logger = Logger.initialize("BackgroundEmbeddingPhase", {
+      minLevel: LogLevel.INFO,
+    });
+  }
+
+  startBackgroundProcessing(): void {
+    this.setupIdleDetection();
+    this.logger.info("Background processing started");
+  }
+
+  private setupIdleDetection(): void {
+    // Monitor various VS Code events for user activity
+    const eventDisposables = [
+      vscode.workspace.onDidChangeTextDocument(() => this.resetIdleTimer()),
+      vscode.window.onDidChangeActiveTextEditor(() => this.resetIdleTimer()),
+      vscode.window.onDidChangeTextEditorSelection(() => this.resetIdleTimer()),
+    ];
+
+    this.disposables.push(...eventDisposables);
+    this.resetIdleTimer();
+  }
+
+  private resetIdleTimer(): void {
+    this.isUserIdle = false;
+
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+    }
+
+    this.idleTimer = setTimeout(() => {
+      this.isUserIdle = true;
+      if (!this.isProcessing) {
+        this.processBackgroundBatch();
+      }
+    }, this.IDLE_THRESHOLD);
+  }
+
+  private async processBackgroundBatch(): Promise<void> {
+    if (!this.isUserIdle || this.isProcessing) return;
+
+    this.isProcessing = true;
+
+    try {
+      // Get next batch of unprocessed files
+      const unprocessedFiles = await this.getUnprocessedFiles();
+      if (unprocessedFiles.length === 0) {
+        this.onBackgroundProcessingComplete();
+        return;
+      }
+
+      const batch = this.prioritizeBatch(
+        unprocessedFiles.slice(0, this.BATCH_SIZE),
+      );
+
+      // Process silently in background
+      vscode.window.setStatusBarMessage(
+        `📚 Background indexing: ${batch.length} files...`,
+        this.processBatchSilently(batch),
+      );
+
+      // Schedule next batch if still idle
+      setTimeout(() => {
+        if (this.isUserIdle) {
+          this.processBackgroundBatch();
+        }
+      }, 2000);
+    } catch (error) {
+      this.logger.error("Background embedding failed:", error);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  private async getUnprocessedFiles(): Promise<string[]> {
+    // This would query the vector database to find unprocessed files
+    // For now, return a mock list
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const allFiles: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      const pattern = "**/*.{ts,js,tsx,jsx,py,java,cpp,c,cs}";
+      const files = await vscode.workspace.findFiles(
+        new vscode.RelativePattern(folder, pattern),
+        "**/node_modules/**",
+      );
+
+      allFiles.push(...files.map((f) => f.fsPath));
+    }
+
+    // Return a subset for demonstration
+    return allFiles.slice(0, 50);
+  }
+
+  private prioritizeBatch(files: string[]): string[] {
+    return files.sort((a, b) => {
+      const priorityA = this.getFilePriority(a);
+      const priorityB = this.getFilePriority(b);
+      return priorityB - priorityA; // Higher priority first
+    });
+  }
+
+  private getFilePriority(filePath: string): number {
+    if (filePath.includes(".test.") || filePath.includes(".spec.")) return 1;
+    if (filePath.includes("config") || filePath.includes(".json")) return 2;
+    if (filePath.includes("/src/")) return 4;
+    if (filePath.includes("/lib/") || filePath.includes("/utils/")) return 3;
+    return 2;
+  }
+
+  private async processBatchSilently(files: string[]): Promise<void> {
+    for (const file of files) {
+      if (!this.isUserIdle) break; // Stop if user becomes active
+
+      try {
+        await this.embedFile(file);
+        await this.delay(200); // Small delay between files
+      } catch (error) {
+        this.logger.error(`Failed to process ${file}:`, error);
+      }
+    }
+  }
+
+  private async embedFile(filePath: string): Promise<void> {
+    this.logger.debug(`Background embedding: ${path.basename(filePath)}`);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  private onBackgroundProcessingComplete(): void {
+    this.logger.info("Background processing completed - all files indexed");
+    vscode.window.showInformationMessage(
+      "✅ CodeBuddy has finished indexing your workspace in the background!",
+    );
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  dispose(): void {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = undefined;
+    }
+    DisposableUtils.safeDispose(this.disposables);
+    this.disposables = [];
+  }
+}
+
+/**
+ * Phase 4: Bulk Processing - Complete codebase indexing when requested
+ * User-initiated complete indexing with progress reporting
+ */
+export class BulkEmbeddingPhase implements vscode.Disposable {
+  private logger: Logger;
+  private disposables: vscode.Disposable[] = [];
+
+  constructor(private workerManager: VectorDbWorkerManager) {
+    this.logger = Logger.initialize("BulkEmbeddingPhase", {
+      minLevel: LogLevel.INFO,
+    });
+  }
+
+  async registerBulkCommand(context: vscode.ExtensionContext): Promise<void> {
+    const command = vscode.commands.registerCommand(
+      "codebuddy.indexEntireCodebase",
+      () => this.processBulkEmbedding(),
+    );
+
+    context.subscriptions.push(command);
+    this.logger.info("Bulk embedding command registered");
+  }
+
+  async processBulkEmbedding(): Promise<void> {
+    try {
+      const allFiles = await this.getAllCodeFiles();
+      const unprocessed = await this.filterUnprocessed(allFiles);
+
+      if (unprocessed.length === 0) {
+        vscode.window.showInformationMessage(
+          "✅ Codebase is already fully indexed!",
+        );
+        return;
+      }
+
+      const estimatedTime = Math.ceil(unprocessed.length / 10); // ~10 files per second
+      const proceed = await vscode.window.showWarningMessage(
+        `Index ${unprocessed.length} files? Estimated time: ${estimatedTime} seconds.`,
+        { modal: true },
+        "Yes, Index All",
+        "Index in Background",
+        "Cancel",
+      );
+
+      if (proceed === "Cancel" || !proceed) return;
+
+      const inBackground = proceed === "Index in Background";
+
+      if (inBackground) {
+        this.processBulkInBackground(unprocessed);
+      } else {
+        await this.processBulkWithProgress(unprocessed);
+      }
+    } catch (error) {
+      this.logger.error("Error in bulk embedding:", error);
+      vscode.window.showErrorMessage(`Failed to start bulk indexing: ${error}`);
+    }
+  }
+
+  private async processBulkWithProgress(files: string[]): Promise<void> {
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: "Indexing entire codebase",
+        cancellable: true,
+      },
+      async (progress, token) => {
+        const batchSize = 15;
+        let processed = 0;
+
+        for (let i = 0; i < files.length; i += batchSize) {
+          if (token.isCancellationRequested) {
+            vscode.window.showWarningMessage(
+              `Indexing cancelled. Processed ${processed}/${files.length} files.`,
+            );
+            break;
+          }
+
+          const batch = files.slice(i, i + batchSize);
+
+          try {
+            await this.processBatch(batch);
+            processed += batch.length;
+
+            progress.report({
+              increment: (batch.length / files.length) * 100,
+              message: `${processed}/${files.length} files indexed`,
+            });
+          } catch (error) {
+            this.logger.error("Batch failed:", error);
+            // Continue with next batch
+          }
+        }
+
+        vscode.window.showInformationMessage(
+          `✅ Indexing complete! Processed ${processed} files.`,
+        );
+      },
+    );
+  }
+
+  private async processBulkInBackground(files: string[]): Promise<void> {
+    vscode.window.showInformationMessage(
+      `🔄 Started background indexing of ${files.length} files. Check status bar for progress.`,
+    );
+
+    const batchSize = 8;
+    let processed = 0;
+
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+
+      vscode.window.setStatusBarMessage(
+        `📚 Background indexing: ${processed + batch.length}/${files.length}`,
+        this.processBatch(batch),
+      );
+
+      processed += batch.length;
+
+      // Delay between batches to keep system responsive
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+
+    vscode.window.showInformationMessage(
+      `✅ Background indexing complete! Indexed ${processed} files.`,
+    );
+  }
+
+  private async processBatch(files: string[]): Promise<void> {
+    for (const file of files) {
+      try {
+        await this.embedFile(file);
+      } catch (error) {
+        this.logger.error(`Failed to process ${file}:`, error);
+      }
+    }
+  }
+
+  private async getAllCodeFiles(): Promise<string[]> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) return [];
+
+    const allFiles: string[] = [];
+
+    for (const folder of workspaceFolders) {
+      const pattern = "**/*.{ts,js,tsx,jsx,py,java,cpp,c,cs}";
+      const files = await vscode.workspace.findFiles(
+        new vscode.RelativePattern(folder, pattern),
+        "**/node_modules/**",
+      );
+
+      allFiles.push(...files.map((f) => f.fsPath));
+    }
+
+    return allFiles;
+  }
+
+  private async filterUnprocessed(files: string[]): Promise<string[]> {
+    // This would check against the vector database
+    // For now, return all files as potentially unprocessed
+    return files;
+  }
+
+  private async embedFile(filePath: string): Promise<void> {
+    this.logger.debug(`Bulk embedding: ${path.basename(filePath)}`);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  dispose(): void {
+    DisposableUtils.safeDispose(this.disposables);
+    this.disposables = [];
+  }
+}
diff --git a/src/services/vector-db-sync.service.ts b/src/services/vector-db-sync.service.ts
new file mode 100644
index 0000000..32fe3e6
--- /dev/null
+++ b/src/services/vector-db-sync.service.ts
@@ -0,0 +1,655 @@
+import * as vscode from "vscode";
+import * as path from "path";
+import { VectorDatabaseService, CodeSnippet } from "./vector-database.service";
+import { CodeIndexingService } from "./code-indexing";
+import { Logger, LogLevel } from "../infrastructure/logger/logger";
+import {
+  VECTOR_OPERATIONS,
+  VectorOperationType,
+} from "./vector-db-worker-manager";
+import { IFunctionData } from "../application/interfaces";
+import {
+  LanguageUtils,
+  FileUtils,
+  AsyncUtils,
+  DisposableUtils,
+} from "../utils/common-utils";
+
+// Interface for code indexing to support dependency injection
+export interface ICodeIndexer {
+  generateEmbeddings(): Promise<IFunctionData[]>;
+}
+
+// Adapter to make CodeIndexingService compatible with ICodeIndexer interface
+export class CodeIndexingAdapter implements ICodeIndexer {
+  constructor(private codeIndexingService: CodeIndexingService) {}
+
+  async generateEmbeddings(): Promise<IFunctionData[]> {
+    return await this.codeIndexingService.generateEmbeddings();
+  }
+}
+
+export interface SyncOperation {
+  type: "created" | "modified" | "deleted";
+  filePath: string;
+  timestamp: number;
+}
+
+export interface VectorDbSyncStats {
+  filesMonitored: number;
+  syncOperations: number;
+  lastSync: string | null;
+  failedOperations: number;
+  queueSize: number;
+}
+
+/**
+ * VectorDbSyncService handles file monitoring and real-time synchronization
+ * with the vector database. It uses debounced batch processing for efficiency.
+ */
+export class VectorDbSyncService implements vscode.Disposable {
+  private vectorDb: VectorDatabaseService;
+  private codeIndexer: ICodeIndexer;
+  private logger: Logger;
+
+  private syncQueue = new Set<string>();
+  private syncTimer: NodeJS.Timeout | null = null;
+  private readonly SYNC_DELAY = 1000; // 1 second debounce
+  private readonly BATCH_SIZE = 10;
+
+  private fileWatchers: vscode.FileSystemWatcher[] = [];
+  private disposables: vscode.Disposable[] = [];
+  private isInitialized = false;
+
+  private stats: VectorDbSyncStats = {
+    filesMonitored: 0,
+    syncOperations: 0,
+    lastSync: null,
+    failedOperations: 0,
+    queueSize: 0,
+  };
+
+  constructor(vectorDb: VectorDatabaseService, codeIndexer: ICodeIndexer) {
+    this.vectorDb = vectorDb;
+    this.codeIndexer = codeIndexer;
+    this.logger = Logger.initialize("VectorDbSyncService", {
+      minLevel: LogLevel.INFO,
+    });
+  }
+
+  /**
+   * Initialize the sync service and set up file monitoring
+   */
+  async initialize(): Promise<void> {
+    try {
+      if (!this.vectorDb.isReady()) {
+        throw new Error(
+          "VectorDatabaseService must be initialized before sync service",
+        );
+      }
+
+      await this.setupFileWatchers();
+      await this.performInitialSync();
+
+      this.isInitialized = true;
+      this.logger.info("VectorDbSyncService initialized successfully");
+    } catch (error) {
+      this.logger.error("Failed to initialize VectorDbSyncService:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Set up file system watchers for different file types
+   */
+  private async setupFileWatchers(): Promise<void> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+      this.logger.warn("No workspace folders found");
+      return;
+    }
+
+    // File patterns to monitor
+    const patterns = [
+      "**/*.ts",
+      "**/*.js",
+      "**/*.tsx",
+      "**/*.jsx",
+      "**/*.py",
+      "**/*.java",
+      "**/*.cpp",
+      "**/*.c",
+      "**/*.cs",
+    ];
+
+    for (const folder of workspaceFolders) {
+      for (const pattern of patterns) {
+        const watcher = vscode.workspace.createFileSystemWatcher(
+          new vscode.RelativePattern(folder, pattern),
+        );
+
+        // File created
+        watcher.onDidCreate((uri) => {
+          this.queueSyncOperation("created", uri.fsPath);
+        });
+
+        // File modified
+        watcher.onDidChange((uri) => {
+          this.queueSyncOperation("modified", uri.fsPath);
+        });
+
+        // File deleted
+        watcher.onDidDelete((uri) => {
+          this.queueSyncOperation("deleted", uri.fsPath);
+        });
+
+        this.fileWatchers.push(watcher);
+        this.disposables.push(watcher);
+      }
+    }
+
+    this.stats.filesMonitored = this.fileWatchers.length;
+    this.logger.info(`Set up ${this.fileWatchers.length} file watchers`);
+  }
+
+  /**
+   * Queue a sync operation with debouncing
+   */
+  private queueSyncOperation(
+    type: "created" | "modified" | "deleted",
+    filePath: string,
+  ): void {
+    // Filter out unwanted files
+    if (this.shouldIgnoreFile(filePath)) {
+      return;
+    }
+
+    const operation = `${type}:${filePath}`;
+    this.syncQueue.add(operation);
+    this.stats.queueSize = this.syncQueue.size;
+
+    this.logger.debug(
+      `Queued ${type} operation for: ${path.basename(filePath)}`,
+    );
+
+    // Reset debounce timer
+    if (this.syncTimer) {
+      clearTimeout(this.syncTimer);
+    }
+
+    this.syncTimer = setTimeout(() => {
+      this.processSyncQueue();
+    }, this.SYNC_DELAY);
+  }
+
+  /**
+   * Check if file should be ignored
+   */
+  private shouldIgnoreFile(filePath: string): boolean {
+    const ignoredPatterns = [
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      "out",
+      ".vscode-test",
+      "coverage",
+    ];
+
+    const ignoredExtensions = [".map", ".d.ts", ".min.js", ".bundle.js"];
+
+    // Check ignored directories
+    for (const pattern of ignoredPatterns) {
+      if (filePath.includes(pattern)) {
+        return true;
+      }
+    }
+
+    // Check ignored file extensions
+    for (const ext of ignoredExtensions) {
+      if (filePath.endsWith(ext)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Process the sync queue in batches
+   */
+  private async processSyncQueue(): Promise<void> {
+    if (this.syncQueue.size === 0) return;
+
+    const operations = Array.from(this.syncQueue);
+    this.syncQueue.clear();
+    this.stats.queueSize = 0;
+
+    const created: string[] = [];
+    const modified: string[] = [];
+    const deleted: string[] = [];
+
+    // Categorize operations
+    for (const op of operations) {
+      const [operation, filePath] = op.split(":");
+      switch (operation) {
+        case "created":
+          created.push(filePath);
+          break;
+        case "modified":
+          modified.push(filePath);
+          break;
+        case "deleted":
+          deleted.push(filePath);
+          break;
+      }
+    }
+
+    try {
+      // Process deletions first
+      if (deleted.length > 0) {
+        await this.handleDeletedFiles(deleted);
+      }
+
+      // Process modifications and creations
+      const filesToProcess = [...created, ...modified];
+      if (filesToProcess.length > 0) {
+        await this.handleModifiedFiles(filesToProcess);
+      }
+
+      this.stats.syncOperations += operations.length;
+      this.stats.lastSync = new Date().toISOString();
+
+      this.logger.info(`Processed ${operations.length} file operations`, {
+        created: created.length,
+        modified: modified.length,
+        deleted: deleted.length,
+      });
+    } catch (error) {
+      this.stats.failedOperations += operations.length;
+      this.logger.error("Error processing sync queue:", error);
+    }
+  }
+
+  /**
+   * Handle deleted files by removing them from vector database with batch processing and error recovery
+   */
+  private async handleDeletedFiles(deletedFiles: string[]): Promise<void> {
+    if (deletedFiles.length === 0) return;
+
+    this.logger.info(`Processing ${deletedFiles.length} deleted files`);
+
+    const batchSize = 10; // Process deletions in batches
+    let successCount = 0;
+    let failureCount = 0;
+
+    for (let i = 0; i < deletedFiles.length; i += batchSize) {
+      const batch = deletedFiles.slice(i, i + batchSize);
+
+      // Process batch in parallel for better performance
+      const results = await Promise.allSettled(
+        batch.map(async (filePath) => {
+          try {
+            // Attempt to delete with retry logic
+            await this.deleteFileEmbeddingsWithRetry(filePath, 2);
+            successCount++;
+            this.logger.debug(
+              `Removed embeddings for deleted file: ${path.basename(filePath)}`,
+            );
+            return { success: true, filePath };
+          } catch (error) {
+            failureCount++;
+            this.logger.error(
+              `Failed to remove embeddings for ${filePath}:`,
+              error,
+            );
+            this.stats.failedOperations++;
+            return { success: false, filePath, error };
+          }
+        }),
+      );
+
+      // Log batch results
+      const batchSuccess = results.filter(
+        (r) => r.status === "fulfilled" && (r.value as any).success,
+      ).length;
+      const batchFailures = results.filter(
+        (r) => r.status === "rejected" || !(r.value as any).success,
+      ).length;
+
+      this.logger.debug(
+        `Batch ${Math.floor(i / batchSize) + 1}: ${batchSuccess} successful, ${batchFailures} failed`,
+      );
+
+      // Small delay between batches to prevent overwhelming the vector DB
+      if (i + batchSize < deletedFiles.length) {
+        await AsyncUtils.delay(200);
+      }
+    }
+
+    this.logger.info(
+      `File deletion processing complete: ${successCount} successful, ${failureCount} failed`,
+    );
+
+    // Update stats
+    this.stats.syncOperations += successCount;
+  }
+
+  /**
+   * Delete file embeddings with retry logic
+   */
+  private async deleteFileEmbeddingsWithRetry(
+    filePath: string,
+    maxRetries: number = 2,
+  ): Promise<void> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        await this.vectorDb.deleteByFile(filePath);
+        return; // Success
+      } catch (error) {
+        lastError = error as Error;
+        this.logger.warn(
+          `Deletion attempt ${attempt}/${maxRetries} failed for ${filePath}:`,
+          error,
+        );
+
+        if (attempt < maxRetries) {
+          // Short delay before retry for deletion operations
+          await AsyncUtils.delay(500 * attempt);
+        }
+      }
+    }
+
+    throw (
+      lastError ||
+      new Error(
+        `Failed to delete embeddings for ${filePath} after ${maxRetries} attempts`,
+      )
+    );
+  }
+
+  /**
+   * Handle modified/created files by reindexing them
+   */
+  private async handleModifiedFiles(modifiedFiles: string[]): Promise<void> {
+    // Process files in batches to avoid overwhelming the system
+    for (let i = 0; i < modifiedFiles.length; i += this.BATCH_SIZE) {
+      const batch = modifiedFiles.slice(i, i + this.BATCH_SIZE);
+
+      await Promise.all(
+        batch.map(async (filePath) => {
+          try {
+            await this.reindexSingleFile(filePath);
+          } catch (error) {
+            this.logger.error(`Reindexing failed for ${filePath}:`, error);
+            this.stats.failedOperations++;
+          }
+        }),
+      );
+
+      // Small delay between batches
+      if (i + this.BATCH_SIZE < modifiedFiles.length) {
+        await AsyncUtils.delay(100);
+      }
+    }
+  }
+
+  /**
+   * Reindex a single file with retry logic and circuit breaker pattern
+   */
+  async reindexSingleFile(
+    filePath: string,
+    retryCount: number = 3,
+  ): Promise<void> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= retryCount; attempt++) {
+      try {
+        // Remove existing embeddings
+        await this.vectorDb.deleteByFile(filePath);
+
+        // Extract new code snippets
+        const snippets = await this.extractSnippetsFromFile(filePath);
+
+        if (snippets.length > 0) {
+          await this.vectorDb.indexCodeSnippets(snippets);
+          this.logger.debug(
+            `Reindexed ${snippets.length} snippets from ${path.basename(filePath)} (attempt ${attempt})`,
+          );
+        }
+
+        // Success - break the retry loop
+        return;
+      } catch (error) {
+        lastError = error as Error;
+        this.logger.warn(
+          `Reindexing failed for ${filePath} (attempt ${attempt}/${retryCount}):`,
+          error,
+        );
+
+        if (attempt < retryCount) {
+          // Exponential backoff with jitter
+          const baseDelay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+          const jitter = Math.random() * 1000;
+          const delay = baseDelay + jitter;
+
+          this.logger.debug(`Retrying ${filePath} in ${Math.round(delay)}ms`);
+          await AsyncUtils.delay(delay);
+        }
+      }
+    }
+
+    // All retries failed
+    this.logger.error(
+      `Reindexing failed after ${retryCount} attempts for ${filePath}:`,
+      lastError,
+    );
+    this.stats.failedOperations++;
+
+    // Don't throw the error to prevent batch failure, but mark as failed
+    // In a production system, you might want to add this to a dead letter queue
+  }
+
+  /**
+   * Extract code snippets from a file using a more efficient approach
+   */
+  private async extractSnippetsFromFile(
+    filePath: string,
+  ): Promise<CodeSnippet[]> {
+    try {
+      // For now, create a simple file-based snippet
+      // In the future, this could be enhanced with more sophisticated parsing
+      const content = await AsyncUtils.safeExecute(
+        async () => {
+          const uri = vscode.Uri.file(filePath);
+          const bytes = await vscode.workspace.fs.readFile(uri);
+          return new TextDecoder().decode(bytes);
+        },
+        "",
+        (error) => this.logger.warn(`Could not read file ${filePath}:`, error),
+      );
+
+      if (!content) {
+        return [];
+      }
+
+      // Create a single snippet for the entire file
+      // This is a simplified approach - in practice, you might want to parse functions/classes
+      return [
+        {
+          id: `file::${filePath}`,
+          filePath,
+          type: "module" as const,
+          name: FileUtils.getRelativePath(filePath),
+          content: content.substring(0, 2000), // Limit content size
+          metadata: {
+            language: LanguageUtils.getLanguageFromPath(filePath),
+            fileSize: content.length,
+            startLine: 1,
+            endLine: content.split("\n").length,
+          },
+        },
+      ];
+    } catch (error) {
+      this.logger.error(`Error extracting snippets from ${filePath}:`, error);
+      return [];
+    }
+  }
+
+  /**
+   * Perform initial sync when service starts
+   */
+  private async performInitialSync(): Promise<void> {
+    try {
+      this.logger.info("Starting initial sync...");
+
+      // Get all existing embeddings
+      const stats = this.vectorDb.getStats();
+
+      if (stats.documentCount === 0) {
+        this.logger.info("No existing embeddings found, skipping initial sync");
+        return;
+      }
+
+      // Check if any files have been modified since last sync
+      const workspaceFiles = await this.getAllWorkspaceFiles();
+      const modifiedFiles: string[] = [];
+
+      for (const filePath of workspaceFiles) {
+        if (await this.hasFileChanged(filePath)) {
+          modifiedFiles.push(filePath);
+        }
+      }
+
+      if (modifiedFiles.length > 0) {
+        this.logger.info(
+          `Found ${modifiedFiles.length} modified files, syncing...`,
+        );
+        await this.handleModifiedFiles(modifiedFiles);
+      }
+
+      this.logger.info("Initial sync completed");
+    } catch (error) {
+      this.logger.error("Error during initial sync:", error);
+    }
+  }
+
+  /**
+   * Get all workspace files that should be indexed
+   */
+  private async getAllWorkspaceFiles(): Promise<string[]> {
+    const files: string[] = [];
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+
+    if (!workspaceFolders) return files;
+
+    for (const folder of workspaceFolders) {
+      const pattern = "**/*.{ts,js,tsx,jsx,py,java,cpp,c,cs}";
+      const foundFiles = await vscode.workspace.findFiles(
+        new vscode.RelativePattern(folder, pattern),
+        "**/node_modules/**",
+      );
+
+      files.push(...foundFiles.map((uri) => uri.fsPath));
+    }
+
+    return files.filter((file) => !this.shouldIgnoreFile(file));
+  }
+
+  /**
+   * Check if file has changed since last sync
+   */
+  private async hasFileChanged(filePath: string): Promise<boolean> {
+    try {
+      const stat = await vscode.workspace.fs.stat(vscode.Uri.file(filePath));
+      const lastModified = new Date(stat.mtime);
+
+      // Compare with last sync time
+      if (this.stats.lastSync) {
+        const lastSyncTime = new Date(this.stats.lastSync);
+        return lastModified > lastSyncTime;
+      }
+
+      return true; // No previous sync, consider as changed
+    } catch (error) {
+      return false; // File might not exist
+    }
+  }
+
+  /**
+   * Get sync service statistics
+   */
+  getStats(): VectorDbSyncStats {
+    return { ...this.stats };
+  }
+
+  /**
+   * Check if service is initialized
+   */
+  isReady(): boolean {
+    return this.isInitialized && this.vectorDb.isReady();
+  }
+
+  /**
+   * Force sync of all workspace files
+   */
+  async performFullReindex(): Promise<void> {
+    try {
+      const files = await this.getAllWorkspaceFiles();
+      this.logger.info(`Starting full reindex of ${files.length} files...`);
+
+      await vscode.window.withProgress(
+        {
+          location: vscode.ProgressLocation.Notification,
+          title: "Reindexing workspace files",
+          cancellable: false,
+        },
+        async (progress) => {
+          for (let i = 0; i < files.length; i += this.BATCH_SIZE) {
+            const batch = files.slice(i, i + this.BATCH_SIZE);
+
+            await this.handleModifiedFiles(batch);
+
+            progress.report({
+              increment: (batch.length / files.length) * 100,
+              message: `Processed ${i + batch.length}/${files.length} files`,
+            });
+          }
+        },
+      );
+
+      this.logger.info("Full reindex completed");
+    } catch (error) {
+      this.logger.error("Error during full reindex:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Utility delay function
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Dispose of all resources
+   */
+  dispose(): void {
+    // Clear sync timer
+    if (this.syncTimer) {
+      clearTimeout(this.syncTimer);
+      this.syncTimer = null;
+    }
+
+    // Dispose of all watchers and disposables
+    DisposableUtils.safeDispose(this.disposables);
+    this.fileWatchers = [];
+    this.disposables = [];
+
+    this.isInitialized = false;
+    this.logger.info("VectorDbSyncService disposed");
+  }
+}
diff --git a/src/test/suite/phase2-implementation.test.ts b/src/test/suite/phase2-implementation.test.ts
new file mode 100644
index 0000000..b680f84
--- /dev/null
+++ b/src/test/suite/phase2-implementation.test.ts
@@ -0,0 +1,381 @@
+import * as assert from "assert";
+import * as sinon from "sinon";
+import * as vscode from "vscode";
+import { VectorDbSyncService, ICodeIndexer } from "../../services/vector-db-sync.service";
+import { VectorDatabaseService } from "../../services/vector-database.service";
+import { ImmediateEmbeddingPhase, OnDemandEmbeddingPhase } from "../../services/smart-embedding-phases";
+import { VectorDbWorkerManager } from "../../services/vector-db-worker-manager";
+import { LanguageUtils, FileUtils, AsyncUtils } from "../../utils/common-utils";
+import { IFunctionData } from "../../application/interfaces";
+
+describe("Phase 2 Implementation Tests", () => {
+  let sandbox: sinon.SinonSandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe("LanguageUtils", () => {
+    it("should correctly identify code files", () => {
+      assert.strictEqual(LanguageUtils.isCodeFile("typescript"), true);
+      assert.strictEqual(LanguageUtils.isCodeFile("javascript"), true);
+      assert.strictEqual(LanguageUtils.isCodeFile("python"), true);
+      assert.strictEqual(LanguageUtils.isCodeFile("plaintext"), false);
+      assert.strictEqual(LanguageUtils.isCodeFile("markdown"), false);
+    });
+
+    it("should get correct language from file path", () => {
+      assert.strictEqual(LanguageUtils.getLanguageFromPath("test.ts"), "typescript");
+      assert.strictEqual(LanguageUtils.getLanguageFromPath("test.js"), "javascript");
+      assert.strictEqual(LanguageUtils.getLanguageFromPath("test.py"), "python");
+      assert.strictEqual(LanguageUtils.getLanguageFromPath("test.unknown"), "plaintext");
+    });
+
+    it("should identify code files by path", () => {
+      assert.strictEqual(LanguageUtils.isCodeFileByPath("test.ts"), true);
+      assert.strictEqual(LanguageUtils.isCodeFileByPath("test.txt"), false);
+    });
+
+    it("should generate correct glob pattern", () => {
+      const pattern = LanguageUtils.getCodeFileGlobPattern();
+      assert.ok(pattern.includes("ts"));
+      assert.ok(pattern.includes("js"));
+      assert.ok(pattern.includes("py"));
+    });
+  });
+
+  describe("FileUtils", () => {
+    it("should correctly identify files to ignore", () => {
+      assert.strictEqual(FileUtils.shouldIgnoreFile("/path/node_modules/test.js"), true);
+      assert.strictEqual(FileUtils.shouldIgnoreFile("/path/.git/config"), true);
+      assert.strictEqual(FileUtils.shouldIgnoreFile("/path/src/test.ts"), false);
+    });
+
+    it("should assign correct file priorities", () => {
+      assert.strictEqual(FileUtils.getFilePriority("/path/index.ts"), 100);
+      assert.strictEqual(FileUtils.getFilePriority("/path/package.json"), 90);
+      assert.strictEqual(FileUtils.getFilePriority("/path/README.md"), 80);
+      assert.strictEqual(FileUtils.getFilePriority("/path/src/utils.ts"), 70);
+      assert.strictEqual(FileUtils.getFilePriority("/path/test/unit.spec.ts"), 60);
+      assert.strictEqual(FileUtils.getFilePriority("/path/other.ts"), 50);
+    });
+  });
+
+  describe("AsyncUtils", () => {
+    it("should process items in batches", async () => {
+      const items = [1, 2, 3, 4, 5];
+      const processed: number[] = [];
+
+      await AsyncUtils.processBatches(
+        items,
+        async (item) => {
+          processed.push(item);
+        },
+        2
+      );
+
+      assert.deepStrictEqual(processed.sort(), [1, 2, 3, 4, 5]);
+    });
+
+    it("should handle async operations safely", async () => {
+      const result = await AsyncUtils.safeExecute(
+        async () => {
+          throw new Error("Test error");
+        },
+        "fallback",
+        (error) => {
+          assert.strictEqual(error.message, "Test error");
+        }
+      );
+
+      assert.strictEqual(result, "fallback");
+    });
+
+    it("should process batches with progress reporting", async () => {
+      const items = [1, 2, 3, 4, 5];
+      const progressReports: Array<{ current: number; total: number }> = [];
+
+      await AsyncUtils.processBatchesWithProgress(
+        items,
+        async (item) => {
+          // Process item
+        },
+        2,
+        (current, total) => {
+          progressReports.push({ current, total });
+        }
+      );
+
+      assert.strictEqual(progressReports.length, 5);
+      assert.strictEqual(progressReports[progressReports.length - 1].current, 5);
+      assert.strictEqual(progressReports[progressReports.length - 1].total, 5);
+    });
+  });
+
+  describe("VectorDbSyncService", () => {
+    let vectorDbService: sinon.SinonStubbedInstance<VectorDatabaseService>;
+    let codeIndexer: sinon.SinonStubbedInstance<ICodeIndexer>;
+    let syncService: VectorDbSyncService;
+
+    beforeEach(() => {
+      vectorDbService = sandbox.createStubInstance(VectorDatabaseService);
+      codeIndexer = {
+        generateEmbeddings: sandbox.stub<[], Promise<IFunctionData[]>>().resolves([]),
+      };
+
+      vectorDbService.isReady.returns(true);
+      vectorDbService.getStats.returns({
+        isInitialized: true,
+        collectionName: "test",
+        documentCount: 0,
+        lastSync: null,
+        memoryUsage: 0,
+      });
+
+      syncService = new VectorDbSyncService(vectorDbService as any, codeIndexer);
+
+      // Mock VS Code workspace
+      sandbox.stub(vscode.workspace, "workspaceFolders").value([{ uri: { fsPath: "/test/workspace" } }]);
+    });
+
+    it("should initialize successfully when vector db is ready", async () => {
+      // Mock file system operations
+      sandbox.stub(vscode.workspace, "createFileSystemWatcher").returns({
+        onDidCreate: sandbox.stub(),
+        onDidChange: sandbox.stub(),
+        onDidDelete: sandbox.stub(),
+        dispose: sandbox.stub(),
+      } as any);
+
+      sandbox.stub(vscode.workspace, "findFiles").resolves([]);
+
+      await syncService.initialize();
+
+      assert.ok(syncService.isReady());
+    });
+
+    it("should handle file system operations correctly", () => {
+      // Test shouldIgnoreFile logic indirectly through public interface
+      const stats = syncService.getStats();
+      assert.strictEqual(typeof stats.filesMonitored, "number");
+      assert.strictEqual(typeof stats.syncOperations, "number");
+      assert.strictEqual(typeof stats.queueSize, "number");
+    });
+
+    it("should provide correct stats", () => {
+      const stats = syncService.getStats();
+
+      assert.ok("filesMonitored" in stats);
+      assert.ok("syncOperations" in stats);
+      assert.ok("lastSync" in stats);
+      assert.ok("failedOperations" in stats);
+      assert.ok("queueSize" in stats);
+    });
+
+    it("should dispose properly", () => {
+      syncService.dispose();
+      assert.ok(!syncService.isReady());
+    });
+  });
+
+  describe("ImmediateEmbeddingPhase", () => {
+    let workerManager: sinon.SinonStubbedInstance<VectorDbWorkerManager>;
+    let immediatePhase: ImmediateEmbeddingPhase;
+
+    beforeEach(() => {
+      workerManager = sandbox.createStubInstance(VectorDbWorkerManager);
+      immediatePhase = new ImmediateEmbeddingPhase(workerManager as any);
+
+      // Mock VS Code workspace
+      sandbox.stub(vscode.workspace, "workspaceFolders").value([{ uri: { fsPath: "/test/workspace" } }]);
+
+      sandbox.stub(vscode.workspace, "textDocuments").value([]);
+    });
+
+    it("should handle empty workspace gracefully", async () => {
+      sandbox.stub(vscode.workspace, "workspaceFolders").value(undefined);
+
+      // Mock progress dialog
+      sandbox.stub(vscode.window, "withProgress").callsFake(async (options, task) => {
+        const progress = {
+          report: sandbox.stub(),
+        };
+        return await task(progress, {} as any);
+      });
+
+      // This should not throw
+      await immediatePhase.embedEssentials({} as any);
+    });
+
+    it("should dispose properly", () => {
+      immediatePhase.dispose();
+      // Should not throw
+    });
+  });
+
+  describe("OnDemandEmbeddingPhase", () => {
+    let workerManager: sinon.SinonStubbedInstance<VectorDbWorkerManager>;
+    let onDemandPhase: OnDemandEmbeddingPhase;
+    let context: vscode.ExtensionContext;
+
+    beforeEach(() => {
+      workerManager = sandbox.createStubInstance(VectorDbWorkerManager);
+      context = {
+        subscriptions: [],
+      } as any;
+
+      onDemandPhase = new OnDemandEmbeddingPhase(workerManager as any);
+    });
+
+    it("should setup triggers without errors", async () => {
+      sandbox.stub(vscode.window, "onDidChangeActiveTextEditor").returns({
+        dispose: sandbox.stub(),
+      } as any);
+
+      sandbox.stub(vscode.workspace, "onDidChangeTextDocument").returns({
+        dispose: sandbox.stub(),
+      } as any);
+
+      onDemandPhase.setupTriggers();
+
+      // Should not throw
+    });
+
+    it("should handle questions correctly", async () => {
+      sandbox.stub(vscode.workspace, "workspaceFolders").value([{ uri: { fsPath: "/test/workspace" } }]);
+
+      sandbox.stub(vscode.workspace, "findFiles").resolves([]);
+
+      await onDemandPhase.onUserQuestion("test question");
+      // Method doesn't return anything, just test it doesn't throw
+    });
+
+    it("should dispose properly", () => {
+      onDemandPhase.dispose();
+      // Should not throw
+    });
+  });
+
+  describe("Integration Tests", () => {
+    it("should integrate VectorDbSyncService with real dependencies", async () => {
+      const vectorDbService = sandbox.createStubInstance(VectorDatabaseService);
+      const codeIndexer = {
+        generateEmbeddings: sandbox.stub<[], Promise<IFunctionData[]>>().resolves([]),
+      };
+
+      vectorDbService.isReady.returns(true);
+      vectorDbService.getStats.returns({
+        isInitialized: true,
+        collectionName: "test",
+        documentCount: 0,
+        lastSync: null,
+        memoryUsage: 0,
+      });
+
+      const syncService = new VectorDbSyncService(vectorDbService as any, codeIndexer);
+
+      // Mock VS Code environment
+      sandbox.stub(vscode.workspace, "workspaceFolders").value([{ uri: { fsPath: "/test/workspace" } }]);
+
+      sandbox.stub(vscode.workspace, "createFileSystemWatcher").returns({
+        onDidCreate: sandbox.stub(),
+        onDidChange: sandbox.stub(),
+        onDidDelete: sandbox.stub(),
+        dispose: sandbox.stub(),
+      } as any);
+
+      sandbox.stub(vscode.workspace, "findFiles").resolves([]);
+
+      await syncService.initialize();
+
+      const stats = syncService.getStats();
+      assert.ok(stats.filesMonitored >= 0);
+
+      syncService.dispose();
+    });
+
+    it("should handle edge cases gracefully", async () => {
+      // Test with no workspace
+      sandbox.stub(vscode.workspace, "workspaceFolders").value(undefined);
+
+      const vectorDbService = sandbox.createStubInstance(VectorDatabaseService);
+      const codeIndexer = {
+        generateEmbeddings: sandbox.stub<[], Promise<IFunctionData[]>>().resolves([]),
+      };
+
+      vectorDbService.isReady.returns(true);
+      vectorDbService.getStats.returns({
+        isInitialized: true,
+        collectionName: "test",
+        documentCount: 0,
+        lastSync: null,
+        memoryUsage: 0,
+      });
+
+      const syncService = new VectorDbSyncService(vectorDbService as any, codeIndexer);
+
+      // Should not throw
+      await syncService.initialize();
+      syncService.dispose();
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle file system errors gracefully", async () => {
+      const vectorDbService = sandbox.createStubInstance(VectorDatabaseService);
+      const codeIndexer = {
+        generateEmbeddings: sandbox.stub<[], Promise<IFunctionData[]>>().resolves([]),
+      };
+
+      vectorDbService.isReady.returns(true);
+      vectorDbService.getStats.returns({
+        isInitialized: true,
+        collectionName: "test",
+        documentCount: 0,
+        lastSync: null,
+        memoryUsage: 0,
+      });
+
+      const syncService = new VectorDbSyncService(vectorDbService as any, codeIndexer);
+
+      // Mock workspace with error
+      sandbox.stub(vscode.workspace, "workspaceFolders").value([{ uri: { fsPath: "/test/workspace" } }]);
+
+      sandbox.stub(vscode.workspace, "createFileSystemWatcher").throws(new Error("Test error"));
+
+      try {
+        await syncService.initialize();
+        assert.fail("Should have thrown");
+      } catch (error) {
+        assert.ok(error instanceof Error);
+      }
+    });
+
+    it("should handle embedding errors gracefully", async () => {
+      const workerManager = sandbox.createStubInstance(VectorDbWorkerManager);
+      const immediatePhase = new ImmediateEmbeddingPhase(workerManager as any);
+
+      // Mock VS Code workspace
+      sandbox.stub(vscode.workspace, "workspaceFolders").value([{ uri: { fsPath: "/test/workspace" } }]);
+
+      sandbox.stub(vscode.workspace, "textDocuments").value([]);
+      sandbox.stub(vscode.workspace, "findFiles").resolves([]);
+      sandbox.stub(vscode.workspace.fs, "readFile").throws(new Error("File read error"));
+
+      // Mock progress dialog
+      sandbox.stub(vscode.window, "withProgress").callsFake(async (options, task) => {
+        const progress = {
+          report: sandbox.stub(),
+        };
+        return await task(progress, {} as any);
+      });
+
+      // Should not throw - errors should be handled gracefully
+      await immediatePhase.embedEssentials({} as any);
+    });
+  });
+});
diff --git a/src/utils/common-utils.ts b/src/utils/common-utils.ts
new file mode 100644
index 0000000..09653a8
--- /dev/null
+++ b/src/utils/common-utils.ts
@@ -0,0 +1,344 @@
+import * as vscode from "vscode";
+import * as path from "path";
+
+/**
+ * Utility class for language and file type operations
+ */
+export class LanguageUtils {
+  /**
+   * Determines if a file is a code file based on its language ID
+   */
+  static isCodeFile(languageId: string): boolean {
+    const codeLanguages = [
+      "typescript",
+      "javascript",
+      "python",
+      "java",
+      "cpp",
+      "c",
+      "csharp",
+      "php",
+      "ruby",
+      "go",
+      "rust",
+      "swift",
+      "kotlin",
+      "scala",
+      "r",
+      "objective-c",
+      "vue",
+      "jsx",
+      "tsx",
+      "json",
+      "yaml",
+      "xml",
+      "html",
+      "css",
+    ];
+    return codeLanguages.includes(languageId);
+  }
+
+  /**
+   * Gets the language ID from a file path
+   */
+  static getLanguageFromPath(filePath: string): string {
+    const extension = path.extname(filePath).toLowerCase();
+    const languageMap: Record<string, string> = {
+      ".ts": "typescript",
+      ".js": "javascript",
+      ".tsx": "tsx",
+      ".jsx": "jsx",
+      ".py": "python",
+      ".java": "java",
+      ".cpp": "cpp",
+      ".c": "c",
+      ".cs": "csharp",
+      ".php": "php",
+      ".rb": "ruby",
+      ".go": "go",
+      ".rs": "rust",
+      ".swift": "swift",
+      ".kt": "kotlin",
+      ".scala": "scala",
+      ".r": "r",
+      ".m": "objective-c",
+      ".vue": "vue",
+      ".json": "json",
+      ".yaml": "yaml",
+      ".yml": "yaml",
+      ".xml": "xml",
+      ".html": "html",
+      ".css": "css",
+    };
+    return languageMap[extension] || "plaintext";
+  }
+
+  /**
+   * Checks if a file is a code file based on its path
+   */
+  static isCodeFileByPath(filePath: string): boolean {
+    const languageId = this.getLanguageFromPath(filePath);
+    return this.isCodeFile(languageId);
+  }
+
+  /**
+   * Gets file extensions for code files
+   */
+  static getCodeFileExtensions(): string[] {
+    return [
+      "ts",
+      "js",
+      "tsx",
+      "jsx",
+      "py",
+      "java",
+      "cpp",
+      "c",
+      "cs",
+      "php",
+      "rb",
+      "go",
+      "rs",
+      "swift",
+      "kt",
+      "scala",
+      "r",
+      "m",
+      "vue",
+    ];
+  }
+
+  /**
+   * Creates a glob pattern for code files
+   */
+  static getCodeFileGlobPattern(): string {
+    const extensions = this.getCodeFileExtensions().join(",");
+    return `**/*.{${extensions}}`;
+  }
+}
+
+/**
+ * Utility class for file system operations
+ */
+export class FileUtils {
+  /**
+   * Safely gets file stats with error handling
+   */
+  static async safeGetStats(uri: vscode.Uri): Promise<vscode.FileStat | null> {
+    try {
+      return await vscode.workspace.fs.stat(uri);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Checks if a file exists
+   */
+  static async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await vscode.workspace.fs.stat(vscode.Uri.file(filePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Gets the relative path from workspace root
+   */
+  static getRelativePath(filePath: string): string {
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) {
+      return path.basename(filePath);
+    }
+    return path.relative(workspaceFolder.uri.fsPath, filePath);
+  }
+
+  /**
+   * Filters out ignored files based on common patterns
+   */
+  static shouldIgnoreFile(filePath: string): boolean {
+    const ignoredPatterns = [
+      /node_modules/,
+      /\.git/,
+      /\.vscode/,
+      /dist/,
+      /build/,
+      /out/,
+      /target/,
+      /bin/,
+      /obj/,
+      /\.next/,
+      /coverage/,
+      /\.nyc_output/,
+      /\.cache/,
+      /temp/,
+      /tmp/,
+      /\.DS_Store/,
+      /Thumbs\.db/,
+    ];
+
+    return ignoredPatterns.some((pattern) => pattern.test(filePath));
+  }
+
+  /**
+   * Gets priority score for a file (higher = more important)
+   */
+  static getFilePriority(filePath: string): number {
+    const fileName = path.basename(filePath).toLowerCase();
+    const directory = path.dirname(filePath).toLowerCase();
+
+    // Entry points and config files
+    if (
+      [
+        "index.ts",
+        "index.js",
+        "main.ts",
+        "main.js",
+        "app.ts",
+        "app.js",
+      ].includes(fileName)
+    ) {
+      return 100;
+    }
+
+    // Config files
+    if (
+      [
+        "package.json",
+        "tsconfig.json",
+        "webpack.config.js",
+        "vite.config.ts",
+      ].includes(fileName)
+    ) {
+      return 90;
+    }
+
+    // README and documentation
+    if (fileName.startsWith("readme") || fileName.includes("doc")) {
+      return 80;
+    }
+
+    // Source directories
+    if (directory.includes("src") || directory.includes("lib")) {
+      return 70;
+    }
+
+    // Test files
+    if (
+      fileName.includes("test") ||
+      fileName.includes("spec") ||
+      directory.includes("test")
+    ) {
+      return 60;
+    }
+
+    // Default priority
+    return 50;
+  }
+}
+
+/**
+ * Utility class for async operations
+ */
+export class AsyncUtils {
+  /**
+   * Delays execution for specified milliseconds
+   */
+  static delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Processes items in batches with optional delay between batches
+   */
+  static async processBatches<T>(
+    items: T[],
+    processor: (item: T) => Promise<void>,
+    batchSize: number = 10,
+    delayMs: number = 0,
+  ): Promise<void> {
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      await Promise.all(batch.map(processor));
+
+      if (delayMs > 0 && i + batchSize < items.length) {
+        await this.delay(delayMs);
+      }
+    }
+  }
+
+  /**
+   * Processes items in batches with progress reporting
+   */
+  static async processBatchesWithProgress<T>(
+    items: T[],
+    processor: (item: T, index: number) => Promise<void>,
+    batchSize: number = 10,
+    progressCallback?: (current: number, total: number) => void,
+  ): Promise<void> {
+    let processed = 0;
+
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+
+      await Promise.all(
+        batch.map(async (item, batchIndex) => {
+          const globalIndex = i + batchIndex;
+          await processor(item, globalIndex);
+          processed++;
+
+          if (progressCallback) {
+            progressCallback(processed, items.length);
+          }
+        }),
+      );
+    }
+  }
+
+  /**
+   * Wraps an async operation with error handling
+   */
+  static async safeExecute<T>(
+    operation: () => Promise<T>,
+    fallback: T,
+    errorHandler?: (error: Error) => void,
+  ): Promise<T> {
+    try {
+      return await operation();
+    } catch (error) {
+      if (errorHandler) {
+        errorHandler(error as Error);
+      }
+      return fallback;
+    }
+  }
+}
+
+/**
+ * Utility class for disposable management
+ */
+export class DisposableUtils {
+  /**
+   * Safely disposes of multiple disposables
+   */
+  static safeDispose(disposables: vscode.Disposable[]): void {
+    disposables.forEach((disposable) => {
+      try {
+        disposable.dispose();
+      } catch (error) {
+        console.warn("Error disposing resource:", error);
+      }
+    });
+  }
+
+  /**
+   * Creates a composite disposable from multiple disposables
+   */
+  static createComposite(disposables: vscode.Disposable[]): vscode.Disposable {
+    return new vscode.Disposable(() => {
+      this.safeDispose(disposables);
+    });
+  }
+}
diff --git a/test-pr-review.md b/test-pr-review.md
deleted file mode 100644
index d39365f..0000000
--- a/test-pr-review.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# PR Review Enhancement Test
-
-This file is created to test the enhanced PR review functionality.
-
-## Changes Made:
-- Enhanced PR review to use VS Code's git integration
-- Added fallback mechanisms for when git detection fails
-- Improved file content reading and analysis
-- Added support for multiple programming languages
-
-## Features:
-- Detects actual changed files instead of returning "0 modified files"
-- Uses VS Code's native git API when available
-- Falls back to recent file detection when git fails
-- Provides actual code content for review instead of empty diffs
-
-This should help the PR review command provide meaningful feedback instead of hypothetical reviews.