bulltrackers-module 1.0.770 → 1.0.772

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

@@ -13,27 +13,25 @@ class GlobalAumPerAsset extends Computation {
             name: 'GlobalAumPerAsset',
             type: 'global',
             category: 'market_insights',
-            
+
             requires: {
                 'computation_results': {
-                    lookback: 0, 
+                    lookback: 0,
                     mandatory: true,
                     fields: ['result_data', 'computation_name', 'date'],
                     // Lowercase to match BigQuery storage
-                    filter: { 
-                        computation_name: 'pidailyassetaum' 
+                    filter: {
+                        computation_name: 'pidailyassetaum'
                     }
                 }
             },
-            
+
             dependencies: ['PIDailyAssetAUM'],
 
             storage: {
                 bigquery: true,
                 firestore: {
-                    enabled: true,
-                    path: 'global_metrics/aum_per_asset_{date}',
-                    merge: true
+                    enabled: false,
                 }
             }
         };
@@ -44,8 +42,8 @@ class GlobalAumPerAsset extends Computation {
 
         let rows = data['computation_results'];
         if (!rows) {
-             console.log('[GlobalAumPerAsset] No input data found.');
-             return;
+            console.log('[GlobalAumPerAsset] No input data found.');
+            return;
         }
 
         if (!Array.isArray(rows) && typeof rows === 'object') {
@@ -64,15 +62,15 @@ class GlobalAumPerAsset extends Computation {
 
         for (const row of rows) {
             let assetMap = row.result_data;
-            
+
             if (typeof assetMap === 'string') {
                 try { assetMap = JSON.parse(assetMap); } catch (e) { continue; }
             }
-            
+
             if (!assetMap) continue;
 
             piCount++;
-            
+
             for (const [ticker, value] of Object.entries(assetMap)) {
                 if (typeof value === 'number') {
                     const current = globalTotals.get(ticker) || 0;

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

@@ -8,7 +8,7 @@ class PIDailyAssetAUM extends Computation {
             type: 'per-entity',
             category: 'popular_investor',
             isHistorical: true,
-            
+
             requires: {
                 // Driver: Only process Popular Investors
                 'portfolio_snapshots': {
@@ -22,22 +22,20 @@ class PIDailyAssetAUM extends Computation {
                     mandatory: true,
                     fields: ['pi_id', 'rankings_data', 'date']
                 },
-                'ticker_mappings': { 
+                'ticker_mappings': {
                     mandatory: false,
-                    fields: ['instrument_id', 'ticker'] 
-                }, 
-                'pi_master_list': { 
+                    fields: ['instrument_id', 'ticker']
+                },
+                'pi_master_list': {
                     mandatory: false,
-                    fields: ['cid', 'username'] 
+                    fields: ['cid', 'username']
                 }
             },
 
             storage: {
                 bigquery: true,
                 firestore: {
-                    enabled: true,
-                    path: 'popular_investors/{entityId}/metrics/asset_aum_{date}',
-                    merge: true
+                    enabled: false
                 }
             }
         };
@@ -62,7 +60,7 @@ class PIDailyAssetAUM extends Computation {
             if (Array.isArray(dataset)) return dataset.filter(r => String(r.user_id || r.pi_id || r.cid) === String(entityId));
             return [];
         };
-        
+
         // Mappings
         const tickerMap = new Map();
         const mappingsList = Array.isArray(context.data['ticker_mappings']) ? context.data['ticker_mappings'] : Object.values(context.data['ticker_mappings'] || {});
@@ -77,8 +75,8 @@ class PIDailyAssetAUM extends Computation {
         let validRanking = null;
 
         // Sort descending using safe date parsing
-        portfolios.sort((a,b) => parseDate(b.date) - parseDate(a.date));
-        rankings.sort((a,b) => parseDate(b.date) - parseDate(a.date));
+        portfolios.sort((a, b) => parseDate(b.date) - parseDate(a.date));
+        rankings.sort((a, b) => parseDate(b.date) - parseDate(a.date));
 
         if (portfolios.length > 0) {
             validPortfolio = portfolios[0];
@@ -88,7 +86,7 @@ class PIDailyAssetAUM extends Computation {
                 const rDate = parseDate(r.date);
                 const diffTime = Math.abs(pDate - rDate);
                 const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
-                
+
                 // Allow up to 14 days gap (matches your data reality)
                 return diffDays <= 14;
             });
@@ -101,10 +99,10 @@ class PIDailyAssetAUM extends Computation {
         // 3. Calculation
         const pData = rules.portfolio.extractPortfolioData(validPortfolio);
         const rData = rules.rankings.extractRankingsData(validRanking);
-        
+
         // FIX: Use 'getAUM' (checked from rules/rankings.js)
-        const totalAum = rules.rankings.getAUM(rData); 
-        
+        const totalAum = rules.rankings.getAUM(rData);
+
         if (!totalAum || totalAum <= 0) return;
 
         const positions = rules.portfolio.extractPositions(pData);
@@ -113,10 +111,10 @@ class PIDailyAssetAUM extends Computation {
         positions.forEach(pos => {
             const id = rules.portfolio.getInstrumentId(pos);
             const ticker = resolveTicker(id);
-            
+
             // FIX: Use 'getInvested' (checked from rules/portfolio.js)
-            const weight = rules.portfolio.getInvested(pos); 
-            
+            const weight = rules.portfolio.getInvested(pos);
+
             if (weight > 0) {
                 // weight is a percentage (e.g., 5.5 for 5.5%), so divide by 100
                 const dollarValue = (weight / 100) * totalAum;

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

@@ -1,14 +1,11 @@
 /**
- * @fileoverview PI Feature Vectors
- * 
- * Global computation that builds normalized feature vectors for all Popular Investors.
- * Used by PiRecommender to find balanced recommendations.
- * 
- * Features computed per PI:
- * - Sector exposure (normalized %)
- * - Risk profile (volatility, risk score)
- * - Performance metrics (gain %, win ratio)
- * - Quality indicators (AUM tier, copiers)
+ * @fileoverview PI Feature Vectors (v2 - Direction Aware)
+ * * Global computation that builds normalized feature vectors for all Popular Investors.
+ * Calculates Net Exposure (Long - Short) based on Portfolio Value %.
+ * * Features computed per PI:
+ * - Net Sector exposure (Signed %: + for Long, - for Short)
+ * - Leverage utilization
+ * - Quality indicators (Risk, Gain, Copiers)
  */
 const { Computation } = require('../framework');
 
@@ -16,7 +13,7 @@ class PiFeatureVectors extends Computation {
     static getConfig() {
         return {
             name: 'PiFeatureVectors',
-            description: 'Computes feature vectors for all PIs for recommendation matching',
+            description: 'Computes signed feature vectors for all PIs (Net Exposure)',
             type: 'global',
             category: 'popular_investor',
             isHistorical: false,
@@ -36,10 +33,10 @@ class PiFeatureVectors extends Computation {
                 'pi_master_list': {
                     lookback: 1,
                     mandatory: false,
-                    fields: ['cid', 'username', 'verified_date']
+                    fields: ['cid', 'username', 'last_updated']
                 },
-                'ticker_mappings': { mandatory: false },
-                'sector_mappings': { mandatory: false }
+                'ticker_mappings': { lookback: 0, mandatory: false, fields: ['instrument_id', 'ticker'] },
+                'sector_mappings': { lookback: 0, mandatory: false, fields: ['symbol', 'sector'] }
             },
 
             storage: {
@@ -53,16 +50,10 @@ class PiFeatureVectors extends Computation {
         const { data, rules, targetDate } = context;
 
         // ===========================================================================
-        // SETUP: Helpers and reference data
+        // SETUP: Mappings
         // ===========================================================================
-        const toArray = (input) => {
-            if (!input) return [];
-            if (Array.isArray(input)) return input;
-            // Handle Map-like structure from DataFetcher
-            return Object.values(input).flat();
-        };
+        const toArray = (input) => Array.isArray(input) ? input : Object.values(input).flat();
 
-        // Build sector lookup
         const tickerMap = new Map();
         toArray(data['ticker_mappings']).forEach(row => {
             if (row.instrument_id && row.ticker) {
@@ -82,7 +73,6 @@ class PiFeatureVectors extends Computation {
             return ticker ? (sectorMap.get(ticker) || 'Other') : 'Other';
         };
 
-        // All known sectors for consistent vector dimensions
         const ALL_SECTORS = [
             'Technology', 'Healthcare', 'Financial Services', 'Consumer Cyclical',
             'Industrials', 'Energy', 'Utilities', 'Real Estate', 'Communication Services',
@@ -90,28 +80,22 @@ class PiFeatureVectors extends Computation {
         ];
 
         // ===========================================================================
-        // GATHER: PI portfolio and rankings data
+        // GATHER DATA
         // ===========================================================================
         const rankings = toArray(data['pi_rankings']);
         const portfolios = data['portfolio_snapshots']; // Map { piId: [rows] }
         const masterList = toArray(data['pi_master_list']);
 
-        // Build username lookup
         const usernameMap = new Map();
-        rankings.forEach(r => {
-            const id = String(r.pi_id || r.CustomerId);
-            usernameMap.set(id, r.username || r.UserName);
-        });
+        rankings.forEach(r => usernameMap.set(String(r.pi_id || r.CustomerId), r.username || r.UserName));
         masterList.forEach(m => {
             if (m.cid && m.username) usernameMap.set(String(m.cid), m.username);
         });
 
         // ===========================================================================
-        // COMPUTE: Feature vectors for each PI
+        // COMPUTE VECTORS
         // ===========================================================================
         const featureVectors = {};
-
-        // Process each PI's portfolio
         const piIds = Object.keys(portfolios || {});
 
         for (const piId of piIds) {
@@ -119,55 +103,37 @@ class PiFeatureVectors extends Computation {
             const latestRow = rows[rows.length - 1];
             if (!latestRow) continue;
 
-            // Extract positions
             const pData = rules.portfolio.extractPortfolioData(latestRow);
             const positions = rules.portfolio.extractPositions(pData);
 
             if (positions.length === 0) continue;
 
-            // Calculate sector exposure
-            const sectorWeights = {};
-            let totalValue = 0;
+            // 1. Calculate Signed Sector Exposure (Net Exposure)
+            // Value is % of Total Portfolio Value.
+            const sectorNetValue = {};
+            let totalGrossExposure = 0; // Sum of abs(value)
 
             positions.forEach(pos => {
                 const instrumentId = rules.portfolio.getInstrumentId(pos);
-                const invested = rules.portfolio.getInvested(pos) || 0;
+                const value = rules.portfolio.getValue(pos) || 0; // Already a %
                 const sector = resolveSector(instrumentId);
+                const isShort = rules.portfolio.isShort(pos);
+
+                // Signed Value: Long is +, Short is -
+                const signedValue = isShort ? -value : value;
 
-                sectorWeights[sector] = (sectorWeights[sector] || 0) + invested;
-                totalValue += invested;
+                sectorNetValue[sector] = (sectorNetValue[sector] || 0) + signedValue;
+                totalGrossExposure += value; // Utilization of equity
             });
 
-            // Normalize sector exposure to percentages
+            // Populate vector with Net Exposure % (e.g., -15.5 for Short Tech)
             const sectorVector = {};
             ALL_SECTORS.forEach(s => {
-                sectorVector[s] = totalValue > 0
-                    ? Number(((sectorWeights[s] || 0) / totalValue).toFixed(4))
-                    : 0;
+                sectorVector[s] = Number((sectorNetValue[s] || 0).toFixed(4));
             });
 
-            // Get ranking data
-            if (piIds.indexOf(piId) === 0) {
-                const availableIds = rankings.map(r => r.pi_id || 'undefined').join(',');
-                console.log(`[DEBUG] Available IDs in rankings: ${availableIds}`);
-                console.log(`[DEBUG] First ranking row keys: ${Object.keys(rankings[0] || {}).join(',')}`);
-                if (rankings[0]) console.log(`[DEBUG] First ranking row pi_id: ${rankings[0].pi_id}`);
-            }
+            // 2. Extract Quality Metrics
             const rankRow = rankings.find(r => String(r.pi_id || r.CustomerId) === String(piId));
-
-            if (piIds.indexOf(piId) === 0) {
-                console.log(`[DEBUG] PiId: ${piId}`);
-                console.log(`[DEBUG] RankRow found: ${!!rankRow}`);
-                if (rankRow) {
-                    console.log(`[DEBUG] RankRow keys: ${Object.keys(rankRow).join(',')}`);
-                    console.log(`[DEBUG] RankingsData type: ${typeof rankRow.rankings_data}`);
-                    if (typeof rankRow.rankings_data === 'object') {
-                        console.log(`[DEBUG] RankingsData keys: ${Object.keys(rankRow.rankings_data).join(',')}`);
-                        console.log(`[DEBUG] RankingsData.Gain: ${rankRow.rankings_data.Gain}`);
-                    }
-                }
-            }
-
             let riskScore = 5, gain = 0, copiers = 0, winRatio = 0, aumTier = 0;
 
             if (rankRow) {
@@ -181,40 +147,28 @@ class PiFeatureVectors extends Computation {
                 }
             }
 
-            // Calculate concentration (Herfindahl index) - higher = more concentrated
-            const weights = Object.values(sectorWeights).filter(w => w > 0);
-            const hhi = totalValue > 0
-                ? weights.reduce((sum, w) => sum + Math.pow(w / totalValue, 2), 0)
+            // Concentration (HHI based on gross exposure per sector)
+            const grossWeights = Object.values(sectorNetValue).map(Math.abs);
+            const sumGross = grossWeights.reduce((a, b) => a + b, 0);
+            const hhi = sumGross > 0
+                ? grossWeights.reduce((sum, w) => sum + Math.pow(w / sumGross, 2), 0)
                 : 1;
 
-            // Assemble feature vector
             featureVectors[piId] = {
                 piId: String(piId),
                 username: usernameMap.get(String(piId)) || 'Unknown',
-
-                // Sector exposure (normalized)
-                sectors: sectorVector,
-
-                // Risk profile
-                riskScore: riskScore,
-                concentration: Number(hhi.toFixed(4)),  // 0-1, higher = less diversified
-
-                // Performance
-                gain: gain,
-                winRatio: winRatio,
-
-                // Quality
-                copiers: copiers,
-                aumTier: aumTier,
-                positionCount: positions.length,
-
-                // Metadata
-                totalValue: Number(totalValue.toFixed(2)),
+                sectors: sectorVector, // Signed Net Exposure
+                riskScore,
+                concentration: Number(hhi.toFixed(4)),
+                gain,
+                winRatio,
+                copiers,
+                aumTier,
+                grossExposure: Number(totalGrossExposure.toFixed(2)),
                 computedAt: targetDate
             };
         }
 
-        // Store all vectors as a single global result
         this.setResult('_global', {
             vectors: featureVectors,
             piCount: Object.keys(featureVectors).length,
@@ -224,4 +178,4 @@ class PiFeatureVectors extends Computation {
     }
 }
 
-module.exports = PiFeatureVectors;
+module.exports = PiFeatureVectors;