@silvestv/migration-planificator 3.0.0

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

@@ -0,0 +1,444 @@
+"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.scanDirectoryWithAST = scanDirectoryWithAST;
+exports.logDetectionStats = logDetectionStats;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+const file_helpers_1 = require("../../utils/core/file-helpers");
+const logger_1 = require("../../utils/core/logger");
+const matchers_1 = require("./matchers");
+const context_matcher_1 = require("./matchers/ts/context-matcher");
+const scanner_regex_1 = require("../scanner-regex");
+const scan_reporter_1 = require("../scan-reporter");
+/**
+ * Groupe les règles AST par SyntaxKind pour optimisation
+ * Permet de ne tester que les règles pertinentes pour chaque type de nœud
+ */
+function groupRulesByNodeType(rules) {
+    const grouped = new Map();
+    for (const rule of rules) {
+        if (!rule.astPattern)
+            continue;
+        const nodeTypes = Array.isArray(rule.astPattern.nodeType)
+            ? rule.astPattern.nodeType
+            : [rule.astPattern.nodeType];
+        for (const typeName of nodeTypes) {
+            if (!typeName)
+                continue;
+            const kind = ts_morph_1.SyntaxKind[typeName];
+            if (kind !== undefined) {
+                if (!grouped.has(kind)) {
+                    grouped.set(kind, []);
+                }
+                grouped.get(kind).push(rule);
+            }
+        }
+    }
+    logger_1.logger.debug(`Règles groupées en ${grouped.size} types de nœuds`);
+    return grouped;
+}
+/**
+ * Scan un batch de fichiers avec les règles groupées par nodeType
+ * OPTIMISÉ : stratégie hybride selon nombre de types
+ */
+function scanBatch(project, rulesByNodeType, projectRoot, matches) {
+    const kindCount = rulesByNodeType.size;
+    for (const sourceFile of project.getSourceFiles()) {
+        const filePath = sourceFile.getFilePath();
+        const relativeFilePath = path.relative(projectRoot, filePath);
+        // Stratégie adaptative selon nombre de types
+        if (kindCount <= 10) {
+            // Peu de types : getDescendantsOfKind() est optimal
+            scanWithGetDescendants(sourceFile, relativeFilePath, rulesByNodeType, matches);
+        }
+        else {
+            // Beaucoup de types : un seul parcours est plus rapide
+            scanWithSingleTraversal(sourceFile, relativeFilePath, rulesByNodeType, matches);
+        }
+        // IMPORTANT: Libérer mémoire des nœuds
+        sourceFile.forgetDescendants();
+    }
+}
+/**
+ * Scan avec getDescendantsOfKind() pour chaque type (optimal si peu de types)
+ */
+function scanWithGetDescendants(sourceFile, relativeFilePath, rulesByNodeType, matches) {
+    for (const [kind, rulesForKind] of rulesByNodeType) {
+        const nodes = sourceFile.getDescendantsOfKind(kind);
+        for (const node of nodes) {
+            processNodeWithRules(node, rulesForKind, sourceFile, relativeFilePath, matches);
+        }
+    }
+}
+/**
+ * Scan avec un seul forEachDescendant() et dispatch (optimal si beaucoup de types)
+ */
+function scanWithSingleTraversal(sourceFile, relativeFilePath, rulesByNodeType, matches) {
+    sourceFile.forEachDescendant((node) => {
+        const kind = node.getKind();
+        const rulesForKind = rulesByNodeType.get(kind);
+        if (rulesForKind) {
+            processNodeWithRules(node, rulesForKind, sourceFile, relativeFilePath, matches);
+        }
+    });
+}
+/**
+ * Traite un nœud avec les règles associées (logique commune)
+ */
+function processNodeWithRules(node, rules, sourceFile, relativeFilePath, matches) {
+    for (const rule of rules) {
+        // Vérifier inFile filter (early exit)
+        if (rule.astPattern.inFile &&
+            !matchers_1.FileMatcher.matchesInFilePattern(relativeFilePath, rule.astPattern.inFile)) {
+            continue;
+        }
+        if ((0, matchers_1.matchesAstPattern)(node, rule.astPattern)) {
+            // Vérifier testSetup si présent
+            if (rule.astPattern.testSetup &&
+                !matchers_1.FileMatcher.matchesTestSetup(sourceFile, rule.astPattern.testSetup)) {
+                continue;
+            }
+            // Optimisation getText() : vérifier width d'abord
+            const width = node.getWidth();
+            const matchedText = width > 100
+                ? node.getText().substring(0, 100).trim()
+                : node.getText().trim();
+            matches.push({
+                ruleKey: rule.key,
+                ruleSummary: rule.summary,
+                filePath: relativeFilePath,
+                lineNumber: node.getStartLineNumber(),
+                matchedText
+            });
+        }
+    }
+}
+/**
+ * Scan un répertoire avec analyse AST TypeScript
+ * @param targetDir Répertoire à scanner (app ou lib)
+ * @param rules Règles avec astPattern défini
+ * @param projectRoot Racine du projet
+ * @returns Liste des occurrences trouvées et statistiques
+ */
+function scanDirectoryWithAST(targetDir, rules, projectRoot) {
+    const matches = [];
+    const detectionMap = new Map();
+    // Séparer règles AST vs regex
+    // Note: regexRules inclut TOUTES les règles non-AST, y compris celles avec onFile (qui ont regex: null)
+    const astRules = rules.filter(r => r.astPattern);
+    const regexRules = rules.filter(r => !r.astPattern);
+    // Fallback vers scanner regex si pas d'AST
+    if (astRules.length === 0) {
+        logger_1.logger.debug('Aucune règle AST, utilisation du scanner regex');
+        const regexMatches = (0, scanner_regex_1.scanDirectory)(targetDir, regexRules, projectRoot);
+        // Tracker les stats regex
+        for (const match of regexMatches) {
+            const existing = detectionMap.get(match.ruleKey);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                detectionMap.set(match.ruleKey, { method: 'regex', count: 1 });
+            }
+        }
+        const stats = Array.from(detectionMap.entries()).map(([ruleKey, data]) => ({
+            ruleKey,
+            method: data.method,
+            occurrences: data.count
+        }));
+        return { matches: regexMatches, stats };
+    }
+    logger_1.logger.info(`Scanner: ${astRules.length} règles AST, ${regexRules.length} règles Regex (fallback)`);
+    // Grouper les règles par nodeType UNE SEULE FOIS
+    const rulesByNodeType = groupRulesByNodeType(astRules);
+    // Créer un projet ts-morph
+    const project = createTsMorphProject();
+    // Collecter tous les fichiers .ts récursivement
+    const tsFiles = (0, file_helpers_1.collectFiles)(targetDir, /\.ts$/);
+    const totalFiles = tsFiles.length;
+    (0, scan_reporter_1.logFilesDetected)('TypeScript', totalFiles);
+    // Charger TOUS les fichiers dans le projet (pas de batch)
+    // Permet la résolution cross-file (referTo, getType(), findReferences())
+    logger_1.logger.info('Chargement de tous les fichiers TypeScript...');
+    addFilesToProject(project, tsFiles);
+    logger_1.logger.success(`${totalFiles} fichiers chargés en mémoire`);
+    // Scanner tous les fichiers en une seule passe
+    logger_1.logger.info('Analyse AST en cours...');
+    scanBatch(project, rulesByNodeType, projectRoot, matches);
+    logger_1.logger.success('Analyse AST terminée');
+    // Libérer la mémoire À LA FIN uniquement
+    logger_1.logger.debug('Libération mémoire...');
+    const sourceFiles = project.getSourceFiles();
+    for (const sourceFile of sourceFiles) {
+        project.removeSourceFile(sourceFile);
+    }
+    // Vider les caches
+    (0, context_matcher_1.clearContextCaches)();
+    (0, matchers_1.clearTemplateCache)();
+    // Scanner les fichiers HTML pour les patterns HTML
+    const htmlFiles = (0, file_helpers_1.collectFiles)(targetDir, /\.html$/);
+    if (htmlFiles.length > 0) {
+        (0, scan_reporter_1.logFilesDetected)('HTML', htmlFiles.length);
+    }
+    scanHtmlFiles(targetDir, astRules, projectRoot, matches);
+    // Tracker les stats AST
+    for (const match of matches) {
+        const existing = detectionMap.get(match.ruleKey);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            detectionMap.set(match.ruleKey, { method: 'ast', count: 1 });
+        }
+    }
+    const astMatchCount = matches.length;
+    logger_1.logger.success(`AST: ${astMatchCount} occurrences`);
+    // Fallback: Scanner les règles sans astPattern avec Regex
+    if (regexRules.length > 0) {
+        const regexMatches = (0, scanner_regex_1.scanDirectory)(targetDir, regexRules, projectRoot);
+        // Tracker les stats Regex
+        for (const match of regexMatches) {
+            const existing = detectionMap.get(match.ruleKey);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                detectionMap.set(match.ruleKey, { method: 'regex', count: 1 });
+            }
+        }
+        matches.push(...regexMatches);
+        logger_1.logger.success(`Regex (fallback): ${regexMatches.length} occurrences`);
+    }
+    // Convertir la map en array de stats
+    const stats = Array.from(detectionMap.entries()).map(([ruleKey, data]) => ({
+        ruleKey,
+        method: data.method,
+        occurrences: data.count
+    }));
+    return { matches, stats };
+}
+/**
+ * Affiche un rapport détaillé des statistiques de détection
+ */
+function logDetectionStats(stats) {
+    logger_1.logger.blank();
+    logger_1.logger.info('═══════════════════════════════════════════════════════════');
+    logger_1.logger.info('         RAPPORT DE DÉTECTION PAR MÉTHODE');
+    logger_1.logger.info('═══════════════════════════════════════════════════════════');
+    logger_1.logger.blank();
+    // Séparer AST et Regex
+    const astStats = stats.filter(s => s.method === 'ast').sort((a, b) => b.occurrences - a.occurrences);
+    const regexStats = stats.filter(s => s.method === 'regex').sort((a, b) => b.occurrences - a.occurrences);
+    const totalAstOccurrences = astStats.reduce((sum, s) => sum + s.occurrences, 0);
+    const totalRegexOccurrences = regexStats.reduce((sum, s) => sum + s.occurrences, 0);
+    const totalOccurrences = totalAstOccurrences + totalRegexOccurrences;
+    // Résumé global
+    logger_1.logger.info(`Total occurrences: ${totalOccurrences}`);
+    logger_1.logger.info(`  • AST:   ${totalAstOccurrences} (${getPercentage(totalAstOccurrences, totalOccurrences)}%)`);
+    logger_1.logger.info(`  • Regex: ${totalRegexOccurrences} (${getPercentage(totalRegexOccurrences, totalOccurrences)}%)`);
+    logger_1.logger.blank();
+    logger_1.logger.info(`Règles actives: ${stats.length}`);
+    logger_1.logger.info(`  • Avec AST:        ${astStats.length}`);
+    logger_1.logger.info(`  • Regex fallback:  ${regexStats.length}`);
+    logger_1.logger.blank();
+    // Détail règles AST
+    if (astStats.length > 0) {
+        logger_1.logger.info('Règles détectées par AST:');
+        for (const stat of astStats) {
+            logger_1.logger.debug(`  ✓ ${stat.ruleKey}: ${stat.occurrences} occurrences`);
+        }
+        logger_1.logger.blank();
+    }
+    // Détail règles Regex (fallback)
+    if (regexStats.length > 0) {
+        logger_1.logger.info('Règles détectées par Regex (fallback):');
+        for (const stat of regexStats) {
+            logger_1.logger.debug(`  ⚠ ${stat.ruleKey}: ${stat.occurrences} occurrences`);
+        }
+        logger_1.logger.blank();
+    }
+    logger_1.logger.info('═══════════════════════════════════════════════════════════');
+    logger_1.logger.blank();
+}
+/**
+ * Calcule un pourcentage arrondi
+ */
+function getPercentage(value, total) {
+    if (total === 0)
+        return '0.0';
+    return ((value / total) * 100).toFixed(1);
+}
+/**
+ * Scan les fichiers HTML avec les patterns HTML (Attribute, PipeExpression, Element, etc.)
+ * Scanne à la fois :
+ * - Les fichiers .html externes (95% des cas en Angular)
+ * - Les templates inline dans les .ts (5% des cas, pour patterns standalone)
+ *
+ * Note: Les patterns Decorator avec template/templateUrl sont déjà gérés
+ * par le DecoratorMatcher lors du scan TypeScript principal.
+ */
+function scanHtmlFiles(targetDir, rules, projectRoot, matches) {
+    // Filtrer uniquement les règles HTML
+    const htmlRules = rules.filter(r => r.astPattern && matchers_1.HtmlMatcher.isHtmlPattern(r.astPattern));
+    if (htmlRules.length === 0) {
+        return;
+    }
+    // 1. Scanner les fichiers .html externes (cas le plus courant)
+    const htmlFiles = (0, file_helpers_1.collectFiles)(targetDir, /\.html$/);
+    for (const htmlFile of htmlFiles) {
+        const relativeFilePath = path.relative(projectRoot, htmlFile);
+        try {
+            const htmlContent = fs.readFileSync(htmlFile, 'utf-8');
+            for (const rule of htmlRules) {
+                const htmlMatches = matchers_1.HtmlMatcher.findHtmlPatternMatches(htmlContent, rule.astPattern);
+                for (const match of htmlMatches) {
+                    matches.push({
+                        ruleKey: rule.key,
+                        ruleSummary: rule.summary,
+                        filePath: relativeFilePath,
+                        lineNumber: match.lineNumber,
+                        matchedText: match.matchedText
+                    });
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.warning(`Impossible de lire le fichier HTML: ${htmlFile}`);
+        }
+    }
+    // 2. Scanner les templates inline dans les fichiers .ts (moins courant mais nécessaire)
+    scanInlineTemplates(targetDir, htmlRules, projectRoot, matches);
+}
+/**
+ * Scan les templates inline dans les fichiers TypeScript
+ * Détecte les patterns HTML standalone dans les templates définis avec template: `...`
+ *
+ * Note: Les patterns Decorator (avec contexte @Component) sont déjà gérés par DecoratorMatcher.
+ * Cette fonction gère uniquement les patterns HTML sans contexte Decorator (Element, Attribute, etc.)
+ */
+function scanInlineTemplates(targetDir, htmlRules, projectRoot, matches) {
+    const tsFiles = (0, file_helpers_1.collectFiles)(targetDir, /\.ts$/);
+    for (const tsFile of tsFiles) {
+        try {
+            const fileContent = fs.readFileSync(tsFile, 'utf-8');
+            const relativeFilePath = path.relative(projectRoot, tsFile);
+            // Regex pour extraire templates inline (supporte backticks simples)
+            // Capture: template: `...` avec support multiline
+            const templateRegex = /template\s*:\s*`([^`]*)`/gs;
+            let match;
+            while ((match = templateRegex.exec(fileContent)) !== null) {
+                const htmlContent = match[1];
+                const templateStartIndex = match.index + match[0].indexOf(match[1]);
+                // Calculer la ligne de début du template dans le fichier .ts
+                const linesBefore = fileContent.substring(0, templateStartIndex).split('\n').length;
+                for (const rule of htmlRules) {
+                    const htmlMatches = matchers_1.HtmlMatcher.findHtmlPatternMatches(htmlContent, rule.astPattern);
+                    for (const htmlMatch of htmlMatches) {
+                        // Ajuster le numéro de ligne pour pointer vers le fichier .ts
+                        const actualLineNumber = linesBefore + htmlMatch.lineNumber - 1;
+                        matches.push({
+                            ruleKey: rule.key,
+                            ruleSummary: rule.summary,
+                            filePath: relativeFilePath,
+                            lineNumber: actualLineNumber,
+                            matchedText: htmlMatch.matchedText
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Silencieux - pas critique si on ne peut pas lire un fichier .ts
+            // (le scan TypeScript principal l'aurait déjà signalé si vraiment problématique)
+        }
+    }
+}
+/**
+ * Crée un projet ts-morph avec configuration optimale
+ */
+function createTsMorphProject() {
+    return new ts_morph_1.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            target: 99, // ESNext
+            module: 99, // ESNext
+        }
+    });
+}
+/**
+ * Ajoute les fichiers au projet ts-morph avec gestion d'erreurs
+ */
+function addFilesToProject(project, tsFiles) {
+    for (const filePath of tsFiles) {
+        try {
+            project.addSourceFileAtPath(filePath);
+        }
+        catch (error) {
+            logger_1.logger.warning(`Impossible d'analyser: ${filePath}`);
+        }
+    }
+}
+/**
+ * Trouve les matches d'un pattern AST dans un fichier
+ */
+function findAstPatternMatches(sourceFile, rule, relativeFilePath) {
+    const matches = [];
+    const pattern = rule.astPattern;
+    // Vérifier le filtre inFile (filtrage par nom de fichier)
+    if (pattern.inFile && !matchers_1.FileMatcher.matchesInFilePattern(relativeFilePath, pattern.inFile)) {
+        return matches;
+    }
+    // Parcourir tous les nœuds de l'AST
+    sourceFile.forEachDescendant((node) => {
+        if ((0, matchers_1.matchesAstPattern)(node, pattern)) {
+            // Vérifier testSetup si présent dans le pattern
+            if (pattern.testSetup && !matchers_1.FileMatcher.matchesTestSetup(sourceFile, pattern.testSetup)) {
+                return; // Skip ce nœud si testSetup ne correspond pas
+            }
+            const lineNumber = node.getStartLineNumber();
+            const matchedText = node.getText().substring(0, 100); // Limiter à 100 caractères
+            matches.push({
+                ruleKey: rule.key,
+                ruleSummary: rule.summary,
+                filePath: relativeFilePath,
+                lineNumber,
+                matchedText: matchedText.trim()
+            });
+        }
+    });
+    return matches;
+}

