push-guardian 1.0.0

package/src/cli/command/install.js

@@ -0,0 +1,137 @@
+const { installHooks } = require('../install/hooks');
+const interactiveMenu = require('../../core/interactiveMenu/interactiveMenu');
+const { installCodeQualityTools } = require('../install/codeQualityTools');
+const { installMirroringTools } = require('../install/mirroring');
+const { loadConfig } = require('../../core/configManager');
+const { getChalk } = require('../../utils/chalk-wrapper');
+
+module.exports = {
+    name: 'install',
+    description: 'Installer les hooks Git',
+    options: [
+        {
+            flags: '-f, --force',
+            description: "forcer l'installation même si déjà installé"
+        },
+        {
+            flags: '-a, --all',
+            description: 'installer tous les modules disponibles'
+        },
+        {
+            flags: '--hooks',
+            description: 'installer les hooks Git'
+        },
+        {
+            flags: '--code-quality',
+            description: 'installer les outils de qualité de code'
+        },
+        {
+            flags: '--skip-hooks',
+            description: 'ne pas installer les hooks Git'
+        },
+        {
+            flags: '--skip-code-quality',
+            description: 'ne pas installer les outils de qualité de code'
+        },
+        {
+            flags: '--mirroring',
+            description: 'installer le système de mirroring'
+        },
+        {
+            flags: '--skip-mirroring',
+            description: 'ne pas installer le système de mirroring'
+        },
+        {
+            flags: '--file <path>',
+            description: 'installer les modules qui se trouvent dans le fichier de configuration'
+        }
+    ],
+    action: async (options) => {
+        const chalk = getChalk();
+        try {
+            if (
+                (options.hooks && options.skipHooks) ||
+                (options.codeQuality && options.skipCodeQuality) ||
+                (options.mirroring && options.skipMirroring)
+            ) {
+                console.log(
+                    chalk.red(
+                        '❌ Options conflictuelles. Veuillez vérifier vos options.\n\t\tVous ne pouvez pas utiliser --hooks et --skip-hooks, --code-quality et --skip-code-quality, ou --mirroring et --skip-mirroring simultanément.'
+                    )
+                );
+                return;
+            }
+
+            const config = options.file ? loadConfig(options.file) : null;
+            let selected = ['Hooks Git', 'Code Quality Tools', 'Mirroring'];
+            let preselectedHooks = false;
+            let preselectedCQT = [];
+            let preselectedMirroring = false;
+
+            if (options.file && config && config.install) {
+                if (config.install.hooks === true) {
+                    preselectedHooks = true;
+                }
+                if (config.install.CQT && Array.isArray(config.install.CQT)) {
+                    preselectedCQT = config.install.CQT;
+                }
+                if (config.install.mirroring === true) {
+                    preselectedMirroring = true;
+                }
+            }
+
+            if (options.skipHooks) selected = selected.filter((item) => item !== 'Hooks Git');
+            if (options.skipCodeQuality) selected = selected.filter((item) => item !== 'Code Quality Tools');
+            if (options.skipMirroring) selected = selected.filter((item) => item !== 'Mirroring');
+            else if (
+                options.hooks ||
+                options.codeQuality ||
+                options.mirroring ||
+                options.skipHooks ||
+                options.skipCodeQuality ||
+                options.skipMirroring
+            ) {
+                selected = [];
+                if (options.hooks && !options.skipHooks) selected.push('Hooks Git');
+                if (options.codeQuality && !options.skipCodeQuality) selected.push('Code Quality Tools');
+                if (options.mirroring && !options.skipMirroring) selected.push('Mirroring');
+
+                /* istanbul ignore next */
+                if (
+                    !options.hooks &&
+                    !options.codeQuality &&
+                    !options.mirroring &&
+                    (options.skipHooks || options.skipCodeQuality || options.skipMirroring)
+                ) {
+                    if (!options.skipHooks) selected.push('Hooks Git');
+                    if (!options.skipCodeQuality) selected.push('Code Quality Tools');
+                    if (!options.skipMirroring) selected.push('Mirroring');
+                }
+            } else {
+                if (options.all) {
+                    selected = ['Hooks Git', 'Code Quality Tools', 'Mirroring'];
+                } else if (preselectedHooks || preselectedCQT.length > 0 || preselectedMirroring) {
+                    selected = [];
+                    if (preselectedHooks) selected.push('Hooks Git');
+                    if (preselectedCQT.length > 0) selected.push('Code Quality Tools');
+                    if (preselectedMirroring) selected.push('Mirroring');
+                } else {
+                    selected = await interactiveMenu('Choisissez les modules à installer', selected);
+                }
+            }
+
+            const installers = {
+                'Hooks Git': () => installHooks(['commit-msg', 'post-checkout', 'pre-push'], options.force),
+                'Code Quality Tools': () => installCodeQualityTools(options.all, preselectedCQT),
+                Mirroring: () => installMirroringTools()
+            };
+
+            selected.forEach((item) => {
+                const installSelected = installers[item];
+                if (installSelected) installSelected();
+            });
+        } catch (error) {
+            console.error(chalk.red('❌ Une erreur est survenue :'), error.message);
+        }
+    }
+};

