aiden-shared-calculations-unified 1.0.82 → 1.0.84

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

@@ -1,152 +1,170 @@
 /**
- * @fileoverview Calculation (Pass 1) for asset P&L status.
+ * @fileoverview Core Metric (Pass 2)
  *
- * This metric answers: "For each asset, how many users in our
- * sample are in profit versus in loss?"
+ * This 'standard' calculation streams all user portfolios
+ * and, for each asset, buckets users into "Winner" (in-profit)
+ * and "Loser" (in-loss) cohorts.
  *
- * This provides a crowd-wide P&L status for each instrument.
- *
- * --- FIX ---
- * 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.
+ * It is a dependency for calculations that need to know
+ * the full list of users in each cohort (e.g., 'helix-contrarian-signal')
+ * but is too large to be a dependency for 'winner-loser-flow'.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 class AssetPnlStatus {
     constructor() {
-        // 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>>
+        // { [ticker]: { winners: [uid1, uid2], losers: [uid1] } }
+        this.tickerBuckets = new Map();
+        // { [sector]: { winners: [uid1, uid2], losers: [uid1] } }
+        this.sectorBuckets = new Map();
+        
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
+        this.sectorMap = null;
+        
+    }
+
+    /** Statically defines metadata */
+    static getMetadata() {
+        return {
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
+            isHistorical: false, // Reads today's portfolio
+            userType: 'all',
+            category: 'core'
+        };
+    }
+
+    /** Statically declare dependencies */
+    static getDependencies() {
+        return []; // This is a Pass 2 calculation
     }
 
     /**
      * Defines the output schema for this calculation.
-     * --- MODIFIED ---
-     * Removed the `users_in_profit` and `users_in_loss` arrays.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
-        const tickerSchema = {
+        const cohortSchema = {
             "type": "object",
-            "description": "P&L status for a specific asset.",
             "properties": {
-                "in_profit_count": {
-                    "type": "number",
-                    "description": "Count of unique users currently in profit on this asset."
+                "winners": {
+                    "type": "array",
+                    "items": { "type": "string" },
+                    "description": "List of User IDs in the 'Winner' (in-profit) cohort."
                 },
-                "in_loss_count": {
-                    "type": "number",
-                    "description": "Count of unique users currently in loss on this asset."
-                },
-                "profit_ratio": {
-                    "type": "number",
-                    "description": "Percentage of users in profit (In Profit / Total)."
+                "losers": {
+                    "type": "array",
+                    "items": { "type": "string" },
+                    "description": "List of User IDs in the 'Loser' (in-loss) cohort."
                 }
             },
-            "required": ["in_profit_count", "in_loss_count", "profit_ratio"]
+            "required": ["winners", "losers"]
         };
-
+        
         return {
             "type": "object",
-            "description": "Tracks the number of users in profit vs. in loss for each asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
+            "description": "Buckets all users into 'Winner' or 'Loser' cohorts per asset and sector.",
+            "properties": {
+                "by_ticker": {
+                    "type": "object",
+                    "patternProperties": { "^.*$": cohortSchema },
+                    "additionalProperties": cohortSchema
+                },
+                "by_sector": {
+                    "type": "object",
+                    "patternProperties": { "^.*$": cohortSchema },
+                    "additionalProperties": cohortSchema
+                }
             },
-            "additionalProperties": tickerSchema
-        };
-    }
-
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: false,
-            userType: 'all',
-            category: 'core_pnl'
+            "required": ["by_ticker", "by_sector"]
         };
     }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
-
-    _initAsset(instrumentId) {
-        if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                in_profit: new Set(),
-                in_loss: new Set()
-            });
+    
+    _init(map, key) {
+        if (!map.has(key)) {
+            map.set(key, { winners: new Set(), losers: new Set() });
         }
     }
 
-    process(portfolioData, yesterdayPortfolio, userId) {
-        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: FIXED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
+             this.sectorMap = context.sectorMapping;
+        }
+        
+        if (!this.tickerMap || !this.sectorMap) {
+            return; // Failsafe if context is missing maps
+        }
+        
+        const positions = todayPortfolio?.AggregatedPositions || todayPortfolio?.PublicPositions;
+        if (!positions || positions.length === 0) {
             return;
         }
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
+            if (!pos.InstrumentID) continue;
             
-            this._initAsset(instrumentId);
-            const asset = this.assets.get(instrumentId);
             const pnl = pos.NetProfit || 0;
+            if (pnl === 0) continue; // Ignore neutral
+            
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[pos.InstrumentID];
+            const sector = this.sectorMap[pos.InstrumentID];
+            const isWinner = pnl > 0;
 
-            // Only count one user once per asset
-            if (pnl > 0) {
-                asset.in_profit.add(userId);
-                asset.in_loss.delete(userId); // Ensure user isn't in both
-            } else if (pnl < 0) {
-                asset.in_loss.add(userId);
-                asset.in_profit.delete(userId); // Ensure user isn't in both
+            if (ticker) {
+                this._init(this.tickerBuckets, ticker);
+                const asset = this.tickerBuckets.get(ticker);
+                if (isWinner) asset.winners.add(userId);
+                else asset.losers.add(userId);
+            }
+            
+            if (sector) {
+                this._init(this.sectorBuckets, sector);
+                const sec = this.sectorBuckets.get(sector);
+                if (isWinner) sec.winners.add(userId);
+                else sec.losers.add(userId);
             }
         }
     }
 
-    /**
-     * --- MODIFIED ---
-     * This now saves only counts.
-     */
     async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // --- STANDARD 0: REMOVED forbidden data load ---
