aiden-shared-calculations-unified 1.0.86 → 1.0.88

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;

package/calculations/core/instrument-price-change-1d.js

@@ -1,75 +1,64 @@
 /**
- * @fileoverview CORE Product Line (Pass 1)
- *
- * This 'meta' calculation computes the 1-day percentage price
- * change for all instruments.
+ * @fileoverview Calculation (Pass 1 - Meta) for 1-day price change.
+ * REFACTORED: Uses process(context) solely.
  */
-
 class InstrumentPriceChange1D {
     constructor() {
         this.result = {};
     }
 
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'meta',
             rootDataDependencies: ['price'],
             isHistorical: true,
-            userType: null, // n/a
+            userType: 'n/a',
             category: 'core'
         };
     }
 
-    /** Statically declare dependencies */
-    static getDependencies() {
-        return [];
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "change_1d_pct": { "type": "number" }
+            },
+            "required": ["change_1d_pct"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * Helper to parse price data from the { instrumentId, prices: { '2025-10-01': 123 } } format
-     * and return a sorted list.
-     */
     _getPrices(priceData) {
-        if (!priceData || !priceData.prices) {
-            return [];
-        }
-        // FIX: Correctly parse and sort price data
+        if (!priceData || !priceData.prices) return [];
         return Object.entries(priceData.prices)
             .map(([date, price]) => ({ date, price }))
             .sort((a, b) => new Date(a.date) - new Date(b.date));
     }
     
-    /**
-     * process (FIXED for 5-arg META signature)
-     * Arg 1: metaPayload (contains all root data from worker's "HACK" fix)
-     * Arg 2: metaRootData (production compliance, unused in test)
-     * Arg 3: dependencies (logger, etc., unused in test)
-     * Arg 4: config (mappings)
-     * Arg 5: fetchedDependencies (unused)
-     */
-    process(metaPayload, metaRootData, dependencies, config, fetchedDependencies) {
-        const results = {};
+    process(context) {
+        const { mappings, prices } = context;
+        const { instrumentToTicker } = mappings;
         
-        // FIX: Read from metaPayload (Arg 1) passed by worker.js
-        const todayPrices = metaPayload.priceData || [];
-        const yesterdayPrices = metaPayload.yesterdayPriceData || [];
+        // Expecting context.prices to be populated by the controller for 'meta' + 'price' dependency
+        const todayPrices = prices?.today || [];
+        const yesterdayPrices = prices?.yesterday || [];
+
+        const results = {};
 
-        // Create lookup maps for today's and yesterday's prices
         const todayPriceMap = new Map(todayPrices.map(p => {
-            const prices = this._getPrices(p);
-            const lastPrice = prices.length > 0 ? prices[prices.length - 1].price : 0;
+            const pList = this._getPrices(p);
+            const lastPrice = pList.length > 0 ? pList[pList.length - 1].price : 0;
             return [p.instrumentId, lastPrice];
         }));
 
         const yesterdayPriceMap = new Map(yesterdayPrices.map(p => {
-            const prices = this._getPrices(p);
-            const lastPrice = prices.length > 0 ? prices[prices.length - 1].price : 0;
+            const pList = this._getPrices(p);
+            const lastPrice = pList.length > 0 ? pList[pList.length - 1].price : 0;
             return [p.instrumentId, lastPrice];
         }));
 
-        const { instrumentToTicker } = config; // Read from Arg 4
-
         for (const [instrumentId, todayPrice] of todayPriceMap) {
             const yesterdayPrice = yesterdayPriceMap.get(instrumentId);
             const ticker = instrumentToTicker[instrumentId];
@@ -81,21 +70,13 @@ class InstrumentPriceChange1D {
                     change_1d_pct: isFinite(changePct) ? changePct : 0
                 };
             } else {
-                results[ticker] = {
-                    change_1d_pct: 0
-                };
+                results[ticker] = { change_1d_pct: 0 };
             }
         }
         this.result = results;
     }
 
-    async getResult() {
-        return this.result;
-    }
-
-    reset() {
-        this.result = {};
-    }
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
 }
-
 module.exports = InstrumentPriceChange1D;

package/calculations/core/instrument-price-momentum-20d.js

@@ -1,94 +1,84 @@
 /**
- * @fileoverview CORE Product Line (Pass 1)
- *
- * This 'meta' calculation computes the 20-day percentage price
- * change (momentum) for all instruments.
+ * @fileoverview Calculation (Pass 1 - Meta) for 20-day momentum.
+ * REFACTORED: Uses process(context) solely.
  */
