aiden-shared-calculations-unified 1.0.95 → 1.0.97

package/calculations/legacy/in_profit_asset_crowd_flow.js

@@ -1,168 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 3) for "In Profit" cohort asset flow.
- *
- * --- MODIFIED ---
- * Removed dependency on 'asset_pnl_status' to fix 1MiB limit.
- * This calculation now determines "in profit" status internally
- * by reading the *yesterday's* portfolio P&L directly.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class InProfitAssetCrowdFlow {
-    constructor() {
-        this.assetData = new Map();
-        this.mappings = null;
-        // No longer need this:
-        // this.inProfitCohorts = 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 profit on that asset.",
-            "patternProperties": {
-                // Ticker
-                "^.*$": {
-                    "type": "object",
-                    "description": "Net flow metrics for a specific asset ticker from its 'in profit' cohort.",
-                    "properties": {
-                        "net_flow_percentage": {
-                            "type": "number",
-                            "description": "Net capital flow % from the 'in profit' 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 _getInProfitCohorts 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 profit 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 = InProfitAssetCrowdFlow;

package/calculations/legacy/negative_expectancy_cohort_flow.js

@@ -1,232 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 4) for negative expectancy cohort flow.
- *
- * This metric calculates the "Net Crowd Flow Percentage" for the
- * "Negative Expectancy Cohort" (users with a low expectancy score).
- *
- * This calculation *depends* on 'user_expectancy_score'
- * to identify the cohort.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class NegativeExpectancyCohortFlow {
-    constructor() {
-        this.assetData = new Map();
-        this.sectorData = new Map();
-        this.mappings = null;
-        this.negExpCohortUserIds = 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 'Negative Expectancy' cohort (score < 0.2), aggregated by asset and sector.",
-            "properties": {
-                "cohort_size": {
-                    "type": "number",
-                    "description": "The number of users identified as being in the Negative Expectancy 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_expectancy_score']; // Pass 3
-    }
-
-    _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,
-            });
-        }
-    }
-
-    _getNegExpCohort(fetchedDependencies) {
-        if (this.negExpCohortUserIds) {
-            return this.negExpCohortUserIds;
-        }
-        
-        const expectancyData = fetchedDependencies['user_expectancy_score'];
-        if (!expectancyData) {
-            return new Set();
-        }
-
-        this.negExpCohortUserIds = new Set();
-        for (const [userId, data] of Object.entries(expectancyData)) {
-            // Definition: Expectancy score < 0.2
-            if (data.expectancy_score < 0.2) {
-                this.negExpCohortUserIds.add(userId);
-            }
-        }
-        return this.negExpCohortUserIds;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        const cohort = this._getNegExpCohort(fetchedDependencies);
-        
-        if (!cohort.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) {
-            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;
-            
-            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) {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        
-        const cohort = this._getNegExpCohort(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: cohort.size,
-            assets: assetResult,
-            sectors: sectorResult
-        };
-    }
-
-    reset() {
-        this.assetData.clear();
-        this.sectorData.clear();
-        this.mappings = null;
-        this.negExpCohortUserIds = null;
-    }
-}
-
-module.exports = NegativeExpectancyCohortFlow;

package/calculations/legacy/new_allocation_percentage.js

@@ -1,98 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for new allocation percentage.
- *
- * This metric answers: "On average, what percentage of a user's
- * portfolio was allocated to *new* positions today?"
- *
- * This measures the flow of capital into new ideas vs. existing ones.
- */
-class NewAllocationPercentage {
-    constructor() {
-        this.total_new_allocation_pct = 0;
-        this.users_with_new_positions = 0;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Calculates the average portfolio percentage allocated to *new* positions today.",
-            "properties": {
-                "average_new_allocation_pct": {
-                    "type": "number",
-                    "description": "The average percentage of a portfolio allocated to new positions, for users who opened new positions."
-                },
-                "total_new_allocation_pct_sum": {
-                    "type": "number",
-                    "description": "The sum of all new allocation percentages."
-                },
-                "user_count_with_new_positions": {
-                    "type": "number",
-                    "description": "The count of users who opened at least one new position."
-                }
-            },
-            "required": ["average_new_allocation_pct", "total_new_allocation_pct_sum", "user_count_with_new_positions"]
-        };
-    }
-
-    _getPortfolioPositionMap(portfolio) {
-        // We MUST use AggregatedPositions for the 'Invested' %
-        const positions = portfolio?.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
-        }
-        // Map<InstrumentID, { invested: number }>
-        return new Map(positions.map(p => [p.InstrumentID, {
-            invested: p.InvestedAmount || p.Invested || 0
-        }]));
-    }
-
-    process(todayPortfolio, yesterdayPortfolio) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPosMap = this._getPortfolioPositionMap(yesterdayPortfolio);
-        const tPosMap = this._getPortfolioPositionMap(todayPortfolio);
-
-        if (tPosMap.size === 0) {
-            return; // No positions today
-        }
-
-        let userNewAllocationPct = 0;
-
-        for (const [tId, tPosData] of tPosMap.entries()) {
-            // Check if this position is new (in today but not yesterday)
-            if (!yPosMap.has(tId)) {
-                userNewAllocationPct += tPosData.invested;
-            }
-        }
-
-        if (userNewAllocationPct > 0) {
-            this.total_new_allocation_pct += userNewAllocationPct;
-            this.users_with_new_positions++;
-        }
-    }
-
-    getResult() {
-        const avg_pct = (this.users_with_new_positions > 0)
-            ? (this.total_new_allocation_pct / this.users_with_new_positions)
-            : 0;
-
-        return {
-            average_new_allocation_pct: avg_pct,
-            total_new_allocation_pct_sum: this.total_new_allocation_pct,
-            user_count_with_new_positions: this.users_with_new_positions
-        };
-    }
-
-    reset() {
-        this.total_new_allocation_pct = 0;
-        this.users_with_new_positions = 0;
-    }
-}
-
-module.exports = NewAllocationPercentage;

