aiden-shared-calculations-unified 1.0.82 → 1.0.84

package/calculations/core/average-daily-pnl-per-sector.js

@@ -1,129 +1,137 @@
 /**
- * @fileoverview Calculation (Pass 1) for average daily P&L per sector.
+ * @fileoverview Core Metric (Pass 2)
  *
- * This metric answers: "What was the average daily P&L for each sector?"
- *
- * This helps identify which parts of the market the crowd
- * is performing well or poorly in.
+ * This 'standard' calculation streams all user portfolios
+ * and calculates the average daily P&L (in %) for all
+ * users, bucketed by sector.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 class AverageDailyPnlPerSector {
     constructor() {
-        // We will store { [sector]: { pnl_sum: 0, user_count: 0 } }
-        this.sectors = new Map();
-        this.mappings = null;
+        // { [sector]: { pnl_sum: 0, count: 0 } }
+        this.sectorBuckets = new Map();
+        
+        // --- STANDARD 0: RENAMED ---
+        this.sectorMap = null;
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
+    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'], // Needs portfolio positions
-            isHistorical: false,
+            rootDataDependencies: ['portfolio'],
+            isHistorical: false, // Reads today's portfolio
             userType: 'all',
-            category: 'core_pnl'
+            category: 'core'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
+    /** Statically declare dependencies */
     static getDependencies() {
         return [];
     }
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
-        const sectorSchema = {
+        const schema = {
             "type": "object",
-            "description": "P&L metrics for a specific sector.",
             "properties": {
-                "average_pnl": {
-                    "type": "number",
-                    "description": "Average P&L for this sector (Sum / User Count)."
-                },
-                "pnl_sum": {
-                    "type": "number",
-                    "description": "Sum of all P&L for this sector."
-                },
-                "user_count": {
-                    "type": "number",
-                    "description": "Count of users with positions in this sector."
-                }
+                "avg_daily_pnl_pct": { "type": "number" },
+                "total_pnl_pct": { "type": "number" },
+                "user_count": { "type": "number" }
             },
-            "required": ["average_pnl", "pnl_sum", "user_count"]
+            "required": ["avg_daily_pnl_pct", "total_pnl_pct", "user_count"]
         };
-
+        
         return {
             "type": "object",
-            "description": "Calculates the average daily P&L per sector.",
-            "patternProperties": {
-                "^.*$": sectorSchema // Sector name
-            },
-            "additionalProperties": sectorSchema
+            "description": "Calculates the avg. daily P&L % for all users, bucketed by sector.",
+            "patternProperties": { "^.*$": schema },
+            "additionalProperties": schema
         };
     }
