/g, '') // Enlever orphelins
+ .replace(/<\/code>/g, ''); // Enlever orphelins
+
+ // Log debug si changement
+ if (originalMatch !== fullMatch && originalMatch.includes('{{')) {
+ await logSh(` 🔧 Réparation HTML: "${originalMatch.substring(0, 80)}" → "${fullMatch.substring(0, 80)}"`, 'DEBUG');
+ }
+
// Séparer nom du tag et variables
const nameMatch = fullMatch.match(/^([^{]+)/);
- const variablesMatch = fullMatch.match(/\{\{([^}]+)\}\}/g);
-
- // FIX REGEX INSTRUCTIONS - Enlever d'abord les {{variables}} puis chercher {instructions}
- const withoutVariables = fullMatch.replace(/\{\{[^}]+\}\}/g, '');
- const instructionsMatch = withoutVariables.match(/\{([^}]+)\}/);
-
let tagName = nameMatch ? nameMatch[1].trim() : fullMatch.split('{')[0];
+ tagName = tagName.replace(/<\/?strong>/g, ''); // Nettoyage
- // NETTOYAGE: Enlever , du nom du tag
- tagName = tagName.replace(/<\/?strong>/g, '');
+ const variablesMatch = fullMatch.match(/\{\{([^}]+)\}\}/g);
+
+ // CAPTURER les instructions EN GARDANT les {{variables}} intactes
+ // Stratégie : d'abord enlever temporairement toutes les {{variables}},
+ // trouver la position de {instruction}, puis revenir au texte original
+ let instructionsMatch = null;
+
+ // Créer une version sans {{variables}} pour trouver où est {instruction}
+ const withoutVars = fullMatch.replace(/\{\{[^}]+\}\}/g, '');
+ const tempInstructionMatch = withoutVars.match(/\{([^}]+)\}/);
+
+ if (tempInstructionMatch) {
+ // On a trouvé une instruction dans la version sans variables
+ // Trouver le PREMIER { qui n'est PAS suivi de { (= début instruction)
+ let instructionStart = -1;
+ for (let idx = 0; idx < fullMatch.length - 1; idx++) {
+ if (fullMatch[idx] === '{' && fullMatch[idx + 1] !== '{') {
+ instructionStart = idx;
+ break;
+ }
+ }
+
+ if (instructionStart !== -1) {
+ // Capturer jusqu'à la } de fermeture (en ignorant les }} de variables)
+ let depth = 0;
+ let instructionEnd = -1;
+ let i = instructionStart;
+
+ while (i < fullMatch.length) {
+ if (fullMatch[i] === '{') {
+ if (fullMatch[i+1] === '{') {
+ // C'est une variable, skip les deux {
+ i += 2;
+ continue;
+ } else {
+ depth++;
+ }
+ } else if (fullMatch[i] === '}') {
+ if (fullMatch[i+1] === '}') {
+ // Fin de variable, skip les deux }
+ i += 2;
+ continue;
+ } else {
+ depth--;
+ if (depth === 0) {
+ instructionEnd = i;
+ break;
+ }
+ }
+ }
+ i++;
+ }
+
+ if (instructionEnd !== -1) {
+ const instructionContent = fullMatch.substring(instructionStart + 1, instructionEnd);
+ instructionsMatch = [fullMatch.substring(instructionStart, instructionEnd + 1), instructionContent];
+
+ // Log debug instruction capturée
+ await logSh(` 📜 Instruction capturée (${tagName}): ${instructionContent.substring(0, 80)}...`, 'DEBUG');
+ }
+ }
+ }
// TAG PUR (sans variables)
const pureTag = `|${tagName}|`;
// RÉSOUDRE le contenu des variables
const resolvedContent = resolveVariablesContent(variablesMatch, csvData);
-
+
+ // RÉSOUDRE aussi les variables DANS les instructions
+ let resolvedInstructions = instructionsMatch ? instructionsMatch[1] : null;
+ if (resolvedInstructions) {
+ const originalInstruction = resolvedInstructions;
+ // Remplacer chaque variable {{XX}} par sa valeur résolue
+ resolvedInstructions = resolvedInstructions.replace(/\{\{([^}]+)\}\}/g, (match, variable) => {
+ const singleVarMatch = [match];
+ return resolveVariablesContent(singleVarMatch, csvData);
+ });
+ // Log si changement
+ if (originalInstruction !== resolvedInstructions && originalInstruction.includes('{{')) {
+ await logSh(` ✨ Instructions résolues (${tagName}): ${originalInstruction.substring(0, 60)} → ${resolvedInstructions.substring(0, 60)}`, 'DEBUG');
+ }
+ }
+
elements.push({
originalTag: pureTag, // ← TAG PUR : |Titre_H3_3|
name: tagName, // ← Titre_H3_3
variables: variablesMatch || [], // ← [{{MC+1_3}}]
resolvedContent: resolvedContent, // ← "Plaque de rue en aluminium"
- instructions: instructionsMatch ? instructionsMatch[1] : null,
+ instructions: resolvedInstructions, // ← Instructions avec variables résolues
type: getElementType(tagName),
originalFullMatch: fullMatch // ← Backup si besoin
});
diff --git a/lib/Main.js b/lib/Main.js
index c6cf79b..64f3cd1 100644
--- a/lib/Main.js
+++ b/lib/Main.js
@@ -10,6 +10,9 @@ const { tracer } = require('./trace');
// Import système de tendances
const { TrendManager } = require('./trend-prompts/TrendManager');
+// Import système de pipelines flexibles
+const { PipelineExecutor } = require('./pipeline/PipelineExecutor');
+
// Imports pipeline de base
const { readInstructionsData, selectPersonalityWithAI, getPersonalities } = require('./BrainConfig');
const { extractElements, buildSmartHierarchy } = require('./ElementExtraction');
@@ -996,6 +999,33 @@ module.exports = {
// 🔄 COMPATIBILITÉ: Alias pour l'ancien handleFullWorkflow
handleFullWorkflow: async (data) => {
+ // 🆕 SYSTÈME DE PIPELINE FLEXIBLE
+ // Si pipelineConfig est fourni, utiliser PipelineExecutor au lieu du workflow modulaire classique
+ if (data.pipelineConfig) {
+ logSh(`🎨 Détection pipeline flexible: ${data.pipelineConfig.name}`, 'INFO');
+
+ const executor = new PipelineExecutor();
+ const result = await executor.execute(
+ data.pipelineConfig,
+ data.rowNumber || 2,
+ { stopOnError: data.stopOnError }
+ );
+
+ // Formater résultat pour compatibilité
+ return {
+ success: result.success,
+ finalContent: result.finalContent,
+ executionLog: result.executionLog,
+ stats: {
+ totalDuration: result.metadata.totalDuration,
+ personality: result.metadata.personality,
+ pipelineName: result.metadata.pipelineName,
+ totalSteps: result.metadata.totalSteps,
+ successfulSteps: result.metadata.successfulSteps
+ }
+ };
+ }
+
// Initialiser TrendManager si tendance spécifiée
let trendManager = null;
if (data.trendId) {
@@ -1016,12 +1046,12 @@ module.exports = {
trendManager: trendManager,
saveIntermediateSteps: data.saveIntermediateSteps || false
};
-
+
// Si des données CSV sont fournies directement (Make.com style)
if (data.csvData && data.xmlTemplate) {
return handleModularWorkflowWithData(data, config);
}
-
+
// Sinon utiliser le workflow normal
return handleModularWorkflow(config);
},
diff --git a/lib/adversarial-generation/AdversarialCore.js b/lib/adversarial-generation/AdversarialCore.js
index e0894dc..2d845ef 100644
--- a/lib/adversarial-generation/AdversarialCore.js
+++ b/lib/adversarial-generation/AdversarialCore.js
@@ -117,7 +117,7 @@ async function applyRegenerationMethod(existingContent, config, strategy) {
try {
const regenerationPrompt = createRegenerationPrompt(chunk, config, strategy);
- const response = await callLLM('claude', regenerationPrompt, {
+ const response = await callLLM(config.llmProvider || 'gemini', regenerationPrompt, {
temperature: 0.7 + (config.intensity * 0.2), // Température variable selon intensité
maxTokens: 2000 * chunk.length
}, config.csvData?.personality);
@@ -164,7 +164,7 @@ async function applyEnhancementMethod(existingContent, config, strategy) {
const enhancementPrompt = createEnhancementPrompt(elementsToEnhance, config, strategy);
try {
- const response = await callLLM('gpt4', enhancementPrompt, {
+ const response = await callLLM(config.llmProvider || 'gemini', enhancementPrompt, {
temperature: 0.5 + (config.intensity * 0.3),
maxTokens: 3000
}, config.csvData?.personality);
diff --git a/lib/modes/ManualServer.js b/lib/modes/ManualServer.js
index e34f02e..7402c0c 100644
--- a/lib/modes/ManualServer.js
+++ b/lib/modes/ManualServer.js
@@ -262,6 +262,466 @@ class ManualServer {
await this.handleGenerateSimple(req, res);
});
+ // ========================================
+ // ENDPOINTS GESTION CONFIGURATIONS
+ // ========================================
+
+ // Sauvegarder une configuration
+ this.app.post('/api/config/save', async (req, res) => {
+ try {
+ const { name, config } = req.body;
+
+ if (!name || !config) {
+ return res.status(400).json({
+ success: false,
+ error: 'Nom et configuration requis'
+ });
+ }
+
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ const result = await configManager.saveConfig(name, config);
+
+ res.json({
+ success: true,
+ message: `Configuration "${name}" sauvegardée`,
+ savedName: result.name
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur save config: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Lister les configurations
+ this.app.get('/api/config/list', async (req, res) => {
+ try {
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ const configs = await configManager.listConfigs();
+
+ res.json({
+ success: true,
+ configs,
+ count: configs.length
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur list configs: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Charger une configuration
+ this.app.get('/api/config/:name', async (req, res) => {
+ try {
+ const { name } = req.params;
+
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ const configData = await configManager.loadConfig(name);
+
+ res.json({
+ success: true,
+ config: configData
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur load config: ${error.message}`, 'ERROR');
+ res.status(404).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Supprimer une configuration
+ this.app.delete('/api/config/:name', async (req, res) => {
+ try {
+ const { name } = req.params;
+
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ await configManager.deleteConfig(name);
+
+ res.json({
+ success: true,
+ message: `Configuration "${name}" supprimée`
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur delete config: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // ========================================
+ // ENDPOINTS PIPELINE MANAGEMENT
+ // ========================================
+
+ // Sauvegarder un pipeline
+ this.app.post('/api/pipeline/save', async (req, res) => {
+ try {
+ const { pipelineDefinition } = req.body;
+
+ if (!pipelineDefinition) {
+ return res.status(400).json({
+ success: false,
+ error: 'pipelineDefinition requis'
+ });
+ }
+
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ const result = await configManager.savePipeline(pipelineDefinition);
+
+ res.json({
+ success: true,
+ message: `Pipeline "${pipelineDefinition.name}" sauvegardé`,
+ savedName: result.name
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur save pipeline: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Lister les pipelines
+ this.app.get('/api/pipeline/list', async (req, res) => {
+ try {
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ const pipelines = await configManager.listPipelines();
+
+ res.json({
+ success: true,
+ pipelines,
+ count: pipelines.length
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur list pipelines: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Obtenir modules disponibles (AVANT :name pour éviter conflit)
+ this.app.get('/api/pipeline/modules', async (req, res) => {
+ try {
+ const { PipelineDefinition, AVAILABLE_LLM_PROVIDERS } = require('../pipeline/PipelineDefinition');
+
+ const modules = PipelineDefinition.listModules();
+
+ res.json({
+ success: true,
+ modules,
+ llmProviders: AVAILABLE_LLM_PROVIDERS
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur get modules: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Obtenir templates prédéfinis (AVANT :name pour éviter conflit)
+ this.app.get('/api/pipeline/templates', async (req, res) => {
+ try {
+ const { listTemplates, getCategories } = require('../pipeline/PipelineTemplates');
+
+ const templates = listTemplates();
+ const categories = getCategories();
+
+ res.json({
+ success: true,
+ templates,
+ categories
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur get templates: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Obtenir template par nom (AVANT :name pour éviter conflit)
+ this.app.get('/api/pipeline/templates/:name', async (req, res) => {
+ try {
+ const { name } = req.params;
+ const { getTemplate } = require('../pipeline/PipelineTemplates');
+
+ const template = getTemplate(name);
+
+ if (!template) {
+ return res.status(404).json({
+ success: false,
+ error: `Template "${name}" non trouvé`
+ });
+ }
+
+ res.json({
+ success: true,
+ template
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur get template: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Charger un pipeline (Route paramétrée APRÈS les routes spécifiques)
+ this.app.get('/api/pipeline/:name', async (req, res) => {
+ try {
+ const { name } = req.params;
+
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ const pipeline = await configManager.loadPipeline(name);
+
+ res.json({
+ success: true,
+ pipeline
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur load pipeline: ${error.message}`, 'ERROR');
+ res.status(404).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Supprimer un pipeline
+ this.app.delete('/api/pipeline/:name', async (req, res) => {
+ try {
+ const { name } = req.params;
+
+ const { ConfigManager } = require('../ConfigManager');
+ const configManager = new ConfigManager();
+
+ await configManager.deletePipeline(name);
+
+ res.json({
+ success: true,
+ message: `Pipeline "${name}" supprimé`
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur delete pipeline: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Exécuter un pipeline
+ this.app.post('/api/pipeline/execute', async (req, res) => {
+ try {
+ const { pipelineConfig, rowNumber } = req.body;
+
+ if (!pipelineConfig) {
+ return res.status(400).json({
+ success: false,
+ error: 'pipelineConfig requis'
+ });
+ }
+
+ if (!rowNumber || rowNumber < 2) {
+ return res.status(400).json({
+ success: false,
+ error: 'rowNumber requis (minimum 2)'
+ });
+ }
+
+ logSh(`🚀 Exécution pipeline: ${pipelineConfig.name} (row ${rowNumber})`, 'INFO');
+
+ const { handleFullWorkflow } = require('../Main');
+
+ const result = await handleFullWorkflow({
+ pipelineConfig,
+ rowNumber,
+ source: 'pipeline_api'
+ });
+
+ res.json({
+ success: true,
+ result: {
+ finalContent: result.finalContent,
+ executionLog: result.executionLog,
+ stats: result.stats
+ }
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur execute pipeline: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Valider un pipeline
+ this.app.post('/api/pipeline/validate', async (req, res) => {
+ try {
+ const { pipelineDefinition } = req.body;
+
+ if (!pipelineDefinition) {
+ return res.status(400).json({
+ success: false,
+ error: 'pipelineDefinition requis'
+ });
+ }
+
+ const { PipelineDefinition } = require('../pipeline/PipelineDefinition');
+
+ const validation = PipelineDefinition.validate(pipelineDefinition);
+
+ res.json({
+ success: validation.valid,
+ valid: validation.valid,
+ errors: validation.errors
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur validate pipeline: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // Estimer durée/coût d'un pipeline
+ this.app.post('/api/pipeline/estimate', async (req, res) => {
+ try {
+ const { pipelineDefinition } = req.body;
+
+ if (!pipelineDefinition) {
+ return res.status(400).json({
+ success: false,
+ error: 'pipelineDefinition requis'
+ });
+ }
+
+ const { PipelineDefinition } = require('../pipeline/PipelineDefinition');
+
+ const summary = PipelineDefinition.getSummary(pipelineDefinition);
+ const duration = PipelineDefinition.estimateDuration(pipelineDefinition);
+
+ res.json({
+ success: true,
+ estimate: {
+ totalSteps: summary.totalSteps,
+ summary: summary.summary,
+ estimatedDuration: duration.formatted,
+ estimatedSeconds: duration.seconds
+ }
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur estimate pipeline: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
+ // ========================================
+ // ENDPOINT PRODUCTION RUN
+ // ========================================
+
+ this.app.post('/api/production-run', async (req, res) => {
+ try {
+ const {
+ rowNumber,
+ selectiveStack,
+ adversarialMode,
+ humanSimulationMode,
+ patternBreakingMode,
+ saveIntermediateSteps = true
+ } = req.body;
+
+ if (!rowNumber) {
+ return res.status(400).json({
+ success: false,
+ error: 'rowNumber requis'
+ });
+ }
+
+ logSh(`🚀 PRODUCTION RUN: Row ${rowNumber}`, 'INFO');
+
+ // Appel handleFullWorkflow depuis Main.js
+ const { handleFullWorkflow } = require('../Main');
+
+ const result = await handleFullWorkflow({
+ rowNumber,
+ selectiveStack: selectiveStack || 'standardEnhancement',
+ adversarialMode: adversarialMode || 'light',
+ humanSimulationMode: humanSimulationMode || 'none',
+ patternBreakingMode: patternBreakingMode || 'none',
+ saveIntermediateSteps,
+ source: 'production_web'
+ });
+
+ res.json({
+ success: true,
+ result: {
+ wordCount: result.compiledWordCount,
+ duration: result.totalDuration,
+ llmUsed: result.llmUsed,
+ cost: result.estimatedCost,
+ slug: result.slug,
+ gsheetsLink: `https://docs.google.com/spreadsheets/d/${process.env.GOOGLE_SHEETS_ID}`
+ }
+ });
+
+ } catch (error) {
+ logSh(`❌ Erreur production run: ${error.message}`, 'ERROR');
+ res.status(500).json({
+ success: false,
+ error: error.message
+ });
+ }
+ });
+
// ========================================
// 🚀 NOUVEAUX ENDPOINTS API RESTful
// ========================================
diff --git a/lib/pipeline/PipelineDefinition.js b/lib/pipeline/PipelineDefinition.js
new file mode 100644
index 0000000..92b6b6a
--- /dev/null
+++ b/lib/pipeline/PipelineDefinition.js
@@ -0,0 +1,374 @@
+/**
+ * PipelineDefinition.js
+ *
+ * Schemas et validation pour les pipelines modulaires flexibles.
+ * Permet de définir des workflows custom avec n'importe quelle combinaison de modules.
+ */
+
+const { logSh } = require('../ErrorReporting');
+
+/**
+ * Providers LLM disponibles
+ */
+const AVAILABLE_LLM_PROVIDERS = [
+ { id: 'claude', name: 'Claude (Anthropic)', default: true },
+ { id: 'openai', name: 'OpenAI GPT-4' },
+ { id: 'gemini', name: 'Google Gemini' },
+ { id: 'deepseek', name: 'Deepseek' },
+ { id: 'moonshot', name: 'Moonshot' },
+ { id: 'mistral', name: 'Mistral AI' }
+];
+
+/**
+ * Modules disponibles dans le pipeline
+ */
+const AVAILABLE_MODULES = {
+ generation: {
+ name: 'Generation',
+ description: 'Génération initiale du contenu',
+ modes: ['simple'],
+ defaultIntensity: 1.0,
+ defaultLLM: 'claude',
+ parameters: {
+ llmProvider: { type: 'string', enum: AVAILABLE_LLM_PROVIDERS.map(p => p.id), default: 'claude' }
+ }
+ },
+ selective: {
+ name: 'Selective Enhancement',
+ description: 'Amélioration sélective par couches',
+ modes: [
+ 'lightEnhancement',
+ 'standardEnhancement',
+ 'fullEnhancement',
+ 'personalityFocus',
+ 'fluidityFocus',
+ 'adaptive'
+ ],
+ defaultIntensity: 1.0,
+ defaultLLM: 'openai',
+ parameters: {
+ layers: { type: 'array', description: 'Couches spécifiques à appliquer' },
+ llmProvider: { type: 'string', enum: AVAILABLE_LLM_PROVIDERS.map(p => p.id), default: 'openai' }
+ }
+ },
+ adversarial: {
+ name: 'Adversarial Generation',
+ description: 'Techniques anti-détection',
+ modes: ['none', 'light', 'standard', 'heavy', 'adaptive'],
+ defaultIntensity: 1.0,
+ defaultLLM: 'gemini',
+ parameters: {
+ detector: { type: 'string', enum: ['general', 'gptZero', 'originality'], default: 'general' },
+ method: { type: 'string', enum: ['enhancement', 'regeneration', 'hybrid'], default: 'regeneration' },
+ llmProvider: { type: 'string', enum: AVAILABLE_LLM_PROVIDERS.map(p => p.id), default: 'gemini' }
+ }
+ },
+ human: {
+ name: 'Human Simulation',
+ description: 'Simulation comportement humain',
+ modes: [
+ 'none',
+ 'lightSimulation',
+ 'standardSimulation',
+ 'heavySimulation',
+ 'adaptiveSimulation',
+ 'personalityFocus',
+ 'temporalFocus'
+ ],
+ defaultIntensity: 1.0,
+ defaultLLM: 'mistral',
+ parameters: {
+ fatigueLevel: { type: 'number', min: 0, max: 1, default: 0.5 },
+ errorRate: { type: 'number', min: 0, max: 1, default: 0.3 },
+ llmProvider: { type: 'string', enum: AVAILABLE_LLM_PROVIDERS.map(p => p.id), default: 'mistral' }
+ }
+ },
+ pattern: {
+ name: 'Pattern Breaking',
+ description: 'Cassage patterns LLM',
+ modes: [
+ 'none',
+ 'lightPatternBreaking',
+ 'standardPatternBreaking',
+ 'heavyPatternBreaking',
+ 'adaptivePatternBreaking',
+ 'syntaxFocus',
+ 'connectorsFocus'
+ ],
+ defaultIntensity: 1.0,
+ defaultLLM: 'deepseek',
+ parameters: {
+ focus: { type: 'string', enum: ['syntax', 'connectors', 'both'], default: 'both' },
+ llmProvider: { type: 'string', enum: AVAILABLE_LLM_PROVIDERS.map(p => p.id), default: 'deepseek' }
+ }
+ }
+};
+
+/**
+ * Schema d'une étape de pipeline
+ */
+const STEP_SCHEMA = {
+ step: { type: 'number', required: true, description: 'Numéro séquentiel de l\'étape' },
+ module: { type: 'string', required: true, enum: Object.keys(AVAILABLE_MODULES), description: 'Module à exécuter' },
+ mode: { type: 'string', required: true, description: 'Mode du module' },
+ intensity: { type: 'number', required: false, min: 0.1, max: 2.0, default: 1.0, description: 'Intensité d\'application' },
+ parameters: { type: 'object', required: false, default: {}, description: 'Paramètres spécifiques au module' },
+ saveCheckpoint: { type: 'boolean', required: false, default: false, description: 'Sauvegarder checkpoint après cette étape' },
+ enabled: { type: 'boolean', required: false, default: true, description: 'Activer/désactiver l\'étape' }
+};
+
+/**
+ * Schema complet d'un pipeline
+ */
+const PIPELINE_SCHEMA = {
+ name: { type: 'string', required: true, minLength: 3, maxLength: 100 },
+ description: { type: 'string', required: false, maxLength: 500 },
+ pipeline: { type: 'array', required: true, minLength: 1, maxLength: 20 },
+ metadata: {
+ type: 'object',
+ required: false,
+ properties: {
+ author: { type: 'string' },
+ created: { type: 'string' },
+ version: { type: 'string' },
+ tags: { type: 'array' }
+ }
+ }
+};
+
+/**
+ * Classe PipelineDefinition
+ */
+class PipelineDefinition {
+ constructor(definition = null) {
+ this.definition = definition;
+ }
+
+ /**
+ * Valide un pipeline complet
+ */
+ static validate(pipeline) {
+ const errors = [];
+
+ // Validation schema principal
+ if (!pipeline.name || typeof pipeline.name !== 'string' || pipeline.name.length < 3) {
+ errors.push('Le nom du pipeline doit contenir au moins 3 caractères');
+ }
+
+ if (!Array.isArray(pipeline.pipeline) || pipeline.pipeline.length === 0) {
+ errors.push('Le pipeline doit contenir au moins une étape');
+ }
+
+ if (pipeline.pipeline && pipeline.pipeline.length > 20) {
+ errors.push('Le pipeline ne peut pas contenir plus de 20 étapes');
+ }
+
+ // Validation des étapes
+ if (Array.isArray(pipeline.pipeline)) {
+ pipeline.pipeline.forEach((step, index) => {
+ const stepErrors = PipelineDefinition.validateStep(step, index);
+ errors.push(...stepErrors);
+ });
+
+ // Vérifier séquence des steps
+ const steps = pipeline.pipeline.map(s => s.step).sort((a, b) => a - b);
+ for (let i = 0; i < steps.length; i++) {
+ if (steps[i] !== i + 1) {
+ errors.push(`Numérotation des étapes incorrecte: attendu ${i + 1}, trouvé ${steps[i]}`);
+ break;
+ }
+ }
+ }
+
+ if (errors.length > 0) {
+ logSh(`❌ Pipeline validation failed: ${errors.join(', ')}`, 'ERROR');
+ return { valid: false, errors };
+ }
+
+ logSh(`✅ Pipeline "${pipeline.name}" validé: ${pipeline.pipeline.length} étapes`, 'DEBUG');
+ return { valid: true, errors: [] };
+ }
+
+ /**
+ * Valide une étape individuelle
+ */
+ static validateStep(step, index) {
+ const errors = [];
+
+ // Step number
+ if (typeof step.step !== 'number' || step.step < 1) {
+ errors.push(`Étape ${index}: 'step' doit être un nombre >= 1`);
+ }
+
+ // Module
+ if (!step.module || !AVAILABLE_MODULES[step.module]) {
+ errors.push(`Étape ${index}: module '${step.module}' inconnu. Disponibles: ${Object.keys(AVAILABLE_MODULES).join(', ')}`);
+ return errors; // Stop si module invalide
+ }
+
+ const moduleConfig = AVAILABLE_MODULES[step.module];
+
+ // Mode
+ if (!step.mode) {
+ errors.push(`Étape ${index}: 'mode' requis pour module ${step.module}`);
+ } else if (!moduleConfig.modes.includes(step.mode)) {
+ errors.push(`Étape ${index}: mode '${step.mode}' invalide pour ${step.module}. Disponibles: ${moduleConfig.modes.join(', ')}`);
+ }
+
+ // Intensity
+ if (step.intensity !== undefined) {
+ if (typeof step.intensity !== 'number' || step.intensity < 0.1 || step.intensity > 2.0) {
+ errors.push(`Étape ${index}: intensity doit être entre 0.1 et 2.0`);
+ }
+ }
+
+ // Parameters (validation basique)
+ if (step.parameters && typeof step.parameters !== 'object') {
+ errors.push(`Étape ${index}: parameters doit être un objet`);
+ }
+
+ return errors;
+ }
+
+ /**
+ * Crée une étape de pipeline valide
+ */
+ static createStep(stepNumber, module, mode, options = {}) {
+ const moduleConfig = AVAILABLE_MODULES[module];
+ if (!moduleConfig) {
+ throw new Error(`Module inconnu: ${module}`);
+ }
+
+ if (!moduleConfig.modes.includes(mode)) {
+ throw new Error(`Mode ${mode} invalide pour module ${module}`);
+ }
+
+ return {
+ step: stepNumber,
+ module,
+ mode,
+ intensity: options.intensity ?? moduleConfig.defaultIntensity,
+ parameters: options.parameters ?? {},
+ saveCheckpoint: options.saveCheckpoint ?? false,
+ enabled: options.enabled ?? true
+ };
+ }
+
+ /**
+ * Crée un pipeline vide
+ */
+ static createEmpty(name, description = '') {
+ return {
+ name,
+ description,
+ pipeline: [],
+ metadata: {
+ author: 'system',
+ created: new Date().toISOString(),
+ version: '1.0',
+ tags: []
+ }
+ };
+ }
+
+ /**
+ * Clone un pipeline
+ */
+ static clone(pipeline, newName = null) {
+ const cloned = JSON.parse(JSON.stringify(pipeline));
+ if (newName) {
+ cloned.name = newName;
+ }
+ cloned.metadata = {
+ ...cloned.metadata,
+ created: new Date().toISOString(),
+ clonedFrom: pipeline.name
+ };
+ return cloned;
+ }
+
+ /**
+ * Estime la durée d'un pipeline
+ */
+ static estimateDuration(pipeline) {
+ // Durées moyennes par module (en secondes)
+ const DURATIONS = {
+ generation: 15,
+ selective: 20,
+ adversarial: 25,
+ human: 15,
+ pattern: 18
+ };
+
+ let totalSeconds = 0;
+ pipeline.pipeline.forEach(step => {
+ if (!step.enabled) return;
+
+ const baseDuration = DURATIONS[step.module] || 20;
+ const intensityFactor = step.intensity || 1.0;
+ totalSeconds += baseDuration * intensityFactor;
+ });
+
+ return {
+ seconds: Math.round(totalSeconds),
+ formatted: PipelineDefinition.formatDuration(totalSeconds)
+ };
+ }
+
+ /**
+ * Formate une durée en secondes
+ */
+ static formatDuration(seconds) {
+ if (seconds < 60) return `${seconds}s`;
+ const minutes = Math.floor(seconds / 60);
+ const secs = seconds % 60;
+ return `${minutes}m ${secs}s`;
+ }
+
+ /**
+ * Obtient les infos d'un module
+ */
+ static getModuleInfo(moduleName) {
+ return AVAILABLE_MODULES[moduleName] || null;
+ }
+
+ /**
+ * Liste tous les modules disponibles
+ */
+ static listModules() {
+ return Object.entries(AVAILABLE_MODULES).map(([key, config]) => ({
+ id: key,
+ ...config
+ }));
+ }
+
+ /**
+ * Génère un résumé lisible du pipeline
+ */
+ static getSummary(pipeline) {
+ const enabledSteps = pipeline.pipeline.filter(s => s.enabled !== false);
+ const moduleCount = {};
+
+ enabledSteps.forEach(step => {
+ moduleCount[step.module] = (moduleCount[step.module] || 0) + 1;
+ });
+
+ const summary = Object.entries(moduleCount)
+ .map(([module, count]) => `${module}×${count}`)
+ .join(' → ');
+
+ return {
+ totalSteps: enabledSteps.length,
+ summary,
+ duration: PipelineDefinition.estimateDuration(pipeline)
+ };
+ }
+}
+
+module.exports = {
+ PipelineDefinition,
+ AVAILABLE_MODULES,
+ AVAILABLE_LLM_PROVIDERS,
+ PIPELINE_SCHEMA,
+ STEP_SCHEMA
+};
diff --git a/lib/pipeline/PipelineExecutor.js b/lib/pipeline/PipelineExecutor.js
new file mode 100644
index 0000000..06c27dc
--- /dev/null
+++ b/lib/pipeline/PipelineExecutor.js
@@ -0,0 +1,472 @@
+/**
+ * PipelineExecutor.js
+ *
+ * Moteur d'exécution des pipelines modulaires flexibles.
+ * Orchestre l'exécution séquentielle des modules avec gestion d'état.
+ */
+
+const { logSh } = require('../ErrorReporting');
+const { tracer } = require('../trace');
+const { PipelineDefinition } = require('./PipelineDefinition');
+const { getPersonalities, readInstructionsData, selectPersonalityWithAI } = require('../BrainConfig');
+const { extractElements, buildSmartHierarchy } = require('../ElementExtraction');
+const { generateMissingKeywords } = require('../MissingKeywords');
+
+// Modules d'exécution
+const { generateSimple } = require('../selective-enhancement/SelectiveUtils');
+const { applySelectiveLayer } = require('../selective-enhancement/SelectiveCore');
+const { applyPredefinedStack: applySelectiveStack } = require('../selective-enhancement/SelectiveLayers');
+const { applyAdversarialLayer } = require('../adversarial-generation/AdversarialCore');
+const { applyPredefinedStack: applyAdversarialStack } = require('../adversarial-generation/AdversarialLayers');
+const { applyHumanSimulationLayer } = require('../human-simulation/HumanSimulationCore');
+const { applyPredefinedSimulation } = require('../human-simulation/HumanSimulationLayers');
+const { applyPatternBreakingLayer } = require('../pattern-breaking/PatternBreakingCore');
+const { applyPatternBreakingStack } = require('../pattern-breaking/PatternBreakingLayers');
+
+/**
+ * Classe PipelineExecutor
+ */
+class PipelineExecutor {
+ constructor() {
+ this.currentContent = null;
+ this.executionLog = [];
+ this.checkpoints = [];
+ this.metadata = {
+ startTime: null,
+ endTime: null,
+ totalDuration: 0,
+ personality: null
+ };
+ }
+
+ /**
+ * Exécute un pipeline complet
+ */
+ async execute(pipelineConfig, rowNumber, options = {}) {
+ return tracer.run('PipelineExecutor.execute', async () => {
+ logSh(`🚀 Démarrage pipeline "${pipelineConfig.name}" (${pipelineConfig.pipeline.length} étapes)`, 'INFO');
+
+ // Validation
+ const validation = PipelineDefinition.validate(pipelineConfig);
+ if (!validation.valid) {
+ throw new Error(`Pipeline invalide: ${validation.errors.join(', ')}`);
+ }
+
+ this.metadata.startTime = Date.now();
+ this.executionLog = [];
+ this.checkpoints = [];
+
+ // Charger les données
+ const csvData = await this.loadData(rowNumber);
+
+ // Exécuter les étapes
+ const enabledSteps = pipelineConfig.pipeline.filter(s => s.enabled !== false);
+
+ for (let i = 0; i < enabledSteps.length; i++) {
+ const step = enabledSteps[i];
+
+ try {
+ logSh(`▶ Étape ${step.step}/${pipelineConfig.pipeline.length}: ${step.module} (${step.mode})`, 'INFO');
+
+ const stepStartTime = Date.now();
+ const result = await this.executeStep(step, csvData, options);
+ const stepDuration = Date.now() - stepStartTime;
+
+ // Log l'étape
+ this.executionLog.push({
+ step: step.step,
+ module: step.module,
+ mode: step.mode,
+ intensity: step.intensity,
+ duration: stepDuration,
+ modifications: result.modifications || 0,
+ success: true,
+ timestamp: new Date().toISOString()
+ });
+
+ // Mise à jour du contenu
+ if (result.content) {
+ this.currentContent = result.content;
+ }
+
+ // Checkpoint si demandé
+ if (step.saveCheckpoint) {
+ this.checkpoints.push({
+ step: step.step,
+ content: this.currentContent,
+ timestamp: new Date().toISOString()
+ });
+ logSh(`💾 Checkpoint sauvegardé (étape ${step.step})`, 'DEBUG');
+ }
+
+ logSh(`✔ Étape ${step.step} terminée (${stepDuration}ms, ${result.modifications || 0} modifs)`, 'INFO');
+
+ } catch (error) {
+ logSh(`✖ Erreur étape ${step.step}: ${error.message}`, 'ERROR');
+
+ this.executionLog.push({
+ step: step.step,
+ module: step.module,
+ mode: step.mode,
+ success: false,
+ error: error.message,
+ timestamp: new Date().toISOString()
+ });
+
+ // Propager l'erreur ou continuer selon options
+ if (options.stopOnError !== false) {
+ throw error;
+ }
+ }
+ }
+
+ this.metadata.endTime = Date.now();
+ this.metadata.totalDuration = this.metadata.endTime - this.metadata.startTime;
+
+ logSh(`✅ Pipeline terminé: ${this.metadata.totalDuration}ms`, 'INFO');
+
+ return {
+ success: true,
+ finalContent: this.currentContent,
+ executionLog: this.executionLog,
+ checkpoints: this.checkpoints,
+ metadata: {
+ ...this.metadata,
+ pipelineName: pipelineConfig.name,
+ totalSteps: enabledSteps.length,
+ successfulSteps: this.executionLog.filter(l => l.success).length
+ }
+ };
+ }, { pipelineName: pipelineConfig.name, rowNumber });
+ }
+
+ /**
+ * Charge les données depuis Google Sheets
+ */
+ async loadData(rowNumber) {
+ return tracer.run('PipelineExecutor.loadData', async () => {
+ const csvData = await readInstructionsData(rowNumber);
+
+ // Charger personnalité si besoin
+ const personalities = await getPersonalities();
+ const personality = await selectPersonalityWithAI(
+ csvData.mc0,
+ csvData.t0,
+ personalities
+ );
+
+ csvData.personality = personality;
+ this.metadata.personality = personality.nom;
+
+ logSh(`📊 Données chargées: ${csvData.mc0}, personnalité: ${personality.nom}`, 'DEBUG');
+
+ return csvData;
+ }, { rowNumber });
+ }
+
+ /**
+ * Exécute une étape individuelle
+ */
+ async executeStep(step, csvData, options) {
+ return tracer.run(`PipelineExecutor.executeStep.${step.module}`, async () => {
+
+ switch (step.module) {
+ case 'generation':
+ return await this.runGeneration(step, csvData);
+
+ case 'selective':
+ return await this.runSelective(step, csvData);
+
+ case 'adversarial':
+ return await this.runAdversarial(step, csvData);
+
+ case 'human':
+ return await this.runHumanSimulation(step, csvData);
+
+ case 'pattern':
+ return await this.runPatternBreaking(step, csvData);
+
+ default:
+ throw new Error(`Module inconnu: ${step.module}`);
+ }
+
+ }, { step: step.step, module: step.module, mode: step.mode });
+ }
+
+ /**
+ * Exécute la génération initiale
+ */
+ async runGeneration(step, csvData) {
+ return tracer.run('PipelineExecutor.runGeneration', async () => {
+
+ if (this.currentContent) {
+ logSh('⚠️ Contenu déjà généré, génération ignorée', 'WARN');
+ return { content: this.currentContent, modifications: 0 };
+ }
+
+ // Étape 1: Extraire les éléments depuis le template XML
+ const elements = await extractElements(csvData.xmlTemplate, csvData);
+ logSh(`✓ Extraction: ${elements.length} éléments extraits`, 'DEBUG');
+
+ // Étape 2: Générer les mots-clés manquants
+ const finalElements = await generateMissingKeywords(elements, csvData);
+
+ // Étape 3: Construire la hiérarchie
+ const elementsArray = Array.isArray(finalElements) ? finalElements :
+ (finalElements && typeof finalElements === 'object') ? Object.values(finalElements) : [];
+ const hierarchy = await buildSmartHierarchy(elementsArray);
+ logSh(`✓ Hiérarchie: ${Object.keys(hierarchy).length} sections`, 'DEBUG');
+
+ // Étape 4: Génération simple avec LLM configurable
+ const llmProvider = step.parameters?.llmProvider || 'claude';
+ const result = await generateSimple(hierarchy, csvData, { llmProvider });
+
+ logSh(`✓ Génération: ${Object.keys(result.content || {}).length} éléments créés avec ${llmProvider}`, 'DEBUG');
+
+ return {
+ content: result.content,
+ modifications: Object.keys(result.content || {}).length
+ };
+
+ }, { mode: step.mode });
+ }
+
+ /**
+ * Exécute l'enhancement sélectif
+ */
+ async runSelective(step, csvData) {
+ return tracer.run('PipelineExecutor.runSelective', async () => {
+
+ if (!this.currentContent) {
+ throw new Error('Aucun contenu à améliorer. Génération requise avant selective enhancement');
+ }
+
+ // Configuration de la couche
+ const llmProvider = step.parameters?.llmProvider || 'openai';
+ const config = {
+ csvData,
+ personality: csvData.personality,
+ intensity: step.intensity || 1.0,
+ llmProvider: llmProvider,
+ ...step.parameters
+ };
+
+ let result;
+
+ // Utiliser le stack si c'est un mode prédéfini
+ const predefinedStacks = ['lightEnhancement', 'standardEnhancement', 'fullEnhancement', 'personalityFocus', 'fluidityFocus', 'adaptive'];
+
+ if (predefinedStacks.includes(step.mode)) {
+ result = await applySelectiveStack(this.currentContent, step.mode, config);
+ } else {
+ // Sinon utiliser la couche directe
+ result = await applySelectiveLayer(this.currentContent, config);
+ }
+
+ logSh(`✓ Selective: modifications appliquées avec ${llmProvider}`, 'DEBUG');
+
+ return {
+ content: result.content || result,
+ modifications: result.modificationsCount || 0
+ };
+
+ }, { mode: step.mode, intensity: step.intensity });
+ }
+
+ /**
+ * Exécute l'adversarial generation
+ */
+ async runAdversarial(step, csvData) {
+ return tracer.run('PipelineExecutor.runAdversarial', async () => {
+
+ if (!this.currentContent) {
+ throw new Error('Aucun contenu à traiter. Génération requise avant adversarial');
+ }
+
+ if (step.mode === 'none') {
+ logSh('Adversarial mode = none, ignoré', 'DEBUG');
+ return { content: this.currentContent, modifications: 0 };
+ }
+
+ const llmProvider = step.parameters?.llmProvider || 'gemini';
+ const config = {
+ csvData,
+ detectorTarget: step.parameters?.detector || 'general',
+ method: step.parameters?.method || 'regeneration',
+ intensity: step.intensity || 1.0,
+ llmProvider: llmProvider
+ };
+
+ let result;
+
+ // Mapper les noms user-friendly vers les vrais noms de stacks
+ const stackMapping = {
+ 'light': 'lightDefense',
+ 'standard': 'standardDefense',
+ 'heavy': 'heavyDefense',
+ 'adaptive': 'adaptive'
+ };
+
+ // Utiliser le stack si c'est un mode prédéfini
+ if (stackMapping[step.mode]) {
+ const stackName = stackMapping[step.mode];
+
+ if (stackName === 'adaptive') {
+ // Mode adaptatif utilise la couche directe
+ result = await applyAdversarialLayer(this.currentContent, config);
+ } else {
+ result = await applyAdversarialStack(this.currentContent, stackName, config);
+ }
+ } else {
+ // Sinon utiliser la couche directe
+ result = await applyAdversarialLayer(this.currentContent, config);
+ }
+
+ logSh(`✓ Adversarial: modifications appliquées avec ${llmProvider}`, 'DEBUG');
+
+ return {
+ content: result.content || result,
+ modifications: result.modificationsCount || 0
+ };
+
+ }, { mode: step.mode, detector: step.parameters?.detector });
+ }
+
+ /**
+ * Exécute la simulation humaine
+ */
+ async runHumanSimulation(step, csvData) {
+ return tracer.run('PipelineExecutor.runHumanSimulation', async () => {
+
+ if (!this.currentContent) {
+ throw new Error('Aucun contenu à traiter. Génération requise avant human simulation');
+ }
+
+ if (step.mode === 'none') {
+ logSh('Human simulation mode = none, ignoré', 'DEBUG');
+ return { content: this.currentContent, modifications: 0 };
+ }
+
+ const llmProvider = step.parameters?.llmProvider || 'mistral';
+ const config = {
+ csvData,
+ personality: csvData.personality,
+ intensity: step.intensity || 1.0,
+ fatigueLevel: step.parameters?.fatigueLevel || 0.5,
+ errorRate: step.parameters?.errorRate || 0.3,
+ llmProvider: llmProvider
+ };
+
+ let result;
+
+ // Utiliser le stack si c'est un mode prédéfini
+ const predefinedModes = ['lightSimulation', 'standardSimulation', 'heavySimulation', 'adaptiveSimulation', 'personalityFocus', 'temporalFocus'];
+
+ if (predefinedModes.includes(step.mode)) {
+ result = await applyPredefinedSimulation(this.currentContent, step.mode, config);
+ } else {
+ // Sinon utiliser la couche directe
+ result = await applyHumanSimulationLayer(this.currentContent, config);
+ }
+
+ logSh(`✓ Human Simulation: modifications appliquées avec ${llmProvider}`, 'DEBUG');
+
+ return {
+ content: result.content || result,
+ modifications: result.modificationsCount || 0
+ };
+
+ }, { mode: step.mode, intensity: step.intensity });
+ }
+
+ /**
+ * Exécute le pattern breaking
+ */
+ async runPatternBreaking(step, csvData) {
+ return tracer.run('PipelineExecutor.runPatternBreaking', async () => {
+
+ if (!this.currentContent) {
+ throw new Error('Aucun contenu à traiter. Génération requise avant pattern breaking');
+ }
+
+ if (step.mode === 'none') {
+ logSh('Pattern breaking mode = none, ignoré', 'DEBUG');
+ return { content: this.currentContent, modifications: 0 };
+ }
+
+ const llmProvider = step.parameters?.llmProvider || 'deepseek';
+ const config = {
+ csvData,
+ personality: csvData.personality,
+ intensity: step.intensity || 1.0,
+ focus: step.parameters?.focus || 'both',
+ llmProvider: llmProvider
+ };
+
+ let result;
+
+ // Utiliser le stack si c'est un mode prédéfini
+ const predefinedModes = ['lightPatternBreaking', 'standardPatternBreaking', 'heavyPatternBreaking', 'adaptivePatternBreaking', 'syntaxFocus', 'connectorsFocus'];
+
+ if (predefinedModes.includes(step.mode)) {
+ result = await applyPatternBreakingStack(step.mode, this.currentContent, config);
+ } else {
+ // Sinon utiliser la couche directe
+ result = await applyPatternBreakingLayer(this.currentContent, config);
+ }
+
+ logSh(`✓ Pattern Breaking: modifications appliquées avec ${llmProvider}`, 'DEBUG');
+
+ return {
+ content: result.content || result,
+ modifications: result.modificationsCount || 0
+ };
+
+ }, { mode: step.mode, intensity: step.intensity });
+ }
+
+ /**
+ * Obtient le contenu actuel
+ */
+ getCurrentContent() {
+ return this.currentContent;
+ }
+
+ /**
+ * Obtient le log d'exécution
+ */
+ getExecutionLog() {
+ return this.executionLog;
+ }
+
+ /**
+ * Obtient les checkpoints sauvegardés
+ */
+ getCheckpoints() {
+ return this.checkpoints;
+ }
+
+ /**
+ * Obtient les métadonnées d'exécution
+ */
+ getMetadata() {
+ return this.metadata;
+ }
+
+ /**
+ * Reset l'état de l'executor
+ */
+ reset() {
+ this.currentContent = null;
+ this.executionLog = [];
+ this.checkpoints = [];
+ this.metadata = {
+ startTime: null,
+ endTime: null,
+ totalDuration: 0,
+ personality: null
+ };
+ }
+}
+
+module.exports = { PipelineExecutor };
diff --git a/lib/pipeline/PipelineTemplates.js b/lib/pipeline/PipelineTemplates.js
new file mode 100644
index 0000000..9432828
--- /dev/null
+++ b/lib/pipeline/PipelineTemplates.js
@@ -0,0 +1,300 @@
+/**
+ * PipelineTemplates.js
+ *
+ * Templates prédéfinis pour pipelines modulaires.
+ * Fournit des configurations ready-to-use pour différents cas d'usage.
+ */
+
+/**
+ * Templates de pipelines
+ */
+const TEMPLATES = {
+ /**
+ * Light & Fast - Pipeline minimal pour génération rapide
+ */
+ 'light-fast': {
+ name: 'Light & Fast',
+ description: 'Pipeline rapide pour contenu basique, idéal pour tests et prototypes',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'lightEnhancement', intensity: 0.7 }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['fast', 'light', 'basic'],
+ estimatedDuration: '35s'
+ }
+ },
+
+ /**
+ * Standard SEO - Pipeline équilibré pour usage quotidien
+ */
+ 'standard-seo': {
+ name: 'Standard SEO',
+ description: 'Pipeline équilibré avec protection anti-détection standard',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'standardEnhancement', intensity: 1.0 },
+ { step: 3, module: 'adversarial', mode: 'light', intensity: 0.8, parameters: { detector: 'general', method: 'enhancement' } },
+ { step: 4, module: 'human', mode: 'lightSimulation', intensity: 0.6 }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['standard', 'seo', 'balanced'],
+ estimatedDuration: '75s'
+ }
+ },
+
+ /**
+ * Premium SEO - Pipeline complet pour contenu premium
+ */
+ 'premium-seo': {
+ name: 'Premium SEO',
+ description: 'Pipeline complet avec anti-détection avancée et qualité maximale',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'fullEnhancement', intensity: 1.0, saveCheckpoint: true },
+ { step: 3, module: 'adversarial', mode: 'standard', intensity: 1.0, parameters: { detector: 'general', method: 'regeneration' } },
+ { step: 4, module: 'human', mode: 'standardSimulation', intensity: 0.8, parameters: { fatigueLevel: 0.5, errorRate: 0.3 } },
+ { step: 5, module: 'pattern', mode: 'standardPatternBreaking', intensity: 0.9 },
+ { step: 6, module: 'adversarial', mode: 'light', intensity: 0.7, parameters: { detector: 'general', method: 'enhancement' } }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['premium', 'complete', 'quality'],
+ estimatedDuration: '130s'
+ }
+ },
+
+ /**
+ * Heavy Guard - Protection maximale anti-détection
+ */
+ 'heavy-guard': {
+ name: 'Heavy Guard',
+ description: 'Protection maximale avec multi-passes adversarial et human simulation',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'fullEnhancement', intensity: 1.0 },
+ { step: 3, module: 'adversarial', mode: 'heavy', intensity: 1.2, parameters: { detector: 'gptZero', method: 'regeneration' }, saveCheckpoint: true },
+ { step: 4, module: 'human', mode: 'heavySimulation', intensity: 1.0, parameters: { fatigueLevel: 0.7, errorRate: 0.4 } },
+ { step: 5, module: 'pattern', mode: 'heavyPatternBreaking', intensity: 1.0 },
+ { step: 6, module: 'adversarial', mode: 'adaptive', intensity: 1.5, parameters: { detector: 'originality', method: 'hybrid' } },
+ { step: 7, module: 'human', mode: 'personalityFocus', intensity: 1.3 },
+ { step: 8, module: 'pattern', mode: 'syntaxFocus', intensity: 1.1 }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['heavy', 'protection', 'anti-detection'],
+ estimatedDuration: '180s'
+ }
+ },
+
+ /**
+ * Personality Focus - Mise en avant de la personnalité
+ */
+ 'personality-focus': {
+ name: 'Personality Focus',
+ description: 'Pipeline optimisé pour un style personnel marqué',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'personalityFocus', intensity: 1.2 },
+ { step: 3, module: 'human', mode: 'personalityFocus', intensity: 1.5 },
+ { step: 4, module: 'adversarial', mode: 'light', intensity: 0.6, parameters: { detector: 'general', method: 'enhancement' } }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['personality', 'style', 'unique'],
+ estimatedDuration: '70s'
+ }
+ },
+
+ /**
+ * Fluidity Master - Transitions et fluidité maximale
+ */
+ 'fluidity-master': {
+ name: 'Fluidity Master',
+ description: 'Pipeline axé sur transitions fluides et connecteurs naturels',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'fluidityFocus', intensity: 1.3 },
+ { step: 3, module: 'pattern', mode: 'connectorsFocus', intensity: 1.2 },
+ { step: 4, module: 'human', mode: 'standardSimulation', intensity: 0.7 }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['fluidity', 'transitions', 'natural'],
+ estimatedDuration: '73s'
+ }
+ },
+
+ /**
+ * Adaptive Smart - Pipeline intelligent avec modes adaptatifs
+ */
+ 'adaptive-smart': {
+ name: 'Adaptive Smart',
+ description: 'Pipeline intelligent qui s\'adapte au contenu',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'adaptive', intensity: 1.0 },
+ { step: 3, module: 'adversarial', mode: 'adaptive', intensity: 1.0, parameters: { detector: 'general', method: 'hybrid' } },
+ { step: 4, module: 'human', mode: 'adaptiveSimulation', intensity: 1.0 },
+ { step: 5, module: 'pattern', mode: 'adaptivePatternBreaking', intensity: 1.0 }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['adaptive', 'smart', 'intelligent'],
+ estimatedDuration: '105s'
+ }
+ },
+
+ /**
+ * GPTZero Killer - Spécialisé anti-GPTZero
+ */
+ 'gptzero-killer': {
+ name: 'GPTZero Killer',
+ description: 'Pipeline optimisé pour contourner GPTZero spécifiquement',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'fullEnhancement', intensity: 1.0 },
+ { step: 3, module: 'adversarial', mode: 'heavy', intensity: 1.5, parameters: { detector: 'gptZero', method: 'regeneration' } },
+ { step: 4, module: 'human', mode: 'heavySimulation', intensity: 1.2 },
+ { step: 5, module: 'pattern', mode: 'heavyPatternBreaking', intensity: 1.1 },
+ { step: 6, module: 'adversarial', mode: 'standard', intensity: 1.0, parameters: { detector: 'gptZero', method: 'hybrid' } }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['gptzero', 'anti-detection', 'specialized'],
+ estimatedDuration: '155s'
+ }
+ },
+
+ /**
+ * Originality Bypass - Spécialisé anti-Originality.ai
+ */
+ 'originality-bypass': {
+ name: 'Originality Bypass',
+ description: 'Pipeline optimisé pour contourner Originality.ai',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 },
+ { step: 2, module: 'selective', mode: 'fullEnhancement', intensity: 1.0 },
+ { step: 3, module: 'adversarial', mode: 'heavy', intensity: 1.4, parameters: { detector: 'originality', method: 'regeneration' } },
+ { step: 4, module: 'human', mode: 'temporalFocus', intensity: 1.1 },
+ { step: 5, module: 'pattern', mode: 'syntaxFocus', intensity: 1.2 },
+ { step: 6, module: 'adversarial', mode: 'adaptive', intensity: 1.3, parameters: { detector: 'originality', method: 'hybrid' } }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['originality', 'anti-detection', 'specialized'],
+ estimatedDuration: '160s'
+ }
+ },
+
+ /**
+ * Minimal Test - Pipeline minimal pour tests rapides
+ */
+ 'minimal-test': {
+ name: 'Minimal Test',
+ description: 'Pipeline minimal pour tests de connectivité et validation',
+ pipeline: [
+ { step: 1, module: 'generation', mode: 'simple', intensity: 1.0 }
+ ],
+ metadata: {
+ author: 'system',
+ created: '2025-10-08',
+ version: '1.0',
+ tags: ['test', 'minimal', 'debug'],
+ estimatedDuration: '15s'
+ }
+ }
+};
+
+/**
+ * Catégories de templates
+ */
+const CATEGORIES = {
+ basic: ['minimal-test', 'light-fast'],
+ standard: ['standard-seo', 'premium-seo'],
+ advanced: ['heavy-guard', 'adaptive-smart'],
+ specialized: ['gptzero-killer', 'originality-bypass'],
+ focus: ['personality-focus', 'fluidity-master']
+};
+
+/**
+ * Obtenir un template par nom
+ */
+function getTemplate(name) {
+ return TEMPLATES[name] || null;
+}
+
+/**
+ * Lister tous les templates
+ */
+function listTemplates() {
+ return Object.entries(TEMPLATES).map(([key, template]) => ({
+ id: key,
+ name: template.name,
+ description: template.description,
+ steps: template.pipeline.length,
+ tags: template.metadata.tags,
+ estimatedDuration: template.metadata.estimatedDuration
+ }));
+}
+
+/**
+ * Lister templates par catégorie
+ */
+function listTemplatesByCategory(category) {
+ const templateIds = CATEGORIES[category] || [];
+ return templateIds.map(id => ({
+ id,
+ ...TEMPLATES[id]
+ }));
+}
+
+/**
+ * Obtenir toutes les catégories
+ */
+function getCategories() {
+ return Object.entries(CATEGORIES).map(([name, templateIds]) => ({
+ name,
+ count: templateIds.length,
+ templates: templateIds
+ }));
+}
+
+/**
+ * Rechercher templates par tag
+ */
+function searchByTag(tag) {
+ return Object.entries(TEMPLATES)
+ .filter(([_, template]) => template.metadata.tags.includes(tag))
+ .map(([id, template]) => ({ id, ...template }));
+}
+
+module.exports = {
+ TEMPLATES,
+ CATEGORIES,
+ getTemplate,
+ listTemplates,
+ listTemplatesByCategory,
+ getCategories,
+ searchByTag
+};
diff --git a/lib/selective-enhancement/SelectiveUtils.js b/lib/selective-enhancement/SelectiveUtils.js
index 58b2c3a..4b50375 100644
--- a/lib/selective-enhancement/SelectiveUtils.js
+++ b/lib/selective-enhancement/SelectiveUtils.js
@@ -484,24 +484,26 @@ function formatDuration(ms) {
*/
/**
- * Génération simple Claude uniquement (compatible avec l'ancien système)
+ * Génération simple avec LLM configurable (compatible avec l'ancien système)
*/
-async function generateSimple(hierarchy, csvData) {
- const { LLMManager } = require('../LLMManager');
-
- logSh(`🔥 Génération simple Claude uniquement`, 'INFO');
-
+async function generateSimple(hierarchy, csvData, options = {}) {
+ const LLMManager = require('../LLMManager');
+
+ const llmProvider = options.llmProvider || 'claude';
+
+ logSh(`🔥 Génération simple avec ${llmProvider.toUpperCase()}`, 'INFO');
+
if (!hierarchy || Object.keys(hierarchy).length === 0) {
throw new Error('Hiérarchie vide ou invalide');
}
-
+
const result = {
content: {},
stats: {
processed: 0,
enhanced: 0,
duration: 0,
- llmProvider: 'claude'
+ llmProvider: llmProvider
}
};
@@ -509,10 +511,91 @@ async function generateSimple(hierarchy, csvData) {
try {
// Générer chaque élément avec Claude
- for (const [tag, instruction] of Object.entries(hierarchy)) {
+ for (const [tag, item] of Object.entries(hierarchy)) {
try {
logSh(`🎯 Génération: ${tag}`, 'DEBUG');
-
+
+ // Extraire l'instruction correctement selon la structure
+ let instruction = '';
+ if (typeof item === 'string') {
+ instruction = item;
+ } else if (item.instructions) {
+ instruction = item.instructions;
+ } else if (item.title && item.title.instructions) {
+ instruction = item.title.instructions;
+ } else if (item.text && item.text.instructions) {
+ instruction = item.text.instructions;
+ } else {
+ logSh(`⚠️ Pas d'instruction trouvée pour ${tag}, structure: ${JSON.stringify(Object.keys(item))}`, 'WARNING');
+ continue; // Skip cet élément
+ }
+
+ // Fonction pour résoudre les variables dans les instructions
+ const resolveVariables = (text, csvData) => {
+ return text.replace(/\{\{?([^}]+)\}?\}/g, (match, variable) => {
+ const cleanVar = variable.trim();
+
+ // Variables simples
+ if (cleanVar === 'MC0') return csvData.mc0 || '';
+ if (cleanVar === 'T0') return csvData.t0 || '';
+ if (cleanVar === 'T-1') return csvData.tMinus1 || '';
+ if (cleanVar === 'L-1') return csvData.lMinus1 || '';
+
+ // Variables avec index MC+1_X
+ if (cleanVar.startsWith('MC+1_')) {
+ const index = parseInt(cleanVar.split('_')[1]) - 1;
+ const mcPlus1 = (csvData.mcPlus1 || '').split(',').map(s => s.trim());
+ const resolved = mcPlus1[index] || csvData.mc0 || '';
+ logSh(` 🔍 Variable ${cleanVar} → "${resolved}" (index ${index}, mcPlus1: ${mcPlus1.length} items)`, 'DEBUG');
+ return resolved;
+ }
+
+ // Variables avec index T+1_X
+ if (cleanVar.startsWith('T+1_')) {
+ const index = parseInt(cleanVar.split('_')[1]) - 1;
+ const tPlus1 = (csvData.tPlus1 || '').split(',').map(s => s.trim());
+ const resolved = tPlus1[index] || csvData.t0 || '';
+ logSh(` 🔍 Variable ${cleanVar} → "${resolved}" (index ${index}, tPlus1: ${tPlus1.length} items)`, 'DEBUG');
+ return resolved;
+ }
+
+ // Variables avec index L+1_X
+ if (cleanVar.startsWith('L+1_')) {
+ const index = parseInt(cleanVar.split('_')[1]) - 1;
+ const lPlus1 = (csvData.lPlus1 || '').split(',').map(s => s.trim());
+ const resolved = lPlus1[index] || '';
+ logSh(` 🔍 Variable ${cleanVar} → "${resolved}" (index ${index}, lPlus1: ${lPlus1.length} items)`, 'DEBUG');
+ return resolved;
+ }
+
+ // Variable inconnue
+ logSh(` ⚠️ Variable inconnue: "${cleanVar}" (match: "${match}")`, 'WARNING');
+ return csvData.mc0 || '';
+ });
+ };
+
+ // Nettoyer l'instruction des balises HTML et résoudre les variables
+ const originalInstruction = instruction;
+
+ // NE PLUS nettoyer le HTML ici - c'est fait dans ElementExtraction.js
+ instruction = instruction.trim();
+
+ logSh(` 📝 Instruction avant résolution (${tag}): ${instruction.substring(0, 100)}...`, 'DEBUG');
+ instruction = resolveVariables(instruction, csvData);
+ logSh(` ✅ Instruction après résolution (${tag}): ${instruction.substring(0, 100)}...`, 'DEBUG');
+
+ // Nettoyer les accolades mal formées restantes
+ instruction = instruction
+ .replace(/\{[^}]*/g, '') // Supprimer accolades non fermées
+ .replace(/[{}]/g, '') // Supprimer accolades isolées
+ .trim();
+
+ // Vérifier que l'instruction n'est pas vide ou invalide
+ if (!instruction || instruction.length < 10) {
+ logSh(`⚠️ Instruction trop courte ou vide pour ${tag}, skip`, 'WARNING');
+ continue;
+ }
+
const prompt = `Tu es un expert en rédaction SEO. Tu dois générer du contenu professionnel et naturel.
CONTEXTE:
@@ -532,11 +615,11 @@ CONSIGNES:
RÉPONSE:`;
- const response = await LLMManager.callLLM('claude', prompt, {
+ const response = await LLMManager.callLLM(llmProvider, prompt, {
temperature: 0.9,
maxTokens: 300,
timeout: 30000
- });
+ }, csvData.personality);
if (response && response.trim()) {
result.content[tag] = cleanGeneratedContent(response.trim());
diff --git a/public/index.html b/public/index.html
new file mode 100644
index 0000000..2662683
--- /dev/null
+++ b/public/index.html
@@ -0,0 +1,373 @@
+
+
+
+
+
+ SEO Generator - Dashboard
+
+
+
+
+
+ 🎯 SEO Generator Dashboard
+
+ Vérification...
+
+
+
+
+
+
+
+
🔧
+
Éditeur de Configuration
+
⚠️ ANCIEN SYSTÈME - Désactivé
+
+ - 4 couches modulaires configurables
+ - Save/Load des configurations
+ - Test en direct avec logs temps réel
+ - Preview JSON de la configuration
+
+
+
+
+
+
🚀
+
Runner de Production
+
⚠️ ANCIEN SYSTÈME - Désactivé
+
+ - Load configuration sauvegardée
+ - Sélection ligne Google Sheets
+ - Logs temps réel pendant l'exécution
+ - Résultats et lien direct vers GSheets
+
+
+
+
+
+
🎨
+
Pipeline Builder
+
Créer des pipelines modulaires flexibles avec drag-and-drop
+
+ - Construction visuelle par glisser-déposer
+ - Ordre et intensités personnalisables
+ - Multi-passes d'un même module
+ - Templates prédéfinis chargeables
+
+
+
+
+
+
⚡
+
Pipeline Runner
+
Exécuter vos pipelines personnalisés sur Google Sheets
+
+ - Chargement pipelines sauvegardés
+ - Preview détaillée avant exécution
+ - Suivi progression étape par étape
+ - Logs d'exécution complets
+
+
+
+
📊 Statistiques Système
+
+
+
+ ⏳
+
+
Configurations sauvegardées
+
+
+
+ ⏳
+
+
Uptime serveur
+
+
+
+ ⏳
+
+
Clients connectés
+
+
+
+ ⏳
+
+
Requêtes traitées
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
🎨 Pipeline Canvas
+
+
+ 👉 Glissez des modules ici ou cliquez sur "Ajouter une étape"
+
+
+
+
+
+
+
+
+
+
⚙️ Configuration
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
${module.name}
+ ${module.description}
+ `;
+
+ // Drag events
+ moduleDiv.addEventListener('dragstart', handleDragStart);
+ moduleDiv.addEventListener('dragend', handleDragEnd);
+
+ // Click to add
+ moduleDiv.addEventListener('click', () => {
+ addStep(module.id, module.modes[0]);
+ });
+
+ catDiv.appendChild(moduleDiv);
+ });
+
+ container.appendChild(catDiv);
+ });
+}
+
+function renderTemplates() {
+ const container = document.getElementById('templatesContainer');
+ container.innerHTML = '';
+
+ state.templates.forEach(template => {
+ const templateDiv = document.createElement('div');
+ templateDiv.className = 'template-item';
+
+ templateDiv.innerHTML = `
+ ${template.name}
+ ${template.description.substring(0, 60)}...
+ `;
+
+ templateDiv.addEventListener('click', () => loadTemplate(template.id));
+
+ container.appendChild(templateDiv);
+ });
+}
+
+function renderPipeline() {
+ const container = document.getElementById('stepsContainer');
+ const empty = document.getElementById('canvasEmpty');
+
+ if (state.pipeline.pipeline.length === 0) {
+ container.style.display = 'none';
+ empty.style.display = 'flex';
+ return;
+ }
+
+ empty.style.display = 'none';
+ container.style.display = 'block';
+ container.innerHTML = '';
+
+ state.pipeline.pipeline.forEach((step, index) => {
+ const stepDiv = createStepElement(step, index);
+ container.appendChild(stepDiv);
+ });
+
+ updatePreview();
+}
+
+function createStepElement(step, index) {
+ const module = state.modules.find(m => m.id === step.module);
+ if (!module) return document.createElement('div');
+
+ const stepDiv = document.createElement('div');
+ stepDiv.className = 'pipeline-step';
+ stepDiv.dataset.stepIndex = index;
+
+ stepDiv.innerHTML = `
+
+
+
+
+
+
+
+
+
+
+ ${renderModuleParameters(step, index, module)}
+
+
+
+
+ `;
+
+ // Autres paramètres du module (sauf llmProvider qui est déjà affiché)
+ if (module.parameters && Object.keys(module.parameters).length > 0) {
+ Object.entries(module.parameters).forEach(([paramName, paramConfig]) => {
+ // Skip llmProvider car déjà affiché ci-dessus
+ if (paramName === 'llmProvider') return;
+
+ const value = step.parameters?.[paramName] || paramConfig.default || '';
+
+ if (paramConfig.enum) {
+ html += `
+
+
+
+
+ `;
+ } else if (paramConfig.type === 'number') {
+ html += `
+
+
+
+
+ `;
+ }
+ });
+ }
+
+ return html;
+}
+
+// ====================
+// PIPELINE OPERATIONS
+// ====================
+
+function addStep(moduleId, mode = null) {
+ const module = state.modules.find(m => m.id === moduleId);
+ if (!module) return;
+
+ const newStep = {
+ step: state.nextStepNumber++,
+ module: moduleId,
+ mode: mode || module.modes[0],
+ intensity: module.defaultIntensity || 1.0,
+ parameters: {},
+ enabled: true
+ };
+
+ state.pipeline.pipeline.push(newStep);
+ reorderSteps();
+ renderPipeline();
+}
+
+function deleteStep(index) {
+ state.pipeline.pipeline.splice(index, 1);
+ reorderSteps();
+ renderPipeline();
+}
+
+function duplicateStep(index) {
+ const step = state.pipeline.pipeline[index];
+ const duplicated = JSON.parse(JSON.stringify(step));
+ duplicated.step = state.nextStepNumber++;
+
+ state.pipeline.pipeline.splice(index + 1, 0, duplicated);
+ reorderSteps();
+ renderPipeline();
+}
+
+function moveStepUp(index) {
+ if (index === 0) return;
+
+ const temp = state.pipeline.pipeline[index];
+ state.pipeline.pipeline[index] = state.pipeline.pipeline[index - 1];
+ state.pipeline.pipeline[index - 1] = temp;
+
+ reorderSteps();
+ renderPipeline();
+}
+
+function moveStepDown(index) {
+ if (index === state.pipeline.pipeline.length - 1) return;
+
+ const temp = state.pipeline.pipeline[index];
+ state.pipeline.pipeline[index] = state.pipeline.pipeline[index + 1];
+ state.pipeline.pipeline[index + 1] = temp;
+
+ reorderSteps();
+ renderPipeline();
+}
+
+function updateStepMode(index, mode) {
+ state.pipeline.pipeline[index].mode = mode;
+ updatePreview();
+}
+
+function updateStepIntensity(index, intensity) {
+ state.pipeline.pipeline[index].intensity = intensity;
+ updatePreview();
+}
+
+function updateStepParameter(index, paramName, value) {
+ if (!state.pipeline.pipeline[index].parameters) {
+ state.pipeline.pipeline[index].parameters = {};
+ }
+
+ // Si value est vide/null/undefined, supprimer la clé pour utiliser le default
+ if (value === '' || value === null || value === undefined) {
+ delete state.pipeline.pipeline[index].parameters[paramName];
+ } else {
+ state.pipeline.pipeline[index].parameters[paramName] = value;
+ }
+
+ updatePreview();
+}
+
+function reorderSteps() {
+ state.pipeline.pipeline.forEach((step, index) => {
+ step.step = index + 1;
+ });
+ state.nextStepNumber = state.pipeline.pipeline.length + 1;
+}
+
+function clearPipeline() {
+ if (!confirm('Effacer tout le pipeline ?')) return;
+
+ state.pipeline.pipeline = [];
+ state.nextStepNumber = 1;
+ document.getElementById('pipelineName').value = '';
+ document.getElementById('pipelineDesc').value = '';
+
+ renderPipeline();
+}
+
+// ====================
+// DRAG & DROP
+// ====================
+
+let draggedElement = null;
+
+function handleDragStart(e) {
+ draggedElement = e.target;
+ e.target.classList.add('dragging');
+ e.dataTransfer.effectAllowed = 'copy';
+ e.dataTransfer.setData('moduleId', e.target.dataset.moduleId);
+}
+
+function handleDragEnd(e) {
+ e.target.classList.remove('dragging');
+}
+
+// Setup drop zone
+document.addEventListener('DOMContentLoaded', () => {
+ const canvas = document.getElementById('pipelineCanvas');
+
+ canvas.addEventListener('dragover', (e) => {
+ e.preventDefault();
+ e.dataTransfer.dropEffect = 'copy';
+ });
+
+ canvas.addEventListener('drop', (e) => {
+ e.preventDefault();
+ const moduleId = e.dataTransfer.getData('moduleId');
+ if (moduleId) {
+ addStep(moduleId);
+ }
+ });
+
+ // Add step button
+ document.getElementById('addStepBtn').addEventListener('click', () => {
+ const firstModule = state.modules[0];
+ if (firstModule) {
+ addStep(firstModule.id);
+ }
+ });
+});
+
+// ====================
+// TEMPLATES
+// ====================
+
+async function loadTemplate(templateId) {
+ try {
+ const response = await fetch(`/api/pipeline/templates/${templateId}`);
+ const data = await response.json();
+
+ if (data.success) {
+ state.pipeline = data.template;
+ state.nextStepNumber = data.template.pipeline.length + 1;
+
+ document.getElementById('pipelineName').value = data.template.name;
+ document.getElementById('pipelineDesc').value = data.template.description || '';
+
+ renderPipeline();
+ showStatus(`Template "${data.template.name}" chargé`, 'success');
+ }
+ } catch (error) {
+ showStatus(`Erreur chargement template: ${error.message}`, 'error');
+ }
+}
+
+// ====================
+// SAVE / VALIDATE / TEST
+// ====================
+
+async function savePipeline() {
+ const name = document.getElementById('pipelineName').value.trim();
+ const description = document.getElementById('pipelineDesc').value.trim();
+
+ if (!name) {
+ showStatus('Nom du pipeline requis', 'error');
+ return;
+ }
+
+ if (state.pipeline.pipeline.length === 0) {
+ showStatus('Pipeline vide, ajoutez au moins une étape', 'error');
+ return;
+ }
+
+ state.pipeline.name = name;
+ state.pipeline.description = description;
+ state.pipeline.metadata.saved = new Date().toISOString();
+
+ try {
+ const response = await fetch('/api/pipeline/save', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ pipelineDefinition: state.pipeline })
+ });
+
+ const data = await response.json();
+
+ if (data.success) {
+ showStatus(`✅ Pipeline "${name}" sauvegardé`, 'success');
+ } else {
+ showStatus(`Erreur: ${data.error}`, 'error');
+ }
+ } catch (error) {
+ showStatus(`Erreur sauvegarde: ${error.message}`, 'error');
+ }
+}
+
+async function validatePipeline() {
+ const name = document.getElementById('pipelineName').value.trim();
+ if (!name) {
+ state.pipeline.name = 'Unnamed Pipeline';
+ } else {
+ state.pipeline.name = name;
+ }
+
+ try {
+ const response = await fetch('/api/pipeline/validate', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ pipelineDefinition: state.pipeline })
+ });
+
+ const data = await response.json();
+
+ if (data.valid) {
+ showStatus('✅ Pipeline valide', 'success');
+ } else {
+ showStatus(`❌ Erreurs: ${data.errors.join(', ')}`, 'error');
+ }
+ } catch (error) {
+ showStatus(`Erreur validation: ${error.message}`, 'error');
+ }
+}
+
+async function testPipeline() {
+ const name = document.getElementById('pipelineName').value.trim();
+
+ if (!name) {
+ showStatus('Nom du pipeline requis pour le test', 'error');
+ return;
+ }
+
+ state.pipeline.name = name;
+ state.pipeline.description = document.getElementById('pipelineDesc').value.trim();
+
+ const rowNumber = prompt('Numéro de ligne Google Sheets à tester ?', '2');
+ if (!rowNumber) return;
+
+ showStatus('🚀 Test en cours...', 'info');
+
+ try {
+ const response = await fetch('/api/pipeline/execute', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ pipelineConfig: state.pipeline,
+ rowNumber: parseInt(rowNumber)
+ })
+ });
+
+ const data = await response.json();
+
+ if (data.success) {
+ showStatus(`✅ Test réussi! Durée: ${data.result.stats.totalDuration}ms`, 'success');
+ console.log('Test result:', data.result);
+ } else {
+ showStatus(`❌ Test échoué: ${data.error}`, 'error');
+ }
+ } catch (error) {
+ showStatus(`Erreur test: ${error.message}`, 'error');
+ }
+}
+
+// ====================
+// PREVIEW & HELPERS
+// ====================
+
+function updatePreview() {
+ const preview = document.getElementById('previewJson');
+ preview.textContent = JSON.stringify(state.pipeline, null, 2);
+}
+
+function showStatus(message, type) {
+ const status = document.getElementById('status');
+ status.textContent = message;
+ status.className = `status ${type}`;
+ status.style.display = 'block';
+
+ setTimeout(() => {
+ status.style.display = 'none';
+ }, 5000);
+}
diff --git a/public/pipeline-runner.html b/public/pipeline-runner.html
new file mode 100644
index 0000000..ec6e8cd
--- /dev/null
+++ b/public/pipeline-runner.html
@@ -0,0 +1,355 @@
+
+
+
+
+
+ Pipeline Runner - SEO Generator
+
+
+
+
+
+
+
+
+
+
+
📂 Sélection Pipeline
+
+
+
+
+
+
+
+
+
+
+
+
⚙️ Paramètres d'Exécution
+
+
+
+
+
+
+
+
+
+
+
+
⏳ Progression
+
+
+
+
+
+
+
+
+
📊 Résultats
+
+
+
+
📝 Log d'Exécution
+
+
+