bulltrackers-module 1.0.769 → 1.0.771

package/functions/computation-system-v2/computations/PiRecommender.js

@@ -1,13 +1,9 @@
 /**
- * @fileoverview PI Recommender (v2 - Diversification-Aware)
- * 
- * Recommends Popular Investors to signed-in users based on:
- * 1. User preferences (sectors, risk tolerance they're drawn to)
- * 2. Diversification benefit (low correlation with current portfolio)
- * 3. Quality thresholds (risk score, copiers, track record)
- * 
- * This replaces the legacy similarity-based approach which was harmful
- * because it doubled down on existing exposure instead of diversifying.
+ * @fileoverview PI Recommender (v3 - Recursive Correlation)
+ * * Recommends Popular Investors by:
+ * 1. Recursively unwrapping the user's copied PIs to find True Net Exposure.
+ * 2. Calculating mathematical correlation between User and Candidate using Asset/Sector matrices.
+ * 3. Favoring "Uncorrelated" (near 0) over "Inverse" (near -1) or "Correlated" (near 1).
  */
 const { Computation } = require('../framework');
 
@@ -15,31 +11,28 @@ class PiRecommender extends Computation {
     static getConfig() {
         return {
             name: 'PiRecommender',
-            description: 'Recommends PIs balancing user preferences with diversification',
+            description: 'Recommends PIs based on recursive portfolio variance reduction',
             type: 'per-entity',
             category: 'signed_in_user',
             isHistorical: false,
 
-            // Depends on global PI feature vectors
-            dependencies: ['PiFeatureVectors'],
+            dependencies: ['pifeaturevectors', 'sectorcorrelations'],
 
             requires: {
                 'portfolio_snapshots': {
-                    lookback: 0,
+                    lookback: 7,
                     mandatory: true,
                     fields: ['user_id', 'portfolio_data', 'date'],
                     filter: { user_type: 'SIGNED_IN_USER' }
                 },
-                'ticker_mappings': { mandatory: false },
-                'sector_mappings': { mandatory: false }
+                'ticker_mappings': { mandatory: false, fields: ['instrument_id', 'ticker'] },
+                'sector_mappings': { mandatory: false, fields: ['symbol', 'sector'] }
             },
 
             storage: {
                 bigquery: true,
                 firestore: {
-                    enabled: true,
-                    path: 'users/{entityId}/recommendations',
-                    merge: true
+                    enabled: false
                 }
             }
         };
@@ -48,45 +41,40 @@ class PiRecommender extends Computation {
     async process(context) {
         const { data, entityId, rules, getDependency, targetDate } = context;
 
+        const portfolioRows = data['portfolio_snapshots'];
+        if (!portfolioRows || !Array.isArray(portfolioRows) || portfolioRows.length === 0) {
+            this.setResult(entityId, { recommendations: [], reason: 'No portfolio data' });
+            return;
+        }
+
         // ===========================================================================
-        // CONFIGURATION: Scoring weights and thresholds
+        // 1. LOAD GLOBAL DEPENDENCIES
         // ===========================================================================
-        const WEIGHTS = {
-            interest: 0.30,        // How much they match user preferences
-            diversification: 0.40, // How different they are (highest weight!)
-            quality: 0.30          // Performance and popularity
-        };
+        const piFeatureData = getDependency('pifeaturevectors', '_global');
+        const correlationData = getDependency('sectorcorrelations', '_global');
 
-        const THRESHOLDS = {
-            minCopiers: 10,        // Skip unpopular PIs
-            maxRiskScore: 8,       // Skip very high risk
-            minGain: -10,          // Skip extreme losers
-            excludeAlreadyCopied: true
-        };
+        if (!piFeatureData || !correlationData) {
+            this.setResult(entityId, { error: 'Missing global dependencies' });
+            return;
+        }
 
-        const TOP_N = 10;  // Return top N recommendations
+        const piVectors = piFeatureData.vectors;
+        const sectorCorrelations = correlationData.correlationMatrix;
+        const sectorList = correlationData.sectors;
 
         // ===========================================================================
-        // SETUP: Build sector lookup and helpers
+        // 2. SETUP MAPPINGS
         // ===========================================================================
-        const toArray = (input) => {
-            if (!input) return [];
-            if (Array.isArray(input)) return input;
-            return Object.values(input).flat();
-        };
+        const toArray = (input) => Array.isArray(input) ? input : Object.values(input).flat();
 
         const tickerMap = new Map();
         toArray(data['ticker_mappings']).forEach(row => {
-            if (row.instrument_id && row.ticker) {
-                tickerMap.set(Number(row.instrument_id), row.ticker.toUpperCase());
-            }
+            if (row.instrument_id && row.ticker) tickerMap.set(Number(row.instrument_id), row.ticker.toUpperCase());
         });
 
         const sectorMap = new Map();
         toArray(data['sector_mappings']).forEach(row => {
-            if (row.symbol && row.sector) {
-                sectorMap.set(row.symbol.toUpperCase(), row.sector);
-            }
+            if (row.symbol && row.sector) sectorMap.set(row.symbol.toUpperCase(), row.sector);
         });
 
         const resolveSector = (instrumentId) => {
@@ -95,265 +83,206 @@ class PiRecommender extends Computation {
         };
 
         // ===========================================================================
-        // STEP 1: Get user's current portfolio profile
+        // 3. BUILD USER'S TRUE RECURSIVE PROFILE
         // ===========================================================================
-        const portfolioRows = data['portfolio_snapshots']?.[entityId];
-        if (!portfolioRows || portfolioRows.length === 0) {
-            this.setResult(entityId, { recommendations: [], reason: 'No portfolio data' });
-            return;
-        }
-
-        const latestRow = Array.isArray(portfolioRows)
-            ? portfolioRows[portfolioRows.length - 1]
-            : portfolioRows;
-
+        const latestRow = portfolioRows[portfolioRows.length - 1];
         const pData = rules.portfolio.extractPortfolioData(latestRow);
-        const positions = rules.portfolio.extractPositions(pData);
-        const mirrors = pData.AggregatedMirrors || [];
-
-        // Already copied PI IDs
-        const copiedPiIds = new Set(
-            mirrors.map(m => String(m.ParentCID || m.CID)).filter(Boolean)
-        );
 
-        // Build user's sector exposure
-        const userSectorWeights = {};
-        let userTotalValue = 0;
+        // Initialize User Vector (Units: % of Portfolio Value)
+        const userNetVector = {};
+        sectorList.forEach(s => userNetVector[s] = 0);
 
+        // 3a. Add Direct Positions (Signed Value)
+        const positions = rules.portfolio.extractPositions(pData);
         positions.forEach(pos => {
             const instrumentId = rules.portfolio.getInstrumentId(pos);
-            const invested = rules.portfolio.getInvested(pos) || 0;
+            const value = rules.portfolio.getValue(pos) || 0; // Already % (e.g., 5.0 for 5%)
+            const isShort = rules.portfolio.isShort(pos);
             const sector = resolveSector(instrumentId);
 
-            userSectorWeights[sector] = (userSectorWeights[sector] || 0) + invested;
-            userTotalValue += invested;
-        });
-
-        // Include mirror exposures
-        mirrors.forEach(m => {
-            userTotalValue += (m.Invested || m.Amount || 0);
+            const signedValue = isShort ? -value : value;
+            if (userNetVector[sector] !== undefined) {
+                userNetVector[sector] += signedValue;
+            }
         });
 
-        // Normalize to percentages
-        const userSectorProfile = {};
-        Object.entries(userSectorWeights).forEach(([sector, weight]) => {
-            userSectorProfile[sector] = userTotalValue > 0
-                ? weight / userTotalValue
-                : 0;
+        // 3b. Add Recursive Copy Exposure
+        const mirrors = rules.portfolio.extractMirrors(pData);
+        const copiedPiIds = new Set();
+
+        mirrors.forEach(mirror => {
+            const parentId = String(mirror.ParentCID || mirror.CID);
+            copiedPiIds.add(parentId);
+
+            // investedInCopy is % of user's portfolio (e.g., 20.0 for 20%)
+            const investedInCopy = mirror.Value || 0;
+
+            // Lookup Parent Vector (Weights are % of Parent's portfolio)
+            const parentStats = piVectors[parentId];
+            if (parentStats && parentStats.sectors) {
+                Object.entries(parentStats.sectors).forEach(([sec, weight]) => {
+                    if (userNetVector[sec] !== undefined) {
+                        // Formula: Parent_Sector_% * (User_Alloc_% / 100) = Contributed_%
+                        // Example: 50.0% * (20.0% / 100) = 10.0%
+                        userNetVector[sec] += (weight * (investedInCopy / 100));
+                    }
+                });
+            }
         });
 
-        // Infer user preferences from copied PIs
-        const userPreferredRiskRange = this._inferRiskPreference(mirrors, rules);
-
         // ===========================================================================
-        // STEP 2: Load global PI feature vectors
+        // 4. SCORE CANDIDATES
         // ===========================================================================
-        const piFeatureData = getDependency('PiFeatureVectors');
-        if (!piFeatureData || !piFeatureData.vectors) {
-            this.setResult(entityId, { recommendations: [], reason: 'No PI features available' });
-            return;
-        }
-
-        const piVectors = piFeatureData.vectors;
+        const candidates = [];
         const allPiIds = Object.keys(piVectors);
 
-        // ===========================================================================
-        // STEP 3: Score each candidate PI
-        // ===========================================================================
-        const scoredCandidates = [];
+        const WEIGHTS = {
+            diversification: 0.50, // Correlation reduction
+            quality: 0.30,         // Risk/Reward
+            interest: 0.20         // Slight bias to things they might understand
+        };
+
+        const THRESHOLDS = {
+            minCopiers: 10,
+            maxRiskScore: 8,
+            minGain: -10,
+            excludeAlreadyCopied: true
+        };
 
         for (const piId of allPiIds) {
-            // Skip already copied
-            if (THRESHOLDS.excludeAlreadyCopied && copiedPiIds.has(piId)) {
-                continue;
-            }
+            if (THRESHOLDS.excludeAlreadyCopied && copiedPiIds.has(piId)) continue;
 
             const piFv = piVectors[piId];
-
-            // Apply quality thresholds
             if (piFv.copiers < THRESHOLDS.minCopiers) continue;
             if (piFv.riskScore > THRESHOLDS.maxRiskScore) continue;
             if (piFv.gain < THRESHOLDS.minGain) continue;
 
-            // Calculate scores
-            const interestScore = this._calcInterestScore(piFv, userSectorProfile, userPreferredRiskRange);
-            const diversificationScore = this._calcDiversificationScore(piFv, userSectorProfile);
+            // Metric: Portfolio Correlation
+            const correlation = this._calculatePortfolioCorrelation(
+                userNetVector,
+                piFv.sectors,
+                sectorCorrelations,
+                sectorList
+            );
+
+            // Diversification Score:
+            // 0.0 = Uncorrelated (Best) -> Score 1.0
+            // 1.0 = Highly Correlated (Worst) -> Score 0.0
+            // -1.0 = Inverse -> Score 0.0 (We prioritize uncorrelation over hedging here)
+            const diversificationScore = 1 - Math.abs(correlation);
+
+            // Interest Score (Overlap)
+            const interestScore = this._calcInterestScore(userNetVector, piFv.sectors);
+
+            // Quality Score
             const qualityScore = this._calcQualityScore(piFv);
 
             const totalScore =
-                (interestScore * WEIGHTS.interest) +
                 (diversificationScore * WEIGHTS.diversification) +
-                (qualityScore * WEIGHTS.quality);
+                (qualityScore * WEIGHTS.quality) +
+                (interestScore * WEIGHTS.interest);
 
-            scoredCandidates.push({
+            candidates.push({
                 piId: piFv.piId,
                 username: piFv.username,
                 score: Number(totalScore.toFixed(4)),
-                breakdown: {
-                    interest: Number(interestScore.toFixed(3)),
-                    diversification: Number(diversificationScore.toFixed(3)),
-                    quality: Number(qualityScore.toFixed(3))
-                },
-                // Include key metrics for frontend
                 metrics: {
+                    correlation: Number(correlation.toFixed(3)),
                     riskScore: piFv.riskScore,
                     gain: piFv.gain,
-                    copiers: piFv.copiers,
-                    winRatio: piFv.winRatio,
                     topSectors: this._getTopSectors(piFv.sectors, 3)
                 },
-                reason: this._generateReason(diversificationScore, interestScore, piFv)
+                reason: this._generateReason(correlation, piFv)
             });
         }
 
         // ===========================================================================
-        // STEP 4: Rank and return top N
+        // 5. SORT AND RETURN
         // ===========================================================================
-        const recommendations = scoredCandidates
+        const recommendations = candidates
             .sort((a, b) => b.score - a.score)
-            .slice(0, TOP_N);
+            .slice(0, 10);
 
         this.setResult(entityId, {
             recommendations,
             userProfile: {
-                topSectors: this._getTopSectors(userSectorProfile, 3),
-                preferredRiskRange: userPreferredRiskRange,
-                currentCopies: copiedPiIds.size
+                topSectors: this._getTopSectors(userNetVector, 5),
+                totalExposure: Object.values(userNetVector).reduce((a, b) => a + b, 0)
             },
             metadata: {
-                candidatesScored: scoredCandidates.length,
-                totalPIs: allPiIds.length,
+                candidatesScored: candidates.length,
                 computedAt: targetDate
             }
         });
     }
 
     // ===========================================================================
-    // SCORING FUNCTIONS
+    // MATH HELPERS
     // ===========================================================================
 
-    /**
-     * Interest score: How well does the PI match user preferences?
-     * Higher = more aligned with sectors/risk they seem to like
-     */
-    _calcInterestScore(piFv, userSectorProfile, preferredRiskRange) {
-        // Sector overlap (dot product of normalized vectors)
-        let sectorOverlap = 0;
-        Object.entries(userSectorProfile).forEach(([sector, userWeight]) => {
-            const piWeight = piFv.sectors[sector] || 0;
-            sectorOverlap += userWeight * piWeight;
-        });
+    _calculatePortfolioCorrelation(vecA, vecB, corrMatrix, sectors) {
+        // Portfolio Variance Proxy: wT * C * w
+        // Uses Correlation Matrix as the Kernel.
 
-        // Risk preference match (1 = perfect match, 0 = way off)
-        const riskMatch = preferredRiskRange.min !== null
-            ? 1 - Math.min(1, Math.abs(piFv.riskScore - preferredRiskRange.avg) / 5)
-            : 0.5;  // Neutral if no preference detected
+        let varA = 0;
+        let varB = 0;
+        let covAB = 0;
 
-        return (sectorOverlap * 0.6) + (riskMatch * 0.4);
-    }
+        for (let i = 0; i < sectors.length; i++) {
+            for (let j = 0; j < sectors.length; j++) {
+                const s1 = sectors[i];
+                const s2 = sectors[j];
+                const corr = corrMatrix[s1]?.[s2] || 0;
 
-    /**
-     * Diversification score: How different is the PI from current portfolio?
-     * Higher = more different = better for diversification
-     */
-    _calcDiversificationScore(piFv, userSectorProfile) {
-        // Calculate sector distance (1 - overlap)
-        let overlap = 0;
-        let userMagnitude = 0;
-        let piMagnitude = 0;
-
-        Object.keys(piFv.sectors).forEach(sector => {
-            const userWeight = userSectorProfile[sector] || 0;
-            const piWeight = piFv.sectors[sector] || 0;
-
-            overlap += userWeight * piWeight;
-            userMagnitude += userWeight * userWeight;
-            piMagnitude += piWeight * piWeight;
-        });
-
-        userMagnitude = Math.sqrt(userMagnitude);
-        piMagnitude = Math.sqrt(piMagnitude);
-
-        // Cosine similarity → distance
-        const cosineSim = (userMagnitude > 0 && piMagnitude > 0)
-            ? overlap / (userMagnitude * piMagnitude)
-            : 0;
+                const wa_i = vecA[s1] || 0;
+                const wa_j = vecA[s2] || 0;
+                const wb_i = vecB[s1] || 0;
+                const wb_j = vecB[s2] || 0;
 
-        const diversityScore = 1 - cosineSim;
+                varA += wa_i * wa_j * corr;
+                varB += wb_i * wb_j * corr;
+                covAB += wa_i * wb_j * corr;
+            }
+        }
 
-        // Bonus for low concentration (well-diversified PI)
-        const concentrationBonus = (1 - piFv.concentration) * 0.3;
+        if (varA <= 0 || varB <= 0) return 0;
+        return covAB / Math.sqrt(varA * varB);
+    }
 
-        return Math.min(1, diversityScore + concentrationBonus);
+    _calcInterestScore(userVec, piVec) {
+        // Dot product of positive weights only (simple overlap)
+        let score = 0;
+        Object.keys(userVec).forEach(k => {
+            // Check if both have exposure in the same direction (Long/Long or Short/Short)
+            if ((userVec[k] > 0 && piVec[k] > 0) || (userVec[k] < 0 && piVec[k] < 0)) {
+                score += Math.abs(userVec[k] * piVec[k]);
+            }
+        });
+        // Normalize score roughly to 0-1 range (assuming total portfolio ~ 100%)
+        return Math.min(1, score / 1000);
     }
 
-    /**
-     * Quality score: How good is the PI objectively?
-     * Combines performance, popularity, and track record
-     */
     _calcQualityScore(piFv) {
-        // Normalize gain to 0-1 scale (-50% to +100% typical range)
         const gainNorm = Math.max(0, Math.min(1, (piFv.gain + 50) / 150));
-
-        // Win ratio already 0-100, normalize
         const winRatioNorm = piFv.winRatio / 100;
-
-        // Copiers (log scale, cap at ~10k)
         const copiersNorm = Math.min(1, Math.log10(Math.max(1, piFv.copiers)) / 4);
-
-        // Risk-adjusted (lower risk = bonus)
         const riskBonus = (10 - piFv.riskScore) / 10 * 0.2;
-
         return (gainNorm * 0.35) + (winRatioNorm * 0.25) + (copiersNorm * 0.2) + riskBonus;
     }
 
-    // ===========================================================================
-    // HELPERS
-    // ===========================================================================
-
-    _inferRiskPreference(mirrors, rules) {
-        if (!mirrors || mirrors.length === 0) {
-            return { min: null, max: null, avg: null };
-        }
-
-        const riskScores = mirrors
-            .map(m => m.RiskScore || 5)
-            .filter(r => r > 0 && r <= 10);
-
-        if (riskScores.length === 0) {
-            return { min: null, max: null, avg: null };
-        }
-
-        return {
-            min: Math.min(...riskScores),
-            max: Math.max(...riskScores),
-            avg: riskScores.reduce((a, b) => a + b, 0) / riskScores.length
-        };
-    }
-
-    _getTopSectors(sectorWeights, n) {
-        return Object.entries(sectorWeights)
-            .filter(([_, weight]) => weight > 0.01)
-            .sort((a, b) => b[1] - a[1])
+    _getTopSectors(vec, n) {
+        return Object.entries(vec)
+            .sort((a, b) => Math.abs(b[1]) - Math.abs(a[1]))
             .slice(0, n)
-            .map(([sector, weight]) => ({
-                sector,
-                weight: Number((weight * 100).toFixed(1))
-            }));
+            .map(([s, w]) => ({ sector: s, weight: Number(w.toFixed(1)) }));
     }
 
-    _generateReason(divScore, intScore, piFv) {
-        if (divScore > 0.7) {
-            return `Diversifies your portfolio with ${this._getTopSectors(piFv.sectors, 1)[0]?.sector || 'different'} exposure`;
-        }
-        if (intScore > 0.6) {
-            return `Matches your investing style with ${piFv.gain.toFixed(0)}% returns`;
-        }
-        if (piFv.copiers > 1000) {
-            return `Popular choice with ${piFv.copiers.toLocaleString()} copiers`;
-        }
-        return `Balanced recommendation with ${piFv.winRatio}% win ratio`;
+    _generateReason(correlation, piFv) {
+        if (Math.abs(correlation) < 0.1) return `Mathematically uncorrelated to your current portfolio`;
+        if (correlation < -0.3) return `Hedges your portfolio against market downturns`;
+        if (piFv.gain > 30) return `Strong performer with uncorrelated returns`;
+        return `Diversifies your holdings in ${this._getTopSectors(piFv.sectors, 1)[0].sector}`;
     }
 }
 
-module.exports = PiRecommender;
+module.exports = PiRecommender;

package/functions/computation-system-v2/computations/PopularInvestorProfileMetrics.js

@@ -14,7 +14,7 @@ class PopularInvestorProfileMetrics extends Computation {
             type: 'per-entity',
             category: 'popular_investor',
             isHistorical: true,
-            
+
             requires: {
                 // --- Core Data ---
                 'portfolio_snapshots': {
@@ -32,7 +32,7 @@ class PopularInvestorProfileMetrics extends Computation {
                     mandatory: false,
                     fields: ['user_id', 'posts_data', 'date']
                 },
-                
+
                 // --- Reference ---
                 'pi_master_list': {
                     lookback: 1,
@@ -76,7 +76,7 @@ class PopularInvestorProfileMetrics extends Computation {
                 bigquery: true,
                 firestore: {
                     enabled: true,
-                    path: 'profiles/{entityId}/metrics/{date}',
+                    path: 'PiProfiles/{entityId}/metrics/{date}',
                     merge: true
                 }
             },
@@ -91,7 +91,7 @@ class PopularInvestorProfileMetrics extends Computation {
         // ==========================================================================================
         // 0. PREPARATION & HELPER FUNCTIONS
         // ==========================================================================================
-        
+
         const toDateStr = (d) => {
             if (!d) return "";
             if (d.value) return d.value;
@@ -137,7 +137,7 @@ class PopularInvestorProfileMetrics extends Computation {
                 return dA.localeCompare(dB);
             });
         };
-        
+
         // Mappings (Global, not per-entity)
         const tickerMap = new Map();
         toArray(data['ticker_mappings']).forEach(row => {
@@ -178,7 +178,7 @@ class PopularInvestorProfileMetrics extends Computation {
         // ==========================================================================================
         // 1. DATA RETRIEVAL (Using Fixed 'getEntityRows')
         // ==========================================================================================
-        
+
         // These tables are keyed by 'user_id' (same as entityId) or 'pi_id' (same value)
         const portfolios = sortAsc(getEntityRows(data['portfolio_snapshots']));
         const historyData = sortAsc(getEntityRows(data['trade_history_snapshots']));
@@ -188,7 +188,7 @@ class PopularInvestorProfileMetrics extends Computation {
         const pageViews = sortAsc(getEntityRows(data['pi_page_views']));
         const watchlists = sortAsc(getEntityRows(data['watchlist_membership']));
         const alerts = sortAsc(getEntityRows(data['pi_alert_history']));
-        const masterList = getEntityRows(data['pi_master_list']); 
+        const masterList = getEntityRows(data['pi_master_list']);
 
         const currentPortfolio = portfolios.length > 0 ? portfolios[portfolios.length - 1] : null;
         const currentRanking = rankings.length > 0 ? rankings[rankings.length - 1] : null;
@@ -234,10 +234,10 @@ class PopularInvestorProfileMetrics extends Computation {
             trades.forEach(trade => {
                 const closeDate = rules.trades.getCloseDate(trade);
                 if (!closeDate) return;
-                
+
                 const dKey = closeDate.toISOString().split('T')[0];
                 const profit = rules.trades.getNetProfit(trade);
-                
+
                 const entry = profitableMap.get(dKey) || { date: dKey, profitableCount: 0, totalCount: 0 };
                 entry.totalCount++;
                 if (profit > 0) entry.profitableCount++;
@@ -272,7 +272,7 @@ class PopularInvestorProfileMetrics extends Computation {
         if (currentPortfolio) {
             const pData = rules.portfolio.extractPortfolioData(currentPortfolio);
             const positions = rules.portfolio.extractPositions(pData);
-            
+
             let totalInvested = 0, totalProfit = 0;
             const secMap = {};
             const assetMap = {};
@@ -280,12 +280,12 @@ class PopularInvestorProfileMetrics extends Computation {
 
             positions.forEach(pos => {
                 const id = rules.portfolio.getInstrumentId(pos);
-                const invested = rules.portfolio.getInvested(pos); 
+                const invested = rules.portfolio.getInvested(pos);
                 const netProfit = rules.portfolio.getNetProfit(pos);
-                
+
                 totalInvested += invested;
                 totalProfit += (invested * (netProfit / 100));
-                
+
                 const ticker = resolveTicker(id);
                 const sector = resolveSector(id);
 
@@ -304,7 +304,7 @@ class PopularInvestorProfileMetrics extends Computation {
             };
 
             Object.entries(assetMap)
-                .sort(([,a], [,b]) => b - a)
+                .sort(([, a], [, b]) => b - a)
                 .slice(0, 10)
                 .forEach(([k, v]) => result.assetExposure.data[k] = Number(v.toFixed(2)));
 
@@ -331,10 +331,10 @@ class PopularInvestorProfileMetrics extends Computation {
             const pData = rules.portfolio.extractPortfolioData(entry);
             const positions = rules.portfolio.extractPositions(pData);
             const dateStr = toDateStr(entry.date);
-            
+
             const dailySec = {};
             const dailyAsset = {};
-            
+
             positions.forEach(pos => {
                 const id = rules.portfolio.getInstrumentId(pos);
                 const invested = rules.portfolio.getInvested(pos);
@@ -351,8 +351,8 @@ class PopularInvestorProfileMetrics extends Computation {
         // ==========================================================================================
         // 7. SOCIAL, RATINGS, PAGEVIEWS, WATCHLIST
         // ==========================================================================================
-        const sevenDaysAgo = new Date(new Date(date).setDate(new Date(date).getDate() - 7)).toISOString().slice(0,10);
-        
+        const sevenDaysAgo = new Date(new Date(date).setDate(new Date(date).getDate() - 7)).toISOString().slice(0, 10);
+
         socialData.filter(d => toDateStr(d.date) >= sevenDaysAgo).forEach(day => {
             const posts = rules.social.extractPosts(day);
             let likes = 0, comments = 0;
@@ -379,7 +379,7 @@ class PopularInvestorProfileMetrics extends Computation {
             const d = toDateStr(p.date);
             if (d) {
                 result.pageViewsData.viewsOverTime.data.push({ date: d, views });
-                result.pageViewsData.totalViews += views; 
+                result.pageViewsData.totalViews += views;
                 result.pageViewsData.uniqueViewers = Number(p.unique_viewers || 0);
             }
         });
@@ -403,7 +403,7 @@ class PopularInvestorProfileMetrics extends Computation {
             const d = toDateStr(row.date);
             const type = row.alert_type;
             const count = Number(row.trigger_count || 1);
-            
+
             if (type && type.toLowerCase().includes('test')) return;
 
             result.alertMetrics.totalLast7Days += count;