seo-generator-server/lib/adversarial-generation/demo-modulaire.js

// ========================================
// DÉMONSTRATION ARCHITECTURE MODULAIRE
// Usage: node lib/adversarial-generation/demo-modulaire.js
// Objectif: Valider l'intégration modulaire adversariale
// ========================================

const { logSh } = require('../ErrorReporting');

// Import modules adversariaux modulaires
const { applyAdversarialLayer } = require('./AdversarialCore');
const { 
  applyPredefinedStack,
  applyAdaptiveLayers,
  getAvailableStacks
} = require('./AdversarialLayers');
const { calculateAntiDetectionScore, evaluateAdversarialImprovement } = require('./AdversarialUtils');

/**
 * EXEMPLE D'UTILISATION MODULAIRE
 */
async function demoModularAdversarial() {
  console.log('\n🎯 === DÉMONSTRATION ADVERSARIAL MODULAIRE ===\n');

  // Contenu d'exemple (simulé contenu généré normal)
  const exempleContenu = {
    '|Titre_Principal_1|': 'Guide complet pour choisir votre plaque personnalisée',
    '|Introduction_1|': 'La personnalisation d\'une plaque signalétique représente un enjeu optimal pour votre entreprise. Cette solution comprehensive permet de créer une identité visuelle robuste et seamless.',
    '|Texte_1|': 'Il est important de noter que les matériaux utilisés sont cutting-edge. Par ailleurs, la qualité est optimal. En effet, nos solutions sont comprehensive et robust.',
    '|FAQ_Question_1|': 'Quels sont les matériaux disponibles ?',
    '|FAQ_Reponse_1|': 'Nos matériaux sont optimal : dibond, aluminium, PMMA. Ces solutions comprehensive garantissent une qualité robust et seamless.'
  };

  console.log('📊 CONTENU ORIGINAL:');
  Object.entries(exempleContenu).forEach(([tag, content]) => {
    console.log(`   ${tag}: "${content.substring(0, 60)}..."`);
  });

  // Analyser contenu original
  const scoreOriginal = calculateAntiDetectionScore(Object.values(exempleContenu).join(' '));
  console.log(`\n📈 Score anti-détection original: ${scoreOriginal}/100`);

  try {
    // ========================================
    // TEST 1: COUCHE SIMPLE
    // ========================================
    console.log('\n🔧 TEST 1: Application couche adversariale simple');
    
    const result1 = await applyAdversarialLayer(exempleContenu, {
      detectorTarget: 'general',
      intensity: 0.8,
      method: 'enhancement'
    });

    console.log(`✅ Résultat: ${result1.stats.elementsModified}/${result1.stats.elementsProcessed} éléments modifiés`);
    
    const scoreAmeliore = calculateAntiDetectionScore(Object.values(result1.content).join(' '));
    console.log(`📈 Score anti-détection amélioré: ${scoreAmeliore}/100 (+${scoreAmeliore - scoreOriginal})`);

    // ========================================
    // TEST 2: STACK PRÉDÉFINI
    // ========================================
    console.log('\n📦 TEST 2: Application stack prédéfini');
    
    // Lister stacks disponibles
    const stacks = getAvailableStacks();
    console.log('   Stacks disponibles:');
    stacks.forEach(stack => {
      console.log(`   - ${stack.name}: ${stack.description} (${stack.layersCount} couches)`);
    });
    
    const result2 = await applyPredefinedStack(exempleContenu, 'standardDefense', {
      csvData: { 
        personality: { nom: 'Marc', style: 'technique' },
        mc0: 'plaque personnalisée'
      }
    });

    console.log(`✅ Stack standard: ${result2.stats.totalModifications} modifications totales`);
    console.log(`   📊 Couches appliquées: ${result2.stats.layers.filter(l => l.success).length}/${result2.stats.layers.length}`);
    
    const scoreStack = calculateAntiDetectionScore(Object.values(result2.content).join(' '));
    console.log(`📈 Score anti-détection stack: ${scoreStack}/100 (+${scoreStack - scoreOriginal})`);

    // ========================================
    // TEST 3: COUCHES ADAPTATIVES
    // ========================================
    console.log('\n🧠 TEST 3: Application couches adaptatives');
    
    const result3 = await applyAdaptiveLayers(exempleContenu, {
      targetDetectors: ['gptZero', 'originality'],
      maxIntensity: 1.2
    });

    if (result3.stats.adaptive) {
      console.log(`✅ Adaptatif: ${result3.stats.layersApplied || result3.stats.totalModifications} modifications`);
      
      const scoreAdaptatif = calculateAntiDetectionScore(Object.values(result3.content).join(' '));
      console.log(`📈 Score anti-détection adaptatif: ${scoreAdaptatif}/100 (+${scoreAdaptatif - scoreOriginal})`);
    }

    // ========================================
    // COMPARAISON FINALE
    // ========================================
    console.log('\n📊 COMPARAISON FINALE:');
    
    const evaluation = evaluateAdversarialImprovement(
      Object.values(exempleContenu).join(' '),
      Object.values(result2.content).join(' '),
      'general'
    );
    
    console.log(`   🔹 Réduction empreintes IA: ${evaluation.fingerprintReduction.toFixed(2)}%`);
    console.log(`   🔹 Augmentation diversité: ${evaluation.diversityIncrease.toFixed(2)}%`);
    console.log(`   🔹 Amélioration variation: ${evaluation.variationIncrease.toFixed(2)}%`);
    console.log(`   🔹 Score amélioration global: ${evaluation.improvementScore}`);
    console.log(`   🔹 Taux modification: ${evaluation.modificationRate.toFixed(2)}%`);
    console.log(`   💡 Recommandation: ${evaluation.recommendation}`);

    // ========================================
    // EXEMPLES DE CONTENU TRANSFORMÉ
    // ========================================
    console.log('\n✨ EXEMPLES DE TRANSFORMATION:');
    
    const exempleTransforme = result2.content['|Introduction_1|'] || result1.content['|Introduction_1|'];
    console.log('\n📝 AVANT:');
    console.log(`   "${exempleContenu['|Introduction_1|']}"`);
    console.log('\n📝 APRÈS:');
    console.log(`   "${exempleTransforme}"`);

    console.log('\n✅ === DÉMONSTRATION MODULAIRE TERMINÉE ===\n');
    
    return {
      success: true,
      originalScore: scoreOriginal,
      improvedScore: Math.max(scoreAmeliore, scoreStack),
      improvement: evaluation.improvementScore
    };

  } catch (error) {
    console.error('\n❌ ERREUR DÉMONSTRATION:', error.message);
    return { success: false, error: error.message };
  }
}

