aiden-shared-calculations-unified 1.0.83 → 1.0.84

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

@@ -1,138 +1,123 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "For each asset and leverage level,
- * what is the average percentage distance from the *entry price*
- * to the stop loss?" (This defines the intended risk).
+ * @fileoverview Calculation (Pass 1) for speculator SL entry distance.
+ * --- FIX ---
+ * - Rewritten logic to calculate *entry* SL distance from raw schema fields
+ * (StopLossRate, OpenRate) instead of the non-existent
+ * 'PctToStopLossAtEntry' 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 EntryDistanceToSlPerLeverage {
+class SpeculatorEntryDistanceToSLPerLeverage {
     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'], // Needs portfolio.PublicPositions
-            isHistorical: false, // Only needs today's data
-            userType: 'speculator', // Only runs for speculators
+            rootDataDependencies: ['portfolio'],
+            isHistorical: false,
+            userType: 'speculator', 
             category: 'core_speculator'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
-        return []; // Pass 1
+        return [];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
-        const leverageSchema = {
+        const bucketSchema = {
             "type": "object",
-            "description": "Average entry-to-SL distance grouped by leverage.",
-            "patternProperties": {
-                // Leverage level, e.g., "1x", "5x", "10x"
-                "^[0-9]+x$": {
-                    "type": "number",
-                    "description": "The average percentage distance from entry price to Stop Loss for this leverage level."
-                }
-            },
-            "additionalProperties": { "type": "number" }
+            "properties": {
+                "avg_entry_distance_pct": { "type": "number" },
+                "position_count": { "type": "number" }
+            }
         };
 
         return {
             "type": "object",
-            "description": "Calculates avg % distance from entry price to SL, bucketed by asset and leverage.",
-            "patternProperties": {
-                "^.*$": leverageSchema // Ticker
-            },
-            "additionalProperties": leverageSchema
+            "description": "Calculates the average *entry* 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, as this calc only needs today's portfolio
-    process(portfolioData) {
-        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 open_rate = pos.OpenRate || 0;
-            
-            if (!instrumentId || sl_rate === 0 || open_rate === 0) {
-                continue; // Skip positions without SL or open rate
+            const leverage = pos.Leverage;
+            const slRate = pos.StopLossRate;
+            const openRate = pos.OpenRate;
+
+            if (!leverage || !slRate || slRate <= 0 || !openRate || openRate <= 0) {
+                continue; 
             }
 
-            if (!this.assets.has(instrumentId)) {
-                this.assets.set(instrumentId, {});
+            let pctToSL = 0;
+            if (pos.IsBuy) {
+                // Long: (Open - SL) / Open
+                pctToSL = (openRate - slRate) / openRate;
+            } else {
+                // Short: (SL - Open) / Open
+                pctToSL = (slRate - openRate) / openRate;
             }
-            const assetData = this.assets.get(instrumentId);
-            
-            const leverage = pos.Leverage || 1;
-            const key = this._initLeverage(assetData, leverage);
-            
-            const distance = Math.abs(open_rate - sl_rate);
-            const distance_pct = (distance / open_rate);
-            
-            assetData[key].sum_dist += distance_pct;
-            assetData[key].count++;
-        }
-    }
 
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+            if (pctToSL <= 0) {
+                continue; // SL is at or beyond open price, invalid
+            }
+
+            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) {
-                    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_entry_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 = EntryDistanceToSlPerLeverage;
+module.exports = SpeculatorEntryDistanceToSLPerLeverage;

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

@@ -1,138 +1,123 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric answers: "For each asset and leverage level,
- * what is the average percentage distance from the *entry price*
- * to the take profit?" (This defines the intended reward).
+ * @fileoverview Calculation (Pass 1) for speculator TP entry distance.
+ * --- FIX ---
+ * - Rewritten logic to calculate *entry* TP distance from raw schema fields
+ * (TakeProfitRate, OpenRate) instead of the non-existent
+ * 'PctToTakeProfitAtEntry' 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 EntryDistanceToTpPerLeverage {
+class SpeculatorEntryDistanceToTPPerLeverage {
     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'], // Needs portfolio.PublicPositions
+            rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator', // Only runs for speculators
+            userType: 'speculator', 
             category: 'core_speculator'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
-        return []; // Pass 1
+        return [];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
-        const leverageSchema = {
+        const bucketSchema = {
             "type": "object",
-            "description": "Average entry-to-TP distance grouped by leverage.",
-            "patternProperties": {
-                // Leverage level, e.g., "1x", "5x", "10x"
-                "^[0-9]+x$": {
-                    "type": "number",
-                    "description": "The average percentage distance from entry price to Take Profit for this leverage level."
-                }
-            },
-            "additionalProperties": { "type": "number" }
+            "properties": {
+                "avg_entry_distance_pct": { "type": "number" },
+                "position_count": { "type": "number" }
+            }
         };
 
         return {
             "type": "object",
-            "description": "Calculates avg % distance from entry price to TP, bucketed by asset and leverage.",
-            "patternProperties": {
-                "^.*$": leverageSchema // Ticker
-            },
-            "additionalProperties": leverageSchema
+            "description": "Calculates the average *entry* 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) {
-        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 open_rate = pos.OpenRate || 0;
-            
-            if (!instrumentId || tp_rate === 0 || open_rate === 0) {
-                continue; // Skip positions without TP or open rate
+            const leverage = pos.Leverage;
+            const tpRate = pos.TakeProfitRate;
+            const openRate = pos.OpenRate;
+
+            if (!leverage || !tpRate || tpRate <= 0 || !openRate || openRate <= 0) {
+                continue; 
             }
 
-            if (!this.assets.has(instrumentId)) {
-                this.assets.set(instrumentId, {});
+            let pctToTP = 0;
+            if (pos.IsBuy) {
+                // Long: (TP - Open) / Open
+                pctToTP = (tpRate - openRate) / openRate;
+            } else {
+                // Short: (Open - TP) / Open
+                pctToTP = (openRate - tpRate) / openRate;
             }
-            const assetData = this.assets.get(instrumentId);
-            
-            const leverage = pos.Leverage || 1;
-            const key = this._initLeverage(assetData, leverage);
-            
-            const distance = Math.abs(tp_rate - open_rate);
-            const distance_pct = (distance / open_rate);
-            
-            assetData[key].sum_dist += distance_pct;
-            assetData[key].count++;
-        }
-    }
 
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+            if (pctToTP <= 0) {
+                continue; // TP is at or below open price, invalid
+            }
+
+            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_entry_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 = EntryDistanceToTpPerLeverage;
+module.exports = SpeculatorEntryDistanceToTPPerLeverage;

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

@@ -1,44 +1,17 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
+ * @fileoverview Calculation (Pass 1) for speculator leverage.
  *
- * This metric answers: "For each asset, what is the
- * distribution of leverage levels used by speculators?"
+ * This metric answers: "For each asset, what is the average
+ * leverage used by speculators?"
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
-class LeveragePerAsset {
+class SpeculatorLeveragePerAsset {
     constructor() {
-        // { [instrumentId]: { [leverage]: count } }
+        // { [instrumentId]: { sum: 0, count: 0 } }
         this.assets = new Map();
-        this.mappings = null;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const leverageSchema = {
-            "type": "object",
-            "description": "Distribution of leverage levels for this asset.",
-            "patternProperties": {
-                // Leverage level, e.g., "1x", "5x"
-                "^[0-9]+x$": {
-                    "type": "number",
-                    "description": "Count of positions at this leverage."
-                }
-            },
-            "additionalProperties": { "type": "number" }
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the distribution of leverage levels used by speculators for each asset.",
-            "patternProperties": {
-                "^.*$": leverageSchema // Ticker
-            },
-            "additionalProperties": leverageSchema
-        };
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 
     /**
@@ -49,7 +22,7 @@ class LeveragePerAsset {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator',
+            userType: 'speculator', // <-- KEY: Only runs for speculators
             category: 'core_speculator'
         };
     }
@@ -61,56 +34,88 @@ class LeveragePerAsset {
         return [];
     }
 
+    /**
+     * Defines the output schema for this calculation.
+     */
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "avg_leverage": { "type": "number" },
+                "position_count": { "type": "number" }
+            },
+            "required": ["avg_leverage", "position_count"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates the average leverage used by speculators for each asset.",
+            "patternProperties": { "^.*$": tickerSchema },
+            "additionalProperties": tickerSchema
+        };
+    }
+
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {});
+            this.assets.set(instrumentId, { sum: 0, count: 0 });
         }
     }
 
-    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;
         }
 
         for (const pos of positions) {
             const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
+            const leverage = pos.Leverage;
+            
+            if (!instrumentId || !leverage || leverage <= 1) {
+                continue; // Only care about leveraged positions
+            }
             
             this._initAsset(instrumentId);
             const assetData = this.assets.get(instrumentId);
-            
-            const leverage = pos.Leverage || 1;
-            const key = `${leverage}x`;
-            
-            if (!assetData[key]) {
-                assetData[key] = 0;
-            }
-            assetData[key]++;
+            assetData.sum += leverage;
+            assetData.count++;
         }
     }
 
     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}`;
-            result[ticker] = data;
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
+            
+            if (data.count > 0) {
+                result[ticker] = {
+                    avg_leverage: data.sum / data.count,
+                    position_count: data.count
+                };
+            }
         }
         return result;
     }
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 }
 
-module.exports = LeveragePerAsset;
+module.exports = SpeculatorLeveragePerAsset;