368 lines
12 KiB
JavaScript
368 lines
12 KiB
JavaScript
// ========================================
|
|
// ÉTAPE 4: ENHANCEMENT STYLE PERSONNALITÉ ADVERSARIAL
|
|
// Responsabilité: Appliquer le style personnalité avec Mistral + anti-détection
|
|
// LLM: Mistral (température 0.8) + Prompts adversariaux
|
|
// ========================================
|
|
|
|
const { callLLM } = require('../LLMManager');
|
|
const { logSh } = require('../ErrorReporting');
|
|
const { tracer } = require('../trace');
|
|
const { createAdversarialPrompt } = require('./AdversarialPromptEngine');
|
|
const { DetectorStrategyManager } = require('./DetectorStrategies');
|
|
|
|
/**
|
|
* MAIN ENTRY POINT - ENHANCEMENT STYLE
|
|
* Input: { content: {}, csvData: {}, context: {} }
|
|
* Output: { content: {}, stats: {}, debug: {} }
|
|
*/
|
|
async function applyPersonalityStyleAdversarial(input) {
|
|
return await tracer.run('AdversarialStyleEnhancement.applyPersonalityStyleAdversarial()', async () => {
|
|
const { content, csvData, context = {}, adversarialConfig = {} } = input;
|
|
|
|
// Configuration adversariale par défaut
|
|
const config = {
|
|
detectorTarget: adversarialConfig.detectorTarget || 'general',
|
|
intensity: adversarialConfig.intensity || 1.0,
|
|
enableAdaptiveStrategy: adversarialConfig.enableAdaptiveStrategy || true,
|
|
contextualMode: adversarialConfig.contextualMode !== false,
|
|
...adversarialConfig
|
|
};
|
|
|
|
// Initialiser manager détecteur
|
|
const detectorManager = new DetectorStrategyManager(config.detectorTarget);
|
|
|
|
await tracer.annotate({
|
|
step: '4/4',
|
|
llmProvider: 'mistral',
|
|
elementsCount: Object.keys(content).length,
|
|
personality: csvData.personality?.nom,
|
|
mc0: csvData.mc0
|
|
});
|
|
|
|
const startTime = Date.now();
|
|
logSh(`🎯 ÉTAPE 4/4 ADVERSARIAL: Enhancement style ${csvData.personality?.nom} (Mistral + ${config.detectorTarget})`, 'INFO');
|
|
logSh(` 📊 ${Object.keys(content).length} éléments à styliser`, 'INFO');
|
|
|
|
try {
|
|
const personality = csvData.personality;
|
|
|
|
if (!personality) {
|
|
logSh(`⚠️ ÉTAPE 4/4: Aucune personnalité définie, style standard`, 'WARNING');
|
|
return {
|
|
content,
|
|
stats: { processed: Object.keys(content).length, enhanced: 0, duration: Date.now() - startTime },
|
|
debug: { llmProvider: 'mistral', step: 4, personalityApplied: 'none' }
|
|
};
|
|
}
|
|
|
|
// 1. Préparer éléments pour stylisation
|
|
const styleElements = prepareElementsForStyling(content);
|
|
|
|
// 2. Appliquer style en chunks avec prompts adversariaux
|
|
const styledResults = await applyStyleInChunksAdversarial(styleElements, csvData, config, detectorManager);
|
|
|
|
// 3. Merger résultats
|
|
const finalContent = { ...content };
|
|
let actuallyStyled = 0;
|
|
|
|
Object.keys(styledResults).forEach(tag => {
|
|
if (styledResults[tag] !== content[tag]) {
|
|
finalContent[tag] = styledResults[tag];
|
|
actuallyStyled++;
|
|
}
|
|
});
|
|
|
|
const duration = Date.now() - startTime;
|
|
const stats = {
|
|
processed: Object.keys(content).length,
|
|
enhanced: actuallyStyled,
|
|
personality: personality.nom,
|
|
duration
|
|
};
|
|
|
|
logSh(`✅ ÉTAPE 4/4 TERMINÉE: ${stats.enhanced} éléments stylisés ${personality.nom} (${duration}ms)`, 'INFO');
|
|
|
|
await tracer.event(`Enhancement style terminé`, stats);
|
|
|
|
return {
|
|
content: finalContent,
|
|
stats,
|
|
debug: {
|
|
llmProvider: 'mistral',
|
|
step: 4,
|
|
personalityApplied: personality.nom,
|
|
styleCharacteristics: {
|
|
vocabulaire: personality.vocabulairePref,
|
|
connecteurs: personality.connecteursPref,
|
|
style: personality.style
|
|
},
|
|
adversarialConfig: config,
|
|
detectorTarget: config.detectorTarget,
|
|
intensity: config.intensity
|
|
}
|
|
};
|
|
|
|
} catch (error) {
|
|
const duration = Date.now() - startTime;
|
|
logSh(`❌ ÉTAPE 4/4 ÉCHOUÉE après ${duration}ms: ${error.message}`, 'ERROR');
|
|
|
|
// Fallback: retourner contenu original si Mistral indisponible
|
|
logSh(`🔄 Fallback: contenu original conservé`, 'WARNING');
|
|
return {
|
|
content,
|
|
stats: { processed: Object.keys(content).length, enhanced: 0, duration },
|
|
debug: { llmProvider: 'mistral', step: 4, error: error.message, fallback: true }
|
|
};
|
|
}
|
|
}, input);
|
|
}
|
|
|
|
/**
|
|
* Préparer éléments pour stylisation
|
|
*/
|
|
function prepareElementsForStyling(content) {
|
|
const styleElements = [];
|
|
|
|
Object.keys(content).forEach(tag => {
|
|
const text = content[tag];
|
|
|
|
// Tous les éléments peuvent bénéficier d'adaptation personnalité
|
|
// Même les courts (titres) peuvent être adaptés au style
|
|
styleElements.push({
|
|
tag,
|
|
content: text,
|
|
priority: calculateStylePriority(text, tag)
|
|
});
|
|
});
|
|
|
|
// Trier par priorité (titres d'abord, puis textes longs)
|
|
styleElements.sort((a, b) => b.priority - a.priority);
|
|
|
|
return styleElements;
|
|
}
|
|
|
|
/**
|
|
* Calculer priorité de stylisation
|
|
*/
|
|
function calculateStylePriority(text, tag) {
|
|
let priority = 1.0;
|
|
|
|
// Titres = haute priorité (plus visible)
|
|
if (tag.includes('Titre') || tag.includes('H1') || tag.includes('H2')) {
|
|
priority += 0.5;
|
|
}
|
|
|
|
// Textes longs = priorité selon longueur
|
|
if (text.length > 200) {
|
|
priority += 0.3;
|
|
} else if (text.length > 100) {
|
|
priority += 0.2;
|
|
}
|
|
|
|
// Introduction = haute priorité
|
|
if (tag.includes('intro') || tag.includes('Introduction')) {
|
|
priority += 0.4;
|
|
}
|
|
|
|
return priority;
|
|
}
|
|
|
|
/**
|
|
* Appliquer style en chunks avec prompts adversariaux
|
|
*/
|
|
async function applyStyleInChunksAdversarial(styleElements, csvData, adversarialConfig, detectorManager) {
|
|
logSh(`🎯 Stylisation adversarial: ${styleElements.length} éléments selon ${csvData.personality.nom}`, 'DEBUG');
|
|
|
|
const results = {};
|
|
const chunks = chunkArray(styleElements, 8); // Chunks de 8 pour Mistral
|
|
|
|
for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
|
|
const chunk = chunks[chunkIndex];
|
|
|
|
try {
|
|
logSh(` 📦 Chunk ${chunkIndex + 1}/${chunks.length}: ${chunk.length} éléments`, 'DEBUG');
|
|
|
|
const basePrompt = createStylePrompt(chunk, csvData);
|
|
|
|
// Générer prompt adversarial pour stylisation
|
|
const adversarialPrompt = createAdversarialPrompt(basePrompt, {
|
|
detectorTarget: adversarialConfig.detectorTarget,
|
|
intensity: adversarialConfig.intensity * 1.1, // Intensité plus élevée pour style (plus visible)
|
|
elementType: 'style_enhancement',
|
|
personality: csvData.personality,
|
|
contextualMode: adversarialConfig.contextualMode,
|
|
csvData: csvData,
|
|
debugMode: false
|
|
});
|
|
|
|
const styledResponse = await callLLM('mistral', adversarialPrompt, {
|
|
temperature: 0.8,
|
|
maxTokens: 3000
|
|
}, csvData.personality);
|
|
|
|
const chunkResults = parseStyleResponse(styledResponse, chunk);
|
|
Object.assign(results, chunkResults);
|
|
|
|
logSh(` ✅ Chunk ${chunkIndex + 1}: ${Object.keys(chunkResults).length} stylisés`, 'DEBUG');
|
|
|
|
// Délai entre chunks
|
|
if (chunkIndex < chunks.length - 1) {
|
|
await sleep(1500);
|
|
}
|
|
|
|
} catch (error) {
|
|
logSh(` ❌ Chunk ${chunkIndex + 1} échoué: ${error.message}`, 'ERROR');
|
|
|
|
// Fallback: garder contenu original
|
|
chunk.forEach(element => {
|
|
results[element.tag] = element.content;
|
|
});
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Créer prompt de stylisation
|
|
*/
|
|
function createStylePrompt(chunk, csvData) {
|
|
const personality = csvData.personality;
|
|
|
|
let prompt = `MISSION: Adapte UNIQUEMENT le style de ces contenus selon ${personality.nom}.
|
|
|
|
CONTEXTE: Article SEO e-commerce ${csvData.mc0}
|
|
PERSONNALITÉ: ${personality.nom}
|
|
DESCRIPTION: ${personality.description}
|
|
STYLE: ${personality.style} adapté web professionnel
|
|
VOCABULAIRE: ${personality.vocabulairePref}
|
|
CONNECTEURS: ${personality.connecteursPref}
|
|
NIVEAU TECHNIQUE: ${personality.niveauTechnique}
|
|
LONGUEUR PHRASES: ${personality.longueurPhrases}
|
|
|
|
CONTENUS À STYLISER:
|
|
|
|
${chunk.map((item, i) => `[${i + 1}] TAG: ${item.tag} (Priorité: ${item.priority.toFixed(1)})
|
|
CONTENU: "${item.content}"`).join('\n\n')}
|
|
|
|
OBJECTIFS STYLISATION ${personality.nom.toUpperCase()}:
|
|
- Adapte le TON selon ${personality.style}
|
|
- Vocabulaire: ${personality.vocabulairePref}
|
|
- Connecteurs variés: ${personality.connecteursPref}
|
|
- Phrases: ${personality.longueurPhrases}
|
|
- Niveau: ${personality.niveauTechnique}
|
|
|
|
CONSIGNES STRICTES:
|
|
- GARDE le même contenu informatif et technique
|
|
- Adapte SEULEMENT ton, expressions, vocabulaire selon ${personality.nom}
|
|
- RESPECTE longueur approximative (±20%)
|
|
- ÉVITE répétitions excessives
|
|
- Style ${personality.nom} reconnaissable mais NATUREL web
|
|
- PAS de messages d'excuse
|
|
|
|
FORMAT RÉPONSE:
|
|
[1] Contenu stylisé selon ${personality.nom}
|
|
[2] Contenu stylisé selon ${personality.nom}
|
|
etc...`;
|
|
|
|
return prompt;
|
|
}
|
|
|
|
/**
|
|
* Parser réponse stylisation
|
|
*/
|
|
function parseStyleResponse(response, chunk) {
|
|
const results = {};
|
|
const regex = /\[(\d+)\]\s*([^[]*?)(?=\n\[\d+\]|$)/gs;
|
|
let match;
|
|
let index = 0;
|
|
|
|
while ((match = regex.exec(response)) && index < chunk.length) {
|
|
let styledContent = match[2].trim();
|
|
const element = chunk[index];
|
|
|
|
// Nettoyer le contenu stylisé
|
|
styledContent = cleanStyledContent(styledContent);
|
|
|
|
if (styledContent && styledContent.length > 10) {
|
|
results[element.tag] = styledContent;
|
|
logSh(`✅ Styled [${element.tag}]: "${styledContent.substring(0, 100)}..."`, 'DEBUG');
|
|
} else {
|
|
results[element.tag] = element.content;
|
|
logSh(`⚠️ Fallback [${element.tag}]: stylisation invalide`, 'WARNING');
|
|
}
|
|
|
|
index++;
|
|
}
|
|
|
|
// Compléter les manquants
|
|
while (index < chunk.length) {
|
|
const element = chunk[index];
|
|
results[element.tag] = element.content;
|
|
index++;
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Nettoyer contenu stylisé
|
|
*/
|
|
function cleanStyledContent(content) {
|
|
if (!content) return content;
|
|
|
|
// Supprimer préfixes indésirables
|
|
content = content.replace(/^(Bon,?\s*)?(alors,?\s*)?voici\s+/gi, '');
|
|
content = content.replace(/^pour\s+ce\s+contenu[,\s]*/gi, '');
|
|
content = content.replace(/\*\*[^*]+\*\*/g, '');
|
|
|
|
// Réduire répétitions excessives mais garder le style personnalité
|
|
content = content.replace(/(du coup[,\s]+){4,}/gi, 'du coup ');
|
|
content = content.replace(/(bon[,\s]+){4,}/gi, 'bon ');
|
|
content = content.replace(/(franchement[,\s]+){3,}/gi, 'franchement ');
|
|
|
|
content = content.replace(/\s{2,}/g, ' ');
|
|
content = content.trim();
|
|
|
|
return content;
|
|
}
|
|
|
|
/**
|
|
* Obtenir instructions de style dynamiques
|
|
*/
|
|
function getPersonalityStyleInstructions(personality) {
|
|
if (!personality) return "Style professionnel standard";
|
|
|
|
return `STYLE ${personality.nom.toUpperCase()} (${personality.style}):
|
|
- Description: ${personality.description}
|
|
- Vocabulaire: ${personality.vocabulairePref || 'professionnel'}
|
|
- Connecteurs: ${personality.connecteursPref || 'par ailleurs, en effet'}
|
|
- Mots-clés: ${personality.motsClesSecteurs || 'technique, qualité'}
|
|
- Phrases: ${personality.longueurPhrases || 'Moyennes'}
|
|
- Niveau: ${personality.niveauTechnique || 'Accessible'}
|
|
- CTA: ${personality.ctaStyle || 'Professionnel'}`;
|
|
}
|
|
|
|
// ============= HELPER FUNCTIONS =============
|
|
|
|
function chunkArray(array, size) {
|
|
const chunks = [];
|
|
for (let i = 0; i < array.length; i += size) {
|
|
chunks.push(array.slice(i, i + size));
|
|
}
|
|
return chunks;
|
|
}
|
|
|
|
function sleep(ms) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
module.exports = {
|
|
applyPersonalityStyleAdversarial, // ← MAIN ENTRY POINT ADVERSARIAL
|
|
prepareElementsForStyling,
|
|
calculateStylePriority,
|
|
applyStyleInChunksAdversarial,
|
|
createStylePrompt,
|
|
parseStyleResponse,
|
|
getPersonalityStyleInstructions
|
|
}; |