aiden-shared-calculations-unified 1.0.95 → 1.0.96

package/calculations/legacy/dumb-cohort-flow.js

@@ -1,238 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 3) for dumb cohort flow.
- *
- * This metric calculates the "Net Crowd Flow Percentage" for the
- * "Dumb Cohort" (bottom 20% of investors).
- *
- * This calculation *depends* on 'user_profitability_tracker'
- * to identify the cohort.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class DumbCohortFlow {
-    constructor() {
-        this.assetData = new Map();
-        this.sectorData = new Map();
-        this.mappings = null;
-        this.dumbCohortUserIds = null;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const flowSchema = {
-            "type": "object",
-            "properties": {
-                "net_flow_percentage": { "type": "number" },
-                "total_invested_today": { "type": "number" },
-                "total_invested_yesterday": { "type": "number" }
-            },
-            "required": ["net_flow_percentage", "total_invested_today", "total_invested_yesterday"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates net capital flow % (price-adjusted) for the 'Dumb Cohort' (bottom 20% users), aggregated by asset and sector.",
-            "properties": {
-                "cohort_size": {
-                    "type": "number",
-                    "description": "The number of users identified as being in the Dumb Cohort."
-                },
-                "assets": {
-                    "type": "object",
-                    "description": "Price-adjusted net flow per asset.",
-                    "patternProperties": { "^.*$": flowSchema }, // Ticker
-                    "additionalProperties": flowSchema
-                },
-                "sectors": {
-                    "type": "object",
-                    "description": "Price-adjusted net flow per sector.",
-                    "patternProperties": { "^.*$": flowSchema }, // Sector
-                    "additionalProperties": flowSchema
-                }
-            },
-            "required": ["cohort_size", "assets", "sectors"]
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return ['user_profitability_tracker']; 
-    }
-
-    _getPortfolioPositions(portfolio) {
-        return portfolio?.PublicPositions || portfolio?.AggregatedPositions;
-    }
-
-    _initAsset(instrumentId) {
-        if (!this.assetData.has(instrumentId)) {
-            this.assetData.set(instrumentId, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0,
-            });
-        }
-    }
-    
-    _initSector(sector) {
-        if (!this.sectorData.has(sector)) {
-            this.sectorData.set(sector, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0,
-            });
-        }
-    }
-
-    /**
-     * Helper to get the cohort IDs from the dependency.
-     */
-    _getDumbCohort(fetchedDependencies) {
-        if (this.dumbCohortUserIds) {
-            return this.dumbCohortUserIds;
-        }
-        
-        const profitabilityData = fetchedDependencies['user_profitability_tracker'];
-        if (!profitabilityData || !profitabilityData.ranked_users) {
-            return new Set();
-        }
-
-        const rankedUsers = profitabilityData.ranked_users;
-        const cohortSize = Math.floor(rankedUsers.length * 0.20);
-        
-        // The 'ranked_users' are sorted ascending by P&L, so bottom 20% is the first 20%.
-        this.dumbCohortUserIds = new Set(rankedUsers.slice(0, cohortSize).map(u => u.userId));
-        return this.dumbCohortUserIds;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        const dumbCohort = this._getDumbCohort(fetchedDependencies);
-        
-        // This user is not in the "dumb cohort", skip.
-        if (!dumbCohort.has(userId)) {
-            return;
-        }
-
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
-        const tPos = this._getPortfolioPositions(todayPortfolio);
-
-        const yPosMap = new Map(yPos?.map(p => [p.InstrumentID, p]) || []);
-        const tPosMap = new Map(tPos?.map(p => [p.InstrumentID, p]) || []);
-
-        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
-        
-        if (!this.mappings) {
-            // Context contains the mappings loaded in Pass 1
-            this.mappings = context.mappings;
-        }
-
-        for (const instrumentId of allInstrumentIds) {
-            if (!instrumentId) continue;
-            
-            this._initAsset(instrumentId);
-            const asset = this.assetData.get(instrumentId);
-
-            const yP = yPosMap.get(instrumentId);
-            const tP = tPosMap.get(instrumentId);
-
-            const yInvested = yP?.InvestedAmount || yP?.Amount || 0;
-            const tInvested = tP?.InvestedAmount || tP?.Amount || 0;
-            
-            // Get sector and initialize it
-            const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
-            this._initSector(sector);
-            const sectorAsset = this.sectorData.get(sector);
-
-            if (yInvested > 0) {
-                const yPriceChange = (yP?.PipsRate || 0) / (yP?.OpenRate || 1);
-                
-                asset.total_invested_yesterday += yInvested;
-                asset.price_change_yesterday += yPriceChange * yInvested;
-                
-                sectorAsset.total_invested_yesterday += yInvested;
-                sectorAsset.price_change_yesterday += yPriceChange * yInvested;
-            }
-            if (tInvested > 0) {
-                asset.total_invested_today += tInvested;
-                sectorAsset.total_invested_today += tInvested;
-            }
-        }
-    }
-    
-    _calculateFlow(dataMap) {
-        const result = {};
-        for (const [key, data] of dataMap.entries()) {
-            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
-            
-            if (total_invested_yesterday > 0) {
-                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
-                const price_contribution = total_invested_yesterday * avg_price_change_pct;
-                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
-                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-                
-                result[key] = {
-                    net_flow_percentage: net_flow_percentage,
-                    total_invested_today: total_invested_today,
-                    total_invested_yesterday: total_invested_yesterday
-                };
-            }
-        }
-        return result;
-    }
-
-    async getResult(fetchedDependencies) {
-        // Ensure mappings are loaded (can be from context or loaded now)
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        
-        // Ensure cohort is calculated at least once
-        const dumbCohort = this._getDumbCohort(fetchedDependencies);
-
-        // 1. Calculate Asset Flow
-        const assetResult = {};
-        for (const [instrumentId, data] of this.assetData.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
-            
-            if (total_invested_yesterday > 0) {
-                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
-                const price_contribution = total_invested_yesterday * avg_price_change_pct;
-                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
-                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-                
-                assetResult[ticker] = {
-                    net_flow_percentage: net_flow_percentage,
-                    total_invested_today: total_invested_today,
-                    total_invested_yesterday: total_invested_yesterday
-                };
-            }
-        }
-        
-        // 2. Calculate Sector Flow
-        const sectorResult = this._calculateFlow(this.sectorData);
-
-        return {
-            cohort_size: dumbCohort.size,
-            assets: assetResult,
-            sectors: sectorResult
-        };
-    }
-
-    reset() {
-        this.assetData.clear();
-        this.sectorData.clear();
-        this.mappings = null;
-        this.dumbCohortUserIds = null;
-    }
-}
-
-module.exports = DumbCohortFlow;