package/dist/src/core/project-detector.js

@@ -0,0 +1,196 @@
+"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.detectProject = detectProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const app_analyzer_1 = require("./app-analyzer");
+/**
+ * Détecte le type de projet Angular (Nx Monorepo ou Standalone)
+ */
+function detectProject(projectPath) {
+    const nxJsonPath = path.join(projectPath, 'nx.json');
+    const angularJsonPath = path.join(projectPath, 'angular.json');
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    const appsDir = path.join(projectPath, 'apps');
+    const libsDir = path.join(projectPath, 'libs');
+    if (!fs.existsSync(projectPath)) {
+        throw new Error(`Le chemin du projet n'existe pas: ${projectPath}`);
+    }
+    const hasNxJson = fs.existsSync(nxJsonPath);
+    const hasAngularJson = fs.existsSync(angularJsonPath);
+    const hasPackageJson = fs.existsSync(packageJsonPath);
+    const hasAppsDir = fs.existsSync(appsDir);
+    const hasLibsDir = fs.existsSync(libsDir);
+    let type = 'unknown';
+    let name = path.basename(projectPath);
+    let angularVersion;
+    let appNames = [];
+    let libNames = [];
+    if (hasNxJson && hasAppsDir) {
+        type = 'nx-monorepo';
+        appNames = extractNxApps(projectPath);
+        if (hasLibsDir) {
+            libNames = extractNxLibs(projectPath);
+        }
+    }
+    else if (hasAngularJson) {
+        type = 'angular-standalone';
+        appNames = extractAngularApps(angularJsonPath);
+    }
+    if (hasPackageJson) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        name = packageJson.name || name;
+        angularVersion = extractAngularVersion(packageJson);
+    }
+    const isNxMonorepo = type === 'nx-monorepo';
+    const apps = appNames.map((appName) => (0, app_analyzer_1.analyzeApp)(appName, projectPath, isNxMonorepo));
+    const libs = isNxMonorepo
+        ? libNames.map((libName) => (0, app_analyzer_1.analyzeLib)(libName, projectPath))
+        : [];
+    return {
+        path: projectPath,
+        type,
+        name,
+        angularVersion,
+        apps,
+        libs
+    };
+}
+function extractNxApps(projectPath) {
+    const appsDir = path.join(projectPath, 'apps');
+    if (!fs.existsSync(appsDir)) {
+        return [];
+    }
+    try {
+        const entries = fs.readdirSync(appsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .filter((dir) => {
+            const projectJsonPath = path.join(appsDir, dir.name, 'project.json');
+            return fs.existsSync(projectJsonPath);
+        })
+            .map((dir) => dir.name);
+    }
+    catch {
+        return [];
+    }
+}
+function extractAngularApps(angularJsonPath) {
+    if (!fs.existsSync(angularJsonPath)) {
+        return [];
+    }
+    try {
+        const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf-8'));
+        return Object.keys(angularJson.projects || {}).filter((projectName) => {
+            const project = angularJson.projects[projectName];
+            return project.projectType === 'application';
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function extractNxLibs(projectPath) {
+    const libsDir = path.join(projectPath, 'libs');
+    if (!fs.existsSync(libsDir)) {
+        return [];
+    }
+    try {
+        const libs = [];
+        // Fonction récursive pour scanner les libs (support structure groupée)
+        function scanLibsRecursive(dir, relativePath = '') {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const fullPath = path.join(dir, entry.name);
+                const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                if (isValidNxLib(fullPath)) {
+                    // C'est une lib valide Nx
+                    libs.push(newRelativePath);
+                }
+                else {
+                    // C'est un dossier de groupe, scanner récursivement
+                    scanLibsRecursive(fullPath, newRelativePath);
+                }
+            }
+        }
+        scanLibsRecursive(libsDir);
+        return libs;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Vérifie si un dossier est une lib Nx valide
+ * Critères obligatoires :
+ * 1. project.json (configuration Nx)
+ * 2. index.ts (racine OU src/) OU src/lib/ (code de la lib)
+ * 3. tsconfig.json ou tsconfig.lib.json (configuration TypeScript)
+ */
+function isValidNxLib(libPath) {
+    // 1. project.json obligatoire
+    const projectJsonPath = path.join(libPath, 'project.json');
+    if (!fs.existsSync(projectJsonPath)) {
+        return false;
+    }
+    // 2. Vérifier présence de code source
+    // Option A : index.ts à la racine (ex: libs/apis/deployment-tool/index.ts)
+    const hasRootIndexTs = fs.existsSync(path.join(libPath, 'index.ts'));
+    // Option B : src/index.ts (structure standard)
+    const hasSrcIndexTs = fs.existsSync(path.join(libPath, 'src', 'index.ts'));
+    // Option C : src/lib/ (barrel export dans lib/)
+    const hasSrcLibDir = fs.existsSync(path.join(libPath, 'src', 'lib'));
+    if (!hasRootIndexTs && !hasSrcIndexTs && !hasSrcLibDir) {
+        return false;
+    }
+    return true;
+}
+function extractAngularVersion(packageJson) {
+    if (typeof packageJson !== 'object' ||
+        packageJson === null ||
+        !('dependencies' in packageJson)) {
+        return undefined;
+    }
+    const deps = packageJson.dependencies;
+    const angularCore = deps['@angular/core'];
+    if (!angularCore) {
+        return undefined;
+    }
+    const versionMatch = angularCore.match(/(\d+)\./);
+    return versionMatch ? versionMatch[1] : undefined;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectStrategy = exports.StandaloneStrategy = exports.NxStrategy = void 0;
+var nx_strategy_1 = require("./nx-strategy");
+Object.defineProperty(exports, "NxStrategy", { enumerable: true, get: function () { return nx_strategy_1.NxStrategy; } });
+var standalone_strategy_1 = require("./standalone-strategy");
+Object.defineProperty(exports, "StandaloneStrategy", { enumerable: true, get: function () { return standalone_strategy_1.StandaloneStrategy; } });
+var strategy_factory_1 = require("./strategy-factory");
+Object.defineProperty(exports, "createProjectStrategy", { enumerable: true, get: function () { return strategy_factory_1.createProjectStrategy; } });