aiden-shared-calculations-unified 1.0.151 → 1.0.153

package/calculations/alerts/Behaviour.js

@@ -15,8 +15,7 @@ class BehavioralAnomaly {
             type: 'standard',
             isHistorical: true, 
             
-            // RESTORED: Request full 60-day history for both Portfolio and Rankings.
-            // CachedDataLoader handles this efficiently via reference pointers.
+            // Request 60 days of history for baseline
             rootDataSeries: {
                 portfolio: 60,
                 rankings: 60 
@@ -57,7 +56,6 @@ class BehavioralAnomaly {
 
         let sumSquares = 0;
         let totalValue = 0;
-
         positions.forEach(p => totalValue += DataExtractor.getPositionValue(p));
 
         if (totalValue === 0) return 0;
@@ -73,7 +71,6 @@ class BehavioralAnomaly {
     calculateMartingaleScore(tradeHistory) {
         if (!tradeHistory || tradeHistory.length < 2) return 0;
         
-        // Trades are already filtered by date in the main loop logic
         const sorted = [...tradeHistory].sort((a, b) => new Date(a.CloseDateTime) - new Date(b.CloseDateTime));
         const recentTrades = sorted.slice(-30);
         
@@ -98,7 +95,6 @@ class BehavioralAnomaly {
 
     getDailyVector(portfolio, rankings, history, math) {
         const { RankingsExtractor } = math;
-
         const hhi = this.calculateHHI(portfolio, math);
         const mScore = this.calculateMartingaleScore(history);
 
@@ -115,7 +111,7 @@ class BehavioralAnomaly {
         return [hhi, mScore, strain, risk];
     }
 
-    process(context) {
+    async process(context) {
         const { math, globalData } = context; 
         const { LinearAlgebra } = math;
         const userId = context.user.id;
@@ -123,8 +119,6 @@ class BehavioralAnomaly {
         const seriesData = globalData?.series?.root || {};
         const portfolioSeries = seriesData.portfolio || {};
         const rankingsSeries = seriesData.rankings || {};
-        
-        // Full Trade History (Contains ALL time, so we must filter it)
         const fullHistory = context.user.history || [];
 
         const availableDates = Object.keys(portfolioSeries).sort();
@@ -135,56 +129,37 @@ class BehavioralAnomaly {
             const datePortfolio = portfolioSeries[date][userId];
             if (!datePortfolio) continue;
 
-            // CRITICAL FIX: Filter History to avoid "Time Travel"
-            // We only look at trades that had closed ON or BEFORE this specific loop date.
             const loopDateObj = new Date(date);
             const historyAsOfDate = fullHistory.filter(t => new Date(t.CloseDateTime) <= loopDateObj);
-
-            // Robust Lookup: Find ranking for this date (or closest recent date)
             const rankingsSnapshot = this.findClosestData(date, rankingsSeries);
             const userRanking = rankingsSnapshot ? rankingsSnapshot.find(r => String(r.CustomerId) === String(userId)) : null;
 
-            const vec = this.getDailyVector(
-                datePortfolio, 
-                userRanking, 
-                historyAsOfDate, // Pass filtered history
-                math
-            );
+            const vec = this.getDailyVector(datePortfolio, userRanking, historyAsOfDate, math);
             trainingVectors.push(vec);
         }
 
         // 2. Minimum Viable Baseline
+        const localResults = {}; // Local container to satisfy Guard logic
         const MIN_DATAPOINTS = 15;
+        
         if (trainingVectors.length < MIN_DATAPOINTS) {
-            this.results[userId] = { 
-                status: 'INSUFFICIENT_BASELINE', 
-                dataPoints: trainingVectors.length 
-            };
-            return;
+            localResults[userId] = { status: 'INSUFFICIENT_BASELINE', dataPoints: trainingVectors.length };
+            this.results = localResults;
+            return this.results;
         }
 
-        // 3. Compute Statistics (Covariance Matrix)
+        // 3. Compute Statistics
         const stats = LinearAlgebra.covarianceMatrix(trainingVectors);
         const inverseCov = LinearAlgebra.invertMatrix(stats.matrix);
 
-        // Singular Matrix Check (If behavior is perfectly identical every day)
         if (!inverseCov) {
-            this.results[userId] = { status: 'STABLE_STATE', info: 'Variance too low' };
-            return;
+            localResults[userId] = { status: 'STABLE_STATE', info: 'Variance too low' };
+            this.results = localResults;
+            return this.results;
         }
 
         // 4. Compute Today's Vector
-        // We use the explicit 'today' injection, or fallback to the series
-        const todayRanking = context.user.rankEntry || 
-                             (this.findClosestData(context.date.today, rankingsSeries) || [])
-                             .find(r => String(r.CustomerId) === String(userId));
-
-        const todayVector = this.getDailyVector(
-            context.user.portfolio.today, 
-            todayRanking,
-            fullHistory, // Today includes all history
-            math
-        );
+        const todayVector = this.getDailyVector(context.user.portfolio.today, context.user.rankEntry, fullHistory, math);
 
         // 5. Calculate Distance
         const distance = LinearAlgebra.mahalanobisDistance(todayVector, stats.means, inverseCov);
@@ -204,31 +179,31 @@ class BehavioralAnomaly {
                 }
             });
 
-            this.results[userId] = {
+            localResults[userId] = {
                 triggered: true,
                 anomalyScore: parseFloat(distance.toFixed(2)),
                 primaryDriver: primaryDriver,
                 driverSignificance: `${maxZ.toFixed(1)}σ`,
                 baselineDays: trainingVectors.length,
-                vectors: {
-                    current: todayVector,
-                    baselineMeans: stats.means
-                }
+                vectors: { current: todayVector, baselineMeans: stats.means }
             };
             
             // Add CID to index for downstream alert handlers
-            if (!this.results.cids) this.results.cids = [];
-            this.results.cids.push(userId);
+            if (!localResults.cids) localResults.cids = [];
+            localResults.cids.push(userId);
         } else {
-            this.results[userId] = { 
-                triggered: false, 
-                anomalyScore: parseFloat(distance.toFixed(2)) 
-            };
-            
+            localResults[userId] = { triggered: false, anomalyScore: parseFloat(distance.toFixed(2)) };
         }
+
+        // --- FINAL ASSIGNMENT ---
+        // Satisfies the Guard AND hands data to getResult()
+        this.results = localResults;
+        return this.results;
+    }
+
+    async getResult() { 
+        return this.results; 
     }
-    async getResult() { return this.results; }
-    
 }
 
 module.exports = BehavioralAnomaly;

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/calculations/popular-investor/PiAssetRecommender.js

@@ -2,9 +2,10 @@
  * @fileoverview Asset Recommendation Engine.
  * Suggests assets based on Similar Users and Sector Gaps.
  */
-
 class PiAssetRecommender {
-    constructor() { this.results = {}; }
+    constructor() { 
+        this.results = {}; 
+    }
 
     static getMetadata() {
         return {
@@ -15,6 +16,8 @@ class PiAssetRecommender {
     }
 
     static getDependencies() { 
+        // Expects these to be available in context.computed
+        // (Ensure these are Meta computations or small enough to be passed in memory)
         return ['PiSectorAnalysis', 'PiSimilarityMatrix', 'PiSimilarityVector']; 
     }
 
@@ -25,15 +28,16 @@ class PiAssetRecommender {
         };
     }
 
-    process(context) {
+    async process(context) {
         // 1. Access computed results from previous steps
         const similarityMatrix = context.computed['PiSimilarityMatrix'];
         const vectors = context.computed['PiSimilarityVector'];
-        const { mappings } = context;
+        const mappings = context.mappings || {};
 
         // Defensive Check: If inputs missing, return empty object
         if (!similarityMatrix || !vectors) {
-            return {};
+            this.results = {};
+            return this.results;
         }
 
         const recommendations = {};
@@ -75,10 +79,12 @@ class PiAssetRecommender {
             recommendations[userId] = sorted;
         }
 
-        // [FIX] CLEANER APPROACH:
-        // Instead of assigning to a confusing 'meta' key, we simply RETURN the data.
-        // The MetaExecutor will automatically save this under the correct 'global' key.
-        return recommendations;
+        // --- CRITICAL FIX ---
+        // 1. Save to Class Property (Required by ResultCommitter via getResult)
+        this.results = recommendations;
+
+        // 2. Return to MetaExecutor (Required for wrapping)
+        return this.results;
     }
 
     async getResult() {

package/calculations/popular-investor/PiSimilarityMatrix.js

@@ -2,7 +2,6 @@
  * @fileoverview Similarity Matrix Meta-Computation.
  * Calculates cosine similarity between all PI vectors to find nearest neighbors.
  */
-
 class PiSimilarityMatrix {
     constructor() { this.results = {}; }
 
@@ -24,12 +23,14 @@ class PiSimilarityMatrix {
         };
     }
 
-    process(context) {
-    const vectorMap = context.computed['PiSimilarityVector'];
-    // [FIX] Ensure we have enough peers to actually compare
-    if (!vectorMap || Object.keys(vectorMap).length < 2) {
-        return {}; // Return TRUE empty so ResultCommitter skips the write
-    }
+    async process(context) {
+        const vectorMap = context.computed['PiSimilarityVector'];
+        
+        // [FIX] Ensure we have enough peers to actually compare
+        if (!vectorMap || Object.keys(vectorMap).length < 2) {
+            this.results = {}; // Explicitly set empty
+            return this.results; 
+        }
 
         const userIds = Object.keys(vectorMap);
         const matrix = {};
@@ -87,8 +88,12 @@ class PiSimilarityMatrix {
             matrix[u1] = matches.sort((a,b) => b.score - a.score).slice(0, 5);
         }
 
-        // [FIX] MetaExecutor requires return value
-        return matrix;
+        // --- CRITICAL FIX ---
+        // 1. Assign to class property (for getResult)
+        this.results = matrix;
+
+        // 2. Return to MetaExecutor (for wrapping)
+        return this.results;
     }
 
     async getResult() {

package/calculations/popular-investor/PiTotalAum.js

@@ -4,7 +4,9 @@
  */
 
 class PiTotalAum {
-    constructor() { this.results = {}; }
+    constructor() { 
+        this.results = {}; // Container for getResult()
+    }
 
     static getMetadata() {
         return {
@@ -14,32 +16,48 @@ class PiTotalAum {
         };
     }
 
-    static getDependencies() { return ['PiAumOverTime']; }
+    static getDependencies() { 
+        return ['PiAumOverTime']; 
+    }
 
     static getSchema() {
-        return { type: 'number', description: 'Total AUM of all tracked PIs' };
+        return { 
+            type: 'number', 
+            description: 'Total AUM of all tracked PIs' 
+        };
     }
 
-    process(context) {
+    async process(context) {
+        // 1. Get the map of CID -> AUM from the dependency
         const aumMap = context.computed['PiAumOverTime'];
         
-        // [FIX] Return 0 if data missing
         if (!aumMap) {
-            return 0;
+            this.results = 0;
+            return this.results;
         }
 
         let total = 0;
         for (const val of Object.values(aumMap)) {
-            // Validate it's a number
-            if (typeof val === 'number') total += val;
+            // Ensure we are adding numbers
+            if (typeof val === 'number') {
+                total += val;
+            }
         }
 
+        // 2. Format result
         const result = Number(total.toFixed(2));
         
-        // [FIX] MetaExecutor requires return value
-        return result;
+        // --- CRITICAL FIX ---
+        // A. Set the property for the Committer (ResultCommitter.js line 72)
+        this.results = result;
+        
+        // B. Return for the Executor (MetaExecutor.js line 176)
+        return this.results;
     }
 
+    /**
+     * REQUIRED: Interface for the storage layer.
+     */
     async getResult() {
         return this.results;
     }

package/package.json

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