package/calculations/legacy/gain_response.js

@@ -1,137 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for gain response.
- *
- * This metric answers: "How do users behave when a position has a
- * gain of over 10%?"
- *
- * It checks all positions from yesterday that were in >10% profit
- * and tracks whether the user:
- * 1. Held (position still open today, same size)
- * 2. Closed (position no longer open today)
- * 3. Reduced (position still open, but Invested % is smaller)
- */
-class GainResponse {
-    constructor() {
-        this.actions = {
-            held: 0,
-            closed: 0,
-            reduced: 0
-        };
-        this.total_in_gain = 0;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Analyzes user behavior in response to a >10% position gain.",
-            "properties": {
-                "total_positions_in_gain": {
-                    "type": "number",
-                    "description": "Total positions from yesterday that were in >10% gain."
-                },
-                "action_held_pct": {
-                    "type": "number",
-                    "description": "Percentage of gain positions that were held."
-                },
-                "action_closed_pct": {
-                    "type": "number",
-                    "description": "Percentage of gain positions that were closed (profit-taking)."
-                },
-                "action_reduced_pct": {
-                    "type": "number",
-                    "description": "Percentage of gain positions that were reduced (scaling out)."
-                },
-                "raw_counts": {
-                    "type": "object",
-                    "properties": {
-                        "held": { "type": "number" },
-                        "closed": { "type": "number" },
-                        "reduced": { "type": "number" }
-                    },
-                    "required": ["held", "closed", "reduced"]
-                }
-            },
-            "required": ["total_positions_in_gain", "action_held_pct", "action_closed_pct", "action_reduced_pct", "raw_counts"]
-        };
-    }
-
-    _getPortfolioMap(portfolio) {
-        // We MUST use PositionID to track specific trades
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
-        }
-        // Map<PositionID, { pnl: number, invested: number }>
-        return new Map(positions.map(p => [p.PositionID, {
-            pnl: (p.NetProfit || 0) / (p.InvestedAmount || p.Amount || 1), // PNL as %
-            invested: p.InvestedAmount || p.Amount || 0
-        }]));
-    }
-
-    process(todayPortfolio, yesterdayPortfolio) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPosMap = this._getPortfolioMap(yesterdayPortfolio);
-        const tPosMap = this._getPortfolioMap(todayPortfolio);
-
-        if (yPosMap.size === 0) {
-            return;
-        }
-
-        for (const [yPosId, yPosData] of yPosMap.entries()) {
-            // Check if position was in >10% gain
-            if (yPosData.pnl > 0.10) {
-                this.total_in_gain++;
-
-                // Now, check what happened today
-                if (!tPosMap.has(yPosId)) {
-                    // 1. Position was closed (Profit Taking)
-                    this.actions.closed++;
-                } else {
-                    const tPosData = tPosMap.get(yPosId);
-                    // 2. Position was reduced (check for > 1% reduction to avoid noise)
-                    if (tPosData.invested < (yPosData.invested * 0.99)) {
-                        this.actions.reduced++;
-                    } else {
-                        // 3. Position was held
-                        this.actions.held++;
-                    }
-                }
-            }
-        }
-    }
-
-    getResult() {
-        const total = this.total_in_gain;
-        if (total === 0) {
-            return {
-                total_positions_in_gain: 0,
-                action_held_pct: 0,
-                action_closed_pct: 0,
-                action_reduced_pct: 0,
-                raw_counts: this.actions
-            };
-        }
-
-        return {
-            total_positions_in_gain: total,
-            action_held_pct: (this.actions.held / total) * 100,
-            action_closed_pct: (this.actions.closed / total) * 100,
-            action_reduced_pct: (this.actions.reduced / total) * 100,
-            raw_counts: this.actions
-        };
-    }
-
-    reset() {
-        this.actions = { held: 0, closed: 0, reduced: 0 };
-        this.total_in_gain = 0;
-    }
-}
-
-module.exports = GainResponse;

