aiden-shared-calculations-unified 1.0.82 → 1.0.84

package/calculations/core/speculator-danger-zone.js

@@ -1,147 +1,134 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "For each asset, how many long and
- * short speculator positions are within 5% of their stop loss?"
+ * @fileoverview Calculation (Pass 1) for speculator "danger zone".
+ * --- FIX ---
+ * - Rewritten logic to calculate SL distance from raw schema fields
+ * (StopLossRate, CurrentRate, OpenRate) instead of 'PctToStopLoss'.
+ * - "Danger Zone" is defined as being >= 90% of the way to the SL.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class SpeculatorDangerZone {
     constructor() {
-        // { [instrumentId]: { long_in_danger: 0, short_in_danger: 0, long_total: 0, short_total: 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": {
-                "long_in_danger": { "type": "number" },
-                "short_in_danger": { "type": "number" },
-                "long_total": { "type": "number" },
-                "short_total": { "type": "number" },
-                "long_danger_pct": {
-                    "type": "number",
-                    "description": "Percentage of long positions in the danger zone."
-                },
-                "short_danger_pct": {
-                    "type": "number",
-                    "description": "Percentage of short positions in the danger zone."
-                }
-            },
-            "required": ["long_in_danger", "short_in_danger", "long_total", "short_total", "long_danger_pct", "short_danger_pct"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Tracks speculator positions within 5% of their Stop Loss.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
-        };
-    }
-
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator', // This calc only runs for speculators
+            userType: 'speculator', 
             category: 'core_speculator'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
         return [];
     }
 
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "danger_zone_pct": { "type": "number" },
+                "danger_zone_count": { "type": "number" },
+                "total_count": { "type": "number" }
+            },
+            "required": ["danger_zone_pct", "danger_zone_count", "total_count"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates the percentage of speculators in the 'danger zone' (90-100% to stop-loss).",
+            "patternProperties": { "^.*$": tickerSchema },
+            "additionalProperties": tickerSchema
+        };
+    }
+
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                long_in_danger: 0,
-                short_in_danger: 0,
-                long_total: 0,
-                short_total: 0
-            });
+            this.assets.set(instrumentId, { danger_zone: 0, total: 0 });
         }
     }
 
-    process(portfolioData) {
-        // This check is now technically redundant due to `userType` in metadata,
-        // but it's good practice to keep it for safety.
-        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 current_price = pos.LastCloseRate || 0;
-            
-            if (!instrumentId || sl_rate === 0 || current_price === 0) {
-                continue;
+            const slRate = pos.StopLossRate;
+            const openRate = pos.OpenRate;
+            const currentRate = pos.CurrentRate;
+
+            if (!instrumentId || !slRate || slRate <= 0 || !openRate || openRate <= 0 || !currentRate || currentRate <= 0) {
+                continue; // No SL or invalid data
             }
-            
+
             this._initAsset(instrumentId);
             const assetData = this.assets.get(instrumentId);
-            
-            const distance = Math.abs(current_price - sl_rate);
-            const distance_pct = (distance / current_price);
-            
-            const isInDanger = distance_pct <= 0.05; // 5% danger zone
+            assetData.total++;
+
+            let totalRiskDistance = 0;
+            let currentDistance = 0;
 
             if (pos.IsBuy) {
-                assetData.long_total++;
-                if (isInDanger) {
-                    assetData.long_in_danger++;
-                }
+                // Long
+                totalRiskDistance = openRate - slRate;
+                currentDistance = currentRate - slRate;
             } else {
-                assetData.short_total++;
-                if (isInDanger) {
-                    assetData.short_in_danger++;
-                }
+                // Short
+                totalRiskDistance = slRate - openRate;
+                currentDistance = slRate - currentRate;
+            }
+
+            if (totalRiskDistance <= 0) {
+                continue; // Invalid SL (at or beyond open price)
+            }
+
+            // This is the percentage of the "risk buffer" that has been used up.
+            // e.g., Open=100, SL=80. RiskDist=20.
+            // Current=82. CurrentDist=2. PctUsed = (20-2)/20 = 18/20 = 90%.
+            const percentOfRiskUsed = (totalRiskDistance - currentDistance) / totalRiskDistance;
+
+            // "Danger Zone" = 90% or more of the way to the SL
+            if (percentOfRiskUsed >= 0.90) { 
+                assetData.danger_zone++;
             }
         }
     }
