@silvestv/migration-planificator 3.0.0

package/dist/src/core/scanner-regex.js

@@ -0,0 +1,298 @@
+"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.scanDirectory = scanDirectory;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const core_1 = require("../utils/core");
+const core_2 = require("../utils/core");
+/**
+ * Vérifie si le projet est un monorepo Nx
+ * @param projectRoot Racine du projet
+ * @returns true si le projet a un fichier nx.json
+ */
+function isNxProject(projectRoot) {
+    const nxJsonPath = path.join(projectRoot, 'nx.json');
+    return fs.existsSync(nxJsonPath);
+}
+/**
+ * Exécute une commande système et retourne sa sortie
+ * @param command Commande à exécuter (ex: "node -v")
+ * @returns Sortie de la commande ou null en cas d'erreur
+ */
+function executeCommand(command) {
+    try {
+        const output = (0, child_process_1.execSync)(command, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        return output.trim();
+    }
+    catch (error) {
+        core_2.logger.warning(`Échec exécution commande: ${command}`);
+        return null;
+    }
+}
+/**
+ * Scan les règles de routine basées sur commande système (routineCmd)
+ * @param rules Règles avec routineCmd défini
+ * @param projectRoot Racine du projet (pour chemins relatifs)
+ * @returns Liste des matches trouvés
+ */
+function scanRoutineCommands(rules, projectRoot) {
+    const matches = [];
+    for (const rule of rules) {
+        if (!rule.routineCmd || !rule.regex) {
+            continue;
+        }
+        const commandOutput = executeCommand(rule.routineCmd);
+        if (commandOutput === null) {
+            continue;
+        }
+        // Tester la sortie avec la regex de la règle
+        const compiledRegex = new RegExp(rule.regex, 'g');
+        const match = compiledRegex.exec(commandOutput);
+        if (match) {
+            // Match trouvé = règle pertinente (action nécessaire)
+            matches.push({
+                ruleKey: rule.key,
+                ruleSummary: rule.summary,
+                filePath: '<system>',
+                lineNumber: 1,
+                matchedText: commandOutput
+            });
+        }
+    }
+    return matches;
+}
+/**
+ * Scan un répertoire et applique les règles de migration
+ * @param targetDir Répertoire à scanner (app ou lib)
+ * @param rules Règles de migration à appliquer
+ * @param projectRoot Racine du projet (pour chemins relatifs)
+ * @returns Liste des occurrences trouvées
+ */
+function scanDirectory(targetDir, rules, projectRoot) {
+    const matches = [];
+    // Scanner les fichiers spécifiques (onFile: ex. package.json)
+    // PRIORITÉ 1 : Chercher onFile à la racine du projet
+    // PRIORITÉ 2 : Si pas trouvé ET onFileNx existe ET projet Nx → Chercher onFileNx
+    // PRIORITÉ 3 : Fallback targetDir (fichiers custom par app/lib)
+    for (const rule of rules.filter(r => r.onFile)) {
+        let targetFile = null;
+        // 1. Chercher onFile à la racine du projet
+        const rootFilePath = path.join(projectRoot, rule.onFile);
+        if (fs.existsSync(rootFilePath)) {
+            targetFile = rootFilePath;
+        }
+        // 2. Si pas trouvé ET onFileNx existe ET projet Nx → Chercher onFileNx
+        else if (rule.onFileNx && isNxProject(projectRoot)) {
+            const nxFilePath = path.join(projectRoot, rule.onFileNx);
+            if (fs.existsSync(nxFilePath)) {
+                targetFile = nxFilePath;
+            }
+        }
+        // 3. Fallback : chercher dans targetDir (pour fichiers spécifiques à l'app/lib)
+        if (!targetFile) {
+            const targetFilePath = path.join(targetDir, rule.onFile);
+            if (fs.existsSync(targetFilePath)) {
+                targetFile = targetFilePath;
+            }
+        }
+        // Scanner le fichier trouvé si règle a une regex
+        if (targetFile && rule.regex) {
+            matches.push(...applyRule(targetFile, rule, projectRoot));
+        }
+    }
+    // Grouper les règles par fileType pattern (ex. *.ts → [règle1, règle2])
+    const fileTypePatternToRules = new Map();
+    const compiledFileTypePatterns = new Map();
+    for (const rule of rules.filter(r => !r.onFile)) {
+        for (const fileTypePattern of rule.fileTypes) {
+            // Grouper les règles
+            if (!fileTypePatternToRules.has(fileTypePattern)) {
+                fileTypePatternToRules.set(fileTypePattern, []);
+                // Compiler le pattern une seule fois
+                // IMPORTANT: Échapper les points AVANT de convertir les étoiles
+                const regexPattern = '^' + fileTypePattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$';
+                compiledFileTypePatterns.set(fileTypePattern, new RegExp(regexPattern));
+            }
+            fileTypePatternToRules.get(fileTypePattern).push(rule);
+        }
+    }
+    // Scanner récursivement uniquement les fichiers qui matchent
+    if (fileTypePatternToRules.size > 0) {
+        scanRecursively(targetDir, fileTypePatternToRules, compiledFileTypePatterns, projectRoot, matches);
+    }
+    return matches;
+}
+/**
+ * Scan récursif des fichiers selon les patterns
+ * @param currentDir Répertoire en cours de scan
+ * @param fileTypePatternToRules Map des fileType patterns vers leurs règles
+ * @param compiledFileTypePatterns Map des patterns vers leurs regex compilées
+ * @param projectRoot Racine du projet
+ * @param matches Accumulateur de résultats (mutated)
+ */
+function scanRecursively(currentDir, fileTypePatternToRules, compiledFileTypePatterns, projectRoot, matches) {
+    try {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (!(0, core_1.shouldIgnoreDir)(entry.name)) {
+                    scanRecursively(fullPath, fileTypePatternToRules, compiledFileTypePatterns, projectRoot, matches);
+                }
+            }
+            else if (entry.isFile()) {
+                // Trouver les règles applicables pour ce fichier (dédupliquées)
+                const applicableRules = new Set();
+                for (const [fileTypePattern, rulesForPattern] of fileTypePatternToRules) {
+                    const compiledPattern = compiledFileTypePatterns.get(fileTypePattern);
+                    if (compiledPattern.test(entry.name)) {
+                        rulesForPattern.forEach(r => applicableRules.add(r));
+                    }
+                }
+                // Scanner uniquement si au moins une règle s'applique
+                if (applicableRules.size > 0) {
+                    matches.push(...applyRules(fullPath, Array.from(applicableRules), projectRoot));
+                }
+            }
+        }
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        core_2.logger.warning(`Impossible de lire: ${currentDir} - ${errorMsg}`);
+    }
+}
+/**
+ * Détecte si une regex nécessite un contexte multiligne
+ * Patterns détectés : [\s\S], [\S\s], \n, \r
+ */
+function needsMultilineContext(regexPattern) {
+    return regexPattern.includes('[\\s\\S]') ||
+        regexPattern.includes('[\\S\\s]') ||
+        regexPattern.includes('\\n') ||
+        regexPattern.includes('\\r');
+}
+/**
+ * Trouve le numéro de ligne d'un match dans le contenu
+ */
+function findLineNumber(content, matchIndex) {
+    const textBeforeMatch = content.substring(0, matchIndex);
+    return textBeforeMatch.split('\n').length;
+}
+/**
+ * Applique plusieurs règles à un fichier (une seule lecture)
+ * @param filePath Chemin complet du fichier
+ * @param rules Règles de migration à appliquer
+ * @param projectRoot Racine du projet (pour chemin relatif)
+ */
+function applyRules(filePath, rules, projectRoot) {
+    const matches = [];
+    // Séparer les règles selon leur type (ligne unique vs multiligne)
+    const singleLineRules = [];
+    const multilineRules = [];
+    for (const rule of rules) {
+        if (rule.regex) {
+            const compiledRegex = new RegExp(rule.regex, 'g');
+            const ruleWithRegex = { rule, regex: compiledRegex };
+            if (needsMultilineContext(rule.regex)) {
+                multilineRules.push(ruleWithRegex);
+            }
+            else {
+                singleLineRules.push(ruleWithRegex);
+            }
+        }
+    }
+    if (singleLineRules.length === 0 && multilineRules.length === 0) {
+        return matches;
+    }
+    try {
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        const relativeFilePath = path.relative(projectRoot, filePath);
+        // ÉTAPE 1 : Appliquer les règles multilignes sur le fichier entier
+        for (const { rule, regex } of multilineRules) {
+            regex.lastIndex = 0;
+            let match;
+            while ((match = regex.exec(fileContent)) !== null) {
+                const lineNumber = findLineNumber(fileContent, match.index);
+                matches.push({
+                    ruleKey: rule.key,
+                    ruleSummary: rule.summary,
+                    filePath: relativeFilePath,
+                    lineNumber,
+                    matchedText: match[0].trim()
+                });
+            }
+        }
+        // ÉTAPE 2 : Appliquer les règles simples ligne par ligne
+        if (singleLineRules.length > 0) {
+            const fileLines = fileContent.split('\n');
+            for (let lineIndex = 0; lineIndex < fileLines.length; lineIndex++) {
+                const currentLine = fileLines[lineIndex];
+                for (const { rule, regex } of singleLineRules) {
+                    regex.lastIndex = 0;
+                    const lineMatches = currentLine.match(regex);
+                    if (lineMatches) {
+                        for (const match of lineMatches) {
+                            matches.push({
+                                ruleKey: rule.key,
+                                ruleSummary: rule.summary,
+                                filePath: relativeFilePath,
+                                lineNumber: lineIndex + 1,
+                                matchedText: match.trim()
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        core_2.logger.warning(`Impossible de lire: ${filePath}`);
+    }
+    return matches;
+}
+/**
+ * Applique une règle regex à un fichier (pour onFile)
+ * @param filePath Chemin complet du fichier
+ * @param rule Règle de migration à appliquer
+ * @param projectRoot Racine du projet (pour chemin relatif)
+ */
+function applyRule(filePath, rule, projectRoot) {
+    return applyRules(filePath, [rule], projectRoot);
+}

package/dist/src/core/workload/calculator.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorkloadReport = calculateWorkloadReport;
+const workload_formatter_1 = require("../../utils/core/workload-formatter");
+const rule_helpers_1 = require("../../utils/core/rule-helpers");
+const metadata_1 = require("./metadata");
+const grouping_1 = require("./grouping");
+const hierarchy_calculator_1 = require("./hierarchy-calculator");
+const rules_loader_1 = require("../rules-loader");
+const project_strategy_1 = require("../project-strategy");
+/**
+ * Calcule le rapport complet de charge de travail hiérarchique
+ */
+function calculateWorkloadReport(projectInfo, matches, rules) {
+    // Créer maps pour accès rapide O(1)
+    const ruleMap = (0, rule_helpers_1.createRuleMap)(rules);
+    const migrationRules = (0, rules_loader_1.loadMigrationRules)();
+    const { ruleMigrationMap, rulePriorityMap } = (0, metadata_1.createRuleMetadataMaps)(migrationRules);
+    // Grouper matches par target (app/lib)
+    const matchesByTarget = (0, grouping_1.groupMatchesByTarget)(matches, projectInfo);
+    // Créer la stratégie appropriée
+    const strategy = (0, project_strategy_1.createProjectStrategy)(projectInfo);
+    // Calculer charge pour chaque target + stats globales en 1 seul parcours
+    const targets = [];
+    let globalTotalMinutes = 0;
+    // Stats globales (calculées en même temps)
+    let totalOccurrences = 0;
+    let totalSpecialWorkloadFiles = 0;
+    let totalRoutineRules = 0;
+    const uniqueRulesSet = new Set();
+    // Calculer charge pour chaque target (app/lib/monorepo)
+    for (const [targetName, targetMatches] of matchesByTarget) {
+        // Déterminer le type de target via la stratégie
+        const targetType = strategy.getTargetType(projectInfo, targetName);
+        // Filtrer les routines selon la stratégie
+        const shouldFilterRoutines = strategy.shouldFilterRoutinesFromTarget(targetName, projectInfo);
+        const filteredMatches = shouldFilterRoutines
+            ? targetMatches.filter(match => {
+                const rule = ruleMap.get(match.ruleKey);
+                return rule && !(0, rule_helpers_1.isRoutineRule)(rule);
+            })
+            : targetMatches;
+        const migrations = (0, hierarchy_calculator_1.calculateMigrationsForTarget)(filteredMatches, ruleMap, ruleMigrationMap, rulePriorityMap, targetName, projectInfo, rules, false // includeRoutines toujours false (routines viennent des matches ou de target MONOREPO)
+        );
+        const targetTotalMinutes = migrations.reduce((sum, m) => sum + m.totalTime.minutes, 0);
+        targets.push({
+            targetName,
+            targetType,
+            totalTime: (0, workload_formatter_1.convertMinutesToWorkloadTime)(targetTotalMinutes),
+            migrations
+        });
+        // Calculer stats en parcourant migrations
+        for (const migration of migrations) {
+            for (const priority of migration.priorities) {
+                for (const rule of priority.rules) {
+                    uniqueRulesSet.add(rule.ruleKey);
+                    if (rule.type === 'routine') {
+                        totalRoutineRules++;
+                    }
+                    else {
+                        totalOccurrences += rule.occurrences;
+                    }
+                    if (rule.specialWorkloadFiles) {
+                        totalSpecialWorkloadFiles += rule.specialWorkloadFiles;
+                    }
+                }
+            }
+        }
+        globalTotalMinutes += targetTotalMinutes;
+    }
+    return {
+        totalTime: (0, workload_formatter_1.convertMinutesToWorkloadTime)(globalTotalMinutes),
+        projectInfo,
+        targets,
+        stats: {
+            totalOccurrences,
+            totalSpecialWorkloadFiles,
+            totalRoutineRules,
+            uniqueRules: uniqueRulesSet.size
+        }
+    };
+}

package/dist/src/core/workload/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIORITY_ORDER = exports.MIGRATION_ORDER = void 0;
+/**
+ * Ordre d'affichage des migrations (to18 → to19 → to20)
+ */
+exports.MIGRATION_ORDER = ['to18', 'to19', 'to20'];
+/**
+ * Ordre d'affichage des priorités (obligatoire → recommandé → optionnel)
+ */
+exports.PRIORITY_ORDER = [
+    'obligatoire',
+    'recommande',
+    'optionnelle'
+];

package/dist/src/core/workload/grouping.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupMatchesByTarget = groupMatchesByTarget;
+exports.groupMatchesByRule = groupMatchesByRule;
+const array_helpers_1 = require("../../utils/core/array-helpers");
+const target_resolver_1 = require("./target-resolver");
+/**
+ * Groupe les matches par target (app ou lib) via filePath
+ */
+function groupMatchesByTarget(matches, projectInfo) {
+    return (0, array_helpers_1.groupBy)(matches, match => (0, target_resolver_1.extractTargetFromFilePath)(match.filePath, projectInfo));
+}
+/**
+ * Groupe les matches par ruleKey
+ */
+function groupMatchesByRule(matches) {
+    return (0, array_helpers_1.groupBy)(matches, match => match.ruleKey);
+}

package/dist/src/core/workload/hierarchy-calculator.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMigrationsForTarget = calculateMigrationsForTarget;
+const workload_formatter_1 = require("../../utils/core/workload-formatter");
+const logger_1 = require("../../utils/core/logger");
+const rule_helpers_1 = require("../../utils/core/rule-helpers");
+const grouping_1 = require("./grouping");
+const target_resolver_1 = require("./target-resolver");
+const special_workload_1 = require("./special-workload");
+const constants_1 = require("./constants");
+/**
+ * Calcule les migrations pour une target donnée
+ */
+function calculateMigrationsForTarget(matches, ruleMap, ruleMigrationMap, rulePriorityMap, targetName, projectInfo, allRules, includeRoutines) {
+    const matchesByMigration = new Map();
+    for (const match of matches) {
+        const migration = ruleMigrationMap.get(match.ruleKey) || 'unknown';
+        if (!matchesByMigration.has(migration)) {
+            matchesByMigration.set(migration, []);
+        }
+        matchesByMigration.get(migration).push(match);
+    }
+    const migrations = [];
+    for (const migration of constants_1.MIGRATION_ORDER) {
+        const migrationMatches = matchesByMigration.get(migration);
+        if (!migrationMatches || migrationMatches.length === 0)
+            continue;
+        const priorities = calculatePrioritiesForMigration(migrationMatches, ruleMap, rulePriorityMap, targetName, projectInfo, allRules, includeRoutines, migration, ruleMigrationMap);
+        const totalMinutes = priorities.reduce((sum, p) => sum + p.totalTime.minutes, 0);
+        migrations.push({
+            migration,
+            totalTime: (0, workload_formatter_1.convertMinutesToWorkloadTime)(totalMinutes),
+            priorities
+        });
+    }
+    return migrations;
+}
+/**
+ * Calcule les priorités pour une migration donnée
+ */
+function calculatePrioritiesForMigration(matches, ruleMap, rulePriorityMap, targetName, projectInfo, allRules, includeRoutines, currentMigration, ruleMigrationMap) {
+    const matchesByPriority = new Map();
+    for (const match of matches) {
+        const priority = rulePriorityMap.get(match.ruleKey) || 'optionnelle';
+        if (!matchesByPriority.has(priority)) {
+            matchesByPriority.set(priority, []);
+        }
+        matchesByPriority.get(priority).push(match);
+    }
+    const priorities = [];
+    for (const priority of constants_1.PRIORITY_ORDER) {
+        const priorityMatches = matchesByPriority.get(priority);
+        if (!priorityMatches || priorityMatches.length === 0)
+            continue;
+        const rules = calculateRulesForPriority(priorityMatches, ruleMap, targetName, projectInfo, allRules, includeRoutines, currentMigration, priority, ruleMigrationMap, rulePriorityMap);
+        const totalMinutes = rules.reduce((sum, r) => sum + r.totalTime.minutes, 0);
+        priorities.push({
+            priority,
+            totalTime: (0, workload_formatter_1.convertMinutesToWorkloadTime)(totalMinutes),
+            rules
+        });
+    }
+    return priorities;
+}
+/**
+ * Calcule les règles pour une priorité donnée (standard + special + routine)
+ */
+function calculateRulesForPriority(matches, ruleMap, targetName, projectInfo, allRules, includeRoutines, currentMigration, currentPriority, ruleMigrationMap, rulePriorityMap) {
+    const matchesByRule = (0, grouping_1.groupMatchesByRule)(matches);
+    const rules = [];
+    // Traiter toutes les règles avec matches (standard + special + routine)
+    // Les routines sont maintenant détectées automatiquement via leur match dans le scanner
+    for (const [ruleKey, ruleMatches] of matchesByRule) {
+        const rule = ruleMap.get(ruleKey);
+        if (!rule)
+            continue;
+        const ruleWorkload = calculateRuleWorkload(rule, ruleMatches, targetName, projectInfo);
+        rules.push(ruleWorkload);
+    }
+    return rules.sort((a, b) => b.totalTime.minutes - a.totalTime.minutes);
+}
+/**
+ * Calcule la charge pour une règle unique (avec support special_workload et routine)
+ */
+function calculateRuleWorkload(rule, matches, targetName, projectInfo) {
+    const occurrences = matches.length;
+    let totalMinutes = occurrences * rule.estimated_time_per_occurrence;
+    let type = 'standard';
+    let specialWorkloadFiles;
+    let baseOccurrences;
+    // Détecter si c'est une routine (règle avec onFile)
+    if ((0, rule_helpers_1.isRoutineRule)(rule)) {
+        type = 'routine';
+        // Pour les routines, occurrences = 1 (tâche unique par projet)
+        totalMinutes = rule.estimated_time_per_occurrence;
+        logger_1.logger.debug(`   🔧 Routine [${rule.key}]: 1 × ${rule.estimated_time_per_occurrence}min (tâche unique)`);
+    }
+    // Support special_workload
+    else if (rule.special_workload) {
+        const targetPath = (0, target_resolver_1.getTargetPath)(projectInfo, targetName);
+        const fileCount = (0, special_workload_1.countSpecialWorkloadFiles)(targetPath, rule, projectInfo.path);
+        // Marquer comme special/combined même si fileCount === 0 (règle a special_workload défini)
+        specialWorkloadFiles = fileCount;
+        baseOccurrences = occurrences;
+        type = occurrences > 0 ? 'combined' : 'special';
+        if (fileCount > 0) {
+            const specialMinutes = fileCount * rule.special_workload.bb_time_by_occurrence;
+            logger_1.logger.debug(`   📦 Special workload [${rule.key}]: ${fileCount} fichiers × ${rule.special_workload.bb_time_by_occurrence}min = ${specialMinutes}min`);
+            totalMinutes += specialMinutes;
+            rule.special_workload.occurrences_found = fileCount;
+        }
+    }
+    const ruleWorkload = {
+        ruleKey: rule.key,
+        ruleSummary: rule.summary,
+        occurrences: type === 'routine' ? 1 : occurrences, // Routine = toujours 1
+        minutesPerOccurrence: rule.estimated_time_per_occurrence,
+        totalTime: (0, workload_formatter_1.convertMinutesToWorkloadTime)(totalMinutes),
+        type
+    };
+    if (specialWorkloadFiles !== undefined) {
+        ruleWorkload.specialWorkloadFiles = specialWorkloadFiles;
+        ruleWorkload.baseOccurrences = baseOccurrences;
+        ruleWorkload.specialTimePerFile = rule.special_workload?.bb_time_by_occurrence;
+    }
+    return ruleWorkload;
+}

package/dist/src/core/workload/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Module workload - Calcul hiérarchique de charge de travail
+ *
+ * API publique :
+ * - calculateWorkloadReport() : Fonction principale
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorkloadReport = void 0;
+var calculator_1 = require("./calculator");
+Object.defineProperty(exports, "calculateWorkloadReport", { enumerable: true, get: function () { return calculator_1.calculateWorkloadReport; } });

package/dist/src/core/workload/metadata.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuleMetadataMaps = createRuleMetadataMaps;
+/**
+ * Crée les maps ruleKey → migration et ruleKey → priority
+ * @param migrationRules Structure hiérarchique des règles par migration et priorité
+ */
+function createRuleMetadataMaps(migrationRules) {
+    const ruleMigrationMap = new Map();
+    const rulePriorityMap = new Map();
+    for (const [migration, priorities] of Object.entries(migrationRules)) {
+        for (const [priority, rulesList] of Object.entries(priorities)) {
+            for (const rule of rulesList) {
+                ruleMigrationMap.set(rule.key, migration);
+                rulePriorityMap.set(rule.key, priority);
+            }
+        }
+    }
+    return { ruleMigrationMap, rulePriorityMap };
+}

package/dist/src/core/workload/special-workload.js

@@ -0,0 +1,101 @@
+"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.countSpecialWorkloadFiles = countSpecialWorkloadFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_helpers_1 = require("../../utils/core/file-helpers");
+const logger_1 = require("../../utils/core/logger");
+/**
+ * Cache pour éviter de recompter les mêmes fichiers
+ * Clé: `${targetPath}::${projectRoot}::${pattern1,pattern2,...}`
+ */
+const specialWorkloadCache = new Map();
+/**
+ * Détermine si un pattern correspond à un fichier racine
+ * Fichiers racine = noms exacts sans wildcard (ex: package.json, tsconfig.json)
+ * Patterns de scan = patterns avec wildcard (ex: *.module.ts, tsconfig*.json)
+ */
+function isRootFilePattern(pattern) {
+    // Fichier racine si pas de wildcard (*) et pas de séparateur de chemin (/)
+    return !pattern.includes('*') && !pattern.includes('/');
+}
+/**
+ * Compte les fichiers correspondant aux patterns special_workload
+ * Utilise un cache pour éviter de recompter les mêmes patterns
+ *
+ * PRIORITÉ : Cherche d'abord les fichiers racine (package.json, tsconfig.json, etc.) dans projectRoot
+ * FALLBACK : Scanne récursivement les patterns avec wildcard dans targetPath
+ */
+function countSpecialWorkloadFiles(targetPath, rule, projectRoot) {
+    if (!rule.special_workload || !rule.special_workload.bb_fileTypes) {
+        return 0;
+    }
+    const patterns = rule.special_workload.bb_fileTypes;
+    const cacheKey = `${targetPath}::${projectRoot}::${patterns.join(',')}`;
+    // Vérifier le cache
+    if (specialWorkloadCache.has(cacheKey)) {
+        const cached = specialWorkloadCache.get(cacheKey);
+        logger_1.logger.debug(`   📦 Cache hit pour ${rule.key}: ${cached} fichiers`);
+        return cached;
+    }
+    // Compter les fichiers pour chaque pattern
+    logger_1.logger.debug(`   🔍 Comptage fichiers special_workload pour ${rule.key}...`);
+    let totalCount = 0;
+    for (const pattern of patterns) {
+        // Détecter si c'est un fichier racine (nom exact sans wildcard)
+        if (isRootFilePattern(pattern)) {
+            // Vérifier à la racine du projet (ex: package.json, tsconfig.json)
+            const rootFilePath = path.join(projectRoot, pattern);
+            if (fs.existsSync(rootFilePath)) {
+                totalCount += 1;
+                logger_1.logger.debug(`      • ${pattern}: 1 fichier (racine)`);
+            }
+        }
+        else {
+            // Scanner récursivement dans targetPath (ex: *.module.ts, tsconfig*.json)
+            const regex = (0, file_helpers_1.buildBlockToRegex)(pattern);
+            const count = (0, file_helpers_1.countFiles)(targetPath, regex);
+            if (count > 0) {
+                logger_1.logger.debug(`      • ${pattern}: ${count} fichier(s)`);
+                totalCount += count;
+            }
+        }
+    }
+    logger_1.logger.debug(`      ✓ Total: ${totalCount} fichier(s) trouvé(s)`);
+    // Stocker dans le cache
+    specialWorkloadCache.set(cacheKey, totalCount);
+    return totalCount;
+}