-
 class InstrumentPriceMomentum20D {
     constructor() {
         this.result = {};
     }
 
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'meta',
             rootDataDependencies: ['price'],
-            isHistorical: true, // Needs history, but just from one 'today' file
-            userType: null, // n/a
+            isHistorical: true,
+            userType: 'n/a',
             category: 'core'
         };
     }
 
-    /** Statically declare dependencies */
-    static getDependencies() {
-        return [];
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "momentum_20d_pct": { "type": "number" }
+            },
+            "required": ["momentum_20d_pct"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * Helper to parse price data from the { instrumentId, prices: { '2025-10-01': 123 } } format
-     * and return a sorted list.
-     */
-    _getPrices(priceData) {
-        if (!priceData || !priceData.prices) {
-            return [];
+    _findPriceOnOrBefore(priceHistoryObj, targetDateStr) {
+        if (!priceHistoryObj || !priceHistoryObj.prices) return null;
+        
+        let checkDate = new Date(targetDateStr + 'T00:00:00Z');
+        for (let i = 0; i < 5; i++) { 
+            const str = checkDate.toISOString().slice(0, 10);
+            const price = priceHistoryObj.prices[str];
+            if (price !== undefined && price !== null && price > 0) return price;
+            checkDate.setUTCDate(checkDate.getUTCDate() - 1);
         }
-        // FIX: Correctly parse and sort price data
-        return Object.entries(priceData.prices)
-            .map(([date, price]) => ({ date, price }))
-            .sort((a, b) => new Date(a.date) - new Date(b.date));
+        return null;
     }
 
-    /**
-     * process (FIXED for 5-arg META signature)
-     * Arg 1: metaPayload (contains all root data from worker's "HACK" fix)
-     * Arg 2: metaRootData (production compliance, unused in test)
-     * Arg 3: dependencies (logger, etc., unused in test)
-     * Arg 4: config (mappings)
-     * Arg 5: fetchedDependencies (unused)
-     */
-    process(metaPayload, metaRootData, dependencies, config, fetchedDependencies) {
-        const results = {};
+    process(context) {
+        const { mappings, prices, date } = context;
+        const { instrumentToTicker } = mappings;
+        
+        // Use historical price data available in context
+        const priceData = prices?.history || []; 
         
-        // FIX: Read from metaPayload (Arg 1) passed by worker.js
-        // We only need today's data, which contains the 90-day history
-        const allPriceData = metaPayload.priceData || [];
-        const { instrumentToTicker } = config; // Read from Arg 4
+        const todayStr = date.today;
+        const todayDate = new Date(todayStr + 'T00:00:00Z');
+        const twentyDaysAgo = new Date(todayDate);
+        twentyDaysAgo.setUTCDate(todayDate.getUTCDate() - 20);
+        const oldStr = twentyDaysAgo.toISOString().slice(0, 10);
 
-        for (const instrumentData of allPriceData) {
-            const { instrumentId } = instrumentData;
+        const results = {};
+
+        for (const p of priceData) {
+            const instrumentId = p.instrumentId;
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
-            
-            const prices = this._getPrices(instrumentData);
-            
-            if (prices.length >= 20) {
-                const currentPrice = prices[prices.length - 1].price;
-                const price20DaysAgo = prices[prices.length - 20].price;
 
-                if (price20DaysAgo > 0) {
-                    const changePct = ((currentPrice - price20DaysAgo) / price20DaysAgo) * 100;
-                    results[ticker] = {
-                        momentum_20d_pct: isFinite(changePct) ? changePct : 0
-                    };
-                } else {
-                    results[ticker] = { momentum_20d_pct: 0 };
-                }
+            const currentPrice = this._findPriceOnOrBefore(p, todayStr);
+            const oldPrice = this._findPriceOnOrBefore(p, oldStr);
+
+            if (currentPrice && oldPrice && oldPrice > 0) {
+                const momPct = ((currentPrice - oldPrice) / oldPrice) * 100;
+                results[ticker] = {
+                    momentum_20d_pct: isFinite(momPct) ? momPct : 0
+                };
             } else {
                 results[ticker] = { momentum_20d_pct: 0 };
             }
         }
         this.result = results;
     }
-    
-    async getResult() {
-        return this.result;
-    }
 
-    reset() {
-        this.result = {};
-    }
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
 }
-
 module.exports = InstrumentPriceMomentum20D;