aiden-shared-calculations-unified 1.0.0

package/calculations/asset_metrics/asset_dollar_metrics.js

@@ -0,0 +1,51 @@
+/**
+ * Aggregates the total dollar amount invested in assets,
+ * broken down by profit or loss (from our sample).
+ */
+class AssetDollarMetrics {
+    constructor() {
+        this.assets = {};
+    }
+
+    _initAsset(ticker) {
+        if (!this.assets[ticker]) {
+            this.assets[ticker] = {
+                total_invested_sum: 0,
+                profit_invested_sum: 0,
+                loss_invested_sum: 0
+            };
+        }
+    }
+
+    process(portfolioData, userId, context) {
+        const { instrumentMappings } = context;
+
+        // FIX: Use the correct portfolio position properties
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) return;
+
+        for (const position of positions) {
+            // FIX: Use the correct PascalCase InstrumentID
+            const ticker = instrumentMappings[position.InstrumentID];
+            if (!ticker) continue;
+
+            this._initAsset(ticker);
+
+            // FIX: Use the correct PascalCase InvestedAmount
+            this.assets[ticker].total_invested_sum += position.InvestedAmount;
+
+            // FIX: Use the correct PascalCase NetProfit
+            if (position.NetProfit > 0) {
+                this.assets[ticker].profit_invested_sum += position.InvestedAmount;
+            } else {
+                this.assets[ticker].loss_invested_sum += position.InvestedAmount;
+            }
+        }
+    }
+
+    getResult() {
+        return this.assets;
+    }
+}
+
+module.exports = AssetDollarMetrics;

package/calculations/asset_metrics/asset_position_size.js

@@ -0,0 +1,57 @@
+/**
+ * Calculates the average position size for each asset.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class AssetPositionSize {
+    constructor() {
+        this.assets = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId, context) {
+        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++;
+            this.assets[instrumentId].position_value_sum += (position.InvestedAmount || position.Amount || 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];
+            
+            // REFACTOR: Perform final calculation and return in standardized format.
+            if (data.position_count > 0) {
+                result[ticker] = {
+                    average_position_size: data.position_value_sum / data.position_count,
+                    position_count: data.position_count // Also include count for context
+                };
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.assets = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = AssetPositionSize;

package/calculations/behavioural/drawdown_response.js

@@ -0,0 +1,56 @@
+/**
+ * Analyzes user behavior after a position experiences a >10% drawdown.
+ */
+class DrawdownResponse {
+    constructor() {
+        this.drawdown_events = {
+            held_position: 0,
+            closed_position: 0,
+            added_to_position: 0
+        };
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!yesterdayPortfolio || !todayPortfolio) {
+            return; // Need both days for comparison
+        }
+
+        // FIX: Get the correct positions arrays and ensure they are iterable
+        const yPositions = yesterdayPortfolio.AggregatedPositions || yesterdayPortfolio.PublicPositions;
+        const tPositions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
+
+        if (!yPositions || !Array.isArray(yPositions) || !tPositions || !Array.isArray(tPositions)) {
+            return;
+        }
+
+        // Create a map of today's positions for efficient lookup
+        const todayPositions = new Map(tPositions.map(p => [p.PositionID, p]));
+
+        for (const yPos of yPositions) {
+            const drawdownPercent = yPos.InvestedAmount > 0 ? yPos.ProfitAndLoss / yPos.InvestedAmount : 0;
+
+            // Check if this position was in a >10% drawdown yesterday
+            if (drawdownPercent < -0.10) {
+                const todayPos = todayPositions.get(yPos.PositionID);
+
+                if (!todayPos) {
+                    // Position was closed
+                    this.drawdown_events.closed_position++;
+                } else if (todayPos.InvestedAmount > yPos.InvestedAmount) {
+                    // User added money to the losing position
+                    this.drawdown_events.added_to_position++;
+                } else {
+                    // Position was held (or reduced, but not added to)
+                    this.drawdown_events.held_position++;
+                }
+            }
+        }
+    }
+
+    getResult() {
+        // Return final calculated values
+        return this.drawdown_events;
+    }
+}
+
+module.exports = DrawdownResponse;

package/calculations/behavioural/gain_response.js

