aiden-shared-calculations-unified 1.0.86 → 1.0.88

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

@@ -1,145 +1,97 @@
 /**
  * @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.
+ * REFACTORED: Calculates average portfolio weight (%) per asset.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class AssetPositionSize {
     constructor() {
-        // { [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;
-        
     }
 
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: false, // Reads today's portfolio
+            isHistorical: false,
             userType: 'all',
             category: 'core'
         };
     }
 
-    /** Statically declare dependencies */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const schema = {
             "type": "object",
             "properties": {
-                "avg_position_usd": { "type": "number" },
-                "total_invested_usd": { "type": "number" },
+                "avg_position_weight": { "type": "number", "description": "Average % of portfolio allocated to this asset." },
+                "total_exposure_weight": { "type": "number", "description": "Sum of all user allocation percentages." },
                 "user_count": { "type": "number" }
             },
-            "required": ["avg_position_usd", "total_invested_usd", "user_count"]
+            "required": ["avg_position_weight", "total_exposure_weight", "user_count"]
         };
-        
         return {
             "type": "object",
-            "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",
-                    "patternProperties": { "^.*$": schema },
-                    "additionalProperties": schema
-                }
-            },
-            "required": ["by_ticker", "by_sector"]
+                "by_ticker": { "type": "object", "patternProperties": { "^.*$": schema } },
+                "by_sector": { "type": "object", "patternProperties": { "^.*$": schema } }
+            }
         };
     }
     
     _init(map, key) {
-        if (!map.has(key)) {
-            map.set(key, { invested_sum: 0, user_count: 0 });
-        }
+        if (!map.has(key)) map.set(key, { weight_sum: 0, user_count: 0 });
     }
 
-    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;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const invested = pos.Invested || 0;
-            if (!pos.InstrumentID || invested <= 0) continue;
+            const weight = extract.getPositionWeight(pos, user.type);
+            if (weight <= 0) continue;
+
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
             
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[pos.InstrumentID];
-            const sector = this.sectorMap[pos.InstrumentID];
+            const ticker = mappings.instrumentToTicker[instId];
+            const sector = mappings.sectorMapping[instId];
 
             if (ticker) {
                 this._init(this.tickerBuckets, ticker);
                 const asset = this.tickerBuckets.get(ticker);
-                asset.invested_sum += invested;
-                asset.user_count++; // Count each position
+                asset.weight_sum += weight;
+                asset.user_count++;
             }
             
             if (sector) {
                 this._init(this.sectorBuckets, sector);
                 const sec = this.sectorBuckets.get(sector);
-                sec.invested_sum += invested;
-                sec.user_count++; // Count each position
+                sec.weight_sum += weight;
+                sec.user_count++;
             }
         }
     }
 
     async getResult() {
-        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 = { by_ticker: {}, by_sector: {} };
         
-        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
-                };
+        const buildResult = (map, out) => {
+            for (const [key, data] of map.entries()) {
+                if (data.user_count > 0) {
+                    out[key] = {
+                        avg_position_weight: data.weight_sum / data.user_count,
+                        total_exposure_weight: data.weight_sum,
+                        user_count: data.user_count
+                    };
+                }
             }
-        }
+        };
+
+        buildResult(this.tickerBuckets, result.by_ticker);
+        buildResult(this.sectorBuckets, result.by_sector);
         
         return result;
     }
