dartmind 17.0.0

package/dist/mcp/servers/flutter-migration/index.js

@@ -0,0 +1,1028 @@
+/**
+ * FlutterAI V16 - Migration MCP Server
+ * Phase 10: Issues 60.2, 63.1
+ * Port: 3008
+ *
+ * Tools:
+ * - migrate_state_management: Migrate between state management solutions
+ * - migrate_dart_version: Migrate to Dart 3 features
+ * - analyze_migration: Analyze codebase for migration opportunities
+ * - generate_migration_plan: Generate a comprehensive migration plan
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+// ============================================================================
+// Tool Definitions
+// ============================================================================
+export const migrationTools = [
+    {
+        name: 'migrate_state_management',
+        description: 'Migrate between state management solutions (Provider→Riverpod, BLoC→Cubit, etc.)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to Flutter project' },
+                from: {
+                    type: 'string',
+                    enum: ['provider', 'riverpod', 'bloc', 'cubit', 'getx', 'setState', 'mobx'],
+                    description: 'Source state management solution'
+                },
+                to: {
+                    type: 'string',
+                    enum: ['provider', 'riverpod', 'bloc', 'cubit', 'getx', 'setState', 'mobx'],
+                    description: 'Target state management solution'
+                },
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific files to migrate (optional)'
+                },
+                dryRun: { type: 'boolean', default: true },
+                preserveLogic: { type: 'boolean', default: true }
+            },
+            required: ['projectPath', 'from', 'to']
+        }
+    },
+    {
+        name: 'migrate_dart_version',
+        description: 'Migrate codebase to use Dart 3 features (super parameters, records, sealed classes)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to Flutter project' },
+                features: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['super_parameters', 'records', 'patterns', 'sealed_classes', 'class_modifiers', 'switch_expressions']
+                    },
+                    description: 'Dart 3 features to migrate to'
+                },
+                minSdkVersion: { type: 'string', default: '3.0.0' },
+                dryRun: { type: 'boolean', default: true }
+            },
+            required: ['projectPath', 'features']
+        }
+    },
+    {
+        name: 'analyze_migration',
+        description: 'Analyze codebase for migration opportunities and recommendations',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to Flutter project' },
+                includeStateManagement: { type: 'boolean', default: true },
+                includeDartFeatures: { type: 'boolean', default: true }
+            },
+            required: ['projectPath']
+        }
+    },
+    {
+        name: 'generate_migration_plan',
+        description: 'Generate a comprehensive migration plan with phases and tasks',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to Flutter project' },
+                migrations: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', enum: ['state_management', 'dart_version'] },
+                            from: { type: 'string' },
+                            to: { type: 'string' }
+                        }
+                    }
+                }
+            },
+            required: ['projectPath', 'migrations']
+        }
+    }
+];
+// ============================================================================
+// Migration Engine
+// ============================================================================
+export class MigrationEngine {
+    migrationPatterns;
+    constructor() {
+        this.migrationPatterns = new Map();
+        this.initializePatterns();
+    }
+    initializePatterns() {
+        // Provider to Riverpod patterns
+        this.migrationPatterns.set('provider_to_riverpod', {
+            name: 'Provider to Riverpod',
+            patterns: [
+                {
+                    from: /ChangeNotifierProvider<(\w+)>/g,
+                    to: 'ChangeNotifierProvider<$1>',
+                    importFrom: "import 'package:provider/provider.dart';",
+                    importTo: "import 'package:flutter_riverpod/flutter_riverpod.dart';"
+                },
+                {
+                    from: /context\.watch<(\w+)>\(\)/g,
+                    to: 'ref.watch($1Provider)',
+                    importFrom: null,
+                    importTo: null
+                },
+                {
+                    from: /context\.read<(\w+)>\(\)/g,
+                    to: 'ref.read($1Provider)',
+                    importFrom: null,
+                    importTo: null
+                },
+                {
+                    from: /Consumer<(\w+)>/g,
+                    to: 'Consumer',
+                    importFrom: null,
+                    importTo: null
+                }
+            ]
+        });
+        // BLoC to Cubit patterns
+        this.migrationPatterns.set('bloc_to_cubit', {
+            name: 'BLoC to Cubit',
+            patterns: [
+                {
+                    from: /class (\w+)Bloc extends Bloc<(\w+)Event, (\w+)State>/g,
+                    to: 'class $1Cubit extends Cubit<$3State>',
+                    importFrom: null,
+                    importTo: null
+                },
+                {
+                    from: /on<(\w+)>\(([^)]+)\)/g,
+                    to: '// Converted from event: $1',
+                    importFrom: null,
+                    importTo: null
+                },
+                {
+                    from: /add\((\w+)\(\)\)/g,
+                    to: '$1()',
+                    importFrom: null,
+                    importTo: null
+                }
+            ]
+        });
+        // GetX to Riverpod patterns
+        this.migrationPatterns.set('getx_to_riverpod', {
+            name: 'GetX to Riverpod',
+            patterns: [
+                {
+                    from: /class (\w+)Controller extends GetxController/g,
+                    to: 'class $1Notifier extends StateNotifier<$1State>',
+                    importFrom: "import 'package:get/get.dart';",
+                    importTo: "import 'package:flutter_riverpod/flutter_riverpod.dart';"
+                },
+                {
+                    from: /final (\w+) = (\w+)\.obs;/g,
+                    to: '// State field: $1',
+                    importFrom: null,
+                    importTo: null
+                },
+                {
+                    from: /Get\.find<(\w+)>\(\)/g,
+                    to: 'ref.read($1Provider.notifier)',
+                    importFrom: null,
+                    importTo: null
+                },
+                {
+                    from: /Obx\(\(\) =>/g,
+                    to: 'Consumer(builder: (context, ref, _) =>',
+                    importFrom: null,
+                    importTo: null
+                }
+            ]
+        });
+        // setState to Riverpod patterns
+        this.migrationPatterns.set('setState_to_riverpod', {
+            name: 'setState to Riverpod',
+            patterns: [
+                {
+                    from: /extends StatefulWidget/g,
+                    to: 'extends ConsumerStatefulWidget',
+                    importFrom: null,
+                    importTo: "import 'package:flutter_riverpod/flutter_riverpod.dart';"
+                },
+                {
+                    from: /extends State<(\w+)>/g,
+                    to: 'extends ConsumerState<$1>',
+                    importFrom: null,
+                    importTo: null
+                },
+                {
+                    from: /setState\(\(\) \{([^}]+)\}\)/g,
+                    to: '// TODO: Move to provider\n    // $1',
+                    importFrom: null,
+                    importTo: null
+                }
+            ]
+        });
+    }
+    /**
+     * Migrate state management solution
+     */
+    async migrateStateManagement(options) {
+        const { projectPath, from, to, files, dryRun = true, preserveLogic = true } = options;
+        const result = {
+            success: true,
+            filesModified: [],
+            warnings: [],
+            suggestions: []
+        };
+        // Get migration pattern
+        const patternKey = `${from}_to_${to}`;
+        const migrationPattern = this.migrationPatterns.get(patternKey);
+        if (!migrationPattern) {
+            result.success = false;
+            result.warnings.push(`Migration from ${from} to ${to} is not directly supported`);
+            result.suggestions.push(`Consider migrating through an intermediate step`);
+            return result;
+        }
+        // Find files to migrate
+        const filesToMigrate = files || this.findStateManagedFiles(projectPath, from);
+        for (const filePath of filesToMigrate) {
+            try {
+                const fullPath = path.join(projectPath, filePath);
+                if (!fs.existsSync(fullPath)) {
+                    result.warnings.push(`File not found: ${filePath}`);
+                    continue;
+                }
+                const originalCode = fs.readFileSync(fullPath, 'utf-8');
+                const { modifiedCode, changes } = this.applyMigrationPattern(originalCode, migrationPattern, preserveLogic);
+                if (changes.length > 0) {
+                    const modification = {
+                        filePath,
+                        originalCode,
+                        modifiedCode,
+                        changes
+                    };
+                    result.filesModified.push(modification);
+                    if (!dryRun) {
+                        fs.writeFileSync(fullPath, modifiedCode);
+                    }
+                }
+            }
+            catch (error) {
+                result.warnings.push(`Error processing ${filePath}: ${error}`);
+            }
+        }
+        // Generate rollback plan
+        result.rollbackPlan = this.generateRollbackPlan(result.filesModified);
+        // Add suggestions
+        result.suggestions = this.generateMigrationSuggestions(from, to, result.filesModified);
+        return result;
+    }
+    /**
+     * Migrate to Dart 3 features
+     */
+    async migrateDartVersion(options) {
+        const { projectPath, features, minSdkVersion = '3.0.0', dryRun = true } = options;
+        const result = {
+            success: true,
+            filesModified: [],
+            warnings: [],
+            suggestions: []
+        };
+        // Find Dart files
+        const dartFiles = this.findDartFiles(projectPath);
+        for (const filePath of dartFiles) {
+            try {
+                const fullPath = path.join(projectPath, filePath);
+                const originalCode = fs.readFileSync(fullPath, 'utf-8');
+                let modifiedCode = originalCode;
+                const changes = [];
+                for (const feature of features) {
+                    const featureChanges = this.applyDartFeature(modifiedCode, feature);
+                    modifiedCode = featureChanges.code;
+                    changes.push(...featureChanges.changes);
+                }
+                if (changes.length > 0) {
+                    const modification = {
+                        filePath,
+                        originalCode,
+                        modifiedCode,
+                        changes
+                    };
+                    result.filesModified.push(modification);
+                    if (!dryRun) {
+                        fs.writeFileSync(fullPath, modifiedCode);
+                    }
+                }
+            }
+            catch (error) {
+                result.warnings.push(`Error processing ${filePath}: ${error}`);
+            }
+        }
+        // Update pubspec.yaml SDK constraint
+        if (!dryRun) {
+            this.updateSdkConstraint(projectPath, minSdkVersion);
+        }
+        result.suggestions = [
+            `Update pubspec.yaml SDK constraint to ^${minSdkVersion}`,
+            'Run `dart analyze` after migration to check for issues',
+            'Run full test suite to verify behavior is preserved'
+        ];
+        return result;
+    }
+    /**
+     * Analyze codebase for migration opportunities
+     */
+    async analyzeMigration(options) {
+        const { projectPath, includeStateManagement = true, includeDartFeatures = true } = options;
+        const analysis = {
+            stateManagement: {
+                currentSolutions: [],
+                migrationOpportunities: []
+            },
+            dartFeatures: {
+                currentSdkVersion: '',
+                availableUpgrades: []
+            },
+            recommendations: [],
+            effort: {
+                stateManagement: 0,
+                dartFeatures: 0,
+                total: 0,
+                breakdown: []
+            }
+        };
+        // Analyze state management
+        if (includeStateManagement) {
+            analysis.stateManagement = this.analyzeStateManagement(projectPath);
+        }
+        // Analyze Dart features
+        if (includeDartFeatures) {
+            analysis.dartFeatures = this.analyzeDartFeatures(projectPath);
+        }
+        // Generate recommendations
+        analysis.recommendations = this.generateRecommendations(analysis);
+        // Estimate effort
+        analysis.effort = this.estimateEffort(analysis);
+        return analysis;
+    }
+    /**
+     * Generate comprehensive migration plan
+     */
+    async generateMigrationPlan(projectPath, migrations) {
+        const analysis = await this.analyzeMigration({ projectPath });
+        const phases = [];
+        let totalFiles = 0;
+        let estimatedEffort = 0;
+        // Phase 1: Preparation
+        phases.push({
+            name: 'Preparation',
+            order: 1,
+            tasks: [
+                {
+                    description: 'Create backup of current codebase',
+                    files: [],
+                    automated: false,
+                    effort: 0.5
+                },
+                {
+                    description: 'Set up migration branch in version control',
+                    files: [],
+                    automated: false,
+                    effort: 0.25
+                },
+                {
+                    description: 'Review and document current state',
+                    files: [],
+                    automated: false,
+                    effort: 1
+                }
+            ],
+            dependencies: []
+        });
+        // Phase 2: Dependency updates
+        phases.push({
+            name: 'Dependency Updates',
+            order: 2,
+            tasks: [
+                {
+                    description: 'Update pubspec.yaml with new dependencies',
+                    files: ['pubspec.yaml'],
+                    automated: true,
+                    effort: 0.5
+                },
+                {
+                    description: 'Run flutter pub get',
+                    files: [],
+                    automated: true,
+                    effort: 0.1
+                }
+            ],
+            dependencies: ['Preparation']
+        });
+        // Phase 3: Core migrations
+        for (const migration of migrations) {
+            if (migration.type === 'state_management' && migration.from && migration.to) {
+                const files = this.findStateManagedFiles(projectPath, migration.from);
+                totalFiles += files.length;
+                phases.push({
+                    name: `State Migration: ${migration.from} → ${migration.to}`,
+                    order: phases.length + 1,
+                    tasks: [
+                        {
+                            description: `Convert ${migration.from} providers to ${migration.to}`,
+                            files: files,
+                            automated: true,
+                            effort: files.length * 0.5
+                        },
+                        {
+                            description: 'Update widget consumers',
+                            files: files,
+                            automated: true,
+                            effort: files.length * 0.25
+                        },
+                        {
+                            description: 'Verify and fix compilation errors',
+                            files: [],
+                            automated: false,
+                            effort: files.length * 0.1
+                        }
+                    ],
+                    dependencies: ['Dependency Updates']
+                });
+                estimatedEffort += files.length * 0.85;
+            }
+            if (migration.type === 'dart_version') {
+                const dartFiles = this.findDartFiles(projectPath);
+                totalFiles += dartFiles.length;
+                phases.push({
+                    name: 'Dart 3 Migration',
+                    order: phases.length + 1,
+                    tasks: [
+                        {
+                            description: 'Apply super parameters',
+                            files: dartFiles,
+                            automated: true,
+                            effort: dartFiles.length * 0.1
+                        },
+                        {
+                            description: 'Convert to records where applicable',
+                            files: dartFiles,
+                            automated: true,
+                            effort: dartFiles.length * 0.2
+                        },
+                        {
+                            description: 'Update switch statements to expressions',
+                            files: dartFiles,
+                            automated: true,
+                            effort: dartFiles.length * 0.15
+                        }
+                    ],
+                    dependencies: ['Dependency Updates']
+                });
+                estimatedEffort += dartFiles.length * 0.45;
+            }
+        }
+        // Phase 4: Testing
+        phases.push({
+            name: 'Testing & Verification',
+            order: phases.length + 1,
+            tasks: [
+                {
+                    description: 'Run static analysis (dart analyze)',
+                    files: [],
+                    automated: true,
+                    effort: 0.25
+                },
+                {
+                    description: 'Run unit tests',
+                    files: [],
+                    automated: true,
+                    effort: 0.5
+                },
+                {
+                    description: 'Run widget tests',
+                    files: [],
+                    automated: true,
+                    effort: 0.5
+                },
+                {
+                    description: 'Run integration tests',
+                    files: [],
+                    automated: true,
+                    effort: 1
+                },
+                {
+                    description: 'Manual testing of critical flows',
+                    files: [],
+                    automated: false,
+                    effort: 2
+                }
+            ],
+            dependencies: migrations.map((_, i) => phases[i + 2]?.name).filter(Boolean)
+        });
+        // Phase 5: Cleanup
+        phases.push({
+            name: 'Cleanup & Documentation',
+            order: phases.length + 1,
+            tasks: [
+                {
+                    description: 'Remove old dependencies from pubspec.yaml',
+                    files: ['pubspec.yaml'],
+                    automated: true,
+                    effort: 0.25
+                },
+                {
+                    description: 'Update documentation',
+                    files: [],
+                    automated: false,
+                    effort: 1
+                },
+                {
+                    description: 'Update README with new architecture',
+                    files: ['README.md'],
+                    automated: false,
+                    effort: 0.5
+                }
+            ],
+            dependencies: ['Testing & Verification']
+        });
+        // Calculate total effort
+        for (const phase of phases) {
+            for (const task of phase.tasks) {
+                estimatedEffort += task.effort;
+            }
+        }
+        return {
+            name: 'FlutterAI Migration Plan',
+            phases,
+            totalFiles,
+            estimatedEffort,
+            rollbackStrategy: `
+1. Keep migration branch separate until fully tested
+2. Maintain original code in backup branch
+3. Use feature flags for gradual rollout if applicable
+4. Document all changes for easy revert
+      `.trim(),
+            testingStrategy: `
+1. Run full test suite after each phase
+2. Add new tests for migrated code
+3. Perform regression testing on critical paths
+4. Conduct performance benchmarking before/after
+      `.trim()
+        };
+    }
+    // ============================================================================
+    // Private Helper Methods
+    // ============================================================================
+    findStateManagedFiles(projectPath, stateType) {
+        const files = [];
+        const patterns = {
+            provider: [/ChangeNotifierProvider/, /Provider\.of/, /context\.watch/, /context\.read/],
+            riverpod: [/ConsumerWidget/, /StateNotifierProvider/, /ref\.watch/, /ref\.read/],
+            bloc: [/BlocProvider/, /BlocBuilder/, /BlocListener/, /extends Bloc/],
+            cubit: [/extends Cubit/, /BlocProvider/, /BlocBuilder/],
+            getx: [/GetxController/, /Get\.find/, /Obx\(/, /\.obs/],
+            setState: [/setState\(/, /extends StatefulWidget/],
+            mobx: [/@observable/, /@action/, /Observer\(/]
+        };
+        const targetPatterns = patterns[stateType];
+        const dartFiles = this.findDartFiles(projectPath);
+        for (const filePath of dartFiles) {
+            try {
+                const fullPath = path.join(projectPath, filePath);
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                for (const pattern of targetPatterns) {
+                    if (pattern.test(content)) {
+                        files.push(filePath);
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        return files;
+    }
+    findDartFiles(projectPath) {
+        const files = [];
+        const walkDir = (dir, relativePath = '') => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relPath = path.join(relativePath, entry.name);
+                    if (entry.isDirectory()) {
+                        // Skip common non-source directories
+                        if (!['build', '.dart_tool', '.git', 'node_modules', '.idea'].includes(entry.name)) {
+                            walkDir(fullPath, relPath);
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.endsWith('.dart')) {
+                        files.push(relPath);
+                    }
+                }
+            }
+            catch {
+                // Skip directories that can't be read
+            }
+        };
+        walkDir(path.join(projectPath, 'lib'), 'lib');
+        walkDir(path.join(projectPath, 'test'), 'test');
+        return files;
+    }
+    applyMigrationPattern(code, pattern, preserveLogic) {
+        let modifiedCode = code;
+        const changes = [];
+        // Apply import changes
+        for (const p of pattern.patterns) {
+            if (p.importFrom && p.importTo && code.includes(p.importFrom)) {
+                modifiedCode = modifiedCode.replace(p.importFrom, p.importTo);
+                changes.push({
+                    line: this.findLineNumber(code, p.importFrom),
+                    type: 'modify',
+                    description: 'Updated import statement',
+                    before: p.importFrom,
+                    after: p.importTo
+                });
+            }
+        }
+        // Apply code pattern changes
+        for (const p of pattern.patterns) {
+            const matches = modifiedCode.match(p.from);
+            if (matches) {
+                for (const match of matches) {
+                    const before = match;
+                    const after = match.replace(p.from, p.to);
+                    if (before !== after) {
+                        modifiedCode = modifiedCode.replace(before, after);
+                        changes.push({
+                            line: this.findLineNumber(code, before),
+                            type: 'modify',
+                            description: `Converted ${pattern.name} pattern`,
+                            before,
+                            after
+                        });
+                    }
+                }
+            }
+        }
+        return { modifiedCode, changes };
+    }
+    applyDartFeature(code, feature) {
+        let modifiedCode = code;
+        const changes = [];
+        switch (feature) {
+            case 'super_parameters':
+                // Convert: Widget({Key? key}) : super(key: key)
+                // To: Widget({super.key})
+                const superParamRegex = /(\w+)\(\{(?:required\s+)?(\w+)\?\s+(\w+)\}\)\s*:\s*super\(\3:\s*\3\)/g;
+                modifiedCode = modifiedCode.replace(superParamRegex, (match, className, type, name) => {
+                    changes.push({
+                        line: this.findLineNumber(code, match),
+                        type: 'modify',
+                        description: `Converted to super parameter: ${name}`,
+                        before: match,
+                        after: `${className}({super.${name}})`
+                    });
+                    return `${className}({super.${name}})`;
+                });
+                break;
+            case 'records':
+                // Convert simple tuple-like classes to records
+                // This is a simplified example - real implementation would be more complex
+                const tupleClassRegex = /class\s+(\w+Tuple)\s*\{\s*final\s+(\w+)\s+(\w+);\s*final\s+(\w+)\s+(\w+);\s*const\s+\1\(this\.\3,\s*this\.\5\);\s*\}/g;
+                modifiedCode = modifiedCode.replace(tupleClassRegex, (match, name, type1, field1, type2, field2) => {
+                    const replacement = `typedef ${name} = (${type1} ${field1}, ${type2} ${field2});`;
+                    changes.push({
+                        line: this.findLineNumber(code, match),
+                        type: 'modify',
+                        description: `Converted class to record: ${name}`,
+                        before: match,
+                        after: replacement
+                    });
+                    return replacement;
+                });
+                break;
+            case 'switch_expressions':
+                // Convert simple switch statements to expressions
+                const simpleSwitchRegex = /switch\s*\((\w+)\)\s*\{\s*case\s+(\w+):\s*return\s+([^;]+);\s*case\s+(\w+):\s*return\s+([^;]+);\s*default:\s*return\s+([^;]+);\s*\}/g;
+                modifiedCode = modifiedCode.replace(simpleSwitchRegex, (match, variable, case1, result1, case2, result2, defaultResult) => {
+                    const replacement = `switch (${variable}) { ${case1} => ${result1}, ${case2} => ${result2}, _ => ${defaultResult} }`;
+                    changes.push({
+                        line: this.findLineNumber(code, match),
+                        type: 'modify',
+                        description: 'Converted switch statement to expression',
+                        before: match,
+                        after: replacement
+                    });
+                    return replacement;
+                });
+                break;
+            case 'sealed_classes':
+                // Add sealed modifier to abstract classes with pattern matching
+                // This requires more sophisticated analysis in practice
+                break;
+            case 'class_modifiers':
+                // Add interface, base, final, mixin modifiers where appropriate
+                break;
+            case 'patterns':
+                // Convert if-else type checks to pattern matching
+                break;
+        }
+        return { code: modifiedCode, changes };
+    }
+    analyzeStateManagement(projectPath) {
+        const solutions = [];
+        const opportunities = [];
+        const stateTypes = ['provider', 'riverpod', 'bloc', 'cubit', 'getx', 'setState', 'mobx'];
+        for (const stateType of stateTypes) {
+            const files = this.findStateManagedFiles(projectPath, stateType);
+            if (files.length > 0) {
+                solutions.push({
+                    type: stateType,
+                    fileCount: files.length,
+                    files,
+                    patterns: this.identifyPatterns(projectPath, files, stateType)
+                });
+            }
+        }
+        // Generate migration opportunities
+        if (solutions.some(s => s.type === 'provider')) {
+            opportunities.push({
+                from: 'provider',
+                to: 'riverpod',
+                benefit: 'Better type safety, compile-time error checking, and testing support',
+                complexity: 'medium',
+                affectedFiles: solutions.find(s => s.type === 'provider')?.files || []
+            });
+        }
+        if (solutions.some(s => s.type === 'setState')) {
+            opportunities.push({
+                from: 'setState',
+                to: 'riverpod',
+                benefit: 'Better state management, easier testing, separation of concerns',
+                complexity: 'high',
+                affectedFiles: solutions.find(s => s.type === 'setState')?.files || []
+            });
+        }
+        if (solutions.some(s => s.type === 'bloc')) {
+            opportunities.push({
+                from: 'bloc',
+                to: 'cubit',
+                benefit: 'Simpler state management without events, less boilerplate',
+                complexity: 'low',
+                affectedFiles: solutions.find(s => s.type === 'bloc')?.files || []
+            });
+        }
+        if (solutions.some(s => s.type === 'getx')) {
+            opportunities.push({
+                from: 'getx',
+                to: 'riverpod',
+                benefit: 'Better architecture, compile-time safety, no magic',
+                complexity: 'high',
+                affectedFiles: solutions.find(s => s.type === 'getx')?.files || []
+            });
+        }
+        return {
+            currentSolutions: solutions,
+            migrationOpportunities: opportunities
+        };
+    }
+    analyzeDartFeatures(projectPath) {
+        const upgrades = [];
+        // Check pubspec.yaml for SDK version
+        const pubspecPath = path.join(projectPath, 'pubspec.yaml');
+        let currentSdkVersion = '2.17.0';
+        try {
+            const pubspec = fs.readFileSync(pubspecPath, 'utf-8');
+            const sdkMatch = pubspec.match(/sdk:\s*['"]?>=?\s*([\d.]+)/);
+            if (sdkMatch) {
+                currentSdkVersion = sdkMatch[1];
+            }
+        }
+        catch {
+            // Use default
+        }
+        const dartFiles = this.findDartFiles(projectPath);
+        // Check for super parameter opportunities
+        let superParamCount = 0;
+        const superParamExamples = [];
+        for (const filePath of dartFiles.slice(0, 20)) {
+            try {
+                const fullPath = path.join(projectPath, filePath);
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                // Look for old-style super calls
+                const matches = content.matchAll(/(\w+)\(\{[^}]*\}\)\s*:\s*super\([^)]+\)/g);
+                for (const match of matches) {
+                    superParamCount++;
+                    if (superParamExamples.length < 3) {
+                        superParamExamples.push({
+                            before: match[0],
+                            after: `${match[1]}({super.key})`,
+                            file: filePath,
+                            line: this.findLineNumber(content, match[0])
+                        });
+                    }
+                }
+            }
+            catch {
+                // Skip
+            }
+        }
+        if (superParamCount > 0) {
+            upgrades.push({
+                feature: 'super_parameters',
+                description: 'Use super parameters for cleaner constructor syntax',
+                affectedFiles: superParamCount,
+                examples: superParamExamples
+            });
+        }
+        // Add other feature upgrades...
+        upgrades.push({
+            feature: 'records',
+            description: 'Use records for simple data aggregation instead of classes',
+            affectedFiles: 0,
+            examples: []
+        });
+        upgrades.push({
+            feature: 'switch_expressions',
+            description: 'Convert switch statements to expressions for cleaner code',
+            affectedFiles: 0,
+            examples: []
+        });
+        return {
+            currentSdkVersion,
+            availableUpgrades: upgrades
+        };
+    }
+    identifyPatterns(projectPath, files, stateType) {
+        const patterns = new Set();
+        // Identify common patterns based on state management type
+        const patternMatchers = {
+            provider: [
+                /MultiProvider/,
+                /ChangeNotifierProvider/,
+                /ProxyProvider/,
+                /Consumer/
+            ],
+            riverpod: [
+                /StateNotifierProvider/,
+                /FutureProvider/,
+                /StreamProvider/,
+                /StateProvider/
+            ],
+            bloc: [
+                /MultiBlocProvider/,
+                /BlocBuilder/,
+                /BlocListener/,
+                /BlocConsumer/
+            ],
+            cubit: [
+                /BlocBuilder.*Cubit/,
+                /extends Cubit/
+            ],
+            getx: [
+                /GetBuilder/,
+                /GetX/,
+                /Obx/,
+                /Get\.put/
+            ],
+            setState: [
+                /initState/,
+                /dispose/,
+                /didUpdateWidget/
+            ],
+            mobx: [
+                /@observable/,
+                /@computed/,
+                /@action/
+            ]
+        };
+        for (const filePath of files.slice(0, 10)) {
+            try {
+                const fullPath = path.join(projectPath, filePath);
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                for (const matcher of patternMatchers[stateType]) {
+                    if (matcher.test(content)) {
+                        patterns.add(matcher.source);
+                    }
+                }
+            }
+            catch {
+                // Skip
+            }
+        }
+        return Array.from(patterns);
+    }
+    generateRecommendations(analysis) {
+        const recommendations = [];
+        // State management recommendations
+        for (const opportunity of analysis.stateManagement.migrationOpportunities) {
+            recommendations.push({
+                priority: opportunity.complexity === 'low' ? 'high' : opportunity.complexity === 'medium' ? 'medium' : 'low',
+                type: 'state_management',
+                description: `Migrate from ${opportunity.from} to ${opportunity.to}`,
+                benefit: opportunity.benefit
+            });
+        }
+        // Dart feature recommendations
+        for (const upgrade of analysis.dartFeatures.availableUpgrades) {
+            if (upgrade.affectedFiles > 0) {
+                recommendations.push({
+                    priority: 'medium',
+                    type: 'dart_feature',
+                    description: `Adopt ${upgrade.feature.replace(/_/g, ' ')}`,
+                    benefit: upgrade.description
+                });
+            }
+        }
+        // Sort by priority
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        recommendations.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+        return recommendations;
+    }
+    estimateEffort(analysis) {
+        let stateManagement = 0;
+        let dartFeatures = 0;
+        const breakdown = [];
+        // State management effort
+        for (const solution of analysis.stateManagement.currentSolutions) {
+            const hours = solution.fileCount * 0.5;
+            stateManagement += hours;
+            breakdown.push(`${solution.type} migration: ${hours.toFixed(1)} hours (${solution.fileCount} files)`);
+        }
+        // Dart features effort
+        for (const upgrade of analysis.dartFeatures.availableUpgrades) {
+            const hours = upgrade.affectedFiles * 0.1;
+            dartFeatures += hours;
+            if (upgrade.affectedFiles > 0) {
+                breakdown.push(`${upgrade.feature}: ${hours.toFixed(1)} hours (${upgrade.affectedFiles} locations)`);
+            }
+        }
+        return {
+            stateManagement,
+            dartFeatures,
+            total: stateManagement + dartFeatures + 5, // Add 5 hours for testing and documentation
+            breakdown
+        };
+    }
+    generateRollbackPlan(modifications) {
+        const lines = [
+            '# Rollback Plan',
+            '',
+            '## Automated Rollback',
+            '',
+            '```bash',
+            'git checkout -- <modified-files>',
+            '```',
+            '',
+            '## Manual Rollback',
+            '',
+            'The following files were modified:',
+            ''
+        ];
+        for (const mod of modifications) {
+            lines.push(`- ${mod.filePath} (${mod.changes.length} changes)`);
+        }
+        lines.push('');
+        lines.push('Original files are preserved in backup. Restore with:');
+        lines.push('```bash');
+        lines.push('cp backup/<file> <destination>');
+        lines.push('```');
+        return lines.join('\n');
+    }
+    generateMigrationSuggestions(from, to, modifications) {
+        const suggestions = [];
+        suggestions.push(`Review all ${modifications.length} modified files for logic preservation`);
+        suggestions.push('Run static analysis to check for type errors');
+        suggestions.push('Update tests to use new state management patterns');
+        if (to === 'riverpod') {
+            suggestions.push('Consider using code generation with riverpod_generator');
+            suggestions.push('Add ProviderScope at the root of your app');
+        }
+        if (to === 'cubit') {
+            suggestions.push('You can remove event classes that are no longer needed');
+            suggestions.push('Consider using freezed for state classes');
+        }
+        return suggestions;
+    }
+    updateSdkConstraint(projectPath, minVersion) {
+        const pubspecPath = path.join(projectPath, 'pubspec.yaml');
+        try {
+            let content = fs.readFileSync(pubspecPath, 'utf-8');
+            content = content.replace(/sdk:\s*['"]?>=?\s*[\d.]+/, `sdk: '>=${minVersion}'`);
+            fs.writeFileSync(pubspecPath, content);
+        }
+        catch {
+            // Log warning
+        }
+    }
+    findLineNumber(code, search) {
+        const index = code.indexOf(search);
+        if (index === -1)
+            return 0;
+        return code.substring(0, index).split('\n').length;
+    }
+}
+// ============================================================================
+// Export
+// ============================================================================
+export const migrationEngine = new MigrationEngine();
+//# sourceMappingURL=index.js.map