+    // --- 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] = {
-                ...data,
-                long_danger_pct: (data.long_total > 0) ? (data.long_in_danger / data.long_total) * 100 : 0,
-                short_danger_pct: (data.short_total > 0) ? (data.short_in_danger / data.short_total) * 100 : 0
-            };
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
+
+            if (data.total > 0) {
+                result[ticker] = {
+                    danger_zone_pct: (data.danger_zone / data.total) * 100,
+                    danger_zone_count: data.danger_zone,
+                    total_count: data.total
+                };
+            }
         }
         return result;
     }
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        this.tickerMap = null;
     }
 }
 

package/calculations/core/speculator-distance-to-stop-loss-per-leverage.js

@@ -1,141 +1,126 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "For each asset and leverage level,
- * what is the average percentage distance from the *current price*
- * to the stop loss?"
+ * @fileoverview Calculation (Pass 1) for speculator SL distance.
+ * --- FIX ---
+ * - Rewritten logic to calculate SL distance from raw schema fields
+ * (StopLossRate, CurrentRate) instead of the non-existent
+ * 'PctToStopLoss' field.
+ * - Updated process signature to match worker.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+const BUCKETS = [1, 2, 5, 10, 20, 30]; // Leverage buckets
 
-class DistanceToStopLossPerLeverage {
+class SpeculatorDistanceToStopLossPerLeverage {
     constructor() {
-        // { [instrumentId]: { [leverage]: { sum_dist: 0, count: 0 } } }
-        this.assets = new Map();
-        this.mappings = null;
+        this.buckets = new Map();
+        this._initBuckets();
+    }
+
+    _initBuckets() {
+        this.buckets.clear();
+        for (const b of BUCKETS) {
+            this.buckets.set(b, { sum: 0, count: 0 });
+        }
+        this.buckets.set('other', { sum: 0, count: 0 });
     }
 
-    // --- 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 leverageSchema = {
+        const bucketSchema = {
             "type": "object",
-            "description": "Average SL distance grouped by leverage.",
-            "patternProperties": {
-                // Leverage level, e.g., "1x", "5x", "10x"
-                "^[0-9]+x$": {
-                    "type": "number",
-                    "description": "The average percentage distance from current price to Stop Loss for this leverage level."
-                }
-            },
-            "additionalProperties": { "type": "number" }
+            "properties": {
+                "avg_distance_pct": { "type": "number" },
+                "position_count": { "type": "number" }
+            }
         };
 
         return {
             "type": "object",
-            "description": "Calculates avg % distance from current price to SL, bucketed by asset and leverage.",
-            "patternProperties": {
-                "^.*$": leverageSchema // Ticker
-            },
-            "additionalProperties": leverageSchema
+            "description": "Calculates the average distance to stop-loss, bucketed by leverage.",
+            "properties": {
+                "x1": bucketSchema,
+                "x2": bucketSchema,
+                "x5": bucketSchema,
+                "x10": bucketSchema,
+                "x20": bucketSchema,
+                "x30": bucketSchema,
+                "other": bucketSchema
+            }
         };
     }
 
-    _initLeverage(assetData, leverage) {
-        const key = `${leverage}x`;
-        if (!assetData[key]) {
-            assetData[key] = { sum_dist: 0, count: 0 };
+    _getBucket(leverage) {
+        if (this.buckets.has(leverage)) {
+            return this.buckets.get(leverage);
         }
-        return key;
+        return this.buckets.get('other');
     }
 
-    // --- REFACTORED ---
-    // Simplified signature
-    process(portfolioData) {
-        // This calculation is only for speculators
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
-        }
-        
-        const positions = portfolioData.PublicPositions;
+    // --- THIS IS THE FIX ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+        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 current_price = pos.LastCloseRate || 0; // Use last close as current price
-            
-            if (!instrumentId || sl_rate === 0 || current_price === 0) {
-                continue; // Skip positions without SL or price
+            const leverage = pos.Leverage;
+            const slRate = pos.StopLossRate;
+            const currentRate = pos.CurrentRate;
+
+            // Check if SL is set (slRate > 0) and we have valid prices
+            if (!leverage || !slRate || slRate <= 0 || !currentRate || currentRate <= 0) {
+                continue; 
             }
 
-            if (!this.assets.has(instrumentId)) {
-                this.assets.set(instrumentId, {});
+            // Manually calculate the percentage distance to SL
+            let pctToSL = 0;
+            if (pos.IsBuy) {
+                // Long: (Current - SL) / Current
+                pctToSL = (currentRate - slRate) / currentRate;
+            } else {
+                // Short: (SL - Current) / Current
+                pctToSL = (slRate - currentRate) / currentRate;
             }
-            const assetData = this.assets.get(instrumentId);
-            
-            const leverage = pos.Leverage || 1;
-            const key = this._initLeverage(assetData, leverage);
-            
-            // Calculate distance
-            const distance = Math.abs(current_price - sl_rate);
-            const distance_pct = (distance / current_price);
-            
-            assetData[key].sum_dist += distance_pct;
-            assetData[key].count++;
-        }
-    }
 
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+            // We only care about open SLs (distance > 0)
+            if (pctToSL <= 0) {
+                continue;
+            }
+
+            const bucket = this._getBucket(leverage);
+            bucket.sum += (pctToSL * 100); // Convert to percentage
+            bucket.count++;
         }
+    }
+    // --- END FIX ---
 
+    getResult() {
         const result = {};
-        for (const [instrumentId, leverageData] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            result[ticker] = {};
-            
-            for (const leverageKey in leverageData) {
-                const data = leverageData[leverageKey];
-                if (data.count > 0) {
-                    // Store the final average distance * 100 for percentage
-                    result[ticker][leverageKey] = (data.sum_dist / data.count) * 100;
-                }
-            }
+        for (const [key, data] of this.buckets.entries()) {
+            const label = (key === 'other') ? 'other' : `x${key}`;
+            result[label] = {
+                avg_distance_pct: (data.count > 0) ? (data.sum / data.count) : 0,
+                position_count: data.count
+            };
         }
         return result;
     }
 
     reset() {
-        this.assets.clear();
-        this.mappings = null;
+        this._initBuckets();
     }
 }
 
-module.exports = DistanceToStopLossPerLeverage;
+module.exports = SpeculatorDistanceToStopLossPerLeverage;

package/calculations/core/speculator-distance-to-tp-per-leverage.js

@@ -1,139 +1,126 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "For each asset and leverage level,
- * what is the average percentage distance from the *current price*
- * to the take profit?"
+ * @fileoverview Calculation (Pass 1) for speculator TP distance.
+ * --- FIX ---
+ * - Rewritten logic to calculate TP distance from raw schema fields
+ * (TakeProfitRate, CurrentRate) instead of the non-existent
+ * 'PctToTakeProfit' field.
+ * - Updated process signature to match worker.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+const BUCKETS = [1, 2, 5, 10, 20, 30]; // Leverage buckets
 
-class DistanceToTakeProfitPerLeverage {
+class SpeculatorDistanceToTakeProfitPerLeverage {
     constructor() {
-        // { [instrumentId]: { [leverage]: { sum_dist: 0, count: 0 } } }
-        this.assets = new Map();
-        this.mappings = null;
+        this.buckets = new Map();
+        this._initBuckets();
+    }
+
+    _initBuckets() {
+        this.buckets.clear();
+        for (const b of BUCKETS) {
+            this.buckets.set(b, { sum: 0, count: 0 });
+        }
+        this.buckets.set('other', { sum: 0, count: 0 });
     }
 
-    // --- 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 leverageSchema = {
+        const bucketSchema = {
             "type": "object",
-            "description": "Average TP distance grouped by leverage.",
-            "patternProperties": {
-                // Leverage level, e.g., "1x", "5x", "10x"
-                "^[0-9]+x$": {
-                    "type": "number",
-                    "description": "The average percentage distance from current price to Take Profit for this leverage level."
-                }
-            },
-            "additionalProperties": { "type": "number" }
+            "properties": {
+                "avg_distance_pct": { "type": "number" },
+                "position_count": { "type": "number" }
+            }
         };
 
         return {
             "type": "object",
-            "description": "Calculates avg % distance from current price to TP, bucketed by asset and leverage.",
-            "patternProperties": {
-                "^.*$": leverageSchema // Ticker
-            },
-            "additionalProperties": leverageSchema
+            "description": "Calculates the average distance to take-profit, bucketed by leverage.",
+            "properties": {
+                "x1": bucketSchema,
+                "x2": bucketSchema,
+                "x5": bucketSchema,
+                "x10": bucketSchema,
+                "x20": bucketSchema,
+                "x30": bucketSchema,
+                "other": bucketSchema
+            }
         };
     }
 
-    _initLeverage(assetData, leverage) {
-        const key = `${leverage}x`;
-        if (!assetData[key]) {
-            assetData[key] = { sum_dist: 0, count: 0 };
+    _getBucket(leverage) {
+        if (this.buckets.has(leverage)) {
+            return this.buckets.get(leverage);
         }
-        return key;
+        return this.buckets.get('other');
     }
 
-    // --- REFACTORED ---
-    // Simplified signature
-    process(portfolioData) {
-        // This calculation is only for speculators
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
-        }
-        
-        const positions = portfolioData.PublicPositions;
+    // --- THIS IS THE FIX ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+        const positions = todayPortfolio.PublicPositions;
         if (!positions || !Array.isArray(positions)) {
             return;
         }
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            const tp_rate = pos.TakeProfitRate || 0;
-            const current_price = pos.LastCloseRate || 0;
-            
-            if (!instrumentId || tp_rate === 0 || current_price === 0) {
-                continue; // Skip positions without TP or price
+            const leverage = pos.Leverage;
+            const tpRate = pos.TakeProfitRate;
+            const currentRate = pos.CurrentRate;
+
+            // Check if TP is set (tpRate > 0) and we have valid prices
+            if (!leverage || !tpRate || tpRate <= 0 || !currentRate || currentRate <= 0) {
+                continue; 
             }
 
-            if (!this.assets.has(instrumentId)) {
-                this.assets.set(instrumentId, {});
+            // Manually calculate the percentage distance to TP
+            let pctToTP = 0;
+            if (pos.IsBuy) {
+                // Long: (TP - Current) / Current
+                pctToTP = (tpRate - currentRate) / currentRate;
+            } else {
+                // Short: (Current - TP) / Current
+                pctToTP = (currentRate - tpRate) / currentRate;
             }
-            const assetData = this.assets.get(instrumentId);
-            
-            const leverage = pos.Leverage || 1;
-            const key = this._initLeverage(assetData, leverage);
-            
-            const distance = Math.abs(tp_rate - current_price);
-            const distance_pct = (distance / current_price);
-            
-            assetData[key].sum_dist += distance_pct;
-            assetData[key].count++;
-        }
-    }
 
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+            // We only care about open TPs (distance > 0)
+            if (pctToTP <= 0) {
+                continue;
+            }
+
+            const bucket = this._getBucket(leverage);
+            bucket.sum += (pctToTP * 100); // Convert to percentage
+            bucket.count++;
         }
+    }
+    // --- END FIX ---
 
+    getResult() {
         const result = {};
-        for (const [instrumentId, leverageData] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            result[ticker] = {};
-            
-            for (const leverageKey in leverageData) {
-                const data = leverageData[leverageKey];
-                if (data.count > 0) {
-                    result[ticker][leverageKey] = (data.sum_dist / data.count) * 100;
-                }
-            }
+        for (const [key, data] of this.buckets.entries()) {
+            const label = (key === 'other') ? 'other' : `x${key}`;
+            result[label] = {
+                avg_distance_pct: (data.count > 0) ? (data.sum / data.count) : 0,
+                position_count: data.count
+            };
         }
         return result;
     }
 
     reset() {
-        this.assets.clear();
-        this.mappings = null;
+        this._initBuckets();
     }
 }
 
-module.exports = DistanceToTakeProfitPerLeverage;
+module.exports = SpeculatorDistanceToTakeProfitPerLeverage;