@anonympins/fingerprint 0.2.1 → 0.2.3

package/problem-manager.js

@@ -1,6 +1,64 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { Optimization } from './library.js';
 
+/**
+ * @namespace FunctionRegistry
+ * @description Registre pour exposer de manière contrôlée les fonctions de la bibliothèque.
+ * Permet de les appeler dynamiquement depuis la configuration des problèmes.
+ * Utilise la notation par points pour accéder aux fonctions imbriquées (ex: 'tsp.calculateEnergy').
+ */
+const FunctionRegistry = {};
+
+// --- Fonctions de "Scoring" (évaluation d'une solution) ---
+// Ces fonctions sont des adaptateurs pour utiliser les utilitaires de la bibliothèque
+// avec la structure attendue par le ProblemManager.
+FunctionRegistry['cpc.solve'] = Optimization.Operators.solveOptimalCPC; // NOUVEAU: Enregistrement du solveur CPC
+
+/**
+/**
+ * Évalue la distance totale d'un chemin pour le problème du voyageur de commerce (TSP).
+ * @param {Array<{x: number, y: number}>} path - Un tableau de points représentant le chemin.
+ * @returns {number} La distance totale du chemin.
+ */
+FunctionRegistry['tsp.calculateEnergy'] = (path) => {
+    // Crée un tableau d'indices [0, 1, 2, ...] pour la fonction evaluatePathDistance.
+    const indices = Array.from({ length: path.length }, (_, i) => i);
+    return Optimization.Utils.evaluatePathDistance(path, indices);
+};
+
+/**
+ * Évalue les métriques d'un portefeuille (rendement et volatilité).
+ * Pour l'instant, retourne le rendement négatif pour correspondre à l'objectif de minimisation
+ * de l'algorithme génétique de la bibliothèque.
+ * @param {Array<number>} weights - Les poids des actifs dans le portefeuille.
+ * @param {object} payload - Le payload du problème, contenant les actifs.
+ * @returns {number} Le rendement négatif du portefeuille.
+ */
+FunctionRegistry['portfolio.calculateMetrics'] = (weights, payload) => {
+    const { assets, maxVolatility } = payload;
+    // On utilise l'opérateur de la bibliothèque pour créer la fonction de fitness
+    // et on l'appelle immédiatement.
+    const fitnessFunction = Optimization.Operators.createPortfolioAllocator({
+        assets,
+        maxVolatility,
+    });
+    // La fonction de fitness retourne le rendement négatif, ce qui est ce que nous voulons
+    // stocker comme "énergie" ou score.
+    return fitnessFunction(weights);
+};
+
+// --- Fonctions de "Résolution" (algorithmes complets) ---
+// Utiles pour les workers qui exécutent une tâche de bout en bout.
+FunctionRegistry['tsp.solve'] = Optimization.Operators.solveTSP;
+FunctionRegistry['portfolio.solve'] = Optimization.Operators.solvePortfolio;
+FunctionRegistry['fraud.solve'] = Optimization.Operators.solveFraudDetection; // NOUVEAU: Enregistrement du solveur de fraude
+FunctionRegistry['facility.solve'] = Optimization.Operators.solveFacilityLocation;
+FunctionRegistry['security.tune'] = Optimization.Operators.solveFullSecurityTuning;
+
+// --- Fonctions "Utilitaires" ---
+FunctionRegistry['utils.evaluatePathDistance'] = Optimization.Utils.evaluatePathDistance;
+
+
 /**
  * @namespace ProblemInitializers
  * @description Fonctions pour générer dynamiquement les données d'un problème.
@@ -68,11 +126,18 @@ class ProblemManager {
             const problems = JSON.parse(data);
             // Initialisation dynamique des problèmes
             for (const problem of problems) { // eslint-disable-line no-unused-vars
+                // Résolution des fonctions via le registre
+                if (problem.workUnit.scoreFunction) {
+                    problem.workUnit.scoreFunction = FunctionRegistry[problem.workUnit.scoreFunction] || null;
+                }
+
                 for (const key in problem.payload) {
                     const value = problem.payload[key];
                     // On cherche une instruction d'initialisation (ex: { "$init": "generate:randomPoints", ... })
                     if (typeof value === 'object' && value !== null && value.$init) {
                         const initializer = ProblemInitializers[value.$init];
+                        // On cherche une instruction de fonction (ex: { "$func": "tsp.calculateEnergy" })
+                        // Note: Actuellement non utilisé, mais prêt pour une future extension.
                         if (initializer) {
                             // On remplace l'objet d'instruction par les données générées.
                             problem.payload[key] = initializer(value.params || {});
@@ -140,6 +205,18 @@ class ProblemManager {
                 task.logProgress = problem.payload.logProgress || false;
                 task.concurrency = problem.payload.concurrency;
                 break;
+            
+            case 'multi_objective_genetic_algorithm':
+                // La difficulté s'applique au nombre de générations
+                const baseGenerationsMulti = Math.max(30, problem.workUnit.baseGenerations || 0);
+                task.generations = scalingFactor
+                    ? Math.floor(baseGenerationsMulti * Math.pow(scalingFactor, suspicionFactor))
+                    : Math.floor(baseGenerationsMulti * (0.5 + suspicionFactor));
+                task.payload = problem.payload;
+                // L'état initial est le front de Pareto actuel, que le client peut utiliser pour l'élitisme
+                task.initialFront = problem.state.paretoFront;
+                task.solverName = problem.workUnit.solverName; // Le nom du solveur à utiliser (ex: 'cpc.solve')
+                break;
         }
 
         return { problemId: problem.id, task };
@@ -156,19 +233,190 @@ class ProblemManager {
 
         switch (problem.workUnit.type) {
             case 'simulated_annealing_iterations':
-                if (solutionData.energy < (parseFloat(problem.state.bestEnergy) || Infinity)) {
+                const currentBest = parseFloat(problem.state.bestEnergy) || Infinity;
+                const isBetter = problem.workUnit.objective === 'maximize'
+                    ? solutionData.energy > currentBest
+                    : solutionData.energy < currentBest;
+
+                if (isBetter) {
                     problem.state.bestSolution = solutionData.solution;
                     problem.state.bestEnergy = solutionData.energy;
+                    problem.state.lastUpdate = new Date().toISOString();
                     console.log(`[ProblemManager] Nouvelle meilleure solution pour ${problemId}: ${solutionData.energy.toFixed(2)}`);
                 }
                 break;
             case 'genetic_algorithm_generations':
+                // Pour l'algo génétique, on pourrait comparer le meilleur fitness de la nouvelle population
                 problem.state.population = solutionData.population;
                 console.log(`[ProblemManager] Population mise à jour pour ${problemId}.`);
                 break;
+            
+            case 'multi_objective_genetic_algorithm':
+                // Pour le multi-objectifs, on fusionne le front de Pareto existant avec celui du client.
+                this._integrateParetoFront(problem, solutionData.paretoFront);
+                break;
         }
         this.saveProblems();
     }
+
+    /**
+     * S'assure qu'un problème a une solution initiale. Si non, en génère une.
+     * @param {object} problem - L'objet problème.
+     * @private
+     */
+    _ensureInitialSolution(problem) {
+        if (problem.state.bestSolution) {
+            return; // Une solution existe déjà
+        }
+
+        console.log(`[ProblemManager] Génération d'une solution initiale pour le problème ${problem.id}...`);
+
+        // On utilise la fonction de score définie dans la config
+        const scoreFunction = problem.workUnit.scoreFunction;
+        // On suppose que la source de la solution initiale est définie dans la config
+        const initialSolutionSource = problem.payload[problem.workUnit.initialSolutionSource];
+
+        if (scoreFunction && initialSolutionSource && Array.isArray(initialSolutionSource)) {
+            const initialSolution = initialSolutionSource;
+            // On calcule le score (énergie, fitness, etc.) de cette solution initiale.
+            // La fonction de scoring peut nécessiter des arguments supplémentaires du payload.
+            const score = scoreFunction(initialSolution, problem.payload);
+
+            problem.state.bestSolution = initialSolution;
+            // Le nom de la propriété du score dépend du type de problème
+            problem.state.bestEnergy = score; // Pourrait être généralisé si besoin
+            problem.state.lastUpdate = new Date().toISOString();
+
+            console.log(`[ProblemManager] Solution initiale pour ${problem.id} générée avec un score de ${score.toFixed(2)}.`);
+            this.saveProblems(); // On sauvegarde la nouvelle solution
+        }
+    }
+
+    /**
+     * Intègre un nouveau front de Pareto dans l'état du problème.
+     * @param {object} problem - L'objet problème.
+     * @param {Array<object>} newFront - Le front de Pareto renvoyé par un client.
+     * @private
+     */
+    _integrateParetoFront(problem, newFront) {
+        if (!Array.isArray(newFront) || newFront.length === 0) return;
+
+        const currentFront = problem.state.paretoFront || [];
+        const combined = [...currentFront, ...newFront];
+
+        // --- Logique de tri non-dominé pour trouver le nouveau meilleur front ---
+        const paretoDominates = (a, b) => {
+            let aIsBetterInOne = false;
+            // On suppose que les objectifs sont à minimiser
+            for (let i = 0; i < a.objectives.length; i++) {
+                if (a.objectives[i] > b.objectives[i]) return false; // A est pire sur au moins un objectif
+                if (a.objectives[i] < b.objectives[i]) aIsBetterInOne = true; // A est strictement meilleur sur au moins un
+            }
+            return aIsBetterInOne;
+        };
+
+        const nextFront = [];
+        const dominatedIndices = new Set();
+
+        for (let i = 0; i < combined.length; i++) {
+            if (dominatedIndices.has(i)) continue;
+            let isDominated = false;
+            for (let j = 0; j < combined.length; j++) {
+                if (i === j || dominatedIndices.has(j)) continue;
+                if (paretoDominates(combined[j], combined[i])) {
+                    isDominated = true;
+                    break;
+                }
+                if (paretoDominates(combined[i], combined[j])) {
+                    dominatedIndices.add(j);
+                }
+            }
+            if (!isDominated) {
+                nextFront.push(combined[i]);
+            }
+        }
+
+        if (nextFront.length > currentFront.length || !problem.state.paretoFront) {
+            console.log(`[ProblemManager] Nouveau front de Pareto pour ${problem.id} avec ${nextFront.length} solutions (précédemment ${currentFront.length}).`);
+            problem.state.paretoFront = nextFront;
+            problem.state.lastUpdate = new Date().toISOString();
+            this.saveProblems();
+        }
+    }
+
+    /**
+     * Récupère la meilleure solution actuellement connue pour un ou plusieurs problèmes.
+     * @param {string} [problemId] - L'ID optionnel du problème à consulter.
+     * Si non fourni, retourne les meilleures solutions pour tous les problèmes.
+     * @returns {object|Array<object>|null}
+     * - Si un `problemId` est fourni, retourne un objet `{ id, solution, score }` ou `null` si non trouvé.
+     * - Si aucun `problemId` n'est fourni, retourne un tableau de ces objets.
+     */
+    getBestSolutions(problemId) {
+        const problemsToProcess = problemId
+            ? this.problems.filter(p => p.id === problemId)
+            : this.problems;
+
+        // On ne génère une solution initiale que pour les problèmes mono-objectif
+        problemsToProcess
+            .filter(p => p.workUnit.type !== 'multi_objective_genetic_algorithm')
+            .forEach(p => this._ensureInitialSolution(p));
+
+        const formatSolution = (p) => {
+            // Après _ensureInitialSolution, on peut supposer que p.state existe.
+            if (!p || !p.state) return null;
+
+            // Cas spécial pour les problèmes multi-objectifs
+            if (p.workUnit.type === 'multi_objective_genetic_algorithm') {
+                return {
+                    id: p.id,
+                    solution: p.state.paretoFront, // La "solution" est l'ensemble du front
+                    score: p.state.paretoFront?.length || 0, // Le "score" est le nombre de points sur le front
+                    lastUpdate: p.state.lastUpdate,
+                };
+            }
+
+            return {
+                id: p.id,
+                solution: p.state.bestSolution,
+                score: p.state.bestEnergy,
+                lastUpdate: p.state.lastUpdate,
+            };
+        };
+
+        if (problemId) {
+            const problem = this.problems.find(p => p.id === problemId);
+            return problem ? formatSolution(problem) : null; // Le filtrage initial a déjà fait le travail
+        }
+
+        // Retourne un aperçu pour tous les problèmes
+        return this.problems.map(formatSolution).filter(s => s && s.solution);
+    }
+
+    /**
+     * Met à jour le payload d'un problème spécifique par son ID.
+     * @param {string} problemId - L'ID du problème à mettre à jour.
+     * @param {object} newPayload - Le nouvel objet payload qui remplacera l'ancien.
+     * @returns {boolean} - True si la mise à jour a réussi, false sinon.
+     */
+    updateProblemPayload(problemId, newPayload) {
+        const problem = this.problems.find(p => p.id === problemId);
+        if (!problem) {
+            console.error(`[ProblemManager] Impossible de mettre à jour : problème avec l'ID '${problemId}' non trouvé.`);
+            return false;
+        }
+
+        console.log(`[ProblemManager] Mise à jour du payload pour le problème '${problemId}'.`);
+        problem.payload = newPayload;
+
+        // Invalider l'état actuel car le problème a changé
+        problem.state.bestSolution = null;
+        problem.state.bestEnergy = "Infinity";
+
+        this.saveProblems();
+        return true;
+    }
+
 }
 
 export { ProblemManager }; // Export the class for testing

