aiden-shared-calculations-unified 1.0.35 → 1.0.37

package/calculations/activity/historical/daily_user_activity_tracker.js

@@ -1,145 +1,145 @@
-/**
- * @fileoverview Tracks user activity by comparing portfolio snapshots.
- * This is a historical calculation that defines an "active user" as someone
- * who has opened, closed, or reallocated a position within the last 24 hours.
- *
- * This provides the "Daily Active Users" count for the monitored cohort.
- * This depreciates the user activity sampler cloud function which was inefficient for the api usage and now provides this data for free
- */
-
-class DailyUserActivityTracker {
-    constructor() {
-        this.activeUserIds = new Set();
-        this.activityEvents = {
-            new_position: 0,
-            closed_position: 0,
-            reallocation: 0
-        };
-    }
-
-    /**
-     * Helper to get a simplified map of positions for comparison.
-     * @param {object} portfolio - A user's full portfolio object.
-     * @returns {object} { posMap: Map<InstrumentID, {invested: number}>, hasAggregated: boolean }
-     */
-    _getPortfolioMaps(portfolio) {
-        // Prioritize AggregatedPositions, but fall back to PublicPositions
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return { posMap: new Map(), hasAggregated: false };
-        }
-
-        const posMap = new Map();
-        for (const pos of positions) {
-            const key = pos.InstrumentID;
-            if (key) {
-                posMap.set(key, {
-                    // 'InvestedAmount' or 'Invested' is the portfolio percentage
-                    // We use this for reallocation logic.
-                    invested: pos.InvestedAmount || pos.Invested || pos.Amount || 0
-                });
-            }
-        }
-        // Return the map and a flag indicating if we can trust the 'invested' field
-        return { posMap, hasAggregated: !!portfolio.AggregatedPositions };
-    }
-
-    /**
-     * Processes a single user's daily data.
-     */
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        // This calculation requires both days to find changes.
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const { posMap: yPosMap, hasAggregated: yHasAgg } = this._getPortfolioMaps(yesterdayPortfolio);
-        const { posMap: tPosMap, hasAggregated: tHasAgg } = this._getPortfolioMaps(todayPortfolio);
-
-        // Skip if user has no positions on either day
-        if (tPosMap.size === 0 && yPosMap.size === 0) {
-            return;
-        }
-
-        const yIds = new Set(yPosMap.keys());
-        const tIds = new Set(tPosMap.keys());
-        let isActive = false;
-
-        // 1. Check for new positions (high-confidence activity)
-        for (const tId of tIds) {
-            if (!yIds.has(tId)) {
-                isActive = true;
-                this.activityEvents.new_position++;
-                break; // Found activity, no need to check more
-            }
-        }
-
-        if (isActive) {
-            this.activeUserIds.add(userId);
-            return;
-        }
-
-        // 2. Check for closed positions (high-confidence activity)
-        for (const yId of yIds) {
-            if (!tIds.has(yId)) {
-                isActive = true;
-                this.activityEvents.closed_position++;
-                break; // Found activity
-            }
-        }
-
-        if (isActive) {
-            this.activeUserIds.add(userId);
-            return;
-        }
-
-        // 3. Check for reallocation (only possible if we have AggregatedPositions for both days)
-        // This checks for changes in the 'Invested' percentage
-        // 3. Check for reallocation (only possible if we have AggregatedPositions for both days)
-        if (yHasAgg && tHasAgg) {
-            for (const tId of tIds) {
-                const tInvested = tPosMap.get(tId).invested;
-                const yInvested = yPosMap.get(tId)?.invested ?? 0;
-
-                // Check for a meaningful change (e.g., > 0.01% to avoid float noise)
-                if (Math.abs(tInvested - yInvested) > 0.0001) {
-                    isActive = true;
-                    this.activityEvents.reallocation++;
-                    break;
-                }
-            }
-        }
-
-
-        if (isActive) {
-            this.activeUserIds.add(userId);
-        }
-    }
-
-    /**
-     * Returns the final aggregated counts for the day.
-     */
-    getResult() {
-        return {
-            // This is the main metric for your graph
-            rawActiveUserCount: this.activeUserIds.size,
-            
-            // This is a bonus metric to see *what* users are doing
-            activityBreakdown: this.activityEvents
-        };
-    }
-
-    /**
-     * Resets the counters for the next run.
-     */
-    reset() {
-        this.activeUserIds.clear();
-        this.activityEvents = {
-            new_position: 0,
-            closed_position: 0,
-            reallocation: 0
-        };
-    }
-}
-
+/**
+ * @fileoverview Tracks user activity by comparing portfolio snapshots.
+ * This is a historical calculation that defines an "active user" as someone
+ * who has opened, closed, or reallocated a position within the last 24 hours.
+ *
+ * This provides the "Daily Active Users" count for the monitored cohort.
+ * This depreciates the user activity sampler cloud function which was inefficient for the api usage and now provides this data for free
+ */
+
+class DailyUserActivityTracker {
+    constructor() {
+        this.activeUserIds = new Set();
+        this.activityEvents = {
+            new_position: 0,
+            closed_position: 0,
+            reallocation: 0
+        };
+    }
+
+    /**
+     * Helper to get a simplified map of positions for comparison.
+     * @param {object} portfolio - A user's full portfolio object.
+     * @returns {object} { posMap: Map<InstrumentID, {invested: number}>, hasAggregated: boolean }
+     */
+    _getPortfolioMaps(portfolio) {
+        // Prioritize AggregatedPositions, but fall back to PublicPositions
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return { posMap: new Map(), hasAggregated: false };
+        }
+
+        const posMap = new Map();
+        for (const pos of positions) {
+            const key = pos.InstrumentID;
+            if (key) {
+                posMap.set(key, {
+                    // 'InvestedAmount' or 'Invested' is the portfolio percentage
+                    // We use this for reallocation logic.
+                    invested: pos.InvestedAmount || pos.Invested || pos.Amount || 0
+                });
+            }
+        }
+        // Return the map and a flag indicating if we can trust the 'invested' field
+        return { posMap, hasAggregated: !!portfolio.AggregatedPositions };
+    }
+
+    /**
+     * Processes a single user's daily data.
+     */
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // This calculation requires both days to find changes.
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const { posMap: yPosMap, hasAggregated: yHasAgg } = this._getPortfolioMaps(yesterdayPortfolio);
+        const { posMap: tPosMap, hasAggregated: tHasAgg } = this._getPortfolioMaps(todayPortfolio);
+
+        // Skip if user has no positions on either day
+        if (tPosMap.size === 0 && yPosMap.size === 0) {
+            return;
+        }
+
+        const yIds = new Set(yPosMap.keys());
+        const tIds = new Set(tPosMap.keys());
+        let isActive = false;
+
+        // 1. Check for new positions (high-confidence activity)
+        for (const tId of tIds) {
+            if (!yIds.has(tId)) {
+                isActive = true;
+                this.activityEvents.new_position++;
+                break; // Found activity, no need to check more
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+            return;
+        }
+
+        // 2. Check for closed positions (high-confidence activity)
+        for (const yId of yIds) {
+            if (!tIds.has(yId)) {
+                isActive = true;
+                this.activityEvents.closed_position++;
+                break; // Found activity
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+            return;
+        }
+
+        // 3. Check for reallocation (only possible if we have AggregatedPositions for both days)
+        // This checks for changes in the 'Invested' percentage
+        // 3. Check for reallocation (only possible if we have AggregatedPositions for both days)
+        if (yHasAgg && tHasAgg) {
+            for (const tId of tIds) {
+                const tInvested = tPosMap.get(tId).invested;
+                const yInvested = yPosMap.get(tId)?.invested ?? 0;
+
+                // Check for a meaningful change (e.g., > 0.01% to avoid float noise)
+                if (Math.abs(tInvested - yInvested) > 0.0001) {
+                    isActive = true;
+                    this.activityEvents.reallocation++;
+                    break;
+                }
+            }
+        }
+
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+        }
+    }
+
+    /**
+     * Returns the final aggregated counts for the day.
+     */
+    getResult() {
+        return {
+            // This is the main metric for your graph
+            rawActiveUserCount: this.activeUserIds.size,
+            
+            // This is a bonus metric to see *what* users are doing
+            activityBreakdown: this.activityEvents
+        };
+    }
+
+    /**
+     * Resets the counters for the next run.
+     */
+    reset() {
+        this.activeUserIds.clear();
+        this.activityEvents = {
+            new_position: 0,
+            closed_position: 0,
+            reallocation: 0
+        };
+    }
+}
+
 module.exports = DailyUserActivityTracker;

