dartmind 17.0.0

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

@@ -0,0 +1,692 @@
+/**
+ * FlutterAI V16 - Flutter Refactor MCP Server
+ * Issues 59.1, 59.2, 60.1: Refactor Server Infrastructure
+ *
+ * Provides autonomous code refactoring capabilities:
+ * - Widget extraction
+ * - Symbol renaming
+ * - Code optimization
+ * - Import organization
+ *
+ * @module flutter-refactor
+ * @version 16.0.0
+ */
+// ============================================================================
+// REFACTOR ENGINE
+// ============================================================================
+export class DartRefactorEngine {
+    /**
+     * Extract selected code into a new widget
+     */
+    async extractWidget(options) {
+        const { code, selectionStart, selectionEnd, newWidgetName, makeStateful = false, } = options;
+        const changes = [];
+        const warnings = [];
+        // Validate selection
+        const selectedCode = code.substring(selectionStart, selectionEnd).trim();
+        if (!selectedCode) {
+            return {
+                success: false,
+                originalCode: code,
+                refactoredCode: code,
+                changes: [],
+                warnings: ['No code selected for extraction'],
+            };
+        }
+        // Analyze selected code for dependencies
+        const dependencies = this.analyzeDependencies(selectedCode, code);
+        // Check if selection is valid widget subtree
+        if (!this.isValidWidgetSubtree(selectedCode)) {
+            warnings.push('Selection may not be a complete widget subtree');
+        }
+        // Generate new widget class
+        const newWidget = this.generateWidgetClass({
+            name: newWidgetName,
+            buildContent: selectedCode,
+            dependencies,
+            isStateful: makeStateful,
+        });
+        // Generate widget usage (replacement in original location)
+        const widgetUsage = this.generateWidgetUsage(newWidgetName, dependencies);
+        // Build refactored code
+        const beforeSelection = code.substring(0, selectionStart);
+        const afterSelection = code.substring(selectionEnd);
+        // Find insertion point for new class (end of file)
+        const insertionPoint = this.findClassInsertionPoint(code);
+        let refactoredCode;
+        if (insertionPoint > selectionEnd) {
+            refactoredCode =
+                beforeSelection +
+                    widgetUsage +
+                    code.substring(selectionEnd, insertionPoint) +
+                    '\n\n' +
+                    newWidget +
+                    code.substring(insertionPoint);
+        }
+        else {
+            refactoredCode =
+                code.substring(0, insertionPoint) +
+                    '\n\n' +
+                    newWidget +
+                    code.substring(insertionPoint, selectionStart) +
+                    widgetUsage +
+                    afterSelection;
+        }
+        changes.push({
+            type: 'extract',
+            location: {
+                file: 'current',
+                startLine: this.getLineNumber(code, selectionStart),
+                endLine: this.getLineNumber(code, selectionEnd),
+            },
+            description: `Extracted widget to ${newWidgetName}`,
+            before: selectedCode,
+            after: widgetUsage,
+        });
+        changes.push({
+            type: 'insert',
+            location: {
+                file: 'current',
+                startLine: this.getLineNumber(code, insertionPoint),
+                endLine: this.getLineNumber(code, insertionPoint),
+            },
+            description: `Created new widget class ${newWidgetName}`,
+            before: '',
+            after: newWidget,
+        });
+        return {
+            success: true,
+            originalCode: code,
+            refactoredCode,
+            changes,
+            warnings,
+        };
+    }
+    /**
+     * Rename symbol in code
+     */
+    async renameSymbol(options) {
+        const { code, oldName, newName, symbolType = 'all' } = options;
+        const changes = [];
+        const warnings = [];
+        // Validate names
+        if (!this.isValidDartIdentifier(newName)) {
+            return {
+                success: false,
+                originalCode: code,
+                refactoredCode: code,
+                changes: [],
+                warnings: [`'${newName}' is not a valid Dart identifier`],
+            };
+        }
+        // Build rename patterns based on symbol type
+        const patterns = this.buildRenamePatterns(oldName, symbolType);
+        let refactoredCode = code;
+        let hasChanges = false;
+        for (const pattern of patterns) {
+            if (pattern.test(refactoredCode)) {
+                refactoredCode = refactoredCode.replace(pattern, (match) => match.replace(new RegExp(`\\b${oldName}\\b`, 'g'), newName));
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            changes.push({
+                type: 'rename',
+                location: { file: 'current', startLine: 0, endLine: 0 },
+                description: `Renamed '${oldName}' to '${newName}'`,
+                before: oldName,
+                after: newName,
+            });
+        }
+        else {
+            warnings.push(`No occurrences of '${oldName}' found`);
+        }
+        return {
+            success: hasChanges,
+            originalCode: code,
+            refactoredCode,
+            changes,
+            warnings,
+        };
+    }
+    /**
+     * Organize imports in a Dart file
+     */
+    async organizeImports(options) {
+        const { code, removeUnused = true, sortAlphabetically = true, groupByType = true, } = options;
+        const changes = [];
+        const warnings = [];
+        // Extract all imports
+        const imports = this.extractImports(code);
+        if (imports.length === 0) {
+            return {
+                success: true,
+                originalCode: code,
+                refactoredCode: code,
+                changes: [],
+                warnings: ['No imports found'],
+            };
+        }
+        // Remove code section with imports
+        const importPattern = /^import\s+['"][^'"]+['"]\s*;?\s*$/gm;
+        const codeWithoutImports = code.replace(importPattern, '').trim();
+        // Filter unused imports if requested
+        let filteredImports = imports;
+        if (removeUnused) {
+            filteredImports = imports.filter((imp) => {
+                const importedName = this.getImportedName(imp);
+                return importedName ? codeWithoutImports.includes(importedName) : true;
+            });
+            const removed = imports.length - filteredImports.length;
+            if (removed > 0) {
+                warnings.push(`Removed ${removed} unused import(s)`);
+            }
+        }
+        // Sort imports
+        if (sortAlphabetically) {
+            filteredImports.sort((a, b) => a.localeCompare(b));
+        }
+        // Group imports
+        let organizedImports;
+        if (groupByType) {
+            const groups = this.groupImports(filteredImports);
+            organizedImports = [
+                groups.dart.join('\n'),
+                groups.flutter.join('\n'),
+                groups.package.join('\n'),
+                groups.relative.join('\n'),
+            ]
+                .filter((g) => g.length > 0)
+                .join('\n\n');
+        }
+        else {
+            organizedImports = filteredImports.join('\n');
+        }
+        const refactoredCode = organizedImports + '\n\n' + codeWithoutImports;
+        changes.push({
+            type: 'move',
+            location: { file: 'current', startLine: 1, endLine: imports.length },
+            description: 'Organized imports',
+            before: imports.join('\n'),
+            after: organizedImports,
+        });
+        return {
+            success: true,
+            originalCode: code,
+            refactoredCode,
+            changes,
+            warnings,
+        };
+    }
+    /**
+     * Apply code optimizations
+     */
+    async optimizeCode(options) {
+        const { code, optimizations } = options;
+        let optimizedCode = code;
+        const changes = [];
+        const warnings = [];
+        for (const optimization of optimizations) {
+            const result = this.applyOptimization(optimizedCode, optimization);
+            if (result.changed) {
+                optimizedCode = result.code;
+                changes.push(...result.changes);
+            }
+        }
+        return {
+            success: changes.length > 0,
+            originalCode: code,
+            refactoredCode: optimizedCode,
+            changes,
+            warnings,
+        };
+    }
+    /**
+     * Convert StatelessWidget to StatefulWidget
+     */
+    async convertToStateful(code, widgetName) {
+        const changes = [];
+        const warnings = [];
+        if (!code.includes(`class ${widgetName} extends StatelessWidget`)) {
+            return {
+                success: false,
+                originalCode: code,
+                refactoredCode: code,
+                changes: [],
+                warnings: [`${widgetName} is not a StatelessWidget`],
+            };
+        }
+        let refactoredCode = code.replace(`class ${widgetName} extends StatelessWidget`, `class ${widgetName} extends StatefulWidget`);
+        // Find the build method and wrap it
+        const buildMethodPattern = /(@override\s+Widget build\(BuildContext context\)\s*\{)/;
+        refactoredCode = refactoredCode.replace(buildMethodPattern, `@override
+  State<${widgetName}> createState() => _${widgetName}State();
+}
+
+class _${widgetName}State extends State<${widgetName}> {
+  $1`);
+        changes.push({
+            type: 'rename',
+            location: { file: 'current', startLine: 0, endLine: 0 },
+            description: `Converted ${widgetName} to StatefulWidget`,
+            before: 'StatelessWidget',
+            after: 'StatefulWidget',
+        });
+        return {
+            success: true,
+            originalCode: code,
+            refactoredCode,
+            changes,
+            warnings,
+        };
+    }
+    /**
+     * Convert StatefulWidget to StatelessWidget
+     */
+    async convertToStateless(code, widgetName) {
+        const changes = [];
+        const warnings = [];
+        // Check if state is actually used
+        if (code.includes('setState(')) {
+            return {
+                success: false,
+                originalCode: code,
+                refactoredCode: code,
+                changes: [],
+                warnings: ['Cannot convert: widget uses setState()'],
+            };
+        }
+        if (!code.includes(`class ${widgetName} extends StatefulWidget`)) {
+            return {
+                success: false,
+                originalCode: code,
+                refactoredCode: code,
+                changes: [],
+                warnings: [`${widgetName} is not a StatefulWidget`],
+            };
+        }
+        // Convert class declaration
+        let refactoredCode = code.replace(`class ${widgetName} extends StatefulWidget`, `class ${widgetName} extends StatelessWidget`);
+        // Remove createState and State class
+        refactoredCode = refactoredCode.replace(/@override\s+State<\w+>\s+createState\(\)\s*=>\s*_\w+State\(\);\s*}\s*class\s+_\w+State\s+extends\s+State<\w+>\s*\{/, '');
+        // Replace widget. references
+        refactoredCode = refactoredCode.replace(/widget\./g, '');
+        changes.push({
+            type: 'rename',
+            location: { file: 'current', startLine: 0, endLine: 0 },
+            description: `Converted ${widgetName} to StatelessWidget`,
+            before: 'StatefulWidget',
+            after: 'StatelessWidget',
+        });
+        return {
+            success: true,
+            originalCode: code,
+            refactoredCode,
+            changes,
+            warnings,
+        };
+    }
+    // ============================================================================
+    // HELPER METHODS
+    // ============================================================================
+    analyzeDependencies(selectedCode, fullCode) {
+        const dependencies = [];
+        // Find variables/parameters used in selection but defined outside
+        const variablePattern = /\b([a-z_][a-zA-Z0-9_]*)\b/g;
+        const matches = selectedCode.matchAll(variablePattern);
+        for (const match of matches) {
+            const varName = match[1];
+            // Check if defined outside selection
+            const defPattern = new RegExp(`(final|var|const|int|double|String|bool|List|Map|Set)\\s+${varName}\\b`);
+            if (defPattern.test(fullCode) && !defPattern.test(selectedCode)) {
+                if (!dependencies.includes(varName)) {
+                    dependencies.push(varName);
+                }
+            }
+        }
+        return dependencies;
+    }
+    isValidWidgetSubtree(code) {
+        const stack = [];
+        const pairs = {
+            '(': ')',
+            '[': ']',
+            '{': '}',
+            '<': '>',
+        };
+        for (const char of code) {
+            if (pairs[char]) {
+                stack.push(pairs[char]);
+            }
+            else if (Object.values(pairs).includes(char)) {
+                if (stack.pop() !== char)
+                    return false;
+            }
+        }
+        return stack.length === 0;
+    }
+    generateWidgetClass(options) {
+        const { name, buildContent, dependencies, isStateful } = options;
+        const params = dependencies.length > 0
+            ? dependencies.map((d) => `required this.${d}`).join(', ')
+            : '';
+        const fields = dependencies.length > 0
+            ? dependencies.map((d) => `  final dynamic ${d};`).join('\n')
+            : '';
+        if (isStateful) {
+            return `
+class ${name} extends StatefulWidget {
+${fields}
+
+  const ${name}({
+    super.key,
+    ${params}
+  });
+
+  @override
+  State<${name}> createState() => _${name}State();
+}
+
+class _${name}State extends State<${name}> {
+  @override
+  Widget build(BuildContext context) {
+    return ${buildContent};
+  }
+}`.trim();
+        }
+        else {
+            return `
+class ${name} extends StatelessWidget {
+${fields}
+
+  const ${name}({
+    super.key,
+    ${params}
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return ${buildContent};
+  }
+}`.trim();
+        }
+    }
+    generateWidgetUsage(name, dependencies) {
+        if (dependencies.length === 0) {
+            return `${name}()`;
+        }
+        const args = dependencies.map((d) => `${d}: ${d}`).join(', ');
+        return `${name}(${args})`;
+    }
+    findClassInsertionPoint(code) {
+        const classEndPattern = /^}\s*$/gm;
+        let lastMatch = null;
+        let match;
+        while ((match = classEndPattern.exec(code)) !== null) {
+            lastMatch = match;
+        }
+        return lastMatch ? lastMatch.index + lastMatch[0].length : code.length;
+    }
+    getLineNumber(code, position) {
+        return code.substring(0, position).split('\n').length;
+    }
+    isValidDartIdentifier(name) {
+        return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+    }
+    buildRenamePatterns(oldName, symbolType) {
+        const patterns = [];
+        const escaped = oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        if (symbolType === 'all' || symbolType === 'class') {
+            patterns.push(new RegExp(`\\bclass\\s+${escaped}\\b`, 'g'));
+            patterns.push(new RegExp(`\\b${escaped}\\s*\\(`, 'g'));
+            patterns.push(new RegExp(`<${escaped}>`, 'g'));
+            patterns.push(new RegExp(`extends\\s+${escaped}\\b`, 'g'));
+            patterns.push(new RegExp(`implements\\s+${escaped}\\b`, 'g'));
+        }
+        if (symbolType === 'all' || symbolType === 'method') {
+            patterns.push(new RegExp(`\\.${escaped}\\s*\\(`, 'g'));
+        }
+        if (symbolType === 'all' || symbolType === 'variable') {
+            patterns.push(new RegExp(`\\b${escaped}\\b`, 'g'));
+        }
+        return patterns;
+    }
+    extractImports(code) {
+        const imports = [];
+        const pattern = /^import\s+['"][^'"]+['"]\s*;?\s*$/gm;
+        let match;
+        while ((match = pattern.exec(code)) !== null) {
+            imports.push(match[0].trim());
+        }
+        return imports;
+    }
+    getImportedName(importStatement) {
+        const asMatch = importStatement.match(/as\s+(\w+)/);
+        if (asMatch)
+            return asMatch[1];
+        const pathMatch = importStatement.match(/['"]([^'"]+)['"]/);
+        if (pathMatch) {
+            const parts = pathMatch[1].split('/');
+            const filename = parts[parts.length - 1].replace('.dart', '');
+            return filename.replace(/_/g, '');
+        }
+        return null;
+    }
+    groupImports(imports) {
+        return {
+            dart: imports.filter((i) => i.includes("'dart:")),
+            flutter: imports.filter((i) => i.includes("'package:flutter")),
+            package: imports.filter((i) => i.includes("'package:") && !i.includes("'package:flutter")),
+            relative: imports.filter((i) => !i.includes("'dart:") && !i.includes("'package:")),
+        };
+    }
+    applyOptimization(code, optimization) {
+        const changes = [];
+        let modified = code;
+        let changed = false;
+        switch (optimization) {
+            case 'const_constructors': {
+                const pattern = /(\s)(new\s+)?([A-Z][a-zA-Z0-9_]*)\s*\(/g;
+                modified = code.replace(pattern, (match, space, _newKeyword, className) => {
+                    if (!match.includes('const ')) {
+                        changed = true;
+                        return `${space}const ${className}(`;
+                    }
+                    return match;
+                });
+                break;
+            }
+            case 'remove_redundant_this': {
+                const pattern = /this\.(\w+)(?!\s*=)/g;
+                modified = code.replace(pattern, (_match, prop) => {
+                    changed = true;
+                    return prop;
+                });
+                break;
+            }
+            case 'prefer_final': {
+                const pattern = /\bvar\s+(\w+)\s*=/g;
+                modified = code.replace(pattern, (match, varName) => {
+                    const reassignPattern = new RegExp(`\\b${varName}\\s*=`, 'g');
+                    const matches = code.match(reassignPattern);
+                    if (matches && matches.length === 1) {
+                        changed = true;
+                        return `final ${varName} =`;
+                    }
+                    return match;
+                });
+                break;
+            }
+            case 'use_super_parameters': {
+                const pattern = /(\w+)\s*:\s*super\.(\w+)/g;
+                modified = code.replace(pattern, (match, param, superParam) => {
+                    if (param === superParam) {
+                        changed = true;
+                        return `super.${param}`;
+                    }
+                    return match;
+                });
+                break;
+            }
+            case 'convert_to_expression_body': {
+                const pattern = /{\s*return\s+([^;]+);\s*}/g;
+                modified = code.replace(pattern, (match, expression) => {
+                    if (!expression.includes('\n')) {
+                        changed = true;
+                        return `=> ${expression}`;
+                    }
+                    return match;
+                });
+                break;
+            }
+            case 'remove_empty_constructors': {
+                const pattern = /\n\s*\w+\(\)\s*;\s*\n/g;
+                modified = code.replace(pattern, '\n');
+                if (modified !== code)
+                    changed = true;
+                break;
+            }
+        }
+        if (changed) {
+            changes.push({
+                type: 'rename',
+                location: { file: 'current', startLine: 0, endLine: 0 },
+                description: `Applied optimization: ${optimization}`,
+                before: '',
+                after: '',
+            });
+        }
+        return { code: modified, changed, changes };
+    }
+}
+// ============================================================================
+// TOOL DEFINITIONS
+// ============================================================================
+export const REFACTOR_TOOLS = [
+    {
+        name: 'extract_widget',
+        description: 'Extract selected code into a new Flutter widget class. Automatically handles dependencies and generates appropriate constructor parameters.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'The full source code of the file' },
+                selectionStart: {
+                    type: 'number',
+                    description: 'Character position where selection starts',
+                },
+                selectionEnd: {
+                    type: 'number',
+                    description: 'Character position where selection ends',
+                },
+                newWidgetName: {
+                    type: 'string',
+                    description: 'Name for the new widget class (PascalCase)',
+                },
+                makeStateful: {
+                    type: 'boolean',
+                    description: 'Whether to create a StatefulWidget',
+                    default: false,
+                },
+            },
+            required: ['code', 'selectionStart', 'selectionEnd', 'newWidgetName'],
+        },
+    },
+    {
+        name: 'rename_symbol',
+        description: 'Rename a symbol (class, method, variable) in code. Handles all references safely.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'The source code' },
+                oldName: { type: 'string', description: 'Current name of the symbol' },
+                newName: { type: 'string', description: 'New name for the symbol' },
+                symbolType: {
+                    type: 'string',
+                    enum: ['class', 'method', 'variable', 'all'],
+                    description: 'Type of symbol to rename',
+                    default: 'all',
+                },
+            },
+            required: ['code', 'oldName', 'newName'],
+        },
+    },
+    {
+        name: 'organize_imports',
+        description: 'Organize imports in a Dart file: remove unused, sort alphabetically, group by type.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'The source code to organize imports in' },
+                removeUnused: { type: 'boolean', description: 'Remove unused imports', default: true },
+                sortAlphabetically: {
+                    type: 'boolean',
+                    description: 'Sort imports alphabetically',
+                    default: true,
+                },
+                groupByType: {
+                    type: 'boolean',
+                    description: 'Group imports by type (dart:, package:, relative)',
+                    default: true,
+                },
+            },
+            required: ['code'],
+        },
+    },
+    {
+        name: 'optimize_code',
+        description: 'Apply code optimizations: const constructors, prefer final, expression bodies, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'The source code to optimize' },
+                optimizations: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: [
+                            'const_constructors',
+                            'remove_redundant_this',
+                            'prefer_final',
+                            'use_super_parameters',
+                            'convert_to_expression_body',
+                            'remove_empty_constructors',
+                        ],
+                    },
+                    description: 'List of optimizations to apply',
+                },
+            },
+            required: ['code', 'optimizations'],
+        },
+    },
+    {
+        name: 'convert_to_stateful',
+        description: 'Convert a StatelessWidget to StatefulWidget',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'The widget code to convert' },
+                widgetName: { type: 'string', description: 'Name of the widget to convert' },
+            },
+            required: ['code', 'widgetName'],
+        },
+    },
+    {
+        name: 'convert_to_stateless',
+        description: 'Convert a StatefulWidget to StatelessWidget (if no state is used)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'The widget code to convert' },
+                widgetName: { type: 'string', description: 'Name of the widget to convert' },
+            },
+            required: ['code', 'widgetName'],
+        },
+    },
+];
+// ============================================================================
+// FACTORY FUNCTION
+// ============================================================================
+export function createRefactorEngine() {
+    return new DartRefactorEngine();
+}
+//# sourceMappingURL=index.js.map