aiden-shared-calculations-unified 1.0.86 → 1.0.88

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

@@ -1,12 +1,8 @@
 /**
- * @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.
+ * @fileoverview Calculation (Pass 1) for speculator Entry distance to SL.
+ * REFACTORED: Uses extract.getOpenRate vs extract.getStopLossRate.
  */
-const BUCKETS = [1, 2, 5, 10, 20, 30]; // Leverage buckets
+const BUCKETS = [1, 2, 5, 10, 20, 30];
 
 class SpeculatorEntryDistanceToSLPerLeverage {
     constructor() {
@@ -16,9 +12,7 @@ class SpeculatorEntryDistanceToSLPerLeverage {
 
     _initBuckets() {
         this.buckets.clear();
-        for (const b of BUCKETS) {
-            this.buckets.set(b, { sum: 0, count: 0 });
-        }
+        for (const b of BUCKETS) this.buckets.set(b, { sum: 0, count: 0 });
         this.buckets.set('other', { sum: 0, count: 0 });
     }
 
@@ -32,9 +26,7 @@ class SpeculatorEntryDistanceToSLPerLeverage {
         };
     }
 
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
     static getSchema() {
         const bucketSchema = {
@@ -44,47 +36,29 @@ class SpeculatorEntryDistanceToSLPerLeverage {
                 "position_count": { "type": "number" }
             }
         };
-
-        return {
-            "type": "object",
-            "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
-            }
-        };
+        return { "type": "object", "patternProperties": { "^.*$": bucketSchema } };
     }
 
     _getBucket(leverage) {
-        if (this.buckets.has(leverage)) {
-            return this.buckets.get(leverage);
-        }
-        return this.buckets.get('other');
+        return this.buckets.has(leverage) ? this.buckets.get(leverage) : this.buckets.get('other');
     }
 
-    // --- THIS IS THE FIX ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        const positions = todayPortfolio.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { user } = context;
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const leverage = pos.Leverage;
-            const slRate = pos.StopLossRate;
-            const openRate = pos.OpenRate;
+            const leverage = extract.getLeverage(pos);
+            const slRate = extract.getStopLossRate(pos);
+            const openRate = extract.getOpenRate(pos);
 
-            if (!leverage || !slRate || slRate <= 0 || !openRate || openRate <= 0) {
-                continue; 
-            }
+            if (!leverage || !slRate || slRate <= 0 || !openRate || openRate <= 0) continue;
 
+            const direction = extract.getDirection(pos);
             let pctToSL = 0;
-            if (pos.IsBuy) {
+            
+            if (direction === 'Buy') {
                 // Long: (Open - SL) / Open
                 pctToSL = (openRate - slRate) / openRate;
             } else {
@@ -92,16 +66,13 @@ class SpeculatorEntryDistanceToSLPerLeverage {
                 pctToSL = (slRate - openRate) / openRate;
             }
 
-            if (pctToSL <= 0) {
-                continue; // SL is at or beyond open price, invalid
-            }
+            if (pctToSL <= 0) continue; // Invalid distance
 
             const bucket = this._getBucket(leverage);
-            bucket.sum += (pctToSL * 100); // Convert to percentage
+            bucket.sum += (pctToSL * 100);
             bucket.count++;
         }
     }
-    // --- END FIX ---
 
     getResult() {
         const result = {};
@@ -119,5 +90,4 @@ class SpeculatorEntryDistanceToSLPerLeverage {
         this._initBuckets();
     }
 }
-
 module.exports = SpeculatorEntryDistanceToSLPerLeverage;

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

@@ -1,14 +1,10 @@
 /**
- * @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.
+ * @fileoverview Calculation (Pass 1) for speculator TP Entry distance (Open Price vs TP).
+ * REFACTORED: Uses context.math.extract.
  */
-const BUCKETS = [1, 2, 5, 10, 20, 30]; // Leverage buckets
+const BUCKETS = [1, 2, 5, 10, 20, 30];
 
-class SpeculatorEntryDistanceToTPPerLeverage {
+class SpeculatorEntryDistanceToTpPerLeverage {
     constructor() {
         this.buckets = new Map();
         this._initBuckets();
@@ -16,9 +12,7 @@ class SpeculatorEntryDistanceToTPPerLeverage {
 
     _initBuckets() {
         this.buckets.clear();
-        for (const b of BUCKETS) {
-            this.buckets.set(b, { sum: 0, count: 0 });
-        }
+        for (const b of BUCKETS) this.buckets.set(b, { sum: 0, count: 0 });
         this.buckets.set('other', { sum: 0, count: 0 });
     }
 
@@ -27,14 +21,12 @@ class SpeculatorEntryDistanceToTPPerLeverage {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator', 
+            userType: 'speculator',
             category: 'core_speculator'
         };
     }
 
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
     static getSchema() {
         const bucketSchema = {
@@ -44,47 +36,32 @@ class SpeculatorEntryDistanceToTPPerLeverage {
                 "position_count": { "type": "number" }
             }
         };
-
-        return {
-            "type": "object",
-            "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
-            }
-        };
+        return { "type": "object", "patternProperties": { "^.*$": bucketSchema } };
     }
 
     _getBucket(leverage) {
-        if (this.buckets.has(leverage)) {
-            return this.buckets.get(leverage);
-        }
-        return this.buckets.get('other');
+        return this.buckets.has(leverage) ? this.buckets.get(leverage) : this.buckets.get('other');
     }
 
-    // --- THIS IS THE FIX ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        const positions = todayPortfolio.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { user } = context;
+
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const leverage = pos.Leverage;
-            const tpRate = pos.TakeProfitRate;
-            const openRate = pos.OpenRate;
+            const leverage = extract.getLeverage(pos);
+            const tpRate = extract.getTakeProfitRate(pos);
+            const openRate = extract.getOpenRate(pos);
 
             if (!leverage || !tpRate || tpRate <= 0 || !openRate || openRate <= 0) {
                 continue; 
             }
 
+            const direction = extract.getDirection(pos);
             let pctToTP = 0;
-            if (pos.IsBuy) {
+            
+            if (direction === 'Buy') {
                 // Long: (TP - Open) / Open
                 pctToTP = (tpRate - openRate) / openRate;
             } else {
@@ -92,16 +69,13 @@ class SpeculatorEntryDistanceToTPPerLeverage {
                 pctToTP = (openRate - tpRate) / openRate;
             }
 
-            if (pctToTP <= 0) {
-                continue; // TP is at or below open price, invalid
-            }
+            if (pctToTP <= 0) continue;
 
             const bucket = this._getBucket(leverage);
-            bucket.sum += (pctToTP * 100); // Convert to percentage
+            bucket.sum += (pctToTP * 100);
             bucket.count++;
         }
     }
-    // --- END FIX ---
 
     getResult() {
         const result = {};
@@ -119,5 +93,4 @@ class SpeculatorEntryDistanceToTPPerLeverage {
         this._initBuckets();
     }
 }
-
-module.exports = SpeculatorEntryDistanceToTPPerLeverage;
+module.exports = SpeculatorEntryDistanceToTpPerLeverage;

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

@@ -1,42 +1,25 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator leverage.
- *
- * This metric answers: "For each asset, what is the average
- * leverage used by speculators?"
+ * @fileoverview Calculation (Pass 1) for speculator leverage per asset.
+ * REFACTORED: Uses context.math.extract.getLeverage.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class SpeculatorLeveragePerAsset {
     constructor() {
-        // { [instrumentId]: { sum: 0, count: 0 } }
         this.assets = new Map();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator', // <-- KEY: Only runs for speculators
+            userType: 'speculator',
             category: 'core_speculator'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
@@ -46,64 +29,44 @@ class SpeculatorLeveragePerAsset {
             },
             "required": ["avg_leverage", "position_count"]
         };
-
-        return {
-            "type": "object",
-            "description": "Calculates the average leverage used by speculators for each asset.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, { sum: 0, count: 0 });
+            this.assets.set(instrumentId, { leverageSum: 0, count: 0 });
         }
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: ADDED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const positions = todayPortfolio.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            const leverage = pos.Leverage;
-            
-            if (!instrumentId || !leverage || leverage <= 1) {
-                continue; // Only care about leveraged positions
-            }
-            
-            this._initAsset(instrumentId);
-            const assetData = this.assets.get(instrumentId);
-            assetData.sum += leverage;
-            assetData.count++;
-        }
-    }
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
 
-    async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
+            const leverage = extract.getLeverage(pos);
+            if (leverage <= 0) continue;
 
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
+            this._initAsset(instId);
+            const data = this.assets.get(instId);
+            data.leverageSum += leverage;
+            data.count++;
         }
+    }
 