package/src/cli/command/mirror.js

@@ -0,0 +1,90 @@
+const { loadConfig } = require('../../core/configManager');
+const { SyncManager } = require('../../core/mirroring/syncManager');
+const { generateWorkflow } = require('../../core/mirroring/generate');
+const errorCMD = require('../../core/errorCMD');
+const { getEnv, loadEnv } = require('../../core/module/env-loader');
+const { getChalk } = require('../../utils/chalk-wrapper');
+
+module.exports = {
+    name: 'mirror',
+    description: 'Référentiels miroirs sur plusieurs plateformes (GitHub, GitLab, BitBucket, Azure DevOps)',
+    options: [
+        { flags: '-s --source <platform>', description: 'Plateforme source (github, gitlab, bitbucket, azure)' },
+        { flags: '-t --target <platform>', description: 'Plateforme cible (github, gitlab, bitbucket, azure)' },
+        {
+            flags: '-r --repo <name>',
+            description: 'Nom du référentiel source (et cible si --target-repo non spécifié)'
+        },
+        { flags: '--source-repo <name>', description: 'Nom du référentiel source' },
+        { flags: '--target-repo <name>', description: 'Nom du référentiel cible' },
+        { flags: '--source-owner <owner>', description: 'Propriétaire du référentiel source (requis pour GitHub)' },
+        { flags: '--target-owner <owner>', description: 'Propriétaire du référentiel cible (requis pour GitHub)' },
+        { flags: '-S --sync-branches', description: 'Activer la synchronisation des branches' },
+        { flags: '-p --public-repo', description: 'Visibilité du mirroir en public' },
+        { flags: '-g --generate', description: 'Génére un workflow' }
+    ],
+    action: async (options) => {
+        const chalk = getChalk();
+        const normalizePlatform = (platform) => (platform ? String(platform).trim().toLowerCase() : platform);
+        try {
+            loadEnv();
+            const config = loadConfig();
+
+            if (options.generate) {
+                generateWorkflow();
+                return;
+            }
+
+            if (!config.mirroring) {
+                console.log(chalk.red('❌ Configuration de mise en miroir manquante dans push-guardian.config.json'));
+                process.exit(1);
+            }
+
+            const sourcePlatform = normalizePlatform(options.source || getEnv('SOURCE_PLATFORM'));
+            const targetPlatform = normalizePlatform(options.target || getEnv('TARGET_PLATFORM'));
+            const sourceRepo = options.sourceRepo || getEnv('SOURCE_REPO');
+            const targetRepo = options.targetRepo || options.repo || getEnv('TARGET_REPO');
+            const sourceOwner = options.sourceOwner || getEnv('SOURCE_OWNER');
+            const targetOwner = options.targetOwner || getEnv('TARGET_OWNER');
+
+            console.log(
+                `SP: ${sourcePlatform}\tTP: ${targetPlatform}\tSR: ${sourceRepo}\tTR: ${targetRepo}\tSO: ${sourceOwner}\tTO: ${targetOwner}`
+            );
+
+            if (!sourcePlatform || !targetPlatform || !sourceRepo || !targetRepo || !sourceOwner || !targetOwner) {
+                console.log(
+                    chalk.red(
+                        "❌ Plateformes, repos et propriétaires source/cible requis. Spécifiez-les via options ou configurez des valeurs par défaut lors de l'installation."
+                    )
+                );
+                process.exit(1);
+            }
+
+            const platformsConfig = {
+                ...(config.mirroring.platforms || {})
+            };
+
+            [sourcePlatform, targetPlatform].filter(Boolean).forEach((platform) => {
+                platformsConfig[platform] = {
+                    ...(platformsConfig[platform] || {}),
+                    enabled: true
+                };
+            });
+
+            const syncManager = new SyncManager(platformsConfig);
+            await syncManager.mirror(
+                sourcePlatform,
+                targetPlatform,
+                sourceRepo,
+                targetRepo,
+                sourceOwner,
+                targetOwner,
+                options.syncBranches,
+                options.publicRepo
+            );
+            console.log(chalk.green('✅ Mise en miroir terminée avec succès'));
+        } catch (error) {
+            errorCMD(error);
+        }
+    }
+};

