aiden-shared-calculations-unified 1.0.83 → 1.0.84

package/calculations/core/speculator-leverage-per-sector.js

@@ -1,19 +1,19 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
+ * @fileoverview Calculation (Pass 1) for speculator leverage.
  *
- * This metric answers: "For each sector, what is the
- * distribution of leverage levels used by speculators?"
+ * This metric answers: "For each sector, what is the average
+ * leverage used by speculators?"
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
-class LeveragePerSector {
+class SpeculatorLeveragePerSector {
     constructor() {
-        // { [sector]: { [leverage]: count } }
+        // { [sectorName]: { sum: 0, count: 0 } }
         this.sectors = new Map();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.sectorMap = null;
     }
 
-    // --- NEW ---
     /**
      * Statically defines all metadata for the manifest builder.
      */
@@ -22,12 +22,11 @@ class LeveragePerSector {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator',
+            userType: 'speculator', // <-- KEY: Only runs for speculators
             category: 'core_speculator'
         };
     }
 
-    // --- NEW ---
     /**
      * Statically declare dependencies.
      */
@@ -37,92 +36,81 @@ class LeveragePerSector {
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
-        const leverageSchema = {
+        const sectorSchema = {
             "type": "object",
-            "description": "Distribution of leverage levels for this sector.",
-            "patternProperties": {
-                // Leverage level, e.g., "1x", "5x", "inf"
-                "^[0-9inf]+x$": {
-                    "type": "number",
-                    "description": "Count of positions at this leverage."
-                }
+            "properties": {
+                "avg_leverage": { "type": "number" },
+                "position_count": { "type": "number" }
             },
-            "additionalProperties": { "type": "number" }
+            "required": ["avg_leverage", "position_count"]
         };
 
         return {
             "type": "object",
-            "description": "Calculates the distribution of leverage levels used by speculators for each sector.",
-            "patternProperties": {
-                "^.*$": leverageSchema // Sector
-            },
-            "additionalProperties": leverageSchema
+            "description": "Calculates the average leverage used by speculators for each sector.",
+            "patternProperties": { "^.*$": sectorSchema },
+            "additionalProperties": sectorSchema
         };
     }
 
-    _initSector(sector) {
-        if (!this.sectors.has(sector)) {
-            this.sectors.set(sector, {
-                '1x': 0,
-                '2x': 0,
-                '5x': 0,
-                '10x': 0,
-                'inf': 0 // For other leverages
-            });
-        }
-    }
-    
-    _getLeverageBucket(leverage) {
-        switch (leverage) {
-            case 1: return '1x';
-            case 2: return '2x';
-            case 5: return '5x';
-            case 10: return '10x';
-            default: return 'inf';
+    _initSector(sectorName) {
+        if (!this.sectors.has(sectorName)) {
+            this.sectors.set(sectorName, { sum: 0, count: 0 });
         }
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
+    // --- STANDARD 0: UPDATED SIGNATURE ---
+    async process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: FIXED ---
+        if (!this.sectorMap) {
+            this.sectorMap = context.sectorMapping;
         }
-        
-        if (!this.mappings) {
-            this.mappings = context.mappings;
-        }
-        
-        const positions = portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions) || !this.mappings) {
+
+        const positions = todayPortfolio.PublicPositions;
+        if (!positions || !Array.isArray(positions) || !this.sectorMap) {
             return;
         }
 
         for (const pos of positions) {
             const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
+            const leverage = pos.Leverage;
             
-            const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
-            this._initSector(sector);
-            const sectorData = this.sectors.get(sector);
+            if (!instrumentId || !leverage || leverage <= 1) {
+                continue; // Only care about leveraged positions
+            }
             
-            const leverage = pos.Leverage || 1;
-            const key = this._getLeverageBucket(leverage);
+            // --- STANDARD 0: FIXED ---
+            const sectorName = this.sectorMap[instrumentId] || 'N/A';
+            this._initSector(sectorName);
+            const sectorData = this.sectors.get(sectorName);
             
-            sectorData[key]++;
+            sectorData.sum += leverage;
+            sectorData.count++;
         }
     }
 
     async getResult() {
-        // Convert Map to plain object
-        return Object.fromEntries(this.sectors);
+        // --- STANDARD 0: REMOVED forbidden data load ---
+
+        const result = {};
+        for (const [sectorName, data] of this.sectors.entries()) {
+            if (data.count > 0) {
+                result[sectorName] = {
+                    avg_leverage: data.sum / data.count,
+                    position_count: data.count
+                };
+            }
+        }
+        return result;
     }
 
     reset() {
         this.sectors.clear();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.sectorMap = null;
     }
 }
 
-module.exports = LeveragePerSector;
+module.exports = SpeculatorLeveragePerSector;

package/calculations/core/speculator-risk-reward-ratio-per-asset.js

@@ -1,124 +1,119 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "What is the average Risk/Reward
- * ratio (based on SL/TP) for speculator positions on each asset?"
+ * @fileoverview Calculation (Pass 1) for speculator R/R.
+ * --- FIX ---
+ * - Rewritten logic to calculate R/R from raw schema fields
+ * (OpenRate, StopLossRate, TakeProfitRate) instead of non-existent
+ * 'PctTo...' fields.
+ * - Updated process signature to match worker.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
-class RiskRewardRatioPerAsset {
+class SpeculatorRiskRewardRatioPerAsset {
     constructor() {
-        // { [instrumentId]: { sum_rr: 0, count: 0 } }
         this.assets = new Map();
-        this.mappings = null;
+        this.tickerMap = null;
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "avg_rr_ratio": {
-                    "type": "number",
-                    "description": "Average Risk/Reward ratio (Reward / Risk)."
-                },
-                "count": {
-                    "type": "number",
-                    "description": "Count of positions with both SL and TP set."
-                }
-            },
-            "required": ["avg_rr_ratio", "count"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the average Risk/Reward ratio from SL/TP settings for each asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
-        };
-    }
-
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator',
+            userType: 'speculator', // <-- KEY: Only runs for speculators
             category: 'core_speculator'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
         return [];
     }
 
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "avg_rr_ratio": { "type": ["number", "null"] },
+                "position_count": { "type": "number" }
+            },
+            "required": ["avg_rr_ratio", "position_count"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates the average Risk/Reward ratio at entry for speculators per asset.",
+            "patternProperties": { "^.*$": tickerSchema },
+            "additionalProperties": tickerSchema
+        };
+    }
+
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, { sum_rr: 0, count: 0 });
+            this.assets.set(instrumentId, { sum: 0, count: 0 });
         }
     }
 