@@ -0,0 +1,54 @@
+/**
+ * Analyzes user behavior after a position experiences a >10% gain.
+ */
+class GainResponse {
+    constructor() {
+        this.gain_events = {
+            held_position: 0,
+            closed_position: 0,
+            reduced_position: 0 // e.g., took partial profit
+        };
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!yesterdayPortfolio || !todayPortfolio) {
+            return; // Need both days for comparison
+        }
+
+        // FIX: Get the correct positions arrays and ensure they are iterable
+        const yPositions = yesterdayPortfolio.AggregatedPositions || yesterdayPortfolio.PublicPositions;
+        const tPositions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
+
+        if (!yPositions || !Array.isArray(yPositions) || !tPositions || !Array.isArray(tPositions)) {
+            return;
+        }
+
+        const todayPositions = new Map(tPositions.map(p => [p.PositionID, p]));
+
+        for (const yPos of yPositions) {
+            const gainPercent = yPos.InvestedAmount > 0 ? yPos.ProfitAndLoss / yPos.InvestedAmount : 0;
+
+            // Check if this position was in a >10% gain yesterday
+            if (gainPercent > 0.10) {
+                const todayPos = todayPositions.get(yPos.PositionID);
+
+                if (!todayPos) {
+                    // Position was closed (took full profit)
+                    this.gain_events.closed_position++;
+                } else if (todayPos.InvestedAmount < yPos.InvestedAmount) {
+                    // User reduced the position (took partial profit)
+                    this.gain_events.reduced_position++;
+                } else {
+                    // Position was held (or added to)
+                    this.gain_events.held_position++;
+                }
+            }
+        }
+    }
+
+    getResult() {
+        return this.gain_events;
+    }
+}
+
+module.exports = GainResponse;

package/calculations/behavioural/paper_vs_diamond_hands.js

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Calculates the "Paper Hands vs. Diamond Hands" index.
+ */
+
+class PaperVsDiamondHands {
+    constructor() {
+        this.newPositions = 0;
+        this.closedPositions = 0;
+        this.heldPositions = 0;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const todayIds = new Set((todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions).map(p => p.PositionID || p.InstrumentID));
+        const yesterdayIds = new Set((yesterdayPortfolio.PublicPositions || yesterdayPortfolio.AggregatedPositions).map(p => p.PositionID || p.InstrumentID));
+
+        const newPos = [...todayIds].filter(id => !yesterdayIds.has(id)).length;
+        const closedPos = [...yesterdayIds].filter(id => !todayIds.has(id)).length;
+        const heldPos = [...todayIds].filter(id => yesterdayIds.has(id)).length;
+
+        this.newPositions += newPos;
+        this.closedPositions += closedPos;
+        this.heldPositions += heldPos;
+    }
+
+    getResult() {
+        const totalPositions = this.newPositions + this.closedPositions + this.heldPositions;
+        if (totalPositions === 0) return {};
+
+        return {
+            paper_hands_index: (this.closedPositions / totalPositions) * 100, // High turnover
+            diamond_hands_index: (this.heldPositions / totalPositions) * 100,   // Low turnover
+        };
+    }
+}
+
+module.exports = PaperVsDiamondHands;

package/calculations/behavioural/position_count_pnl.js

@@ -0,0 +1,50 @@
+/**
+ * Aggregates P/L by the number of positions a user holds.
+ * Used to create a dot plot.
+ */
+class PositionCountPnl {
+    constructor() {
+        // We will store sums and counts to calculate averages later
+        this.pnl_by_position_count = {};
+    }
+
+    _initBucket(count) {
+        if (!this.pnl_by_position_count[count]) {
+            this.pnl_by_position_count[count] = { pnl_sum: 0, count: 0 };
+        }
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return; // Need P/L and today's data
+        }
+
+        // FIX: Get the correct positions array
+        const positions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
+        
+        // FIX: Add check to ensure positions is an iterable array
+        if (!positions || !Array.isArray(positions)) {
+            return; // Skip users with no positions array
+        }
+
+        const positionCount = positions.length;
+        if (positionCount === 0) {
+            return; // Skip users with no positions
+        }
+
+        const dailyPnl = todayPortfolio.PortfolioValue - yesterdayPortfolio.PortfolioValue;
+
+        this._initBucket(positionCount);
+        this.pnl_by_position_count[positionCount].pnl_sum += dailyPnl;
+        this.pnl_by_position_count[positionCount].count++;
+    }
+
+    getResult() {
+        // Return the aggregated object.
+        // Frontend will iterate keys, calculate avg (pnl_sum/count),
+        // and plot { x: positionCount, y: avg_pnl }
+        return this.pnl_by_position_count;
+    }
+}
+
+module.exports = PositionCountPnl;

