aiden-shared-calculations-unified 1.0.95 → 1.0.97

package/calculations/legacy/user-investment-profile.js

@@ -1,313 +0,0 @@
-/**
- * @fileoverview Calculates a rolling 90-day "Investor Score" (IS) for each normal user.
- *
- * --- META REFACTOR (v2) ---
- * This calculation is now `type: "meta"` and expects its dependencies
- * to be fetched by the pass runner and provided to its `process` method.
- * It also dynamically fetches its own historical user data.
- */
-
-const { Firestore } = require('@google-cloud/firestore');
-const firestore = new Firestore();
-// NOTE: Corrected relative path for data_loader
-const { loadDataByRefs, getPortfolioPartRefs, loadFullDayMap } = require('../../../bulltrackers-module/functions/computation-system/utils/data_loader');
-const { loadAllPriceData, getInstrumentSectorMap } = require('../../utils/price_data_provider');
-
-// Config
-const NUM_SHARDS = 50;
-const ROLLING_DAYS = 90;
-const SHARD_COLLECTION_NAME = 'user_profile_history';
-const PNL_TRACKER_CALC_ID = 'user-profitability-tracker';
-
-// Helper: stable shard index
-function getShardIndex(id) {
-    const n = parseInt(id, 10);
-    if (!Number.isNaN(n)) return Math.abs(n) % NUM_SHARDS;
-    let h = 0;
-    for (let i = 0; i < id.length; i++) {
-        h = ((h << 5) - h) + id.charCodeAt(i);
-        h |= 0;
-    }
-    return Math.abs(h) % NUM_SHARDS;
-}
-
-class UserInvestmentProfile {
-
-    /**
-     * (NEW) Statically declare dependencies.
-     * The runner will fetch these results for the *current date*
-     * and pass them to `process`.
-     */
-    static getDependencies() {
-        return [PNL_TRACKER_CALC_ID];
-    }
-
-    /**
-     * HEURISTIC 1: Risk & Diversification Score (0-10).
-     */
-    _calculateRiskAndDivScore(todayPortfolio, sectorMap) {
-        if (!todayPortfolio.AggregatedPositions || todayPortfolio.AggregatedPositions.length === 0) {
-            return 5; // neutral
-        }
-
-        const positions = todayPortfolio.AggregatedPositions;
-        let totalInvested = 0;
-        let weightedRetSum = 0;
-        let weightedRetSqSum = 0;
-        let maxPosition = 0;
-        const sectors = new Set();
-
-        for (const pos of positions) {
-            const invested = pos.InvestedAmount || pos.Amount || 0;
-            const netProfit = ('NetProfit' in pos) ? pos.NetProfit : (pos.ProfitAndLoss || 0); // decimal % return
-            const ret = invested > 0 ? (netProfit) : netProfit; 
-
-            weightedRetSum += ret * invested;
-            weightedRetSqSum += (ret * ret) * invested;
-            totalInvested += invested;
-            if (invested > maxPosition) maxPosition = invested;
-
-            sectors.add(sectorMap[pos.InstrumentID] || 'N/A');
-        }
-
-        const meanReturn = totalInvested > 0 ? (weightedRetSum / totalInvested) : 0;
-        const meanReturnSq = totalInvested > 0 ? (weightedRetSqSum / totalInvested) : (meanReturn * meanReturn);
-        const variance = Math.max(0, meanReturnSq - (meanReturn * meanReturn));
-        const stdReturn = Math.sqrt(variance);
-        let dispersionRiskProxy = stdReturn > 0 ? meanReturn / stdReturn : 0;
-        const capped = Math.max(-2, Math.min(4, dispersionRiskProxy));
-        const scoreSharpe = ((capped + 2) / 6) * 10; 
-        const sectorCount = sectors.size;
-        let scoreDiversification = 0;
-        if (sectorCount === 1) scoreDiversification = 0;
-        else if (sectorCount <= 4) scoreDiversification = 5;
-        else if (sectorCount <= 7) scoreDiversification = 8;
-        else scoreDiversification = 10;
-        const concentrationRatio = totalInvested > 0 ? (maxPosition / totalInvested) : 0;
-        let scoreSizing = 0;
-        if (concentrationRatio > 0.8) scoreSizing = 0;
-        else if (concentrationRatio > 0.5) scoreSizing = 2;
-        else if (concentrationRatio > 0.3) scoreSizing = 5;
-        else if (concentrationRatio > 0.15) scoreSizing = 8;
-        else scoreSizing = 10;
-        const final = (scoreSharpe * 0.4) + (scoreDiversification * 0.3) + (scoreSizing * 0.3);
-        return Math.max(0, Math.min(10, final));
-    }
-
-    /**
-     * HEURISTIC 2: Discipline Score (0-10).
-     */
-    _calculateDisciplineScore(yesterdayPortfolio = {}, todayPortfolio = {}) {
-        const yPositions = yesterdayPortfolio.AggregatedPositions || [];
-        const tPositions = new Map((todayPortfolio.AggregatedPositions || []).map(p => [p.PositionID, p]));
-        if (yPositions.length === 0) {
-            return 5; // neutral
-        }
-        let eventPoints = 0;
-        let eventCount = 0;
-        for (const yPos of yPositions) {
-            const profitAndLoss = ('ProfitAndLoss' in yPos) ? yPos.ProfitAndLoss : (yPos.NetProfit || 0);
-            const invested = yPos.InvestedAmount || yPos.Amount || 0;
-            const pnlPercent = profitAndLoss;
-            const tPos = tPositions.get(yPos.PositionID);
-            if (!tPos) {
-                eventCount++;
-                if (pnlPercent < -0.05) eventPoints += 10;
-                else if (pnlPercent > 0.20) eventPoints += 8;
-                else if (pnlPercent > 0 && pnlPercent < 0.05) eventPoints += 2;
-                else eventPoints += 5;
-            } else {
-                if (pnlPercent < -0.10) {
-                    eventCount++;
-                    const tInvested = tPos.InvestedAmount || tPos.Amount || 0;
-                    if (tInvested > invested) eventPoints += 0;
-                    else eventPoints += 3;
-                } else if (pnlPercent > 0.15) {
-                    eventCount++;
-                    eventPoints += 10;
-                }
-            }
-        }
-        const avg = (eventCount > 0) ? (eventPoints / eventCount) : 5;
-        return Math.max(0, Math.min(10, avg));
-    }
-
-    /**
-     * HEURISTIC 3: Market Timing Score (0-10).
-     */
-    _calculateMarketTimingScore(yesterdayPortfolio = {}, todayPortfolio = {}, priceMap) {
-        const yIds = new Set((yesterdayPortfolio.AggregatedPositions || []).map(p => p.PositionID));
-        const newPositions = (todayPortfolio.AggregatedPositions || []).filter(p => !yIds.has(p.PositionID));
-        if (newPositions.length === 0) return 5;
-        let timingPoints = 0;
-        let timingCount = 0;
-        for (const tPos of newPositions) {
-            const prices = priceMap[tPos.InstrumentID];
-            if (!prices) continue;
-            let historyPrices = [];
-            if (Array.isArray(prices)) {
-                historyPrices = prices
-                    .map(p => (typeof p === 'number' ? p : (p.price || p.close || null)))
-                    .filter(v => v != null);
-            } else {
-                const entries = Object.keys(prices)
-                    .map(d => ({ d, p: prices[d] }))
-                    .filter(e => e.p != null)
-                    .sort((a, b) => new Date(a.d) - new Date(b.d));
-                historyPrices = entries.map(e => e.p);
-            }
-            const last30 = historyPrices.slice(-30);
-            if (last30.length < 2) continue;
-            const minPrice = Math.min(...last30);
-            const maxPrice = Math.max(...last30);
-            const openRate = tPos.OpenRate;
-            const range = maxPrice - minPrice;
-            if (!isFinite(range) || range === 0) continue;
-            let proximity = (openRate - minPrice) / range;
-            proximity = Math.max(0, Math.min(1, proximity));
-            timingCount++;
-            if (proximity < 0.2) timingPoints += 10;
-            else if (proximity < 0.4) timingPoints += 8;
-            else if (proximity > 0.9) timingPoints += 1;
-            else if (proximity > 0.7) timingPoints += 3;
-            else timingPoints += 5;
-        }
-        const avg = (timingCount > 0) ? (timingPoints / timingCount) : 5;
-        return Math.max(0, Math.min(10, avg));
-    }
-    
-    /**
-     * REFACTORED PROCESS METHOD
-     * @param {string} dateStr - The date being processed (YYYY-MM-DD).
-     * @param {object} dependencies - Shared dependencies (db, logger, rootData, etc.).
-     * @param {object} config - The computation system configuration.
-     * @param {object} fetchedDependencies - An object containing the results of this
-     * calc's dependencies (e.g., { 'user-profitability-tracker': ... }).
-     */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { logger, db, rootData } = dependencies;
-        const { portfolioRefs } = rootData;
-
-        logger.log('INFO', '[UserInvestmentProfile] Starting meta-process...');
-
-        // 1. Get Pass 1 dependency from the `fetchedDependencies` argument
-        const pnlTrackerResult = fetchedDependencies[PNL_TRACKER_CALC_ID];
-        if (!pnlTrackerResult || !pnlTrackerResult.daily_pnl_map) {
-            logger.log('WARN', `[UserInvestmentProfile] Dependency '${PNL_TRACKER_CALC_ID}' not found in fetchedDependencies. Aborting.`);
-            return null; // Return null to signal failure
-        }
-        const pnlScores = pnlTrackerResult.daily_pnl_map;
-        logger.log('INFO', `[UserInvestmentProfile] Received ${Object.keys(pnlScores).length} PNL scores from dependency.`);
-
-        // 2. Load external dependencies (prices, sectors)
-        const [priceMap, sectorMap] = await Promise.all([
-            loadAllPriceData(),
-            getInstrumentSectorMap()
-        ]);
-        if (!priceMap || !sectorMap) {
-            logger.log('ERROR', '[UserInvestmentProfile] Failed to load priceMap or sectorMap.');
-            return null;
-        }
-        
-        // 3. Load "yesterday's" portfolio data for comparison
-        const yesterdayDate = new Date(dateStr + 'T00:00:00Z');
-        yesterdayDate.setUTCDate(yesterdayDate.getUTCDate() - 1);
-        const yesterdayStr = yesterdayDate.toISOString().slice(0, 10);
-        const yesterdayRefs = await getPortfolioPartRefs(config, dependencies, yesterdayStr);
-        const yesterdayPortfolios = await loadFullDayMap(config, dependencies, yesterdayRefs);
-        logger.log('INFO', `[UserInvestmentProfile] Loaded ${yesterdayRefs.length} part refs for yesterday.`);
-
-        // 4. Stream "today's" portfolio data and process
-        const batchSize = config.partRefBatchSize || 10;
-        const dailyUserScores = {}; // Local state for this run
-
-        for (let i = 0; i < portfolioRefs.length; i += batchSize) {
-            const batchRefs = portfolioRefs.slice(i, i + batchSize);
-            const todayPortfoliosChunk = await loadDataByRefs(config, dependencies, batchRefs);
-
-            for (const uid in todayPortfoliosChunk) {
-                const pToday = todayPortfoliosChunk[uid];
-                if (!pToday || !pToday.AggregatedPositions) continue; // Skip
-
-                const pYesterday = yesterdayPortfolios[uid] || {};
-
-                const score_rd = this._calculateRiskAndDivScore(pToday, sectorMap);
-                const score_disc = this._calculateDisciplineScore(pYesterday, pToday);
-                const score_time = this._calculateMarketTimingScore(pYesterday, pToday, priceMap);
-
-                dailyUserScores[uid] = {
-                    score_rd,
-                    score_disc,
-                    score_time
-                };
-            }
-        }
-        logger.log('INFO', `[UserInvestmentProfile] Calculated daily scores for ${Object.keys(dailyUserScores).length} users.`);
-        
-        // 5. GETRESULT LOGIC (Final aggregation)
-        const shardedResults = {};
-        for (let i = 0; i < NUM_SHARDS; i++) {
-            const shardKey = `${SHARD_COLLECTION_NAME}_shard_${i}`;
-            shardedResults[shardKey] = { profiles: {}, lastUpdated: dateStr };
-        }
-        const dailyInvestorScoreMap = {};
-
-        // Fetch existing shards in parallel
-        const shardPromises = [];
-        for (let i = 0; i < NUM_SHARDS; i++) {
-            const docRef = firestore.collection(SHARD_COLLECTION_NAME).doc(`${SHARD_COLLECTION_NAME}_shard_${i}`);
-            shardPromises.push(docRef.get());
-        }
-        const shardSnapshots = await Promise.all(shardPromises);
-        const existingShards = shardSnapshots.map((snap) => (snap.exists ? snap.data().profiles : {}));
-        
-        // Process users
-        for (const userId of Object.keys(dailyUserScores)) {
-            const shardIndex = getShardIndex(userId);
-            const scores = dailyUserScores[userId];
-            const existingProfiles = existingShards[shardIndex] || {};
-            const history = (existingProfiles[userId] || []).slice(); // clone
-            history.push({
-                date: dateStr,
-                ...scores,
-                pnl: (pnlScores[userId] || 0)
-            });
-            const newHistory = history.slice(-ROLLING_DAYS);
-
-            // compute rolling averages
-            let avg_rd = 0, avg_disc = 0, avg_time = 0, avg_pnl = 0;
-            for (const entry of newHistory) {
-                avg_rd += (entry.score_rd || 0);
-                avg_disc += (entry.score_disc || 0);
-                avg_time += (entry.score_time || 0);
-                avg_pnl += (entry.pnl || 0);
-            }
-            const N = newHistory.length || 1;
-            avg_rd /= N;
-            avg_disc /= N;
-            avg_time /= N;
-            avg_pnl /= N;
-
-            const normalizedPnl = Math.max(-10, Math.min(10, avg_pnl * 1000));
-            const finalISRaw = (avg_disc * 0.4) + (avg_rd * 0.3) + (avg_time * 0.2) + (normalizedPnl * 0.1);
-            const finalIS = Math.max(0, Math.min(10, finalISRaw));
-
-            const shardKey = `${SHARD_COLLECTION_NAME}_shard_${shardIndex}`;
-            shardedResults[shardKey].profiles[userId] = newHistory;
-            dailyInvestorScoreMap[userId] = finalIS;
-        }
-        
-        logger.log('INFO', `[UserInvestmentProfile] Finalized IS scores for ${Object.keys(dailyInvestorScoreMap).length} users.`);
-        
-        // Return the final result object
-        return {
-            sharded_user_profile: shardedResults,
-            daily_investor_scores: dailyInvestorScoreMap
-        };
-    }
-
-    async getResult() { return null; }
-    reset() {}
-}
-
-module.exports = UserInvestmentProfile;

