aiden-shared-calculations-unified 1.0.86 → 1.0.87

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;
     }
 }

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

@@ -1,90 +1,60 @@
 /**
- * @fileoverview Calculation (Pass 1) for average P&L per position.
- *
- * This metric answers: "What was the average P&L across all
- * individual positions held by the crowd today?"
- *
- * This is different from "average P&L per user" as a user
- * can have multiple positions.
+ * @fileoverview Calculation (Pass 1) for average P&L % per position.
+ * REFACTORED: Uses P&L %.
  */
 class AverageDailyPositionPnl {
     constructor() {
-        this.totalPnl = 0;
+        this.totalPnlPct = 0;
         this.positionCount = 0;
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'], // Needs portfolio positions
+            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 individual positions.",
             "properties": {
-                "average_pnl": {
-                    "type": "number",
-                    "description": "The average daily P&L per position (Total P&L / Position Count)."
-                },
-                "total_pnl": {
-                    "type": "number",
-                    "description": "The sum of all daily P&L from all positions."
-                },
-                "position_count": {
-                    "type": "number",
-                    "description": "The total number of positions processed."
-                }
+                "avg_position_pnl_pct": { "type": "number" },
+                "aggregate_pnl_pct_sum": { "type": "number" },
+                "total_positions": { "type": "number" }
             },
-            "required": ["average_pnl", "total_pnl", "position_count"]
+            "required": ["avg_position_pnl_pct", "aggregate_pnl_pct_sum", "total_positions"]
         };
     }
 
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { user } = context;
+
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            this.totalPnl += pos.NetProfit || 0;
+            this.totalPnlPct += extract.getNetProfit(pos);
             this.positionCount++;
         }
     }
 
     getResult() {
         return {
-            average_pnl: (this.positionCount > 0) ? (this.totalPnl / this.positionCount) : 0,
-            total_pnl: this.totalPnl,
-            position_count: this.positionCount
+            avg_position_pnl_pct: (this.positionCount > 0) ? (this.totalPnlPct / this.positionCount) : 0,
+            aggregate_pnl_pct_sum: this.totalPnlPct,
+            total_positions: this.positionCount
         };
     }
 
     reset() {
-        this.totalPnl = 0;
+        this.totalPnlPct = 0;
         this.positionCount = 0;
     }
 }
-
 module.exports = AverageDailyPositionPnl;

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

@@ -1,162 +1,60 @@
 /**
  * @fileoverview Calculation (Pass 1) for user behaviour.
- *
- * REFACTOR: This metric now answers: "What is the average holding duration
- * (in hours) for *closed* positions, averaged across all users, grouped by asset?"
- *
- * This calculation now uses the 'history' data source, not 'portfolio'.
+ * REFACTORED: Uses context.math.history.getDailyHistory().
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
 class HoldingDurationPerAsset {
     constructor() {
-        // { [instrumentId]: { sum_hours: 0, count: 0 } }
-        // '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();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['history'], // It only needs the history doc
-            isHistorical: false, // It only needs today's history doc
-            userType: 'all',
-            category: 'core_metrics'
-        };
+        return { type: 'standard', rootDataDependencies: ['history'], isHistorical: false, userType: 'all', category: 'core_metrics' };
     }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     */
+    static getDependencies() { return []; }
     static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "avg_duration_hours": {
-                    "type": "number",
-                    "description": "Average holding duration in hours (averaged across all users)."
-                },
-                "count": {
-                    "type": "number",
-                    "description": "Count of users used in average."
-                }
-            },
-            "required": ["avg_duration_hours", "count"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the average holding duration (in hours) for closed positions per asset, averaged across all users.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
-        };
+        const tickerSchema = { "type": "object", "properties": { "avg_duration_hours": { "type": "number" }, "count": { "type": "number" } }, "required": ["avg_duration_hours", "count"] };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
     _initAsset(instrumentId) {
-        if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, { sum_hours: 0, count: 0 });
-        }
+        if (!this.assets.has(instrumentId)) this.assets.set(instrumentId, { sum_hours: 0, count: 0 });
     }
 
-    /**
-     * Process data from the 'history' root data source.
-     */
-    process(
-        todayPortfolio, 
-        yesterdayPortfolio, 
-        userId, 
-        context, 
-        todayInsights, 
-        yesterdayInsights, 
-        todaySocialPostInsights, 
-        yesterdaySocialPostInsights,
-        todayHistory
-    ) {
-        // --- STANDARD 0: FIXED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { history } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.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;
-        }
+        // V4: Strict Access via Math Layer
+        const historyDoc = history.getDailyHistory(user);
+        const tradedAssets = history.getTradedAssets(historyDoc);
 
-        // 2. Iterate over the aggregated assets in the history doc
-        for (const asset of historyData.assets) {
-            const instrumentId = asset.instrumentId;
+        for (const asset of tradedAssets) {
+            const instId = history.getInstrumentId(asset);
+            if (!instId || instId === -1) continue;
 
-            // Skip the "all" aggregate entry
-            if (!instrumentId || instrumentId === -1) {
-                continue;
-            }
-            
-            const durationMinutes = asset.avgHoldingTimeInMinutes;
-            
-            if (typeof durationMinutes === 'number' && durationMinutes > 0) {
-                this._initAsset(instrumentId);
-                
-                const assetData = this.assets.get(instrumentId);
-                
-                // Convert minutes to hours and add to the sum
+            const durationMinutes = history.getAvgHoldingTimeMinutes(asset);
+            if (durationMinutes > 0) {
+                this._initAsset(instId);
+                const assetData = this.assets.get(instId);
                 assetData.sum_hours += (durationMinutes / 60);
-                
-                // Increment count
                 assetData.count++;
             }
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
-        }
-
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-            
+        for (const [instId, data] of this.assets.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
             if (data.count > 0) {
-                result[ticker] = {
-                    // Calculate the final average (avg of avgs)
-                    avg_duration_hours: data.sum_hours / data.count,
-                    count: data.count
-                };
+                result[ticker] = { avg_duration_hours: data.sum_hours / data.count, count: data.count };
             }
         }
         return result;
     }
-
-    reset() {
-        this.assets.clear();
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null;
-    }
+    reset() { this.assets.clear(); this.tickerMap = null; }
 }
-
 module.exports = HoldingDurationPerAsset;