package/src/cli/command/performance.js

@@ -0,0 +1,160 @@
+const performanceAnalyzer = require('../../core/performance/performanceAnalyzer');
+const metricsCollector = require('../../core/performance/metricsCollector');
+const { getChalk } = require('../../utils/chalk-wrapper');
+const chalk = getChalk();
+
+module.exports = {
+    name: 'performance',
+    description: 'Analyser les performances de push-guardian',
+    options: [
+        {
+            flags: '-a, --analyze',
+            description: 'Analyser les performances actuelles'
+        },
+        {
+            flags: '-c, --compare <path>',
+            description: 'Comparer avec un rapport précédent'
+        },
+        {
+            flags: '-r, --report',
+            description: 'Afficher le dernier rapport'
+        },
+        {
+            flags: '--reset',
+            description: 'Réinitialiser les métriques'
+        },
+        {
+            flags: '-d, --detailed',
+            description: 'Afficher les détails complets'
+        },
+        {
+            flags: '-j, --json',
+            description: 'Sortie au format JSON'
+        }
+    ],
+    action: async (options) => {
+        try {
+            // Vérifier les options conflictuelles
+            const actions = [options.analyze, options.compare, options.report, options.reset].filter(Boolean);
+            if (actions.length > 1) {
+                console.log(
+                    chalk.red(
+                        '❌ Options conflictuelles. Veuillez choisir une seule action: --analyze, --compare, --report ou --reset'
+                    )
+                );
+                return;
+            }
+
+            // Si aucune option n'est fournie, afficher l'aide
+            if (!options.analyze && !options.compare && !options.report && !options.reset) {
+                console.log(chalk.yellow('Actions disponibles:'));
+                console.log(chalk.cyan('  -a, --analyze') + '        - Analyser les performances actuelles');
+                console.log(chalk.cyan('  -c, --compare <path>') + ' - Comparer avec un rapport précédent');
+                console.log(chalk.cyan('  -r, --report') + '         - Afficher le dernier rapport');
+                console.log(chalk.cyan('  --reset') + '            - Réinitialiser les métriques');
+                console.log(chalk.gray('\nOptions supplémentaires: -d, --detailed, -j, --json'));
+                console.log(chalk.gray('Exemple: npx push-guardian performance --analyze --detailed'));
+                return;
+            }
+
+            // Exécuter l'action demandée
+            if (options.analyze) {
+                console.log(chalk.blue('📊 Analyse des performances en cours...'));
+                await performanceAnalyzer.analyze(options);
+                if (options.detailed) {
+                    displayDetailedMetrics();
+                }
+            } else if (options.compare) {
+                console.log(chalk.blue('📊 Comparaison des rapports...'));
+                await performanceAnalyzer.compare(options.compare, options);
+            } else if (options.report) {
+                console.log(chalk.blue('📊 Rapport de performance actuel:'));
+                displayCurrentMetrics(options);
+            } else if (options.reset) {
+                metricsCollector.reset();
+                console.log(chalk.green('✅ Métriques réinitialisées'));
+            }
+        } catch (error) {
+            console.log(chalk.red('❌ Erreur:'), error.message);
+            process.exit(1);
+        }
+    }
+};
+
+/**
+ * Affiche les métriques actuelles
+ */
+function displayCurrentMetrics(options) {
+    const metrics = metricsCollector.getMetrics();
+
+    if (options.json) {
+        console.log(JSON.stringify(metrics, null, 2));
+        return;
+    }
+
+    console.log(chalk.bold('\n📈 Métriques de performance:\n'));
+
+    // Métriques système
+    if (metrics.system) {
+        console.log(chalk.cyan('Système:'));
+        console.log(`  RAM min: ${chalk.yellow(metrics.system.memory.min.toFixed(2))} MB`);
+        console.log(`  RAM max: ${chalk.yellow(metrics.system.memory.max.toFixed(2))} MB`);
+        console.log(`  RAM moyenne: ${chalk.yellow(metrics.system.memory.avg.toFixed(2))} MB`);
+        console.log(`  Threads actifs: ${chalk.yellow(metrics.system.threads.active)}`);
+        console.log(`  Ressources actives: ${chalk.yellow(metrics.system.threads.resources)}`);
+    }
+
+    if (metrics.validation) {
+        console.log(chalk.cyan('\nValidation:'));
+        console.log(`  Durée: ${chalk.yellow(metrics.validation.duration || 0)}ms`);
+        console.log(`  Fichiers analysés: ${chalk.yellow(metrics.validation.filesAnalyzed || 0)}`);
+    }
+
+    if (metrics.plugins) {
+        console.log(chalk.cyan('\nPlugins:'));
+        console.log(`  Chargés: ${chalk.yellow(metrics.plugins.loaded || 0)}`);
+        console.log(`  Temps de chargement: ${chalk.yellow(metrics.plugins.loadTime || 0)}ms`);
+    }
+
+    if (metrics.git) {
+        console.log(chalk.cyan('\nGit:'));
+        console.log(`  Opérations: ${chalk.yellow(metrics.git.operations || 0)}`);
+        console.log(`  Durée totale: ${chalk.yellow(metrics.git.duration || 0)}ms`);
+    }
+
+    // Afficher les statistiques calculées
+    if (metrics.stats) {
+        console.log(chalk.cyan('\nStatistiques:'));
+
+        if (metrics.stats.validation && metrics.stats.validation.count > 0) {
+            console.log(
+                `  Validations: ${chalk.yellow(metrics.stats.validation.count)} (${chalk.yellow(metrics.stats.validation.successRate.toFixed(1))}% succès)`
+            );
+        }
+
+        if (metrics.stats.hooks && metrics.stats.hooks.count > 0) {
+            console.log(
+                `  Hooks: ${chalk.yellow(metrics.stats.hooks.count)} (${chalk.yellow(metrics.stats.hooks.avgDuration.toFixed(2))}ms moy.)`
+            );
+        }
+
+        if (metrics.stats.linting && metrics.stats.linting.count > 0) {
+            console.log(
+                `  Linting: ${chalk.yellow(metrics.stats.linting.count)} (${chalk.yellow(metrics.stats.linting.avgDuration.toFixed(2))}ms moy.)`
+            );
+        }
+    }
+
+    console.log();
+}
+
+/**
+ * Affiche les métriques détaillées
+ */
+function displayDetailedMetrics() {
+    const metrics = metricsCollector.getMetrics();
+
+    console.log(chalk.bold('\n🔍 Détails des métriques:\n'));
+    console.log(JSON.stringify(metrics, null, 2));
+    console.log();
+}

