aiden-shared-calculations-unified 1.0.0

package/calculations/pnl/average_daily_position_pnl.js

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Calculates the overall average PnL (NetProfit %) across every single position held by the crowd.
+ * This gives a high-level view of whether the average position is in profit or loss.
+ */
+
+class AverageDailyPositionPnl {
+    constructor() {
+        this.totalNetProfit = 0;
+        this.totalPositions = 0;
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.AggregatedPositions) {
+            for (const position of portfolioData.AggregatedPositions) {
+                this.totalNetProfit += position.NetProfit;
+                this.totalPositions++;
+            }
+        }
+    }
+
+    getResult() {
+        if (this.totalPositions === 0) {
+            return {};
+        }
+
+        // REFACTOR: Perform the final calculation directly.
+        const average_daily_position_pnl = this.totalNetProfit / this.totalPositions;
+
+        return {
+            average_daily_position_pnl
+        };
+    }
+
+    reset() {
+        this.totalNetProfit = 0;
+        this.totalPositions = 0;
+    }
+}
+
+module.exports = AverageDailyPositionPnl;

package/calculations/pnl/pnl_distribution_per_stock.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Calculates the necessary components to determine the statistical variance of PnL for each stock,
+ * serving as a proxy for crowd volatility.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class PnlDistributionPerStock {
+    constructor() {
+        this.distributionData = {};
+        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.distributionData[instrumentId]) {
+                this.distributionData[instrumentId] = {
+                    pnl_sum: 0,
+                    pnl_sum_sq: 0,
+                    position_count: 0
+                };
+            }
+
+            this.distributionData[instrumentId].pnl_sum += netProfit;
+            this.distributionData[instrumentId].pnl_sum_sq += netProfit * netProfit;
+            this.distributionData[instrumentId].position_count++;
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.distributionData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.distributionData[instrumentId];
+        }
+        return { pnl_distribution_by_asset: result };
+    }
+
+    reset() {
+        this.distributionData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = PnlDistributionPerStock;

package/calculations/pnl/profitability_migration.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Calculates the migration of users between profitability states.
+ */
+
+class ProfitabilityMigration {
+    constructor() {
+        this.profitableToUnprofitable = 0;
+        this.unprofitableToProfitable = 0;
+        this.remainedProfitable = 0;
+        this.remainedUnprofitable = 0;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const todayProfit = this.calculateTotalPnl(todayPortfolio);
+        const yesterdayProfit = this.calculateTotalPnl(yesterdayPortfolio);
+
+        if (todayProfit === null || yesterdayProfit === null) {
+            return;
+        }
+
+        const wasProfitable = yesterdayProfit > 0;
+        const isProfitable = todayProfit > 0;
+
+        if (wasProfitable && !isProfitable) {
+            this.profitableToUnprofitable++;
+        } else if (!wasProfitable && isProfitable) {
+            this.unprofitableToProfitable++;
+        } else if (wasProfitable && isProfitable) {
+            this.remainedProfitable++;
+        } else {
+            this.remainedUnprofitable++;
+        }
+    }
+
+    calculateTotalPnl(portfolio) {
+        if (portfolio && portfolio.AggregatedPositions) {
+            return portfolio.AggregatedPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
+        } else if (portfolio && portfolio.PublicPositions) {
+            return portfolio.PublicPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
+        }
+        return null;
+    }
+
+    getResult() {
+        return {
+            profitable_to_unprofitable: this.profitableToUnprofitable,
+            unprofitable_to_profitable: this.unprofitableToProfitable,
+            remained_profitable: this.remainedProfitable,
+            remained_unprofitable: this.remainedUnprofitable,
+        };
+    }
+}
+
+module.exports = ProfitabilityMigration;

package/calculations/pnl/profitability_ratio_per_stock.js

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Calculates the ratio of profitable vs. unprofitable positions for each stock.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class ProfitabilityRatioPerStock {
+    constructor() {
+        this.profitabilityData = {};
+        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.profitabilityData[instrumentId]) {
+                this.profitabilityData[instrumentId] = { profitable: 0, unprofitable: 0 };
+            }
+
+            if (netProfit > 0) {
+                this.profitabilityData[instrumentId].profitable++;
+            } else if (netProfit < 0) {
+                this.profitabilityData[instrumentId].unprofitable++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.profitabilityData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.profitabilityData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return { profitability_by_asset: result };
+    }
+
+    reset() {
+        this.profitabilityData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = ProfitabilityRatioPerStock;

package/calculations/pnl/profitability_skew_per_stock.js

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Calculates the magnitude of profitable vs. unprofitable positions for each stock,
+ * providing insight into the skew of returns.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class ProfitabilitySkewPerStock {
+    constructor() {
+        this.skewData = {};
+        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.skewData[instrumentId]) {
+                this.skewData[instrumentId] = {
+                    profit_sum: 0,
+                    loss_sum: 0,
+                    profitable_count: 0,
+                    unprofitable_count: 0
+                };
+            }
+
+            if (netProfit > 0) {
+                this.skewData[instrumentId].profit_sum += netProfit;
+                this.skewData[instrumentId].profitable_count++;
+            } else if (netProfit < 0) {
+                this.skewData[instrumentId].loss_sum += netProfit; // Keep it negative to sum up losses
+                this.skewData[instrumentId].unprofitable_count++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.skewData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.skewData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return { profitability_skew_by_asset: result };
+    }
+
+    reset() {
+        this.skewData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = ProfitabilitySkewPerStock;

package/calculations/pnl/user_profitability_tracker.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Tracks user profitability over a 7-day rolling window.
+ * This version shards the output to avoid Firestore's "too many index entries" error.
+ */
+
+const { Firestore } = require('@google-cloud/firestore');
+const firestore = new Firestore();
+
+// Define a constant for the number of shards
+const NUM_SHARDS = 50;
+
+class UserProfitabilityTracker {
+    constructor() {
+        this.dailyProfits = {};
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio) return;
+
+        const todayPnl = this.calculateTotalPnl(todayPortfolio);
+        if (todayPnl !== null) {
+            this.dailyProfits[userId] = todayPnl;
+        }
+    }
+
+    calculateTotalPnl(portfolio) {
+        if (portfolio && portfolio.AggregatedPositions) {
+            return portfolio.AggregatedPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
+        } else if (portfolio && portfolio.PublicPositions) {
+            return portfolio.PublicPositions.reduce((sum, pos) => sum + pos.NetProfit, 0);
+        }
+        return null;
+    }
+
+    async getResult() {
+        const today = new Date().toISOString().slice(0, 10);
+        const results = {};
+
+        // Prepare sharded data structure
+        for (let i = 0; i < NUM_SHARDS; i++) {
+            results[`user_profitability_shard_${i}`] = {};
+        }
+
+        // Fetch all existing shards in parallel for efficiency
+        const shardPromises = [];
+        for (let i = 0; i < NUM_SHARDS; i++) {
+            const docRef = firestore.collection('historical_insights').doc(`user_profitability_shard_${i}`);
+            shardPromises.push(docRef.get());
+        }
+        const shardSnapshots = await Promise.all(shardPromises);
+        const existingData = shardSnapshots.map(snap => (snap.exists ? snap.data().profits : {}));
+
+        // Process users and assign them to shards
+        for (const userId in this.dailyProfits) {
+            const shardIndex = parseInt(userId, 10) % NUM_SHARDS;
+            const userHistory = existingData[shardIndex][userId] || [];
+            
+            userHistory.push({ date: today, pnl: this.dailyProfits[userId] });
+            
+            // Ensure we only keep the last 7 days of data
+            results[`user_profitability_shard_${shardIndex}`][userId] = userHistory.slice(-7);
+        }
+
+        return { sharded_user_profitability: results };
+    }
+}
+
+module.exports = UserProfitabilityTracker;

package/calculations/sanity/users_processed.js

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview A simple counter that increments for each user processed.
+ */
+
+class UsersProcessed {
+    constructor() {
+        this.userCount = 0;
+    }
+
+    process(portfolioData, userId, context) {
+        this.userCount++;
+    }
+
+    getResult() {
+        if (this.userCount === 0) return {};
+        // FIX: Rename the key to use the 'raw' prefix for correct aggregation.
+        return {
+            rawTotalUsersProcessed: this.userCount
+        };
+    }
+
+    reset() {
+        this.userCount = 0;
+    }
+}
+
+module.exports = UsersProcessed;

package/calculations/sectors/diversification_pnl.js

@@ -0,0 +1,59 @@
+// CORRECTED PATH: ../utils/ instead of ../../utils/
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+/**
+ * Aggregates P/L by the number of unique sectors a user is invested in.
+ */
+class DiversificationPnl {
+    // ... (rest of the code is unchanged) ...
+    constructor() {
+        this.pnl_by_sector_count = {};
+        // Load the mapping on initialization
+        this.sectorMapping = null; // Changed: Load async in process
+    }
+
+    _initBucket(count) {
+        if (!this.pnl_by_sector_count[count]) {
+            this.pnl_by_sector_count[count] = { pnl_sum: 0, count: 0 };
+        }
+    }
+
+    async process(todayPortfolio, yesterdayPortfolio, userId) { // Added async
+        if (!yesterdayPortfolio || !todayPortfolio) {
+            return;
+        }
+         // Load mapping if not already loaded
+        if(!this.sectorMapping) {
+            this.sectorMapping = await getInstrumentSectorMap();
+        }
+
+        const positions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
+
+        if (!positions || !Array.isArray(positions)) {
+            return;
+        }
+
+        const uniqueSectors = new Set();
+        for (const position of positions) {
+            const sector = this.sectorMapping[position.InstrumentID] || 'Other';
+            uniqueSectors.add(sector);
+        }
+
+        const sectorCount = uniqueSectors.size;
+        if (sectorCount === 0) {
+            return;
+        }
+
+        const dailyPnl = todayPortfolio.PortfolioValue - yesterdayPortfolio.PortfolioValue;
+
+        this._initBucket(sectorCount);
+        this.pnl_by_sector_count[sectorCount].pnl_sum += dailyPnl;
+        this.pnl_by_sector_count[sectorCount].count++;
+    }
+
+    getResult() {
+        return this.pnl_by_sector_count;
+    }
+}
+
+module.exports = DiversificationPnl;

package/calculations/sectors/sector_dollar_metrics.js

@@ -0,0 +1,49 @@
+/**
+ * Aggregates the total dollar amount invested in sectors,
+ * broken down by profit or loss (from our sample).
+ */
+class SectorDollarMetrics {
+    constructor() {
+        this.sectors = {};
+    }
+
+    _initSector(sector) {
+        if (!this.sectors[sector]) {
+            this.sectors[sector] = {
+                total_invested_sum: 0,
+                profit_invested_sum: 0,
+                loss_invested_sum: 0
+            };
+        }
+    }
+
+    process(portfolioData, userId, context) {
+        const { sectorMapping } = context; // Assumes sectorMapping is in 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 sector = sectorMapping[position.InstrumentID] || 'Other';
+            this._initSector(sector);
+
+            // FIX: Use the correct PascalCase InvestedAmount
+            this.sectors[sector].total_invested_sum += position.InvestedAmount;
+
+            // FIX: Use the correct PascalCase NetProfit
+            if (position.NetProfit > 0) {
+                this.sectors[sector].profit_invested_sum += position.InvestedAmount;
+            } else {
+                this.sectors[sector].loss_invested_sum += position.InvestedAmount;
+            }
+        }
+    }
+
+    getResult() {
+        return this.sectors;
+    }
+}
+
+module.exports = SectorDollarMetrics;

package/calculations/sectors/sector_rotation.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Analyzes sector rotation by comparing investment amounts between two days.
+ */
+// CORRECTED PATH: ../utils/ instead of ../../utils/
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+class SectorRotation {
+    // ... (rest of the code is unchanged) ...
+    constructor() {
+        this.todaySectorInvestment = {};
+        this.yesterdaySectorInvestment = {};
+        this.sectorMap = null;
+    }
+
+    async process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!this.sectorMap) {
+            this.sectorMap = await getInstrumentSectorMap();
+        }
+
+        if (todayPortfolio) {
+            this.accumulateSectorInvestment(todayPortfolio, this.todaySectorInvestment);
+        }
+        if (yesterdayPortfolio) {
+            this.accumulateSectorInvestment(yesterdayPortfolio, this.yesterdaySectorInvestment);
+        }
+    }
+
+    accumulateSectorInvestment(portfolio, target) {
+        // Use AggregatedPositions, as PublicPositions don't have Invested amount
+        if (portfolio && portfolio.AggregatedPositions) {
+            for (const pos of portfolio.AggregatedPositions) {
+                 // Check if sectorMap is loaded before accessing it
+                 if (!this.sectorMap) {
+                     console.warn('Sector map not loaded in accumulateSectorInvestment');
+                     continue; // or handle appropriately
+                 }
+                const sector = this.sectorMap[pos.InstrumentID] || 'N/A';
+                if (!target[sector]) {
+                    target[sector] = 0;
+                }
+                // Use Invested amount if available, otherwise fallback might be needed
+                target[sector] += (pos.Invested || pos.Amount || 0); // Added fallback
+            }
+        }
+         // Optional: Handle PublicPositions if needed, though they lack 'Invested'
+         else if (portfolio && portfolio.PublicPositions) {
+             // Logic to handle PublicPositions if necessary, e.g., using 'Amount'
+             // console.warn("Using PublicPositions for sector rotation, 'Invested' amount missing.");
+         }
+    }
+
+
+    getResult() {
+        const sectorRotationData = {};
+        const allSectors = new Set([...Object.keys(this.todaySectorInvestment), ...Object.keys(this.yesterdaySectorInvestment)]);
+
+        for (const sector of allSectors) {
+            const todayAmount = this.todaySectorInvestment[sector] || 0;
+            const yesterdayAmount = this.yesterdaySectorInvestment[sector] || 0;
+            sectorRotationData[sector] = todayAmount - yesterdayAmount;
+        }
+
+        return { sector_rotation: sectorRotationData };
+    }
+}
+
+
+module.exports = SectorRotation;

package/calculations/sectors/total_long_per_sector.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Counts the total number of 'long' (Buy) positions for each sector.
+ */
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider'); // Correctly import the new function
+
+class TotalLongPerSector {
+    constructor() {
+        this.longPositions = [];
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.AggregatedPositions) {
+            for (const position of portfolioData.AggregatedPositions) {
+                if (position.Direction === 'Buy') {
+                    this.longPositions.push(position);
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        const longCountBySector = {};
+        const sectorMap = await getInstrumentSectorMap(); // Use the new function
+
+        for (const position of this.longPositions) {
+            const instrumentId = position.InstrumentID;
+            const sector = sectorMap[instrumentId] || 'N/A';
+            longCountBySector[sector] = (longCountBySector[sector] || 0) + 1;
+        }
+
+        const result = {};
+        for (const sector in longCountBySector) {
+            result[`raw_${sector}_long_count`] = longCountBySector[sector];
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.longPositions = [];
+    }
+}
+
+module.exports = TotalLongPerSector;

package/calculations/sectors/total_short_per_sector.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Counts the total number of 'short' (Sell) positions for each sector.
+ */
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider'); // Correctly import the new function
+
+class TotalShortPerSector {
+    constructor() {
+        this.shortPositions = [];
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.AggregatedPositions) {
+            for (const position of portfolioData.AggregatedPositions) {
+                if (position.Direction === 'Sell') {
+                    this.shortPositions.push(position);
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        const shortCountBySector = {};
+        const sectorMap = await getInstrumentSectorMap(); // Use the new function
+
+        for (const position of this.shortPositions) {
+            const instrumentId = position.InstrumentID;
+            const sector = sectorMap[instrumentId] || 'N/A';
+            shortCountBySector[sector] = (shortCountBySector[sector] || 0) + 1;
+        }
+
+        const result = {};
+        for (const sector in shortCountBySector) {
+            result[`raw_${sector}_short_count`] = shortCountBySector[sector];
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.shortPositions = [];
+    }
+}
+
+module.exports = TotalShortPerSector;