bulltrackers-module 1.0.287 → 1.0.288

package/functions/computation-system/context/ManifestBuilder.js

@@ -2,9 +2,10 @@
  * @fileoverview Dynamic Manifest Builder - Handles Topological Sort and Auto-Discovery.
  * UPDATED: Generates Granular Hash Composition for Audit Trails.
  * UPGRADE: Implements Tarjan's Algorithm for Precise Cycle Detection.
+ * FIXED: Now incorporates System Infrastructure Hash into Calculation Hashes.
  */
-const { generateCodeHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
-const { normalizeName }                    = require('../utils/utils');
+const { generateCodeHash, getInfrastructureHash, LEGACY_MAPPING } = require('../topology/HashManager.js');
+const { normalizeName } = require('../utils/utils');
 
 const SYSTEM_EPOCH = require('../system_epoch');
 
@@ -138,7 +139,6 @@ function detectCircularDependencies(manifestMap) {
     }
 
     if (cycles.length > 0) {
-        // Format the first cycle for display
         const cycle = cycles[0];
         return cycle.join(' -> ') + ' -> ' + cycle[0];
     }
@@ -148,6 +148,10 @@ function detectCircularDependencies(manifestMap) {
 function buildManifest(productLinesToRun = [], calculations) {
     log.divider('Building Dynamic Manifest');
     
+    // [CRITICAL FIX] Calculate Infrastructure Hash once per build
+    const INFRA_HASH = getInfrastructureHash();
+    log.info(`[ManifestBuilder] System Infrastructure Hash: ${INFRA_HASH.substring(0, 8)}`);
+
     const requestedLog = (!productLinesToRun || productLinesToRun.length === 0) 
         ? "ALL (Wildcard/Empty)" 
         : productLinesToRun.join(', ');
@@ -171,7 +175,9 @@ function buildManifest(productLinesToRun = [], calculations) {
         const codeStr      = Class.toString();
         const selfCodeHash = generateCodeHash(codeStr);
         
-        let compositeHashString = selfCodeHash + `|EPOCH:${SYSTEM_EPOCH}`; 
+        // [CRITICAL FIX] Include INFRA_HASH in the composite signature
+        // This ensures that if the system platform changes, ALL calculations are considered "changed"
+        let compositeHashString = selfCodeHash + `|EPOCH:${SYSTEM_EPOCH}|INFRA:${INFRA_HASH}`; 
         
         const usedDeps = [];
         const usedLayerHashes = {}; 
@@ -221,6 +227,7 @@ function buildManifest(productLinesToRun = [], calculations) {
             composition: {
                 epoch: SYSTEM_EPOCH,
                 code: selfCodeHash,
+                infra: INFRA_HASH, // Stored in composition for audit
                 layers: layerComposition,
                 deps: {} 
             },
@@ -235,9 +242,9 @@ function buildManifest(productLinesToRun = [], calculations) {
     
     for (const folderName in calculations) {
         if (folderName === 'legacy') continue;
-        const group = calculations[folderName];
-        for (const key in group) {
-            const entry = group[key];
+        const calculationGroup = calculations[folderName];
+        for (const key in calculationGroup) {
+            const entry = calculationGroup[key];
             if (typeof entry === 'function') { processCalc(entry, key, folderName); } 
         } 
     }
@@ -312,7 +319,6 @@ function buildManifest(productLinesToRun = [], calculations) {
         queue.sort(); 
     }
 
-    // UPGRADE: Use Tarjan's for precise cycle reporting
     if (sortedManifest.length !== filteredManifestMap.size) {
         const cycle = detectCircularDependencies(filteredManifestMap);
         if (cycle) {

package/functions/computation-system/tools/BuildReporter.js

@@ -1,33 +1,107 @@
+const { analyzeDateExecution } = require('../WorkflowOrchestrator');
+const { fetchComputationStatus, updateComputationStatus } = require('../persistence/StatusRepository');
+const { normalizeName, getExpectedDateStrings, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils');
+const { checkRootDataAvailability } = require('../data/AvailabilityChecker');
+const SimRunner = require('../simulation/SimRunner');
+const pLimit = require('p-limit');
+const path = require('path');
+const crypto = require('crypto');
+const fs = require('fs'); // [NEW] Required for file reading
+const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+const packageVersion = packageJson.version;
+const { generateCodeHash } = require('../utils/utils'); // Reuse your standard logic
+
+// Persistent Registry for SimHashes
+const SIMHASH_REGISTRY_COLLECTION = 'system_simhash_registry';
+
+// --- [NEW] RECURSIVE SYSTEM HASHING ---
+
+// 1. define the Root of the system (one level up from 'tools')
+const SYSTEM_ROOT = path.resolve(__dirname, '..');
+
+// 2. Define what to ignore to prevent noise or infinite loops
+const IGNORED_DIRS = new Set(['node_modules', '.git', '.idea', 'coverage', 'logs', 'tests']);
+const IGNORED_FILES = new Set(['package-lock.json', '.DS_Store', '.env']);
+
+/**
+ * Recursively walks a directory and returns a list of file paths.
+ */
+function walkSync(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    
+    files.forEach(file => {
+        if (IGNORED_FILES.has(file)) return;
+        
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        
+        if (stat.isDirectory()) {
+            if (!IGNORED_DIRS.has(file)) {
+                walkSync(filePath, fileList);
+            }
+        } else {
+            // Only hash code files (add .yaml if you want workflows included)
+            if (file.endsWith('.js') || file.endsWith('.json') || file.endsWith('.yaml')) {
+                fileList.push(filePath);
+            }
+        }
+    });
+    return fileList;
+}
+
 /**
- * @fileoverview Build Reporter & Auto-Runner.
- * Generates a "Pre-Flight" report of what the computation system WILL do.
- * UPGRADED: Implements Behavioral Hashing (SimHash) to detect Cosmetic vs Logic changes.
- * OPTIMIZED: Caches SimHashes and actively updates status for Stable items to prevent re-runs.
- * OPTIMIZED (V2): Implements System Fingerprinting to skip 90-day scan if manifest is identical.
+ * Generates a single hash representing the entire infrastructure code state.
  */
+function getInfrastructureHash() {
+    try {
+        const allFiles = walkSync(SYSTEM_ROOT);
+        allFiles.sort(); // Crucial for determinism
+
+        const bigHash = crypto.createHash('sha256');
+
+        for (const filePath of allFiles) {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const relativePath = path.relative(SYSTEM_ROOT, filePath);
+
+            // DECISION: How to clean?
+            let cleanContent = content;
+
+            // 1. If it's JS, use your system standard for code hashing
+            if (filePath.endsWith('.js')) {
+                // This strips comments and whitespace consistently with ManifestBuilder
+                // Note: generateCodeHash returns a hash, we can just use that hash
+                cleanContent = generateCodeHash(content); 
+            } 
+            // 2. If it's JSON/YAML, just strip basic whitespace to ignore indent changes
+            else {
+                cleanContent = content.replace(/\s+/g, '');
+            }
 
-const { analyzeDateExecution }                                             = require('../WorkflowOrchestrator');
-const { fetchComputationStatus, updateComputationStatus }                  = require('../persistence/StatusRepository');
-const { normalizeName, getExpectedDateStrings, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils');
-const { checkRootDataAvailability }                                        = require('../data/AvailabilityChecker');
-const SimRunner                                                            = require('../simulation/SimRunner');
-const pLimit                                                               = require('p-limit');
-const path                                                                 = require('path');
-const crypto                                                               = require('crypto');
-const packageJson                                                          = require(path.join(__dirname, '..', '..', '..', 'package.json'));
-const packageVersion                                                       = packageJson.version;
-
-// Persistent Registry for SimHashes (so Workers don't have to recalc)
-const SIMHASH_REGISTRY_COLLECTION = 'system_simhash_registry';
+            // Feed the PATH and the CLEAN CONTENT into the master hash
+            bigHash.update(`${relativePath}:${cleanContent}|`);
+        }
+
+        return bigHash.digest('hex');
+    } catch (e) {
+        console.warn(`[BuildReporter] ⚠️ Failed to generate infra hash: ${e.message}`);
+        return 'infra_hash_error'; // Fail safe so we run the report rather than crash
+    }
+}
 
 /**
- * Helper: Generates a unique signature for the entire computation system state.
- * If ANY calculation logic or dependency changes, this hash changes.
+ * UPDATED: System Fingerprint = Manifest Hash + Infrastructure Hash
  */
 function getSystemFingerprint(manifest) {
-    // Sort to ensure determinism
-    const sortedHashes = manifest.map(c => c.hash).sort().join('|');
-    return crypto.createHash('sha256').update(sortedHashes).digest('hex');
+    // 1. Business Logic Hash (The Calculations)
+    const sortedManifestHashes = manifest.map(c => c.hash).sort().join('|');
+    
+    // 2. Infrastructure Hash (The System Code)
+    const infraHash = getInfrastructureHash();
+
+    // 3. Combine
+    return crypto.createHash('sha256')
+        .update(sortedManifestHashes + infraHash)
+        .digest('hex');
 }
 
 /**

package/functions/computation-system/topology/HashManager.js

@@ -1,7 +1,10 @@
 /**
  * @fileoverview Manages code versioning, hashing, and legacy mappings.
+ * UPDATED: Includes Centralized Infrastructure Hashing to track system-level changes.
  */
 const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
 
 // Legacy Keys Mapping (Ensures backward compatibility)
 const LEGACY_MAPPING = {
@@ -24,6 +27,10 @@ const LEGACY_MAPPING = {
     AdaptiveAnalytics: 'adaptive'
 };
 
+/**
+ * Generates a SHA-256 hash of a code string.
+ * Strips comments and whitespace for loose equality.
+ */
 function generateCodeHash(codeString) {
     if (!codeString) return 'unknown';
     let clean = codeString.replace(/\/\/.*$/gm, '');
@@ -32,4 +39,66 @@ function generateCodeHash(codeString) {
     return crypto.createHash('sha256').update(clean).digest('hex');
 }
 
-module.exports = { LEGACY_MAPPING, generateCodeHash };
+// --- INFRASTRUCTURE HASHING (The "System Fingerprint") ---
+
+const SYSTEM_ROOT = path.resolve(__dirname, '..');
+const IGNORED_DIRS = new Set(['node_modules', '.git', '.idea', 'coverage', 'logs', 'tests', 'docs']);
+const IGNORED_FILES = new Set(['package-lock.json', '.DS_Store', '.env', 'README.md']);
+
+function walkSync(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        if (IGNORED_FILES.has(file)) return;
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            if (!IGNORED_DIRS.has(file)) {
+                walkSync(filePath, fileList);
+            }
+        } else {
+            // Hash JS, JSON, and YAML (Workflows)
+            if (file.endsWith('.js') || file.endsWith('.json') || file.endsWith('.yaml')) {
+                fileList.push(filePath);
+            }
+        }
+    });
+    return fileList;
+}
+
+/**
+ * Generates a hash representing the state of the entire computation-system codebase.
+ * This ensures that changes to infrastructure (like ContextFactory or Executors)
+ * trigger a re-run of calculations even if the calculation logic itself didn't change.
+ */
+function getInfrastructureHash() {
+    try {
+        const allFiles = walkSync(SYSTEM_ROOT);
+        allFiles.sort(); // Crucial for determinism
+
+        const bigHash = crypto.createHash('sha256');
+
+        for (const filePath of allFiles) {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const relativePath = path.relative(SYSTEM_ROOT, filePath);
+            
+            let cleanContent = content;
+
+            // Reuse the standard code hash logic for JS files to be consistent
+            if (filePath.endsWith('.js')) {
+                cleanContent = generateCodeHash(content);
+            } else {
+                // For JSON/YAML, just strip whitespace
+                cleanContent = content.replace(/\s+/g, '');
+            }
+
+            bigHash.update(`${relativePath}:${cleanContent}|`);
+        }
+
+        return bigHash.digest('hex');
+    } catch (e) {
+        console.warn(`[HashManager] ⚠️ Failed to generate infra hash: ${e.message}`);
+        return 'infra_error'; 
+    }
+}
+
+module.exports = { LEGACY_MAPPING, generateCodeHash, getInfrastructureHash };

package/package.json

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