-    process(portfolioData) {
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
+    // --- THIS IS THE FIX ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
         }
-        
-        const positions = portfolioData.PublicPositions;
+
+        const positions = todayPortfolio.PublicPositions;
         if (!positions || !Array.isArray(positions)) {
             return;
         }
 
         for (const pos of positions) {
             const instrumentId = pos.InstrumentID;
-            const sl_rate = pos.StopLossRate || 0;
-            const tp_rate = pos.TakeProfitRate || 0;
-            const open_rate = pos.OpenRate || 0;
-            
-            // Need all three to calculate R/R
-            if (!instrumentId || sl_rate === 0 || tp_rate === 0 || open_rate === 0) {
-                continue;
+            const slRate = pos.StopLossRate;
+            const tpRate = pos.TakeProfitRate;
+            const openRate = pos.OpenRate;
+
+            if (!instrumentId || !slRate || slRate <= 0 || !tpRate || tpRate <= 0 || !openRate || openRate <= 0) {
+                continue; // Must have SL, TP, and OpenRate
             }
-            
-            const risk = Math.abs(open_rate - sl_rate);
-            const reward = Math.abs(tp_rate - open_rate);
-            
-            if (risk === 0) {
-                continue; // Cannot divide by zero
+
+            let risk = 0;
+            let reward = 0;
+
+            if (pos.IsBuy) {
+                // Long
+                risk = openRate - slRate;
+                reward = tpRate - openRate;
+            } else {
+                // Short
+                risk = slRate - openRate;
+                reward = openRate - tpRate;
+            }
+
+            // If risk or reward is negative/zero, it's an invalid R/R setup
+            if (risk <= 0 || reward <= 0) {
+                continue;
             }
-            
-            const rr_ratio = reward / risk;
-            
+
             this._initAsset(instrumentId);
             const assetData = this.assets.get(instrumentId);
-            assetData.sum_rr += rr_ratio;
+
+            const rrRatio = reward / risk;
+
+            assetData.sum += rrRatio;
             assetData.count++;
         }
     }
+    // --- END FIX ---
 
     async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        if (!this.tickerMap) {
+            return {}; 
         }
 
         const result = {};
         for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
+
             if (data.count > 0) {
                 result[ticker] = {
-                    avg_rr_ratio: data.sum_rr / data.count,
-                    count: data.count
+                    avg_rr_ratio: data.sum / data.count,
+                    position_count: data.count
                 };
             }
         }
@@ -127,8 +122,8 @@ class RiskRewardRatioPerAsset {
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        this.tickerMap = null;
     }
 }
 
-module.exports = RiskRewardRatioPerAsset;
+module.exports = SpeculatorRiskRewardRatioPerAsset;

package/calculations/core/speculator-stop-loss-distance-by-sector-short-long-breakdown.js

@@ -1,140 +1,119 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "For each sector, what is the
- * average stop loss distance (in % and value) for
- * long and short positions?"
+ * @fileoverview Calculation (Pass 1) for speculator SL distance.
+ * --- FIX ---
+ * - Rewritten logic to calculate SL distance from raw schema fields
+ * (StopLossRate, CurrentRate) instead of 'PctToStopLoss'.
+ * - Updated process signature to match worker.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
-class StopLossDistanceBySectorShortLongBreakdown {
+class SpeculatorSLDistanceBySectorShortLong {
     constructor() {
-        // { [sector]: { long_pct: [], long_val: [], short_pct: [], short_val: [] } }
         this.sectors = new Map();
-        this.mappings = null;
+        this.sectorMap = null;
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator',
+            userType: 'speculator', // <-- KEY: Only runs for speculators
             category: 'core_speculator'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
         return [];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
         const sectorSchema = {
             "type": "object",
             "properties": {
-                "long_avg_dist_pct": { "type": "number" },
-                "long_avg_dist_val": { "type": "number" },
-                "long_count": { "type": "number" },
-                "short_avg_dist_pct": { "type": "number" },
-                "short_avg_dist_val": { "type": "number" },
-                "short_count": { "type": "number" }
-            },
-            "required": ["long_avg_dist_pct", "long_avg_dist_val", "long_count", "short_avg_dist_pct", "short_avg_dist_val", "short_count"]
+                "long_avg_distance_pct": { "type": "number" },
+                "long_position_count": { "type": "number" },
+                "short_avg_distance_pct": { "type": "number" },
+                "short_position_count": { "type": "number" }
+            }
         };
 
         return {
             "type": "object",
-            "description": "Calculates avg SL distance (% and value) for long/short positions, grouped by sector.",
-            "patternProperties": {
-                "^.*$": sectorSchema // Sector
-            },
+            "description": "Calculates the average distance to SL, broken down by long/short, per sector.",
+            "patternProperties": { "^.*$": sectorSchema },
             "additionalProperties": sectorSchema
         };
     }
 
-    _initSector(sector) {
-        if (!this.sectors.has(sector)) {
-            this.sectors.set(sector, {
-                long_pct: [], long_val: [], short_pct: [], short_val: []
-            });
+    _initSector(sectorName) {
+        if (!this.sectors.has(sectorName)) {
+            this.sectors.set(sectorName, { long_sum: 0, long_count: 0, short_sum: 0, short_count: 0 });
         }
     }
-    
-    _avg(arr) {
-        if (arr.length === 0) return 0;
-        return arr.reduce((a, b) => a + b, 0) / arr.length;
-    }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
+    // --- THIS IS THE FIX ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+        if (!this.sectorMap) {
+            this.sectorMap = context.sectorMapping;
         }
-        if (!this.mappings) {
-            this.mappings = context.mappings;
-        }
-        
-        const positions = portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions) || !this.mappings) {
+
+        const positions = todayPortfolio.PublicPositions;
+        if (!positions || !Array.isArray(positions) || !this.sectorMap) {
             return;
         }
 
         for (const pos of positions) {
             const instrumentId = pos.InstrumentID;
-            const sl_rate = pos.StopLossRate || 0;
-            const open_rate = pos.OpenRate || 0;
-            
-            if (!instrumentId || sl_rate === 0 || open_rate === 0) {
-                continue;
+            const slRate = pos.StopLossRate;
+            const currentRate = pos.CurrentRate;
+
+            if (!instrumentId || !slRate || slRate <= 0 || !currentRate || currentRate <= 0) {
+                continue; // No SL or invalid data
             }
-            
-            const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
-            this._initSector(sector);
-            const sectorData = this.sectors.get(sector);
-            
-            const distance_val = Math.abs(open_rate - sl_rate);
-            const distance_pct = (distance_val / open_rate) * 100;
-            
+
+            const sectorName = this.sectorMap[instrumentId] || 'N/A';
+            this._initSector(sectorName);
+            const sectorData = this.sectors.get(sectorName);
+
+            let pctToSL = 0;
             if (pos.IsBuy) {
-                sectorData.long_pct.push(distance_pct);
-                sectorData.long_val.push(distance_val);
+                // Long: (Current - SL) / Current
+                pctToSL = (currentRate - slRate) / currentRate;
+                if (pctToSL > 0) {
+                    sectorData.long_sum += (pctToSL * 100);
+                    sectorData.long_count++;
+                }
             } else {
-                sectorData.short_pct.push(distance_pct);
-                sectorData.short_val.push(distance_val);
+                // Short: (SL - Current) / Current
+                pctToSL = (slRate - currentRate) / currentRate;
+                if (pctToSL > 0) {
+                    sectorData.short_sum += (pctToSL * 100);
+                    sectorData.short_count++;
+                }
             }
         }
     }
+    // --- END FIX ---
 
     async getResult() {
         const result = {};
-        for (const [sector, data] of this.sectors.entries()) {
-            result[sector] = {
-                long_avg_dist_pct: this._avg(data.long_pct),
-                long_avg_dist_val: this._avg(data.long_val),
-                long_count: data.long_pct.length,
-                short_avg_dist_pct: this._avg(data.short_pct),
-                short_avg_dist_val: this._avg(data.short_val),
-                short_count: data.short_pct.length
-            };
+        for (const [sectorName, data] of this.sectors.entries()) {
+            if (data.long_count > 0 || data.short_count > 0) {
+                result[sectorName] = {
+                    long_avg_distance_pct: (data.long_count > 0) ? (data.long_sum / data.long_count) : 0,
+                    long_position_count: data.long_count,
+                    short_avg_distance_pct: (data.short_count > 0) ? (data.short_sum / data.short_count) : 0,
+                    short_position_count: data.short_count
+                };
+            }
         }
         return result;
     }
 
     reset() {
         this.sectors.clear();
-        this.mappings = null;
+        this.sectorMap = null;
     }
 }
 
-module.exports = StopLossDistanceBySectorShortLongBreakdown;
+module.exports = SpeculatorSLDistanceBySectorShortLong;