bulltrackers-module 1.0.213 → 1.0.214

package/functions/computation-system/helpers/computation_manifest_builder.js

@@ -1,26 +1,19 @@
 /**
  * @fileoverview
- * Dynamic Manifest Builder (v5.1 - Smart Hashing with Safe Mode)
+ * Dynamic Manifest Builder (v6 - Merkle Tree Dependency Hashing)
  *
- * This script builds the computation manifest and generates a "Smart Hash"
- * for each calculation.
- *
- * KEY FEATURE:
- * It performs static analysis on the calculation code to detect which
- * specific math layers it utilizes. It then combines the calculation's own
- * code hash with the current hashes of those specific layers.
- * * SAFE MODE:
- * If a calculation uses no detectable layer keywords, it defaults to
- * depending on ALL layers to prevent staleness.
- * * FIXED:
- * - Broadened LAYER_TRIGGERS to detect context usage (e.g. 'math.signals')
- * - Updated isHistorical check to look for 'previousComputed'
+ * KEY FEATURES:
+ * 1. Smart Layer Hashing: Detects used layers (Math, Extractors) to avoid stale helper code.
+ * 2. Cascading Invalidation (Merkle Hashing): 
+ * The final hash of a computation is derived from:
+ * [Own Code] + [Layer States] + [Hashes of all Dependencies]
+ * * This guarantees that if Calculation A is updated, Calculation B (which depends on A)
+ * will automatically generate a new hash, forcing the system to re-run it.
  */
 
 const { generateCodeHash } = require('../utils/utils');
 
 // 1. Import Layers directly to generate their "State Hashes"
-// We import them individually to hash them as distinct domains.
 const MathematicsLayer = require('../layers/mathematics');
 const ExtractorsLayer  = require('../layers/extractors');
 const ProfilingLayer   = require('../layers/profiling');
@@ -30,10 +23,6 @@ const ValidatorsLayer  = require('../layers/validators');
  * 1. Layer Hash Generation
  * -------------------------------------------------- */
 
