aiden-shared-calculations-unified 1.0.84 → 1.0.87

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;

package/calculations/core/long-position-per-stock.js

@@ -1,112 +1,83 @@
 /**
  * @fileoverview Calculation (Pass 1) for long positions per stock.
- *
- * This metric answers: "How many long ('buy') positions
- * are there for each stock?"
+ * REFACTORED: Uses context.math.extract. No USD.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class LongPositionPerStock {
     constructor() {
-        // We will store { [instrumentId]: count }
-        this.assets = new Map();
-        // --- STANDARD 0: RENAMED ---
+        this.stockData = new Map();
         this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
             userType: 'all',
-            category: 'core_sentiment' // Based on Computation_documentation.md (short_and_long_stats -> sentiment_per_stock)
+            category: 'core_sentiment'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        return {
+        const schema = {
             "type": "object",
-            "description": "Calculates the total count of long ('buy') positions for each asset.",
-            "patternProperties": {
-                // Ticker
-                "^.*$": {
-                    "type": "number",
-                    "description": "The total count of long positions for this asset."
-                }
+            "properties": {
+                "long_count": { "type": "number" },
+                "total_long_exposure_weight": { "type": "number" }
             },
-            "additionalProperties": {
-                "type": "number"
-            }
+            "required": ["long_count", "total_long_exposure_weight"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
     }
 
-    _initAsset(instrumentId) {
-        if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, 0);
+    _initStock(instId) {
+        if (!this.stockData.has(instId)) {
+            this.stockData.set(instId, { count: 0, weight: 0 });
         }
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: ADDED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        // --- STANDARD 0: UPDATED ---
-        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            // Only count 'buy' (long) positions
-            if (pos.IsBuy) {
-                const instrumentId = pos.InstrumentID;
-                if (!instrumentId) continue;
-                
-                this._initAsset(instrumentId);
-                this.assets.set(instrumentId, this.assets.get(instrumentId) + 1);
-            }
-        }
-    }
+            if (extract.getDirection(pos) !== 'Buy') continue;
 
-    async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
 
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
+            const weight = extract.getPositionWeight(pos, user.type);
+
+            this._initStock(instId);
+            const data = this.stockData.get(instId);
+            data.count++;
+            data.weight += weight;
         }
+    }
 
+    async getResult() {
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const [instrumentId, count] of this.assets.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-            result[ticker] = count;
+        for (const [instId, data] of this.stockData.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
+            if (data.count > 0) {
+                result[ticker] = {
+                    long_count: data.count,
+                    total_long_exposure_weight: data.weight
+                };
+            }
         }
         return result;
     }
 
     reset() {
-        this.assets.clear();
-        // --- STANDARD 0: RENAMED ---
+        this.stockData.clear();
         this.tickerMap = null;
     }
 }
-
 module.exports = LongPositionPerStock;

package/calculations/core/overall-holding-duration.js

@@ -1,108 +1,37 @@
 /**
  * @fileoverview Calculation (Pass 1) for user behaviour.
- *
- * This metric answers: "What is the average holding duration (in hours)
- * for *closed* positions, averaged across all users?"
- *
- * It uses the 'history' data source's 'all' object.
+ * REFACTORED: Uses context.math.history.getDailyHistory().
  */
 class AverageHoldingDurationOverall {
-    constructor() {
-        // Stores all the user-level average durations
-        this.durationsHours = [];
-    }
+    constructor() { this.durationsHours = []; }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['history'], // Needs the history doc
-            isHistorical: false, // Needs today's history doc
-            userType: 'all',
-            category: 'core_metrics'
-        };
-    }
-
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
+        return { type: 'standard', rootDataDependencies: ['history'], isHistorical: false, userType: 'all', category: 'core_metrics' };
     }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
