dartmind 17.0.0

package/dist/migration/MigrationEngine.js

@@ -0,0 +1,803 @@
+/**
+ * FlutterAI v8.0 Supreme Vision - Migration Engine
+ * Project-Wide State Management Refactoring
+ *
+ * Capabilities:
+ * - State Management Migration (Provider -> Riverpod, BLoC -> Cubit, etc.)
+ * - Null Safety Migration
+ * - Flutter Version Upgrades
+ * - Deprecation Fixes
+ * - Pattern Transformation
+ * - Atomic Rollback Support
+ *
+ * @author FlutterAI Supreme Engine
+ * @version 8.0.0
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { EventEmitter } from 'events';
+import { ProjectAnalyzer, StateManagementType } from '../analysis/ProjectAnalyzer.js';
+// ============================================================================
+// TYPE DEFINITIONS
+// ============================================================================
+export var MigrationType;
+(function (MigrationType) {
+    // State Management Migrations
+    MigrationType["PROVIDER_TO_RIVERPOD"] = "provider_to_riverpod";
+    MigrationType["BLOC_TO_CUBIT"] = "bloc_to_cubit";
+    MigrationType["GETX_TO_RIVERPOD"] = "getx_to_riverpod";
+    MigrationType["SETSTATE_TO_PROVIDER"] = "setstate_to_provider";
+    MigrationType["SETSTATE_TO_RIVERPOD"] = "setstate_to_riverpod";
+    MigrationType["MOBX_TO_RIVERPOD"] = "mobx_to_riverpod";
+    // Code Modernization
+    MigrationType["NULL_SAFETY"] = "null_safety";
+    MigrationType["FLUTTER_3_UPGRADE"] = "flutter_3_upgrade";
+    MigrationType["FLUTTER_3_16_UPGRADE"] = "flutter_3_16_upgrade";
+    MigrationType["DART_3_UPGRADE"] = "dart_3_upgrade";
+    // Pattern Transformations
+    MigrationType["CHANGE_NOTIFIER_TO_NOTIFIER"] = "change_notifier_to_notifier";
+    MigrationType["STATEFUL_TO_HOOKS"] = "stateful_to_hooks";
+    MigrationType["FUTURE_BUILDER_TO_ASYNC_NOTIFIER"] = "future_builder_to_async_notifier";
+    // Deprecation Fixes
+    MigrationType["FIX_DEPRECATIONS"] = "fix_deprecations";
+    MigrationType["MATERIAL_3_MIGRATION"] = "material_3_migration";
+})(MigrationType || (MigrationType = {}));
+export var ChangeType;
+(function (ChangeType) {
+    ChangeType["IMPORT_ADD"] = "import_add";
+    ChangeType["IMPORT_REMOVE"] = "import_remove";
+    ChangeType["IMPORT_MODIFY"] = "import_modify";
+    ChangeType["CLASS_RENAME"] = "class_rename";
+    ChangeType["CLASS_MODIFY"] = "class_modify";
+    ChangeType["METHOD_RENAME"] = "method_rename";
+    ChangeType["METHOD_MODIFY"] = "method_modify";
+    ChangeType["METHOD_ADD"] = "method_add";
+    ChangeType["METHOD_REMOVE"] = "method_remove";
+    ChangeType["FIELD_MODIFY"] = "field_modify";
+    ChangeType["TYPE_MODIFY"] = "type_modify";
+    ChangeType["ANNOTATION_ADD"] = "annotation_add";
+    ChangeType["ANNOTATION_REMOVE"] = "annotation_remove";
+    ChangeType["SYNTAX_UPDATE"] = "syntax_update";
+    ChangeType["DEPENDENCY_ADD"] = "dependency_add";
+    ChangeType["DEPENDENCY_REMOVE"] = "dependency_remove";
+    ChangeType["FULL_REWRITE"] = "full_rewrite";
+})(ChangeType || (ChangeType = {}));
+// ============================================================================
+// MIGRATION ENGINE CLASS
+// ============================================================================
+export class MigrationEngine extends EventEmitter {
+    projectPath;
+    analyzer = null;
+    backupPath;
+    rollbacks = new Map();
+    // Migration patterns for each type
+    PROVIDER_TO_RIVERPOD_PATTERNS = [
+        {
+            name: 'Import: provider -> riverpod',
+            find: /import\s+['"]package:provider\/provider\.dart['"]\s*;/g,
+            replace: "import 'package:flutter_riverpod/flutter_riverpod.dart';",
+            confidence: 95,
+            breaking: false
+        },
+        {
+            name: 'ChangeNotifierProvider -> NotifierProvider',
+            find: /ChangeNotifierProvider<(\w+)>\s*\(\s*create:\s*\([^)]*\)\s*=>\s*(\w+)\(\)/g,
+            replace: (match, ctx) => {
+                const className = match[1];
+                const provider = this.toProviderName(className);
+                return `final ${provider} = NotifierProvider<${className}, ${this.inferStateType(className, ctx)}>(() => ${className}())`;
+            },
+            confidence: 85,
+            breaking: true
+        },
+        {
+            name: 'Consumer -> Consumer (Riverpod)',
+            find: /Consumer<(\w+)>\s*\(\s*builder:\s*\(\s*context\s*,\s*(\w+)\s*,\s*child\s*\)/g,
+            replace: (match, ctx) => {
+                const typeName = match[1];
+                const varName = match[2];
+                const provider = this.toProviderName(typeName);
+                return `Consumer(\n  builder: (context, ref, child) {\n    final ${varName} = ref.watch(${provider})`;
+            },
+            confidence: 80,
+            breaking: true
+        },
+        {
+            name: 'Provider.of -> ref.watch',
+            find: /Provider\.of<(\w+)>\s*\(\s*context\s*(,\s*listen:\s*(true|false))?\s*\)/g,
+            replace: (match) => {
+                const typeName = match[1];
+                const listen = match[3] !== 'false';
+                const provider = this.toProviderName(typeName);
+                return listen ? `ref.watch(${provider})` : `ref.read(${provider})`;
+            },
+            confidence: 90,
+            breaking: true
+        },
+        {
+            name: 'context.watch -> ref.watch',
+            find: /context\.watch<(\w+)>\s*\(\s*\)/g,
+            replace: (match) => {
+                const typeName = match[1];
+                const provider = this.toProviderName(typeName);
+                return `ref.watch(${provider})`;
+            },
+            confidence: 90,
+            breaking: true
+        },
+        {
+            name: 'context.read -> ref.read',
+            find: /context\.read<(\w+)>\s*\(\s*\)/g,
+            replace: (match) => {
+                const typeName = match[1];
+                const provider = this.toProviderName(typeName);
+                return `ref.read(${provider})`;
+            },
+            confidence: 90,
+            breaking: true
+        },
+        {
+            name: 'MultiProvider -> ProviderScope',
+            find: /MultiProvider\s*\(\s*providers:\s*\[/g,
+            replace: 'ProviderScope(\n  child: ',
+            confidence: 75,
+            breaking: true
+        },
+        {
+            name: 'ChangeNotifier -> Notifier',
+            find: /class\s+(\w+)\s+extends\s+ChangeNotifier\s*\{/g,
+            replace: (match, ctx) => {
+                const className = match[1];
+                const stateType = this.inferStateType(className, ctx);
+                return `class ${className} extends Notifier<${stateType}> {\n  @override\n  ${stateType} build() => ${stateType}();\n`;
+            },
+            confidence: 75,
+            breaking: true
+        },
+        {
+            name: 'notifyListeners() -> state = state.copyWith()',
+            find: /notifyListeners\s*\(\s*\)\s*;/g,
+            replace: '// State automatically notified in Riverpod',
+            confidence: 60,
+            breaking: true
+        },
+        {
+            name: 'StatelessWidget -> ConsumerWidget',
+            find: /class\s+(\w+)\s+extends\s+StatelessWidget\s*\{/g,
+            replace: (match) => `class ${match[1]} extends ConsumerWidget {`,
+            condition: (content) => content.includes('Provider.of') || content.includes('context.watch'),
+            confidence: 85,
+            breaking: false
+        },
+        {
+            name: 'build(BuildContext context) -> build(BuildContext context, WidgetRef ref)',
+            find: /Widget\s+build\s*\(\s*BuildContext\s+context\s*\)\s*\{/g,
+            replace: 'Widget build(BuildContext context, WidgetRef ref) {',
+            condition: (content) => content.includes('ConsumerWidget'),
+            confidence: 90,
+            breaking: false
+        }
+    ];
+    BLOC_TO_CUBIT_PATTERNS = [
+        {
+            name: 'Bloc -> Cubit',
+            find: /class\s+(\w+)\s+extends\s+Bloc<(\w+),\s*(\w+)>\s*\{/g,
+            replace: (match) => `class ${match[1]} extends Cubit<${match[3]}> {`,
+            confidence: 85,
+            breaking: true
+        },
+        {
+            name: 'Remove event handlers',
+            find: /on<(\w+)>\s*\(\s*(\w+)\s*\)\s*;/g,
+            replace: '// Converted from event handler',
+            confidence: 70,
+            breaking: true
+        },
+        {
+            name: 'emit(state) remains same',
+            find: /emit\s*\(/g,
+            replace: 'emit(',
+            confidence: 100,
+            breaking: false
+        },
+        {
+            name: 'BlocProvider unchanged',
+            find: /BlocProvider<(\w+)>/g,
+            replace: 'BlocProvider<$1>',
+            confidence: 100,
+            breaking: false
+        },
+        {
+            name: 'BlocBuilder unchanged',
+            find: /BlocBuilder<(\w+),\s*(\w+)>/g,
+            replace: 'BlocBuilder<$1, $2>',
+            confidence: 100,
+            breaking: false
+        }
+    ];
+    NULL_SAFETY_PATTERNS = [
+        {
+            name: 'Add required keyword',
+            find: /@required\s+/g,
+            replace: 'required ',
+            confidence: 95,
+            breaking: false
+        },
+        {
+            name: 'Remove @required annotation',
+            find: /import\s+['"]package:meta\/meta\.dart['"]\s*;/g,
+            replace: '',
+            condition: (content) => !content.includes('@visibleForTesting') && !content.includes('@protected'),
+            confidence: 80,
+            breaking: false
+        },
+        {
+            name: 'Nullable type inference',
+            find: /(\w+)\s+(\w+)\s*;\s*\/\/\s*nullable/g,
+            replace: '$1? $2;',
+            confidence: 70,
+            breaking: false
+        },
+        {
+            name: 'Late initialization',
+            find: /(\w+)\s+(\w+)\s*;\s*\/\/\s*late/g,
+            replace: 'late $1 $2;',
+            confidence: 70,
+            breaking: false
+        }
+    ];
+    MATERIAL_3_PATTERNS = [
+        {
+            name: 'ThemeData useMaterial3',
+            find: /ThemeData\s*\(/g,
+            replace: 'ThemeData(\n    useMaterial3: true,',
+            condition: (content) => !content.includes('useMaterial3'),
+            confidence: 90,
+            breaking: false
+        },
+        {
+            name: 'ElevatedButton.styleFrom',
+            find: /ElevatedButton\.styleFrom\s*\(\s*primary:/g,
+            replace: 'ElevatedButton.styleFrom(\n    backgroundColor:',
+            confidence: 95,
+            breaking: false
+        },
+        {
+            name: 'ElevatedButton.styleFrom onPrimary',
+            find: /onPrimary:/g,
+            replace: 'foregroundColor:',
+            condition: (content) => content.includes('ElevatedButton.styleFrom'),
+            confidence: 90,
+            breaking: false
+        },
+        {
+            name: 'TextButton.styleFrom primary',
+            find: /TextButton\.styleFrom\s*\(\s*primary:/g,
+            replace: 'TextButton.styleFrom(\n    foregroundColor:',
+            confidence: 95,
+            breaking: false
+        }
+    ];
+    constructor(projectPath) {
+        super();
+        this.projectPath = path.resolve(projectPath);
+        this.backupPath = path.join(this.projectPath, '.fai', 'migration_backups');
+    }
+    // ==========================================================================
+    // PUBLIC API
+    // ==========================================================================
+    /**
+     * Initialize migration engine with project analysis
+     */
+    async initialize() {
+        this.emit('status', 'Initializing Migration Engine...');
+        // Verify project
+        if (!fs.existsSync(this.projectPath)) {
+            throw new Error(`Project path does not exist: ${this.projectPath}`);
+        }
+        const pubspecPath = path.join(this.projectPath, 'pubspec.yaml');
+        if (!fs.existsSync(pubspecPath)) {
+            throw new Error('Not a Flutter project: pubspec.yaml not found');
+        }
+        // Initialize analyzer
+        this.analyzer = new ProjectAnalyzer(this.projectPath);
+        await this.analyzer.initialize();
+        // Ensure backup directory
+        if (!fs.existsSync(this.backupPath)) {
+            fs.mkdirSync(this.backupPath, { recursive: true });
+        }
+        this.emit('status', 'Migration Engine initialized');
+    }
+    /**
+     * Analyze project and create migration plan
+     */
+    async plan(config) {
+        const fullConfig = {
+            type: MigrationType.PROVIDER_TO_RIVERPOD,
+            projectPath: this.projectPath,
+            dryRun: true,
+            createBackup: true,
+            interactive: false,
+            excludePatterns: [],
+            includeTests: true,
+            preserveComments: true,
+            maxFilesPerBatch: 50,
+            ...config
+        };
+        this.emit('status', `Creating migration plan for ${fullConfig.type}...`);
+        // Run analysis
+        const analysis = await this.analyzer.analyze();
+        // Get patterns for migration type
+        const patterns = this.getPatternsForType(fullConfig.type);
+        // Scan files for matches
+        const migrationFiles = [];
+        let totalChanges = 0;
+        for (const file of analysis.files) {
+            if (this.shouldExclude(file.relativePath, fullConfig.excludePatterns)) {
+                continue;
+            }
+            if (!fullConfig.includeTests && file.relativePath.includes('_test.dart')) {
+                continue;
+            }
+            const changes = await this.findChanges(file, patterns);
+            if (changes.length > 0) {
+                const content = fs.readFileSync(file.path, 'utf-8');
+                migrationFiles.push({
+                    path: file.relativePath,
+                    changes,
+                    beforeHash: crypto.createHash('md5').update(content).digest('hex'),
+                    status: 'pending'
+                });
+                totalChanges += changes.length;
+            }
+        }
+        // Calculate risk level
+        let riskLevel = 'low';
+        const breakingChanges = migrationFiles.reduce((sum, f) => sum + f.changes.filter(c => c.breaking).length, 0);
+        if (breakingChanges > 50 || migrationFiles.length > 30) {
+            riskLevel = 'high';
+        }
+        else if (breakingChanges > 10 || migrationFiles.length > 10) {
+            riskLevel = 'medium';
+        }
+        // Determine required dependencies
+        const dependencies = this.getDependenciesForType(fullConfig.type);
+        // Calculate estimated duration (rough: 100ms per change)
+        const estimatedDuration = totalChanges * 100;
+        const plan = {
+            id: crypto.randomUUID(),
+            type: fullConfig.type,
+            files: migrationFiles,
+            totalChanges,
+            estimatedDuration,
+            riskLevel,
+            warnings: this.generateWarnings(migrationFiles, fullConfig.type),
+            dependencies,
+            createdAt: new Date()
+        };
+        this.emit('planCreated', plan);
+        return plan;
+    }
+    /**
+     * Execute migration plan
+     */
+    async execute(plan, options = {}) {
+        const startTime = Date.now();
+        const dryRun = options.dryRun ?? false;
+        const createBackup = options.createBackup ?? true;
+        this.emit('status', `Executing migration ${plan.id}...`);
+        const result = {
+            success: true,
+            plan,
+            filesModified: 0,
+            filesSkipped: 0,
+            filesFailed: 0,
+            changesApplied: 0,
+            errors: [],
+            warnings: [],
+            duration: 0,
+            canRollback: false
+        };
+        // Create backup if requested
+        let rollbackInfo = null;
+        if (createBackup && !dryRun) {
+            rollbackInfo = await this.createBackup(plan);
+            result.canRollback = true;
+            result.rollbackId = rollbackInfo.id;
+        }
+        // Get patterns
+        const patterns = this.getPatternsForType(plan.type);
+        // Process each file
+        for (const migrationFile of plan.files) {
+            try {
+                migrationFile.status = 'processing';
+                this.emit('fileProcessing', migrationFile.path);
+                const filePath = path.join(this.projectPath, migrationFile.path);
+                let content = fs.readFileSync(filePath, 'utf-8');
+                // Apply changes
+                const transformedContent = await this.applyChanges(content, migrationFile.changes, patterns);
+                if (content !== transformedContent) {
+                    if (!dryRun) {
+                        fs.writeFileSync(filePath, transformedContent, 'utf-8');
+                    }
+                    result.filesModified++;
+                    result.changesApplied += migrationFile.changes.length;
+                    migrationFile.status = 'completed';
+                }
+                else {
+                    migrationFile.status = 'skipped';
+                    result.filesSkipped++;
+                }
+                this.emit('fileCompleted', {
+                    path: migrationFile.path,
+                    status: migrationFile.status
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                migrationFile.status = 'failed';
+                migrationFile.error = errorMessage;
+                result.filesFailed++;
+                result.errors.push({
+                    file: migrationFile.path,
+                    message: errorMessage,
+                    type: 'transform',
+                    recoverable: true
+                });
+                this.emit('fileError', { path: migrationFile.path, error: errorMessage });
+            }
+        }
+        // Update dependencies if not dry run
+        if (!dryRun && plan.dependencies.length > 0) {
+            await this.updateDependencies(plan.dependencies);
+        }
+        result.duration = Date.now() - startTime;
+        result.success = result.filesFailed === 0;
+        if (rollbackInfo) {
+            this.rollbacks.set(rollbackInfo.id, rollbackInfo);
+        }
+        this.emit('migrationComplete', result);
+        return result;
+    }
+    /**
+     * Rollback a migration
+     */
+    async rollback(rollbackId) {
+        const rollbackInfo = this.rollbacks.get(rollbackId);
+        if (!rollbackInfo) {
+            throw new Error(`Rollback not found: ${rollbackId}`);
+        }
+        this.emit('status', `Rolling back migration ${rollbackInfo.migrationId}...`);
+        try {
+            for (const file of rollbackInfo.files) {
+                const filePath = path.join(this.projectPath, file.path);
+                fs.writeFileSync(filePath, file.content, 'utf-8');
+                this.emit('fileRolledBack', file.path);
+            }
+            this.rollbacks.delete(rollbackId);
+            this.emit('rollbackComplete', rollbackId);
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.emit('rollbackError', { id: rollbackId, error: errorMessage });
+            return false;
+        }
+    }
+    /**
+     * Get available migration types for current project
+     */
+    async suggestMigrations() {
+        const analysis = await this.analyzer.analyze();
+        const suggestions = [];
+        // Check state management
+        if (analysis.stateManagement.detected.includes(StateManagementType.PROVIDER)) {
+            suggestions.push({
+                type: MigrationType.PROVIDER_TO_RIVERPOD,
+                reason: 'Provider detected. Riverpod provides better compile-time safety and testability.',
+                impact: `~${analysis.files.filter((f) => f.imports.some((i) => i.package.includes('provider'))).length} files affected`
+            });
+        }
+        if (analysis.stateManagement.detected.includes(StateManagementType.BLOC)) {
+            suggestions.push({
+                type: MigrationType.BLOC_TO_CUBIT,
+                reason: 'BLoC detected. Cubit is simpler for many use cases.',
+                impact: `~${analysis.files.filter((f) => f.classes.some((c) => c.extends === 'Bloc')).length} files affected`
+            });
+        }
+        if (analysis.stateManagement.detected.includes(StateManagementType.VANILLA)) {
+            suggestions.push({
+                type: MigrationType.SETSTATE_TO_RIVERPOD,
+                reason: 'setState detected. State management library recommended for scalability.',
+                impact: `~${analysis.files.filter((f) => f.classes.some((c) => c.extends === 'State')).length} files affected`
+            });
+        }
+        // Check for Material 3
+        const hasMaterial3 = analysis.files.some((f) => {
+            const content = fs.readFileSync(f.path, 'utf-8');
+            return content.includes('useMaterial3: true');
+        });
+        if (!hasMaterial3) {
+            suggestions.push({
+                type: MigrationType.MATERIAL_3_MIGRATION,
+                reason: 'Material 3 not enabled. Modern UI guidelines recommended.',
+                impact: 'Theme and widget styling updates'
+            });
+        }
+        // Check for deprecations
+        const hasDeprecations = analysis.files.some((f) => {
+            const content = fs.readFileSync(f.path, 'utf-8');
+            return content.includes('primary:') || content.includes('onPrimary:');
+        });
+        if (hasDeprecations) {
+            suggestions.push({
+                type: MigrationType.FIX_DEPRECATIONS,
+                reason: 'Deprecated APIs detected. Update for Flutter compatibility.',
+                impact: 'Multiple styling properties to update'
+            });
+        }
+        return suggestions;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - PATTERNS
+    // ==========================================================================
+    getPatternsForType(type) {
+        switch (type) {
+            case MigrationType.PROVIDER_TO_RIVERPOD:
+                return this.PROVIDER_TO_RIVERPOD_PATTERNS;
+            case MigrationType.BLOC_TO_CUBIT:
+                return this.BLOC_TO_CUBIT_PATTERNS;
+            case MigrationType.NULL_SAFETY:
+                return this.NULL_SAFETY_PATTERNS;
+            case MigrationType.MATERIAL_3_MIGRATION:
+            case MigrationType.FIX_DEPRECATIONS:
+                return this.MATERIAL_3_PATTERNS;
+            default:
+                return [];
+        }
+    }
+    getDependenciesForType(type) {
+        switch (type) {
+            case MigrationType.PROVIDER_TO_RIVERPOD:
+                return [
+                    { name: 'provider', action: 'remove', requiredVersion: '' },
+                    { name: 'flutter_riverpod', action: 'add', requiredVersion: '^2.4.0' },
+                    { name: 'riverpod_annotation', action: 'add', requiredVersion: '^2.3.0' }
+                ];
+            case MigrationType.BLOC_TO_CUBIT:
+                return [
+                    { name: 'flutter_bloc', action: 'update', requiredVersion: '^8.1.0' }
+                ];
+            case MigrationType.SETSTATE_TO_RIVERPOD:
+                return [
+                    { name: 'flutter_riverpod', action: 'add', requiredVersion: '^2.4.0' }
+                ];
+            default:
+                return [];
+        }
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - CHANGE DETECTION
+    // ==========================================================================
+    async findChanges(file, patterns) {
+        const changes = [];
+        const content = fs.readFileSync(file.path, 'utf-8');
+        const lines = content.split('\n');
+        const context = {
+            file,
+            content,
+            imports: new Map(file.imports.map((i) => [i.package, i.alias || ''])),
+            classNames: new Set(file.classes.map((c) => c.name))
+        };
+        for (const pattern of patterns) {
+            // Check condition
+            if (pattern.condition && !pattern.condition(content, file)) {
+                continue;
+            }
+            // Find all matches
+            let match;
+            const regex = new RegExp(pattern.find.source, pattern.find.flags);
+            while ((match = regex.exec(content)) !== null) {
+                const startIndex = match.index;
+                const endIndex = startIndex + match[0].length;
+                // Calculate line/column
+                const beforeMatch = content.substring(0, startIndex);
+                const linesBefore = beforeMatch.split('\n');
+                const line = linesBefore.length;
+                const column = linesBefore[linesBefore.length - 1].length + 1;
+                const afterMatch = content.substring(0, endIndex);
+                const linesAfter = afterMatch.split('\n');
+                const endLine = linesAfter.length;
+                const endColumn = linesAfter[linesAfter.length - 1].length + 1;
+                // Calculate replacement
+                let replacement;
+                if (typeof pattern.replace === 'function') {
+                    replacement = pattern.replace(match, context);
+                }
+                else {
+                    replacement = match[0].replace(regex, pattern.replace);
+                }
+                changes.push({
+                    id: crypto.randomUUID(),
+                    type: this.inferChangeType(pattern.name),
+                    description: pattern.name,
+                    line,
+                    column,
+                    endLine,
+                    endColumn,
+                    before: match[0],
+                    after: replacement,
+                    confidence: pattern.confidence,
+                    requiresReview: pattern.confidence < 80,
+                    breaking: pattern.breaking
+                });
+            }
+        }
+        return changes;
+    }
+    inferChangeType(patternName) {
+        const lower = patternName.toLowerCase();
+        if (lower.includes('import')) {
+            if (lower.includes('add'))
+                return ChangeType.IMPORT_ADD;
+            if (lower.includes('remove'))
+                return ChangeType.IMPORT_REMOVE;
+            return ChangeType.IMPORT_MODIFY;
+        }
+        if (lower.includes('class')) {
+            if (lower.includes('rename'))
+                return ChangeType.CLASS_RENAME;
+            return ChangeType.CLASS_MODIFY;
+        }
+        if (lower.includes('method')) {
+            if (lower.includes('add'))
+                return ChangeType.METHOD_ADD;
+            if (lower.includes('remove'))
+                return ChangeType.METHOD_REMOVE;
+            return ChangeType.METHOD_MODIFY;
+        }
+        if (lower.includes('annotation')) {
+            if (lower.includes('add'))
+                return ChangeType.ANNOTATION_ADD;
+            if (lower.includes('remove'))
+                return ChangeType.ANNOTATION_REMOVE;
+        }
+        if (lower.includes('dependency')) {
+            if (lower.includes('add'))
+                return ChangeType.DEPENDENCY_ADD;
+            if (lower.includes('remove'))
+                return ChangeType.DEPENDENCY_REMOVE;
+        }
+        return ChangeType.SYNTAX_UPDATE;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - TRANSFORMATION
+    // ==========================================================================
+    async applyChanges(content, changes, patterns) {
+        let result = content;
+        // Sort changes by position (reverse order to preserve indices)
+        const sortedChanges = [...changes].sort((a, b) => {
+            if (a.line !== b.line)
+                return b.line - a.line;
+            return b.column - a.column;
+        });
+        // Apply each change
+        for (const change of sortedChanges) {
+            const before = change.before;
+            const after = change.after;
+            // Find and replace (considering the change might have shifted)
+            const index = result.indexOf(before);
+            if (index !== -1) {
+                result = result.substring(0, index) + after + result.substring(index + before.length);
+            }
+        }
+        return result;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - HELPERS
+    // ==========================================================================
+    toProviderName(className) {
+        // Convert PascalCase to camelCase and add Provider suffix
+        const camel = className.charAt(0).toLowerCase() + className.slice(1);
+        return `${camel}Provider`;
+    }
+    inferStateType(className, context) {
+        // Try to infer state type from class definition
+        const cls = context.file.classes.find((c) => c.name === className);
+        if (cls) {
+            // Look for a state field
+            const stateField = cls.fields.find((f) => f.name === 'state' || f.name === '_state' || f.type.includes('State'));
+            if (stateField) {
+                return stateField.type;
+            }
+        }
+        // Default to generic state type
+        return `${className}State`;
+    }
+    shouldExclude(filePath, patterns) {
+        for (const pattern of patterns) {
+            if (filePath.includes(pattern))
+                return true;
+        }
+        return false;
+    }
+    generateWarnings(files, type) {
+        const warnings = [];
+        const breakingCount = files.reduce((sum, f) => sum + f.changes.filter(c => c.breaking).length, 0);
+        if (breakingCount > 0) {
+            warnings.push(`${breakingCount} breaking changes detected. Review carefully.`);
+        }
+        const lowConfidenceCount = files.reduce((sum, f) => sum + f.changes.filter(c => c.confidence < 80).length, 0);
+        if (lowConfidenceCount > 0) {
+            warnings.push(`${lowConfidenceCount} changes with low confidence. Manual review recommended.`);
+        }
+        if (files.length > 30) {
+            warnings.push('Large migration. Consider running in batches.');
+        }
+        if (type === MigrationType.PROVIDER_TO_RIVERPOD) {
+            warnings.push('Provider to Riverpod migration requires updating widget signatures.');
+            warnings.push('Test thoroughly after migration.');
+        }
+        return warnings;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - BACKUP & DEPENDENCIES
+    // ==========================================================================
+    async createBackup(plan) {
+        const rollbackId = crypto.randomUUID();
+        const rollbackFiles = [];
+        for (const file of plan.files) {
+            const filePath = path.join(this.projectPath, file.path);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const hash = crypto.createHash('md5').update(content).digest('hex');
+            rollbackFiles.push({
+                path: file.path,
+                content,
+                hash
+            });
+        }
+        // Save backup to disk
+        const backupFile = path.join(this.backupPath, `${rollbackId}.json`);
+        const rollbackInfo = {
+            id: rollbackId,
+            migrationId: plan.id,
+            type: plan.type,
+            files: rollbackFiles,
+            createdAt: new Date(),
+            expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) // 7 days
+        };
+        fs.writeFileSync(backupFile, JSON.stringify(rollbackInfo, null, 2));
+        return rollbackInfo;
+    }
+    async updateDependencies(dependencies) {
+        const pubspecPath = path.join(this.projectPath, 'pubspec.yaml');
+        let content = fs.readFileSync(pubspecPath, 'utf-8');
+        for (const dep of dependencies) {
+            if (dep.action === 'add') {
+                // Add dependency
+                const dependenciesMatch = content.match(/dependencies:\n([\s\S]*?)(\n\w|$)/);
+                if (dependenciesMatch) {
+                    const indent = '  ';
+                    const newDep = `${indent}${dep.name}: ${dep.requiredVersion}\n`;
+                    const insertIndex = dependenciesMatch.index + dependenciesMatch[0].length - dependenciesMatch[2].length;
+                    content = content.slice(0, insertIndex) + newDep + content.slice(insertIndex);
+                }
+            }
+            else if (dep.action === 'remove') {
+                // Remove dependency
+                const depRegex = new RegExp(`\\s*${dep.name}:.*\\n`, 'g');
+                content = content.replace(depRegex, '\n');
+            }
+            else if (dep.action === 'update') {
+                // Update version
+                const depRegex = new RegExp(`(${dep.name}:)\\s*.*`);
+                content = content.replace(depRegex, `$1 ${dep.requiredVersion}`);
+            }
+        }
+        fs.writeFileSync(pubspecPath, content);
+        this.emit('dependenciesUpdated', dependencies);
+    }
+}
+export default MigrationEngine;
+//# sourceMappingURL=MigrationEngine.js.map