-/**
- * Generates a single hash representing the entire state of a layer module.
- * Combines all exported classes/functions/objects into one deterministic string.
- */
 function generateLayerHash(layerExports, layerName) {
     const keys = Object.keys(layerExports).sort(); // Sort for determinism
     let combinedSource = `LAYER:${layerName}`;
@@ -60,7 +49,6 @@ const LAYER_HASHES = {
 };
 
 // Map code patterns to Layer dependencies
-// If a calculation's code contains these strings, it depends on that layer.
 const LAYER_TRIGGERS = {
     'mathematics': [
         'math.compute', 'MathPrimitives',
@@ -124,18 +112,6 @@ function suggestClosest(name, candidates, n = 3) {
     return scores.slice(0, n).map(s => s[0]);
 }
 
-function findCycles(manifestMap, adjacencyList) {
-    const visited = new Set(), stack = new Set(), cycles = [];
-    const dfs = (node, path) => {
-        if (stack.has(node)) { const idx = path.indexOf(node); cycles.push([...path.slice(idx), node]); return; }
-        if (visited.has(node)) return;
-        visited.add(node); stack.add(node);
-        for (const nb of adjacencyList.get(node) || []) dfs(nb, [...path, nb]);
-        stack.delete(node); };
-    for (const name of manifestMap.keys()) dfs(name, [name]);
-    return cycles;
-}
-
 function getDependencySet(endpoints, adjacencyList) {
     const required = new Set(endpoints);
     const queue    = [...endpoints];
@@ -149,24 +125,21 @@ function getDependencySet(endpoints, adjacencyList) {
  * -------------------------------------------------- */
 
 function buildManifest(productLinesToRun = [], calculations) {
-    log.divider('Building Dynamic Manifest (Smart Hashing)');
+    log.divider('Building Dynamic Manifest (Merkle Hashing)');
     log.info(`Target Product Lines: [${productLinesToRun.join(', ')}]`);
-    log.info(`Layer Hashes Initialized: ${Object.keys(LAYER_HASHES).join(', ')}`);
-
+    
     const manifestMap      = new Map();
     const adjacency        = new Map(); 
     const reverseAdjacency = new Map(); 
     const inDegree         = new Map();
     let hasFatalError      = false;
     
-    /* ---------------- 1. Load All Calculations ---------------- */
+    /* ---------------- 1. Load All Calculations (Phase 1: Intrinsic Hash) ---------------- */
     log.step('Loading and validating all calculation classes…');
-    const allCalculationClasses = new Map();
 
     function processCalc(Class, name, folderName) {
         if (!Class || typeof Class !== 'function') return;
         const normalizedName = normalizeName(name);
-        allCalculationClasses.set(normalizedName, Class);
         
         if (typeof Class.getMetadata !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getMetadata().`); hasFatalError = true; return; }
         if (typeof Class.getDependencies !== 'function') { log.fatal(`Calculation "${normalizedName}" is missing static getDependencies().`); hasFatalError = true;return; }
@@ -174,47 +147,34 @@ function buildManifest(productLinesToRun = [], calculations) {
         const metadata     = Class.getMetadata();
         const dependencies = Class.getDependencies().map(normalizeName);
         
-        // FIX: Updated check to include 'previousComputed'
         const codeStr = Class.toString();
         if (metadata.isHistorical === true && !codeStr.includes('yesterday') && !codeStr.includes('previousComputed')) { 
-            log.warn(`Calculation "${normalizedName}" marked 'isHistorical' but no 'previousComputed' or 'yesterday' reference found.`); 
+            log.warn(`Calculation "${normalizedName}" marked 'isHistorical' but no 'previousComputed' state reference found.`); 
         }
 
-        let finalCategory = folderName;
-        if (folderName === 'core') {
-            if (metadata.category) finalCategory = metadata.category;
-        } else {
-            finalCategory = folderName;
-        }
+        let finalCategory = folderName === 'core' && metadata.category ? metadata.category : folderName;
 
-        // --- SMART HASH GENERATION ---
-        let compositeHashString = generateCodeHash(codeStr); // Start with own code
+        // --- PHASE 1: INTRINSIC HASH (Code + Layers) ---
+        // We do NOT include dependencies yet.
+        let compositeHashString = generateCodeHash(codeStr); 
         const usedLayers = [];
 
-        // 1. Check for specific layer usage
+        // Check for specific layer usage
         for (const [layerName, triggers] of Object.entries(LAYER_TRIGGERS)) {
-            // If code contains any trigger for this layer
             if (triggers.some(trigger => codeStr.includes(trigger))) {
-                compositeHashString += LAYER_HASHES[layerName]; // Append Layer Hash
+                compositeHashString += LAYER_HASHES[layerName]; 
                 usedLayers.push(layerName);
             }
         }
 
-        // 2. SAFE MODE FALLBACK
-        // If we found NO specific triggers (e.g. legacy code or unique structure), 
-        // assume it might use anything. Depend on ALL layers to be safe.
+        // Safe Mode Fallback
         let isSafeMode = false;
         if (usedLayers.length === 0) {
             isSafeMode = true;
             Object.values(LAYER_HASHES).forEach(h => compositeHashString += h);
         }
 
-        // Generate final composite hash
-        const finalHash = generateCodeHash(compositeHashString);
-
-        if (isSafeMode) {
-            log.warn(`[Hash] ${normalizedName}: No specific dependencies detected. Enforcing SAFE MODE (Linked to ALL Layers).`);
-        } 
+        const baseHash = generateCodeHash(compositeHashString);
 
         const manifestEntry = {
             name: normalizedName,
@@ -227,7 +187,7 @@ function buildManifest(productLinesToRun = [], calculations) {
             userType: metadata.userType,
             dependencies: dependencies,
             pass: 0,
-            hash: finalHash, // The Smart Hash
+            hash: baseHash, // Intrinsic Hash (Updated later to include deps)
             debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedLayers
         };
         
@@ -241,7 +201,6 @@ function buildManifest(productLinesToRun = [], calculations) {
         throw new Error('Manifest build failed: Invalid calculations object.');
     }
 
-    // Iterate over folders (folderName becomes the default category)
     for (const folderName in calculations) {
         if (folderName === 'legacy') continue;
         const group = calculations[folderName];
@@ -312,6 +271,31 @@ function buildManifest(productLinesToRun = [], calculations) {
     if (sortedManifest.length !== filteredManifestMap.size) {
         throw new Error('Circular dependency detected. Manifest build failed.'); }
 
+    /* ---------------- 5. Phase 2: Cascading Dependency Hashing ---------------- */
+    // Now that we have a topological order (Dependencies come BEFORE Consumers),
+    // we can update hashes sequentially.
+    log.step('Computing Cascading Merkle Hashes...');
+
+    for (const entry of sortedManifest) {
+        // Start with the intrinsic hash (Code + Layers)
+        let dependencySignature = entry.hash;
+
+        // Append the hashes of all dependencies
+        // Since we are iterating in topo order, dependencies are guaranteed to be processed/updated already.
+        if (entry.dependencies && entry.dependencies.length > 0) {
+            const depHashes = entry.dependencies.map(depName => {
+                const depEntry = filteredManifestMap.get(depName);
+                if (!depEntry) return ''; // Should not happen given validation
+                return depEntry.hash;
+            }).join('|'); // Use separator to prevent collisions
+            
+            dependencySignature += `|DEPS:${depHashes}`;
+        }
+
+        // Generate the Final Smart Hash
+        entry.hash = generateCodeHash(dependencySignature);
+    }
+
     log.success(`Total passes required: ${maxPass}`);
     return sortedManifest;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.213",
+  "version": "1.0.214",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [