bulltrackers-module 1.0.237 → 1.0.238

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,7 +1,6 @@
 /**
  * @fileoverview Main Orchestrator. Coordinates the topological execution.
- * UPDATED: Detects Category changes to trigger migration/cleanup.
- * FIX: Decouples migration detection from hash verification to handle simultaneous code & category changes.
+ * UPDATED: Exports analyzeDateExecution for Build Reporting tools.
  */
 const { normalizeName }                                    = require('./utils/utils');
 const { checkRootDataAvailability }                        = require('./data/AvailabilityChecker');
@@ -124,7 +123,6 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
             report.runnable.push(calc);
         } else if (storedHash !== currentHash) {
             // Hash Mismatch (Code Changed).
-            // Pass migration info here too, in case category ALSO changed.
             report.reRuns.push({ 
                 name: cName, 
                 oldHash: storedHash, 
@@ -268,4 +266,4 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     return { date: dateStr, updates: dateUpdates };
 }
 
-module.exports = { runDateComputation, groupByPass };
+module.exports = { runDateComputation, groupByPass, analyzeDateExecution };

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

@@ -0,0 +1,161 @@
+/**
+ * @fileoverview Build Reporter & Auto-Runner.
+ * Generates a "Pre-Flight" report of what the computation system WILL do.
+ * Simulates execution logic (Hash Mismatches) assuming perfect data availability.
+ */
+
+const { analyzeDateExecution } = require('../WorkflowOrchestrator');
+const { fetchComputationStatus } = require('../persistence/StatusRepository');
+const { normalizeName, getExpectedDateStrings } = require('../utils/utils');
+const { FieldValue } = require('@google-cloud/firestore');
+
+// Attempt to load package.json to get version. Path depends on where this is invoked.
+let packageVersion = '1.0.237';
+
+
+/**
+ * AUTO-RUN ENTRY POINT
+ * Checks if a report for the current version exists. If not, runs it.
+ * Designed to be called "Fire-and-Forget" at system init.
+ */
+async function ensureBuildReport(config, dependencies, manifest) {
+    const { db, logger } = dependencies;
+    const buildId = `v${packageVersion}`; 
+    const reportRef = db.collection('computation_build_records').doc(buildId);
+
+    try {
+        const doc = await reportRef.get();
+        if (doc.exists) {
+            logger.log('INFO', `[BuildReporter] ✅ Pre-flight check for ${buildId} already exists. Skipping.`);
+            return;
+        }
+        
+        logger.log('INFO', `[BuildReporter] 🚀 New Version Detected (${buildId}). Auto-running Pre-flight Report...`);
+        // We do NOT await this in the main thread if called during init, 
+        // but here we are in an async function so we proceed.
+        await generateBuildReport(config, dependencies, manifest, 7, buildId);
+        
+    } catch (e) {
+        logger.log('ERROR', `[BuildReporter] Auto-run check failed: ${e.message}`);
+    }
+}
+
+/**
+ * Generates the report and saves to Firestore.
+ * @param {object} config 
+ * @param {object} dependencies 
+ * @param {Array} manifest 
+ * @param {number} daysBack - Days to simulate (default 7)
+ * @param {string} customBuildId - Optional ID override
+ */
+async function generateBuildReport(config, dependencies, manifest, daysBack = 7, customBuildId = null) {
+    const { db, logger } = dependencies;
+    const buildId = customBuildId || `manual_${Date.now()}`;
+    
+    logger.log('INFO', `[BuildReporter] Generating Build Report: ${buildId} (Scope: ${daysBack} days)...`);
+
+    // 1. Determine Date Range
+    const today = new Date();
+    const startDate = new Date();
+    startDate.setDate(today.getDate() - daysBack);
+    
+    // We check UP TO yesterday usually, as today might be partial. 
+    // But let's check today too to see immediate effects.
+    const datesToCheck = getExpectedDateStrings(startDate, today);
+    const manifestMap = new Map(manifest.map(c => [normalizeName(c.name), c]));
+    
+    const reportData = {
+        buildId,
+        version: packageVersion,
+        generatedAt: new Date().toISOString(),
+        summary: {},
+        dates: {}
+    };
+
+    let totalReRuns = 0;
+    let totalNew = 0;
+
+    // 2. Iterate Dates & Simulate
+    for (const dateStr of datesToCheck) {
+        // A. Fetch REAL status from DB (What ran previously?)
+        const dailyStatus = await fetchComputationStatus(dateStr, config, dependencies);
+
+        // B. MOCK Root Data Availability
+        // We force this to TRUE to prove logic changes.
+        // We want to know: "IF data exists, would this run?"
+        const mockRootDataStatus = {
+            hasPortfolio: true,
+            hasInsights: true,
+            hasSocial: true,
+            hasHistory: true,
+            hasPrices: true
+        };
+
+        // C. Run Logic Analysis
+        // Pass ENTIRE manifest to see global state
+        const analysis = analyzeDateExecution(dateStr, manifest, mockRootDataStatus, dailyStatus, manifestMap);
+
+        // D. Format Findings
+        const dateSummary = {
+            willRun: [],
+            willReRun: [],
+            blocked: []
+            // We omit 'skipped' to save space unless explicitly IMPOSSIBLE
+        };
+
+        // -- Runnable (New) --
+        analysis.runnable.forEach(item => {
+            dateSummary.willRun.push({ name: item.name, reason: "New / No Previous Record" });
+        });
+
+        // -- Re-Runs (Hash Mismatch / Migration) --
+        analysis.reRuns.forEach(item => {
+            let reason = "Hash Mismatch";
+            let details = `Old: ${item.oldHash?.substring(0,6)}... New: ${item.newHash?.substring(0,6)}...`;
+            
+            if (item.previousCategory) {
+                reason = "Migration";
+                details = `Moving ${item.previousCategory} -> ${item.newCategory}`;
+            }
+
+            dateSummary.willReRun.push({ name: item.name, reason, details });
+        });
+
+        // -- Blocked / Impossible --
+        analysis.impossible.forEach(item => {
+             dateSummary.blocked.push({ name: item.name, reason: item.reason }); // e.g. "Permanently Impossible"
+        });
+        analysis.failedDependency.forEach(item => {
+             dateSummary.blocked.push({ name: item.name, reason: `Dependency Missing: ${item.missing.join(', ')}` });
+        });
+
+        // Only add date to report if something interesting is happening
+        if (dateSummary.willRun.length || dateSummary.willReRun.length || dateSummary.blocked.length) {
+            reportData.dates[dateStr] = dateSummary;
+            totalNew += dateSummary.willRun.length;
+            totalReRuns += dateSummary.willReRun.length;
+        }
+    }
+
+    reportData.summary = { totalReRuns, totalNew, scanRange: `${datesToCheck[0]} to ${datesToCheck[datesToCheck.length-1]}` };
+
+    // 3. Store Report
+    const reportRef = db.collection('computation_build_records').doc(buildId);
+    await reportRef.set(reportData);
+
+    // 4. Update 'latest' pointer
+    await db.collection('computation_build_records').doc('latest').set({
+        ...reportData,
+        note: "Latest build report pointer."
+    });
+
+    logger.log('SUCCESS', `[BuildReporter] Report ${buildId} saved. Re-runs: ${totalReRuns}, New: ${totalNew}.`);
+    
+    return {
+        success: true,
+        reportId: buildId,
+        summary: reportData.summary
+    };
+}
+
+module.exports = { ensureBuildReport, generateBuildReport };

package/index.js

@@ -30,6 +30,9 @@ const { build: buildManifest }                            = require('./functions
 const { runDateComputation: runComputationPass }          = require('./functions/computation-system/WorkflowOrchestrator');
 const { dispatchComputationPass }                         = require('./functions/computation-system/helpers/computation_dispatcher');
 const { handleComputationTask }                           = require('./functions/computation-system/helpers/computation_worker');
+// [NEW] Import Report Tools
+const { ensureBuildReport, generateBuildReport }          = require('./functions/computation-system/tools/BuildReporter');
+
 const dataLoader                                          = require('./functions/computation-system/utils/data_loader');
 const computationUtils                                    = require('./functions/computation-system/utils/utils');
 
@@ -87,6 +90,9 @@ const computationSystem = {
   dataLoader,
   computationUtils,
   buildManifest,
+  // [NEW] Export Tools
+  ensureBuildReport,
+  generateBuildReport,
 };
 
 const api = {

package/package.json

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