aiden-shared-calculations-unified 1.0.80 → 1.0.82

package/calculations/core/asset-pnl-status.js

@@ -7,68 +7,46 @@
  * This provides a crowd-wide P&L status for each instrument.
  *
  * --- FIX ---
- * This version is modified to only store user *IDs* in the arrays,
- * not the full user P&L objects, to prevent exceeding the
- * 1 MiB Firestore document size limit.
+ * This version is modified to *only* store counts. The
+ * `users_in_profit` and `users_in_loss` arrays are removed
+ * to prevent exceeding the 1 MiB Firestore document size limit.
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class AssetPnlStatus {
     constructor() {
-        // We will store { [instrumentId]: { in_profit: Map(), in_loss: Map() } }
-        // The maps will store <userId, pnl> but only the keys (userIds) will be saved.
+        // We will store { [instrumentId]: { in_profit_count: 0, in_loss_count: 0 } }
+        // We no longer store the user maps, just the counts.
         this.assets = new Map();
         this.mappings = null;
+        this.seenUsers = new Map(); // Map<instrumentId, Set<userId>>
     }
 
     /**
      * Defines the output schema for this calculation.
      * --- MODIFIED ---
-     * The `users_in_profit` and `users_in_loss` schemas are changed
-     * from `items: userSchema` to `items: { "type": "string" }`.
+     * Removed the `users_in_profit` and `users_in_loss` arrays.
      * @returns {object} JSON Schema object
      */
     static getSchema() {
-        /*
-        // The userSchema is no longer needed in the output
-        const userSchema = {
-            "type": "object",
-            "properties": {
-                "userId": { "type": "string" },
-                "pnl": { "type": "number" }
-            },
-            "required": ["userId", "pnl"]
-        };
-        */
-
         const tickerSchema = {
             "type": "object",
             "description": "P&L status for a specific asset.",
             "properties": {
                 "in_profit_count": {
                     "type": "number",
-                    "description": "Count of users currently in profit on this asset."
+                    "description": "Count of unique users currently in profit on this asset."
                 },
                 "in_loss_count": {
                     "type": "number",
-                    "description": "Count of users currently in loss on this asset."
+                    "description": "Count of unique users currently in loss on this asset."
                 },
                 "profit_ratio": {
                     "type": "number",
                     "description": "Percentage of users in profit (In Profit / Total)."
-                },
-                "users_in_profit": {
-                    "type": "array",
-                    "description": "List of user IDs in profit.",
-                    "items": { "type": "string" } // <-- MODIFIED
-                },
-                "users_in_loss": {
-                    "type": "array",
-                    "description": "List of user IDs in loss.",
-                    "items": { "type": "string" } // <-- MODIFIED
                 }
             },
-            "required": ["in_profit_count", "in_loss_count", "profit_ratio", "users_in_profit", "users_in_loss"]
+            "required": ["in_profit_count", "in_loss_count", "profit_ratio"]
         };
 
         return {
@@ -104,8 +82,8 @@ class AssetPnlStatus {
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
             this.assets.set(instrumentId, {
-                in_profit: new Map(), // Map<userId, pnl>
-                in_loss: new Map()   // Map<userId, pnl>
+                in_profit: new Set(),
+                in_loss: new Set()
             });
         }
     }
@@ -124,18 +102,20 @@ class AssetPnlStatus {
             const asset = this.assets.get(instrumentId);
             const pnl = pos.NetProfit || 0;
 
+            // Only count one user once per asset
             if (pnl > 0) {
-                asset.in_profit.set(userId, pnl);
+                asset.in_profit.add(userId);
+                asset.in_loss.delete(userId); // Ensure user isn't in both
             } else if (pnl < 0) {
-                asset.in_loss.set(userId, pnl);
+                asset.in_loss.add(userId);
+                asset.in_profit.delete(userId); // Ensure user isn't in both
             }
         }
     }
 
     /**
      * --- MODIFIED ---
-     * This now saves an array of strings (user IDs) instead of
-     * an array of {userId, pnl} objects to save space.
+     * This now saves only counts.
      */
     async getResult() {
         if (!this.mappings) {
@@ -154,10 +134,8 @@ class AssetPnlStatus {
                 result[ticker] = {
                     in_profit_count: profitCount,
                     in_loss_count: lossCount,
-                    profit_ratio: (profitCount / total) * 100,
-                    // Convert Maps to arrays of *keys* (user IDs)
-                    users_in_profit: Array.from(data.in_profit.keys()), // <-- MODIFIED
-                    users_in_loss: Array.from(data.in_loss.keys())   // <-- MODIFIED
+                    profit_ratio: (profitCount / total) * 100
+                    // Removed the user arrays
                 };
             }
         }
@@ -167,6 +145,7 @@ class AssetPnlStatus {
     reset() {
         this.assets.clear();
         this.mappings = null;
+        this.seenUsers.clear();
     }
 }
 

package/calculations/core/price-metrics.js

@@ -0,0 +1,372 @@
+/**
+ * @fileoverview Calculation (Pass 1 - Meta) for historical price metrics.
+ *
+ * This metric answers: "What is the Volatility, Sharpe Ratio, and Max Drawdown
+ * for all instruments over 7, 30, 90, and 365-day periods?"
+ *
+ * It also aggregates these metrics as an average for each sector.
+ */
+
+const RANGES = [7, 30, 90, 365];
+const TRADING_DAYS_PER_YEAR = 252;
+const MAX_LOOKBACK_DAYS = 5; // For finding a non-holiday/weekend price
+
+class CorePriceMetrics {
+
+    // #region --- Static Metadata & Schema ---
+
+    /**
+     * Statically defines all metadata for the manifest builder.
+     */
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: [], // Relies on price data, not root data
+            isHistorical: true, // Needs up to 365d of price history
+            userType: 'n/a',
+            category: 'core_metrics' // Fits with other price/metric calcs
+        };
+    }
+
+    /**
+     * This is a Pass 1 calculation and has no dependencies on other calculations.
+     */
+    static getDependencies() {
+        return [];
+    }
+
+    /**
+     * Defines the output schema for this calculation.
+     */
+    static getSchema() {
+        // This is the sub-schema for a single instrument's metrics
+        const instrumentMetricsSchema = {
+            "type": "object",
+            "properties": {
+                "stdev_7d": { "type": ["number", "null"], "description": "7-day standard deviation of daily returns" },
+                "volatility_annualized_7d": { "type": ["number", "null"], "description": "7-day annualized volatility" },
+                "sharpe_ratio_7d": { "type": ["number", "null"], "description": "7-day annualized Sharpe ratio (rf=0)" },
+                "max_drawdown_7d": { "type": ["number", "null"], "description": "7-day max peak-to-trough drawdown" },
+
+                "stdev_30d": { "type": ["number", "null"], "description": "30-day standard deviation of daily returns" },
+                "volatility_annualized_30d": { "type": ["number", "null"], "description": "30-day annualized volatility" },
+                "sharpe_ratio_30d": { "type": ["number", "null"], "description": "30-day annualized Sharpe ratio (rf=0)" },
+                "max_drawdown_30d": { "type": ["number", "null"], "description": "30-day max peak-to-trough drawdown" },
+
+                "stdev_90d": { "type": ["number", "null"], "description": "90-day standard deviation of daily returns" },
+                "volatility_annualized_90d": { "type": ["number", "null"], "description": "90-day annualized volatility" },
+                "sharpe_ratio_90d": { "type": ["number", "null"], "description": "90-day annualized Sharpe ratio (rf=0)" },
+                "max_drawdown_90d": { "type": ["number", "null"], "description": "90-day max peak-to-trough drawdown" },
+
+                "stdev_365d": { "type": ["number", "null"], "description": "365-day standard deviation of daily returns" },
+                "volatility_annualized_365d": { "type": ["number", "null"], "description": "365-day annualized volatility" },
+                "sharpe_ratio_365d": { "type": ["number", "null"], "description": "365-day annualized Sharpe ratio (rf=0)" },
+                "max_drawdown_365d": { "type": ["number", "null"], "description": "365-day max peak-to-trough drawdown" }
+            },
+            "additionalProperties": false
+        };
+
+        // This is the sub-schema for a single sector's *averages*
+        const sectorMetricsSchema = {
+            "type": "object",
+            "properties": {
+                "average_stdev_7d": { "type": ["number", "null"], "description": "Average 7-day standard deviation for the sector" },
+                "average_volatility_annualized_7d": { "type": ["number", "null"], "description": "Average 7-day annualized volatility for the sector" },
+                "average_sharpe_ratio_7d": { "type": ["number", "null"], "description": "Average 7-day annualized Sharpe ratio for the sector" },
+                "average_max_drawdown_7d": { "type": ["number", "null"], "description": "Average 7-day max drawdown for the sector" },
+
+                "average_stdev_30d": { "type": ["number", "null"], "description": "Average 30-day standard deviation for the sector" },
+                "average_volatility_annualized_30d": { "type": ["number", "null"], "description": "Average 30-day annualized volatility for the sector" },
+                "average_sharpe_ratio_30d": { "type": ["number", "null"], "description": "Average 30-day annualized Sharpe ratio for the sector" },
+                "average_max_drawdown_30d": { "type": ["number", "null"], "description": "Average 30-day max drawdown for the sector" },
+
+                "average_stdev_90d": { "type": ["number", "null"], "description": "Average 90-day standard deviation for the sector" },
+                "average_volatility_annualized_90d": { "type": ["number", "null"], "description": "Average 90-day annualized volatility for the sector" },
+                "average_sharpe_ratio_90d": { "type": ["number", "null"], "description": "Average 90-day annualized Sharpe ratio for the sector" },
+                "average_max_drawdown_90d": { "type": ["number", "null"], "description": "Average 90-day max drawdown for the sector" },
+
+                "average_stdev_365d": { "type": ["number", "null"], "description": "Average 365-day standard deviation for the sector" },
+                "average_volatility_annualized_365d": { "type": ["number", "null"], "description": "Average 365-day annualized volatility for the sector" },
+                "average_sharpe_ratio_365d": { "type": ["number", "null"], "description": "Average 365-day annualized Sharpe ratio for the sector" },
+                "average_max_drawdown_365d": { "type": ["number", "null"], "description": "Average 365-day max drawdown for the sector" }
+            },
+            "additionalProperties": false
+        };
+
+        // This is the final, top-level schema
+        return {
+            "type": "object",
+            "description": "Calculates risk/return metrics (StdDev, Sharpe, Vol, Drawdown) for instruments and sectors.",
+            "properties": {
+                "by_instrument": {
+                    "type": "object",
+                    "description": "Metrics per instrument, keyed by Ticker.",
+                    "patternProperties": { "^[A-Z\\.]+$": instrumentMetricsSchema }, // Match tickers like 'NVDA' or 'BRK.B'
+                    "additionalProperties": instrumentMetricsSchema
+                },
+                "by_sector": {
+                    "type": "object",
+                    "description": "Average metrics per sector, keyed by Sector Name.",
+                    "patternProperties": { "^[a-zA-Z0-9_ ]+$": sectorMetricsSchema }, // Match sector names
+                    "additionalProperties": sectorMetricsSchema
+                }
+            },
+            "required": ["by_instrument", "by_sector"]
+        };
+    }
+
+    // #endregion --- Static Metadata & Schema ---
+
+
+    // #region --- Main Process ---
+
+    /**
+     * This is a 'meta' calculation. It runs once.
+     * @param {string} dateStr - The date string 'YYYY-MM-DD'.
+     * @param {object} dependencies - The shared dependencies (e.g., logger, calculationUtils).
+     * @param {object} config - The computation system configuration.
+     * @returns {Promise<object>} The calculation result.
+     */
+    async process(dateStr, dependencies, config) {
+        const { logger, calculationUtils } = dependencies;
+        
+        const priceMap = await calculationUtils.loadAllPriceData();
+        const mappings = await calculationUtils.loadInstrumentMappings();
+        
+        if (!priceMap || !mappings || !mappings.instrumentToTicker || !mappings.instrumentToSector) {
+            logger.log('ERROR', '[core-price-metrics] Failed to load priceMap or mappings.');
+            return { by_instrument: {}, by_sector: {} };
+        }
+
+        const { instrumentToTicker, instrumentToSector } = mappings;
+        const by_instrument = {};
+
+        // 1. Calculate Per-Instrument Metrics
+        for (const instrumentId in priceMap) {
+            const ticker = instrumentToTicker[instrumentId];
+            if (!ticker) continue; 
+
+            const priceHistoryObj = priceMap[instrumentId];
+            const instrumentMetrics = {};
+            
+            // Null-out all metrics by default to ensure consistent schema
+            for (const range of RANGES) {
+                instrumentMetrics[`stdev_${range}d`] = null;
+                instrumentMetrics[`volatility_annualized_${range}d`] = null;
+                instrumentMetrics[`sharpe_ratio_${range}d`] = null;
+                instrumentMetrics[`max_drawdown_${range}d`] = null;
+            }
+
+            for (const range of RANGES) {
+                // Get the price slice for the range (e.g., last 30 days)
+                // We need range + 1 prices to calculate `range` number of returns
+                const priceArray = this._getHistoricalPriceArray(priceHistoryObj, dateStr, range + 1);
+
+                if (priceArray.length < 2) {
+                    continue; // Not enough data for this range
+                }
+
+                // Calculate drawdown on prices
+                instrumentMetrics[`max_drawdown_${range}d`] = this._calculateMaxDrawdown(priceArray);
+
+                // Calculate returns and return-based metrics
+                const dailyReturns = this._calculateDailyReturns(priceArray);
+                if (dailyReturns.length < 2) {
+                    continue; // Not enough returns to calculate stddev
+                }
+
+                const meanReturn = this._calculateMean(dailyReturns);
+                const stdDev = this._calculateStdDev(dailyReturns, meanReturn);
+                
+                instrumentMetrics[`stdev_${range}d`] = stdDev;
+
+                if (stdDev > 0) {
+                    instrumentMetrics[`sharpe_ratio_${range}d`] = (meanReturn / stdDev) * Math.sqrt(TRADING_DAYS_PER_YEAR);
+                    instrumentMetrics[`volatility_annualized_${range}d`] = stdDev * Math.sqrt(TRADING_DAYS_PER_YEAR);
+                } else {
+                    instrumentMetrics[`sharpe_ratio_${range}d`] = 0;
+                    instrumentMetrics[`volatility_annualized_${range}d`] = 0;
+                }
+            }
+            
+            by_instrument[ticker] = instrumentMetrics;
+        }
+
+        // 2. Calculate Sector Aggregates
+        const by_sector = this._aggregateMetricsBySector(by_instrument, instrumentToTicker, instrumentToSector);
+
+        return {
+            by_instrument,
+            by_sector,
+        };
+    }
+
+    // #endregion --- Main Process ---
+
+
+    // #region --- Aggregation Helpers ---
+
+    _aggregateMetricsBySector(by_instrument, instrumentToTicker, instrumentToSector) {
+        const sectorAggregates = {}; // { [sector]: { metrics: { [metricName]: sum }, counts: { [metricName]: count } } }
+        const tickerToInstrument = Object.fromEntries(Object.entries(instrumentToTicker).map(([id, ticker]) => [ticker, id]));
+
+        for (const ticker in by_instrument) {
+            const instrumentId = tickerToInstrument[ticker];
+            const sector = instrumentToSector[instrumentId] || "Unknown";
+            const metrics = by_instrument[ticker];
+
+            if (!sectorAggregates[sector]) {
+                sectorAggregates[sector] = { metrics: {}, counts: {} };
+            }
+
+            for (const metricName in metrics) {
+                const value = metrics[metricName];
+                // Check for valid, non-null, finite numbers
+                if (value !== null && typeof value === 'number' && isFinite(value)) {
+                    if (!sectorAggregates[sector].metrics[metricName]) {
+                        sectorAggregates[sector].metrics[metricName] = 0;
+                        sectorAggregates[sector].counts[metricName] = 0;
+                    }
+                    sectorAggregates[sector].metrics[metricName] += value;
+                    sectorAggregates[sector].counts[metricName]++;
+                }
+            }
+        }
+
+        // Finalize averages
+        const by_sector = {};
+        for (const sector in sectorAggregates) {
+            by_sector[sector] = {};
+            const agg = sectorAggregates[sector];
+            
+            // Get all unique metric names from this sector's aggregation
+            const allMetricNames = Object.keys(agg.metrics);
+
+            for (const metricName of allMetricNames) {
+                const count = agg.counts[metricName];
+                if (count > 0) {
+                    by_sector[sector][`average_${metricName}`] = agg.metrics[metricName] / count;
+                } else {
+                    by_sector[sector][`average_${metricName}`] = null; // Ensure null if no valid data
+                }
+            }
+        }
+        return by_sector;
+    }
+
+    // #endregion --- Aggregation Helpers ---
+
+
+    // #region --- Math & Price Helpers ---
+
+    /**
+     * Re-implementation of the logic from price_data_provider.js's private helper.
+     * Finds the most recent available price on or before a given date.
+     */
+    _findPriceOnOrBefore(priceHistory, dateStr) {
+        if (!priceHistory) return null;
+
+        let checkDate = new Date(dateStr + 'T00:00:00Z');
+        
+        for (let i = 0; i < MAX_LOOKBACK_DAYS; i++) {
+            const checkDateStr = checkDate.toISOString().slice(0, 10);
+            const price = priceHistory[checkDateStr];
+            
+            if (price !== undefined && price !== null && price > 0) {
+                return price; // Found it
+            }
+            // If not found, look back one more day
+            checkDate.setUTCDate(checkDate.getUTCDate() - 1);
+        }
+        return null;
+    }
+
+    /**
+* Gets a gap-filled array of prices for a historical range.
+* @param {object} priceHistoryObj - The map of { "YYYY-MM-DD": price }
+* @param {string} endDateStr - The end date of the period (e.g., today).
+* @param {number} numDays - The number of calendar days to fetch prices for.
+* @returns {number[]} A sorted array of prices, oldest to newest.
+*/
+    _getHistoricalPriceArray(priceHistoryObj, endDateStr, numDays) {
+        const prices = [];
+        let currentDate = new Date(endDateStr + 'T00:00:00Z');
+        let lastPrice = null;
+
+        for (let i = 0; i < numDays; i++) {
+            const targetDateStr = currentDate.toISOString().slice(0, 10);
+            let price = this._findPriceOnOrBefore(priceHistoryObj, targetDateStr);
+            
+            // If price is null (e.g., new instrument), try to use the last known price
+            if (price === null) {
+                price = lastPrice; 
+            } else {
+                lastPrice = price; // Update last known price
+            }
+
+            if (price !== null) {
+                prices.push(price);
+            }
+            
+            // Go back one calendar day for the next data point
+            currentDate.setUTCDate(currentDate.getUTCDate() - 1);
+        }
+        
+        // We built the array from newest to oldest, so reverse it.
+        // And filter out any initial nulls if lastPrice was null at the start
+        return prices.reverse().filter(p => p !== null);
+    }
+
+
+    _calculateMean(arr) {
+        if (!arr || arr.length === 0) return 0;
+        const sum = arr.reduce((acc, val) => acc + val, 0);
+        return sum / arr.length;
+    }
+
+    _calculateStdDev(arr, mean) {
+        if (!arr || arr.length < 2) return 0;
+        const avg = mean === undefined ? this._calculateMean(arr) : mean;
+        // Use N-1 for sample standard deviation
+        const variance = arr.reduce((acc, val) => acc + (val - avg) ** 2, 0) / (arr.length - 1);
+        return Math.sqrt(variance);
+    }
+
+    _calculateDailyReturns(prices) {
+        const returns = [];
+        for (let i = 1; i < prices.length; i++) {
+            const prevPrice = prices[i - 1];
+            const currPrice = prices[i];
+            if (prevPrice !== 0 && prevPrice !== null && currPrice !== null) {
+                returns.push((currPrice - prevPrice) / prevPrice);
+            } else {
+                returns.push(0);
+            }
+        }
+        return returns;
+    }
+
+    _calculateMaxDrawdown(prices) {
+        if (!prices || prices.length < 2) return 0;
+        let maxDrawdown = 0;
+        let peak = -Infinity;
+
+        for (const price of prices) {
+            if (price > peak) {
+                peak = price;
+            }
+            if (peak > 0) { // Only calculate drawdown if peak is positive
+                const drawdown = (price - peak) / peak;
+                if (drawdown < maxDrawdown) {
+                    maxDrawdown = drawdown;
+                }
+            }
+        }
+        // Ensure result is a finite number, default to 0
+        return isFinite(maxDrawdown) ? maxDrawdown : 0;
+    }
+
+    // #endregion --- Math & Price Helpers ---
+}
+
+module.exports = CorePriceMetrics;