package/calculations/legacy/historical_performance_aggregator.js

@@ -1,85 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for aggregating user performance.
- *
- * This class processes each user's daily P&L and aggregates it into
- * buckets for statistical analysis. It collects all individual P&Ls
- * to build a distribution.
- *
- * This is a foundational calculation needed by many Pass 3 metrics.
- */
-class HistoricalPerformanceAggregator {
-    constructor() {
-        // Stores the 7-day weighted P&L for every user.
-        this.userPnlHistory = [];
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Aggregates historical P&L from 'user_profitability_tracker' for all users to build a performance distribution.",
-            "properties": {
-                "user_pnl_distribution": {
-                    "type": "array",
-                    "description": "An array of 7-day weighted average P&L values, one for each user.",
-                    "items": { "type": "number" }
-                },
-                "user_count": {
-                    "type": "number",
-                    "description": "Total number of users processed."
-                }
-            },
-            "required": ["user_pnl_distribution", "user_count"]
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return ['user_profitability_tracker'];
-    }
-
-    /**
-     * process() is a no-op. All logic is in getResult().
-     * This calculation doesn't process portfolios; it processes
-     * the *result* of another calculation.
-     */
-    process() {
-        // No-op
-    }
-
-    /**
-     * Aggregates results from the dependency.
-     */
-    getResult(fetchedDependencies) {
-        const profitabilityData = fetchedDependencies['user_profitability_tracker'];
-        
-        if (!profitabilityData || !profitabilityData.user_details) {
-            return {
-                user_pnl_distribution: [],
-                user_count: 0
-            };
-        }
-        
-        // Extract the 7-day weighted P&L for all users
-        const pnlDistribution = Object.values(profitabilityData.user_details)
-            .map(details => details.weighted_avg_pnl_7d)
-            // Filter out any null/undefined/NaN values
-            .filter(pnl => typeof pnl === 'number' && !isNaN(pnl));
-
-        return {
-            user_pnl_distribution: pnlDistribution,
-            user_count: pnlDistribution.length
-        };
-    }
-
-    reset() {
-        this.userPnlHistory = [];
-    }
-}
-
-module.exports = HistoricalPerformanceAggregator;

package/calculations/legacy/in_loss_asset_crowd_flow.js