+
+        // Failsafe check
+        if (!this.tickerMap) {
+            return { by_ticker: {}, by_sector: {} };
         }
 
-        const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            
-            const profitCount = data.in_profit.size;
-            const lossCount = data.in_loss.size;
-            const total = profitCount + lossCount;
-            
-            if (total > 0) {
-                result[ticker] = {
-                    in_profit_count: profitCount,
-                    in_loss_count: lossCount,
-                    profit_ratio: (profitCount / total) * 100
-                    // Removed the user arrays
-                };
-            }
+        const result = {
+            by_ticker: {},
+            by_sector: {}
+        };
+        
+        for (const [ticker, data] of this.tickerBuckets.entries()) {
+            result.by_ticker[ticker] = {
+                winners: Array.from(data.winners),
+                losers: Array.from(data.losers)
+            };
         }
+        
+        for (const [sector, data] of this.sectorBuckets.entries()) {
+            result.by_sector[sector] = {
+                winners: Array.from(data.winners),
+                losers: Array.from(data.losers)
+            };
+        }
+        
         return result;
     }
-
+    
     reset() {
-        this.assets.clear();
-        this.mappings = null;
-        this.seenUsers.clear();
+        this.tickerBuckets.clear();
+        this.sectorBuckets.clear();
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
+        this.sectorMap = null;
     }
 }
-
 module.exports = AssetPnlStatus;

package/calculations/core/asset-position-size.js

@@ -1,118 +1,155 @@
 /**
- * Calculates the average position size (as a portfolio percentage) for each asset.
+ * @fileoverview Core Metric (Pass 2)
+ *
+ * This 'standard' calculation streams all user portfolios
+ * and calculates the *average position size in $USD* for
+ * all holders of each asset, bucketed by ticker and sector.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 class AssetPositionSize {
     constructor() {
-        this.assets = {};
-        this.mappings = null;
+        // { [ticker]: { invested_sum: 0, user_count: 0 } }
+        this.tickerBuckets = new Map();
+        // { [sector]: { invested_sum: 0, user_count: 0 } }
+        this.sectorBuckets = new Map();
+
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
+        this.sectorMap = null;
+        
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
+    /** Statically defines metadata */
     static getMetadata() {
         return {
-            type: 'standard', // It processes each user
-            rootDataDependencies: ['portfolio'], // It only needs portfolio data
-            isHistorical: false, // It only needs today's portfolio
-            userType: 'all', // It runs for all users
-            category: 'core_metrics' // Belongs to the core product line
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
+            isHistorical: false, // Reads today's portfolio
+            userType: 'all',
+            category: 'core'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
+    /** Statically declare dependencies */
     static getDependencies() {
-        return []; // This is a Pass 1 calculation
+        return [];
     }
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "avg_position_usd": { "type": "number" },
+                "total_invested_usd": { "type": "number" },
+                "user_count": { "type": "number" }
+            },
+            "required": ["avg_position_usd", "total_invested_usd", "user_count"]
+        };
+        
         return {
             "type": "object",
-            "description": "Calculates the average position size (as a portfolio percentage) and holder count for each asset.",
-            "patternProperties": {
-                // This matches any string key (which will be a ticker)
-                "^.*$": {
+            "description": "Calculates the avg. $USD position size for all holders per asset/sector.",
+            "properties": {
+                "by_ticker": {
+                    "type": "object",
+                    "patternProperties": { "^.*$": schema },
+                    "additionalProperties": schema
+                },
+                "by_sector": {
                     "type": "object",
-                    "description": "Metrics for a specific asset ticker.",
-                    "properties": {
-                        "average_position_size": {
-                            "type": "number",
-                            "description": "The average portfolio percentage allocated to this asset by users who hold it."
-                        },
-                        "position_count": {
-                            "type": "number",
-                            "description": "The total number of positions held in this asset across the user sample."
-                        }
-                    },
-                    "required": ["average_position_size", "position_count"]
+                    "patternProperties": { "^.*$": schema },
+                    "additionalProperties": schema
                 }
             },
-            "additionalProperties": {
-                "type": "object",
-                "properties": {
-                    "average_position_size": { "type": "number" },
-                    "position_count": { "type": "number" }
-                }
-            }
+            "required": ["by_ticker", "by_sector"]
         };
     }
+    
+    _init(map, key) {
+        if (!map.has(key)) {
+            map.set(key, { invested_sum: 0, user_count: 0 });
+        }
+    }
 
-    // --- REFACTORED ---
-    // Simplified signature. This calc doesn't need history, context, or insights.
-    process(portfolioData) {
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions)) return;
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: FIXED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
+             this.sectorMap = context.sectorMapping;
+        }
+        
+        if (!this.tickerMap || !this.sectorMap) {
+            return; // Failsafe if context is missing maps
+        }
+        
+        const positions = todayPortfolio?.AggregatedPositions || todayPortfolio?.PublicPositions;
+        if (!positions || positions.length === 0) {
+            return;
+        }
 