package/calculations/legacy/user_expectancy_score.js

@@ -1,106 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 3) for user expectancy score.
- *
- * This metric calculates a "trader expectancy score" for each user.
- * Expectancy = (Win % * Avg Win Size) - (Loss % * Avg Loss Size)
- *
- * It *depends* on 'user_profitability_tracker' to get the
- * historical win/loss data for each user.
- */
-class UserExpectancyScore {
-    constructor() {
-        // No per-user processing
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const userSchema = {
-            "type": "object",
-            "properties": {
-                "expectancy_score": {
-                    "type": "number",
-                    "description": "Trader expectancy score: (Win % * Avg Win) - (Loss % * Avg Loss). Measures P&L per trade."
-                },
-                "win_rate_pct": { "type": "number" },
-                "avg_win_pct": { "type": "number" },
-                "loss_rate_pct": { "type": "number" },
-                "avg_loss_pct": { "type": "number" },
-                "total_days_processed": { "type": "number" }
-            },
-            "required": ["expectancy_score", "win_rate_pct", "avg_win_pct", "loss_rate_pct", "avg_loss_pct"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates a 'trader expectancy score' for each user based on their 7-day P&L history.",
-            "patternProperties": {
-                "^.*$": userSchema // UserID
-            },
-            "additionalProperties": userSchema
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'user_profitability_tracker' // Pass 2
-        ];
-    }
-
-    process() {
-        // No-op
-    }
-
-    getResult(fetchedDependencies) {
-        const profitabilityData = fetchedDependencies['user_profitability_tracker']?.user_details;
-
-        if (!profitabilityData) {
-            return {};
-        }
-
-        const result = {};
-
-        for (const [userId, data] of Object.entries(profitabilityData)) {
-            const history = data.pnl_history_7d || [];
-            if (history.length === 0) continue;
-            
-            const wins = history.filter(pnl => pnl > 0);
-            const losses = history.filter(pnl => pnl < 0);
-            const totalTrades = history.length;
-
-            if (totalTrades === 0) continue;
-
-            const winRate = (wins.length / totalTrades);
-            const lossRate = (losses.length / totalTrades);
-
-            const avgWin = (wins.length > 0) ? (wins.reduce((a, b) => a + b, 0) / wins.length) : 0;
-            // AvgLoss should be a positive number
-            const avgLoss = (losses.length > 0) ? (Math.abs(losses.reduce((a, b) => a + b, 0)) / losses.length) : 0;
-            
-            // Expectancy = (Win % * Avg Win) - (Loss % * Avg Loss)
-            const expectancy = (winRate * avgWin) - (lossRate * avgLoss);
-            
-            result[userId] = {
-                expectancy_score: expectancy,
-                win_rate_pct: winRate * 100,
-                avg_win_pct: avgWin,
-                loss_rate_pct: lossRate * 100,
-                avg_loss_pct: avgLoss,
-                total_days_processed: totalTrades
-            };
-        }
-        
-        return result;
-    }
-
-    reset() {
-        // No state
-    }
-}
-
-module.exports = UserExpectancyScore;

package/calculations/legacy/user_profitability_tracker.js

@@ -1,131 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for user profitability tracker.
- *
- * This metric answers: "What is each user's weighted average
- * daily P&L, and what is their 7-day rolling profitability history?"
- *
- * This is a foundational calculation for identifying 'smart' and
- * 'dumb' cohorts in later passes.
- *
- * It is *stateful* and requires reading the *previous day's*
- * result of *this same calculation* from Firestore.
- */
-class UserProfitabilityTracker {
-    constructor() {
-        // Map<userId, { weighted_avg_pnl_7d, profitable_days_7d, pnl_history_7d: [] }>
-        this.userHistory = new Map();
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const userDetailSchema = {
-            "type": "object",
-            "properties": {
-                "weighted_avg_pnl_7d": {
-                    "type": "number",
-                    "description": "Weighted average P&L over the last 7 days (recent days weighted more)."
-                },
-                "profitable_days_7d": {
-                    "type": "number",
-                    "description": "Count of profitable days in the last 7 days."
-                },
-                "pnl_history_7d": {
-                    "type": "array",
-                    "description": "List of the last 7 days' P&L values.",
-                    "items": { "type": "number" }
-                }
-            },
-            "required": ["weighted_avg_pnl_7d", "profitable_days_7d", "pnl_history_7d"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Tracks 7-day rolling profitability for each user; used to define cohorts.",
-            "properties": {
-                "ranked_users": {
-                    "type": "array",
-                    "description": "List of all users, sorted ascending by their 7-day weighted average P&L.",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "userId": { "type": "string" },
-                            "weighted_avg_pnl_7d": { "type": "number" }
-                        },
-                        "required": ["userId", "weighted_avg_pnl_7d"]
-                    }
-                },
-                "user_details": {
-                    "type": "object",
-                    "description": "A map of user IDs to their detailed profitability data.",
-                    "patternProperties": {
-                        "^.*$": userDetailSchema // UserID
-                    },
-                    "additionalProperties": userDetailSchema
-                }
-            },
-            "required": ["ranked_users", "user_details"]
-        };
-    }
-
-    _calculateWeightedAverage(history) {
-        const weights = [0.25, 0.20, 0.15, 0.12, 0.10, 0.08, 0.10]; // Example weights (sum to 1.0)
-        let weightedSum = 0;
-        
-        for (let i = 0; i < history.length; i++) {
-            // Apply weights in reverse (most recent gets highest weight)
-            weightedSum += history[i] * (weights[i] || 0);
-        }
-        return weightedSum;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        // 1. Get this user's history from *yesterday's* run of this metric
-        // This data is pre-loaded into context by the computation system
-        const yHistoryData = context.yesterdaysDependencyData['user_profitability_tracker'];
-        const userHistory = yHistoryData?.user_details?.[userId]?.pnl_history_7d || [];
-
-        // 2. Get today's P&L
-        const todayPnl = todayPortfolio?.Summary?.NetProfit || 0;
-
-        // 3. Create new 7-day history
-        const newHistory = [todayPnl, ...userHistory].slice(0, 7);
-        
-        // 4. Calculate new metrics
-        const weightedAvg = this._calculateWeightedAverage(newHistory);
-        const profitableDays = newHistory.filter(pnl => pnl > 0).length;
-
-        // 5. Store for getResult()
-        this.userHistory.set(userId, {
-            weighted_avg_pnl_7d: weightedAvg,
-            profitable_days_7d: profitableDays,
-            pnl_history_7d: newHistory
-        });
-    }
-
-    getResult() {
-        const user_details = Object.fromEntries(this.userHistory);
-        
-        // Create the ranked list for cohorts
-        const ranked_users = Array.from(this.userHistory.entries())
-            .map(([userId, data]) => ({
-                userId: userId,
-                weighted_avg_pnl_7d: data.weighted_avg_pnl_7d
-            }))
-            // Sort ascending (lowest P&L first)
-            .sort((a, b) => a.weighted_avg_pnl_7d - b.weighted_avg_pnl_7d);
-
-        return {
-            ranked_users: ranked_users,
-            user_details: user_details
-        };
-    }
-
-    reset() {
-        this.userHistory.clear();
-    }
-}
-
-module.exports = UserProfitabilityTracker;