package/calculations/behavioural/smart_money_flow.js

@@ -0,0 +1,166 @@
+/**
+ * @fileoverview Tracks the investment flow of "smart money".
+ */
+
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+// CORRECTED PATH: ../utils/ instead of ../../utils/
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+class SmartMoneyFlow {
+    // ... (rest of the code is unchanged) ...
+    constructor() {
+        this.smartMoneyUsers = new Set();
+        this.sectorFlow = {};
+        this.sectorMap = null; // Cache for the sector map
+    }
+
+    async process(todayPortfolio, yesterdayPortfolio, userId) {
+        // Load smart money users only if the set is empty
+        if (this.smartMoneyUsers.size === 0) {
+            await this.identifySmartMoney();
+             // Log after identification attempt
+             console.log(`Identified ${this.smartMoneyUsers.size} smart money users.`);
+        }
+
+        // Load sector map if not already loaded
+        if (!this.sectorMap) {
+             try {
+                 this.sectorMap = await getInstrumentSectorMap();
+                 if (!this.sectorMap || Object.keys(this.sectorMap).length === 0) {
+                     console.warn('Sector map loaded but is empty.');
+                 } else {
+                    // console.log('Sector map loaded successfully.'); // Optional: remove if too verbose
+                 }
+            } catch (error) {
+                console.error('Failed to load sector map:', error);
+                return; // Stop processing if sector map fails to load
+            }
+        }
+
+        // Check if the current user is considered "smart money"
+        if (this.smartMoneyUsers.has(userId) && todayPortfolio && yesterdayPortfolio) {
+             // Ensure sectorMap is available before proceeding
+            if (!this.sectorMap) {
+                console.warn(`Skipping user ${userId}: Sector map not available.`);
+                return;
+            }
+            const todaySectorInvestment = this.calculateSectorInvestment(todayPortfolio);
+            const yesterdaySectorInvestment = this.calculateSectorInvestment(yesterdayPortfolio);
+
+            // Calculate change in investment per sector
+            const allSectors = new Set([...Object.keys(todaySectorInvestment), ...Object.keys(yesterdaySectorInvestment)]);
+            for (const sector of allSectors) {
+                const todayAmount = todaySectorInvestment[sector] || 0;
+                const yesterdayAmount = yesterdaySectorInvestment[sector] || 0;
+                const change = todayAmount - yesterdayAmount;
+
+                // Only record if there is a change
+                if (change !== 0) {
+                     if (!this.sectorFlow[sector]) {
+                        this.sectorFlow[sector] = 0;
+                    }
+                    this.sectorFlow[sector] += change;
+                }
+            }
+        } else {
+             // Optional: Log why processing is skipped for a user
+             // if (!this.smartMoneyUsers.has(userId)) console.log(`User ${userId} is not smart money.`);
+             // if (!todayPortfolio) console.log(`User ${userId}: Missing today's portfolio.`);
+             // if (!yesterdayPortfolio) console.log(`User ${userId}: Missing yesterday's portfolio.`);
+        }
+    }
+
+     async identifySmartMoney() {
+        console.log("Attempting to identify smart money users...");
+        try {
+            // Fetching sharded profitability data
+            const shardPromises = [];
+            const NUM_SHARDS = 50; // Ensure this matches the value used in user_profitability_tracker
+            for (let i = 0; i < NUM_SHARDS; i++) {
+                // Corrected document path for shards
+                const docRef = firestore.collection('historical_insights').doc(`user_profitability_shard_${i}`);
+                shardPromises.push(docRef.get());
+            }
+            const shardSnapshots = await Promise.all(shardPromises);
+
+            let profitableUsersFound = 0;
+            shardSnapshots.forEach((snap, index) => {
+                if (snap.exists) {
+                    const shardData = snap.data().profits || {}; // Assuming data structure { profits: { userId: [...] } }
+                    for (const userId in shardData) {
+                        const history = shardData[userId];
+                        // Check if history is an array and has enough entries
+                        if (Array.isArray(history) && history.length >= 5) {
+                             // "Smart money" definition: profitable for at least 5 of the last 7 days
+                             // Filter based on the 'pnl' property of each history entry
+                             const profitableDays = history.slice(-7).filter(d => d && typeof d.pnl === 'number' && d.pnl > 0).length;
+                             if (profitableDays >= 5) {
+                                this.smartMoneyUsers.add(userId);
+                                profitableUsersFound++;
+                            }
+                        }
+                    }
+                } else {
+                     console.warn(`Profitability shard user_profitability_shard_${index} does not exist.`);
+                }
+            });
+             console.log(`Found ${profitableUsersFound} potentially smart money users across all shards.`);
+
+        } catch (error) {
+            console.error('Error identifying smart money users:', error);
+            // Decide how to handle error: maybe retry, or proceed without smart money data
+            this.smartMoneyUsers.clear(); // Ensure set is empty on error
+        }
+         // Final check after attempt
+         if (this.smartMoneyUsers.size === 0) {
+            console.warn("No smart money users identified. Smart money flow calculation might be empty.");
+        }
+    }
+
+
+    calculateSectorInvestment(portfolio) {
+        const sectorInvestment = {};
+         // Ensure sectorMap is loaded
+         if (!this.sectorMap) {
+             console.warn("Cannot calculate sector investment: Sector map not loaded.");
+             return sectorInvestment; // Return empty object
+         }
+
+        // Use AggregatedPositions as it contains 'Invested' amount
+        if (portfolio && portfolio.AggregatedPositions && Array.isArray(portfolio.AggregatedPositions)) {
+            for (const pos of portfolio.AggregatedPositions) {
+                 if (pos && typeof pos.InstrumentID !== 'undefined' && typeof pos.Invested === 'number') {
+                    const sector = this.sectorMap[pos.InstrumentID] || 'N/A';
+                    if (!sectorInvestment[sector]) {
+                        sectorInvestment[sector] = 0;
+                    }
+                    sectorInvestment[sector] += pos.Invested;
+                } else {
+                     // Log potentially malformed position data
+                     // console.warn('Skipping position due to missing InstrumentID or Invested amount:', pos);
+                }
+            }
+        } else {
+             // Log if AggregatedPositions are missing or not an array
+             // console.warn('AggregatedPositions missing or invalid in portfolio for sector investment calculation.');
+        }
+        return sectorInvestment;
+    }
+
+
+    getResult() {
+        // Return only sectors with non-zero flow if desired, or the full object
+         const filteredFlow = {};
+         for (const sector in this.sectorFlow) {
+             if (this.sectorFlow[sector] !== 0) {
+                 filteredFlow[sector] = this.sectorFlow[sector];
+             }
+         }
+         // console.log("Final Smart Money Flow:", filteredFlow); // Optional: Log final result
+        return { smart_money_flow: filteredFlow };
+        // Or return the full object: return { smart_money_flow: this.sectorFlow };
+    }
+}
+
+module.exports = SmartMoneyFlow;

