StillHammer
f51c4095f6
- Add complete modular demo interface (public/modular-pipeline-demo.html) - Add standalone demo server (simple-server.js) on port 3333 - Integrate real SelectiveCore, AdversarialCore, HumanSimulation, PatternBreaking modules - Add configurable pipeline with step-by-step content transformation display - Add new trend management and workflow configuration modules - Add comprehensive test suite for full pipeline validation - Update core modules for better modular integration and demo compatibility 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
573 lines
18 KiB
JavaScript
573 lines
18 KiB
JavaScript
// ========================================
|
|
// DYNAMIC PROMPT ENGINE - SYSTÈME AVANCÉ
|
|
// Responsabilité: Génération dynamique de prompts adaptatifs ultra-modulaires
|
|
// ========================================
|
|
|
|
const { logSh } = require('../ErrorReporting');
|
|
const { tracer } = require('../trace');
|
|
|
|
/**
|
|
* DYNAMIC PROMPT ENGINE
|
|
* Système avancé de génération de prompts avec composition multi-niveaux
|
|
*/
|
|
class DynamicPromptEngine {
|
|
constructor() {
|
|
this.name = 'DynamicPromptEngine';
|
|
this.templates = new Map();
|
|
this.contextAnalyzers = new Map();
|
|
this.adaptiveRules = new Map();
|
|
|
|
// Initialiser templates par défaut
|
|
this.initializeDefaultTemplates();
|
|
this.initializeContextAnalyzers();
|
|
this.initializeAdaptiveRules();
|
|
}
|
|
|
|
// ========================================
|
|
// INITIALISATION TEMPLATES
|
|
// ========================================
|
|
|
|
initializeDefaultTemplates() {
|
|
// Templates de base modulaires
|
|
this.templates.set('technical', {
|
|
meta: {
|
|
role: "Tu es un expert {domain} avec {experience} d'expérience",
|
|
expertise: "Spécialisé en {specialization} et {methods}",
|
|
approach: "Adopte une approche {style} et {precision}"
|
|
},
|
|
context: {
|
|
mission: "MISSION: {task_description}",
|
|
domain_context: "CONTEXTE: {sector} - {activity_type}",
|
|
target_audience: "PUBLIC: {audience_level} ({audience_characteristics})",
|
|
constraints: "CONTRAINTES: {content_constraints}"
|
|
},
|
|
task: {
|
|
primary_objective: "OBJECTIF PRINCIPAL: {main_goal}",
|
|
specific_actions: "ACTIONS SPÉCIFIQUES:\n{action_list}",
|
|
quality_criteria: "CRITÈRES DE QUALITÉ: {quality_requirements}",
|
|
success_metrics: "MÉTRIQUES DE SUCCÈS: {success_indicators}"
|
|
},
|
|
instructions: {
|
|
guidelines: "CONSIGNES {instruction_type}:\n{instruction_list}",
|
|
restrictions: "INTERDICTIONS: {avoid_list}",
|
|
emphasis: "PRIORITÉS: {emphasis_list}",
|
|
style_guide: "STYLE: {style_requirements}"
|
|
},
|
|
examples: {
|
|
format: "FORMAT ATTENDU:\n{format_example}",
|
|
sample_input: "EXEMPLE D'ENTRÉE: {input_example}",
|
|
sample_output: "EXEMPLE DE SORTIE: {output_example}"
|
|
}
|
|
});
|
|
|
|
this.templates.set('style', {
|
|
meta: {
|
|
role: "Tu es un rédacteur expert en communication {communication_type}",
|
|
personality: "Adopte la personnalité de {personality_profile}",
|
|
tone_master: "Maîtrise parfaitement le ton {target_tone}"
|
|
},
|
|
context: {
|
|
brand_voice: "IDENTITÉ: {brand_characteristics}",
|
|
target_emotion: "ÉMOTION CIBLE: {desired_emotion}",
|
|
communication_goal: "BUT COMMUNICATIONNEL: {communication_objective}",
|
|
audience_psychology: "PSYCHOLOGIE AUDIENCE: {audience_mindset}"
|
|
},
|
|
task: {
|
|
style_transformation: "TRANSFORMATION STYLISTIQUE: {transformation_type}",
|
|
tone_adaptation: "ADAPTATION TONALE: {tone_specifications}",
|
|
personality_injection: "INJECTION PERSONNALITÉ: {personality_traits}",
|
|
emotional_calibration: "CALIBRAGE ÉMOTIONNEL: {emotional_targets}"
|
|
}
|
|
});
|
|
|
|
this.templates.set('adversarial', {
|
|
meta: {
|
|
role: "Tu es un expert en rédaction naturelle anti-détection",
|
|
stealth_mode: "Mode furtif niveau {stealth_level}",
|
|
human_mimicry: "Imite parfaitement l'écriture humaine {human_characteristics}"
|
|
},
|
|
context: {
|
|
detection_threats: "MENACES DÉTECTION: {detector_types}",
|
|
target_metrics: "MÉTRIQUES CIBLES: {target_scores}",
|
|
natural_patterns: "PATTERNS NATURELS: {natural_characteristics}",
|
|
human_variance: "VARIANCE HUMAINE: {variance_patterns}"
|
|
},
|
|
task: {
|
|
stealth_rewrite: "RÉÉCRITURE FURTIVE: {stealth_techniques}",
|
|
pattern_breaking: "CASSAGE PATTERNS: {pattern_break_methods}",
|
|
human_errors: "ERREURS HUMAINES: {human_error_types}",
|
|
style_diversification: "DIVERSIFICATION: {diversification_methods}"
|
|
}
|
|
});
|
|
|
|
logSh(`✅ ${this.templates.size} templates modulaires initialisés`, 'DEBUG');
|
|
}
|
|
|
|
initializeContextAnalyzers() {
|
|
// Analyseurs de contexte automatiques
|
|
this.contextAnalyzers.set('domain_inference', (content, csvData) => {
|
|
const mc0 = csvData?.mc0?.toLowerCase() || '';
|
|
|
|
if (mc0.includes('signalétique') || mc0.includes('plaque')) {
|
|
return {
|
|
domain: 'signalétique industrielle',
|
|
specialization: 'communication visuelle B2B',
|
|
sector: 'industrie/signalétique',
|
|
activity_type: 'fabrication sur mesure'
|
|
};
|
|
}
|
|
|
|
if (mc0.includes('bijou') || mc0.includes('gravure')) {
|
|
return {
|
|
domain: 'artisanat créatif',
|
|
specialization: 'joaillerie personnalisée',
|
|
sector: 'artisanat/luxe',
|
|
activity_type: 'création artisanale'
|
|
};
|
|
}
|
|
|
|
return {
|
|
domain: 'communication visuelle',
|
|
specialization: 'impression numérique',
|
|
sector: 'services/impression',
|
|
activity_type: 'prestation de services'
|
|
};
|
|
});
|
|
|
|
this.contextAnalyzers.set('complexity_assessment', (content) => {
|
|
const totalText = Object.values(content).join(' ');
|
|
const technicalTerms = (totalText.match(/\b(technique|procédé|norme|ISO|DIN|matériau|aluminum|PMMA)\b/gi) || []).length;
|
|
const complexity = technicalTerms / totalText.split(' ').length;
|
|
|
|
return {
|
|
complexity_level: complexity > 0.05 ? 'élevée' : complexity > 0.02 ? 'moyenne' : 'standard',
|
|
technical_density: complexity,
|
|
recommended_approach: complexity > 0.05 ? 'expert' : 'accessible'
|
|
};
|
|
});
|
|
|
|
this.contextAnalyzers.set('audience_inference', (content, csvData, trend) => {
|
|
const personality = csvData?.personality;
|
|
|
|
if (trend?.id === 'generation-z') {
|
|
return {
|
|
audience_level: 'digital natives',
|
|
audience_characteristics: 'connectés, inclusifs, authentiques',
|
|
audience_mindset: 'recherche authenticité et transparence'
|
|
};
|
|
}
|
|
|
|
if (personality?.style === 'technique') {
|
|
return {
|
|
audience_level: 'professionnels techniques',
|
|
audience_characteristics: 'expérimentés, précis, orientés solutions',
|
|
audience_mindset: 'recherche expertise et fiabilité'
|
|
};
|
|
}
|
|
|
|
return {
|
|
audience_level: 'grand public',
|
|
audience_characteristics: 'curieux, pragmatiques, sensibles qualité',
|
|
audience_mindset: 'recherche clarté et valeur ajoutée'
|
|
};
|
|
});
|
|
|
|
logSh(`✅ ${this.contextAnalyzers.size} analyseurs de contexte initialisés`, 'DEBUG');
|
|
}
|
|
|
|
initializeAdaptiveRules() {
|
|
// Règles d'adaptation conditionnelles
|
|
this.adaptiveRules.set('intensity_scaling', {
|
|
condition: (config) => config.intensity,
|
|
adaptations: {
|
|
low: (config) => ({
|
|
precision: 'accessible',
|
|
style: 'naturel et fluide',
|
|
instruction_type: 'DOUCES',
|
|
stealth_level: 'discret'
|
|
}),
|
|
medium: (config) => ({
|
|
precision: 'équilibrée',
|
|
style: 'professionnel et engageant',
|
|
instruction_type: 'STANDARD',
|
|
stealth_level: 'modéré'
|
|
}),
|
|
high: (config) => ({
|
|
precision: 'maximale',
|
|
style: 'expert et percutant',
|
|
instruction_type: 'STRICTES',
|
|
stealth_level: 'avancé'
|
|
})
|
|
},
|
|
getLevel: (intensity) => {
|
|
if (intensity < 0.7) return 'low';
|
|
if (intensity < 1.2) return 'medium';
|
|
return 'high';
|
|
}
|
|
});
|
|
|
|
this.adaptiveRules.set('trend_adaptation', {
|
|
condition: (config) => config.trend,
|
|
adaptations: {
|
|
'eco-responsable': {
|
|
communication_type: 'responsable et engagée',
|
|
desired_emotion: 'confiance et respect',
|
|
brand_characteristics: 'éthique, durable, transparente',
|
|
communication_objective: 'sensibiliser et rassurer'
|
|
},
|
|
'tech-innovation': {
|
|
communication_type: 'moderne et dynamique',
|
|
desired_emotion: 'excitation et confiance',
|
|
brand_characteristics: 'innovante, performante, avant-gardiste',
|
|
communication_objective: 'impressionner et convaincre'
|
|
},
|
|
'artisanal-premium': {
|
|
communication_type: 'authentique et raffinée',
|
|
desired_emotion: 'admiration et désir',
|
|
brand_characteristics: 'traditionnelle, qualitative, exclusive',
|
|
communication_objective: 'valoriser et différencier'
|
|
}
|
|
}
|
|
});
|
|
|
|
logSh(`✅ ${this.adaptiveRules.size} règles adaptatives initialisées`, 'DEBUG');
|
|
}
|
|
|
|
// ========================================
|
|
// GÉNÉRATION DYNAMIQUE DE PROMPTS
|
|
// ========================================
|
|
|
|
/**
|
|
* MAIN METHOD - Génère un prompt adaptatif complet
|
|
*/
|
|
async generateAdaptivePrompt(config) {
|
|
return await tracer.run('DynamicPromptEngine.generateAdaptivePrompt()', async () => {
|
|
const {
|
|
templateType = 'technical',
|
|
content = {},
|
|
csvData = null,
|
|
trend = null,
|
|
layerConfig = {},
|
|
customVariables = {}
|
|
} = config;
|
|
|
|
await tracer.annotate({
|
|
templateType,
|
|
hasTrend: !!trend,
|
|
contentSize: Object.keys(content).length,
|
|
hasCustomVars: Object.keys(customVariables).length > 0
|
|
});
|
|
|
|
logSh(`🧠 Génération prompt adaptatif: ${templateType}`, 'INFO');
|
|
|
|
try {
|
|
// 1. ANALYSE CONTEXTUELLE AUTOMATIQUE
|
|
const contextAnalysis = await this.analyzeContext(content, csvData, trend);
|
|
|
|
// 2. APPLICATION RÈGLES ADAPTATIVES
|
|
const adaptiveConfig = this.applyAdaptiveRules(layerConfig, trend, contextAnalysis);
|
|
|
|
// 3. GÉNÉRATION VARIABLES DYNAMIQUES
|
|
const dynamicVariables = this.generateDynamicVariables(
|
|
contextAnalysis,
|
|
adaptiveConfig,
|
|
customVariables,
|
|
layerConfig
|
|
);
|
|
|
|
// 4. COMPOSITION TEMPLATE MULTI-NIVEAUX
|
|
const composedPrompt = this.composeMultiLevelPrompt(
|
|
templateType,
|
|
dynamicVariables,
|
|
layerConfig
|
|
);
|
|
|
|
// 5. POST-PROCESSING ADAPTATIF
|
|
const finalPrompt = this.postProcessPrompt(composedPrompt, adaptiveConfig);
|
|
|
|
const stats = {
|
|
templateType,
|
|
variablesCount: Object.keys(dynamicVariables).length,
|
|
adaptationRules: Object.keys(adaptiveConfig).length,
|
|
promptLength: finalPrompt.length,
|
|
contextComplexity: contextAnalysis.complexity_level
|
|
};
|
|
|
|
logSh(`✅ Prompt adaptatif généré: ${stats.promptLength} chars, ${stats.variablesCount} variables`, 'DEBUG');
|
|
|
|
return {
|
|
prompt: finalPrompt,
|
|
metadata: {
|
|
stats,
|
|
contextAnalysis,
|
|
adaptiveConfig,
|
|
dynamicVariables: Object.keys(dynamicVariables)
|
|
}
|
|
};
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur génération prompt adaptatif: ${error.message}`, 'ERROR');
|
|
throw error;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* ANALYSE CONTEXTUELLE AUTOMATIQUE
|
|
*/
|
|
async analyzeContext(content, csvData, trend) {
|
|
const context = {};
|
|
|
|
// Exécuter tous les analyseurs
|
|
for (const [analyzerName, analyzer] of this.contextAnalyzers) {
|
|
try {
|
|
const analysis = analyzer(content, csvData, trend);
|
|
Object.assign(context, analysis);
|
|
|
|
logSh(` 🔍 ${analyzerName}: ${JSON.stringify(analysis)}`, 'DEBUG');
|
|
} catch (error) {
|
|
logSh(` ⚠️ Analyseur ${analyzerName} échoué: ${error.message}`, 'WARNING');
|
|
}
|
|
}
|
|
|
|
return context;
|
|
}
|
|
|
|
/**
|
|
* APPLICATION DES RÈGLES ADAPTATIVES
|
|
*/
|
|
applyAdaptiveRules(layerConfig, trend, contextAnalysis) {
|
|
const adaptiveConfig = {};
|
|
|
|
for (const [ruleName, rule] of this.adaptiveRules) {
|
|
try {
|
|
if (rule.condition(layerConfig)) {
|
|
let adaptation = {};
|
|
|
|
if (ruleName === 'intensity_scaling') {
|
|
const level = rule.getLevel(layerConfig.intensity || 1.0);
|
|
adaptation = rule.adaptations[level](layerConfig);
|
|
} else if (ruleName === 'trend_adaptation' && trend) {
|
|
adaptation = rule.adaptations[trend.id] || {};
|
|
}
|
|
|
|
Object.assign(adaptiveConfig, adaptation);
|
|
logSh(` 🎛️ Règle ${ruleName} appliquée`, 'DEBUG');
|
|
}
|
|
} catch (error) {
|
|
logSh(` ⚠️ Règle ${ruleName} échouée: ${error.message}`, 'WARNING');
|
|
}
|
|
}
|
|
|
|
return adaptiveConfig;
|
|
}
|
|
|
|
/**
|
|
* GÉNÉRATION VARIABLES DYNAMIQUES
|
|
*/
|
|
generateDynamicVariables(contextAnalysis, adaptiveConfig, customVariables, layerConfig) {
|
|
const variables = {
|
|
// Variables contextuelles
|
|
...contextAnalysis,
|
|
|
|
// Variables adaptatives
|
|
...adaptiveConfig,
|
|
|
|
// Variables personnalisées
|
|
...customVariables,
|
|
|
|
// Variables de configuration
|
|
experience: this.generateExperienceLevel(contextAnalysis.complexity_level),
|
|
methods: this.generateMethods(layerConfig),
|
|
task_description: this.generateTaskDescription(layerConfig),
|
|
action_list: this.generateActionList(layerConfig),
|
|
instruction_list: this.generateInstructionList(layerConfig),
|
|
|
|
// Variables dynamiques calculées
|
|
timestamp: new Date().toISOString(),
|
|
session_id: this.generateSessionId()
|
|
};
|
|
|
|
return variables;
|
|
}
|
|
|
|
/**
|
|
* COMPOSITION TEMPLATE MULTI-NIVEAUX
|
|
*/
|
|
composeMultiLevelPrompt(templateType, variables, layerConfig) {
|
|
const template = this.templates.get(templateType);
|
|
if (!template) {
|
|
throw new Error(`Template ${templateType} introuvable`);
|
|
}
|
|
|
|
const sections = [];
|
|
|
|
// Composer chaque niveau du template
|
|
for (const [sectionName, sectionTemplate] of Object.entries(template)) {
|
|
const composedSection = this.composeSection(sectionTemplate, variables);
|
|
|
|
if (composedSection.trim()) {
|
|
sections.push(composedSection);
|
|
}
|
|
}
|
|
|
|
return sections.join('\n\n');
|
|
}
|
|
|
|
/**
|
|
* COMPOSITION SECTION INDIVIDUELLE
|
|
*/
|
|
composeSection(sectionTemplate, variables) {
|
|
const lines = [];
|
|
|
|
for (const [key, template] of Object.entries(sectionTemplate)) {
|
|
const interpolated = this.interpolateTemplate(template, variables);
|
|
|
|
if (interpolated && interpolated.trim() !== template) {
|
|
lines.push(interpolated);
|
|
}
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
/**
|
|
* INTERPOLATION TEMPLATE AVEC VARIABLES
|
|
*/
|
|
interpolateTemplate(template, variables) {
|
|
return template.replace(/\{([^}]+)\}/g, (match, varName) => {
|
|
return variables[varName] || match;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* POST-PROCESSING ADAPTATIF
|
|
*/
|
|
postProcessPrompt(prompt, adaptiveConfig) {
|
|
let processed = prompt;
|
|
|
|
// Suppression des lignes vides multiples
|
|
processed = processed.replace(/\n\n\n+/g, '\n\n');
|
|
|
|
// Suppression des variables non résolues
|
|
processed = processed.replace(/\{[^}]+\}/g, '');
|
|
|
|
// Suppression des lignes vides après suppression variables
|
|
processed = processed.replace(/\n\s*\n/g, '\n\n');
|
|
|
|
return processed.trim();
|
|
}
|
|
|
|
// ========================================
|
|
// GÉNÉRATEURS HELPER
|
|
// ========================================
|
|
|
|
generateExperienceLevel(complexity) {
|
|
switch (complexity) {
|
|
case 'élevée': return '10+ années';
|
|
case 'moyenne': return '5+ années';
|
|
default: return '3+ années';
|
|
}
|
|
}
|
|
|
|
generateMethods(layerConfig) {
|
|
const methods = [];
|
|
|
|
if (layerConfig.targetTerms?.length > 0) {
|
|
methods.push('terminologie spécialisée');
|
|
}
|
|
if (layerConfig.focusAreas?.length > 0) {
|
|
methods.push('approche métier');
|
|
}
|
|
|
|
return methods.length > 0 ? methods.join(', ') : 'méthodes éprouvées';
|
|
}
|
|
|
|
generateTaskDescription(layerConfig) {
|
|
const type = layerConfig.layerType || 'enhancement';
|
|
const descriptions = {
|
|
technical: 'Améliore la précision technique et le vocabulaire spécialisé',
|
|
style: 'Adapte le style et la personnalité du contenu',
|
|
adversarial: 'Rend le contenu plus naturel et humain'
|
|
};
|
|
|
|
return descriptions[type] || 'Améliore le contenu selon les spécifications';
|
|
}
|
|
|
|
generateActionList(layerConfig) {
|
|
const actions = [];
|
|
|
|
if (layerConfig.targetTerms) {
|
|
actions.push(`- Intégrer naturellement: ${layerConfig.targetTerms.slice(0, 5).join(', ')}`);
|
|
}
|
|
if (layerConfig.avoidTerms) {
|
|
actions.push(`- Éviter absolument: ${layerConfig.avoidTerms.slice(0, 3).join(', ')}`);
|
|
}
|
|
|
|
actions.push('- Conserver le message original et la structure');
|
|
actions.push('- Maintenir la cohérence stylistique');
|
|
|
|
return actions.join('\n');
|
|
}
|
|
|
|
generateInstructionList(layerConfig) {
|
|
const instructions = [
|
|
'GARDE exactement le même sens et message',
|
|
'PRÉSERVE la structure et la longueur approximative',
|
|
'ASSURE-TOI que le résultat reste naturel et fluide'
|
|
];
|
|
|
|
if (layerConfig.preservePersonality) {
|
|
instructions.push('MAINTIENS la personnalité et le ton existants');
|
|
}
|
|
|
|
return instructions.map(i => `- ${i}`).join('\n');
|
|
}
|
|
|
|
generateSessionId() {
|
|
return Math.random().toString(36).substring(2, 15);
|
|
}
|
|
|
|
// ========================================
|
|
// API PUBLIQUE ÉTENDUE
|
|
// ========================================
|
|
|
|
/**
|
|
* Ajouter template personnalisé
|
|
*/
|
|
addCustomTemplate(name, template) {
|
|
this.templates.set(name, template);
|
|
logSh(`✨ Template personnalisé ajouté: ${name}`, 'INFO');
|
|
}
|
|
|
|
/**
|
|
* Ajouter analyseur de contexte
|
|
*/
|
|
addContextAnalyzer(name, analyzer) {
|
|
this.contextAnalyzers.set(name, analyzer);
|
|
logSh(`🔍 Analyseur personnalisé ajouté: ${name}`, 'INFO');
|
|
}
|
|
|
|
/**
|
|
* Ajouter règle adaptative
|
|
*/
|
|
addAdaptiveRule(name, rule) {
|
|
this.adaptiveRules.set(name, rule);
|
|
logSh(`🎛️ Règle adaptative ajoutée: ${name}`, 'INFO');
|
|
}
|
|
|
|
/**
|
|
* Status du moteur
|
|
*/
|
|
getEngineStatus() {
|
|
return {
|
|
templates: Array.from(this.templates.keys()),
|
|
contextAnalyzers: Array.from(this.contextAnalyzers.keys()),
|
|
adaptiveRules: Array.from(this.adaptiveRules.keys()),
|
|
totalComponents: this.templates.size + this.contextAnalyzers.size + this.adaptiveRules.size
|
|
};
|
|
}
|
|
}
|
|
|
|
// ============= EXPORTS =============
|
|
module.exports = { DynamicPromptEngine }; |