package/calculations/activity/historical/speculator_adjustment_activity.js

@@ -1,77 +1,77 @@
-/**
- * @fileoverview Tracks "tinkering" activity from speculators.
- * Instead of just opening/closing, this counts how many users
- * actively *adjusted* the SL, TP, or TSL on existing trades.
- */
-class SpeculatorAdjustmentActivity {
-    constructor() {
-        // Use Sets to count unique users
-        this.sl_adjusted_users = new Set();
-        this.tp_adjusted_users = new Set();
-        this.tsl_toggled_users = new Set();
-    }
-
-    _getPublicPositionsMap(portfolio) {
-        const positions = portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
-        }
-        // Map<PositionID, PositionObject>
-        return new Map(positions.map(p => [p.PositionID, p]));
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        // This calculation is only for speculators
-        if (todayPortfolio?.context?.userType !== 'speculator' || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPosMap = this._getPublicPositionsMap(yesterdayPortfolio);
-        const tPosMap = this._getPublicPositionsMap(todayPortfolio);
-
-        if (yPosMap.size === 0 || tPosMap.size === 0) {
-            return; // No positions to compare
-        }
-
-        for (const [tPosId, tPos] of tPosMap.entries()) {
-            // Check if this position existed yesterday
-            if (yPosMap.has(tPosId)) {
-                const yPos = yPosMap.get(tPosId);
-
-                // 1. Check for Stop Loss adjustment
-                if (tPos.StopLossRate !== yPos.StopLossRate) {
-                    this.sl_adjusted_users.add(userId);
-                }
-
-                // 2. Check for Take Profit adjustment
-                if (tPos.TakeProfitRate !== yPos.TakeProfitRate) {
-                    this.tp_adjusted_users.add(userId);
-                }
-                
-                // 3. Check if TSL was toggled on or off
-                if (tPos.IsTslEnabled !== yPos.IsTslEnabled) {
-                    this.tsl_toggled_users.add(userId);
-                }
-            }
-        }
-    }
-
-    getResult() {
-        return {
-            // Count of unique users who adjusted at least one trade's SL
-            unique_users_adjusted_sl: this.sl_adjusted_users.size,
-            // Count of unique users who adjusted at least one trade's TP
-            unique_users_adjusted_tp: this.tp_adjusted_users.size,
-            // Count of unique users who toggled TSL on or off
-            unique_users_toggled_tsl: this.tsl_toggled_users.size
-        };
-    }
-
-    reset() {
-        this.sl_adjusted_users.clear();
-        this.tp_adjusted_users.clear();
-        this.tsl_toggled_users.clear();
-    }
-}
-
+/**
+ * @fileoverview Tracks "tinkering" activity from speculators.
+ * Instead of just opening/closing, this counts how many users
+ * actively *adjusted* the SL, TP, or TSL on existing trades.
+ */
+class SpeculatorAdjustmentActivity {
+    constructor() {
+        // Use Sets to count unique users
+        this.sl_adjusted_users = new Set();
+        this.tp_adjusted_users = new Set();
+        this.tsl_toggled_users = new Set();
+    }
+
+    _getPublicPositionsMap(portfolio) {
+        const positions = portfolio?.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return new Map();
+        }
+        // Map<PositionID, PositionObject>
+        return new Map(positions.map(p => [p.PositionID, p]));
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // This calculation is only for speculators
+        if (todayPortfolio?.context?.userType !== 'speculator' || !yesterdayPortfolio) {
+            return;
+        }
+
+        const yPosMap = this._getPublicPositionsMap(yesterdayPortfolio);
+        const tPosMap = this._getPublicPositionsMap(todayPortfolio);
+
+        if (yPosMap.size === 0 || tPosMap.size === 0) {
+            return; // No positions to compare
+        }
+
+        for (const [tPosId, tPos] of tPosMap.entries()) {
+            // Check if this position existed yesterday
+            if (yPosMap.has(tPosId)) {
+                const yPos = yPosMap.get(tPosId);
+
+                // 1. Check for Stop Loss adjustment
+                if (tPos.StopLossRate !== yPos.StopLossRate) {
+                    this.sl_adjusted_users.add(userId);
+                }
+
+                // 2. Check for Take Profit adjustment
+                if (tPos.TakeProfitRate !== yPos.TakeProfitRate) {
+                    this.tp_adjusted_users.add(userId);
+                }
+                
+                // 3. Check if TSL was toggled on or off
+                if (tPos.IsTslEnabled !== yPos.IsTslEnabled) {
+                    this.tsl_toggled_users.add(userId);
+                }
+            }
+        }
+    }
+
+    getResult() {
+        return {
+            // Count of unique users who adjusted at least one trade's SL
+            unique_users_adjusted_sl: this.sl_adjusted_users.size,
+            // Count of unique users who adjusted at least one trade's TP
+            unique_users_adjusted_tp: this.tp_adjusted_users.size,
+            // Count of unique users who toggled TSL on or off
+            unique_users_toggled_tsl: this.tsl_toggled_users.size
+        };
+    }
+
+    reset() {
+        this.sl_adjusted_users.clear();
+        this.tp_adjusted_users.clear();
+        this.tsl_toggled_users.clear();
+    }
+}
+
 module.exports = SpeculatorAdjustmentActivity;

