aiden-shared-calculations-unified 1.0.86 → 1.0.87

package/calculations/core/price-metrics.js

@@ -1,199 +1,46 @@
 /**
  * @fileoverview Calculation (Pass 1 - Meta) for historical price metrics.
- * --- FIX ---
- * - Changed 'type' from 'standard' to 'meta'.
- * - Rewrote 'process' to use the 5-arg 'meta' signature.
- * - Removed 'calculationUtils.loadAllPriceData()' (not in harness).
- * - Logic now reads 'priceData' from Arg 1 (metaPayload) and
- * mappings from Arg 4 (config), as provided by the fixed worker.
- * * --- ** THIS IS THE FIX FOR THE EMPTY RESULT ** ---
- * - Updated _findPriceOnOrBefore to look inside the 'prices' object
- * (e.g., priceHistoryObj.prices[checkDateStr]) to match the
- * data-generator.js and 'instrument-price-momentum-20d.js' structure.
+ * REFACTORED: Uses process(context) solely.
  */
-
 const RANGES = [7, 30, 90, 365];
 const TRADING_DAYS_PER_YEAR = 252;
-const MAX_LOOKBACK_DAYS = 5; 
 
 class CorePriceMetrics {
-
     constructor() {
         this.result = { by_instrument: {}, by_sector: {} };
     }
 
-    // --- THIS IS THE FIX (Part 1) ---
     static getMetadata() {
         return {
-            type: 'meta', // Must be meta to access all price data
-            rootDataDependencies: ['price'], // Request price data
-            isHistorical: true, // Needs up to 365d of price history
+            type: 'meta',
+            rootDataDependencies: ['price'],
+            isHistorical: true,
             userType: 'n/a',
             category: 'core_metrics'
         };
     }
-    // --- END FIX (Part 1) ---
 
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
     static getSchema() {
-        // [Schema omitted for brevity]
         return {
             "type": "object",
-            "description": "Calculates risk/return metrics (StdDev, Sharpe, Vol, Drawdown) for instruments and sectors.",
             "properties": { "by_instrument": { "type": "object" }, "by_sector": { "type": "object" } },
             "required": ["by_instrument", "by_sector"]
         };
     }
 
-    // --- THIS IS THE FIX (Part 2) ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-
-        // Get mappings from Arg 4 (config)
-        const { instrumentToTicker, sectorMapping } = config; 
-
-        // Get price data from Arg 1 (dateStr is metaPayload)
-        const priceData = dateStr.priceData;
-        // Get today's date from Arg 1
-        const todayDateStr = dateStr.date;
-
-        if (!priceData || priceData.length === 0 || !instrumentToTicker || !sectorMapping || !todayDateStr) {
-            this.result = { by_instrument: {}, by_sector: {} };
-            return;
-        }
-
-        const by_instrument = {};
-
-        // 1. Calculate Per-Instrument Metrics
-        for (const p of priceData) {
-            const instrumentId = p.instrumentId;
-            const ticker = instrumentToTicker[instrumentId];
-            if (!ticker) continue; 
-
-            // 'p' is the price entry, which is the object with 'prices: { ... }'
-            const priceHistoryObj = p; 
-            const instrumentMetrics = {};
-
-            for (const range of RANGES) {
-                instrumentMetrics[`stdev_${range}d`] = null;
-                instrumentMetrics[`volatility_annualized_${range}d`] = null;
-                instrumentMetrics[`sharpe_ratio_${range}d`] = null;
-                instrumentMetrics[`max_drawdown_${range}d`] = null;
-            }
-
-            for (const range of RANGES) {
-                // Pass the raw price object (p)
-                const priceArray = this._getHistoricalPriceArray(priceHistoryObj, todayDateStr, range + 1);
-                if (priceArray.length < 2) continue; 
-
-                instrumentMetrics[`max_drawdown_${range}d`] = this._calculateMaxDrawdown(priceArray);
-
-                const dailyReturns = this._calculateDailyReturns(priceArray);
-                if (dailyReturns.length < 2) continue;
-
-                const meanReturn = this._calculateMean(dailyReturns);
-                const stdDev = this._calculateStdDev(dailyReturns, meanReturn);
-
-                instrumentMetrics[`stdev_${range}d`] = stdDev;
-
-                if (stdDev > 0) {
-                    instrumentMetrics[`sharpe_ratio_${range}d`] = (meanReturn / stdDev) * Math.sqrt(TRADING_DAYS_PER_YEAR);
-                    instrumentMetrics[`volatility_annualized_${range}d`] = stdDev * Math.sqrt(TRADING_DAYS_PER_YEAR);
-                } else {
-                    instrumentMetrics[`sharpe_ratio_${range}d`] = 0;
-                    instrumentMetrics[`volatility_annualized_${range}d`] = 0;
-                }
-            }
-
-            by_instrument[ticker] = instrumentMetrics;
-        }
-
-        // 2. Calculate Sector Aggregates
-        const by_sector = this._aggregateMetricsBySector(by_instrument, instrumentToTicker, sectorMapping);
-
-        this.result = {
-            by_instrument,
-            by_sector,
-        };
-    }
-    // --- END FIX (Part 2) ---
-
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
-
-    reset() {
-        this.result = { by_instrument: {}, by_sector: {} };
-    }
-
-    _aggregateMetricsBySector(by_instrument, instrumentToTicker, instrumentToSector) {
-        const sectorAggregates = {};
-        const tickerToInstrument = Object.fromEntries(Object.entries(instrumentToTicker).map(([id, ticker]) => [ticker, id]));
-
-        for (const ticker in by_instrument) {
-            const instrumentId = tickerToInstrument[ticker];
-            const sector = instrumentToSector[instrumentId] || "Unknown";
-            const metrics = by_instrument[ticker];
-
-            if (!sectorAggregates[sector]) {
-                sectorAggregates[sector] = { metrics: {}, counts: {} };
-            }
-
-            for (const metricName in metrics) {
-                const value = metrics[metricName];
-                if (value !== null && typeof value === 'number' && isFinite(value)) {
-                    if (!sectorAggregates[sector].metrics[metricName]) {
-                        sectorAggregates[sector].metrics[metricName] = 0;
-                        sectorAggregates[sector].counts[metricName] = 0;
-                    }
-                    sectorAggregates[sector].metrics[metricName] += value;
-                    sectorAggregates[sector].counts[metricName]++;
-                }
-            }
-        }
-
-        const by_sector = {};
-        for (const sector in sectorAggregates) {
-            by_sector[sector] = {};
-            const agg = sectorAggregates[sector];
-            const allMetricNames = Object.keys(agg.metrics);
-
-            for (const metricName of allMetricNames) {
-                const count = agg.counts[metricName];
-                if (count > 0) {
-                    by_sector[sector][`average_${metricName}`] = agg.metrics[metricName] / count;
-                } else {
-                    by_sector[sector][`average_${metricName}`] = null;
-                }
-            }
-        }
-        return by_sector;
-    }
-
-    // --- THIS IS THE FIX FOR THE EMPTY RESULT ---
     _findPriceOnOrBefore(priceHistoryObj, dateStr) {
-        // Add a safety check for the nested 'prices' object
         if (!priceHistoryObj || !priceHistoryObj.prices) return null;
-        
         let checkDate = new Date(dateStr + 'T00:00:00Z');
-        for (let i = 0; i < MAX_LOOKBACK_DAYS; i++) {
+        for (let i = 0; i < 5; i++) {
             const checkDateStr = checkDate.toISOString().slice(0, 10);
-
-            // ** THE FIX **
-            // Was: priceHistoryObj[`prices.${checkDateStr}`]
-            // Is:  priceHistoryObj.prices[checkDateStr]
-            const price = priceHistoryObj.prices[checkDateStr]; 
-            
-            if (price !== undefined && price !== null && price > 0) {
-                return price; // Found it
-            }
+            const price = priceHistoryObj.prices[checkDateStr];
+            if (price !== undefined && price !== null && price > 0) return price;
             checkDate.setUTCDate(checkDate.getUTCDate() - 1);
         }
         return null;
     }
-    // --- END FIX ---
 
     _getHistoricalPriceArray(priceHistoryObj, endDateStr, numDays) {
         const prices = [];
@@ -203,68 +50,110 @@ class CorePriceMetrics {
         for (let i = 0; i < numDays; i++) {
             const targetDateStr = currentDate.toISOString().slice(0, 10);
             let price = this._findPriceOnOrBefore(priceHistoryObj, targetDateStr);
+            if (price === null) price = lastPrice; 
+            else lastPrice = price;
 
-            if (price === null) {
-                price = lastPrice; 
-            } else {
-                lastPrice = price;
-            }
-
-            if (price !== null) {
-                prices.push(price);
-            }
-
+            if (price !== null) prices.push(price);
             currentDate.setUTCDate(currentDate.getUTCDate() - 1);
         }
-
         return prices.reverse().filter(p => p !== null);
     }
 
-    _calculateMean(arr) {
-        if (!arr || arr.length === 0) return 0;
-        const sum = arr.reduce((acc, val) => acc + val, 0);
-        return sum / arr.length;
-    }
+    _calculateStats(priceArray) {
+        if (priceArray.length < 2) return { stdDev: 0, mean: 0, drawdown: 0 };
 
-    _calculateStdDev(arr, mean) {
-        if (!arr || arr.length < 2) return 0;
-        const avg = mean === undefined ? this._calculateMean(arr) : mean;
-        const variance = arr.reduce((acc, val) => acc + (val - avg) ** 2, 0) / (arr.length - 1);
-        return Math.sqrt(variance);
-    }
+        // Drawdown
+        let maxDrawdown = 0, peak = -Infinity;
+        for (const price of priceArray) {
+            if (price > peak) peak = price;
+            if (peak > 0) {
+                const dd = (price - peak) / peak;
+                if (dd < maxDrawdown) maxDrawdown = dd;
+            }
+        }
 
-    _calculateDailyReturns(prices) {
+        // Returns & StdDev
         const returns = [];
-        for (let i = 1; i < prices.length; i++) {
-            const prevPrice = prices[i - 1];
-            const currPrice = prices[i];
-            if (prevPrice !== 0 && prevPrice !== null && currPrice !== null) {
-                returns.push((currPrice - prevPrice) / prevPrice);
-            } else {
-                returns.push(0);
-            }
+        for (let i = 1; i < priceArray.length; i++) {
+            const prev = priceArray[i - 1];
+            const curr = priceArray[i];
+            returns.push(prev > 0 ? (curr - prev) / prev : 0);
         }
-        return returns;
+        const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
+        const variance = returns.reduce((a, b) => a + (b - mean) ** 2, 0) / (returns.length - 1);
+
+        return { stdDev: Math.sqrt(variance), mean, drawdown: maxDrawdown };
     }
 
-    _calculateMaxDrawdown(prices) {
-        if (!prices || prices.length < 2) return 0;
-        let maxDrawdown = 0;
-        let peak = -Infinity;
+    process(context) {
+        const { mappings, prices, date } = context;
+        const { instrumentToTicker, sectorMapping } = mappings;
+        
+        // Uses history from context
+        const priceData = prices?.history;
+        const todayDateStr = date.today;
+
+        if (!priceData || !todayDateStr) {
+            this.result = { by_instrument: {}, by_sector: {} };
+            return;
+        }
 
-        for (const price of prices) {
-            if (price > peak) {
-                peak = price;
+        const by_instrument = {};
+        const tickerToInstrument = {};
+
+        for (const p of priceData) {
+            const ticker = instrumentToTicker[p.instrumentId];
+            if (!ticker) continue;
+            tickerToInstrument[ticker] = p.instrumentId;
+
+            const metrics = {};
+            for (const range of RANGES) {
+                const priceArray = this._getHistoricalPriceArray(p, todayDateStr, range + 1);
+                const stats = this._calculateStats(priceArray);
+
+                metrics[`stdev_${range}d`] = stats.stdDev;
+                metrics[`max_drawdown_${range}d`] = stats.drawdown;
+                metrics[`volatility_annualized_${range}d`] = stats.stdDev * Math.sqrt(TRADING_DAYS_PER_YEAR);
+                metrics[`sharpe_ratio_${range}d`] = stats.stdDev > 0 
+                    ? (stats.mean / stats.stdDev) * Math.sqrt(TRADING_DAYS_PER_YEAR) 
+                    : 0;
             }
-            if (peak > 0) { 
-                const drawdown = (price - peak) / peak;
-                if (drawdown < maxDrawdown) {
-                    maxDrawdown = drawdown;
+            by_instrument[ticker] = metrics;
+        }
+
+        // Sector Aggregation
+        const sectorAggs = {};
+        for (const ticker in by_instrument) {
+            const instId = tickerToInstrument[ticker];
+            const sector = sectorMapping[instId] || "Unknown";
+            if (!sectorAggs[sector]) sectorAggs[sector] = { metrics: {}, counts: {} };
+
+            const data = by_instrument[ticker];
+            for (const key in data) {
+                if (!sectorAggs[sector].metrics[key]) {
+                    sectorAggs[sector].metrics[key] = 0;
+                    sectorAggs[sector].counts[key] = 0;
+                }
+                if (data[key] !== null) {
+                    sectorAggs[sector].metrics[key] += data[key];
+                    sectorAggs[sector].counts[key]++;
                 }
             }
         }
-        return isFinite(maxDrawdown) ? maxDrawdown : 0;
+
+        const by_sector = {};
+        for (const sector in sectorAggs) {
+            by_sector[sector] = {};
+            for (const key in sectorAggs[sector].metrics) {
+                const count = sectorAggs[sector].counts[key];
+                by_sector[sector][`average_${key}`] = count > 0 ? sectorAggs[sector].metrics[key] / count : null;
+            }
+        }
+
+        this.result = { by_instrument, by_sector };
     }
-}
 
+    async getResult() { return this.result; }
+    reset() { this.result = { by_instrument: {}, by_sector: {} }; }
+}
 module.exports = CorePriceMetrics;

package/calculations/core/profitability-ratio-per-sector.js

@@ -1,23 +1,13 @@
 /**
- * @fileoverview Calculation (Pass 1) for P&L.
- *
- * This metric provides the profitability ratio (profitable positions /
- * unprofitable positions) for all open positions, grouped by sector.
+ * @fileoverview Calculation (Pass 1) for profitability ratio per sector.
+ * REFACTORED: Counts (No USD involved).
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class ProfitabilityRatioPerSector {
     constructor() {
-        // We will store { [sectorName]: { profitable: 0, unprofitable: 0 } }
-        // --- STANDARD 0: RENAMED ---
         this.sectorData = new Map();
-        // --- STANDARD 0: RENAMED ---
-        this.sectorMap = null; // This will hold InstID -> SectorName
+        this.sectorMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
@@ -28,101 +18,66 @@ class ProfitabilityRatioPerSector {
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const sectorSchema = {
             "type": "object",
             "properties": {
-                "ratio": {
-                    "type": ["number", "null"],
-                    "description": "Ratio of profitable to unprofitable positions (profitable / unprofitable). Null if 0 unprofitable."
-                },
+                "profitability_ratio": { "type": ["number", "null"] },
                 "profitable_count": { "type": "number" },
                 "unprofitable_count": { "type": "number" }
             },
-            "required": ["ratio", "profitable_count", "unprofitable_count"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the profitability ratio (profitable/unprofitable positions) per sector.",
-            "patternProperties": {
-                "^.*$": sectorSchema // Sector Name
-            },
-            "additionalProperties": sectorSchema
+            "required": ["profitability_ratio", "profitable_count", "unprofitable_count"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": sectorSchema } };
     }
 
-    _initSector(sectorName) {
-        if (!this.sectorData.has(sectorName)) {
-            this.sectorData.set(sectorName, { profitable: 0, unprofitable: 0 });
+    _initSector(sector) {
+        if (!this.sectorData.has(sector)) {
+            this.sectorData.set(sector, { profitable: 0, unprofitable: 0 });
         }
     }
 
-    // --- STANDARD 0: UPDATED (no longer async) ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: FIXED ---
-        if (!this.sectorMap) {
-            // Load mappings on first process call from the standard context
-            this.sectorMap = context.sectorMapping;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.sectorMap) this.sectorMap = mappings.sectorMapping;
 
-        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!positions || !Array.isArray(positions) || !this.sectorMap) {
-            return;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            const pnl = pos.NetProfit;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
 
-            if (!instrumentId || typeof pnl !== 'number') {
-                continue;
-            }
-            
-            // --- STANDARD 0: FIXED ---
-            // Use the standard InstID -> SectorName map
-            const sectorName = this.sectorMap[instrumentId] || 'N/A';
-            this._initSector(sectorName);
-            const data = this.sectorData.get(sectorName);
+            const sector = this.sectorMap[instId] || 'Unknown';
+            const pnl = extract.getNetProfit(pos);
 
-            // Tally
-            if (pnl > 0) {
-                data.profitable++;
-            } else if (pnl < 0) {
-                data.unprofitable++;
-            }
+            this._initSector(sector);
+            const data = this.sectorData.get(sector);
+
+            if (pnl > 0) data.profitable++;
+            else if (pnl < 0) data.unprofitable++;
         }
     }
 
-    getResult() {
+    async getResult() {
         const result = {};
-        for (const [sectorName, data] of this.sectorData.entries()) {
-            const { profitable, unprofitable } = data;
-            
-            result[sectorName] = {
-                ratio: (unprofitable > 0) ? (profitable / unprofitable) : null,
-                profitable_count: profitable,
-                unprofitable_count: unprofitable
-            };
+        for (const [sector, data] of this.sectorData.entries()) {
+            if (data.profitable > 0 || data.unprofitable > 0) {
+                result[sector] = {
+                    profitability_ratio: (data.unprofitable > 0) ? (data.profitable / data.unprofitable) : null,
+                    profitable_count: data.profitable,
+                    unprofitable_count: data.unprofitable
+                };
+            }
         }
         return result;
     }
 
     reset() {
         this.sectorData.clear();
-        // --- STANDARD 0: RENAMED ---
-        this.sectorMap = null; // Reset mappings
+        this.sectorMap = null;
     }
 }
-
 module.exports = ProfitabilityRatioPerSector;