@sun-asterisk/sunlint 1.3.34 → 1.3.35

package/engines/arch-detect/core/analyzer.js

@@ -0,0 +1,413 @@
+"use strict";
+/**
+ * Architecture Analyzer
+ * Core orchestrator cho việc phân tích kiến trúc project
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchitectureAnalyzer = void 0;
+const path = __importStar(require("node:path"));
+const hybrid_detector_1 = require("../engine/hybrid-detector");
+const rule_executor_1 = require("../engine/rule-executor");
+const violation_detector_1 = require("../engine/violation-detector");
+const rule_registry_1 = require("../rules/rule-registry");
+const types_1 = require("../types");
+const enums_1 = require("../types/enums");
+const file_scanner_1 = require("../utils/file-scanner");
+// Import all rules to register them
+require("../rules/project-scanner");
+require("../rules/layered");
+require("../rules/modular");
+require("../rules/presentation");
+class ArchitectureAnalyzer {
+    constructor(options = {}) {
+        this.ruleExecutor = new rule_executor_1.RuleExecutor();
+        this.hybridDetector = new hybrid_detector_1.HybridDetector();
+        this.violationDetector = new violation_detector_1.ViolationDetector();
+        // Merge options với default config
+        this.config = {
+            ...types_1.DEFAULT_CONFIG,
+            scanner: {
+                ...types_1.DEFAULT_CONFIG.scanner,
+                respectGitignore: options.respectGitignore ?? types_1.DEFAULT_CONFIG.scanner.respectGitignore,
+            },
+            analyzer: {
+                ...types_1.DEFAULT_CONFIG.analyzer,
+                patterns: options.patterns || types_1.DEFAULT_CONFIG.analyzer.patterns,
+            },
+        };
+    }
+    /**
+     * Analyze một project
+     */
+    async analyze(projectPath) {
+        const startTime = Date.now();
+        const absolutePath = path.resolve(projectPath);
+        console.log(`\n🔍 Analyzing project: ${absolutePath}\n`);
+        // Step 1: Scan project
+        console.log('📁 Scanning project structure...');
+        const scanner = new file_scanner_1.FileScanner({
+            ...this.config.scanner,
+            projectPath: absolutePath,
+        });
+        const scanResult = await scanner.scan();
+        // Collect all directories
+        const directories = this.collectDirectories(scanResult.tree);
+        // Step 2: Build project context
+        const context = {
+            projectPath: absolutePath,
+            files: scanResult.files,
+            directories,
+            directoryTree: scanResult.tree,
+            config: this.config,
+            cache: new Map(),
+            projectInfo: {
+                projectRoot: absolutePath,
+            },
+            helpers: {
+                readFile: async (filePath) => file_scanner_1.FileScanner.readFileContent(filePath),
+                fileExists: (filePath) => file_scanner_1.FileScanner.fileExists(filePath),
+                findFiles: (pattern) => file_scanner_1.FileScanner.findFilesByPattern(scanResult.files, pattern),
+                findFolders: (pattern) => file_scanner_1.FileScanner.findFoldersByPattern(scanResult.tree, pattern),
+                searchInFiles: async (pattern, files) => file_scanner_1.FileScanner.searchInFiles(pattern, files || scanResult.files),
+                getExtension: (filePath) => filePath.split('.').pop() || '',
+                getLanguage: (filePath) => file_scanner_1.FileScanner.getLanguageFromPath(filePath),
+            },
+        };
+        console.log(`   Found ${context.files.length} files in ${directories.length} directories\n`);
+        // Step 3: Execute all pattern rules
+        console.log('🔎 Detecting architecture patterns...\n');
+        const patternResults = await this.ruleExecutor.executeAll(context);
+        // Step 4: Detect hybrid patterns
+        const hybridResult = this.hybridDetector.detectHybrid(patternResults);
+        // Step 5: Detect violations for primary pattern
+        console.log('⚠️  Detecting architecture violations...');
+        const primaryPatternResult = patternResults.find((p) => p.pattern === hybridResult.primaryPattern);
+        const violationAssessment = primaryPatternResult
+            ? this.violationDetector.detectViolations(primaryPatternResult)
+            : undefined;
+        // Step 6: Generate recommendations
+        const recommendations = this.generateRecommendations(patternResults, hybridResult);
+        // Step 7: Build final result
+        const analysisTime = Date.now() - startTime;
+        const result = {
+            projectPath: absolutePath,
+            timestamp: new Date().toISOString(),
+            patterns: patternResults,
+            hybridAnalysis: hybridResult,
+            primaryPattern: hybridResult.primaryPattern,
+            violationAssessment,
+            recommendations,
+            metadata: {
+                totalFiles: context.files.length,
+                totalDirectories: directories.length,
+                analysisTimeMs: analysisTime,
+                rulesExecuted: this.countExecutedRules(patternResults),
+                engineVersion: '1.0.0',
+            },
+        };
+        return result;
+    }
+    /**
+     * Collect all directories from tree
+     */
+    collectDirectories(tree) {
+        const dirs = [tree];
+        for (const sub of tree.subdirectories) {
+            dirs.push(...this.collectDirectories(sub));
+        }
+        return dirs;
+    }
+    /**
+     * Count total rules executed
+     */
+    countExecutedRules(results) {
+        return results.reduce((sum, r) => sum + r.ruleResults.length, 0);
+    }
+    /**
+     * Generate recommendations based on analysis
+     */
+    generateRecommendations(patternResults, hybridResult) {
+        const recommendations = [];
+        // Add hybrid recommendations
+        const hybridRecs = this.hybridDetector.getRecommendation(hybridResult);
+        recommendations.push(...hybridRecs);
+        // Add pattern-specific recommendations
+        for (const result of patternResults) {
+            if (result.suggestions) {
+                recommendations.push(...result.suggestions.slice(0, 3));
+            }
+        }
+        // Remove duplicates
+        return [...new Set(recommendations)];
+    }
+    /**
+     * Format result as text
+     */
+    formatAsText(result) {
+        const lines = [];
+        lines.push('╔══════════════════════════════════════════════════════════════╗');
+        lines.push('║              ARCHITECTURE DETECTION REPORT                    ║');
+        lines.push('╚══════════════════════════════════════════════════════════════╝');
+        lines.push('');
+        lines.push(`📂 Project: ${result.projectPath}`);
+        lines.push(`📅 Analyzed: ${result.timestamp}`);
+        lines.push(`⏱️  Analysis time: ${result.metadata.analysisTimeMs}ms`);
+        lines.push('');
+        // Primary pattern
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        if (result.hybridAnalysis.isHybrid) {
+            lines.push(`🏛️  HYBRID ARCHITECTURE: ${result.hybridAnalysis.combination}`);
+            lines.push(`    Primary: ${result.hybridAnalysis.primaryPattern}`);
+            lines.push(`    Secondary: ${result.hybridAnalysis.secondaryPatterns.join(', ')}`);
+        }
+        else {
+            lines.push(`🏛️  PRIMARY ARCHITECTURE: ${result.primaryPattern}`);
+        }
+        lines.push(`    Confidence: ${(result.hybridAnalysis.confidence * 100).toFixed(1)}%`);
+        lines.push('');
+        // Pattern details
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('PATTERN DETECTION RESULTS:');
+        lines.push('');
+        for (const pattern of result.patterns) {
+            const scorePercent = (pattern.score.normalizedScore * 100).toFixed(1);
+            const bar = this.createProgressBar(pattern.score.normalizedScore, 20);
+            const icon = this.getClassificationIcon(pattern.classification);
+            lines.push(`${icon} ${pattern.pattern.toString().padEnd(15)} ${bar} ${scorePercent}% (${pattern.classification})`);
+            if (pattern.variant) {
+                lines.push(`   └─ Variant: ${pattern.variant}`);
+            }
+        }
+        lines.push('');
+        // Recommendations
+        if (result.recommendations.length > 0) {
+            lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            lines.push('💡 RECOMMENDATIONS:');
+            lines.push('');
+            for (const rec of result.recommendations.slice(0, 5)) {
+                lines.push(`   • ${rec}`);
+            }
+            lines.push('');
+        }
+        // Statistics
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('📊 STATISTICS:');
+        lines.push(`   Files analyzed: ${result.metadata.totalFiles}`);
+        lines.push(`   Directories scanned: ${result.metadata.totalDirectories}`);
+        lines.push(`   Rules executed: ${result.metadata.rulesExecuted}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    /**
+     * Format result as markdown
+     */
+    formatAsMarkdown(result) {
+        const lines = [];
+        const projectName = path.basename(result.projectPath);
+        const analyzedDate = new Date(result.timestamp).toLocaleString('vi-VN');
+        lines.push('# Architecture Detection Report');
+        lines.push('');
+        lines.push(`| | |`);
+        lines.push(`|---|---|`);
+        lines.push(`| **Project** | ${projectName} |`);
+        lines.push(`| **Analyzed** | ${analyzedDate} |`);
+        lines.push(`| **Analysis time** | ${result.metadata.analysisTimeMs}ms |`);
+        lines.push('');
+        // Primary pattern
+        lines.push('## Detected Architecture');
+        lines.push('');
+        if (result.hybridAnalysis.isHybrid) {
+            lines.push(`**Hybrid Architecture:** ${result.hybridAnalysis.combination}`);
+            lines.push(`- Primary: ${result.hybridAnalysis.primaryPattern}`);
+            lines.push(`- Secondary: ${result.hybridAnalysis.secondaryPatterns.join(', ')}`);
+        }
+        else {
+            lines.push(`**Primary Architecture:** ${result.primaryPattern}`);
+        }
+        lines.push(`**Confidence:** ${(result.hybridAnalysis.confidence * 100).toFixed(1)}%`);
+        lines.push('');
+        // Pattern details table
+        lines.push('## Pattern Detection Results');
+        lines.push('');
+        lines.push('| Pattern | Score | Classification | Confidence |');
+        lines.push('|---------|-------|----------------|------------|');
+        for (const pattern of result.patterns) {
+            const scorePercent = (pattern.score.normalizedScore * 100).toFixed(1);
+            const confPercent = (pattern.confidence * 100).toFixed(1);
+            lines.push(`| ${pattern.pattern} | ${scorePercent}% | ${pattern.classification} | ${confPercent}% |`);
+        }
+        lines.push('');
+        // Recommendations
+        if (result.recommendations.length > 0) {
+            lines.push('## Recommendations');
+            lines.push('');
+            for (const rec of result.recommendations) {
+                lines.push(`- ${rec}`);
+            }
+            lines.push('');
+        }
+        // Violation Assessment
+        if (result.violationAssessment && result.violationAssessment.violations.length > 0) {
+            const va = result.violationAssessment;
+            lines.push('## Architecture Health Assessment');
+            lines.push('');
+            lines.push(`**Health Score:** ${this.violationDetector.getHealthIcon(va.healthScore)} ${va.healthScore.toFixed(0)}/100`);
+            lines.push('');
+            lines.push(`**Assessment:** ${va.overallAssessment}`);
+            lines.push('');
+            // Violation summary
+            lines.push('### Violation Summary');
+            lines.push('');
+            lines.push('| Impact | Count |');
+            lines.push('|--------|-------|');
+            if (va.summary.critical > 0)
+                lines.push(`| 🔴 Critical | ${va.summary.critical} |`);
+            if (va.summary.high > 0)
+                lines.push(`| 🟠 High | ${va.summary.high} |`);
+            if (va.summary.medium > 0)
+                lines.push(`| 🟡 Medium | ${va.summary.medium} |`);
+            if (va.summary.low > 0)
+                lines.push(`| 🟢 Low | ${va.summary.low} |`);
+            lines.push(`| **Total** | **${va.summary.total}** |`);
+            lines.push('');
+            // Violation details
+            lines.push('### Violation Details');
+            lines.push('');
+            for (const violation of va.violations) {
+                const icon = this.violationDetector.getImpactIcon(violation.impact);
+                lines.push(`#### ${icon} ${violation.ruleName}`);
+                lines.push('');
+                lines.push(`| Attribute | Value |`);
+                lines.push(`|-----------|-------|`);
+                lines.push(`| **Impact Level** | ${violation.impact} |`);
+                lines.push(`| **Score** | ${violation.description.match(/\d+%/)?.[0] || 'N/A'} |`);
+                lines.push(`| **Type** | ${violation.type} |`);
+                lines.push('');
+                lines.push(`**Problem:** ${violation.impactReason}`);
+                lines.push('');
+                // Affected Files - SPECIFIC to this project
+                if (violation.affectedFiles && violation.affectedFiles.length > 0) {
+                    lines.push('**📁 Affected Files trong project này:**');
+                    lines.push('```');
+                    for (const file of violation.affectedFiles) {
+                        lines.push(file);
+                    }
+                    lines.push('```');
+                    lines.push('');
+                }
+                // Examples found - SPECIFIC to this project
+                if (violation.examples && violation.examples.length > 0) {
+                    lines.push('**📍 Ví dụ cụ thể tìm thấy:**');
+                    lines.push('```');
+                    for (const example of violation.examples) {
+                        lines.push(example);
+                    }
+                    lines.push('```');
+                    lines.push('');
+                }
+                lines.push('**⚠️ Hậu quả nếu không fix:**');
+                for (const consequence of violation.consequences) {
+                    lines.push(`- ${consequence}`);
+                }
+                lines.push('');
+                lines.push(`**✅ Cách fix:** ${violation.suggestedFix}`);
+                lines.push('');
+                lines.push('---');
+                lines.push('');
+            }
+        }
+        else {
+            lines.push('## Architecture Health Assessment');
+            lines.push('');
+            lines.push('💚 **Health Score:** 100/100');
+            lines.push('');
+            lines.push('**No violations detected.** The architecture follows best practices.');
+            lines.push('');
+        }
+        // Statistics
+        lines.push('## Statistics');
+        lines.push('');
+        lines.push(`- Files analyzed: ${result.metadata.totalFiles}`);
+        lines.push(`- Directories scanned: ${result.metadata.totalDirectories}`);
+        lines.push(`- Rules executed: ${result.metadata.rulesExecuted}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    /**
+     * Create progress bar
+     */
+    createProgressBar(value, width) {
+        const filled = Math.round(value * width);
+        const empty = width - filled;
+        return '█'.repeat(filled) + '░'.repeat(empty);
+    }
+    /**
+     * Get icon for classification
+     */
+    getClassificationIcon(classification) {
+        switch (classification) {
+            case enums_1.PatternClassification.STRONG_MATCH:
+                return '✅';
+            case enums_1.PatternClassification.DETECTED:
+                return '🟢';
+            case enums_1.PatternClassification.POSSIBLE:
+                return '🟡';
+            case enums_1.PatternClassification.WEAK_SIGNAL:
+                return '🟠';
+            default:
+                return '⚪';
+        }
+    }
+    /**
+     * Get registered rules count
+     */
+    getRegisteredRulesCount() {
+        return rule_registry_1.ruleRegistry.getAllRules().length;
+    }
+    /**
+     * List all registered rules
+     */
+    listRegisteredRules() {
+        return rule_registry_1.ruleRegistry.getAllRules().map((rule) => ({
+            id: rule.id,
+            name: rule.name,
+            pattern: rule.applicableTo,
+        }));
+    }
+}
+exports.ArchitectureAnalyzer = ArchitectureAnalyzer;
+exports.default = ArchitectureAnalyzer;
+//# sourceMappingURL=analyzer.js.map

package/engines/arch-detect/core/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Core Index
+ * Export core components
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./analyzer"), exports);
+//# sourceMappingURL=index.js.map

package/engines/arch-detect/engine/hybrid-detector.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Hybrid Detector
+ * Phát hiện hybrid patterns (kết hợp nhiều patterns)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridDetector = void 0;
+const enums_1 = require("../types/enums");
+/**
+ * Common hybrid combinations
+ */
+const HYBRID_COMBINATIONS = [
+    {
+        combination: 'LAYERED+MODULAR',
+        patterns: [enums_1.PatternType.LAYERED, enums_1.PatternType.MODULAR],
+        description: 'Layered architecture with modular organization (e.g., NestJS, Angular)',
+    },
+    {
+        combination: 'MODULAR+MVVM',
+        patterns: [enums_1.PatternType.MODULAR, enums_1.PatternType.MVVM],
+        description: 'Feature modules with MVVM pattern per module',
+    },
+    {
+        combination: 'LAYERED+MVVM',
+        patterns: [enums_1.PatternType.LAYERED, enums_1.PatternType.MVVM],
+        description: 'Layered architecture with MVVM presentation (e.g., Android apps)',
+    },
+    {
+        combination: 'MODULAR+VIPER',
+        patterns: [enums_1.PatternType.MODULAR, enums_1.PatternType.VIPER],
+        description: 'Feature modules with VIPER pattern per module (iOS)',
+    },
+];
+class HybridDetector {
+    /**
+     * Detect hybrid patterns từ multiple pattern results
+     */
+    detectHybrid(results) {
+        // Get detected patterns (above threshold)
+        const detectedPatterns = results.filter((r) => r.classification === enums_1.PatternClassification.STRONG_MATCH ||
+            r.classification === enums_1.PatternClassification.DETECTED);
+        if (detectedPatterns.length <= 1) {
+            // Not a hybrid
+            const primary = this.getPrimaryPattern(results);
+            return {
+                isHybrid: false,
+                primaryPattern: primary?.pattern || enums_1.PatternType.LAYERED,
+                secondaryPatterns: [],
+                combination: primary?.pattern.toString() || 'UNKNOWN',
+                analysis: primary
+                    ? `Single pattern detected: ${primary.pattern} with ${(primary.score.normalizedScore * 100).toFixed(1)}% match`
+                    : 'No clear pattern detected',
+                confidence: primary?.confidence || 0,
+            };
+        }
+        // Sort by score
+        const sorted = [...detectedPatterns].sort((a, b) => b.score.normalizedScore - a.score.normalizedScore);
+        const primary = sorted[0];
+        const secondary = sorted.slice(1);
+        // Check for known hybrid combinations
+        const detectedTypes = sorted.map((r) => r.pattern);
+        const matchedCombination = this.findMatchingCombination(detectedTypes);
+        // Build combination string
+        const combinationStr = sorted.map((r) => r.pattern).join('+');
+        // Calculate hybrid confidence
+        const confidence = this.calculateHybridConfidence(sorted);
+        // Generate analysis
+        const analysis = this.generateAnalysis(sorted, matchedCombination);
+        return {
+            isHybrid: true,
+            primaryPattern: primary.pattern,
+            secondaryPatterns: secondary.map((r) => r.pattern),
+            combination: matchedCombination?.combination || combinationStr,
+            analysis,
+            confidence,
+        };
+    }
+    /**
+     * Get primary pattern from results
+     */
+    getPrimaryPattern(results) {
+        if (results.length === 0)
+            return null;
+        // Sort by score and return highest
+        const sorted = [...results].sort((a, b) => b.score.normalizedScore - a.score.normalizedScore);
+        // Only return if above weak signal threshold
+        if (sorted[0].score.normalizedScore >= 0.2) {
+            return sorted[0];
+        }
+        return null;
+    }
+    /**
+     * Find matching known hybrid combination
+     */
+    findMatchingCombination(patterns) {
+        for (const combo of HYBRID_COMBINATIONS) {
+            const matched = combo.patterns.every((p) => patterns.includes(p));
+            if (matched) {
+                return combo;
+            }
+        }
+        return null;
+    }
+    /**
+     * Calculate hybrid confidence
+     */
+    calculateHybridConfidence(sortedResults) {
+        if (sortedResults.length < 2)
+            return 0;
+        // Base confidence from pattern scores
+        let confidence = sortedResults.reduce((sum, r) => sum + r.confidence, 0) / sortedResults.length;
+        // Boost if patterns complement each other
+        const primary = sortedResults[0].pattern;
+        const secondary = sortedResults[1].pattern;
+        // Layered + Modular is a common and valid combination
+        if ((primary === enums_1.PatternType.LAYERED && secondary === enums_1.PatternType.MODULAR) ||
+            (primary === enums_1.PatternType.MODULAR && secondary === enums_1.PatternType.LAYERED)) {
+            confidence += 0.1;
+        }
+        // Presentation + Layered is common in client apps
+        if ((primary === enums_1.PatternType.MVVM || primary === enums_1.PatternType.VIPER) &&
+            secondary === enums_1.PatternType.LAYERED) {
+            confidence += 0.1;
+        }
+        return Math.min(confidence, 1);
+    }
+    /**
+     * Generate analysis text
+     */
+    generateAnalysis(sortedResults, matchedCombination) {
+        const parts = [];
+        if (matchedCombination) {
+            parts.push(matchedCombination.description);
+        }
+        parts.push('Detected patterns:');
+        for (const result of sortedResults) {
+            const scorePercent = (result.score.normalizedScore * 100).toFixed(1);
+            parts.push(`- ${result.pattern}: ${scorePercent}% (${result.classification})`);
+        }
+        // Add primary pattern analysis
+        const primary = sortedResults[0];
+        parts.push(`\nPrimary architecture: ${primary.pattern}`);
+        if (primary.variant) {
+            parts.push(`Variant: ${primary.variant}`);
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Get recommendation for hybrid architecture
+     */
+    getRecommendation(hybridResult) {
+        const recommendations = [];
+        if (!hybridResult.isHybrid) {
+            recommendations.push('Consider if a hybrid approach might better suit your needs');
+            return recommendations;
+        }
+        // Recommendations based on combination
+        if (hybridResult.combination.includes('LAYERED') &&
+            hybridResult.combination.includes('MODULAR')) {
+            recommendations.push('Ensure module boundaries are respected to maintain modularity');
+            recommendations.push('Consider using barrel files (index.ts) for module public APIs');
+        }
+        if (hybridResult.combination.includes('MVVM')) {
+            recommendations.push('Ensure ViewModels do not depend on View implementations');
+            recommendations.push('Use data binding consistently across the application');
+        }
+        if (hybridResult.combination.includes('VIPER')) {
+            recommendations.push('Ensure each VIPER module has all 5 components');
+            recommendations.push('Router should be the only component handling navigation');
+        }
+        return recommendations;
+    }
+}
+exports.HybridDetector = HybridDetector;
+exports.default = HybridDetector;
+//# sourceMappingURL=hybrid-detector.js.map

package/engines/arch-detect/engine/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Engine Index
+ * Export tất cả engine components
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hybrid-detector"), exports);
+__exportStar(require("./rule-executor"), exports);
+__exportStar(require("./score-calculator"), exports);
+//# sourceMappingURL=index.js.map