-        for (const position of positions) {
-            const instrumentId = position.InstrumentID;
-            if (!instrumentId) continue;
+        for (const pos of positions) {
+            const invested = pos.Invested || 0;
+            if (!pos.InstrumentID || invested <= 0) continue;
+            
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[pos.InstrumentID];
+            const sector = this.sectorMap[pos.InstrumentID];
 
-            if (!this.assets[instrumentId]) {
-                this.assets[instrumentId] = { position_count: 0, position_value_sum: 0 };
+            if (ticker) {
+                this._init(this.tickerBuckets, ticker);
+                const asset = this.tickerBuckets.get(ticker);
+                asset.invested_sum += invested;
+                asset.user_count++; // Count each position
+            }
+            
+            if (sector) {
+                this._init(this.sectorBuckets, sector);
+                const sec = this.sectorBuckets.get(sector);
+                sec.invested_sum += invested;
+                sec.user_count++; // Count each position
             }
-
-            this.assets[instrumentId].position_count++;
-            // FIX: Use the 'Invested' field, which holds the portfolio percentage
-            this.assets[instrumentId].position_value_sum += (position.Invested || 0);
         }
     }
 
     async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        const result = {
+            by_ticker: {},
+            by_sector: {}
+        };
+        
+        for (const [ticker, data] of this.tickerBuckets.entries()) {
+            if (data.user_count > 0) {
+                result.by_ticker[ticker] = {
+                    avg_position_usd: data.invested_sum / data.user_count,
+                    total_invested_usd: data.invested_sum,
+                    user_count: data.user_count
+                };
+            }
         }
-
-        const result = {};
-        for (const instrumentId in this.assets) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            const data = this.assets[instrumentId];
-            
-            if (data.position_count > 0) {
-                result[ticker] = {
-                    // This is now the average *percentage* size
-                    average_position_size: data.position_value_sum / data.position_count,
-                    position_count: data.position_count
+        
+        for (const [sector, data] of this.sectorBuckets.entries()) {
+            if (data.user_count > 0) {
+                result.by_sector[sector] = {
+                    avg_position_usd: data.invested_sum / data.user_count,
+                    total_invested_usd: data.invested_sum,
+                    user_count: data.user_count
                 };
             }
         }
         
         return result;
     }
-
+    
     reset() {
-        this.assets = {};
-        this.mappings = null;
+        this.tickerBuckets.clear();
+        this.sectorBuckets.clear();
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
+        this.sectorMap = null;
     }
 }
-
 module.exports = AssetPositionSize;

package/calculations/core/average-daily-pnl-all-users.js

@@ -60,9 +60,23 @@ class AverageDailyPnlAllUsers {
         };
     }
 
-    process(portfolioData) {
-        // Use the P&L from the summary, which is for the *day*
-        const dailyPnl = portfolioData.Summary?.NetProfit || 0;
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        let dailyPnl = 0;
+
+        // Check if it's a SPECULATOR portfolio (it has a root 'NetProfit' and 'PublicPositions')
+        if (todayPortfolio.NetProfit !== undefined && todayPortfolio.PublicPositions) {
+            
+            dailyPnl = todayPortfolio.NetProfit;
+
+        // Check if it's a NORMAL user portfolio (it has 'AggregatedPositionsByInstrumentTypeID')
+        } else if (todayPortfolio.AggregatedPositionsByInstrumentTypeID) {
+            
+            // Sum the P&L by calculating (Value - Invested) from the aggregates
+            dailyPnl = todayPortfolio.AggregatedPositionsByInstrumentTypeID.reduce((sum, agg) => {
+                return sum + (agg.Value - agg.Invested);
+            }, 0);
+            
+        }
         
         this.totalPnl += dailyPnl;
         this.userCount++;