-
-    _initSector(sector) {
-        if (!this.sectors.has(sector)) {
-            this.sectors.set(sector, {
-                pnl_sum: 0,
-                users: new Set() // Use Set to count unique users
-            });
+    
+    _init(map, key) {
+        if (!map.has(key)) {
+            map.set(key, { pnl_sum: 0, count: 0 });
         }
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        // This calculation needs the sector mappings from Pass 1 context
-        if (!this.mappings) {
-            this.mappings = context.mappings;
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: FIXED ---
+        if (!this.sectorMap) {
+             this.sectorMap = context.sectorMapping;
         }
+        
+        if (!this.sectorMap) {
+            return; // Failsafe if context is missing map
+        }
+        
+        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;
 
-        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
-        if (!positions || !Array.isArray(positions) || !this.mappings) {
+        // 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);
+            
+        }
+        if (dailyPnl === 0) return; // No P&L
+        
+        const positions = todayPortfolio?.AggregatedPositions || todayPortfolio?.PublicPositions;
+        if (!positions || positions.length === 0) {
             return;
         }
 
+        // We only care about sectors this user *holds*
+        const heldSectors = new Set();
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
-            
-            const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
-            this._initSector(sector);
-            
-            const sectorData = this.sectors.get(sector);
-            sectorData.pnl_sum += pos.NetProfit || 0;
-            sectorData.users.add(userId);
+            if (!pos.InstrumentID) continue;
+            // --- STANDARD 0: SIMPLIFIED ---
+            const sector = this.sectorMap[pos.InstrumentID];
+            if (sector) {
+                heldSectors.add(sector);
+            }
+        }
+        
+        for (const sector of heldSectors) {
+            this._init(this.sectorBuckets, sector);
+            const sec = this.sectorBuckets.get(sector);
+            sec.pnl_sum += dailyPnl;
+            sec.count++;
         }
     }
 
-    getResult() {
+    async getResult() {
         const result = {};
-        for (const [sector, data] of this.sectors.entries()) {
-            const userCount = data.users.size;
-            if (userCount > 0) {
+        
+        for (const [sector, data] of this.sectorBuckets.entries()) {
+            if (data.count > 0) {
                 result[sector] = {
-                    average_pnl: data.pnl_sum / userCount,
-                    pnl_sum: data.pnl_sum,
-                    user_count: userCount
+                    avg_daily_pnl_pct: (data.pnl_sum / data.count) * 100, // Convert decimal to %
+                    total_pnl_pct: data.pnl_sum * 100,
+                    user_count: data.count
                 };
             }
         }
+        
         return result;
     }
-
+    
     reset() {
-        this.sectors.clear();
-        this.mappings = null;
+        this.sectorBuckets.clear();
+        // --- STANDARD 0: RENAMED ---
+        this.sectorMap = null;
     }
 }
-
 module.exports = AverageDailyPnlPerSector;

package/calculations/core/average-daily-pnl-per-stock.js

@@ -1,126 +1,137 @@
 /**
- * @fileoverview Calculation (Pass 1) for average daily P&L per stock.
+ * @fileoverview Core Metric (Pass 2)
  *
- * This metric answers: "What was the average daily P&L for a
- * position in each specific stock?"
+ * This 'standard' calculation streams all user portfolios
+ * and calculates the average daily P&L (in %) for all
+ * users, bucketed by stock ticker.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 class AverageDailyPnlPerStock {
     constructor() {
-        // We will store { [instrumentId]: { pnl_sum: 0, position_count: 0 } }
-        this.assets = new Map();
-        this.mappings = null;
+        // { [ticker]: { pnl_sum: 0, count: 0 } }
+        this.tickerBuckets = new Map();
+
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
+    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'], // Needs portfolio positions
-            isHistorical: false,
+            rootDataDependencies: ['portfolio'],
+            isHistorical: false, // Reads today's portfolio
             userType: 'all',
-            category: 'core_pnl'
+            category: 'core'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
+    /** Statically declare dependencies */
     static getDependencies() {
         return [];
     }
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
-        const tickerSchema = {
+        const schema = {
             "type": "object",
-            "description": "P&L metrics for a specific asset ticker.",
             "properties": {
-                "average_pnl": {
-                    "type": "number",
-                    "description": "Average P&L per position (Sum / Count)."
-                },
-                "pnl_sum": {
-                    "type": "number",
-                    "description": "Sum of all P&L for this asset."
-                },
-                "position_count": {
-                    "type": "number",
-                    "description": "Count of positions in this asset."
-                }
+                "avg_daily_pnl_pct": { "type": "number" },
+                "total_pnl_pct": { "type": "number" },
+                "user_count": { "type": "number" }
             },
-            "required": ["average_pnl", "pnl_sum", "position_count"]
+            "required": ["avg_daily_pnl_pct", "total_pnl_pct", "user_count"]
         };
-
+        
         return {
             "type": "object",
-            "description": "Calculates the average daily P&L per stock/asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
+            "description": "Calculates the avg. daily P&L % for all users, bucketed by stock.",
+            "patternProperties": { "^.*$": schema },
+            "additionalProperties": schema
         };
     }
-
-    _initAsset(instrumentId) {
-        if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                pnl_sum: 0,
-                position_count: 0
-            });
+    
+    _init(map, key) {
+        if (!map.has(key)) {
+            map.set(key, { pnl_sum: 0, count: 0 });
         }
     }
 
-    process(portfolioData) {
-        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: FIXED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
+        }
+        
+        if (!this.tickerMap) {
+            return; // Failsafe if context is missing map
         }
+        
+        let dailyPnl = 0;
 
-        for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
+        // 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) {
             
-            this._initAsset(instrumentId);
+            // Sum the P&L by calculating (Value - Invested) from the aggregates
+            dailyPnl = todayPortfolio.AggregatedPositionsByInstrumentTypeID.reduce((sum, agg) => {
+                return sum + (agg.Value - agg.Invested);
+            }, 0);
             
-            const assetData = this.assets.get(instrumentId);
-            assetData.pnl_sum += pos.NetProfit || 0;
-            assetData.position_count++;
         }
-    }
+        if (dailyPnl === 0) return; // No P&L
+        
+        const positions = todayPortfolio?.AggregatedPositions || todayPortfolio?.PublicPositions;
+        if (!positions || positions.length === 0) {
+            return;
+        }
 
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // We only care about tickers this user *holds*
+        const heldTickers = new Set();
+        for (const pos of positions) {
+            if (!pos.InstrumentID) continue;
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[pos.InstrumentID];
+            if (ticker) {
+                heldTickers.add(ticker);
+            }
         }
+        
+        for (const ticker of heldTickers) {
+            this._init(this.tickerBuckets, ticker);
+            const asset = this.tickerBuckets.get(ticker);
+            asset.pnl_sum += dailyPnl;
+            asset.count++;
+        }
+    }
 
