aiden-shared-calculations-unified 1.0.152 → 1.0.153

package/calculations/popular-investor/GlobalAumPerAsset30D.js

@@ -1,5 +1,6 @@
 /**
- * @fileoverview Aggregates PI Asset AUM over the last 30 days.
+ * @fileoverview Aggregates the $ AUM invested in every asset across all Popular Investors.
+ * Reads the results from PIDailyAssetAUM.
  */
 class GlobalAumPerAsset30D {
     static getMetadata() {
@@ -7,45 +8,42 @@ class GlobalAumPerAsset30D {
             type: 'meta',
             category: 'analytics',
             rootDataDependencies: [],
-            // No dependencySeries needed! We just need Today's results via getDependencies.
             schedule: { type: 'DAILY' }
         };
     }
 
     static getDependencies() { 
-        // Force running AFTER the Standard comp
-        // CRITICAL: Must match the File Name of the standard computation
         return ['PIDailyAssetAUM']; 
     }
 
     async process(context) {
-        // Access the results injected by getDependencies()
-        // CRITICAL: Must match the File Name
+        // Access the map of results: { UserID: { Ticker: $Amount } }
         const allUserResults = context.computed['PIDailyAssetAUM']; 
 
-        const globalAverages = {};
-        let userCount = 0;
+        const globalTotals = {};
+        let piCount = 0;
 
         if (allUserResults) {
-            Object.values(allUserResults).forEach(userOutput => {
-                // userOutput is: { dailyMap, averageMap }
-                const avgMap = userOutput.averageMap;
-                if (!avgMap) return;
-
-                userCount++;
-                Object.entries(avgMap).forEach(([ticker, avgVal]) => {
-                    if (!globalAverages[ticker]) globalAverages[ticker] = 0;
-                    globalAverages[ticker] += avgVal;
+            Object.values(allUserResults).forEach(userAllocationMap => {
+                if (!userAllocationMap) return;
+                
+                piCount++;
+                
+                // userAllocationMap is { AAPL: 5000, TSLA: 2000, ... }
+                Object.entries(userAllocationMap).forEach(([ticker, usdValue]) => {
+                    if (!globalTotals[ticker]) globalTotals[ticker] = 0;
+                    globalTotals[ticker] += usdValue;
                 });
             });
         }
 
-        // Result: The Sum of everyone's 30-Day Average Allocations
-        this.results = globalAverages;
+        // Result: { AAPL: 5000000, TSLA: ... }
+        this.results = globalTotals;
         
-        // CRITICAL FIX: MetaExecutor requires the data to be returned
+        // Return for potential debugging or further chaining
         return this.results;
     }
+    
     async getResult() { return this.results; }
 }
 

package/calculations/popular-investor/PIDailyAssetAUM.js

@@ -1,25 +1,23 @@
 /**
- * @fileoverview Calculates the $ AUM allocated to each asset for a single PI using a Rolling 30-Day Window.
+ * @fileoverview Calculates the $ AUM allocated to each asset for a single PI.
+ * Includes a lookback mechanism: If AUM is missing today, it checks the last 30 days of rankings.
  */
 class PIDailyAssetAUM {
     static getMetadata() {
         return {
             type: 'standard',
             category: 'analytics',
-            userType: 'POPULAR_INVESTOR',
+            userType: 'POPULAR_INVESTOR', // Ensures we only run for PIs
             
             // 1. Core Data
             rootDataDependencies: ['portfolio', 'rankings'],
-            mandatoryRoots: ['portfolio', 'rankings'],
+            mandatoryRoots: ['portfolio'], // Rankings are mandatory but handled via lookback if missing today
 
-            // 2. History: Load MY OWN results from the last 29 days
-            // CRITICAL: Name must match the File Name (PIDailyAssetAUM)
-            dependencySeries: {
-                'PIDailyAssetAUM': 29 
-            },
-
-            // 3. Bootstrap Flag: Allows running even if history is empty (First Run)
-            canHaveMissingSeries: true
+            // 2. Rankings Lookback Series
+            // This requests the last 30 days of rankings to be available in context.seriesData.root.rankings
+            rootDataSeries: {
+                rankings: 30
+            }
         };
     }
 
@@ -29,73 +27,63 @@ class PIDailyAssetAUM {
         const { extract, RankingsExtractor } = context.math;
         const userId = context.user.id;
 
-        // --- STEP A: Calculate TODAY (T-0) ---
-        const piAum = RankingsExtractor.getAUMValue(context.user.rankEntry);
-        const todayAllocation = {};
-
-        if (piAum > 0) {
-            const positions = extract.getPositions(context.user.portfolio.today, context.user.type);
-            positions.forEach(pos => {
-                const instId = extract.getInstrumentId(pos);
-                const ticker = context.mappings.instrumentToTicker[instId] || `ID:${instId}`;
-                const pct = extract.getPositionValue(pos) || 0;
-                
-                // Convert % to $
-                const usdValue = piAum * (pct / 100);
+        // --- STEP A: Determine AUM (With Lookback) ---
+        // 1. Try Today
+        let piAum = RankingsExtractor.getAUMValue(context.user.rankEntry);
+        
+        // 2. If missing, look back up to 30 days
+        if (!piAum || piAum === 0) {
+            const rankingsSeries = context.seriesData?.root?.rankings || {};
+            
+            // Get dates sorted newest to oldest
+            const availableDates = Object.keys(rankingsSeries).sort((a, b) => b.localeCompare(a));
+            
+            for (const dateKey of availableDates) {
+                const dailyRankings = rankingsSeries[dateKey];
+                const historicalEntry = RankingsExtractor.getEntry(dailyRankings, userId);
+                const historicalAum = RankingsExtractor.getAUMValue(historicalEntry);
                 
-                if (usdValue > 0) {
-                    if (!todayAllocation[ticker]) todayAllocation[ticker] = 0;
-                    todayAllocation[ticker] += usdValue;
+                if (historicalAum > 0) {
+                    piAum = historicalAum;
+                    // Optional: Log that we used historical data
+                    // context.logger.log('INFO', `Using historical AUM for ${userId} from ${dateKey}: $${piAum}`);
+                    break;
                 }
-            });
+            }
         }
 
-        // --- STEP B: Load History (T-1 to T-29) ---
-        // Access using the FILE NAME key
-        const historyMap = context.globalData.series?.results?.['PIDailyAssetAUM'] || {};
-        
-        const rollingWindow = [];
-        
-        if (historyMap) {
-            Object.values(historyMap).forEach(dayResult => {
-                const userResult = dayResult[userId];
-                if (userResult && userResult.dailyMap) {
-                    rollingWindow.push(userResult.dailyMap);
-                }
-            });
+        // If still no AUM found, we cannot compute $ allocation
+        if (!piAum || piAum <= 0) {
+            return; 
         }
 
-        // Always add Today
-        rollingWindow.push(todayAllocation);
+        // --- STEP B: Calculate $ Allocation Per Asset ---
+        const allocationMap = {};
+        const positions = extract.getPositions(context.user.portfolio.today, context.user.type);
 
-        // --- STEP C: Compute Rolling Average ---
-        const summedStats = {};
-        
-        rollingWindow.forEach(dayAllocations => {
-            Object.entries(dayAllocations).forEach(([ticker, val]) => {
-                if (!summedStats[ticker]) summedStats[ticker] = { total: 0, count: 0 };
-                summedStats[ticker].total += val;
-                summedStats[ticker].count += 1; 
-            });
-        });
-
-        const rollingAverage = {};
-        const validDays = rollingWindow.length;
+        positions.forEach(pos => {
+            const instId = extract.getInstrumentId(pos);
+            const ticker = context.mappings.instrumentToTicker[instId] || `ID:${instId}`;
+            
+            // Get Weight (%)
+            const pct = extract.getPositionWeight(pos); // Uses Invested or Amount based on schema
 
-        if (validDays > 0) {
-            Object.entries(summedStats).forEach(([ticker, stat]) => {
-                rollingAverage[ticker] = stat.total / validDays;
-            });
-        }
+            // Calculate $ Value: AUM * (Weight / 100)
+            // Note: Ensure pct is treated as percentage (e.g. 5.5 = 5.5%)
+            if (pct > 0) {
+                const usdValue = piAum * (pct / 100);
+                
+                if (!allocationMap[ticker]) allocationMap[ticker] = 0;
+                allocationMap[ticker] += usdValue;
+            }
+        });
 
-        // --- STEP D: Output Results ---
-        // StandardExecutor reads 'this.results', it does NOT use the return value.
+        // --- STEP C: Output Results ---
+        // Format: { [UserId]: { Ticker: $Amount } }
         this.results = {
-            [userId]: {
-                dailyMap: todayAllocation,
-                averageMap: rollingAverage
-            }
+            [userId]: allocationMap
         };
+        
         return this.results;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.152",
+  "version": "1.0.153",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [