aiden-shared-calculations-unified 1.0.83 → 1.0.84

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

@@ -1,144 +1,124 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "For each ticker, 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 StopLossDistanceByTickerShortLongBreakdown {
+class SpeculatorSLDistanceByTickerShortLong {
     constructor() {
-        // { [instrumentId]: { long_pct: [], long_val: [], short_pct: [], short_val: [] } }
         this.assets = new Map();
-        this.mappings = null;
+        this.tickerMap = 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 tickerSchema = {
             "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 asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
+            "description": "Calculates the average distance to SL, broken down by long/short, per asset.",
+            "patternProperties": { "^.*$": tickerSchema },
             "additionalProperties": tickerSchema
         };
     }
 
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                long_pct: [], long_val: [], short_pct: [], short_val: []
-            });
+            this.assets.set(instrumentId, { 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;
-    }
 
-    // --- REFACTORED ---
-    // Simplified signature
-    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 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
             }
-            
+
             this._initAsset(instrumentId);
             const assetData = this.assets.get(instrumentId);
-            
-            const distance_val = Math.abs(open_rate - sl_rate);
-            const distance_pct = (distance_val / open_rate) * 100;
-            
+
+            let pctToSL = 0;
             if (pos.IsBuy) {
-                assetData.long_pct.push(distance_pct);
-                assetData.long_val.push(distance_val);
+                // Long: (Current - SL) / Current
+                pctToSL = (currentRate - slRate) / currentRate;
+                if (pctToSL > 0) {
+                    assetData.long_sum += (pctToSL * 100);
+                    assetData.long_count++;
+                }
             } else {
-                assetData.short_pct.push(distance_pct);
-                assetData.short_val.push(distance_val);
+                // Short: (SL - Current) / Current
+                pctToSL = (slRate - currentRate) / currentRate;
+                if (pctToSL > 0) {
+                    assetData.short_sum += (pctToSL * 100);
+                    assetData.short_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}`;
-            
-            result[ticker] = {
-                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
-            };
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
+
+            if (data.long_count > 0 || data.short_count > 0) {
+                result[ticker] = {
+                    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.assets.clear();
-        this.mappings = null;
+        this.tickerMap = null;
     }
 }
 
-module.exports = StopLossDistanceByTickerShortLongBreakdown;
+module.exports = SpeculatorSLDistanceByTickerShortLong;

package/calculations/core/speculator-stop-loss-per-asset.js

@@ -1,96 +1,64 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
+ * @fileoverview Calculation (Pass 1) for speculator SL usage.
  *
- * This metric answers: "For each asset, what is the
- * average stop loss level and the percentage of
- * positions that have a stop loss set?"
+ * This metric answers: "For each asset, what percentage
+ * of speculators are using a stop-loss?"
+ * --- FIX ---
+ * - Logic changed to check 'StopLossRate > 0' instead of 'PctToStopLoss >= 0'
+ * to match schema.md.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
-class StopLossPerAsset {
+class SpeculatorStopLossPerAsset {
     constructor() {
-        // { [instrumentId]: { sl_rate_sum: 0, sl_dist_sum: 0, sl_set_count: 0, total_count: 0 } }
         this.assets = new Map();
-        this.mappings = null;
+        this.tickerMap = 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 tickerSchema = {
             "type": "object",
             "properties": {
-                "avg_sl_rate": {
-                    "type": "number",
-                    "description": "Average SL price level (for positions with SL)."
-                },
-                "avg_sl_pct_dist": {
-                    "type": "number",
-                    "description": "Average SL distance from open price % (for positions with SL)."
-                },
-                "sl_set_count": { "type": "number" },
-                "total_count": { "type": "number" },
-                "sl_set_rate_pct": {
-                    "type": "number",
-                    "description": "Percentage of positions that have a SL set."
-                }
+                "sl_usage_pct": { "type": "number" },
+                "sl_count": { "type": "number" },
+                "total_count": { "type": "number" }
             },
-            "required": ["avg_sl_rate", "avg_sl_pct_dist", "sl_set_count", "total_count", "sl_set_rate_pct"]
+            "required": ["sl_usage_pct", "sl_count", "total_count"]
         };
 
         return {
             "type": "object",
-            "description": "Calculates the average SL level and usage rate per asset for speculators.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
+            "description": "Calculates the percentage of speculators using a stop-loss per asset.",
+            "patternProperties": { "^.*$": tickerSchema },
             "additionalProperties": tickerSchema
         };
     }
 
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                sl_rate_sum: 0,
-                sl_dist_sum: 0,
-                sl_set_count: 0,
-                total_count: 0
-            });
+            this.assets.set(instrumentId, { with_sl: 0, total: 0 });
         }
     }
 
-    // --- REFACTORED ---
-    // Simplified signature
-    process(portfolioData) {
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
         }
-        
-        const positions = portfolioData.PublicPositions;
+
+        const positions = todayPortfolio.PublicPositions;
         if (!positions || !Array.isArray(positions)) {
             return;
         }
@@ -98,50 +66,45 @@ class StopLossPerAsset {
         for (const pos of positions) {
             const instrumentId = pos.InstrumentID;
             if (!instrumentId) continue;
-            
+
             this._initAsset(instrumentId);
             const assetData = this.assets.get(instrumentId);
-            assetData.total_count++;
-            
-            const sl_rate = pos.StopLossRate || 0;
-            if (sl_rate > 0) {
-                assetData.sl_set_count++;
-                assetData.sl_rate_sum += sl_rate;
-                
-                const open_rate = pos.OpenRate || 0;
-                if (open_rate > 0) {
-                    const distance = Math.abs(open_rate - sl_rate);
-                    assetData.sl_dist_sum += (distance / open_rate);
-                }
+            assetData.total++;
+
+            // --- THIS IS THE FIX ---
+            // 'PctToStopLoss' is not in schema.md. 'StopLossRate' is.
+            // A rate > 0 indicates an SL is set.
+            if (pos.StopLossRate > 0) {
+            // --- END FIX ---
+                assetData.with_sl++;
             }
         }
     }
 
     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 count = data.sl_set_count;
-            
-            result[ticker] = {
-                avg_sl_rate: (count > 0) ? (data.sl_rate_sum / count) : 0,
-                avg_sl_pct_dist: (count > 0) ? (data.sl_dist_sum / count) * 100 : 0,
-                sl_set_count: data.sl_set_count,
-                total_count: data.total_count,
-                sl_set_rate_pct: (data.total_count > 0) ? (data.sl_set_count / data.total_count) * 100 : 0
-            };
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
+
+            if (data.total > 0) {
+                result[ticker] = {
+                    sl_usage_pct: (data.with_sl / data.total) * 100,
+                    sl_count: data.with_sl,
+                    total_count: data.total
+                };
+            }
         }
         return result;
     }
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        this.tickerMap = null;
     }
 }
 
-module.exports = StopLossPerAsset;
+module.exports = SpeculatorStopLossPerAsset;

package/calculations/core/speculator-take-profit-per-asset.js

@@ -1,20 +1,19 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
+ * @fileoverview Calculation (Pass 1) for speculator TP usage.
  *
- * This metric answers: "For each asset, what is the
- * average take profit level and the percentage of
- * positions that have a take profit set?"
+ * This metric answers: "For each asset, what percentage
+ * of speculators are using a take-profit?"
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
-class TakeProfitPerAsset {
+class SpeculatorTakeProfitPerAsset {
     constructor() {
-        // { [instrumentId]: { tp_rate_sum: 0, tp_dist_sum: 0, tp_set_count: 0, total_count: 0 } }
+        // { [instrumentId]: { with_tp: 0, total: 0 } }
         this.assets = new Map();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 
-    // --- NEW ---
     /**
      * Statically defines all metadata for the manifest builder.
      */
@@ -23,12 +22,11 @@ class TakeProfitPerAsset {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator',
+            userType: 'speculator', // <-- KEY: Only runs for speculators
             category: 'core_speculator'
         };
     }
 
-    // --- NEW ---
     /**
      * Statically declare dependencies.
      */
@@ -38,59 +36,40 @@ class TakeProfitPerAsset {
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "avg_tp_rate": {
-                    "type": "number",
-                    "description": "Average TP price level (for positions with TP)."
-                },
-                "avg_tp_pct_dist": {
-                    "type": "number",
-                    "description": "Average TP distance from open price % (for positions with TP)."
-                },
-                "tp_set_count": { "type": "number" },
-                "total_count": { "type": "number" },
-                "tp_set_rate_pct": {
-                    "type": "number",
-                    "description": "Percentage of positions that have a TP set."
-                }
+                "tp_usage_pct": { "type": "number" },
+                "tp_count": { "type": "number" },
+                "total_count": { "type": "number" }
             },
-            "required": ["avg_tp_rate", "avg_tp_pct_dist", "tp_set_count", "total_count", "tp_set_rate_pct"]
+            "required": ["tp_usage_pct", "tp_count", "total_count"]
         };
 
         return {
             "type": "object",
-            "description": "Calculates the average TP level and usage rate per asset for speculators.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
+            "description": "Calculates the percentage of speculators using a take-profit per asset.",
+            "patternProperties": { "^.*$": tickerSchema },
             "additionalProperties": tickerSchema
         };
     }
 
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                tp_rate_sum: 0,
-                tp_dist_sum: 0,
-                tp_set_count: 0,
-                total_count: 0
-            });
+            this.assets.set(instrumentId, { with_tp: 0, total: 0 });
         }
     }
 
-    // --- REFACTORED ---
-    // Simplified signature
-    process(portfolioData) {
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
+    // --- STANDARD 0: UPDATED SIGNATURE ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: ADDED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
         }
-        
-        const positions = portfolioData.PublicPositions;
+
+        const positions = todayPortfolio.PublicPositions;
         if (!positions || !Array.isArray(positions)) {
             return;
         }
@@ -101,47 +80,44 @@ class TakeProfitPerAsset {
             
             this._initAsset(instrumentId);
             const assetData = this.assets.get(instrumentId);
-            assetData.total_count++;
-            
-            const tp_rate = pos.TakeProfitRate || 0;
-            if (tp_rate > 0) {
-                assetData.tp_set_count++;
-                assetData.tp_rate_sum += tp_rate;
-                
-                const open_rate = pos.OpenRate || 0;
-                if (open_rate > 0) {
-                    const distance = Math.abs(tp_rate - open_rate);
-                    assetData.tp_dist_sum += (distance / open_rate);
-                }
+            assetData.total++;
+
+            // PctToTakeProfit is -1 if no TP is set
+            if (pos.PctToTakeProfit >= 0) {
+                assetData.with_tp++;
             }
         }
     }
 
     async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // --- STANDARD 0: REMOVED forbidden data load ---
+
+        // Failsafe check
+        if (!this.tickerMap) {
+            return {}; // process() must run first
         }
 
         const result = {};
         for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            const count = data.tp_set_count;
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
             
-            result[ticker] = {
-                avg_tp_rate: (count > 0) ? (data.tp_rate_sum / count) : 0,
-                avg_tp_pct_dist: (count > 0) ? (data.tp_dist_sum / count) * 100 : 0,
-                tp_set_count: data.tp_set_count,
-                total_count: data.total_count,
-                tp_set_rate_pct: (data.total_count > 0) ? (data.tp_set_count / data.total_count) * 100 : 0
-            };
+            if (data.total > 0) {
+                result[ticker] = {
+                    tp_usage_pct: (data.with_tp / data.total) * 100,
+                    tp_count: data.with_tp,
+                    total_count: data.total
+                };
+            }
         }
         return result;
     }
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 }
 
-module.exports = TakeProfitPerAsset;
+module.exports = SpeculatorTakeProfitPerAsset;