@silvestv/migration-planificator 3.0.0

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

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareScans = compareScans;
+exports.logDeltaReport = logDeltaReport;
+const core_1 = require("../utils/core");
+/**
+ * Compare les résultats de deux scans et génère une analyse détaillée
+ */
+function compareScans(astResult, regexResult, options = {}) {
+    const startTime = Date.now();
+    // 1. Construire le résumé global
+    const summary = buildComparisonSummary(astResult.matches, regexResult.matches);
+    // 2. Analyser règle par règle
+    const byRule = buildRuleComparisons(astResult.matches, regexResult.matches, options);
+    // 3. Identifier les divergences
+    const divergences = options.analyzeDivergences !== false
+        ? buildDivergenceDetails(astResult.matches, regexResult.matches)
+        : createEmptyDivergences();
+    // 4. Comparer les performances
+    const performance = buildPerformanceComparison(astResult, regexResult);
+    const comparison = {
+        summary,
+        byRule,
+        divergences,
+        performance
+    };
+    const result = {
+        astResult,
+        regexResult,
+        comparison,
+        timestamp: new Date().toISOString()
+    };
+    core_1.logger.debug(`Analyse comparative complétée en ${Date.now() - startTime}ms`);
+    return result;
+}
+/**
+ * Construit le résumé global de la comparaison
+ */
+function buildComparisonSummary(astMatches, regexMatches) {
+    const totalAst = astMatches.length;
+    const totalRegex = regexMatches.length;
+    const delta = totalAst - totalRegex;
+    const astSet = createMatchSignatureSet(astMatches);
+    const regexSet = createMatchSignatureSet(regexMatches);
+    const commonMatches = astMatches.filter(m => regexSet.has(createMatchSignature(m))).length;
+    const maxTotal = Math.max(totalAst, totalRegex);
+    const matchRate = maxTotal > 0 ? (commonMatches / maxTotal) * 100 : 100;
+    return {
+        totalAst,
+        totalRegex,
+        delta,
+        deltaPercentage: totalRegex > 0 ? (delta / totalRegex) * 100 : 0,
+        commonMatches,
+        matchRate
+    };
+}
+/**
+ * Construit la comparaison détaillée par règle
+ */
+function buildRuleComparisons(astMatches, regexMatches, options) {
+    const astByRule = groupMatchesByRule(astMatches);
+    const regexByRule = groupMatchesByRule(regexMatches);
+    const allRuleKeys = new Set([...astByRule.keys(), ...regexByRule.keys()]);
+    const comparisons = [];
+    for (const ruleKey of allRuleKeys) {
+        const astCount = astByRule.get(ruleKey)?.length || 0;
+        const regexCount = regexByRule.get(ruleKey)?.length || 0;
+        const delta = astCount - regexCount;
+        const status = determineComparisonStatus(astCount, regexCount);
+        // Filtrer les identiques si demandé
+        if (!options.includeIdentical && status === 'identical') {
+            continue;
+        }
+        // Filtrer par seuil de delta si spécifié
+        if (options.minDeltaThreshold && Math.abs(delta) < options.minDeltaThreshold) {
+            continue;
+        }
+        const ruleSummary = astMatches.find(m => m.ruleKey === ruleKey)?.ruleSummary
+            || regexMatches.find(m => m.ruleKey === ruleKey)?.ruleSummary;
+        comparisons.push({
+            ruleKey,
+            ruleSummary,
+            astCount,
+            regexCount,
+            delta,
+            deltaPercentage: regexCount > 0 ? (delta / regexCount) * 100 : 0,
+            status,
+            confidence: determineConfidenceLevel(status, astCount, regexCount)
+        });
+    }
+    // Trier par delta absolu décroissant
+    return comparisons.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+}
+/**
+ * Construit les détails sur les divergences
+ */
+function buildDivergenceDetails(astMatches, regexMatches) {
+    const astSet = createMatchSignatureSet(astMatches);
+    const regexSet = createMatchSignatureSet(regexMatches);
+    const onlyInAst = astMatches
+        .filter(m => !regexSet.has(createMatchSignature(m)))
+        .map(m => createMatchDivergence(m, 'ast'));
+    const onlyInRegex = regexMatches
+        .filter(m => !astSet.has(createMatchSignature(m)))
+        .map(m => createMatchDivergence(m, 'regex'));
+    return {
+        onlyInAst,
+        onlyInRegex,
+        locationMismatch: [] // À implémenter si nécessaire
+    };
+}
+/**
+ * Crée un objet MatchDivergence avec analyse de la catégorie
+ */
+function createMatchDivergence(match, source) {
+    const category = analyzeDivergenceCategory(match, source);
+    const possibleReason = getDivergenceReason(category);
+    return {
+        match,
+        category,
+        possibleReason
+    };
+}
+/**
+ * Analyse la catégorie probable d'une divergence
+ */
+function analyzeDivergenceCategory(match, source) {
+    // Heuristiques simples pour classifier la divergence
+    const text = match.matchedText.toLowerCase();
+    if (source === 'ast') {
+        // AST a trouvé quelque chose que Regex n'a pas trouvé
+        if (text.includes('comment') || text.includes('//') || text.includes('/*')) {
+            return 'ast-precision'; // AST ignore les commentaires correctement
+        }
+        return 'ast-precision';
+    }
+    else {
+        // Regex a trouvé quelque chose que AST n'a pas trouvé
+        if (text.length < 5) {
+            return 'false-positive-regex'; // Probablement un match trop court
+        }
+        return 'regex-coverage';
+    }
+}
+/**
+ * Retourne une raison explicative pour une catégorie de divergence
+ */
+function getDivergenceReason(category) {
+    const reasons = {
+        'false-positive-ast': 'AST peut détecter des patterns ambigus',
+        'false-positive-regex': 'Regex peut matcher du texte non pertinent',
+        'ast-precision': 'AST offre une détection contextuelle plus précise',
+        'regex-coverage': 'Regex capture une portée plus large',
+        'unknown': 'Raison de divergence à analyser manuellement'
+    };
+    return reasons[category];
+}
+/**
+ * Construit la comparaison de performance
+ */
+function buildPerformanceComparison(astResult, regexResult) {
+    const filesProcessed = Math.max(astResult.filesScanned || 0, regexResult.filesScanned || 0);
+    const performance = {
+        filesProcessed
+    };
+    if (astResult.duration !== undefined) {
+        performance.astDuration = astResult.duration;
+    }
+    if (regexResult.duration !== undefined) {
+        performance.regexDuration = regexResult.duration;
+    }
+    if (performance.astDuration && performance.regexDuration) {
+        performance.speedRatio = performance.astDuration / performance.regexDuration;
+        performance.averageTimePerFile = {
+            ast: performance.astDuration / filesProcessed,
+            regex: performance.regexDuration / filesProcessed
+        };
+    }
+    return performance;
+}
+/**
+ * Détermine le statut de comparaison
+ */
+function determineComparisonStatus(astCount, regexCount) {
+    if (astCount === 0 && regexCount === 0)
+        return 'identical';
+    if (astCount === 0)
+        return 'regex-only';
+    if (regexCount === 0)
+        return 'ast-only';
+    if (astCount === regexCount)
+        return 'identical';
+    return astCount > regexCount ? 'ast-more' : 'regex-more';
+}
+/**
+ * Détermine le niveau de confiance d'une détection
+ */
+function determineConfidenceLevel(status, astCount, regexCount) {
+    if (status === 'identical')
+        return 'high';
+    const maxCount = Math.max(astCount, regexCount);
+    const minCount = Math.min(astCount, regexCount);
+    if (minCount === 0)
+        return 'low'; // Un seul détecte
+    const ratio = minCount / maxCount;
+    if (ratio >= 0.9)
+        return 'high'; // Différence < 10%
+    if (ratio >= 0.7)
+        return 'medium'; // Différence 10-30%
+    return 'low'; // Différence > 30%
+}
+/**
+ * Crée un objet divergences vide
+ */
+function createEmptyDivergences() {
+    return {
+        onlyInAst: [],
+        onlyInRegex: [],
+        locationMismatch: []
+    };
+}
+/**
+ * Affiche le rapport de delta dans la console
+ */
+function logDeltaReport(result) {
+    const { comparison } = result;
+    const { summary, byRule, divergences, performance } = comparison;
+    core_1.logger.blank();
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.info('         RAPPORT DE COMPARAISON AST vs REGEX');
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.blank();
+    // Vue d'ensemble
+    core_1.logger.info('Vue d\'ensemble:');
+    core_1.logger.info(`  • Total AST:   ${summary.totalAst} occurrences`);
+    core_1.logger.info(`  • Total Regex: ${summary.totalRegex} occurrences`);
+    core_1.logger.info(`  • Delta:       ${summary.delta > 0 ? '+' : ''}${summary.delta} (${summary.deltaPercentage.toFixed(1)}%)`);
+    core_1.logger.info(`  • Taux de correspondance: ${summary.matchRate.toFixed(1)}%`);
+    core_1.logger.blank();
+    core_1.logger.info('Répartition:');
+    core_1.logger.info(`  • Commun aux deux:      ${summary.commonMatches} occurrences`);
+    core_1.logger.info(`  • Uniquement AST:       ${divergences.onlyInAst.length} occurrences`);
+    core_1.logger.info(`  • Uniquement Regex:     ${divergences.onlyInRegex.length} occurrences`);
+    core_1.logger.blank();
+    // Performance
+    if (performance.astDuration && performance.regexDuration) {
+        core_1.logger.info('Performance:');
+        core_1.logger.info(`  • Durée AST:   ${(performance.astDuration / 1000).toFixed(2)}s`);
+        core_1.logger.info(`  • Durée Regex: ${(performance.regexDuration / 1000).toFixed(2)}s`);
+        core_1.logger.info(`  • Ratio:       ${performance.speedRatio.toFixed(2)}x ${performance.speedRatio > 1 ? '(Regex plus rapide)' : '(AST plus rapide)'}`);
+        core_1.logger.blank();
+    }
+    // Comparaison par règle
+    const identicalRules = byRule.filter(r => r.status === 'identical');
+    const divergentRules = byRule.filter(r => r.status !== 'identical');
+    core_1.logger.info(`Règles analysées: ${byRule.length}`);
+    core_1.logger.info(`  • Identiques: ${identicalRules.length}`);
+    core_1.logger.info(`  • Divergentes: ${divergentRules.length}`);
+    core_1.logger.blank();
+    // Top règles divergentes
+    if (divergentRules.length > 0) {
+        core_1.logger.info('Top 10 règles avec le plus grand écart:');
+        for (const rule of divergentRules.slice(0, 10)) {
+            const statusIcon = getStatusIcon(rule.status);
+            const confidenceIcon = getConfidenceIcon(rule.confidence);
+            const sign = rule.delta > 0 ? '+' : '';
+            core_1.logger.debug(`  ${statusIcon} ${confidenceIcon} ${rule.ruleKey}: AST=${rule.astCount}, Regex=${rule.regexCount} (${sign}${rule.delta})`);
+        }
+        core_1.logger.blank();
+    }
+    // Règles uniquement détectées par un scanner
+    const astOnlyRules = byRule.filter(r => r.status === 'ast-only');
+    const regexOnlyRules = byRule.filter(r => r.status === 'regex-only');
+    if (astOnlyRules.length > 0) {
+        core_1.logger.info(`Règles détectées uniquement par AST (${astOnlyRules.length}):`);
+        for (const rule of astOnlyRules) {
+            core_1.logger.debug(`  ✓ ${rule.ruleKey}: ${rule.astCount} occurrences`);
+        }
+        core_1.logger.blank();
+    }
+    if (regexOnlyRules.length > 0) {
+        core_1.logger.info(`Règles détectées uniquement par Regex (${regexOnlyRules.length}):`);
+        for (const rule of regexOnlyRules) {
+            core_1.logger.debug(`  ⚠ ${rule.ruleKey}: ${rule.regexCount} occurrences`);
+        }
+        core_1.logger.blank();
+    }
+    core_1.logger.info('═══════════════════════════════════════════════════════════');
+    core_1.logger.blank();
+}
+/**
+ * Groupe les matches par règle
+ */
+function groupMatchesByRule(matches) {
+    const grouped = new Map();
+    for (const match of matches) {
+        if (!grouped.has(match.ruleKey)) {
+            grouped.set(match.ruleKey, []);
+        }
+        grouped.get(match.ruleKey).push(match);
+    }
+    return grouped;
+}
+/**
+ * Crée une signature unique pour un match (fichier:ligne:règle)
+ */
+function createMatchSignature(match) {
+    return `${match.filePath}:${match.lineNumber}:${match.ruleKey}`;
+}
+/**
+ * Crée un Set de signatures pour recherche rapide
+ */
+function createMatchSignatureSet(matches) {
+    return new Set(matches.map(createMatchSignature));
+}
+/**
+ * Retourne l'icône correspondant au status
+ */
+function getStatusIcon(status) {
+    const icons = {
+        'identical': '=',
+        'ast-more': '↑',
+        'regex-more': '↓',
+        'ast-only': '✓',
+        'regex-only': '⚠'
+    };
+    return icons[status];
+}
+/**
+ * Retourne l'icône correspondant au niveau de confiance
+ */
+function getConfidenceIcon(confidence) {
+    const icons = {
+        'high': '●',
+        'medium': '◐',
+        'low': '○'
+    };
+    return icons[confidence];
+}

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

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeScan = executeScan;
+const scanner_ast_1 = require("./ast/scanner-ast");
+const scanner_regex_1 = require("./scanner-regex");
+const scanner_delta_1 = require("./scanner-delta");
+const core_1 = require("../utils/core");
+const scan_reporter_1 = require("./scan-reporter");
+const core_2 = require("../utils/core");
+const target_resolver_1 = require("./workload/target-resolver");
+const project_strategy_1 = require("./project-strategy");
+/**
+ * Affiche un rapport concis des occurrences par règle, groupé par migration et priorité
+ */
+function logScannerReport(matches, scannerName, allRules) {
+    core_1.logger.blank();
+    core_1.logger.info(`═══════════════════════════════════════════════════════════`);
+    core_1.logger.info(`         RAPPORT ${scannerName.toUpperCase()}`);
+    core_1.logger.info(`═══════════════════════════════════════════════════════════`);
+    core_1.logger.blank();
+    // Grouper les matches par ruleKey (DRY: utilise groupBy helper)
+    const matchesByRule = (0, core_1.groupBy)(matches, match => match.ruleKey);
+    // Charger la structure MigrationRules pour avoir migration + priority
+    const { loadMigrationRules } = require('./rules-loader');
+    const migrationRules = loadMigrationRules();
+    // Créer une map ruleKey -> { migration, priority, rule }
+    const ruleMetadata = new Map();
+    for (const [migration, priorities] of Object.entries(migrationRules)) {
+        for (const [priority, rules] of Object.entries(priorities)) {
+            for (const rule of rules) {
+                ruleMetadata.set(rule.key, { migration, priority, rule });
+            }
+        }
+    }
+    const organized = new Map();
+    for (const [ruleKey, ruleMatches] of matchesByRule) {
+        const metadata = ruleMetadata.get(ruleKey);
+        if (!metadata)
+            continue;
+        const { migration, priority, rule } = metadata;
+        if (!organized.has(migration)) {
+            organized.set(migration, new Map());
+        }
+        const migrationMap = organized.get(migration);
+        if (!migrationMap.has(priority)) {
+            migrationMap.set(priority, []);
+        }
+        migrationMap.get(priority).push({
+            rule,
+            count: ruleMatches.length
+        });
+    }
+    // Afficher par migration (trié)
+    const migrations = ['to18', 'to19', 'to20'].filter(m => organized.has(m));
+    for (const migration of migrations) {
+        const prioritiesMap = organized.get(migration);
+        // Calculer total migration
+        const totalMigration = Array.from(prioritiesMap.values())
+            .flat()
+            .reduce((sum, e) => sum + e.count, 0);
+        core_1.logger.info(`📦 Migration ${migration.toUpperCase()} (${totalMigration} occurrences)`);
+        core_1.logger.blank();
+        // Afficher par priorité
+        const priorities = ['obligatoire', 'recommande', 'optionnelle'];
+        for (const priority of priorities) {
+            const entries = prioritiesMap.get(priority) || [];
+            if (entries.length === 0)
+                continue;
+            const totalPriority = entries.reduce((sum, e) => sum + e.count, 0);
+            const priorityIcon = priority === 'obligatoire' ? '🔴' : priority === 'recommande' ? '🟡' : '🟢';
+            core_1.logger.info(`  ${priorityIcon} ${priority.toUpperCase()} (${totalPriority} occurrences)`);
+            // Trier par nombre d'occurrences décroissant
+            entries.sort((a, b) => b.count - a.count);
+            for (const entry of entries) {
+                const countStr = `${entry.count}`.padStart(3);
+                core_1.logger.debug(`      ${countStr} × ${entry.rule.summary}`);
+            }
+            core_1.logger.blank();
+        }
+    }
+    core_1.logger.info(`═══════════════════════════════════════════════════════════`);
+    core_1.logger.blank();
+}
+/**
+ * Orchestre le scan selon le type de scanner demandé
+ */
+function executeScan(projectInfo, rules, scannerType) {
+    // Afficher compteurs règles spéciales (une seule fois, peu importe le scanner)
+    const specialWorkloadCount = rules.filter(r => r.special_workload).length;
+    const routineCount = rules.filter(r => (0, core_2.isRoutineRule)(r)).length;
+    (0, scan_reporter_1.logSpecialRulesInfo)(specialWorkloadCount, routineCount);
+    if (scannerType === 'both') {
+        return executeBothScans(projectInfo, rules);
+    }
+    else if (scannerType === 'ast') {
+        return executeAstScan(projectInfo, rules);
+    }
+    else {
+        return executeRegexScan(projectInfo, rules);
+    }
+}
+/**
+ * Exécute uniquement le scanner AST
+ */
+function executeAstScan(projectInfo, rules) {
+    core_1.logger.blank();
+    core_1.logger.step('Analyse des applications (AST)...');
+    core_1.logger.blank();
+    const allMatches = [];
+    // Séparer les règles de routine (onFile) des règles normales
+    const routineRules = rules.filter(r => (0, core_2.isRoutineRule)(r));
+    const nonRoutineRules = rules.filter(r => !(0, core_2.isRoutineRule)(r));
+    // Scanner les règles de routine UNE SEULE FOIS à la racine du projet (avec fallback regex)
+    if (routineRules.length > 0) {
+        const routineMatches = (0, scanner_regex_1.scanDirectory)(projectInfo.path, routineRules, projectInfo.path);
+        allMatches.push(...routineMatches);
+    }
+    // Scanner les règles normales par target avec AST
+    const strategy = (0, project_strategy_1.createProjectStrategy)(projectInfo);
+    const targets = strategy.getTargetsList(projectInfo);
+    const astRulesCount = nonRoutineRules.filter(r => r.astPattern).length;
+    const regexRulesCount = nonRoutineRules.filter(r => !r.astPattern && r.regex).length;
+    for (const target of targets) {
+        const targetType = (0, target_resolver_1.getTargetType)(target.name, projectInfo);
+        const targetPath = (0, target_resolver_1.getTargetPath)(projectInfo, target.name);
+        (0, scan_reporter_1.logTargetStart)(target.name, targetType);
+        (0, scan_reporter_1.logScannerInfo)(astRulesCount, regexRulesCount);
+        const startTime = Date.now();
+        const result = (0, scanner_ast_1.scanDirectoryWithAST)(targetPath, nonRoutineRules, projectInfo.path);
+        const duration = Date.now() - startTime;
+        allMatches.push(...result.matches);
+        (0, scan_reporter_1.logTargetComplete)(target.name, result.matches, duration);
+    }
+    core_1.logger.blank();
+    core_1.logger.success(`Analyse AST terminée: ${allMatches.length} occurrences totales`);
+    return { matches: allMatches };
+}
+/**
+ * Exécute uniquement le scanner Regex
+ */
+function executeRegexScan(projectInfo, rules) {
+    core_1.logger.blank();
+    core_1.logger.step('Analyse des applications (Regex)...');
+    core_1.logger.blank();
+    const allMatches = [];
+    // Séparer les règles de routine (onFile) des règles normales
+    const routineRules = rules.filter(r => (0, core_2.isRoutineRule)(r));
+    const nonRoutineRules = rules.filter(r => !(0, core_2.isRoutineRule)(r));
+    // Scanner les règles de routine UNE SEULE FOIS à la racine du projet
+    if (routineRules.length > 0) {
+        const routineMatches = (0, scanner_regex_1.scanDirectory)(projectInfo.path, routineRules, projectInfo.path);
+        allMatches.push(...routineMatches);
+    }
+    // Scanner les règles normales par target
+    const strategy = (0, project_strategy_1.createProjectStrategy)(projectInfo);
+    const targets = strategy.getTargetsList(projectInfo);
+    const regexRulesCount = nonRoutineRules.filter(r => r.regex).length;
+    for (const target of targets) {
+        const targetType = (0, target_resolver_1.getTargetType)(target.name, projectInfo);
+        const targetPath = (0, target_resolver_1.getTargetPath)(projectInfo, target.name);
+        (0, scan_reporter_1.logTargetStart)(target.name, targetType);
+        (0, scan_reporter_1.logScannerInfo)(0, regexRulesCount);
+        const startTime = Date.now();
+        const matches = (0, scanner_regex_1.scanDirectory)(targetPath, nonRoutineRules, projectInfo.path);
+        const duration = Date.now() - startTime;
+        allMatches.push(...matches);
+        (0, scan_reporter_1.logTargetComplete)(target.name, matches, duration);
+    }
+    core_1.logger.blank();
+    core_1.logger.success(`Analyse Regex terminée: ${allMatches.length} occurrences totales`);
+    return { matches: allMatches };
+}
+/**
+ * Exécute les deux scanners et génère une comparaison
+ */
+function executeBothScans(projectInfo, rules) {
+    const strategy = (0, project_strategy_1.createProjectStrategy)(projectInfo);
+    const targets = strategy.getTargetsList(projectInfo);
+    const fileCount = targets.length;
+    // Séparer les règles de routine (onFile) des règles normales UNE SEULE FOIS
+    const routineRules = rules.filter(r => (0, core_2.isRoutineRule)(r));
+    const nonRoutineRules = rules.filter(r => !(0, core_2.isRoutineRule)(r));
+    const astRulesCount = nonRoutineRules.filter(r => r.astPattern).length;
+    const regexRulesCount = nonRoutineRules.filter(r => r.regex).length;
+    // 1. Scanner avec AST
+    core_1.logger.blank();
+    core_1.logger.step('Analyse AST en cours...');
+    core_1.logger.blank();
+    const astStartTime = Date.now();
+    const astMatches = [];
+    const astStats = [];
+    // Scanner les règles de routine UNE SEULE FOIS à la racine du projet (avec fallback regex)
+    if (routineRules.length > 0) {
+        const routineMatches = (0, scanner_regex_1.scanDirectory)(projectInfo.path, routineRules, projectInfo.path);
+        astMatches.push(...routineMatches);
+    }
+    // Scanner les règles normales par target avec AST
+    for (const target of targets) {
+        const targetType = (0, target_resolver_1.getTargetType)(target.name, projectInfo);
+        const targetPath = (0, target_resolver_1.getTargetPath)(projectInfo, target.name);
+        (0, scan_reporter_1.logTargetStart)(target.name, targetType);
+        (0, scan_reporter_1.logScannerInfo)(astRulesCount, 0);
+        const startTime = Date.now();
+        const result = (0, scanner_ast_1.scanDirectoryWithAST)(targetPath, nonRoutineRules, projectInfo.path);
+        const duration = Date.now() - startTime;
+        astMatches.push(...result.matches);
+        astStats.push(...result.stats);
+        (0, scan_reporter_1.logTargetComplete)(target.name, result.matches, duration);
+    }
+    const astDuration = Date.now() - astStartTime;
+    core_1.logger.blank();
+    core_1.logger.success(`AST terminé: ${astMatches.length} occurrences en ${(astDuration / 1000).toFixed(2)}s`);
+    // 2. Scanner avec Regex
+    core_1.logger.blank();
+    core_1.logger.step('Analyse Regex en cours...');
+    core_1.logger.blank();
+    const regexStartTime = Date.now();
+    const regexMatches = [];
+    // Scanner les règles de routine UNE SEULE FOIS à la racine du projet
+    if (routineRules.length > 0) {
+        const routineMatches = (0, scanner_regex_1.scanDirectory)(projectInfo.path, routineRules, projectInfo.path);
+        regexMatches.push(...routineMatches);
+    }
+    // Scanner les règles normales par target
+    for (const target of targets) {
+        const targetType = (0, target_resolver_1.getTargetType)(target.name, projectInfo);
+        const targetPath = (0, target_resolver_1.getTargetPath)(projectInfo, target.name);
+        (0, scan_reporter_1.logTargetStart)(target.name, targetType);
+        (0, scan_reporter_1.logScannerInfo)(0, regexRulesCount);
+        const startTime = Date.now();
+        const matches = (0, scanner_regex_1.scanDirectory)(targetPath, nonRoutineRules, projectInfo.path);
+        const duration = Date.now() - startTime;
+        regexMatches.push(...matches);
+        (0, scan_reporter_1.logTargetComplete)(target.name, matches, duration);
+    }
+    const regexDuration = Date.now() - regexStartTime;
+    core_1.logger.blank();
+    core_1.logger.success(`Regex terminé: ${regexMatches.length} occurrences en ${(regexDuration / 1000).toFixed(2)}s`);
+    // 3. Afficher les rapports détaillés par scanner
+    logScannerReport(astMatches, 'AST', rules);
+    logScannerReport(regexMatches, 'REGEX', rules);
+    // 4. Construire les résultats de scan
+    const astResult = {
+        matches: astMatches,
+        stats: astStats,
+        scannerType: 'ast',
+        duration: astDuration,
+        filesScanned: fileCount
+    };
+    const regexResult = {
+        matches: regexMatches,
+        stats: [],
+        scannerType: 'regex',
+        duration: regexDuration,
+        filesScanned: fileCount
+    };
+    // 5. Comparer les résultats
+    const comparison = (0, scanner_delta_1.compareScans)(astResult, regexResult);
+    // 6. Afficher le rapport de comparaison (delta)
+    (0, scanner_delta_1.logDeltaReport)(comparison);
+    // Utiliser les résultats AST par défaut
+    return {
+        matches: astMatches,
+        comparison
+    };
+}