aiden-shared-calculations-unified 1.0.71 → 1.0.72

package/calculations/behavioural/historical/dumb-cohort-flow.js

@@ -61,7 +61,7 @@ class DumbCohortFlow {
      * Statically declare dependencies.
      */
     static getDependencies() {
-        return ['user_profitability_tracker'];
+        return ['user_profitability_tracker']; 
     }
 
     _getPortfolioPositions(portfolio) {

package/calculations/insights/daily_ownership_per_sector.js

@@ -54,7 +54,7 @@ class DailyOwnershipPerSector {
         // 2. Get the insights document
         const insightsDoc = rootData.insights;
         if (!insightsDoc || !Array.isArray(insightsDoc.insights)) {
-            dependencies.logger.log('WARN', `[daily-ownership-per-sector] No 'insights' data found for ${dateStr}.`);
+            // dependencies.logger.log('WARN', `[daily-ownership-per-sector] No 'insights' data found for ${dateStr}.`); TODO : This is broken, returns log undefined 
             return {};
         }
 

package/calculations/meta/crowd_sharpe_ratio_proxy.js

@@ -6,14 +6,19 @@
  *
  * It uses the distribution of P&L from 'pnl_distribution_per_stock'
  * to calculate variance (risk).
+ *
+ * --- FIX: 2025-11-12 ---
+ * Refactored this file to be a "meta" calculation.
+ * 1. Removed constructor, getResult, reset, and the no-op 'process'.
+ * 2. Added the required `async process(dStr, deps, config, fetchedDeps)` method.
+ * 3. Moved all logic into `process`.
+ * 4. Updated logic to read from `fetchedDeps['pnl_distribution_per_stock']`.
+ * 5. Updated data access to read from the new `data.stats` object
+ * provided by the fixed dependency.
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class CrowdSharpeRatioProxy {
-    constructor() {
-        this.mappings = null;
-    }
-
     /**
      * Defines the output schema for this calculation.
      * @returns {object} JSON Schema object
@@ -54,25 +59,36 @@ class CrowdSharpeRatioProxy {
         ];
     }
 
-    process() {
-        // No-op
-    }
-
-    async getResult(fetchedDependencies) {
+    /**
+     * --- FIX: This is the new main execution method for meta-calcs ---
+     * It receives all dependencies from the orchestrator.
+     */
+    async process(dateStr, dependencies, config, fetchedDependencies) {
+        // --- FIX: Load dependency data from the argument ---
         const pnlDistData = fetchedDependencies['pnl_distribution_per_stock'];
         
         if (!pnlDistData) {
+            dependencies.logger.log('WARN', `[crowd_sharpe_ratio_proxy] Missing dependency 'pnl_distribution_per_stock' for ${dateStr}. Skipping.`);
             return {};
         }
         
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // --- FIX: Load mappings inside the process method ---
+        const mappings = await loadInstrumentMappings();
+        if (!mappings || !mappings.instrumentToTicker) {
+            dependencies.logger.log('ERROR', `[crowd_sharpe_ratio_proxy] Failed to load instrument mappings.`);
+            return {};
         }
 
         const result = {};
 
-        for (const [instrumentId, data] of Object.entries(pnlDistData)) {
-            const { sum, sumSq, count } = data;
+        for (const [ticker, data] of Object.entries(pnlDistData)) {
+            
+            // --- FIX: Read from the new 'stats' sub-object ---
+            if (!data.stats) {
+                continue; // Skip if data is malformed
+            }
+            
+            const { sum, sumSq, count } = data.stats;
             
             if (count < 2) {
                 continue; // Need at least 2 data points for variance
@@ -102,7 +118,8 @@ class CrowdSharpeRatioProxy {
             // Sharpe = Mean(Return) / StdDev(Return)
             const sharpeProxy = mean / stdDev;
             
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            // --- FIX: Data is already keyed by ticker, no mapping needed ---
+            // const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
 
             result[ticker] = {
                 sharpe_ratio_proxy: sharpeProxy,
@@ -115,10 +132,6 @@ class CrowdSharpeRatioProxy {
         
         return result;
     }
-
-    reset() {
-        this.mappings = null;
-    }
 }
 
 module.exports = CrowdSharpeRatioProxy;

package/calculations/meta/social-topic-driver-index.js

@@ -21,8 +21,10 @@ class SocialTopicDriverIndex {
             "properties": {
                 "topic": { "type": "string" },
                 "driver_score": { "type": "number" },
-                "correlation_flow_30d": { "type": "number" },
-                "correlation_price_30d": { "type": "number" }
+                // These fields are from an older version but kept for schema
+                // compatibility. They will be null in the corrected logic.
+                "correlation_flow_30d": { "type": ["number", "null"] },
+                "correlation_price_30d": { "type": ["number", "null"] }
             },
             "required": ["topic", "driver_score"]
         };
@@ -48,6 +50,7 @@ class SocialTopicDriverIndex {
 
     /**
      * Statically declare dependencies.
+     * (This was already correct)
      */
     static getDependencies() {
         return [
@@ -59,6 +62,13 @@ class SocialTopicDriverIndex {
         // No-op
     }
 
+    /**
+     * --- LOGIC FIXED ---
+     * This function is rewritten to correctly consume the output of
+     * 'social-topic-predictive-potential'. It aggregates the
+     * 'predictivePotential' score for each topic across *all* tickers
+     * to create a global driver score.
+     */
     getResult(fetchedDependencies) {
         const potentialData = fetchedDependencies['social-topic-predictive-potential'];
         
@@ -67,23 +77,60 @@ class SocialTopicDriverIndex {
             all_topics: []
         };
 
-        if (!potentialData) {
+        // The dependency returns a nested object. We need 'daily_topic_signals'.
+        const dailyTopicSignals = potentialData?.daily_topic_signals;
+
+        if (!dailyTopicSignals || Object.keys(dailyTopicSignals).length === 0) {
             return defaults;
         }
 
+        // Use a Map to aggregate scores for each topic
+        const topicAggregator = new Map();
+
+        // Iterate over each TICKER (e.g., 'AAPL', 'TSLA') in the signals
+        for (const tickerData of Object.values(dailyTopicSignals)) {
+            
+            // Combine bullish and bearish topics for that ticker
+            const allTickerTopics = [
+                ...(tickerData.topPredictiveBullishTopics || []),
+                ...(tickerData.topPredictiveBearishTopics || [])
+            ];
+
+            // Iterate over the topics *for that ticker*
+            for (const topicData of allTickerTopics) {
+                const topicName = topicData.topic;
+                
+                // Use the 'predictivePotential' score calculated by the dependency
+                const score = topicData.predictivePotential || 0;
+
+                if (!topicAggregator.has(topicName)) {
+                    topicAggregator.set(topicName, { totalScore: 0, count: 0 });
+                }
+                
+                const agg = topicAggregator.get(topicName);
+                agg.totalScore += score;
+                agg.count += 1;
+            }
+        }
+        
         const allTopics = [];
-        for (const [topic, data] of Object.entries(potentialData)) {
-            // Create a "Driver Score" - prioritize flow correlation
-            const score = (data.correlation_flow_30d * 0.7) + (data.correlation_price_30d * 0.3);
+        // Now, create the final ranked list
+        for (const [topic, data] of topicAggregator.entries()) {
+            if (data.count === 0) continue;
+            
+            // Calculate the average driver score across all tickers
+            const avgScore = data.totalScore / data.count;
             
             allTopics.push({
                 topic: topic,
-                driver_score: score,
-                correlation_flow_30d: data.correlation_flow_30d,
-                correlation_price_30d: data.correlation_price_30d
+                driver_score: avgScore,
+                // Set old/incompatible fields to null to match schema
+                correlation_flow_30d: null, 
+                correlation_price_30d: null 
             });
         }
         
+        // Sort by the new, correct driver_score
         allTopics.sort((a, b) => b.driver_score - a.driver_score);
 
         return {

package/calculations/meta/social-topic-predictive-potential.js

@@ -152,7 +152,8 @@ function _findPriceForward(instrumentId, dateStr, priceMap) {
 class SocialTopicPredictivePotentialIndex {
 
     static getDependencies() {
-        return ['social-topic-driver-index'];
+        // --- FIX 1: Changed from 'social-topic-driver-index' to break the cycle ---
+        return ['social-topic-sentiment-matrix'];
     }
 
     constructor() {
@@ -195,10 +196,13 @@ class SocialTopicPredictivePotentialIndex {
         // pLimit is not in calculationUtils by default, so we'll use our own
         // If it were, we'd use: this.pLimit = calculationUtils.pLimit(MAX_CONCURRENT_TRANSACTIONS);
         await this._loadDependencies(calculationUtils);
-        const todaySignals = fetchedDependencies['social-topic-driver-index'];
+        
+        // --- FIX 2: Read from the correct dependency ---
+        const todaySignals = fetchedDependencies['social-topic-sentiment-matrix'];
 
         if (!todaySignals || Object.keys(todaySignals).length === 0) {
-            logger.log('WARN', `[SocialTopicPredictive] Missing or empty dependency 'social-topic-driver-index' for ${dateStr}. Skipping.`);
+            // --- FIX 2.1: Updated log message ---
+            logger.log('WARN', `[SocialTopicPredictive] Missing or empty dependency 'social-topic-sentiment-matrix' for ${dateStr}. Skipping.`);
             return null;
         }
 
@@ -264,6 +268,8 @@ class SocialTopicPredictivePotentialIndex {
                 this._updateForwardReturns(state, instrumentId, dateStr, todayPrice, this.priceMap);
 
                 // --- 4c. Add New Signals (Factored Helper) ---
+                // We assume 'todaySignal' (from social-topic-sentiment-matrix)
+                // has an 'allDrivers' property.
                 this._addNewSignals(state, todaySignal.allDrivers || [], dateStr);
 
                 // --- 4d. Recalculate Correlations (Factored Helper) ---

package/calculations/pnl/pnl_distribution_per_stock.js

@@ -7,6 +7,13 @@
  * REFACTOR: This calculation now aggregates the distribution into
  * predefined buckets on the server-side, returning a chart-ready
  * histogram object instead of raw arrays.
+ *
+ * --- FIX: 2025-11-12 ---
+ * This calculation is a dependency for crowd_sharpe_ratio_proxy,
+ * which requires sum, sumSq, and count for variance calculations.
+ * This file has been updated to provide *both* the histogram
+ * and a 'stats' object containing these required values.
+ * ---------------------
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
@@ -31,28 +38,48 @@ class PnlDistributionPerStock {
     /**
      * Defines the output schema for this calculation.
      * REFACTOR: Schema now describes the server-calculated histogram.
-     * @returns {object} JSON Schema object
+     *
+     * --- FIX: 2025-11-12 ---
+     * Added 'stats' object to the schema to support downstream
+     * meta-calculations like crowd_sharpe_ratio_proxy.
      */
     static getSchema() {
         const bucketSchema = {
             "type": "object",
-            "description": "Histogram of P&L distribution for a single asset.",
+            "description": "Histogram and stats of P&L distribution for a single asset.",
             "properties": {
-                "loss_heavy": { "type": "number", "description": "Count of positions with > 50% loss" },
-                "loss_medium": { "type": "number", "description": "Count of positions with 25-50% loss" },
-                "loss_light": { "type": "number", "description": "Count of positions with 0-25% loss" },
-                "gain_light": { "type": "number", "description": "Count of positions with 0-25% gain" },
-                "gain_medium": { "type": "number", "description": "Count of positions with 25-50% gain" },
-                "gain_heavy": { "type": "number", "description": "Count of positions with 50-100% gain" },
-                "gain_extreme": { "type": "number", "description": "Count of positions with > 100% gain" },
-                "total_positions": { "type": "number", "description": "Total positions counted" }
+                "histogram": {
+                    "type": "object",
+                    "description": "Histogram of P&L distribution.",
+                    "properties": {
+                        "loss_heavy": { "type": "number", "description": "Count of positions with > 50% loss" },
+                        "loss_medium": { "type": "number", "description": "Count of positions with 25-50% loss" },
+                        "loss_light": { "type": "number", "description": "Count of positions with 0-25% loss" },
+                        "gain_light": { "type": "number", "description": "Count of positions with 0-25% gain" },
+                        "gain_medium": { "type": "number", "description": "Count of positions with 25-50% gain" },
+                        "gain_heavy": { "type": "number", "description": "Count of positions with 50-100% gain" },
+                        "gain_extreme": { "type": "number", "description": "Count of positions with > 100% gain" },
+                        "total_positions": { "type": "number", "description": "Total positions counted" }
+                    },
+                    "required": ["total_positions"]
+                },
+                "stats": {
+                    "type": "object",
+                    "description": "Raw statistics needed for variance/Sharpe calculations.",
+                    "properties": {
+                        "sum": { "type": "number", "description": "Sum of all P&L percentages" },
+                        "sumSq": { "type": "number", "description": "Sum of all squared P&L percentages" },
+                        "count": { "type": "number", "description": "Total count of positions" }
+                    },
+                    "required": ["sum", "sumSq", "count"]
+                }
             },
-            "required": ["total_positions"]
+            "required": ["histogram", "stats"]
         };
 
         return {
             "type": "object",
-            "description": "Calculates a histogram of P&L percentage distribution for all open positions, per asset.",
+            "description": "Calculates a histogram and raw stats of P&L percentage distribution for all open positions, per asset.",
             "patternProperties": {
                 "^.*$": bucketSchema // Ticker
             },
@@ -90,6 +117,9 @@ class PnlDistributionPerStock {
     /**
      * REFACTOR: This method now calculates the distribution on the server.
      * It transforms the raw P&L arrays into histogram bucket counts.
+     *
+     * --- FIX: 2025-11-12 ---
+     * Also calculates and returns sum, sumSq, and count.
      */
     async getResult() {
         if (!this.mappings) {
@@ -100,6 +130,11 @@ class PnlDistributionPerStock {
 
         for (const [instrumentId, pnlValues] of this.pnlMap.entries()) {
             const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            const count = pnlValues.length;
+
+            if (count === 0) {
+                continue;
+            }
 
             // 1. Initialize the histogram object for this ticker
             const histogram = {
@@ -110,11 +145,20 @@ class PnlDistributionPerStock {
                 gain_medium: 0,
                 gain_heavy: 0,
                 gain_extreme: 0,
-                total_positions: pnlValues.length
+                total_positions: count
             };
 
-            // 2. Process all P&L values into the buckets
+            // --- FIX: Initialize stats ---
+            let sum = 0;
+            let sumSq = 0;
+
+            // 2. Process all P&L values into buckets and calculate stats
             for (const pnl of pnlValues) {
+                // --- FIX: Add to stats ---
+                sum += pnl;
+                sumSq += (pnl * pnl);
+
+                // Add to histogram
                 for (const bucket of BUCKETS) {
                     if (pnl >= bucket.min && pnl < bucket.max) {
                         histogram[bucket.label]++;
@@ -122,9 +166,19 @@ class PnlDistributionPerStock {
                     }
                 }
             }
+            
+            // --- FIX: Create stats object ---
+            const stats = {
+                sum: sum,
+                sumSq: sumSq,
+                count: count
+            };
 
-            // 3. Add the aggregated histogram to the final result
-            result[ticker] = histogram;
+            // 3. Add the aggregated histogram and stats to the final result
+            result[ticker] = {
+                histogram: histogram,
+                stats: stats
+            };
         }
         return result;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.71",
+  "version": "1.0.72",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [
@@ -24,7 +24,8 @@
     "@google-cloud/firestore": "^7.11.3",
     "sharedsetup": "latest",
     "require-all": "^3.0.0",
-    "dotenv": "latest"
+    "dotenv": "latest",
+    "viz.js": "^2.1.2"
   },
   "devDependencies": {
     "bulltracker-deployer": "file:../bulltracker-deployer"