@@ -147,9 +99,6 @@ class AssetPositionSize {
     reset() {
         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

@@ -1,97 +1,58 @@
 /**
- * @fileoverview Calculation (Pass 1) for average daily P&L.
- *
- * This metric answers: "What was the average daily P&L
- * for the average user?"
- *
- * This is a global health metric for the crowd.
+ * @fileoverview Calculation (Pass 1) for average daily P&L %.
+ * REFACTORED: Uses standardized P&L % access.
  */
 class AverageDailyPnlAllUsers {
     constructor() {
-        this.totalPnl = 0;
+        this.totalPnlPct = 0;
         this.userCount = 0;
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'], // Needs portfolio.Summary
+            rootDataDependencies: ['portfolio'],
             isHistorical: false,
             userType: 'all',
             category: 'core_pnl'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
         return {
             "type": "object",
-            "description": "Calculates the average daily P&L across all users.",
             "properties": {
-                "average_daily_pnl": {
-                    "type": "number",
-                    "description": "The average daily P&L per user (Total P&L / User Count)."
-                },
-                "total_pnl": {
-                    "type": "number",
-                    "description": "The sum of all daily P&L from all users."
-                },
-                "user_count": {
-                    "type": "number",
-                    "description": "The total number of users processed."
-                }
+                "average_daily_pnl_pct": { "type": "number" },
+                "total_aggregate_pnl_pct": { "type": "number", "description": "Sum of all user daily P&L percentages." },
+                "user_count": { "type": "number" }
             },
-            "required": ["average_daily_pnl", "total_pnl", "user_count"]
+            "required": ["average_daily_pnl_pct", "total_aggregate_pnl_pct", "user_count"]
         };
     }
 
-    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;
+    process(context) {
+        const { extract } = context.math;
+        const { user } = context;
 
-        // 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);
-            
-        }
+        // extract.getPortfolioDailyPnl returns the daily P&L as a percentage for the user
+        const dailyPnl = extract.getPortfolioDailyPnl(user.portfolio.today, user.type);
         
-        this.totalPnl += dailyPnl;
+        this.totalPnlPct += dailyPnl;
         this.userCount++;
     }
 
     getResult() {
         return {
-            average_daily_pnl: (this.userCount > 0) ? (this.totalPnl / this.userCount) : 0,
-            total_pnl: this.totalPnl,
+            average_daily_pnl_pct: (this.userCount > 0) ? (this.totalPnlPct / this.userCount) : 0,
+            total_aggregate_pnl_pct: this.totalPnlPct,
             user_count: this.userCount
         };
     }
 
     reset() {
-        this.totalPnl = 0;
+        this.totalPnlPct = 0;
         this.userCount = 0;
     }
 }

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

@@ -1,136 +1,89 @@
 /**
- * @fileoverview Core Metric (Pass 2)
- *
- * This 'standard' calculation streams all user portfolios
- * and calculates the average daily P&L (in %) for all
- * users, bucketed by sector.
+ * @fileoverview Calculation (Pass 1) for average daily P&L % per sector.
+ * REFACTORED: Aggregates P&L percentages.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class AverageDailyPnlPerSector {
     constructor() {
-        // { [sector]: { pnl_sum: 0, count: 0 } }
-        this.sectorBuckets = new Map();
-        
-        // --- STANDARD 0: RENAMED ---
+        this.sectorData = new Map();
         this.sectorMap = null;
     }
 
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: false, // Reads today's portfolio
+            isHistorical: false,
             userType: 'all',
-            category: 'core'
+            category: 'core_pnl'
         };
     }
 
-    /** Statically declare dependencies */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        const schema = {
+        const sectorSchema = {
             "type": "object",
             "properties": {
                 "avg_daily_pnl_pct": { "type": "number" },
-                "total_pnl_pct": { "type": "number" },
+                "aggregate_pnl_pct_sum": { "type": "number", "description": "Sum of P&L % points for sector." },
                 "user_count": { "type": "number" }
             },
-            "required": ["avg_daily_pnl_pct", "total_pnl_pct", "user_count"]
-        };
-        
-        return {
-            "type": "object",
-            "description": "Calculates the avg. daily P&L % for all users, bucketed by sector.",
-            "patternProperties": { "^.*$": schema },
-            "additionalProperties": schema
+            "required": ["avg_daily_pnl_pct", "aggregate_pnl_pct_sum", "user_count"]
         };
-    }
-    
-    _init(map, key) {
-        if (!map.has(key)) {
-            map.set(key, { pnl_sum: 0, count: 0 });
-        }
+        return { "type": "object", "patternProperties": { "^.*$": sectorSchema } };
     }
 
-    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
+    _initSector(sector) {
+        if (!this.sectorData.has(sector)) {
+            this.sectorData.set(sector, { total_pnl_pct: 0, count: 0 });
         }
-        
-        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;
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.sectorMap) this.sectorMap = mappings.sectorMapping;
 
-        // 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;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
+        const userSectorPnL = new Map();
 
-        // We only care about sectors this user *holds*
-        const heldSectors = new Set();
         for (const pos of positions) {
-            if (!pos.InstrumentID) continue;
-            // --- STANDARD 0: SIMPLIFIED ---
-            const sector = this.sectorMap[pos.InstrumentID];
-            if (sector) {
-                heldSectors.add(sector);
-            }
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
+
+            const sector = this.sectorMap[instId] || 'Unknown';
+            // NetProfit is the % profit relative to invested capital for that position
+            // We sum these to get the user's "sector performance points"
+            const pnlPct = extract.getNetProfit(pos);
+
+            if (!userSectorPnL.has(sector)) userSectorPnL.set(sector, 0);
+            userSectorPnL.set(sector, userSectorPnL.get(sector) + pnlPct);
         }
-        
-        for (const sector of heldSectors) {
-            this._init(this.sectorBuckets, sector);
-            const sec = this.sectorBuckets.get(sector);
-            sec.pnl_sum += dailyPnl;
-            sec.count++;
+
+        for (const [sector, pnl] of userSectorPnL.entries()) {
+            this._initSector(sector);
+            const data = this.sectorData.get(sector);
+            data.total_pnl_pct += pnl;
+            data.count++;
         }
     }
 
     async getResult() {
         const result = {};
-        
-        for (const [sector, data] of this.sectorBuckets.entries()) {
+        for (const [sector, data] of this.sectorData.entries()) {
             if (data.count > 0) {
                 result[sector] = {
-                    avg_daily_pnl_pct: (data.pnl_sum / data.count) * 100, // Convert decimal to %
-                    total_pnl_pct: data.pnl_sum * 100,
+                    avg_daily_pnl_pct: data.total_pnl_pct / data.count,
+                    aggregate_pnl_pct_sum: data.total_pnl_pct,
                     user_count: data.count
                 };
             }
         }
-        
         return result;
     }
-    
+
     reset() {
-        this.sectorBuckets.clear();
-        // --- STANDARD 0: RENAMED ---
+        this.sectorData.clear();
         this.sectorMap = null;
     }
 }

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

@@ -1,136 +1,83 @@
 /**
- * @fileoverview Core Metric (Pass 2)
- *
- * This 'standard' calculation streams all user portfolios
- * and calculates the average daily P&L (in %) for all
- * users, bucketed by stock ticker.
+ * @fileoverview Calculation (Pass 1) for average daily P&L % per stock.
+ * REFACTORED: Aggregates P&L percentages.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class AverageDailyPnlPerStock {
     constructor() {
-        // { [ticker]: { pnl_sum: 0, count: 0 } }
-        this.tickerBuckets = new Map();
-
-        // --- STANDARD 0: RENAMED ---
+        this.stockData = new Map();
         this.tickerMap = null;
     }
 
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: false, // Reads today's portfolio
+            isHistorical: false,
             userType: 'all',
-            category: 'core'
+            category: 'core_pnl'
         };
     }
 
-    /** Statically declare dependencies */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        const schema = {
+        const stockSchema = {
             "type": "object",
             "properties": {
                 "avg_daily_pnl_pct": { "type": "number" },
-                "total_pnl_pct": { "type": "number" },
-                "user_count": { "type": "number" }
+                "aggregate_pnl_pct_sum": { "type": "number" },
+                "position_count": { "type": "number" }
             },
-            "required": ["avg_daily_pnl_pct", "total_pnl_pct", "user_count"]
+            "required": ["avg_daily_pnl_pct", "aggregate_pnl_pct_sum", "position_count"]
         };
-        
-        return {
-            "type": "object",
-            "description": "Calculates the avg. daily P&L % for all users, bucketed by stock.",
-            "patternProperties": { "^.*$": schema },
-            "additionalProperties": schema
-        };
-    }
-    
-    _init(map, key) {
-        if (!map.has(key)) {
-            map.set(key, { pnl_sum: 0, count: 0 });
-        }
+        return { "type": "object", "patternProperties": { "^.*$": stockSchema } };
     }
 
-    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
+    _initStock(instId) {
+        if (!this.stockData.has(instId)) {
+            this.stockData.set(instId, { total_pnl_pct: 0, count: 0 });
         }
-        
-        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;
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        // 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;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
-        // 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++;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
+
+            // NetProfit is %
+            const pnlPct = extract.getNetProfit(pos);
+
+            this._initStock(instId);
+            const data = this.stockData.get(instId);
+            data.total_pnl_pct += pnlPct;
+            data.count++;
         }
     }
 
     async getResult() {
+        if (!this.tickerMap) return {};
         const result = {};
-        
-        for (const [ticker, data] of this.tickerBuckets.entries()) {
+        for (const [instId, data] of this.stockData.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
             if (data.count > 0) {
                 result[ticker] = {
-                    avg_daily_pnl_pct: (data.pnl_sum / data.count) * 100, // Convert decimal to %
-                    total_pnl_pct: data.pnl_sum * 100,
-                    user_count: data.count
+                    avg_daily_pnl_pct: data.total_pnl_pct / data.count,
+                    aggregate_pnl_pct_sum: data.total_pnl_pct,
+                    position_count: data.count
                 };
             }
         }
-        
         return result;
     }
-    
+
     reset() {
-        this.tickerBuckets.clear();
-        // --- STANDARD 0: RENAMED ---
+        this.stockData.clear();
         this.tickerMap = null;
     }
 }