/**
 * EXEMPLE D'INTÉGRATION AVEC PIPELINE NORMALE
 */
async function demoIntegrationPipeline() {
  console.log('\n🔗 === DÉMONSTRATION INTÉGRATION PIPELINE ===\n');
  
  // Simuler résultat pipeline normale (Level 1)
  const contenuNormal = {
    '|Titre_H1_1|': 'Solutions de plaques personnalisées professionnelles',
    '|Intro_1|': 'Notre expertise en signalétique permet de créer des plaques sur mesure adaptées à vos besoins spécifiques.',
    '|Texte_1|': 'Les matériaux proposés incluent l\'aluminium, le dibond et le PMMA. Chaque solution présente des avantages particuliers selon l\'usage prévu.'
  };
  
  console.log('💼 SCÉNARIO: Application adversarial post-pipeline normale');
  
  try {
    // Exemple Level 6 - Post-processing adversarial
    console.log('\n🎯 Étape 1: Contenu généré par pipeline normale');
    console.log('   ✅ Contenu de base: qualité préservée');
    
    console.log('\n🎯 Étape 2: Application couche adversariale modulaire');
    const resultAdversarial = await applyAdversarialLayer(contenuNormal, {
      detectorTarget: 'gptZero',
      intensity: 0.9,
      method: 'hybrid',
      preserveStructure: true
    });
    
    console.log(`   ✅ Couche adversariale: ${resultAdversarial.stats.elementsModified} éléments modifiés`);
    
    console.log('\n📊 RÉSULTAT FINAL:');
    Object.entries(resultAdversarial.content).forEach(([tag, content]) => {
      console.log(`   ${tag}:`);
      console.log(`     AVANT: "${contenuNormal[tag]}"`);
      console.log(`     APRÈS: "${content}"`);
      console.log('');
    });
    
    return { success: true, result: resultAdversarial };
    
  } catch (error) {
    console.error('❌ ERREUR INTÉGRATION:', error.message);
    return { success: false, error: error.message };
  }
}

// Exécuter démonstrations si fichier appelé directement
if (require.main === module) {
  (async () => {
    await demoModularAdversarial();
    await demoIntegrationPipeline();
  })().catch(console.error);
}

module.exports = {
  demoModularAdversarial,
  demoIntegrationPipeline
};