@silvestv/migration-planificator 3.0.0

package/dist/src/core/project-strategy/nx-strategy.js

@@ -0,0 +1,130 @@
+"use strict";
+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.NxStrategy = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * Stratégie pour projets Nx Monorepo
+ * - Structure apps/ et libs/
+ * - Routines globales séparées des targets apps/libs
+ * - Target "monorepo" pour règles de routine
+ */
+class NxStrategy {
+    getTargetPath(projectInfo, targetName) {
+        // Essayer d'abord apps/, puis libs/
+        const appPath = path.join(projectInfo.path, 'apps', targetName);
+        const libPath = path.join(projectInfo.path, 'libs', targetName);
+        if (fs.existsSync(appPath)) {
+            return appPath;
+        }
+        return libPath;
+    }
+    getTargetType(projectInfo, targetName) {
+        // Si targetName === projectInfo.name ET projet a plusieurs apps/libs → target "monorepo"
+        const hasMultipleTargets = (projectInfo.apps?.length || 0) + (projectInfo.libs?.length || 0) > 1;
+        if (hasMultipleTargets && targetName === projectInfo.name) {
+            return 'monorepo';
+        }
+        // Vérifier dans les apps
+        if (projectInfo.apps?.some(app => app.name === targetName)) {
+            return 'app';
+        }
+        // Vérifier dans les libs
+        if (projectInfo.libs?.some(lib => lib.name === targetName)) {
+            return 'lib';
+        }
+        // Par défaut app
+        return 'app';
+    }
+    extractTargetFromFilePath(filePath, projectInfo) {
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        // Nx monorepo : apps/XXX ou libs/XXX (ou libs/groupe/XXX pour structure groupée)
+        const appsMatch = normalizedPath.match(/^apps\/([^\/]+)/);
+        if (appsMatch)
+            return appsMatch[1];
+        // Support libs groupées : libs/apis/git-platform → "apis/git-platform"
+        const libsMatch = normalizedPath.match(/^libs\/(.*?)(?:\/|$)/);
+        if (libsMatch) {
+            // Extraire tout le chemin après libs/ jusqu'au premier fichier
+            const fullLibPath = normalizedPath.substring(5); // Enlever "libs/"
+            // Trouver la lib complète en cherchant dans projectInfo.libs
+            const matchingLib = projectInfo.libs?.find(lib => fullLibPath.startsWith(lib.name));
+            if (matchingLib) {
+                return matchingLib.name; // Ex: "apis/git-platform"
+            }
+            // Fallback : prendre premier segment (ancien comportement)
+            return libsMatch[1];
+        }
+        // Si le chemin ne correspond pas à apps/ ou libs/, c'est un fichier global (ex: package.json)
+        // Pour Nx monorepo, ces règles de routine vont dans le target "monorepo" (nom du projet)
+        return projectInfo.name;
+    }
+    shouldFilterRoutinesFromTarget(targetName, projectInfo) {
+        // Nx avec plusieurs targets : filtrer routines des apps/libs normaux
+        // Les routines vont dans le target "monorepo"
+        const hasMultipleTargets = (projectInfo.apps?.length || 0) + (projectInfo.libs?.length || 0) > 1;
+        const isMonorepoTarget = hasMultipleTargets && targetName === projectInfo.name;
+        // Filtrer routines pour apps/libs normaux, PAS pour target monorepo
+        return hasMultipleTargets && !isMonorepoTarget;
+    }
+    shouldDisplayMonorepoTarget(target) {
+        // Ne pas afficher target MONOREPO s'il contient SEULEMENT des routines
+        if (target.targetType !== 'monorepo') {
+            return true; // Toujours afficher apps/libs normaux
+        }
+        // Vérifier si target monorepo contient des règles non-routine
+        for (const migration of target.migrations) {
+            for (const priority of migration.priorities) {
+                for (const rule of priority.rules) {
+                    if (rule.type !== 'routine') {
+                        return true; // A au moins une règle non-routine
+                    }
+                }
+            }
+        }
+        // Target monorepo ne contient QUE des routines → ne pas afficher
+        return false;
+    }
+    getTargetsList(projectInfo) {
+        const apps = projectInfo.apps || [];
+        const libs = projectInfo.libs || [];
+        return [...apps, ...libs];
+    }
+    isMultiTarget(projectInfo) {
+        return ((projectInfo.apps?.length || 0) + (projectInfo.libs?.length || 0)) > 1;
+    }
+}
+exports.NxStrategy = NxStrategy;

package/dist/src/core/project-strategy/project-strategy.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/project-strategy/standalone-strategy.js