package/calculations/pnl/asset_pnl_status.js

@@ -0,0 +1,47 @@
+/**
+ * Counts the number of users in profit vs. loss for each asset (from our sample).
+ * This data is used for extrapolation with the ground truth owner count.
+ */
+class AssetPnlStatus {
+    constructor() {
+        this.assets = {};
+    }
+
+    _initAsset(ticker) {
+        if (!this.assets[ticker]) {
+            this.assets[ticker] = { profit_count: 0, loss_count: 0 };
+        }
+    }
+
+    process(portfolioData, userId, context) {
+        const { instrumentMappings } = context;
+        const processedTickers = new Set(); // Ensure one user is only counted once per ticker
+
+        // FIX: Use the correct portfolio position properties
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) return;
+
+        for (const position of positions) {
+            // FIX: Use the correct PascalCase InstrumentID
+            const ticker = instrumentMappings[position.InstrumentID];
+            if (!ticker || processedTickers.has(ticker)) continue;
+
+            this._initAsset(ticker);
+
+            // FIX: Use the correct PascalCase NetProfit
+            if (position.NetProfit > 0) {
+                this.assets[ticker].profit_count++;
+            } else {
+                this.assets[ticker].loss_count++;
+            }
+            processedTickers.add(ticker);
+        }
+    }
+
+    getResult() {
+        // Returns raw counts for frontend extrapolation
+        return this.assets;
+    }
+}
+
+module.exports = AssetPnlStatus;