package/redis-store.js

@@ -1,43 +1,43 @@
-/**
- * @file Creates a store adapter for ioredis.
- * This adapter handles the serialization and deserialization of complex objects,
- * including the conversion of Set objects to arrays for storage in Redis.
- */
-
-/**
- * Creates a store adapter for an ioredis client.
- * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createRedisStore(redisClient) {
-  return {
-    async get(key) {
-      const value = await redisClient.get(key);
-      if (!value) return null;
-      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
-      return JSON.parse(value, (k, v) => {
-        if (k === 'ips' && Array.isArray(v)) {
-          return new Set(v);
-        }
-        return v;
-      });
-    },
-    async set(key, value, ttl) {
-      // Use a replacer to convert Set objects into arrays before serialization.
-      const stringValue = JSON.stringify(value, (k, v) => {
-        if (v instanceof Set) {
-          return Array.from(v);
-        }
-        return v;
-      });
-
-      if (ttl && ttl > 0) {
-        await redisClient.set(key, stringValue, 'EX', ttl);
-      } else {
-        await redisClient.set(key, stringValue);
-      }
-    },
-    async has(key) { return (await redisClient.exists(key)) === 1; },
-    async delete(key) { await redisClient.del(key); },
-  };
+/**
+ * @file Creates a store adapter for ioredis.
+ * This adapter handles the serialization and deserialization of complex objects,
+ * including the conversion of Set objects to arrays for storage in Redis.
+ */
+
+/**
+ * Creates a store adapter for an ioredis client.
+ * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createRedisStore(redisClient) {
+  return {
+    async get(key) {
+      const value = await redisClient.get(key);
+      if (!value) return null;
+      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
+      return JSON.parse(value, (k, v) => {
+        if (k === 'ips' && Array.isArray(v)) {
+          return new Set(v);
+        }
+        return v;
+      });
+    },
+    async set(key, value, ttl) {
+      // Use a replacer to convert Set objects into arrays before serialization.
+      const stringValue = JSON.stringify(value, (k, v) => {
+        if (v instanceof Set) {
+          return Array.from(v);
+        }
+        return v;
+      });
+
+      if (ttl && ttl > 0) {
+        await redisClient.set(key, stringValue, 'EX', ttl);
+      } else {
+        await redisClient.set(key, stringValue);
+      }
+    },
+    async has(key) { return (await redisClient.exists(key)) === 1; },
+    async delete(key) { await redisClient.del(key); },
+  };
 }

package/sql-store.js

@@ -1,78 +1,78 @@
-/**
- * @file Creates a store adapter for Knex.js.
- * This adapter is compatible with various SQL databases like PostgreSQL, MySQL, and SQLite.
- * It handles serialization of complex objects and TTL for automatic data expiration.
- */
-
-/**
- * Creates a store adapter for a Knex.js client.
- *
- * **Note:** You must create the table yourself before using the store.
- * The table should have at least the following columns:
- * - `key` (string, primary key)
- * - `value` (text or json/jsonb)
- * - `expiresAt` (datetime or timestamp with time zone)
- *
- * Example schema for PostgreSQL:
- * ```sql
- * CREATE TABLE your_table_name (
- *   "key" VARCHAR(255) PRIMARY KEY,
- *   "value" TEXT NOT NULL,
- *   "expiresAt" TIMESTAMPTZ
- * );
- * ```
- *
- * @param {import('knex').Knex} knex - An instance of the Knex client.
- * @param {string} [tableName='fingerprint_store'] - The name of the table to use.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createSqlStore(knex, tableName = 'fingerprint_store') {
-  // Custom replacer/reviver to handle Set serialization, similar to the Redis store.
-  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
-  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
-
-  return {
-    async get(key) {
-      const row = await knex(tableName).where('key', key).first();
-      if (!row) return null;
-
-      // Manually check for expiration, as not all SQL databases have automatic TTL cleanup.
-      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
-        await this.delete(key); // Clean up expired key.
-        return null;
-      }
-
-      try {
-        return JSON.parse(row.value, reviver);
-      } catch (e) {
-        // In case of malformed JSON, treat it as a miss.
-        return null;
-      }
-    },
-
-    async set(key, value, ttl) {
-      const stringValue = JSON.stringify(value, replacer);
-      const expiresAt = ttl ? new Date(Date.now() + ttl * 1000) : null;
-
-      // Use native upsert capabilities of Knex for different SQL dialects.
-      await knex(tableName)
-        .insert({ key, value: stringValue, expiresAt })
-        .onConflict('key')
-        .merge();
-    },
-
-    async has(key) {
-      const row = await knex(tableName).where('key', key).first('key');
-      if (!row) return false;
-      // Also check for expiration here.
-      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
-        return false;
-      }
-      return true;
-    },
-
-    async delete(key) {
-      await knex(tableName).where('key', key).del();
-    },
-  };
+/**
+ * @file Creates a store adapter for Knex.js.
+ * This adapter is compatible with various SQL databases like PostgreSQL, MySQL, and SQLite.
+ * It handles serialization of complex objects and TTL for automatic data expiration.
+ */
+
+/**
+ * Creates a store adapter for a Knex.js client.
+ *
+ * **Note:** You must create the table yourself before using the store.
+ * The table should have at least the following columns:
+ * - `key` (string, primary key)
+ * - `value` (text or json/jsonb)
+ * - `expiresAt` (datetime or timestamp with time zone)
+ *
+ * Example schema for PostgreSQL:
+ * ```sql
+ * CREATE TABLE your_table_name (
+ *   "key" VARCHAR(255) PRIMARY KEY,
+ *   "value" TEXT NOT NULL,
+ *   "expiresAt" TIMESTAMPTZ
+ * );
+ * ```
+ *
+ * @param {import('knex').Knex} knex - An instance of the Knex client.
+ * @param {string} [tableName='fingerprint_store'] - The name of the table to use.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createSqlStore(knex, tableName = 'fingerprint_store') {
+  // Custom replacer/reviver to handle Set serialization, similar to the Redis store.
+  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
+  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
+
+  return {
+    async get(key) {
+      const row = await knex(tableName).where('key', key).first();
+      if (!row) return null;
+
+      // Manually check for expiration, as not all SQL databases have automatic TTL cleanup.
+      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
+        await this.delete(key); // Clean up expired key.
+        return null;
+      }
+
+      try {
+        return JSON.parse(row.value, reviver);
+      } catch (e) {
+        // In case of malformed JSON, treat it as a miss.
+        return null;
+      }
+    },
+
+    async set(key, value, ttl) {
+      const stringValue = JSON.stringify(value, replacer);
+      const expiresAt = ttl ? new Date(Date.now() + ttl * 1000) : null;
+
+      // Use native upsert capabilities of Knex for different SQL dialects.
+      await knex(tableName)
+        .insert({ key, value: stringValue, expiresAt })
+        .onConflict('key')
+        .merge();
+    },
+
+    async has(key) {
+      const row = await knex(tableName).where('key', key).first('key');
+      if (!row) return false;
+      // Also check for expiration here.
+      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
+        return false;
+      }
+      return true;
+    },
+
+    async delete(key) {
+      await knex(tableName).where('key', key).del();
+    },
+  };
 }