+    async getResult() {
         const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            
-            if (data.position_count > 0) {
+        
+        for (const [ticker, data] of this.tickerBuckets.entries()) {
+            if (data.count > 0) {
                 result[ticker] = {
-                    average_pnl: data.pnl_sum / data.position_count,
-                    pnl_sum: data.pnl_sum,
-                    position_count: data.position_count
+                    avg_daily_pnl_pct: (data.pnl_sum / data.count) * 100, // Convert decimal to %
+                    total_pnl_pct: data.pnl_sum * 100,
+                    user_count: data.count
                 };
             }
         }
+        
         return result;
     }
-
+    
     reset() {
-        this.assets.clear();
-        this.mappings = null;
+        this.tickerBuckets.clear();
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 }
-
 module.exports = AverageDailyPnlPerStock;

package/calculations/core/average-daily-position-pnl.js

@@ -61,8 +61,8 @@ class AverageDailyPositionPnl {
         };
     }
 
-    process(portfolioData) {
-        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
         if (!positions || !Array.isArray(positions)) {
             return;
         }

package/calculations/core/holding-duration-per-asset.js

@@ -6,7 +6,7 @@
  *
  * This calculation now uses the 'history' data source, not 'portfolio'.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 
 class HoldingDurationPerAsset {
@@ -15,10 +15,10 @@ class HoldingDurationPerAsset {
         // 'sum_hours' will be the sum of user-level averages
         // 'count' will be the number of users who traded that asset
         this.assets = new Map();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 
-    // --- NEW ---
     /**
      * Statically defines all metadata for the manifest builder.
      */
@@ -32,7 +32,6 @@ class HoldingDurationPerAsset {
         };
     }
 
-    // --- NEW ---
     /**
      * Statically declare dependencies.
      */
@@ -42,7 +41,6 @@ class HoldingDurationPerAsset {
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
         const tickerSchema = {
@@ -76,18 +74,8 @@ class HoldingDurationPerAsset {
         }
     }
 
-    // --- REFACTORED ---
     /**
      * Process data from the 'history' root data source.
-     * @param {object} todayPortfolio - (Not used)
-     * @param {object} yesterdayPortfolio - (Not used)
-     * @param {string} userId - The user ID.
-     * @param {object} context - (Not used)
-     * @param {object} todayInsights - (Not used)
-     * @param {object} yesterdayInsights - (Not used)
-     * @param {object} todaySocialPostInsights - (Not used)
-     * @param {object} yesterdaySocialPostInsights - (Not used)
-     * @param {object} todayHistory - The user's history doc for today.
      */
     process(
         todayPortfolio, 
@@ -100,8 +88,17 @@ class HoldingDurationPerAsset {
         yesterdaySocialPostInsights,
         todayHistory
     ) {
-        // 1. Get the history data from the 9th argument
-        const historyData = todayHistory;
+        // --- STANDARD 0: FIXED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
+        }
+
+        // ---
+        // FIX: The test harness injects data based on getMetadata().
+        // Because rootDataDependencies is ONLY ['history'], the test harness
+        // places the history object in the *first* argument (todayPortfolio).
+        // ---
+        const historyData = todayPortfolio; // NOT todayHistory
         if (!historyData || !Array.isArray(historyData.assets)) {
             return;
         }
@@ -125,21 +122,24 @@ class HoldingDurationPerAsset {
                 // Convert minutes to hours and add to the sum
                 assetData.sum_hours += (durationMinutes / 60);
                 
-                // Increment count (this now counts *users* who have
-                // an average for this asset, not individual positions)
+                // Increment count
                 assetData.count++;
             }
         }
     }
 
     async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // --- STANDARD 0: REMOVED forbidden data load ---
+
+        // Failsafe check
+        if (!this.tickerMap) {
+            return {}; // process() must run first
         }
 
         const result = {};
         for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
             
             if (data.count > 0) {
                 result[ticker] = {
@@ -154,7 +154,8 @@ class HoldingDurationPerAsset {
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 }