package/calculations/core/social-sentiment-aggregation.js

@@ -4,6 +4,10 @@
  * This metric answers: "What is the aggregated social media
  * sentiment (bullish, bearish, neutral) globally and
  * for each ticker?"
+ *
+ * --- MODIFIED ---
+ * Changed `process` method to read from `dependencies.rootData.todaySocialPostInsights`
+ * instead of a non-existent `calculationUtils.loadSocialData`.
  */
 class SocialSentimentAggregation {
     constructor() {
@@ -90,19 +94,21 @@ class SocialSentimentAggregation {
 
     /**
      * @param {string} dateStr - Today's date.
-     * @param {object} dependencies - db, logger.
+     * @param {object} dependencies - db, logger, calculationUtils, AND rootData.
      * @param {object} config - Computation config.
      * @param {object} fetchedDependencies - (UNUSED) In-memory results.
      */
     async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { calculationUtils } = dependencies;
-        // This helper should exist on calculationUtils, loaded by the runner
-        const todaySocialPosts = await calculationUtils.loadSocialData(dateStr); 
+        // --- MODIFIED ---
+        // 'meta' calcs get rootData injected into the dependencies object.
+        const todaySocialPosts = dependencies.rootData?.todaySocialPostInsights || {}; 
+        // --- END MODIFIED ---
 
-        for (const post of todaySocialPosts) {
+        for (const post of Object.values(todaySocialPosts)) {
             // This logic assumes 'sentiment' is a simple string,
             // not the object from gemini. This is correct for this calc.
-            const sentiment = post.sentiment || 'neutral'; // 'bullish', 'bearish', 'neutral'
+            // --- MODIFIED: Read from structured sentiment object ---
+            const sentiment = post.sentiment?.overallSentiment?.toLowerCase() || 'neutral';
             
             // 1. Aggregate global sentiment
             if (sentiment === 'bullish') {