dartmind 17.0.0

package/dist/gates/ConstPromotionEngine.js

@@ -0,0 +1,792 @@
+/**
+ * FlutterAI v5.0 Gold Level - Const Promotion Engine
+ *
+ * SUPREME PROTOCOL: Transform PerformanceGate from "warning system" to "auto-fix engine"
+ *
+ * Architecture:
+ * 1. Identify const-eligible widgets via intelligent pattern matching
+ * 2. Stage fixes via AtomicWriter (shadow staging)
+ * 3. Verify via dart analyze
+ * 4. Auto-rollback on failure
+ *
+ * @author FlutterAI Team
+ * @version 5.0.0
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { glob } from 'glob';
+import { AtomicWriter } from './AtomicWriter.js';
+import { ShellExecutor } from '../shell/ShellExecutor.js';
+import { ShellCommandType, FixActionType } from '../core/types.js';
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+/**
+ * Widgets that are inherently const-eligible (no state, no context dependency)
+ */
+const CONST_ELIGIBLE_WIDGETS = [
+    // Basic display widgets
+    'Text',
+    'Icon',
+    'SizedBox',
+    'Spacer',
+    'Divider',
+    'VerticalDivider',
+    'Placeholder',
+    // Container/positioning widgets
+    'Padding',
+    'Center',
+    'Align',
+    'AspectRatio',
+    'FittedBox',
+    'FractionallySizedBox',
+    'LimitedBox',
+    'Offstage',
+    'OverflowBox',
+    'SizedOverflowBox',
+    'Transform',
+    'RotatedBox',
+    'ConstrainedBox',
+    'UnconstrainedBox',
+    'IntrinsicHeight',
+    'IntrinsicWidth',
+    'Baseline',
+    // Layout widgets
+    'Row',
+    'Column',
+    'Stack',
+    'IndexedStack',
+    'Wrap',
+    'Flex',
+    'Flow',
+    'Table',
+    'TableRow',
+    'TableCell',
+    // Visual effect widgets
+    'Opacity',
+    'DecoratedBox',
+    'Container',
+    'Card',
+    'Material',
+    'ClipRect',
+    'ClipRRect',
+    'ClipOval',
+    'ClipPath',
+    'PhysicalModel',
+    'PhysicalShape',
+    // Other
+    'Tooltip',
+    'Semantics',
+    'MergeSemantics',
+    'ExcludeSemantics',
+    'BlockSemantics',
+    'Visibility',
+    'IgnorePointer',
+    'AbsorbPointer',
+];
+/**
+ * Value types that are always const-eligible
+ */
+const CONST_ELIGIBLE_VALUES = [
+    'EdgeInsets.all',
+    'EdgeInsets.symmetric',
+    'EdgeInsets.only',
+    'EdgeInsets.fromLTRB',
+    'EdgeInsets.zero',
+    'EdgeInsetsDirectional.all',
+    'EdgeInsetsDirectional.symmetric',
+    'EdgeInsetsDirectional.only',
+    'EdgeInsetsDirectional.fromSTEB',
+    'BorderRadius.circular',
+    'BorderRadius.all',
+    'BorderRadius.only',
+    'BorderRadius.zero',
+    'Radius.circular',
+    'Radius.elliptical',
+    'Radius.zero',
+    'TextStyle',
+    'BoxDecoration',
+    'BorderSide',
+    'Border.all',
+    'BoxShadow',
+    'BoxConstraints',
+    'Size',
+    'Offset',
+    'Rect.fromLTWH',
+    'Rect.fromLTRB',
+    'Duration',
+    'Alignment',
+    'AlignmentDirectional',
+    'Color',
+    'Colors.',
+    'FontWeight.',
+    'FontStyle.',
+    'TextAlign.',
+    'MainAxisAlignment.',
+    'CrossAxisAlignment.',
+    'MainAxisSize.',
+    'Axis.',
+    'Icons.',
+];
+/**
+ * Patterns that PREVENT const promotion
+ */
+const CONST_BLOCKERS = [
+    /\$\{[^}]+\}/, // String interpolation ${...}
+    /\$\w+/, // Simple string interpolation $var
+    /\bWidget\s+\w+/, // Dynamic widget parameter
+    /\.of\s*\(\s*context/, // Context-dependent (Theme.of, MediaQuery.of)
+    /\bcontext\b/, // Uses BuildContext
+    /\bthis\./, // Instance member access
+    /\bsuper\./, // Superclass access
+    /\bwidget\./, // State widget access
+    /\bstate\./, // State access
+    /\bawait\b/, // Async operation
+    /\bFuture\b/, // Future usage
+    /\bStream\b/, // Stream usage
+    /\bDateTime\.now/, // Runtime value
+    /\bRandom\s*\(/, // Random value
+    /\bPlatform\./, // Platform-specific
+    /\bkIsWeb\b/, // Web check
+    /\[\s*\.\.\./, // Spread operator
+    /\bif\s*\(/, // Conditional
+    /\bfor\s*\(/, // Loop
+    /\bswitch\s*\(/, // Switch
+    /\?\s*:/, // Ternary operator
+    /\?\?/, // Null coalescing
+    /\.\.\?/, // Null-aware cascade
+    /\?\.+/, // Null-aware access
+    /\bsnapshot\./, // FutureBuilder/StreamBuilder
+    /\bindex\b/, // Usually loop variable
+    /\bitem\b/, // Usually iteration variable
+    /\be\b\./, // Usually event parameter
+    /\.length\b/, // Dynamic property
+    /\.isEmpty\b/, // Dynamic property
+    /\.isNotEmpty\b/, // Dynamic property
+    /\bsetState\b/, // State mutation
+    /\bnotifyListeners\b/, // ChangeNotifier
+    /\bref\./, // Riverpod ref
+    /\bwatch\(/, // Riverpod watch
+    /\bread\(/, // Riverpod read
+    /\bProvider\./, // Provider access
+    /\bGetX\b/, // GetX
+    /\bObx\(/, // GetX Obx
+    /\bBlocBuilder\b/, // BLoC
+    /\bBlocProvider\./, // BLoC
+    // Additional dynamic value indicators
+    /\*\s*[\d.]+/, // Multiplication with number (often dynamic calc)
+    /[\d.]+\s*\*/, // Number times something
+    /\bsize\./, // Usually from MediaQuery.of(context).size
+    /\bheight\b(?!\s*:)/, // height variable (not named param)
+    /\bwidth\b(?!\s*:)/, // width variable (not named param)
+    /\bconstraints\./, // LayoutBuilder constraints
+    /\bdata\b/, // Usually from inherited widget
+    /\bvalue\b(?!\s*:)/, // Usually a variable
+    /\bmodel\./, // Usually a model variable
+    /\bcontroller\./, // Usually a controller
+    /\b_\w+/, // Private variable reference
+];
+/**
+ * Patterns that indicate the expression is ALREADY const
+ */
+const ALREADY_CONST_PATTERNS = [
+    /^\s*const\s+/, // Starts with const
+    /=\s*const\s+/, // Assignment with const
+    /:\s*const\s+/, // Named parameter with const
+    /,\s*const\s+/, // List item with const
+    /\[\s*const\s+/, // List starting with const
+    /\(\s*const\s+/, // Parenthesis starting with const
+];
+// ============================================================================
+// MAIN ENGINE CLASS
+// ============================================================================
+export class ConstPromotionEngine {
+    projectPath;
+    atomicWriter;
+    shellExecutor;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        this.atomicWriter = new AtomicWriter(projectPath);
+        this.shellExecutor = new ShellExecutor({ projectPath });
+    }
+    /**
+     * Initialize the engine
+     */
+    async initialize() {
+        await this.atomicWriter.initialize();
+    }
+    /**
+     * Find all const-eligible candidates in the project
+     */
+    async findCandidates() {
+        const candidates = [];
+        // Find all Dart files in lib/
+        const dartFiles = await glob('**/*.dart', {
+            cwd: path.join(this.projectPath, 'lib'),
+            ignore: [
+                '**/build/**',
+                '**/.dart_tool/**',
+                '**/*.g.dart', // Generated files
+                '**/*.freezed.dart', // Freezed generated
+                '**/*.gr.dart', // Auto-route generated
+                '**/*.mocks.dart', // Mockito mocks
+            ]
+        });
+        for (const file of dartFiles) {
+            const filePath = path.join(this.projectPath, 'lib', file);
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const fileCandidates = this.analyzeFile(content, filePath, file);
+                candidates.push(...fileCandidates);
+            }
+            catch (error) {
+                // Skip files that can't be read
+                continue;
+            }
+        }
+        // Sort by confidence (highest first)
+        return candidates.sort((a, b) => b.confidence - a.confidence);
+    }
+    /**
+     * Analyze a single file for const candidates
+     */
+    analyzeFile(content, absolutePath, relativePath) {
+        const candidates = [];
+        const lines = content.split('\n');
+        // Build a regex to match widget constructors
+        const widgetPattern = new RegExp(`(?<!const\\s+)(?<!new\\s+)(${CONST_ELIGIBLE_WIDGETS.join('|')})\\s*\\(`, 'g');
+        // Build a regex to match value constructors
+        const valuePatternStr = CONST_ELIGIBLE_VALUES
+            .map(v => v.replace(/\./g, '\\.').replace(/\(/g, '\\('))
+            .join('|');
+        const valuePattern = new RegExp(`(?<!const\\s+)(${valuePatternStr})\\s*\\(?`, 'g');
+        // Find widget candidates
+        let match;
+        while ((match = widgetPattern.exec(content)) !== null) {
+            const candidate = this.analyzeMatch(match, content, absolutePath, relativePath, lines, 'widget');
+            if (candidate) {
+                candidates.push(candidate);
+            }
+        }
+        // Find value candidates
+        while ((match = valuePattern.exec(content)) !== null) {
+            const candidate = this.analyzeMatch(match, content, absolutePath, relativePath, lines, 'value');
+            if (candidate) {
+                candidates.push(candidate);
+            }
+        }
+        return candidates;
+    }
+    /**
+     * Analyze a regex match to determine if it's a valid const candidate
+     */
+    analyzeMatch(match, content, absolutePath, relativePath, lines, matchType) {
+        const offset = match.index;
+        const widgetType = match[1];
+        // Find line and column
+        const beforeMatch = content.substring(0, offset);
+        const line = beforeMatch.split('\n').length;
+        const lastNewline = beforeMatch.lastIndexOf('\n');
+        const column = offset - lastNewline;
+        // Get the full expression (find matching parenthesis)
+        const expressionEnd = this.findMatchingParen(content, offset + match[0].length - 1);
+        if (expressionEnd === -1) {
+            return null; // Couldn't find matching paren
+        }
+        const originalCode = content.substring(offset, expressionEnd + 1);
+        // Check if already const - look at more context before the match
+        const contextBefore = content.substring(Math.max(0, offset - 100), offset);
+        // Multiple patterns to check for already being const
+        // 1. Direct const keyword before this widget
+        if (/const\s+$/.test(contextBefore)) {
+            return null; // Already const
+        }
+        // 2. Inside a const children array: children: const [
+        if (/children:\s*const\s*\[\s*$/.test(contextBefore)) {
+            return null; // Inside const array
+        }
+        // 3. Check if we're inside a larger const expression
+        // Look for 'const ' followed by any widget name, then check if we're inside it
+        const constWidgetPattern = /const\s+([\w.]+)\s*\(/g;
+        let constMatch;
+        let isInsideConst = false;
+        // Check all const declarations before this position
+        const fullBefore = content.substring(0, offset);
+        while ((constMatch = constWidgetPattern.exec(fullBefore)) !== null) {
+            const constStart = constMatch.index;
+            const constExprEnd = this.findMatchingParen(content, constStart + constMatch[0].length - 1);
+            // If our offset is within this const expression, we're already const
+            if (constExprEnd > offset) {
+                isInsideConst = true;
+                break;
+            }
+        }
+        if (isInsideConst) {
+            return null; // Inside a const expression
+        }
+        // Also check for standard already-const patterns
+        for (const pattern of ALREADY_CONST_PATTERNS) {
+            if (pattern.test(contextBefore)) {
+                return null; // Already const
+            }
+        }
+        // Check for const blockers in the expression
+        const { blocked, blocker } = this.checkConstBlockers(originalCode);
+        if (blocked) {
+            return null; // Cannot be const
+        }
+        // Calculate confidence
+        const { confidence, reason } = this.calculateConfidence(originalCode, widgetType, matchType, content, offset);
+        // Skip low confidence matches
+        if (confidence < 50) {
+            return null;
+        }
+        return {
+            filePath: absolutePath,
+            relativePath: `lib/${relativePath}`,
+            line,
+            column,
+            offset,
+            endOffset: expressionEnd + 1,
+            widgetType,
+            originalCode: originalCode.trim(),
+            suggestedFix: `const ${originalCode.trim()}`,
+            confidence,
+            confidenceReason: reason,
+        };
+    }
+    /**
+     * Find the matching closing parenthesis
+     */
+    findMatchingParen(content, startParen) {
+        let depth = 1;
+        let i = startParen + 1;
+        let inString = false;
+        let stringChar = '';
+        let escaped = false;
+        while (i < content.length && depth > 0) {
+            const char = content[i];
+            const prevChar = content[i - 1];
+            // Handle escape sequences
+            if (escaped) {
+                escaped = false;
+                i++;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                i++;
+                continue;
+            }
+            // Handle strings
+            if (!inString && (char === '"' || char === "'")) {
+                // Check for triple quotes
+                if (content.substring(i, i + 3) === '"""' || content.substring(i, i + 3) === "'''") {
+                    inString = true;
+                    stringChar = content.substring(i, i + 3);
+                    i += 3;
+                    continue;
+                }
+                inString = true;
+                stringChar = char;
+                i++;
+                continue;
+            }
+            if (inString) {
+                if (stringChar.length === 3) {
+                    // Triple quote string
+                    if (content.substring(i, i + 3) === stringChar) {
+                        inString = false;
+                        i += 3;
+                        continue;
+                    }
+                }
+                else if (char === stringChar) {
+                    inString = false;
+                }
+                i++;
+                continue;
+            }
+            // Handle parentheses (only when not in string)
+            if (char === '(') {
+                depth++;
+            }
+            else if (char === ')') {
+                depth--;
+            }
+            i++;
+        }
+        return depth === 0 ? i - 1 : -1;
+    }
+    /**
+     * Check if the expression contains any const blockers
+     */
+    checkConstBlockers(code) {
+        // First check standard patterns
+        for (const pattern of CONST_BLOCKERS) {
+            if (pattern.test(code)) {
+                return { blocked: true, blocker: pattern.source };
+            }
+        }
+        // Additional check: Look for bare variable identifiers that might be dynamic
+        // This catches cases like Text(title) where title is a variable
+        const bareIdentifierPattern = /\(\s*([a-z_][a-zA-Z0-9_]*)\s*[,)]/g;
+        let match;
+        while ((match = bareIdentifierPattern.exec(code)) !== null) {
+            const identifier = match[1];
+            // Skip known const-safe identifiers
+            const constSafeIdentifiers = [
+                'true', 'false', 'null',
+                'const', 'new', 'final', 'var',
+                // Common Flutter consts
+                'infinity', 'nan',
+            ];
+            if (constSafeIdentifiers.includes(identifier.toLowerCase())) {
+                continue;
+            }
+            // Skip if it looks like a static member access (Icons.star comes in as identifier after the dot)
+            if (code.includes(`.${identifier}`)) {
+                continue;
+            }
+            // Skip if it's immediately followed by a colon (named parameter name)
+            const afterMatch = code.substring(match.index + match[0].length - 1);
+            if (afterMatch.startsWith(':')) {
+                continue;
+            }
+            // This looks like a bare variable reference
+            return { blocked: true, blocker: `bare identifier: ${identifier}` };
+        }
+        // Check for parameter-style variable references: key: value where value is an identifier
+        const paramValuePattern = /:\s*([a-z_][a-zA-Z0-9_]*)\s*[,)]/g;
+        while ((match = paramValuePattern.exec(code)) !== null) {
+            const identifier = match[1];
+            // Skip known const-safe values
+            const constSafeValues = [
+                'true', 'false', 'null',
+                // Common Flutter enum prefixes that will be caught by . check
+            ];
+            if (constSafeValues.includes(identifier.toLowerCase())) {
+                continue;
+            }
+            // Skip if there's a dot before (like Icons.star, Colors.red)
+            const fullMatch = code.substring(0, match.index + match[0].length);
+            const beforeColon = fullMatch.lastIndexOf(':');
+            if (beforeColon > 0) {
+                const valueSection = code.substring(beforeColon, match.index + match[0].length);
+                // If it contains a dot accessor, it's likely a const enum or static field
+                if (/\.\s*[a-zA-Z]/.test(valueSection)) {
+                    continue;
+                }
+            }
+            // Check if the value section has any literals (quotes, numbers)
+            const valueStart = match.index - (code.lastIndexOf(':', match.index) - match.index);
+            const valueCode = code.substring(code.lastIndexOf(':', match.index), match.index + match[0].length);
+            // If it's just an identifier with no qualifiers, it's likely a variable
+            if (!/['"`\d.]/.test(valueCode) && !/[A-Z][a-zA-Z]*\./.test(valueCode)) {
+                // Additional check: is this identifier a known widget property that takes const values?
+                const constProperties = ['alignment', 'direction', 'axis', 'crossAxisAlignment', 'mainAxisAlignment'];
+                const beforeEquals = code.substring(Math.max(0, match.index - 50), match.index);
+                const isConstProperty = constProperties.some(p => beforeEquals.includes(p));
+                if (!isConstProperty) {
+                    return { blocked: true, blocker: `possible variable value: ${identifier}` };
+                }
+            }
+        }
+        return { blocked: false };
+    }
+    /**
+     * Calculate confidence score for a candidate
+     */
+    calculateConfidence(code, widgetType, matchType, fullContent, offset) {
+        let confidence = 70; // Base confidence
+        const reasons = [];
+        // Boost for simple widgets
+        const simpleWidgets = ['SizedBox', 'Spacer', 'Divider', 'Icon', 'Text'];
+        if (simpleWidgets.includes(widgetType)) {
+            confidence += 15;
+            reasons.push('simple widget type');
+        }
+        // Boost for value types (EdgeInsets, BorderRadius, etc.)
+        if (matchType === 'value') {
+            confidence += 10;
+            reasons.push('value type');
+        }
+        // Reduce for nested expressions
+        const parenCount = (code.match(/\(/g) || []).length;
+        if (parenCount > 3) {
+            confidence -= (parenCount - 3) * 5;
+            reasons.push('complex nesting');
+        }
+        // Reduce for very long expressions (might have dynamic content)
+        if (code.length > 200) {
+            confidence -= 10;
+            reasons.push('long expression');
+        }
+        // Boost if inside a children array
+        const contextBefore = fullContent.substring(Math.max(0, offset - 100), offset);
+        if (/children:\s*\[/.test(contextBefore)) {
+            confidence += 5;
+            reasons.push('in children array');
+        }
+        // Reduce if it looks like it might be in a builder
+        if (/builder:\s*\(/.test(contextBefore)) {
+            confidence -= 20;
+            reasons.push('possibly in builder');
+        }
+        // Reduce if there's a variable reference that might be dynamic
+        if (/\b[a-z_][a-zA-Z0-9_]*(?!\s*\()/.test(code)) {
+            // Check if it's not just a named parameter
+            const varMatches = code.match(/\b([a-z_][a-zA-Z0-9_]*)\b(?!\s*:)(?!\s*\()/g) || [];
+            const dynamicVars = varMatches.filter(v => !['true', 'false', 'null', 'const', 'new', 'final', 'var'].includes(v) &&
+                !CONST_ELIGIBLE_VALUES.some(ce => ce.startsWith(v)));
+            if (dynamicVars.length > 0) {
+                confidence -= dynamicVars.length * 10;
+                reasons.push(`potential dynamic vars: ${dynamicVars.slice(0, 3).join(', ')}`);
+            }
+        }
+        // Cap confidence
+        confidence = Math.max(0, Math.min(100, confidence));
+        return {
+            confidence,
+            reason: reasons.length > 0 ? reasons.join('; ') : 'standard confidence'
+        };
+    }
+    /**
+     * Apply const fixes to candidates
+     */
+    async applyFixes(candidates, options = {}) {
+        const startTime = Date.now();
+        const { verifyEach = true, rollbackOnFailure = true, maxFixes = 100, minConfidence = 70, dryRun = false, } = options;
+        const result = {
+            filesAnalyzed: 0,
+            candidatesFound: candidates.length,
+            fixesApplied: 0,
+            fixesFailed: 0,
+            verificationPassed: false,
+            transactionId: '',
+            candidates: [...candidates],
+            errors: [],
+            duration: 0,
+        };
+        // Filter by confidence
+        const eligibleCandidates = candidates
+            .filter(c => c.confidence >= minConfidence)
+            .slice(0, maxFixes);
+        if (eligibleCandidates.length === 0) {
+            result.verificationPassed = true;
+            result.duration = Date.now() - startTime;
+            return result;
+        }
+        if (dryRun) {
+            result.fixesApplied = eligibleCandidates.length;
+            result.verificationPassed = true;
+            result.duration = Date.now() - startTime;
+            return result;
+        }
+        // Group candidates by file for efficient processing
+        const candidatesByFile = new Map();
+        for (const candidate of eligibleCandidates) {
+            const existing = candidatesByFile.get(candidate.filePath) || [];
+            existing.push(candidate);
+            candidatesByFile.set(candidate.filePath, existing);
+        }
+        result.filesAnalyzed = candidatesByFile.size;
+        // Start transaction
+        await this.atomicWriter.initialize();
+        result.transactionId = this.atomicWriter.startTransaction('const-promotion-batch');
+        try {
+            // Process each file
+            for (const [filePath, fileCandidates] of candidatesByFile) {
+                // Sort by offset descending (so we don't mess up offsets when inserting)
+                fileCandidates.sort((a, b) => b.offset - a.offset);
+                let content = await fs.readFile(filePath, 'utf-8');
+                const relativePath = path.relative(this.projectPath, filePath);
+                // Apply fixes to this file (in reverse order to preserve offsets)
+                for (const candidate of fileCandidates) {
+                    const beforeFix = content;
+                    // Insert 'const ' at the offset
+                    content =
+                        content.substring(0, candidate.offset) +
+                            'const ' +
+                            content.substring(candidate.offset);
+                    candidate.fixed = true;
+                    result.fixesApplied++;
+                }
+                // Stage the modified file
+                await this.atomicWriter.stageWrite(relativePath, content);
+                // Verify if option is enabled
+                if (verifyEach) {
+                    // Temporarily write to verify
+                    const tempPath = filePath + '.const_temp';
+                    await fs.writeFile(tempPath, content, 'utf-8');
+                    try {
+                        const verifyResult = await this.verifyFile(tempPath);
+                        if (!verifyResult.passed) {
+                            // Mark candidates as failed
+                            for (const candidate of fileCandidates) {
+                                candidate.fixed = false;
+                                candidate.fixError = verifyResult.errors.join('; ');
+                                result.fixesFailed++;
+                                result.fixesApplied--;
+                            }
+                            result.errors.push(`Verification failed for ${relativePath}: ${verifyResult.errors.join('; ')}`);
+                            if (rollbackOnFailure) {
+                                // Don't include this file in the commit
+                                // Read original and re-stage
+                                const original = await fs.readFile(filePath, 'utf-8');
+                                await this.atomicWriter.stageWrite(relativePath, original);
+                            }
+                        }
+                    }
+                    finally {
+                        // Clean up temp file
+                        await fs.unlink(tempPath).catch(() => { });
+                    }
+                }
+            }
+            // Verify staging
+            const stageVerify = await this.atomicWriter.verify();
+            if (!stageVerify.passed) {
+                result.errors.push('Staging verification failed');
+                if (rollbackOnFailure) {
+                    await this.atomicWriter.rollback();
+                    result.transactionId = '';
+                    result.verificationPassed = false;
+                    result.duration = Date.now() - startTime;
+                    return result;
+                }
+            }
+            // Commit the changes
+            const transaction = await this.atomicWriter.commit('Const promotion auto-fix');
+            result.transactionId = transaction.id;
+            result.verificationPassed = true;
+        }
+        catch (error) {
+            result.errors.push(`Error during fix application: ${error}`);
+            if (rollbackOnFailure) {
+                await this.atomicWriter.rollback();
+                result.transactionId = '';
+            }
+        }
+        result.duration = Date.now() - startTime;
+        return result;
+    }
+    /**
+     * Verify a file with dart analyze
+     */
+    async verifyFile(filePath) {
+        try {
+            const result = await this.shellExecutor.execute('dart', ['analyze', '--fatal-infos', filePath], ShellCommandType.DART_ANALYZE);
+            const errors = [];
+            // Check for const-related errors
+            if (result.stderr.includes('error') || result.stdout.includes('error')) {
+                // Extract error messages
+                const errorLines = (result.stdout + result.stderr)
+                    .split('\n')
+                    .filter(line => line.includes('error') || line.includes('Error'));
+                errors.push(...errorLines.slice(0, 5)); // Limit to first 5 errors
+            }
+            return {
+                passed: result.exitCode === 0 && errors.length === 0,
+                errors
+            };
+        }
+        catch (error) {
+            return {
+                passed: false,
+                errors: [`Dart analyze failed: ${error}`]
+            };
+        }
+    }
+    /**
+     * Verify all project files with dart analyze
+     */
+    async verifyProject() {
+        try {
+            const result = await this.shellExecutor.dartAnalyze({ fatal: true });
+            const errors = [];
+            if (result.exitCode !== 0) {
+                const errorLines = (result.stdout + result.stderr)
+                    .split('\n')
+                    .filter(line => line.includes('error') || line.includes('warning'));
+                errors.push(...errorLines.slice(0, 10));
+            }
+            return {
+                passed: result.exitCode === 0,
+                errors
+            };
+        }
+        catch (error) {
+            return {
+                passed: false,
+                errors: [`Dart analyze failed: ${error}`]
+            };
+        }
+    }
+    /**
+     * Undo the last const promotion
+     */
+    async undoLastPromotion() {
+        try {
+            const transactions = await this.atomicWriter.listTransactions();
+            const constPromotion = transactions.find(t => t.goal.includes('const-promotion') && t.state === 'committed');
+            if (constPromotion) {
+                await this.atomicWriter.undoTransaction(constPromotion.id);
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Convert candidates to GateIssue format for integration with PerformanceGate
+     */
+    candidatesToIssues(candidates) {
+        return candidates.map(c => ({
+            severity: 'info',
+            code: 'CONST_PROMOTABLE',
+            message: `${c.widgetType} can be const (${c.confidence}% confidence)`,
+            filePath: c.relativePath,
+            line: c.line,
+            autoFixable: true,
+            fixAction: {
+                id: `const-${c.line}-${c.column}`,
+                type: FixActionType.ADD_CONST,
+                confidence: c.confidence,
+                filePath: c.relativePath,
+                line: c.line,
+                column: c.column,
+                message: `Add const to ${c.widgetType}`,
+                suggestedFix: c.suggestedFix,
+                requiresHumanApproval: c.confidence < 80,
+            }
+        }));
+    }
+    /**
+     * Get statistics about const usage in the project
+     */
+    async getConstStatistics() {
+        const candidates = await this.findCandidates();
+        const typeCount = new Map();
+        for (const c of candidates) {
+            const count = typeCount.get(c.widgetType) || 0;
+            typeCount.set(c.widgetType, count + 1);
+        }
+        const topMissingTypes = Array.from(typeCount.entries())
+            .map(([type, count]) => ({ type, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 10);
+        // This is an approximation - we'd need full AST for exact count
+        return {
+            totalWidgets: 0, // Would need full analysis
+            constWidgets: 0,
+            nonConstWidgets: candidates.length,
+            constPercentage: 0,
+            topMissingTypes
+        };
+    }
+}
+export default ConstPromotionEngine;
+//# sourceMappingURL=ConstPromotionEngine.js.map