package/calculations/pnl/average_daily_pnl_all_users.js

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Calculates the average PnL (NetProfit %) on a per-user basis, and then averages those user PnLs.
+ * This metric answers: "What was the average daily PnL for the average user?"
+ */
+
+class AverageDailyPnlAllUsers {
+    constructor() {
+        this.totalOfUserAveragePnls = 0;
+        this.userCount = 0;
+    }
+
+    process(portfolioData, userId, context) {
+        if (!portfolioData || !portfolioData.AggregatedPositions || portfolioData.AggregatedPositions.length === 0) {
+            return;
+        }
+
+        let userTotalPnl = 0;
+        const positionCount = portfolioData.AggregatedPositions.length;
+
+        for (const position of portfolioData.AggregatedPositions) {
+            userTotalPnl += position.NetProfit;
+        }
+
+        const userAveragePnl = userTotalPnl / positionCount;
+        this.totalOfUserAveragePnls += userAveragePnl;
+        this.userCount++;
+    }
+
+    getResult() {
+        if (this.userCount === 0) {
+            return {};
+        }
+
+        // REFACTOR: Perform the final calculation directly.
+        const average_daily_pnl = this.totalOfUserAveragePnls / this.userCount;
+
+        return {
+            average_daily_pnl: average_daily_pnl
+        };
+    }
+
+    reset() {
+        this.totalOfUserAveragePnls = 0;
+        this.userCount = 0;
+    }
+}
+
+module.exports = AverageDailyPnlAllUsers;

package/calculations/pnl/average_daily_pnl_per_sector.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Calculates the average daily PnL (NetProfit %) for each sector.
+ * This is a simple average, not weighted by position size.
+ */
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+class AverageDailyPnlPerSector {
+    constructor() {
+        this.positions = [];
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.AggregatedPositions) {
+            this.positions.push(...portfolioData.AggregatedPositions);
+        }
+    }
+
+    async getResult() {
+        if (this.positions.length === 0) return {};
+
+        const sectorPnlSum = {};
+        const positionCountBySector = {};
+        const sectorMap = await getInstrumentSectorMap();
+
+        for (const position of this.positions) {
+            const instrumentId = position.InstrumentID;
+            const sector = sectorMap[instrumentId] || 'N/A';
+
+            sectorPnlSum[sector] = (sectorPnlSum[sector] || 0) + position.NetProfit;
+            positionCountBySector[sector] = (positionCountBySector[sector] || 0) + 1;
+        }
+
+        const result = {};
+        for (const sector in sectorPnlSum) {
+            // REFACTOR: Calculate the final average directly.
+            result[sector] = {
+                average_pnl: sectorPnlSum[sector] / positionCountBySector[sector]
+            };
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.positions = [];
+    }
+}
+
+module.exports = AverageDailyPnlPerSector;

package/calculations/pnl/average_daily_pnl_per_stock.js

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Calculates the average daily PnL (NetProfit) for each individual stock.
+ * This metric answers: "What was the average PnL for a position in this specific stock?"
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class AverageDailyPnlPerStock {
+    constructor() {
+        this.pnlData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId, context) {
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions) {
+            return;
+        }
+
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            const netProfit = position.NetProfit;
+
+            if (!this.pnlData[instrumentId]) {
+                this.pnlData[instrumentId] = {
+                    pnl_sum: 0,
+                    position_count: 0
+                };
+            }
+
+            this.pnlData[instrumentId].pnl_sum += netProfit;
+            this.pnlData[instrumentId].position_count++;
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+
+        const result = {};
+        for (const instrumentId in this.pnlData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.pnlData[instrumentId];
+            
+            // REFACTOR: Perform the final calculation directly.
+            if (data.position_count > 0) {
+                 result[ticker] = {
+                    average_daily_pnl: data.pnl_sum / data.position_count
+                 };
+            }
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.pnlData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = AverageDailyPnlPerStock;