@@ -1,168 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 3) for "In Loss" cohort asset flow.
- *
- * --- MODIFIED ---
- * Removed dependency on 'asset_pnl_status' to fix 1MiB limit.
- * This calculation now determines "in loss" status internally
- * by reading the *yesterday's* portfolio P&L directly.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class InLossAssetCrowdFlow {
-    constructor() {
-        this.assetData = new Map();
-        this.mappings = null;
-        // No longer need this:
-        // this.inLossCohorts = null; 
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Calculates net capital flow % (price-adjusted) per asset, but only for the cohort of users currently in loss on that asset.",
-            "patternProperties": {
-                // Ticker
-                "^.*$": {
-                    "type": "object",
-                    "description": "Net flow metrics for a specific asset ticker from its 'in loss' cohort.",
-                    "properties": {
-                        "net_flow_percentage": {
-                            "type": "number",
-                            "description": "Net capital flow % from the 'in loss' cohort, adjusted for price changes."
-                        },
-                        "total_invested_today": { "type": "number" },
-                        "total_invested_yesterday": { "type": "number" },
-                        "cohort_size": { "type": "number" }
-                    },
-                    "required": ["net_flow_percentage", "total_invested_today", "total_invested_yesterday", "cohort_size"]
-                }
-            },
-            "additionalProperties": {
-                "type": "object",
-                "properties": {
-                    "net_flow_percentage": { "type": "number" },
-                    "total_invested_today": { "type": "number" },
-                    "total_invested_yesterday": { "type": "number" },
-                    "cohort_size": { "type": "number" }
-                }
-            }
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     * --- MODIFIED ---
-     * Removed 'asset_pnl-status'
-     */
-    static getDependencies() {
-        return [];
-    }
-
-    _getPortfolioPositions(portfolio) {
-        return portfolio?.PublicPositions || portfolio?.AggregatedPositions;
-    }
-
-    _initAsset(instrumentId) {
-        if (!this.assetData.has(instrumentId)) {
-            this.assetData.set(instrumentId, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0,
-                cohort: new Set()
-            });
-        }
-    }
-
-    // --- MODIFIED ---
-    // Removed _getInLossCohorts helper
-
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        if (!this.mappings) {
-            this.mappings = context.mappings;
-        }
-        
-        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
-        const tPos = this._getPortfolioPositions(todayPortfolio);
-
-        const yPosMap = new Map(yPos?.map(p => [p.InstrumentID, p]) || []);
-        const tPosMap = new Map(tPos?.map(p => [p.InstrumentID, p]) || []);
-
-        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
-
-        for (const instrumentId of allInstrumentIds) {
-            if (!instrumentId) continue;
-            
-            const yP = yPosMap.get(instrumentId);
-            const tP = tPosMap.get(instrumentId);
-
-            // --- MODIFIED ---
-            // Check P&L from YESTERDAY's position to define cohort
-            const yPnl = yP?.NetProfit || 0;
-            if (yPnl >= 0) {
-                continue; // User was not in loss yesterday, skip.
-            }
-            // --- END MODIFIED ---
-            
-            // User *is* in the cohort, process their data
-            this._initAsset(instrumentId);
-            const asset = this.assetData.get(instrumentId);
-            asset.cohort.add(userId); // Track cohort size
-
-            const yInvested = yP?.InvestedAmount || yP?.Amount || 0;
-            const tInvested = tP?.InvestedAmount || tP?.Amount || 0;
-
-            if (yInvested > 0) {
-                asset.total_invested_yesterday += yInvested;
-                const yPriceChange = (yP?.PipsRate || 0) / (yP?.OpenRate || 1);
-                asset.price_change_yesterday += yPriceChange * yInvested;
-            }
-            if (tInvested > 0) {
-                asset.total_invested_today += tInvested;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-
-        const result = {};
-
-        for (const [instrumentId, data] of this.assetData.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-
-            const { total_invested_yesterday, total_invested_today, price_change_yesterday, cohort } = data;
-
-            if (total_invested_yesterday > 0) {
-                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
-                const price_contribution = total_invested_yesterday * avg_price_change_pct;
-                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
-                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-
-                result[ticker] = {
-                    net_flow_percentage: net_flow_percentage,
-                    total_invested_today: total_invested_today,
-                    total_invested_yesterday: total_invested_yesterday,
-                    cohort_size: cohort.size
-                };
-            }
-        }
-        return result;
-    }
-
-    reset() {
-        this.assetData.clear();
-        this.mappings = null;
-    }
-}
-
-module.exports = InLossAssetCrowdFlow;