aiden-shared-calculations-unified 1.0.109 → 1.0.110

package/calculations/core/platform-daily-ownership-delta.js

@@ -1,10 +1,6 @@
-/**
- * @fileoverview Calculation (Pass 1) for ownership delta (users added/lost per asset).
- * REFACTORED: Tracks net change in number of owners. ---> TODO IN TEST ENVIRONMENT THE VALUE OF NUMBER OF CLOSURES ALWAYS RETURNS 0, IS THIS A COMPUTATION BUG OR A TEST HARNESS BUG?
- */
 class PlatformDailyOwnershipDelta {
     constructor() {
-        this.assetChanges = new Map(); // { instId: { added: 0, removed: 0 } }
+        this.assetChanges = new Map();
         this.tickerMap = null;
     }
 
@@ -26,16 +22,17 @@ class PlatformDailyOwnershipDelta {
             "properties": {
                 "owners_added": { "type": "number" },
                 "owners_removed": { "type": "number" },
-                "net_ownership_change": { "type": "number" }
+                "net_ownership_change": { "type": "number" },
+                "total_owners_today": { "type": "number" }
             },
-            "required": ["owners_added", "owners_removed", "net_ownership_change"]
+            "required": ["owners_added", "owners_removed", "net_ownership_change", "total_owners_today"]
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
     _initAsset(instId) {
         if (!this.assetChanges.has(instId)) {
-            this.assetChanges.set(instId, { added: 0, removed: 0 });
+            this.assetChanges.set(instId, { added: 0, removed: 0, total: 0 });
         }
     }
 
@@ -53,28 +50,29 @@ class PlatformDailyOwnershipDelta {
         const { mappings, user } = context;
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        // If either portfolio is missing, we can't calculate delta for this user
-        if (!user.portfolio.today || !user.portfolio.yesterday) return;
-
         const todayPositions = extract.getPositions(user.portfolio.today, user.type);
-        const yesterdayPositions = extract.getPositions(user.portfolio.yesterday, user.type);
-
         const tSet = this._getOwnedInstruments(todayPositions, extract);
-        const ySet = this._getOwnedInstruments(yesterdayPositions, extract);
 
-        // Added: In Today, Not Yesterday
+        // Establish current total for Baseline
         for (const instId of tSet) {
-            if (!ySet.has(instId)) {
-                this._initAsset(instId);
-                this.assetChanges.get(instId).added++;
-            }
+            this._initAsset(instId);
+            this.assetChanges.get(instId).total++;
         }
 
-        // Removed: In Yesterday, Not Today
-        for (const instId of ySet) {
-            if (!tSet.has(instId)) {
-                this._initAsset(instId);
-                this.assetChanges.get(instId).removed++;
+        if (user.portfolio.yesterday) {
+            const yesterdayPositions = extract.getPositions(user.portfolio.yesterday, user.type);
+            const ySet = this._getOwnedInstruments(yesterdayPositions, extract);
+            for (const instId of tSet) {
+                if (!ySet.has(instId)) {
+                    this._initAsset(instId);
+                    this.assetChanges.get(instId).added++;
+                }
+            }
+            for (const instId of ySet) {
+                if (!tSet.has(instId)) {
+                    this._initAsset(instId);
+                    this.assetChanges.get(instId).removed++;
+                }
             }
         }
     }
@@ -84,13 +82,12 @@ class PlatformDailyOwnershipDelta {
         const result = {};
         for (const [instId, data] of this.assetChanges.entries()) {
             const ticker = this.tickerMap[instId] || `id_${instId}`;
-            if (data.added > 0 || data.removed > 0) {
-                result[ticker] = {
-                    owners_added: data.added,
-                    owners_removed: data.removed,
-                    net_ownership_change: data.added - data.removed
-                };
-            }
+            result[ticker] = {
+                owners_added: data.added,
+                owners_removed: data.removed,
+                net_ownership_change: data.added - data.removed,
+                total_owners_today: data.total
+            };
         }
         return result;
     }

package/calculations/core/price-metrics.js

@@ -1,15 +1,9 @@
-/**
- * @fileoverview Calculation (Pass 1 - Meta) for historical price metrics.
- * FIXED: Supports Sharded/Batched Execution.
- * MOVED: Sector aggregation logic moved to getResult() to handle sharding correctly.
- */
 const RANGES = [7, 30, 90, 365];
 const TRADING_DAYS_PER_YEAR = 252;
 
 class CorePriceMetrics {
     constructor() {
         this.result = { by_instrument: {}, by_sector: {} };
-        // We persist mappings here because we process shard-by-shard
         this.mappings = null; 
     }
 
@@ -49,13 +43,11 @@ class CorePriceMetrics {
         const prices = [];
         let currentDate = new Date(endDateStr + 'T00:00:00Z');
         let lastPrice = null;
-
         for (let i = 0; i < numDays; i++) {
             const targetDateStr = currentDate.toISOString().slice(0, 10);
             let price = this._findPriceOnOrBefore(priceHistoryObj, targetDateStr);
             if (price === null) price = lastPrice; 
             else lastPrice = price;
-
             if (price !== null) prices.push(price);
             currentDate.setUTCDate(currentDate.getUTCDate() - 1);
         }
@@ -63,9 +55,9 @@ class CorePriceMetrics {
     }
 
     _calculateStats(priceArray) {
-        if (priceArray.length < 2) return { stdDev: 0, mean: 0, drawdown: 0 };
+        const currentPrice = priceArray[priceArray.length - 1] || null;
+        if (priceArray.length < 2) return { stdDev: null, mean: null, drawdown: null, currentPrice };
 
-        // Drawdown
         let maxDrawdown = 0, peak = -Infinity;
         for (const price of priceArray) {
             if (price > peak) peak = price;
@@ -74,8 +66,6 @@ class CorePriceMetrics {
                 if (dd < maxDrawdown) maxDrawdown = dd;
             }
         }
-
-        // Returns & StdDev
         const returns = [];
         for (let i = 1; i < priceArray.length; i++) {
             const prev = priceArray[i - 1];
@@ -84,78 +74,53 @@ class CorePriceMetrics {
         }
         const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
         const variance = returns.reduce((a, b) => a + (b - mean) ** 2, 0) / (returns.length - 1);
-
-        return { stdDev: Math.sqrt(variance), mean, drawdown: maxDrawdown };
+        return { stdDev: Math.sqrt(variance), mean, drawdown: maxDrawdown, currentPrice };
     }
 
     process(context) {
         const { mappings, prices, date } = context;
         const { instrumentToTicker } = mappings;
-        
-        // Save mappings for the final aggregation step
         if (!this.mappings) this.mappings = mappings;
-        
         const priceData = prices?.history;
         const todayDateStr = date.today;
+        if (!priceData || !todayDateStr) return;
 
-        if (!priceData || !todayDateStr) {
-            return;
-        }
-
-        // Iterate over THIS SHARD'S data
         for (const p of Object.values(priceData)) {
             const ticker = instrumentToTicker[p.instrumentId];
             if (!ticker) continue;
-
-            const metrics = {};
+            const metrics = { baseline_price: null };
             for (const range of RANGES) {
                 const priceArray = this._getHistoricalPriceArray(p, todayDateStr, range + 1);
                 const stats = this._calculateStats(priceArray);
-
-                metrics[`stdev_${range}d`] = stats.stdDev;
-                metrics[`max_drawdown_${range}d`] = stats.drawdown;
-                metrics[`volatility_annualized_${range}d`] = stats.stdDev * Math.sqrt(TRADING_DAYS_PER_YEAR);
-                metrics[`sharpe_ratio_${range}d`] = stats.stdDev > 0 
-                    ? (stats.mean / stats.stdDev) * Math.sqrt(TRADING_DAYS_PER_YEAR) 
-                    : 0;
+                metrics.baseline_price = stats.currentPrice;
+                metrics[`stdev_${range}d`] = (stats.stdDev !== null && isFinite(stats.stdDev)) ? stats.stdDev : null;
+                metrics[`max_drawdown_${range}d`] = (stats.drawdown !== null && isFinite(stats.drawdown)) ? stats.drawdown : null;
+                metrics[`volatility_annualized_${range}d`] = (stats.stdDev !== null) ? stats.stdDev * Math.sqrt(TRADING_DAYS_PER_YEAR) : null;
+                metrics[`sharpe_ratio_${range}d`] = (stats.stdDev > 0) ? (stats.mean / stats.stdDev) * Math.sqrt(TRADING_DAYS_PER_YEAR) : null;
             }
-            // Accumulate into by_instrument
             this.result.by_instrument[ticker] = metrics;
         }
     }
 
     async getResult() { 
-        // Perform Sector Aggregation HERE (after all shards are processed)
         const by_instrument = this.result.by_instrument;
         const instrumentToSector = this.mappings?.instrumentToSector || {};
         const instrumentToTicker = this.mappings?.instrumentToTicker || {};
-        
-        // Reverse map ticker -> instrumentId
         const tickerToInstrument = {};
-        for(const [id, tick] of Object.entries(instrumentToTicker)) {
-            tickerToInstrument[tick] = id;
-        }
+        for(const [id, tick] of Object.entries(instrumentToTicker)) tickerToInstrument[tick] = id;
 
         const sectorAggs = {};
         for (const ticker in by_instrument) {
             const instId = tickerToInstrument[ticker];
             const sector = instrumentToSector[instId] || "Unknown"; 
-            
             if (!sectorAggs[sector]) sectorAggs[sector] = { metrics: {}, counts: {} };
-
             const data = by_instrument[ticker];
             for (const key in data) {
-                if (!sectorAggs[sector].metrics[key]) {
-                    sectorAggs[sector].metrics[key] = 0;
-                    sectorAggs[sector].counts[key] = 0;
-                }
-                if (data[key] !== null) {
-                    sectorAggs[sector].metrics[key] += data[key];
-                    sectorAggs[sector].counts[key]++;
-                }
+                if (key === 'baseline_price') continue;
+                if (!sectorAggs[sector].metrics[key]) { sectorAggs[sector].metrics[key] = 0; sectorAggs[sector].counts[key] = 0; }
+                if (data[key] !== null) { sectorAggs[sector].metrics[key] += data[key]; sectorAggs[sector].counts[key]++; }
             }
         }
-
         const by_sector = {};
         for (const sector in sectorAggs) {
             by_sector[sector] = {};
@@ -164,14 +129,10 @@ class CorePriceMetrics {
                 by_sector[sector][`average_${key}`] = count > 0 ? sectorAggs[sector].metrics[key] / count : null;
             }
         }
-        
         this.result.by_sector = by_sector;
         return this.result; 
     }
 
-    reset() { 
-        this.result = { by_instrument: {}, by_sector: {} }; 
-        this.mappings = null;
-    }
+    reset() { this.result = { by_instrument: {}, by_sector: {} }; this.mappings = null; }
 }
 module.exports = CorePriceMetrics;

package/calculations/core/short-interest-growth.js

@@ -19,7 +19,7 @@ class ShortInterestGrowth {
             "TICKER": {
                 "shortCount": 0,
                 "shortSparkline": [0, 0, 0, 0, 0, 0, 0],
-                "growth7d": 0.0
+                "growth7d": { "type": ["number", "null"] }
             }
         };
     }
@@ -27,7 +27,6 @@ class ShortInterestGrowth {
     async process(context) {
         const { insights: insightsHelper } = context.math;
         const { previousComputed, mappings } = context;
-        
         const dailyInsights = insightsHelper.getInsights(context, 'today');
         const previousState = previousComputed['short-interest-growth'] || {};
 
@@ -36,34 +35,28 @@ class ShortInterestGrowth {
             const ticker = mappings.instrumentToTicker[instId];
             if (!ticker) continue;
 
-            // Calculate Short Count: Total Owners * (Sell % / 100)
             const shortCount = insightsHelper.getShortCount(insight);
-            
             const prevState = previousState[ticker] || { shortSparkline: [] };
             const sparkline = [...(prevState.shortSparkline || [])];
-            
             sparkline.push(shortCount);
             if (sparkline.length > 7) sparkline.shift();
 
-            // Calculate simple 7-day growth %
-            let growth7d = 0;
-            if (sparkline.length > 1) {
+            let growth7d = null;
+            if (sparkline.length >= 7) {
                 const start = sparkline[0];
                 const end = sparkline[sparkline.length - 1];
-                if (start > 0) {
-                    growth7d = ((end - start) / start) * 100;
-                }
+                if (start > 0) growth7d = ((end - start) / start) * 100;
             }
 
             this.results[ticker] = {
                 shortCount,
                 shortSparkline: sparkline,
-                growth7d
+                growth7d: (growth7d !== null && isFinite(growth7d)) ? growth7d : null
             };
         }
     }
 
     async getResult() { return this.results; }
+    reset() { this.results = {}; }
 }
-
 module.exports = ShortInterestGrowth;

package/calculations/core/trending-ownership-momentum.js

@@ -7,7 +7,7 @@ class TrendingOwnershipMomentum {
             type: 'meta',
             category: 'core',
             userType: 'n/a',
-            isHistorical: true, // Needed for rolling history
+            isHistorical: true, 
             rootDataDependencies: ['insights']
         };
     }
@@ -18,9 +18,9 @@ class TrendingOwnershipMomentum {
         return {
             "TICKER": {
                 "currentOwners": 0,
-                "sparkline": [0, 0, 0, 0, 0, 0, 0], // 7-Day History
-                "momentumScore": 0.0, // Slope of the trend
-                "trend": "string" // 'RISING', 'FALLING', 'STABLE'
+                "sparkline": [0, 0, 0, 0, 0, 0, 0],
+                "momentumScore": { "type": ["number", "null"] },
+                "trend": "string"
             }
         };
     }
@@ -28,12 +28,8 @@ class TrendingOwnershipMomentum {
     async process(context) {
         const { insights: insightsHelper } = context.math;
         const { previousComputed, mappings } = context;
-        
-        // 1. Get Today's Data
         const dailyInsights = insightsHelper.getInsights(context, 'today');
-        if (!dailyInsights.length) return;
-
-        // 2. Get Yesterday's State (for rolling history)
+        if (!dailyInsights || !dailyInsights.length) return;
         const previousState = previousComputed['trending-ownership-momentum'] || {};
 
         for (const insight of dailyInsights) {
@@ -43,45 +39,37 @@ class TrendingOwnershipMomentum {
 
             const currentCount = insightsHelper.getTotalOwners(insight);
             const prevState = previousState[ticker] || { sparkline: [] };
-            
-            // 3. Update Rolling Window (Last 7 Days)
-            // Create new array copy to avoid mutation issues
             const sparkline = [...(prevState.sparkline || [])];
             sparkline.push(currentCount);
-            
-            // Keep only last 7 entries
             if (sparkline.length > 7) sparkline.shift();
 
-            // 4. Calculate Momentum Score (Linear Regression Slope)
-            let momentumScore = 0;
-            if (sparkline.length >= 2) {
+            let momentumScore = null;
+            let trend = 'WARM_UP';
+
+            if (sparkline.length >= 7) {
                 const n = sparkline.length;
                 let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
                 for (let i = 0; i < n; i++) {
-                    sumX += i;
-                    sumY += sparkline[i];
-                    sumXY += i * sparkline[i];
-                    sumXX += i * i;
+                    sumX += i; sumY += sparkline[i]; sumXY += i * sparkline[i]; sumXX += i * i;
                 }
                 const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
-                // Normalize slope by current count to get percentage-like momentum
                 momentumScore = currentCount > 0 ? (slope / currentCount) * 100 : 0;
+                
+                trend = 'STABLE';
+                if (momentumScore > 0.5) trend = 'RISING';
+                if (momentumScore < -0.5) trend = 'FALLING';
             }
 
-            let trend = 'STABLE';
-            if (momentumScore > 0.5) trend = 'RISING';
-            if (momentumScore < -0.5) trend = 'FALLING';
-
             this.results[ticker] = {
                 currentOwners: currentCount,
                 sparkline,
-                momentumScore,
+                momentumScore: (momentumScore !== null && isFinite(momentumScore)) ? momentumScore : null,
                 trend
             };
         }
     }
 
     async getResult() { return this.results; }
+    reset() { this.results = {}; }
 }
-
 module.exports = TrendingOwnershipMomentum;

package/calculations/gauss/cohort-capital-flow.js

@@ -1,12 +1,8 @@
-/**
- * @fileoverview GAUSS Product Line (Pass 3)
- * REFACTORED: Implemented getResult logic and mapping caching.
- */
 class CohortCapitalFlow {
     constructor() {
         this.cohortFlows = new Map();
         this.cohortMap = new Map();
-        this.tickerMap = null; // Cache mappings
+        this.tickerMap = null;
         this.dependenciesLoaded = false;
     }
 
@@ -14,36 +10,26 @@ class CohortCapitalFlow {
         const flowSchema = {
             "type": "object",
             "properties": {
-                "net_flow_percentage": { "type": "number" },
-                "net_flow_contribution": { "type": "number" }
+                "net_flow_percentage": { "type": ["number", "null"] },
+                "net_flow_contribution": { "type": ["number", "null"] },
+                "total_invested_today": { "type": "number" } // Baseline
             },
-            "required": ["net_flow_percentage", "net_flow_contribution"]
-        };
-        return {
-            "type": "object",
-            "patternProperties": { "^.*$": { "type": "object", "patternProperties": { "^.*$": flowSchema } } }
+            "required": ["net_flow_percentage", "net_flow_contribution", "total_invested_today"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "patternProperties": { "^.*$": flowSchema } } } };
     }
 
     static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio', 'history'],
-            isHistorical: true,
-            userType: 'all',
-            category: 'gauss'
-        };
+        return { type: 'standard', rootDataDependencies: ['portfolio', 'history'], isHistorical: true, userType: 'all', category: 'gauss' };
     }
 
-    static getDependencies() {
-        return ['cohort-definer', 'instrument-price-change-1d'];
-    }
+    static getDependencies() { return ['cohort-definer', 'instrument-price-change-1d']; }
 
     _initFlowData(cohortName, instrumentId) {
         if (!this.cohortFlows.has(cohortName)) this.cohortFlows.set(cohortName, new Map());
         if (!this.cohortFlows.get(cohortName).has(instrumentId)) {
             this.cohortFlows.get(cohortName).set(instrumentId, {
-                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0
+                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0, has_yesterday: false
             });
         }
     }
@@ -62,84 +48,61 @@ class CohortCapitalFlow {
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract } = math;
-
-        // Cache mapping for getResult phase
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
         this._loadDependencies(computed);
-        
         const cohortName = this.cohortMap.get(user.id);
         if (!cohortName) return;
         
         const priceChangeMap = computed['instrument-price-change-1d'];
-        if (!priceChangeMap) return;
-
-        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
         const tPos = extract.getPositions(user.portfolio.today, user.type);
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
 
         const yPosMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
         const tPosMap = new Map(tPos.map(p => [extract.getInstrumentId(p), p]));
         const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
 
         for (const instId of allInstrumentIds) {
-            if (!instId) continue;
-            
             this._initFlowData(cohortName, instId);
             const asset = this.cohortFlows.get(cohortName).get(instId);
-            
-            const yInvested = extract.getPositionWeight(yPosMap.get(instId), user.type);
             const tInvested = extract.getPositionWeight(tPosMap.get(instId), user.type);
-
-            if (yInvested > 0) {
-                asset.total_invested_yesterday += yInvested;
-                
-                const ticker = this.tickerMap[instId];
-                const yPriceChange_pct = (ticker && priceChangeMap[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
-                
-                asset.price_change_yesterday += (yPriceChange_pct / 100.0) * yInvested;
-            }
-            if (tInvested > 0) {
-                asset.total_invested_today += tInvested;
+            if (tInvested > 0) asset.total_invested_today += tInvested;
+
+            if (user.portfolio.yesterday) {
+                asset.has_yesterday = true;
+                const yInvested = extract.getPositionWeight(yPosMap.get(instId), user.type);
+                if (yInvested > 0) {
+                    asset.total_invested_yesterday += yInvested;
+                    const ticker = this.tickerMap[instId];
+                    const yPriceChange = (ticker && priceChangeMap?.[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
+                    asset.price_change_yesterday += ((yPriceChange || 0) / 100.0) * yInvested;
+                }
             }
         }
     }
 
     async getResult() {
         const finalResult = {};
-        
-        if (!this.tickerMap) return {}; // Should be populated by process()
-
+        if (!this.tickerMap) return {};
         for (const [cohortName, assetsMap] of this.cohortFlows.entries()) {
             finalResult[cohortName] = {};
-            
             for (const [instId, data] of assetsMap.entries()) {
                 const ticker = this.tickerMap[instId] || `id_${instId}`;
-                
-                // Logic: Flow = Today - (Yesterday * (1 + PriceChange))
-                // This isolates the capital movement from the price action.
-                const expectedToday = data.total_invested_yesterday + data.price_change_yesterday;
-                const netFlow = data.total_invested_today - expectedToday;
-                
-                // Avoid divide by zero or noise for very small numbers
-                const denominator = Math.max(1, (data.total_invested_yesterday + data.total_invested_today) / 2);
-                const netFlowPct = (netFlow / denominator) * 100;
-
+                let netFlow = null, netFlowPct = null;
+                if (data.has_yesterday) {
+                    const expectedToday = data.total_invested_yesterday + data.price_change_yesterday;
+                    netFlow = data.total_invested_today - expectedToday;
+                    const denom = Math.max(1, (data.total_invested_yesterday + data.total_invested_today) / 2);
+                    netFlowPct = (netFlow / denom) * 100;
+                }
                 finalResult[cohortName][ticker] = {
-                    net_flow_percentage: netFlowPct,
-                    net_flow_contribution: netFlow
+                    net_flow_percentage: (netFlowPct !== null && isFinite(netFlowPct)) ? netFlowPct : null,
+                    net_flow_contribution: (netFlow !== null && isFinite(netFlow)) ? netFlow : null,
+                    total_invested_today: data.total_invested_today
                 };
             }
         }
-        
         return finalResult;
     }
-
-    reset() {
-        this.cohortFlows.clear();
-        this.cohortMap.clear();
-        this.tickerMap = null;
-        this.dependenciesLoaded = false;
-    }
+    reset() { this.cohortFlows.clear(); this.cohortMap.clear(); this.tickerMap = null; this.dependenciesLoaded = false; }
 }
-
-module.exports = CohortCapitalFlow;
+module.exports = CohortCapitalFlow;