bulltrackers-module 1.0.218 → 1.0.219

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

@@ -1,14 +1,13 @@
 /**
  * @fileoverview
- * Dynamic Manifest Builder (v6 - Merkle Tree Dependency Hashing)
+ * Dynamic Manifest Builder (v6.1 - Granular Merkle Tree Dependency Hashing)
  *
  * KEY FEATURES:
- * 1. Smart Layer Hashing: Detects used layers (Math, Extractors) to avoid stale helper code.
+ * 1. Smart Granular Hashing: Detects SPECIFIC classes used within layers to avoid unnecessary re-runs.
+ * - Changing 'MathPrimitives' won't invalidate computations that only use 'SignalPrimitives'.
  * 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.
+ * [Own Code] + [Specific Layer Class Hashes] + [Hashes of all Dependencies]
  */
 
 const { generateCodeHash } = require('../utils/utils');
@@ -20,57 +19,75 @@ const ProfilingLayer   = require('../layers/profiling');
 const ValidatorsLayer  = require('../layers/validators');
 
 /* --------------------------------------------------
- * 1. Layer Hash Generation
+ * 1. Granular Layer Hash Generation
  * -------------------------------------------------- */
 
-function generateLayerHash(layerExports, layerName) {
+/**
+ * Generates a map of hashes for every export in a layer.
+ * Returns: { 'MathPrimitives': 'sha256...', 'SignalPrimitives': 'sha256...', ... }
+ */
+function generateLayerHashes(layerExports, layerName) {
+    const hashes = {};
     const keys = Object.keys(layerExports).sort(); 
-    let combinedSource = `LAYER:${layerName}`;
 
     for (const key of keys) {
         const item = layerExports[key];
-        if (typeof item === 'function')                       { combinedSource += item.toString();
-        } else if (typeof item === 'object' && item !== null) { combinedSource += JSON.stringify(item);
-        } else                                                { combinedSource += String(item); }
+        // We hash the specific export content prefixed with its identity
+        let source = `LAYER:${layerName}:EXPORT:${key}`;
+
+        if (typeof item === 'function') {
+            source += item.toString();
+        } else if (typeof item === 'object' && item !== null) {
+            source += JSON.stringify(item);
+        } else {
+            source += String(item);
+        }
+        
+        hashes[key] = generateCodeHash(source);
     }
-    return generateCodeHash(combinedSource);
+    return hashes;
 }
 
-// Pre-compute layer hashes at startup
+// Pre-compute granular layer hashes at startup
+// Structure: { mathematics: { MathPrimitives: '...', SignalPrimitives: '...' }, ... }
 const LAYER_HASHES = {
-    'mathematics': generateLayerHash(MathematicsLayer, 'mathematics'),
-    'extractors':  generateLayerHash(ExtractorsLayer,  'extractors'),
-    'profiling':   generateLayerHash(ProfilingLayer,   'profiling'),
-    'validators':  generateLayerHash(ValidatorsLayer,  'validators')
+    'mathematics': generateLayerHashes(MathematicsLayer, 'mathematics'),
+    'extractors':  generateLayerHashes(ExtractorsLayer,  'extractors'),
+    'profiling':   generateLayerHashes(ProfilingLayer,   'profiling'),
+    'validators':  generateLayerHashes(ValidatorsLayer,  'validators')
 };
 
-// Map code patterns to Layer dependencies
+// Map code patterns to SPECIFIC Layer Exports
+// Structure: { LayerName: { ExportName: [Triggers...] } }
 const LAYER_TRIGGERS = {
-    'mathematics': [
-        'math.compute', 'MathPrimitives',
-        'math.signals', 'SignalPrimitives', 'signals.',
-        'math.aggregate', 'Aggregators',
-        'math.timeseries', 'TimeSeries', 'timeSeries.',
-        'math.distribution', 'DistributionAnalytics', 'distribution.',
-        'math.financial', 'FinancialEngineering'
-    ],
-    'extractors': [
-        'math.extract', 'DataExtractor',
-        'math.history', 'HistoryExtractor',
-        'math.prices', 'priceExtractor',
-        'math.insights', 'InsightsExtractor', 'insights.',
-        'math.tradeSeries', 'TradeSeriesBuilder'
-    ],
-    'profiling': [
-        'math.profiling', 'SCHEMAS',
-        'math.classifier', 'UserClassifier',
-        'math.psychometrics', 'Psychometrics',
-        'math.bias', 'CognitiveBiases',
-        'math.skill', 'SkillAttribution'
-    ],
-    'validators': [
-        'math.validate', 'Validators'
-    ]
+    'mathematics': {
+        'MathPrimitives':        ['math.compute', 'MathPrimitives'],
+        'SignalPrimitives':      ['math.signals', 'SignalPrimitives', 'signals.'],
+        'Aggregators':           ['math.aggregate', 'Aggregators'],
+        'TimeSeries':            ['math.timeseries', 'TimeSeries', 'timeSeries.'],
+        'TimeSeriesAnalysis':    ['TimeSeriesAnalysis'],
+        'DistributionAnalytics': ['math.distribution', 'DistributionAnalytics', 'distribution.'],
+        'FinancialEngineering':  ['math.financial', 'FinancialEngineering']
+    },
+    'extractors': {
+        'DataExtractor':         ['math.extract', 'DataExtractor'],
+        'HistoryExtractor':      ['math.history', 'HistoryExtractor'],
+        'priceExtractor':        ['math.prices', 'priceExtractor'],
+        'InsightsExtractor':     ['math.insights', 'InsightsExtractor', 'insights.'],
+        'TradeSeriesBuilder':    ['math.tradeSeries', 'TradeSeriesBuilder']
+    },
+    'profiling': {
+        'SCHEMAS':               ['math.profiling', 'SCHEMAS'],
+        'UserClassifier':        ['math.classifier', 'UserClassifier'],
+        'Psychometrics':         ['math.psychometrics', 'Psychometrics'],
+        'CognitiveBiases':       ['math.bias', 'CognitiveBiases'],
+        'SkillAttribution':      ['math.skill', 'SkillAttribution'],
+        'ExecutionAnalytics':    ['ExecutionAnalytics'],
+        'AdaptiveAnalytics':     ['AdaptiveAnalytics']
+    },
+    'validators': {
+        'Validators':            ['math.validate', 'Validators']
+    }
 };
 
 /* --------------------------------------------------
@@ -121,7 +138,7 @@ function getDependencySet(endpoints, adjacencyList) {
  * -------------------------------------------------- */
 
 function buildManifest(productLinesToRun = [], calculations) {
-    log.divider('Building Dynamic Manifest (Merkle Hashing)');
+    log.divider('Building Dynamic Manifest (Granular Merkle Hashing)');
     log.info(`Target Product Lines: [${productLinesToRun.join(', ')}]`);
     
     const manifestMap      = new Map();
@@ -150,21 +167,33 @@ function buildManifest(productLinesToRun = [], calculations) {
 
         let finalCategory = folderName === 'core' && metadata.category ? metadata.category : folderName;
 
-        // --- PHASE 1: INTRINSIC HASH (Code + Layers) ---
-        // We do NOT include dependencies yet.
+        // --- PHASE 1: INTRINSIC HASH (Code + Granular Layers) ---
         let compositeHashString = generateCodeHash(codeStr); 
-        const usedLayers = [];
-
-        // Check for specific layer usage
-        for (const [layerName, triggers] of Object.entries(LAYER_TRIGGERS)) {
-            if (triggers.some(trigger => codeStr.includes(trigger))) { compositeHashString += LAYER_HASHES[layerName];  usedLayers.push(layerName); }
+        const usedDeps = [];
+
+        // Check for specific layer usage (Granular Check)
+        for (const [layerName, exportsMap] of Object.entries(LAYER_TRIGGERS)) {
+            const layerHashes = LAYER_HASHES[layerName]; // { Export: Hash }
+
+            for (const [exportName, triggers] of Object.entries(exportsMap)) {
+                // If code uses this specific export...
+                if (triggers.some(trigger => codeStr.includes(trigger))) {
+                    const exportHash = layerHashes[exportName];
+                    if (exportHash) {
+                        compositeHashString += exportHash;
+                        usedDeps.push(`${layerName}.${exportName}`);
+                    }
+                }
+            }
         }
 
-        // Safe Mode Fallback
+        // Safe Mode Fallback: If no dependencies detected, assume usage of ALL to be safe.
         let isSafeMode = false;
-        if (usedLayers.length === 0) {
+        if (usedDeps.length === 0) {
             isSafeMode = true;
-            Object.values(LAYER_HASHES).forEach(h => compositeHashString += h);
+            Object.values(LAYER_HASHES).forEach(layerObj => {
+                Object.values(layerObj).forEach(h => compositeHashString += h);
+            });
         }
 
         const baseHash = generateCodeHash(compositeHashString);
@@ -181,7 +210,7 @@ function buildManifest(productLinesToRun = [], calculations) {
             dependencies: dependencies,
             pass: 0,
             hash: baseHash,
-            debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedLayers
+            debugUsedLayers: isSafeMode ? ['ALL (Safe Mode)'] : usedDeps
         };
         
         manifestMap.set(normalizedName, manifestEntry);
@@ -264,7 +293,7 @@ function buildManifest(productLinesToRun = [], calculations) {
     log.step('Computing Cascading Merkle Hashes...');
 
     for (const entry of sortedManifest) {
-        // Start with the intrinsic hash (Code + Layers)
+        // Start with the intrinsic hash (Code + Granular Layers)
         let dependencySignature = entry.hash;
 
         if (entry.dependencies && entry.dependencies.length > 0) {

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

@@ -70,16 +70,9 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
         const storedStatus = dailyStatus[cName];
         const currentHash  = calc.hash;
 
-        // 1. Dependency Check
         if (calc.dependencies && calc.dependencies.length > 0) { const missing = calc.dependencies.filter(depName => !dailyStatus[normalizeName(depName)]); if (missing.length > 0) { logger.log('TRACE', `[Skip] ${cName} missing deps: ${missing.join(', ')}`);  continue; } }
-
-        // 2. Logic A: No previous run
         if (!storedStatus) { logger.log('INFO', `[Versioning] ${cName}: New run needed (No prior status).`); calcsToAttempt.push(calc); continue; }
-
-        // 3. Logic B: Hash Mismatch
         if (typeof storedStatus === 'string' && currentHash && storedStatus !== currentHash) { logger.log('INFO', `[Versioning] ${cName}: Code Changed. (Old: ${storedStatus.substring(0,6)}... New: ${currentHash.substring(0,6)}...)`); calcsToAttempt.push(calc); continue; }
-
-        // 4. Logic C: Upgrade Legacy Boolean -> Hash
         if (storedStatus === true && currentHash) { logger.log('INFO', `[Versioning] ${cName}: Upgrading legacy status to Hash.`); calcsToAttempt.push(calc); continue; }
     }
 
@@ -109,11 +102,8 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
         const prevDateStr     = prevDate.toISOString().slice(0, 10);
         const previousResults = await fetchExistingResults(prevDateStr, calcsRunning, computationManifest, config, dependencies, true);
 
-        if (standardToRun.length) { const updates = await runStandardComputationPass(dateToProcess, standardToRun, `Pass ${passToRun} (Std)`, config, dependencies, rootData, existingResults, previousResults, false);
-            Object.assign(dateUpdates, updates); }
-
-        if (metaToRun.length) { const updates = await runMetaComputationPass(dateToProcess, metaToRun, `Pass ${passToRun} (Meta)`, config, dependencies, existingResults, previousResults, rootData, false);
-            Object.assign(dateUpdates, updates); }
+        if (standardToRun.length) { const updates = await runStandardComputationPass(dateToProcess, standardToRun, `Pass ${passToRun} (Std)`, config, dependencies, rootData, existingResults, previousResults, false); Object.assign(dateUpdates, updates); }
+        if (metaToRun.length) { const updates = await runMetaComputationPass(dateToProcess, metaToRun, `Pass ${passToRun} (Meta)`, config, dependencies, existingResults, previousResults, rootData, false); Object.assign(dateUpdates, updates); }
 
     } catch (err) {
         logger.log('ERROR', `[DateRunner] FAILED Pass ${passToRun} for ${dateStr}`, { errorMessage: err.message });

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

@@ -28,7 +28,7 @@ const LEGACY_MAPPING = {
 
 function groupByPass(manifest) { return manifest.reduce((acc, calc) => { (acc[calc.pass] = acc[calc.pass] || []).push(calc); return acc; }, {}); }
 
-function validateResultPatterns(logger, calcName, results, category) {
+function validateResultPatterns(logger, calcName, results, category) { // TODO Unused? Could use this for validation
     if (category === 'speculator' || category === 'speculators') return;
     const tickers = Object.keys(results); const totalItems = tickers.length; if (totalItems < 5) return;
     const sampleTicker = tickers.find(t => results[t] && typeof results[t] === 'object'); if (!sampleTicker) return;

package/functions/computation-system/layers/extractors.js

@@ -252,6 +252,14 @@ class InsightsExtractor {
      * @param {string} timeframe - 'today' or 'yesterday'
      * @returns {Array} Array of insight objects
      */
+
+    // MAJOR FIX TO GET INSIGHTS METHOD FOR THE CORRECT STRUCTURE AND SUPPORTING YESTERDAY + TODAY DATA REQUESTS
+    // THIS IS INJECTED TO BE USED LIKE :
+
+    // process(context) {
+       // const { insights: insightsHelper } = context.math;
+        // const insights = insightsHelper.getInsights(context); This is the direct call
+
     static getInsights(context, timeframe = 'today') {
         const insightsData = context.insights;
         
@@ -263,9 +271,7 @@ class InsightsExtractor {
         if (!doc) return [];
         
         // Extract the insights array from the document
-        if (doc.insights && Array.isArray(doc.insights)) {
-            return doc.insights;
-        }
+        if (doc.insights && Array.isArray(doc.insights)) { return doc.insights; }
         
         return [];
     }

package/package.json

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