@@ -0,0 +1,74 @@
+"use strict";
+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.StandaloneStrategy = void 0;
+const path = __importStar(require("path"));
+/**
+ * Stratégie pour projets Angular Standalone
+ * - Structure src/ unique
+ * - Pas de séparation apps/libs
+ * - Routines intégrées au target principal
+ */
+class StandaloneStrategy {
+    getTargetPath(projectInfo, targetName) {
+        // Projet standalone : toujours src/
+        return path.join(projectInfo.path, 'src');
+    }
+    getTargetType(projectInfo, targetName) {
+        // Projet standalone : toujours 'app'
+        return 'app';
+    }
+    extractTargetFromFilePath(filePath, projectInfo) {
+        // Projet standalone : tout va dans le projet principal
+        return projectInfo.name;
+    }
+    shouldFilterRoutinesFromTarget(targetName, projectInfo) {
+        // Standalone : pas de filtrage, routines incluses dans le target principal
+        return false;
+    }
+    shouldDisplayMonorepoTarget(target) {
+        // Standalone : pas de target monorepo, N/A
+        return true;
+    }
+    getTargetsList(projectInfo) {
+        // Standalone : un seul target (le projet lui-même)
+        return projectInfo.apps || [{ name: projectInfo.name }];
+    }
+    isMultiTarget(projectInfo) {
+        // Standalone : toujours false
+        return false;
+    }
+}
+exports.StandaloneStrategy = StandaloneStrategy;

package/dist/src/core/project-strategy/strategy-factory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectStrategy = createProjectStrategy;
+const nx_strategy_1 = require("./nx-strategy");
+const standalone_strategy_1 = require("./standalone-strategy");
+/**
+ * Factory pour créer la stratégie appropriée selon le type de projet
+ */
+function createProjectStrategy(projectInfo) {
+    if (projectInfo.type === 'nx-monorepo') {
+        return new nx_strategy_1.NxStrategy();
+    }
+    // 'angular-standalone' ou 'unknown' → Stratégie standalone par défaut
+    return new standalone_strategy_1.StandaloneStrategy();
+}

package/dist/src/core/rules-loader.js

@@ -0,0 +1,89 @@
+"use strict";
+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.loadMigrationRules = loadMigrationRules;
+exports.getRulesForMigration = getRulesForMigration;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("../utils/core");
+/**
+ * Charge les règles de migration depuis la nouvelle architecture
+ * Lit tous les fichiers JSON dans src/data/rules/to{18,19,20}/
+ */
+function loadMigrationRules() {
+    const rulesDir = path.join(__dirname, '..', 'data', 'rules');
+    if (!fs.existsSync(rulesDir)) {
+        throw new Error(`Répertoire des règles introuvable: ${rulesDir}`);
+    }
+    const migrations = {
+        'to18': { obligatoire: [], recommande: [], optionnelle: [] },
+        'to19': { obligatoire: [], recommande: [], optionnelle: [] },
+        'to20': { obligatoire: [], recommande: [], optionnelle: [] }
+    };
+    // Charger les règles pour chaque migration
+    const migrationDirs = ['to18', 'to19', 'to20'];
+    for (const dir of migrationDirs) {
+        const migrationDir = path.join(rulesDir, dir);
+        if (!fs.existsSync(migrationDir))
+            continue;
+        // Charger chaque fichier de priorité
+        for (const priority of ['obligatoire', 'recommande', 'optionnelle']) {
+            const filename = `rules-${dir.replace('to', '')}-${priority}.json`;
+            const filePath = path.join(migrationDir, filename);
+            if (fs.existsSync(filePath)) {
+                try {
+                    const rules = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                    migrations[dir][priority] = rules;
+                }
+                catch (error) {
+                    core_1.logger.warning(`Erreur lors du chargement de ${filePath}: ${error}`);
+                }
+            }
+        }
+    }
+    return migrations;
+}
+/**
+ * Charge les règles pour une migration spécifique (17→18, 18→19, 19→20)
+ */
+function getRulesForMigration(migration) {
+    const allRules = loadMigrationRules();
+    const migrationRules = allRules[migration];
+    return [
+        ...migrationRules.obligatoire,
+        ...migrationRules.recommande,
+        ...migrationRules.optionnelle
+    ];
+}

package/dist/src/core/scan-reporter.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logScanStart = logScanStart;
+exports.logTargetStart = logTargetStart;
+exports.logTargetComplete = logTargetComplete;
+exports.logScanProgress = logScanProgress;
+exports.logMethodStats = logMethodStats;
+exports.logWorkloadReport = logWorkloadReport;
+exports.logTopRules = logTopRules;
+exports.logScanComplete = logScanComplete;
+exports.logScannerInfo = logScannerInfo;
+exports.logSpecialRulesInfo = logSpecialRulesInfo;
+exports.logFilesDetected = logFilesDetected;
+const core_1 = require("../utils/core");
+const core_2 = require("../utils/core");
+const project_strategy_1 = require("./project-strategy");
+/**
+ * Reporter centralisé pour afficher la progression et les résultats du scan
+ */
+/**
+ * Affiche la bannière de démarrage du scan
+ */
+function logScanStart(projectInfo, scannerType, rules) {
+    core_1.logger.blank();
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.info('         ANGULAR MIGRATION PLANIFICATOR');
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.blank();
+    core_1.logger.step(`Analyse du projet: ${projectInfo.name}`);
+    core_1.logger.info(`Scanner: ${scannerType.toUpperCase()}`);
+    core_1.logger.success(`Projet détecté: ${projectInfo.name}`);
+    core_1.logger.info(`Type: ${projectInfo.type}`);
+    if (projectInfo.angularVersion) {
+        core_1.logger.info(`Version Angular: ${projectInfo.angularVersion}`);
+    }
+    if (projectInfo.apps && projectInfo.apps.length > 0) {
+        const appNames = projectInfo.apps.map(a => a.name).join(', ');
+        core_1.logger.info(`Applications: ${projectInfo.apps.length} (${appNames})`);
+    }
+    if (projectInfo.libs && projectInfo.libs.length > 0) {
+        const libCount = projectInfo.libs.length;
+        const libNames = projectInfo.libs.slice(0, 3).join(', ');
+        const moreText = libCount > 3 ? `, +${libCount - 3}` : '';
+        core_1.logger.info(`Librairies: ${libCount} (${libNames}${moreText})`);
+    }
+    core_1.logger.blank();
+    // Info sur les règles chargées
+    const migrations = new Set(rules.map(r => {
+        if (r.key.includes('_18_'))
+            return 'to18';
+        if (r.key.includes('_19_'))
+            return 'to19';
+        if (r.key.includes('_20_'))
+            return 'to20';
+        return 'unknown';
+    }));
+    const migrationList = Array.from(migrations).filter(m => m !== 'unknown').map(m => m.replace('to', '')).join(', ');
+    core_1.logger.step(`Chargement des règles (${migrationList})...`);
+    core_1.logger.success(`${rules.length} règles chargées`);
+}
+/**
+ * Affiche le début du scan d'un target
+ */
+function logTargetStart(targetName, targetType) {
+    core_1.logger.blank();
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.info(`         SCAN: ${targetName.toUpperCase()} (${targetType})`);
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.blank();
+}
+/**
+ * Affiche la fin du scan d'un target avec statistiques
+ */
+function logTargetComplete(targetName, matches, duration) {
+    const uniqueRules = new Set(matches.map(m => m.ruleKey)).size;
+    const durationText = duration ? ` en ${(duration / 1000).toFixed(2)}s` : '';
+    core_1.logger.blank();
+    core_1.logger.success(`Target ${targetName}: ${matches.length} occurrences (${uniqueRules} règles actives)${durationText}`);
+}
+/**
+ * Affiche la progression du scan AST par batch
+ */
+function logScanProgress(current, total, message) {
+    const progress = Math.round((current / total) * 100);
+    const spinner = getSpinner(current);
+    const extraMsg = message ? ` - ${message}` : '';
+    core_1.logger.debug(`  Progression: ${progress}% (${current}/${total})${extraMsg} ${spinner}`);
+}
+/**
+ * Affiche les statistiques de détection par méthode (AST vs Regex)
+ */
+function logMethodStats(astCount, regexCount, astRulesCount, regexRulesCount) {
+    const total = astCount + regexCount;
+    const astPercent = total > 0 ? ((astCount / total) * 100).toFixed(1) : '0.0';
+    const regexPercent = total > 0 ? ((regexCount / total) * 100).toFixed(1) : '0.0';
+    core_1.logger.blank();
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.info('         RAPPORT DE DÉTECTION PAR MÉTHODE');
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.blank();
+    core_1.logger.info(`Total occurrences: ${total}`);
+    core_1.logger.info(`  • AST:   ${astCount} (${astPercent}%)`);
+    core_1.logger.info(`  • Regex: ${regexCount} (${regexPercent}%)`);
+    core_1.logger.blank();
+    core_1.logger.info(`Règles actives: ${astRulesCount + regexRulesCount}`);
+    core_1.logger.info(`  • Avec AST:       ${astRulesCount}`);
+    core_1.logger.info(`  • Regex fallback: ${regexRulesCount}`);
+    core_1.logger.blank();
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+}
+/**
+ * Affiche le rapport hiérarchique de charge de travail
+ */
+function logWorkloadReport(report) {
+    core_1.logger.blank();
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.info('         RAPPORT DE CHARGE DE TRAVAIL');
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.blank();
+    core_1.logger.info(`📊 Charge totale estimée: ${(0, core_2.formatWorkloadTime)(report.totalTime)}`);
+    // Créer la stratégie pour déterminer l'affichage
+    const strategy = (0, project_strategy_1.createProjectStrategy)(report.projectInfo);
+    const isMultiTarget = strategy.isMultiTarget(report.projectInfo);
+    // Afficher résumé des routines pour monorepo multi-target
+    if (isMultiTarget && report.stats.totalRoutineRules > 0) {
+        const routineRules = collectRoutineRules(report);
+        if (routineRules.length > 0) {
+            core_1.logger.blank();
+            core_1.logger.info(`🔧 Règles de routine (${routineRules.length}) - Tâches globales monorepo:`);
+            for (const routine of routineRules) {
+                const timeStr = (0, core_2.formatWorkloadTime)(routine.totalTime).padEnd(15);
+                core_1.logger.debug(`   • [ROUTINE] ${timeStr} → ${routine.ruleSummary}`);
+            }
+        }
+    }
+    core_1.logger.blank();
+    for (const target of report.targets) {
+        // Pour multi-target (Nx) : skip l'affichage des targets qui ne doivent pas être affichés
+        if (isMultiTarget && !strategy.shouldDisplayMonorepoTarget(target)) {
+            continue;
+        }
+        let targetIcon;
+        if (target.targetType === 'app') {
+            targetIcon = '📦 APP';
+        }
+        else if (target.targetType === 'lib') {
+            targetIcon = '📚 LIB';
+        }
+        else {
+            targetIcon = '🏗️  MONOREPO';
+        }
+        core_1.logger.info(`${targetIcon}: ${target.targetName} (${(0, core_2.formatWorkloadTime)(target.totalTime)})`);
+        core_1.logger.blank();
+        for (const migration of target.migrations) {
+            core_1.logger.info(`   🔄 ${migration.migration.toUpperCase()} (${(0, core_2.formatWorkloadTime)(migration.totalTime)})`);
+            for (const priority of migration.priorities) {
+                const priorityIcon = getPriorityIcon(priority.priority);
+                const rulesCount = priority.rules.length;
+                core_1.logger.info(`      ${priorityIcon} ${priority.priority.toUpperCase()} (${(0, core_2.formatWorkloadTime)(priority.totalTime)}) - ${rulesCount} règles`);
+                // Afficher top 5 règles par priorité
+                const topRules = priority.rules.slice(0, 5);
+                for (const rule of topRules) {
+                    let displayStr;
+                    if (rule.type === 'routine') {
+                        // Règle de routine : charge unique
+                        const timeStr = (0, core_2.formatWorkloadTime)(rule.totalTime).padEnd(15);
+                        displayStr = `[ROUTINE] 1 × ${timeStr} → ${rule.ruleSummary}`;
+                    }
+                    else if (rule.type === 'combined') {
+                        // Règle combinée : AST + fichiers
+                        const timeStr = (0, core_2.formatWorkloadTime)(rule.totalTime).padEnd(15);
+                        if (rule.specialWorkloadFiles === 0) {
+                            // Cas spécial : règle avec special_workload mais 0 fichiers trouvés
+                            const countStr = `${rule.baseOccurrences}`.padStart(3);
+                            displayStr = `[SPECIAL] ${countStr} × ${timeStr} → ${rule.ruleSummary}`;
+                        }
+                        else {
+                            displayStr = `[SPECIAL] ${rule.baseOccurrences} occ. + ${rule.specialWorkloadFiles} fichiers = ${timeStr} → ${rule.ruleSummary}`;
+                        }
+                    }
+                    else if (rule.type === 'special') {
+                        // Règle special seulement (pas d'occurrences AST)
+                        const timeStr = (0, core_2.formatWorkloadTime)(rule.totalTime).padEnd(15);
+                        displayStr = `[SPECIAL] ${rule.specialWorkloadFiles} fichiers × ${timeStr} → ${rule.ruleSummary}`;
+                    }
+                    else {
+                        // Règle standard (AST/Regex)
+                        const countStr = `${rule.occurrences}`.padStart(3);
+                        const timeStr = (0, core_2.formatWorkloadTime)(rule.totalTime).padEnd(15);
+                        displayStr = `${countStr} × ${timeStr} → ${rule.ruleSummary}`;
+                    }
+                    core_1.logger.debug(`         ${displayStr}`);
+                }
+                if (priority.rules.length > 5) {
+                    core_1.logger.debug(`         ... et ${priority.rules.length - 5} règles supplémentaires`);
+                }
+                core_1.logger.blank();
+            }
+        }
+    }
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+}
+/**
+ * Affiche le top N des règles les plus fréquentes
+ */
+function logTopRules(matches, topN = 10) {
+    if (matches.length === 0) {
+        return;
+    }
+    core_1.logger.blank();
+    core_1.logger.step(`Top ${topN} règles les plus fréquentes:`);
+    const ruleCount = new Map();
+    for (const match of matches) {
+        const existing = ruleCount.get(match.ruleKey);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            ruleCount.set(match.ruleKey, { summary: match.ruleSummary, count: 1 });
+        }
+    }
+    const topRules = Array.from(ruleCount.entries())
+        .sort((a, b) => b[1].count - a[1].count)
+        .slice(0, topN);
+    for (const [index, [ruleKey, data]] of topRules.entries()) {
+        core_1.logger.debug(`  ${index + 1}. ${data.summary}: ${data.count} occurrences`);
+    }
+}
+/**
+ * Affiche la fin du scan global avec statistiques enrichies
+ */
+function logScanComplete(totalDuration, totalMatches, routineCount, specialWorkloadFilesCount) {
+    core_1.logger.blank();
+    if (totalDuration) {
+        core_1.logger.success(`Analyse terminée en ${(totalDuration / 1000).toFixed(2)}s`);
+    }
+    else {
+        core_1.logger.success('Analyse terminée');
+    }
+    if (totalMatches !== undefined) {
+        core_1.logger.success(`  • Occurrences détectées (AST/Regex): ${totalMatches}`);
+    }
+    if (specialWorkloadFilesCount && specialWorkloadFilesCount > 0) {
+        core_1.logger.success(`  • Fichiers comptés (special_workload): ${specialWorkloadFilesCount}`);
+    }
+    if (routineCount && routineCount > 0) {
+        core_1.logger.success(`  • Tâches de routine identifiées: ${routineCount}`);
+    }
+    core_1.logger.blank();
+}
+/**
+ * Affiche les informations sur le scanner utilisé
+ */
+function logScannerInfo(astRulesCount, regexRulesCount) {
+    core_1.logger.info(`Scanner: ${astRulesCount} règles AST, ${regexRulesCount} règles Regex (fallback)`);
+}
+/**
+ * Affiche les compteurs de règles spéciales (special_workload et routines)
+ */
+function logSpecialRulesInfo(specialWorkloadCount, routineCount) {
+    if (specialWorkloadCount > 0) {
+        core_1.logger.info(`📦 ${specialWorkloadCount} règle(s) avec special_workload détectée(s)`);
+    }
+    if (routineCount > 0) {
+        core_1.logger.info(`🔧 ${routineCount} règle(s) de routine détectée(s)`);
+    }
+}
+/**
+ * Affiche les fichiers détectés
+ */
+function logFilesDetected(fileType, count) {
+    core_1.logger.info(`Fichiers ${fileType}: ${count} détectés`);
+}
+/**
+ * Retourne l'icône correspondant à une priorité
+ */
+function getPriorityIcon(priority) {
+    switch (priority) {
+        case 'obligatoire':
+            return '🔴';
+        case 'recommande':
+            return '🟡';
+        case 'optionnelle':
+            return '🟢';
+        default:
+            return '⚪';
+    }
+}
+/**
+ * Retourne un caractère de spinner pour animer la progression
+ */
+function getSpinner(step) {
+    const spinners = ['⣷', '⣯', '⣟', '⡿', '⢿', '⣻', '⣽', '⣾'];
+    return spinners[step % spinners.length];
+}
+/**
+ * Collecte toutes les règles de routine depuis le rapport (parcours hiérarchique)
+ */
+function collectRoutineRules(report) {
+    const routineRules = [];
+    for (const target of report.targets) {
+        for (const migration of target.migrations) {
+            for (const priority of migration.priorities) {
+                for (const rule of priority.rules) {
+                    if (rule.type === 'routine') {
+                        routineRules.push({
+                            ruleSummary: rule.ruleSummary,
+                            totalTime: rule.totalTime
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return routineRules;
+}