package/calculations/legacy/paper_vs_diamond_hands.js

@@ -1,107 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for Paper vs Diamond Hands.
- *
- * This metric provides a simple ratio of positions that were
- * closed today ("paper hands") vs. positions that were held
- * ("diamond hands").
- *
- * It gives a general sense of market turnover.
- */
-class PaperVsDiamondHands {
-    constructor() {
-        this.paper_hands = 0; // Positions closed
-        this.diamond_hands = 0; // Positions held
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Calculates the ratio of positions closed ('paper hands') vs. held ('diamond hands') from yesterday to today.",
-            "properties": {
-                "paper_hands_count": {
-                    "type": "number",
-                    "description": "Total count of positions that existed yesterday but were closed today."
-                },
-                "diamond_hands_count": {
-                    "type": "number",
-                    "description": "Total count of positions that existed yesterday and are still held today."
-                },
-                "total_positions_yesterday": {
-                    "type": "number",
-                    "description": "The sum of paper and diamond hands counts."
-                },
-                "paper_hands_ratio": {
-                    "type": "number",
-                    "description": "Ratio of paper hands to diamond hands (Paper / Diamond). Null if no diamond hands."
-                },
-                "paper_hands_pct": {
-                    "type": "number",
-                    "description": "Percentage of positions that were 'paper handed' (closed)."
-                },
-                "diamond_hands_pct": {
-                    "type": "number",
-                    "description": "Percentage of positions that were 'diamond handed' (held)."
-                }
-            },
-            "required": ["paper_hands_count", "diamond_hands_count", "total_positions_yesterday", "paper_hands_pct", "diamond_hands_pct"]
-        };
-    }
-
-    _getPortfolioPositionIds(portfolio) {
-        // We MUST use PositionID to track specific trades
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Set();
-        }
-        return new Set(positions.map(p => p.PositionID).filter(Boolean));
-    }
-
-    process(todayPortfolio, yesterdayPortfolio) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPosIds = this._getPortfolioPositionIds(yesterdayPortfolio);
-        const tPosIds = this._getPortfolioPositionIds(todayPortfolio);
-
-        if (yPosIds.size === 0) {
-            return; // No positions yesterday to analyze
-        }
-
-        for (const yPosId of yPosIds) {
-            if (tPosIds.has(yPosId)) {
-                // Position was held
-                this.diamond_hands++;
-            } else {
-                // Position was closed
-                this.paper_hands++;
-            }
-        }
-    }
-
-    getResult() {
-        const total = this.paper_hands + this.diamond_hands;
-        
-        return {
-            paper_hands_count: this.paper_hands,
-            diamond_hands_count: this.diamond_hands,
-            total_positions_yesterday: total,
-            // Ratio of paper-to-diamond. Can be null if diamond_hands is 0.
-            paper_hands_ratio: (this.diamond_hands > 0) ? (this.paper_hands / this.diamond_hands) : null,
-            // Percentage of total positions
-            paper_hands_pct: (total > 0) ? (this.paper_hands / total) * 100 : 0,
-            diamond_hands_pct: (total > 0) ? (this.diamond_hands / total) * 100 : 0,
-        };
-    }
-
-    reset() {
-        this.paper_hands = 0;
-        this.diamond_hands = 0;
-    }
-}
-
-module.exports = PaperVsDiamondHands;