dartmind 17.0.0

package/dist/analysis/ProjectAnalyzer.js

@@ -0,0 +1,1128 @@
+/**
+ * FlutterAI V15 - Project-Wide Analyzer
+ * The "Brain" - Global Semantic Intelligence
+ *
+ * Capabilities:
+ * - Full dependency graph (Imports -> Classes -> Functions)
+ * - State Management Auto-Detection (Provider, Riverpod, BLoC, GetX, etc.)
+ * - Architecture Pattern Detection (Clean, MVVM, MVC, Feature-First)
+ * - Code Quality Metrics & Technical Debt Analysis
+ * - Impact Analysis for Refactoring
+ *
+ * @module analysis/ProjectAnalyzer
+ * @version 15.1.0
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventEmitter } from 'events';
+import * as crypto from 'crypto';
+// Import types from dedicated module
+import { StateManagementType, ArchitecturePattern, } from './types.js';
+// V15.1: Import extracted DartParser
+import { DartParser } from './DartParser.js';
+// Re-export all types for backward compatibility
+export { StateManagementType, ArchitecturePattern, } from './types.js';
+// ============================================================================
+// PROJECT ANALYZER CLASS
+// ============================================================================
+export class ProjectAnalyzer extends EventEmitter {
+    projectPath;
+    cache = new Map();
+    dependencyGraph = null;
+    lastAnalysis = null;
+    fileWatcher = null;
+    analysisInProgress = false;
+    // State management detection patterns
+    STATE_PATTERNS = {
+        [StateManagementType.PROVIDER]: [
+            /import\s+['"]package:provider\//,
+            /ChangeNotifier/,
+            /ChangeNotifierProvider/,
+            /Consumer<\w+>/,
+            /Provider\.of<\w+>/,
+            /context\.watch<\w+>/,
+            /context\.read<\w+>/,
+            /MultiProvider/,
+            /ProxyProvider/,
+            /FutureProvider/,
+            /StreamProvider/
+        ],
+        [StateManagementType.RIVERPOD]: [
+            /import\s+['"]package:flutter_riverpod\//,
+            /import\s+['"]package:riverpod\//,
+            /import\s+['"]package:hooks_riverpod\//,
+            /StateNotifier/,
+            /StateNotifierProvider/,
+            /ConsumerWidget/,
+            /ConsumerStatefulWidget/,
+            /ref\.watch\(/,
+            /ref\.read\(/,
+            /ProviderScope/,
+            /AsyncNotifier/,
+            /Notifier/,
+            /@riverpod/,
+            /NotifierProvider/
+        ],
+        [StateManagementType.BLOC]: [
+            /import\s+['"]package:flutter_bloc\//,
+            /import\s+['"]package:bloc\//,
+            /extends\s+Bloc</,
+            /BlocProvider/,
+            /BlocBuilder/,
+            /BlocListener/,
+            /BlocConsumer/,
+            /MultiBlocProvider/,
+            /context\.read<\w+Bloc>/,
+            /emit\(/
+        ],
+        [StateManagementType.CUBIT]: [
+            /extends\s+Cubit</,
+            /CubitProvider/,
+            /context\.read<\w+Cubit>/
+        ],
+        [StateManagementType.GETX]: [
+            /import\s+['"]package:get\//,
+            /GetxController/,
+            /GetBuilder/,
+            /Obx\(/,
+            /\.obs\b/,
+            /Get\.put\(/,
+            /Get\.find</,
+            /GetMaterialApp/,
+            /GetX</
+        ],
+        [StateManagementType.MOBX]: [
+            /import\s+['"]package:mobx\//,
+            /import\s+['"]package:flutter_mobx\//,
+            /@observable/,
+            /@action/,
+            /@computed/,
+            /Observer\(/,
+            /Store\b/
+        ],
+        [StateManagementType.REDUX]: [
+            /import\s+['"]package:flutter_redux\//,
+            /import\s+['"]package:redux\//,
+            /StoreProvider/,
+            /StoreConnector/,
+            /StoreBuilder/,
+            /Reducer\b/,
+            /Middleware\b/
+        ],
+        [StateManagementType.SIGNALS]: [
+            /import\s+['"]package:signals\//,
+            /createSignal/,
+            /createComputed/,
+            /createEffect/,
+            /Signal</
+        ],
+        [StateManagementType.INHERITED_WIDGET]: [
+            /extends\s+InheritedWidget/,
+            /extends\s+InheritedNotifier/,
+            /extends\s+InheritedModel/,
+            /updateShouldNotify/
+        ],
+        [StateManagementType.VANILLA]: [
+            /setState\s*\(/
+        ],
+        [StateManagementType.MIXED]: [],
+        [StateManagementType.UNKNOWN]: []
+    };
+    // Architecture pattern indicators
+    ARCHITECTURE_INDICATORS = {
+        [ArchitecturePattern.CLEAN]: {
+            directories: [
+                /\/domain\//i,
+                /\/data\//i,
+                /\/presentation\//i,
+                /\/entities\//i,
+                /\/usecases?\//i,
+                /\/repositories\//i,
+                /\/datasources?\//i
+            ],
+            files: [
+                /_usecase\.dart$/i,
+                /_repository\.dart$/i,
+                /_entity\.dart$/i,
+                /_model\.dart$/i,
+                /_datasource\.dart$/i
+            ],
+            imports: [
+                /package:dartz\//,
+                /package:injectable\//,
+                /package:get_it\//
+            ]
+        },
+        [ArchitecturePattern.MVVM]: {
+            directories: [
+                /\/viewmodels?\//i,
+                /\/views?\//i,
+                /\/models?\//i
+            ],
+            files: [
+                /_viewmodel\.dart$/i,
+                /_view\.dart$/i,
+                /_model\.dart$/i
+            ],
+            imports: []
+        },
+        [ArchitecturePattern.MVC]: {
+            directories: [
+                /\/controllers?\//i,
+                /\/views?\//i,
+                /\/models?\//i
+            ],
+            files: [
+                /_controller\.dart$/i,
+                /_view\.dart$/i,
+                /_model\.dart$/i
+            ],
+            imports: []
+        },
+        [ArchitecturePattern.MVP]: {
+            directories: [
+                /\/presenters?\//i,
+                /\/views?\//i,
+                /\/models?\//i
+            ],
+            files: [
+                /_presenter\.dart$/i,
+                /_view\.dart$/i,
+                /_model\.dart$/i
+            ],
+            imports: []
+        },
+        [ArchitecturePattern.FEATURE_FIRST]: {
+            directories: [
+                /\/features?\//i,
+                /\/modules?\//i
+            ],
+            files: [],
+            imports: []
+        },
+        [ArchitecturePattern.LAYER_FIRST]: {
+            directories: [
+                /^lib\/ui\//i,
+                /^lib\/services?\//i,
+                /^lib\/models?\//i,
+                /^lib\/widgets?\//i
+            ],
+            files: [],
+            imports: []
+        },
+        [ArchitecturePattern.DOMAIN_DRIVEN]: {
+            directories: [
+                /\/domain\//i,
+                /\/infrastructure\//i,
+                /\/application\//i,
+                /\/aggregates?\//i,
+                /\/value_objects?\//i
+            ],
+            files: [
+                /_aggregate\.dart$/i,
+                /_value_object\.dart$/i,
+                /_service\.dart$/i
+            ],
+            imports: [
+                /package:freezed\//,
+                /package:dartz\//
+            ]
+        },
+        [ArchitecturePattern.MODULAR]: {
+            directories: [
+                /\/modules?\//i
+            ],
+            files: [
+                /_module\.dart$/i
+            ],
+            imports: [
+                /package:flutter_modular\//
+            ]
+        },
+        [ArchitecturePattern.MONOLITHIC]: {
+            directories: [],
+            files: [],
+            imports: []
+        },
+        [ArchitecturePattern.UNKNOWN]: {
+            directories: [],
+            files: [],
+            imports: []
+        }
+    };
+    constructor(projectPath) {
+        super();
+        this.projectPath = path.resolve(projectPath);
+    }
+    // ==========================================================================
+    // PUBLIC API
+    // ==========================================================================
+    /**
+     * Initialize the analyzer and perform initial scan
+     */
+    async initialize() {
+        this.emit('status', 'Initializing Project Analyzer...');
+        if (!fs.existsSync(this.projectPath)) {
+            throw new Error(`Project path does not exist: ${this.projectPath}`);
+        }
+        const pubspecPath = path.join(this.projectPath, 'pubspec.yaml');
+        if (!fs.existsSync(pubspecPath)) {
+            throw new Error(`Not a Flutter project: pubspec.yaml not found`);
+        }
+        this.emit('status', 'Project Analyzer initialized');
+    }
+    /**
+     * Perform full project analysis
+     */
+    async analyze() {
+        if (this.analysisInProgress) {
+            throw new Error('Analysis already in progress');
+        }
+        this.analysisInProgress = true;
+        const startTime = Date.now();
+        try {
+            this.emit('progress', { phase: 'scanning', progress: 0 });
+            // Phase 1: Scan all Dart files
+            const dartFiles = await this.scanDartFiles();
+            this.emit('progress', { phase: 'scanning', progress: 25 });
+            // Phase 2: Parse all files
+            const parsedFiles = await this.parseAllFiles(dartFiles);
+            this.emit('progress', { phase: 'parsing', progress: 50 });
+            // Phase 3: Build dependency graph
+            const dependencyGraph = this.buildDependencyGraph(parsedFiles);
+            this.emit('progress', { phase: 'graph', progress: 65 });
+            // Phase 4: Detect state management
+            const stateManagement = this.analyzeStateManagement(parsedFiles);
+            this.emit('progress', { phase: 'state', progress: 75 });
+            // Phase 5: Detect architecture
+            const architecture = this.analyzeArchitecture(parsedFiles);
+            this.emit('progress', { phase: 'architecture', progress: 85 });
+            // Phase 6: Calculate metrics
+            const metrics = this.calculateMetrics(parsedFiles);
+            this.emit('progress', { phase: 'metrics', progress: 95 });
+            // Phase 7: Generate issues and suggestions
+            const issues = this.detectIssues(parsedFiles, dependencyGraph);
+            const suggestions = this.generateSuggestions(parsedFiles, dependencyGraph, stateManagement, architecture);
+            const result = {
+                projectPath: this.projectPath,
+                analyzedAt: new Date(),
+                duration: Date.now() - startTime,
+                files: parsedFiles,
+                dependencyGraph,
+                stateManagement,
+                architecture,
+                metrics,
+                issues,
+                suggestions
+            };
+            this.lastAnalysis = result;
+            this.dependencyGraph = dependencyGraph;
+            this.emit('progress', { phase: 'complete', progress: 100 });
+            this.emit('complete', result);
+            return result;
+        }
+        finally {
+            this.analysisInProgress = false;
+        }
+    }
+    /**
+     * Analyze impact of changes to a file
+     */
+    analyzeImpact(filePath) {
+        if (!this.dependencyGraph) {
+            throw new Error('Run analyze() first to build dependency graph');
+        }
+        const relativePath = path.relative(this.projectPath, filePath);
+        const node = this.dependencyGraph.nodes.get(relativePath);
+        if (!node) {
+            return {
+                changedFile: relativePath,
+                directlyAffected: [],
+                indirectlyAffected: [],
+                testFiles: [],
+                riskLevel: 'low',
+                recommendations: ['File not in dependency graph']
+            };
+        }
+        // Find directly affected files
+        const directlyAffected = node.importedBy;
+        // Find indirectly affected files (transitive)
+        const indirectlyAffected = new Set();
+        const visited = new Set([relativePath, ...directlyAffected]);
+        const queue = [...directlyAffected];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const currentNode = this.dependencyGraph.nodes.get(current);
+            if (currentNode) {
+                for (const importer of currentNode.importedBy) {
+                    if (!visited.has(importer)) {
+                        visited.add(importer);
+                        indirectlyAffected.add(importer);
+                        queue.push(importer);
+                    }
+                }
+            }
+        }
+        // Find test files
+        const testFiles = [...directlyAffected, ...indirectlyAffected].filter(f => f.includes('_test.dart') || f.startsWith('test/'));
+        // Calculate risk level
+        const totalAffected = directlyAffected.length + indirectlyAffected.size;
+        let riskLevel;
+        if (totalAffected > 20 || node.importedBy.length > 10) {
+            riskLevel = 'high';
+        }
+        else if (totalAffected > 5 || node.importedBy.length > 3) {
+            riskLevel = 'medium';
+        }
+        else {
+            riskLevel = 'low';
+        }
+        const recommendations = [];
+        if (riskLevel === 'high') {
+            recommendations.push('Consider breaking this file into smaller modules');
+            recommendations.push('Run full test suite before committing');
+            recommendations.push('Consider feature flags for gradual rollout');
+        }
+        if (testFiles.length === 0 && totalAffected > 0) {
+            recommendations.push('Add unit tests for this file');
+        }
+        return {
+            changedFile: relativePath,
+            directlyAffected,
+            indirectlyAffected: [...indirectlyAffected],
+            testFiles,
+            riskLevel,
+            recommendations
+        };
+    }
+    /**
+     * Get cached analysis result
+     */
+    getLastAnalysis() {
+        return this.lastAnalysis;
+    }
+    /**
+     * Get dependency graph
+     */
+    getDependencyGraph() {
+        return this.dependencyGraph;
+    }
+    /**
+     * Find all classes implementing a specific interface/extending a class
+     */
+    findImplementations(baseClass) {
+        if (!this.lastAnalysis)
+            return [];
+        const implementations = [];
+        for (const file of this.lastAnalysis.files) {
+            for (const cls of file.classes) {
+                if (cls.extends === baseClass ||
+                    cls.implements.includes(baseClass) ||
+                    cls.mixins.includes(baseClass)) {
+                    implementations.push(cls);
+                }
+            }
+        }
+        return implementations;
+    }
+    /**
+     * Find all usages of a class/function
+     */
+    findUsages(symbol) {
+        const usages = [];
+        const libPath = path.join(this.projectPath, 'lib');
+        const dartFiles = this.findDartFilesSync(libPath);
+        const symbolRegex = new RegExp(`\\b${symbol}\\b`, 'g');
+        for (const filePath of dartFiles) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (symbolRegex.test(lines[i])) {
+                    usages.push({
+                        file: path.relative(this.projectPath, filePath),
+                        line: i + 1,
+                        context: lines[i].trim()
+                    });
+                }
+                symbolRegex.lastIndex = 0;
+            }
+        }
+        return usages;
+    }
+    /**
+     * Start watching for file changes
+     */
+    startWatching() {
+        if (this.fileWatcher)
+            return;
+        const libPath = path.join(this.projectPath, 'lib');
+        this.fileWatcher = fs.watch(libPath, { recursive: true }, (eventType, filename) => {
+            if (filename && filename.endsWith('.dart')) {
+                this.emit('fileChange', { eventType, filename });
+                this.invalidateCache(filename);
+            }
+        });
+        this.emit('status', 'File watching started');
+    }
+    /**
+     * Stop watching for file changes
+     */
+    stopWatching() {
+        if (this.fileWatcher) {
+            this.fileWatcher.close();
+            this.fileWatcher = null;
+            this.emit('status', 'File watching stopped');
+        }
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - FILE SCANNING
+    // ==========================================================================
+    async scanDartFiles() {
+        const libPath = path.join(this.projectPath, 'lib');
+        const testPath = path.join(this.projectPath, 'test');
+        const files = [];
+        if (fs.existsSync(libPath)) {
+            files.push(...this.findDartFilesSync(libPath));
+        }
+        if (fs.existsSync(testPath)) {
+            files.push(...this.findDartFilesSync(testPath));
+        }
+        return files;
+    }
+    findDartFilesSync(dir) {
+        const files = [];
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Skip hidden directories and common non-source directories
+                    if (!entry.name.startsWith('.') &&
+                        entry.name !== 'build' &&
+                        entry.name !== '.dart_tool') {
+                        files.push(...this.findDartFilesSync(fullPath));
+                    }
+                }
+                else if (entry.isFile() && entry.name.endsWith('.dart')) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Ignore permission errors
+        }
+        return files;
+    }
+    // ==========================================================================
+    // PRIVATE METHODS - FILE PARSING
+    // ==========================================================================
+    async parseAllFiles(filePaths) {
+        const parsedFiles = [];
+        for (const filePath of filePaths) {
+            try {
+                const parsed = await this.parseFile(filePath);
+                parsedFiles.push(parsed);
+                this.cache.set(filePath, parsed);
+            }
+            catch (error) {
+                this.emit('warning', `Failed to parse ${filePath}: ${error}`);
+            }
+        }
+        return parsedFiles;
+    }
+    async parseFile(filePath) {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const stats = fs.statSync(filePath);
+        const hash = crypto.createHash('md5').update(content).digest('hex');
+        // Check cache
+        const cached = this.cache.get(filePath);
+        if (cached && cached.hash === hash) {
+            return cached;
+        }
+        const lines = content.split('\n');
+        // V15.1: Use extracted DartParser for all parsing operations
+        return {
+            path: filePath,
+            relativePath: path.relative(this.projectPath, filePath),
+            hash,
+            size: stats.size,
+            imports: DartParser.parseImports(lines),
+            exports: DartParser.parseExports(lines),
+            classes: DartParser.parseClasses(content, lines),
+            functions: DartParser.parseFunctions(content, lines),
+            mixins: DartParser.parseMixins(content, lines),
+            extensions: DartParser.parseExtensions(content, lines),
+            enums: DartParser.parseEnums(content, lines),
+            typeAliases: DartParser.parseTypeAliases(lines),
+            globalVariables: DartParser.parseGlobalVariables(lines),
+            annotations: DartParser.parseAnnotations(content),
+            lastModified: stats.mtime
+        };
+    }
+    // V15.1: Parsing methods moved to DartParser.ts
+    // See: src/analysis/DartParser.ts for parseImports, parseExports, parseClasses, etc.
+    invalidateCache(filename) {
+        for (const [key] of this.cache) {
+            if (key.includes(filename)) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    // ==========================================================================
+    // DEPENDENCY GRAPH BUILDING
+    // ==========================================================================
+    buildDependencyGraph(files) {
+        const nodes = new Map();
+        const edges = [];
+        // Initialize nodes
+        for (const file of files) {
+            nodes.set(file.relativePath, {
+                file: file.relativePath,
+                imports: [],
+                importedBy: [],
+                exports: [],
+                depth: 0,
+                isEntryPoint: false,
+                isLeaf: true
+            });
+        }
+        // Build edges
+        for (const file of files) {
+            const node = nodes.get(file.relativePath);
+            for (const imp of file.imports) {
+                const resolvedPath = this.resolveImportPath(file.relativePath, imp.package);
+                if (resolvedPath && nodes.has(resolvedPath)) {
+                    node.imports.push(resolvedPath);
+                    nodes.get(resolvedPath).importedBy.push(file.relativePath);
+                    edges.push({ from: file.relativePath, to: resolvedPath, type: 'import' });
+                }
+            }
+            for (const exp of file.exports) {
+                const resolvedPath = this.resolveImportPath(file.relativePath, exp.path);
+                if (resolvedPath && nodes.has(resolvedPath)) {
+                    node.exports.push(resolvedPath);
+                    edges.push({ from: file.relativePath, to: resolvedPath, type: 'export' });
+                }
+            }
+        }
+        // Identify entry points and leaf nodes
+        const entryPoints = [];
+        const leafNodes = [];
+        for (const [path, node] of nodes) {
+            if (node.importedBy.length === 0 && !path.includes('_test.dart')) {
+                entryPoints.push(path);
+                node.isEntryPoint = true;
+            }
+            if (node.imports.length === 0) {
+                leafNodes.push(path);
+                node.isLeaf = true;
+            }
+            else {
+                node.isLeaf = false;
+            }
+        }
+        // Calculate depths
+        const visited = new Set();
+        const calculateDepth = (nodePath, depth) => {
+            if (visited.has(nodePath))
+                return;
+            visited.add(nodePath);
+            const node = nodes.get(nodePath);
+            node.depth = Math.max(node.depth, depth);
+            for (const imp of node.imports) {
+                calculateDepth(imp, depth + 1);
+            }
+        };
+        for (const entryPoint of entryPoints) {
+            visited.clear();
+            calculateDepth(entryPoint, 0);
+        }
+        // Detect cycles
+        const cycles = this.detectCycles(nodes);
+        // Build layers
+        const layers = new Map();
+        for (const [path, node] of nodes) {
+            if (!layers.has(node.depth)) {
+                layers.set(node.depth, []);
+            }
+            layers.get(node.depth).push(path);
+        }
+        return {
+            nodes,
+            edges,
+            entryPoints,
+            leafNodes,
+            cycles,
+            layers
+        };
+    }
+    resolveImportPath(currentFile, importPath) {
+        if (importPath.startsWith('dart:') || importPath.startsWith('package:')) {
+            // External package or dart SDK
+            const packageMatch = importPath.match(/package:([^\/]+)\//);
+            if (packageMatch) {
+                const packageName = packageMatch[1];
+                const pubspec = this.getPubspecName();
+                if (packageName === pubspec) {
+                    return 'lib/' + importPath.replace(`package:${packageName}/`, '');
+                }
+            }
+            return null;
+        }
+        // Relative import
+        const currentDir = path.dirname(currentFile);
+        return path.normalize(path.join(currentDir, importPath));
+    }
+    getPubspecName() {
+        try {
+            const pubspecPath = path.join(this.projectPath, 'pubspec.yaml');
+            const content = fs.readFileSync(pubspecPath, 'utf-8');
+            const nameMatch = content.match(/^name:\s*(\S+)/m);
+            return nameMatch ? nameMatch[1] : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    detectCycles(nodes) {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        const dfs = (nodePath) => {
+            visited.add(nodePath);
+            recursionStack.add(nodePath);
+            path.push(nodePath);
+            const node = nodes.get(nodePath);
+            if (node) {
+                for (const imp of node.imports) {
+                    if (!visited.has(imp)) {
+                        dfs(imp);
+                    }
+                    else if (recursionStack.has(imp)) {
+                        // Found cycle
+                        const cycleStart = path.indexOf(imp);
+                        if (cycleStart !== -1) {
+                            cycles.push([...path.slice(cycleStart), imp]);
+                        }
+                    }
+                }
+            }
+            path.pop();
+            recursionStack.delete(nodePath);
+        };
+        for (const nodePath of nodes.keys()) {
+            if (!visited.has(nodePath)) {
+                dfs(nodePath);
+            }
+        }
+        return cycles;
+    }
+    // ==========================================================================
+    // STATE MANAGEMENT ANALYSIS
+    // ==========================================================================
+    analyzeStateManagement(files) {
+        const evidence = [];
+        const typeCounts = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file.path, 'utf-8');
+            const lines = content.split('\n');
+            for (const [type, patterns] of Object.entries(this.STATE_PATTERNS)) {
+                if (type === StateManagementType.MIXED || type === StateManagementType.UNKNOWN) {
+                    continue;
+                }
+                for (const pattern of patterns) {
+                    for (let i = 0; i < lines.length; i++) {
+                        if (pattern.test(lines[i])) {
+                            evidence.push({
+                                type: type,
+                                file: file.relativePath,
+                                line: i + 1,
+                                pattern: lines[i].trim(),
+                                confidence: this.calculateStateConfidence(type, lines[i])
+                            });
+                            typeCounts.set(type, (typeCounts.get(type) || 0) + 1);
+                        }
+                        pattern.lastIndex = 0;
+                    }
+                }
+            }
+        }
+        // Determine primary state management
+        let primary = StateManagementType.UNKNOWN;
+        let maxCount = 0;
+        const detected = [];
+        for (const [type, count] of typeCounts) {
+            if (count > 0) {
+                detected.push(type);
+                if (count > maxCount) {
+                    maxCount = count;
+                    primary = type;
+                }
+            }
+        }
+        if (detected.length > 1) {
+            primary = StateManagementType.MIXED;
+        }
+        else if (detected.length === 0) {
+            // Check for vanilla setState
+            const setStateCount = evidence.filter(e => e.type === StateManagementType.VANILLA).length;
+            if (setStateCount > 0) {
+                primary = StateManagementType.VANILLA;
+                detected.push(StateManagementType.VANILLA);
+            }
+        }
+        const confidence = detected.length > 0
+            ? Math.min(100, (maxCount / files.length) * 100 + 50)
+            : 0;
+        return {
+            primary,
+            detected,
+            confidence,
+            evidence: evidence.slice(0, 50), // Limit evidence
+            recommendations: this.generateStateRecommendations(primary, detected)
+        };
+    }
+    calculateStateConfidence(type, line) {
+        // Higher confidence for imports and key patterns
+        if (line.includes('import'))
+            return 95;
+        if (line.includes('Provider') || line.includes('Notifier'))
+            return 90;
+        if (line.includes('extends'))
+            return 85;
+        return 70;
+    }
+    generateStateRecommendations(primary, detected) {
+        const recommendations = [];
+        if (primary === StateManagementType.MIXED && detected.length > 1) {
+            recommendations.push('Consider consolidating to a single state management solution');
+            recommendations.push(`Most used: ${detected[0]}, consider migrating others`);
+        }
+        if (primary === StateManagementType.VANILLA) {
+            recommendations.push('Consider adopting a state management solution for better scalability');
+            recommendations.push('Riverpod or BLoC are recommended for larger applications');
+        }
+        if (detected.includes(StateManagementType.PROVIDER)) {
+            recommendations.push('Consider migrating from Provider to Riverpod for better compile-time safety');
+        }
+        return recommendations;
+    }
+    // ==========================================================================
+    // ARCHITECTURE ANALYSIS
+    // ==========================================================================
+    analyzeArchitecture(files) {
+        const scores = new Map();
+        for (const [pattern, indicators] of Object.entries(this.ARCHITECTURE_INDICATORS)) {
+            let score = 0;
+            for (const file of files) {
+                // Check directory patterns
+                for (const dirPattern of indicators.directories) {
+                    if (dirPattern.test(file.relativePath)) {
+                        score += 10;
+                    }
+                }
+                // Check file naming patterns
+                for (const filePattern of indicators.files) {
+                    if (filePattern.test(file.relativePath)) {
+                        score += 5;
+                    }
+                }
+                // Check imports
+                for (const imp of file.imports) {
+                    for (const importPattern of indicators.imports) {
+                        if (importPattern.test(imp.statement)) {
+                            score += 15;
+                        }
+                    }
+                }
+            }
+            scores.set(pattern, score);
+        }
+        // Determine primary pattern
+        let maxScore = 0;
+        let detectedPattern = ArchitecturePattern.UNKNOWN;
+        for (const [pattern, score] of scores) {
+            if (score > maxScore) {
+                maxScore = score;
+                detectedPattern = pattern;
+            }
+        }
+        // If no clear pattern, check for monolithic
+        if (maxScore < 30) {
+            detectedPattern = ArchitecturePattern.MONOLITHIC;
+        }
+        const confidence = Math.min(100, maxScore * 2);
+        return {
+            pattern: detectedPattern,
+            confidence,
+            layers: this.detectLayers(files, detectedPattern),
+            violations: this.detectViolations(files, detectedPattern),
+            suggestions: this.generateArchitectureSuggestions(detectedPattern, files.length)
+        };
+    }
+    detectLayers(files, pattern) {
+        const layers = [];
+        if (pattern === ArchitecturePattern.CLEAN) {
+            layers.push({ name: 'Domain', directories: ['domain'], dependencies: [], files: [] }, { name: 'Data', directories: ['data'], dependencies: ['Domain'], files: [] }, { name: 'Presentation', directories: ['presentation'], dependencies: ['Domain'], files: [] });
+        }
+        else if (pattern === ArchitecturePattern.MVVM) {
+            layers.push({ name: 'Models', directories: ['models'], dependencies: [], files: [] }, { name: 'ViewModels', directories: ['viewmodels'], dependencies: ['Models'], files: [] }, { name: 'Views', directories: ['views'], dependencies: ['ViewModels'], files: [] });
+        }
+        // Populate files
+        for (const layer of layers) {
+            for (const file of files) {
+                for (const dir of layer.directories) {
+                    if (file.relativePath.includes(`/${dir}/`)) {
+                        layer.files.push(file.relativePath);
+                    }
+                }
+            }
+        }
+        return layers;
+    }
+    detectViolations(files, pattern) {
+        const violations = [];
+        if (pattern === ArchitecturePattern.CLEAN) {
+            // Check for domain importing from data/presentation
+            for (const file of files) {
+                if (file.relativePath.includes('/domain/')) {
+                    for (const imp of file.imports) {
+                        if (imp.package.includes('/data/') || imp.package.includes('/presentation/')) {
+                            violations.push({
+                                type: 'dependency',
+                                severity: 'critical',
+                                message: `Domain layer should not depend on ${imp.package.includes('/data/') ? 'Data' : 'Presentation'} layer`,
+                                file: file.relativePath,
+                                line: imp.line,
+                                suggestion: 'Move the dependency to an interface in the domain layer'
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return violations;
+    }
+    generateArchitectureSuggestions(pattern, fileCount) {
+        const suggestions = [];
+        if (pattern === ArchitecturePattern.MONOLITHIC && fileCount > 20) {
+            suggestions.push('Consider adopting Clean Architecture for better maintainability');
+            suggestions.push('Separate concerns into domain, data, and presentation layers');
+        }
+        if (pattern === ArchitecturePattern.UNKNOWN) {
+            suggestions.push('Establish a clear architecture pattern for the project');
+            suggestions.push('Recommended: Clean Architecture or Feature-First for Flutter projects');
+        }
+        return suggestions;
+    }
+    // ==========================================================================
+    // METRICS CALCULATION
+    // ==========================================================================
+    calculateMetrics(files) {
+        let totalLines = 0;
+        let totalClasses = 0;
+        let totalFunctions = 0;
+        let totalComplexity = 0;
+        let maxComplexity = 0;
+        let documentedItems = 0;
+        let totalItems = 0;
+        for (const file of files) {
+            const content = fs.readFileSync(file.path, 'utf-8');
+            totalLines += content.split('\n').length;
+            totalClasses += file.classes.length;
+            totalFunctions += file.functions.length;
+            for (const cls of file.classes) {
+                totalComplexity += cls.complexity;
+                maxComplexity = Math.max(maxComplexity, cls.complexity);
+                totalItems++;
+                if (cls.documentation)
+                    documentedItems++;
+                for (const method of cls.methods) {
+                    totalComplexity += method.complexity;
+                    maxComplexity = Math.max(maxComplexity, method.complexity);
+                    totalItems++;
+                    if (method.documentation)
+                        documentedItems++;
+                }
+            }
+            for (const func of file.functions) {
+                totalComplexity += func.complexity;
+                maxComplexity = Math.max(maxComplexity, func.complexity);
+                totalItems++;
+                if (func.documentation)
+                    documentedItems++;
+            }
+        }
+        const methodCount = files.reduce((sum, f) => sum + f.classes.reduce((s, c) => s + c.methods.length, 0), 0);
+        const averageComplexity = methodCount > 0 ? totalComplexity / methodCount : 0;
+        const documentationCoverage = totalItems > 0
+            ? (documentedItems / totalItems) * 100
+            : 0;
+        const testFiles = files.filter(f => f.relativePath.includes('_test.dart'));
+        const testCoverage = files.length > 0
+            ? (testFiles.length / (files.length - testFiles.length)) * 100
+            : 0;
+        return {
+            totalFiles: files.length,
+            totalLines,
+            totalClasses,
+            totalFunctions,
+            averageComplexity: Math.round(averageComplexity * 100) / 100,
+            maxComplexity,
+            testCoverage: Math.round(Math.min(100, testCoverage) * 100) / 100,
+            documentationCoverage: Math.round(documentationCoverage * 100) / 100,
+            technicalDebt: this.calculateTechnicalDebt(files, averageComplexity, documentationCoverage),
+            codeQuality: this.calculateCodeQuality(files, averageComplexity, documentationCoverage, testCoverage)
+        };
+    }
+    calculateTechnicalDebt(files, avgComplexity, docCoverage) {
+        const issues = [];
+        let totalHours = 0;
+        for (const file of files) {
+            // High complexity
+            for (const cls of file.classes) {
+                if (cls.complexity > 20) {
+                    const hours = (cls.complexity - 20) * 0.5;
+                    totalHours += hours;
+                    issues.push({
+                        type: 'complexity',
+                        severity: cls.complexity > 50 ? 'high' : 'medium',
+                        file: file.relativePath,
+                        message: `Class ${cls.name} has cyclomatic complexity of ${cls.complexity}`,
+                        estimatedHours: hours
+                    });
+                }
+                for (const method of cls.methods) {
+                    if (method.complexity > 10) {
+                        const hours = (method.complexity - 10) * 0.3;
+                        totalHours += hours;
+                        issues.push({
+                            type: 'complexity',
+                            severity: method.complexity > 20 ? 'high' : 'medium',
+                            file: file.relativePath,
+                            message: `Method ${method.name} has cyclomatic complexity of ${method.complexity}`,
+                            estimatedHours: hours
+                        });
+                    }
+                }
+            }
+            // Missing documentation
+            if (file.classes.some(c => !c.documentation) && file.classes.length > 0) {
+                const undocumented = file.classes.filter(c => !c.documentation).length;
+                const hours = undocumented * 0.25;
+                totalHours += hours;
+                issues.push({
+                    type: 'documentation',
+                    severity: 'low',
+                    file: file.relativePath,
+                    message: `${undocumented} classes without documentation`,
+                    estimatedHours: hours
+                });
+            }
+        }
+        // Calculate debt score (0-100, lower is better)
+        const complexityScore = Math.min(50, avgComplexity * 5);
+        const docScore = Math.max(0, 50 - docCoverage / 2);
+        const score = Math.min(100, complexityScore + docScore);
+        return {
+            score: Math.round(score),
+            hours: Math.round(totalHours),
+            issues: issues.slice(0, 20) // Limit to top 20 issues
+        };
+    }
+    calculateCodeQuality(files, avgComplexity, docCoverage, testCoverage) {
+        const maintainability = Math.max(0, 100 - avgComplexity * 3);
+        const reliability = Math.min(100, testCoverage);
+        const security = 85; // Base score, would need security analysis
+        const performance = Math.max(0, 100 - avgComplexity * 2);
+        const testability = Math.max(0, 100 - avgComplexity * 2);
+        const overall = (maintainability + reliability + security + performance + testability) / 5;
+        return {
+            overall: Math.round(overall),
+            maintainability: Math.round(maintainability),
+            reliability: Math.round(reliability),
+            security,
+            performance: Math.round(performance),
+            testability: Math.round(testability)
+        };
+    }
+    // ==========================================================================
+    // ISSUE DETECTION & SUGGESTIONS
+    // ==========================================================================
+    detectIssues(files, graph) {
+        const issues = [];
+        // Circular dependencies
+        for (const cycle of graph.cycles) {
+            issues.push({
+                severity: 'error',
+                code: 'CIRCULAR_DEPENDENCY',
+                message: `Circular dependency detected: ${cycle.join(' -> ')}`,
+                file: cycle[0],
+                suggestion: 'Break the cycle by extracting shared code to a new module'
+            });
+        }
+        // Large files
+        for (const file of files) {
+            const content = fs.readFileSync(file.path, 'utf-8');
+            const lines = content.split('\n').length;
+            if (lines > 500) {
+                issues.push({
+                    severity: 'warning',
+                    code: 'LARGE_FILE',
+                    message: `File has ${lines} lines, consider splitting`,
+                    file: file.relativePath,
+                    suggestion: 'Split into smaller, focused modules'
+                });
+            }
+            // God classes
+            for (const cls of file.classes) {
+                if (cls.methods.length > 20) {
+                    issues.push({
+                        severity: 'warning',
+                        code: 'GOD_CLASS',
+                        message: `Class ${cls.name} has ${cls.methods.length} methods`,
+                        file: file.relativePath,
+                        line: cls.startLine,
+                        suggestion: 'Consider extracting functionality into smaller classes'
+                    });
+                }
+            }
+        }
+        return issues;
+    }
+    generateSuggestions(files, graph, stateManagement, architecture) {
+        const suggestions = [];
+        // High-impact files
+        for (const [path, node] of graph.nodes) {
+            if (node.importedBy.length > 10) {
+                suggestions.push({
+                    type: 'refactor',
+                    priority: 'high',
+                    title: `High-impact file: ${path}`,
+                    description: `This file is imported by ${node.importedBy.length} other files. Changes here have wide impact.`,
+                    files: [path],
+                    estimatedImpact: 'Affects many parts of the application'
+                });
+            }
+        }
+        // Missing tests
+        const testedFiles = new Set(files.filter(f => f.relativePath.includes('_test.dart'))
+            .map(f => f.relativePath.replace('_test.dart', '.dart').replace('test/', 'lib/')));
+        for (const file of files) {
+            if (file.relativePath.startsWith('lib/') && !testedFiles.has(file.relativePath)) {
+                suggestions.push({
+                    type: 'test',
+                    priority: 'medium',
+                    title: `Add tests for ${file.relativePath}`,
+                    description: 'This file has no corresponding test file',
+                    files: [file.relativePath],
+                    estimatedImpact: 'Improves code reliability'
+                });
+            }
+        }
+        return suggestions;
+    }
+}
+export default ProjectAnalyzer;
+//# sourceMappingURL=ProjectAnalyzer.js.map