+    static getDependencies() { return []; }
     static getSchema() {
-        return {
-            "type": "object",
-            "description": "Calculates the platform-wide average holding duration (in hours) for closed positions.",
-            "properties": {
-                "average_duration_hours": {
-                    "type": "number",
-                    "description": "The average holding duration in hours, averaged across all users."
-                },
-                "user_count": {
-                    "type": "number",
-                    "description": "The number of users included in the average."
-                }
-            },
-            "required": ["average_duration_hours", "user_count"]
-        };
+        return { "type": "object", "properties": { "average_duration_hours": { "type": "number" }, "user_count": { "type": "number" } }, "required": ["average_duration_hours", "user_count"] };
     }
 
-    // --- REFACTORED ---
-    /**
-     * Process data from the 'history' root data source.
-     * @param {object} todayPortfolio - Contains today's history doc
-     * @param {object} yesterdayPortfolio - (Not used)
-     * @param {string} userId - The user ID.
-     */
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        
-        // ---
-        // 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 todayPortfolio?.history
-        if (!historyData || !historyData.all) {
-            return;
-        }
+    process(context) {
+        const { history } = context.math;
+        const { user } = context;
 
-        // 2. Get the user's overall average holding time
-        const durationMinutes = historyData.all.avgHoldingTimeInMinutes;
+        // V4: Strict Access via Math Layer
+        const historyDoc = history.getDailyHistory(user);
+        const summary = history.getSummary(historyDoc);
 
-        if (typeof durationMinutes === 'number' && durationMinutes > 0) {
-            this.durationsHours.push(durationMinutes / 60);
+        if (summary && summary.avgHoldingTimeInMinutes > 0) {
+            this.durationsHours.push(summary.avgHoldingTimeInMinutes / 60);
         }
     }
 
     getResult() {
         const count = this.durationsHours.length;
-        if (count === 0) {
-            return {
-                average_duration_hours: 0,
-                user_count: 0
-            };
-        }
-
+        if (count === 0) return { average_duration_hours: 0, user_count: 0 };
         const sum = this.durationsHours.reduce((a, b) => a + b, 0);
-        
-        return {
-            average_duration_hours: sum / count,
-            user_count: count
-        };
-    }
-
-    reset() {
-        this.durationsHours = [];
+        return { average_duration_hours: sum / count, user_count: count };
     }
+    reset() { this.durationsHours = []; }
 }
-
 module.exports = AverageHoldingDurationOverall;

package/calculations/core/overall-profitability-ratio.js

@@ -1,9 +1,6 @@
 /**
  * @fileoverview Calculation (Pass 1) for P&L.
- *
- * This metric provides the *overall* platform-wide profitability ratio
- * (total profitable positions / total unprofitable positions)
- * across all users and all open positions.
+ * REFACTORED: Standardized extraction.
  */
 class ProfitabilityRatioOverall {
     constructor() {
@@ -11,10 +8,6 @@ class ProfitabilityRatioOverall {
         this.unprofitable = 0;
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
@@ -25,50 +18,28 @@ class ProfitabilityRatioOverall {
         };
     }
 
-    // --- 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 overall profitability ratio (profitable/unprofitable positions) for the entire platform.",
             "properties": {
-                "overall_ratio": {
-                    "type": ["number", "null"],
-                    "description": "Ratio of profitable to unprofitable positions (profitable / unprofitable). Null if 0 unprofitable."
-                },
-                "total_profitable": {
-                    "type": "number",
-                    "description": "Total count of all profitable positions."
-                },
-                "total_unprofitable": {
-                    "type": "number",
-                    "description": "Total count of all unprofitable positions."
-                }
+                "overall_ratio": { "type": ["number", "null"] },
+                "total_profitable": { "type": "number" },
+                "total_unprofitable": { "type": "number" }
             },
             "required": ["overall_ratio", "total_profitable", "total_unprofitable"]
         };
     }
 
-    // --- REFACTORED ---
-    // Simplified signature
-    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) {
-            const pnl = pos.NetProfit;
+            const pnl = extract.getNetProfit(pos); // This is a %
 
             if (pnl > 0) {
                 this.profitable++;