package/src/cli/command/plugin.js

@@ -0,0 +1,171 @@
+const pluginRegistry = require('../../core/plugins/pluginRegistry');
+const pluginManager = require('../../core/plugins/pluginManager');
+const { getChalk } = require('../../utils/chalk-wrapper');
+const chalk = getChalk();
+
+module.exports = {
+    name: 'plugin',
+    description: 'Gestion des plugins push-guardian (list, commands, run, enable, disable, help)',
+    arguments: [
+        {
+            name: '<action>',
+            description: 'Action a executer (list, commands, run, enable, disable)'
+        },
+        { name: '[args...]', description: "Arguments de l'action" }
+    ],
+    action: async (action, args, options) => {
+        await pluginCommand([action, ...args], options);
+    }
+};
+
+/**
+ * Commande de gestion des plugins
+ * @param {Array} args - Arguments de la commande
+ * @param {Object} options - Options de la commande
+ */
+async function pluginCommand(args, options) {
+    const action = args[0];
+
+    if (!action) {
+        displayHelp();
+        return;
+    }
+
+    switch (action) {
+        case 'enable':
+            await handleEnable(args[1]);
+            break;
+
+        case 'disable':
+            await handleDisable(args[1]);
+            break;
+
+        case 'list':
+            handleList();
+            break;
+
+        case 'commands':
+            handleCommands();
+            break;
+
+        case 'run':
+            await handleRun(args.slice(1), options);
+            break;
+
+        default:
+            console.log(chalk.red(`Action inconnue: ${action}`));
+            displayHelp();
+    }
+}
+
+/**
+ * Active un plugin
+ */
+async function handleEnable(pluginName) {
+    if (!pluginName) {
+        console.log(chalk.red('Nom du plugin requis'));
+        console.log(chalk.yellow('Usage: push-guardian plugin enable <nom>'));
+        return;
+    }
+
+    pluginRegistry.enablePlugin(pluginName);
+}
+
+/**
+ * Désactive un plugin
+ */
+async function handleDisable(pluginName) {
+    if (!pluginName) {
+        console.log(chalk.red('Nom du plugin requis'));
+        console.log(chalk.yellow('Usage: push-guardian plugin disable <nom>'));
+        return;
+    }
+
+    pluginRegistry.disablePlugin(pluginName);
+}
+
+/**
+ * Liste les plugins installés
+ */
+function handleList() {
+    pluginManager.listPlugins();
+}
+
+/**
+ * Liste les commandes disponibles
+ */
+function handleCommands() {
+    pluginManager.displayCommands();
+}
+
+/**
+ * Exécute une commande d'un plugin
+ */
+async function handleRun(runArgs, options) {
+    if (!runArgs || runArgs.length === 0) {
+        console.log(chalk.red('Nom de commande requis'));
+        console.log(chalk.yellow('Usage: push-guardian plugin run <commande> [args...]'));
+        console.log(chalk.yellow('   ou: push-guardian plugin run <plugin> <commande> [args...]'));
+        return;
+    }
+
+    let pluginName;
+    let commandName;
+    let args = [];
+
+    const [firstArg, secondArg] = runArgs;
+    const pluginInfo = pluginRegistry.getPluginInfo(firstArg);
+    const isExplicitPluginSyntax = Boolean(secondArg) && Boolean(pluginInfo);
+
+    if (isExplicitPluginSyntax) {
+        pluginName = firstArg;
+        commandName = secondArg;
+        args = runArgs.slice(2);
+    } else {
+        commandName = firstArg;
+        args = runArgs.slice(1);
+
+        const matches = pluginManager.listCommands().filter((cmd) => cmd.command === commandName);
+
+        if (matches.length === 0) {
+            console.log(chalk.red(`Commande plugin introuvable: ${commandName}`));
+            console.log(chalk.yellow('Utilisez: push-guardian plugin commands'));
+            return;
+        }
+
+        if (matches.length > 1) {
+            const plugins = [...new Set(matches.map((m) => m.plugin))].join(', ');
+            console.log(chalk.red(`Commande ambiguë: ${commandName}`));
+            console.log(chalk.yellow(`Plugins correspondants: ${plugins}`));
+            console.log(chalk.yellow(`Utilisez: push-guardian plugin run <plugin> ${commandName} [args...]`));
+            return;
+        }
+
+        pluginName = matches[0].plugin;
+    }
+
+    try {
+        const result = await pluginManager.executeCommand(pluginName, commandName, args, options);
+        if (result !== undefined) {
+            console.log(result);
+        }
+    } catch (error) {
+        console.log(chalk.red('Erreur:'), error.message);
+    }
+}
+
+/**
+ * Affiche l'aide
+ */
+function displayHelp() {
+    console.log(chalk.bold('\nGestion des plugins push-guardian\n'));
+    console.log(chalk.cyan('Usage:') + ' push-guardian plugin <action> [options]\n');
+    console.log(chalk.bold('Actions disponibles:\n'));
+    console.log('  ' + chalk.green('enable <nom>') + '       - Active un plugin');
+    console.log('  ' + chalk.green('disable <nom>') + '      - Desactive un plugin');
+    console.log('  ' + chalk.green('list') + '               - Liste les plugins installes');
+    console.log('  ' + chalk.green('commands') + '           - Liste les commandes disponibles');
+    console.log('  ' + chalk.green('run <cmd> [args...]') + '  - Execute une commande unique');
+    console.log('  ' + chalk.green('run <plugin> <cmd>') + ' - Execute une commande de plugin');
+    console.log();
+}