+    async getResult() {
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-            
+        for (const [instId, data] of this.assets.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
             if (data.count > 0) {
                 result[ticker] = {
-                    avg_leverage: data.sum / data.count,
+                    avg_leverage: data.leverageSum / data.count,
                     position_count: data.count
                 };
             }
@@ -113,9 +76,7 @@ class SpeculatorLeveragePerAsset {
 
     reset() {
         this.assets.clear();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 }
-
 module.exports = SpeculatorLeveragePerAsset;

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

@@ -1,42 +1,25 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator leverage.
- *
- * This metric answers: "For each sector, what is the average
- * leverage used by speculators?"
+ * @fileoverview Calculation (Pass 1) for speculator leverage per sector.
+ * REFACTORED: Uses context.math.extract.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class SpeculatorLeveragePerSector {
     constructor() {
-        // { [sectorName]: { sum: 0, count: 0 } }
-        this.sectors = new Map();
-        // --- STANDARD 0: RENAMED ---
+        this.sectorData = new Map();
         this.sectorMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator', // <-- KEY: Only runs for speculators
+            userType: 'speculator',
             category: 'core_speculator'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const sectorSchema = {
             "type": "object",
@@ -46,59 +29,42 @@ class SpeculatorLeveragePerSector {
             },
             "required": ["avg_leverage", "position_count"]
         };
-
-        return {
-            "type": "object",
-            "description": "Calculates the average leverage used by speculators for each sector.",
-            "patternProperties": { "^.*$": sectorSchema },
-            "additionalProperties": sectorSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": sectorSchema } };
     }
 
-    _initSector(sectorName) {
-        if (!this.sectors.has(sectorName)) {
-            this.sectors.set(sectorName, { sum: 0, count: 0 });
+    _initSector(sector) {
+        if (!this.sectorData.has(sector)) {
+            this.sectorData.set(sector, { leverageSum: 0, count: 0 });
         }
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE ---
-    async process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: FIXED ---
-        if (!this.sectorMap) {
-            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;
-        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 leverage = pos.Leverage;
-            
-            if (!instrumentId || !leverage || leverage <= 1) {
-                continue; // Only care about leveraged positions
-            }
-            
-            // --- STANDARD 0: FIXED ---
-            const sectorName = this.sectorMap[instrumentId] || 'N/A';
-            this._initSector(sectorName);
-            const sectorData = this.sectors.get(sectorName);
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
+
+            const sector = this.sectorMap[instId] || 'Unknown';
+            const leverage = extract.getLeverage(pos);
             
-            sectorData.sum += leverage;
-            sectorData.count++;
+            this._initSector(sector);
+            const data = this.sectorData.get(sector);
+            data.leverageSum += leverage;
+            data.count++;
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
         const result = {};
-        for (const [sectorName, data] of this.sectors.entries()) {
+        for (const [sector, data] of this.sectorData.entries()) {
             if (data.count > 0) {
-                result[sectorName] = {
-                    avg_leverage: data.sum / data.count,
+                result[sector] = {
+                    avg_leverage: data.leverageSum / data.count,
                     position_count: data.count
                 };
             }
@@ -107,10 +73,8 @@ class SpeculatorLeveragePerSector {
     }
 
     reset() {
-        this.sectors.clear();
-        // --- STANDARD 0: RENAMED ---
+        this.sectorData.clear();
         this.sectorMap = null;
     }
 }
-
 module.exports = SpeculatorLeveragePerSector;

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

@@ -1,12 +1,7 @@
 /**
  * @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.
+ * REFACTORED: Uses rate extraction.
  */
-
 class SpeculatorRiskRewardRatioPerAsset {
     constructor() {
         this.assets = new Map();
@@ -18,14 +13,12 @@ class SpeculatorRiskRewardRatioPerAsset {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator', // <-- KEY: Only runs for speculators
+            userType: 'speculator',
             category: 'core_speculator'
         };
     }
 
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
     static getSchema() {
         const tickerSchema = {
@@ -36,13 +29,7 @@ class SpeculatorRiskRewardRatioPerAsset {
             },
             "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
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
     _initAsset(instrumentId) {
@@ -51,65 +38,50 @@ class SpeculatorRiskRewardRatioPerAsset {
         }
     }
 
-    // --- THIS IS THE FIX ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const positions = todayPortfolio.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            const slRate = pos.StopLossRate;
-            const tpRate = pos.TakeProfitRate;
-            const openRate = pos.OpenRate;
+            const instId = extract.getInstrumentId(pos);
+            const slRate = extract.getStopLossRate(pos);
+            const tpRate = extract.getTakeProfitRate(pos);
+            const openRate = extract.getOpenRate(pos);
 
-            if (!instrumentId || !slRate || slRate <= 0 || !tpRate || tpRate <= 0 || !openRate || openRate <= 0) {
-                continue; // Must have SL, TP, and OpenRate
+            if (!instId || !slRate || slRate <= 0 || !tpRate || tpRate <= 0 || !openRate || openRate <= 0) {
+                continue; 
             }
 
+            const direction = extract.getDirection(pos);
             let risk = 0;
             let reward = 0;
 
-            if (pos.IsBuy) {
-                // Long
+            if (direction === 'Buy') {
                 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;
-            }
-
-            this._initAsset(instrumentId);
-            const assetData = this.assets.get(instrumentId);
+            if (risk <= 0 || reward <= 0) continue;
 
-            const rrRatio = reward / risk;
+            this._initAsset(instId);
+            const assetData = this.assets.get(instId);
 
-            assetData.sum += rrRatio;
+            assetData.sum += (reward / risk);
             assetData.count++;
         }
     }
-    // --- END FIX ---
 
     async getResult() {
-        if (!this.tickerMap) {
-            return {}; 
-        }
-
+        if (!this.tickerMap) return {}; 
         const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-
+        for (const [instId, data] of this.assets.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
             if (data.count > 0) {
                 result[ticker] = {
                     avg_rr_ratio: data.sum / data.count,
@@ -125,5 +97,4 @@ class SpeculatorRiskRewardRatioPerAsset {
         this.tickerMap = null;
     }
 }
-
 module.exports = SpeculatorRiskRewardRatioPerAsset;