package/calculations/asset_metrics/asset_position_size.js

@@ -1,58 +1,58 @@
-/**
- * Calculates the average position size (as a portfolio percentage) for each asset.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class AssetPositionSize {
-    constructor() {
-        this.assets = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights) {
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions)) return;
-
-        for (const position of positions) {
-            const instrumentId = position.InstrumentID;
-            if (!instrumentId) continue;
-
-            if (!this.assets[instrumentId]) {
-                this.assets[instrumentId] = { position_count: 0, position_value_sum: 0 };
-            }
-
-            this.assets[instrumentId].position_count++;
-            // FIX: Use the 'Invested' field, which holds the portfolio percentage
-            this.assets[instrumentId].position_value_sum += (position.Invested || 0);
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-
-        const result = {};
-        for (const instrumentId in this.assets) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            const data = this.assets[instrumentId];
-            
-            if (data.position_count > 0) {
-                result[ticker] = {
-                    // This is now the average *percentage* size
-                    average_position_size: data.position_value_sum / data.position_count,
-                    position_count: data.position_count
-                };
-            }
-        }
-        
-        return result;
-    }
-
-    reset() {
-        this.assets = {};
-        this.mappings = null;
-    }
-}
-
+/**
+ * Calculates the average position size (as a portfolio percentage) for each asset.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class AssetPositionSize {
+    constructor() {
+        this.assets = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights) {
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) return;
+
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            if (!instrumentId) continue;
+
+            if (!this.assets[instrumentId]) {
+                this.assets[instrumentId] = { position_count: 0, position_value_sum: 0 };
+            }
+
+            this.assets[instrumentId].position_count++;
+            // FIX: Use the 'Invested' field, which holds the portfolio percentage
+            this.assets[instrumentId].position_value_sum += (position.Invested || 0);
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+
+        const result = {};
+        for (const instrumentId in this.assets) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.assets[instrumentId];
+            
+            if (data.position_count > 0) {
+                result[ticker] = {
+                    // This is now the average *percentage* size
+                    average_position_size: data.position_value_sum / data.position_count,
+                    position_count: data.position_count
+                };
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.assets = {};
+        this.mappings = null;
+    }
+}
+
 module.exports = AssetPositionSize;