aiden-shared-calculations-unified 1.0.109 → 1.0.110

package/calculations/core/insights-daily-bought-vs-sold-count.js

@@ -17,37 +17,42 @@ class InsightsDailyBoughtVsSoldCount {
         const tickerSchema = { 
             "type": "object", 
             "properties": { 
-                "positions_bought": { "type": "number" }, 
-                "positions_sold": { "type": "number" }, 
-                "net_change": { "type": "number" } 
+                "positions_bought": { "type": ["number", "null"] }, 
+                "positions_sold": { "type": ["number", "null"] }, 
+                "net_change": { "type": ["number", "null"] },
+                "total_positions": { "type": "number" } // Baseline
             }, 
-            "required": ["positions_bought", "positions_sold", "net_change"] 
+            "required": ["positions_bought", "positions_sold", "net_change", "total_positions"] 
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
     
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
+        const insights = insightsHelper.getInsights(context);
         const { mappings } = context;
         const tickerMap = mappings.instrumentToTicker || {};
 
-        if (insights.length === 0) return;
+        if (!insights || insights.length === 0) return;
 
         for (const insight of insights) {
             const instId = insight.instrumentId;
             const ticker = tickerMap[instId] || `id_${instId}`;
+            const total = insightsHelper.getTotalOwners(insight);
+            
+            // netChange requires yesterday's data to be accurate
             const netChange = insightsHelper.getNetOwnershipChange(insight);
-            const bought = netChange > 0 ? netChange : 0;
-            const sold   = netChange < 0 ? Math.abs(netChange) : 0;
+            
+            // If netChange is null (missing history), we still save total_positions
+            const bought = (netChange !== null && netChange > 0) ? netChange : 0;
+            const sold   = (netChange !== null && netChange < 0) ? Math.abs(netChange) : 0;
 
-            if (bought > 0 || sold > 0) {
-                this.results[ticker] = { 
-                    positions_bought: bought, 
-                    positions_sold: sold, 
-                    net_change: netChange 
-                };
-            }
+            this.results[ticker] = { 
+                positions_bought: bought, 
+                positions_sold: sold, 
+                net_change: netChange,
+                total_positions: total
+            };
         }
     }
     

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

@@ -17,36 +17,38 @@ class InsightsDailyOwnershipDelta {
         const tickerSchema = { 
             "type": "object", 
             "properties": { 
-                "owners_added": { "type": "number" }, 
-                "owners_removed": { "type": "number" }, 
-                "net_ownership_change": { "type": "number" } 
+                "owners_added": { "type": ["number", "null"] }, 
+                "owners_removed": { "type": ["number", "null"] }, 
+                "net_ownership_change": { "type": ["number", "null"] },
+                "total_owners": { "type": "number" } // Baseline
             }, 
-            "required": ["owners_added", "owners_removed", "net_ownership_change"] 
+            "required": ["owners_added", "owners_removed", "net_ownership_change", "total_owners"] 
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
     
     process(context) {
         const { insights: insightsHelper } = context.math;
-        const insights = insightsHelper.getInsights(context); // FIXED: Direct call
+        const insights = insightsHelper.getInsights(context);
         const { mappings } = context;
         const tickerMap = mappings.instrumentToTicker || {};
 
-        if (insights.length === 0) return;
+        if (!insights || insights.length === 0) return;
 
         for (const insight of insights) {
+            const total = insightsHelper.getTotalOwners(insight);
             const netChange = insightsHelper.getNetOwnershipChange(insight);
-            if (netChange === 0) continue;
             
             const instId = insight.instrumentId;
             const ticker = tickerMap[instId] || `id_${instId}`;
-            const added = netChange > 0 ? netChange : 0;
-            const removed = netChange < 0 ? Math.abs(netChange) : 0;
+            const added = (netChange !== null && netChange > 0) ? netChange : 0;
+            const removed = (netChange !== null && netChange < 0) ? Math.abs(netChange) : 0;
 
             this.results[ticker] = { 
                 owners_added: added, 
                 owners_removed: removed, 
-                net_ownership_change: netChange 
+                net_ownership_change: netChange,
+                total_owners: total
             };
         }
     }

package/calculations/core/instrument-price-change-1d.js

@@ -1,11 +1,5 @@
-/**
- * @fileoverview Calculation (Pass 1 - Meta) for 1-day price change.
- * FIXED: Supports Sharded/Batched Execution (Accumulates results).
- */
 class InstrumentPriceChange1D {
-    constructor() {
-        this.result = {};
-    }
+    constructor() { this.result = {}; }
 
     static getMetadata() {
         return {
@@ -23,9 +17,10 @@ class InstrumentPriceChange1D {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "change_1d_pct": { "type": "number" }
+                "change_1d_pct": { "type": ["number", "null"] },
+                "closing_price": { "type": "number" } // Baseline
             },
-            "required": ["change_1d_pct"]
+            "required": ["change_1d_pct", "closing_price"]
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
@@ -35,48 +30,38 @@ class InstrumentPriceChange1D {
         const { instrumentToTicker } = mappings;
         const { priceExtractor } = math;
         
-        if (!prices || !prices.history) {
-            // Do NOT reset result here, just return if this shard is empty
-            return;
-        }
+        if (!prices || !prices.history) return;
 
         const todayStr = date.today;
-        const todayDate = new Date(todayStr + 'T00:00:00Z');
-        const yesterdayDate = new Date(todayDate);
-        yesterdayDate.setUTCDate(yesterdayDate.getUTCDate() - 1);
-        const yesterdayStr = yesterdayDate.toISOString().slice(0, 10);
+        const prevDate = new Date(todayStr + 'T00:00:00Z');
+        prevDate.setUTCDate(prevDate.getUTCDate() - 1);
+        const yesterdayStr = prevDate.toISOString().slice(0, 10);
 
         const batchResults = {};
 
-        // Iterate over THIS SHARD'S instruments
         for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
 
-            // Note: getHistory works on the partial 'prices' object just fine
-            const history = priceExtractor.getHistory(prices, instrumentId);
-            if (history.length === 0) continue;
-
             const todayPrice = priceData.prices?.[todayStr];
             const yesterdayPrice = priceData.prices?.[yesterdayStr];
 
-            if (todayPrice && yesterdayPrice && yesterdayPrice > 0) {
-                const changePct = ((todayPrice - yesterdayPrice) / yesterdayPrice) * 100;
+            if (todayPrice) {
+                let changePct = null;
+                if (yesterdayPrice && yesterdayPrice > 0) {
+                    changePct = ((todayPrice - yesterdayPrice) / yesterdayPrice) * 100;
+                }
+
                 batchResults[ticker] = {
-                    change_1d_pct: isFinite(changePct) ? changePct : 0
+                    change_1d_pct: (changePct !== null && isFinite(changePct)) ? changePct : null,
+                    closing_price: todayPrice
                 };
-            } else {
-                batchResults[ticker] = { change_1d_pct: 0 };
             }
         }
-        
-        // Merge batch results into main result
         Object.assign(this.result, batchResults);
     }
 
     async getResult() { return this.result; }
-    
-    // Explicit reset only called by system between full runs
     reset() { this.result = {}; }
 }
 module.exports = InstrumentPriceChange1D;

package/calculations/core/instrument-price-momentum-20d.js

@@ -1,11 +1,5 @@
-/**
- * @fileoverview Calculation (Pass 1 - Meta) for 20-day momentum.
- * FIXED: Supports Sharded/Batched Execution (Accumulates results).
- */
 class InstrumentPriceMomentum20D {
-    constructor() {
-        this.result = {};
-    }
+    constructor() { this.result = {}; }
 
     static getMetadata() {
         return {
@@ -23,9 +17,10 @@ class InstrumentPriceMomentum20D {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "momentum_20d_pct": { "type": "number" }
+                "momentum_20d_pct": { "type": ["number", "null"] },
+                "current_price": { "type": "number" }
             },
-            "required": ["momentum_20d_pct"]
+            "required": ["momentum_20d_pct", "current_price"]
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
@@ -33,7 +28,6 @@ class InstrumentPriceMomentum20D {
     _findPriceOnOrBefore(prices, instrumentId, targetDateStr) {
         const priceData = prices.history[instrumentId];
         if (!priceData || !priceData.prices) return null;
-        
         let checkDate = new Date(targetDateStr + 'T00:00:00Z');
         for (let i = 0; i < 5; i++) { 
             const str = checkDate.toISOString().slice(0, 10);
@@ -47,20 +41,15 @@ class InstrumentPriceMomentum20D {
     process(context) {
         const { mappings, prices, date } = context;
         const { instrumentToTicker } = mappings;
-        
-        if (!prices || !prices.history) {
-            return;
-        }
+        if (!prices || !prices.history) return;
         
         const todayStr = date.today;
-        const todayDate = new Date(todayStr + 'T00:00:00Z');
-        const twentyDaysAgo = new Date(todayDate);
-        twentyDaysAgo.setUTCDate(todayDate.getUTCDate() - 20);
-        const oldStr = twentyDaysAgo.toISOString().slice(0, 10);
+        const oldDate = new Date(todayStr + 'T00:00:00Z');
+        oldDate.setUTCDate(oldDate.getUTCDate() - 20);
+        const oldStr = oldDate.toISOString().slice(0, 10);
 
         const batchResults = {};
 
-        // Iterate over THIS SHARD'S instruments
         for (const [instrumentId, priceData] of Object.entries(prices.history)) {
             const ticker = instrumentToTicker[instrumentId];
             if (!ticker) continue;
@@ -68,17 +57,18 @@ class InstrumentPriceMomentum20D {
             const currentPrice = this._findPriceOnOrBefore(prices, instrumentId, todayStr);
             const oldPrice = this._findPriceOnOrBefore(prices, instrumentId, oldStr);
 
-            if (currentPrice && oldPrice && oldPrice > 0) {
-                const momPct = ((currentPrice - oldPrice) / oldPrice) * 100;
+            if (currentPrice) {
+                let momPct = null;
+                if (oldPrice && oldPrice > 0) {
+                    momPct = ((currentPrice - oldPrice) / oldPrice) * 100;
+                }
+
                 batchResults[ticker] = {
-                    momentum_20d_pct: isFinite(momPct) ? momPct : 0
+                    momentum_20d_pct: (momPct !== null && isFinite(momPct)) ? momPct : null,
+                    current_price: currentPrice
                 };
-            } else {
-                batchResults[ticker] = { momentum_20d_pct: 0 };
             }
         }
-        
-        // Merge
         Object.assign(this.result, batchResults);
     }
 

package/calculations/core/ownership-vs-performance-ytd.js

@@ -1,5 +1,5 @@
 class OwnershipVsPerformanceYTD {
-    constructor() { this.results = {}; }
+    constructor() { this.results = { metrics: {}, baselines: {} }; }
 
     static getMetadata() {
         return {
@@ -7,7 +7,7 @@ class OwnershipVsPerformanceYTD {
             type: 'meta',
             category: 'core',
             userType: 'n/a',
-            isHistorical: true, // Required to carry forward Jan 1st baseline
+            isHistorical: true,
             rootDataDependencies: ['insights', 'price']
         };
     }
@@ -18,33 +18,17 @@ class OwnershipVsPerformanceYTD {
         const metricSchema = {
             "type": "object",
             "properties": {
-                "priceYtd": { "type": "number" },
-                "ownersYtd": { "type": "number" },
+                "priceYtd": { "type": ["number", "null"] },
+                "ownersYtd": { "type": ["number", "null"] },
                 "currentPrice": { "type": "number" },
                 "currentOwners": { "type": "number" }
             },
             "required": ["priceYtd", "ownersYtd", "currentPrice", "currentOwners"]
         };
 
-        const baselineSchema = {
-            "type": "object",
-            "patternProperties": {
-                "^.*$": {
-                    "type": "object",
-                    "properties": {
-                        "startPrice": { "type": "number" },
-                        "startOwners": { "type": "number" },
-                        "date": { "type": "string" }
-                    }
-                }
-            }
-        };
-
         return {
             "type": "object",
-            "properties": {
-                "baselines": baselineSchema
-            },
+            "properties": { "baselines": { "type": "object" } },
             "additionalProperties": metricSchema
         };
     }
@@ -54,15 +38,11 @@ class OwnershipVsPerformanceYTD {
         const { previousComputed, mappings, prices, date } = context;
 
         const dailyInsights = insightsHelper.getInsights(context, 'today');
-
-        // 1. Manage Baseline State (Jan 1st snapshot)
-        // If today is Jan 1st (or first run), we reset. Otherwise, we load from yesterday.
-        let baselineState = previousComputed['ownership-vs-performance-ytd']?.baselines || {};
+        const prevRes = previousComputed['ownership-vs-performance-ytd'];
+        let baselineState = prevRes?.baselines || {};
+        
         const isStartOfYear = date.today.endsWith('-01-01') || date.today.endsWith('-01-02');
-
-        if (isStartOfYear) {
-            baselineState = {}; // Reset for new year
-        }
+        if (isStartOfYear) baselineState = {}; 
 
         const currentMetrics = {};
 
@@ -72,14 +52,11 @@ class OwnershipVsPerformanceYTD {
             if (!ticker) continue;
 
             const currentOwners = insightsHelper.getTotalOwners(insight);
-
-            // Get Price History
             const priceHist = priceExtractor.getHistory(prices, ticker);
             if (!priceHist.length) continue;
 
             const currentPrice = priceHist[priceHist.length - 1].price;
 
-            // 2. Set Baseline if missing
             if (!baselineState[ticker]) {
                 baselineState[ticker] = {
                     startPrice: currentPrice,
@@ -89,37 +66,23 @@ class OwnershipVsPerformanceYTD {
             }
 
             const base = baselineState[ticker];
-
-            // 3. Calculate Deltas
-            const priceYtd = base.startPrice > 0
-                ? ((currentPrice - base.startPrice) / base.startPrice) * 100
-                : 0;
-
-            const ownersYtd = base.startOwners > 0
-                ? ((currentOwners - base.startOwners) / base.startOwners) * 100
-                : 0;
+            const priceYtd = base.startPrice > 0 ? ((currentPrice - base.startPrice) / base.startPrice) * 100 : 0;
+            const ownersYtd = base.startOwners > 0 ? ((currentOwners - base.startOwners) / base.startOwners) * 100 : 0;
 
             currentMetrics[ticker] = {
-                priceYtd,
-                ownersYtd,
+                priceYtd: isFinite(priceYtd) ? priceYtd : null,
+                ownersYtd: isFinite(ownersYtd) ? ownersYtd : null,
                 currentPrice,
                 currentOwners
             };
         }
 
-        // 4. Output structure includes the baselines so they are saved for tomorrow
-        this.results = {
-            metrics: currentMetrics,
-            baselines: baselineState
-        };
+        this.results = { metrics: currentMetrics, baselines: baselineState };
     }
 
     async getResult() {
-        // We flatten the 'metrics' for easy API consumption, 
-        // but we must ensure 'baselines' is preserved in the stored document 
-        // so 'previousComputed' picks it up tomorrow.
         return { ...this.results.metrics, baselines: this.results.baselines };
     }
+    reset() { this.results = { metrics: {}, baselines: {} }; }
 }
-
 module.exports = OwnershipVsPerformanceYTD;

package/calculations/core/ownership-vs-volatility.js

@@ -7,7 +7,7 @@ class OwnershipVsVolatility {
             type: 'meta',
             category: 'core',
             userType: 'n/a',
-            isHistorical: true, // To calculate ownership change over window
+            isHistorical: true,
             rootDataDependencies: ['insights', 'price']
         };
     }
@@ -18,13 +18,10 @@ class OwnershipVsVolatility {
         const schema = {
             "type": "object",
             "properties": {
-                "volatilityScore": { "type": "number" },
-                "ownerChange7d": { "type": "number" },
+                "volatilityScore": { "type": ["number", "null"] },
+                "ownerChange7d": { "type": ["number", "null"] },
                 "laggedOwners": { "type": "number" },
-                "_history": {
-                    "type": "array",
-                    "items": { "type": "number" }
-                }
+                "_history": { "type": "array", "items": { "type": "number" } }
             },
             "required": ["volatilityScore", "ownerChange7d", "laggedOwners"]
         };
@@ -34,10 +31,7 @@ class OwnershipVsVolatility {
     async process(context) {
         const { insights: insightsHelper, priceExtractor, compute } = context.math;
         const { previousComputed, mappings, prices } = context;
-
         const dailyInsights = insightsHelper.getInsights(context, 'today');
-
-        // Use 7-day lookback for ownership change
         const prevState = previousComputed['ownership-vs-volatility'] || {};
 
         for (const insight of dailyInsights) {
@@ -45,42 +39,39 @@ class OwnershipVsVolatility {
             const ticker = mappings.instrumentToTicker[instId];
             if (!ticker) continue;
 
-            // 1. Calculate Recent Volatility (14 Day StdDev of Returns)
+            const currentOwners = insightsHelper.getTotalOwners(insight);
             const priceHist = priceExtractor.getHistory(prices, ticker);
-            if (priceHist.length < 14) continue;
-
-            const recentPrices = priceHist.slice(-14);
-            const returns = [];
-            for (let i = 1; i < recentPrices.length; i++) {
-                returns.push((recentPrices[i].price - recentPrices[i - 1].price) / recentPrices[i - 1].price);
+            
+            let volatility = null;
+            if (priceHist.length >= 14) {
+                const recentPrices = priceHist.slice(-14);
+                const returns = [];
+                for (let i = 1; i < recentPrices.length; i++) {
+                    returns.push((recentPrices[i].price - recentPrices[i - 1].price) / recentPrices[i - 1].price);
+                }
+                volatility = compute.standardDeviation(returns);
             }
 
-            const volatility = compute.standardDeviation(returns); // Raw std dev
+            const history = [...(prevState[ticker]?._history || [])];
+            history.push(currentOwners);
+            if (history.length > 7) history.shift();
 
-            // 2. Calculate Ownership Change (Current vs 7 days ago stored state)
-            const currentOwners = insightsHelper.getTotalOwners(insight);
-            const prevOwners = prevState[ticker]?.laggedOwners || currentOwners;
-
-            const ownerChangePct = prevOwners > 0
-                ? ((currentOwners - prevOwners) / prevOwners) * 100
-                : 0;
+            const laggedOwners = history[0];
+            let ownerChangePct = null;
+            if (laggedOwners > 0 && history.length >= 7) {
+                ownerChangePct = ((currentOwners - laggedOwners) / laggedOwners) * 100;
+            }
 
             this.results[ticker] = {
-                volatilityScore: volatility,
-                ownerChange7d: ownerChangePct,
-                // Store current owners as 'laggedOwners' for next week? 
-                // Actually, for daily rolling 7d change, we need a queue. 
-                // Simplified: We store today's value, and the API/UI compares.
-                // Better: Use a simple rolling queue like the Momentum calc.
-                _history: [...(prevState[ticker]?._history || []), currentOwners].slice(-7),
-
-                // For the output: Calculate change vs the oldest in history (approx 7d ago)
-                laggedOwners: (prevState[ticker]?._history?.[0] || currentOwners)
+                volatilityScore: (volatility !== null && isFinite(volatility)) ? volatility : null,
+                ownerChange7d: (ownerChangePct !== null && isFinite(ownerChangePct)) ? ownerChangePct : null,
+                _history: history,
+                laggedOwners: laggedOwners
             };
         }
     }
 
     async getResult() { return this.results; }
+    reset() { this.results = {}; }
 }
-
 module.exports = OwnershipVsVolatility;

package/calculations/core/platform-daily-bought-vs-sold-count.js

@@ -1,7 +1,3 @@
-/**
- * @fileoverview Calculation (Pass 1) for daily bought vs. sold count.
- * REFACTORED: Uses context.math.extract on today vs yesterday.
- */
 class DailyBoughtVsSoldCount {
     constructor() {
         this.assetActivity = new Map();
@@ -26,16 +22,17 @@ class DailyBoughtVsSoldCount {
             "properties": {
                 "positions_bought": { "type": "number" },
                 "positions_sold": { "type": "number" },
-                "net_change": { "type": "number" }
+                "net_change": { "type": "number" },
+                "aggregate_portfolio_size": { "type": "number" } // Baseline
             },
-            "required": ["positions_bought", "positions_sold", "net_change"]
+            "required": ["positions_bought", "positions_sold", "net_change", "aggregate_portfolio_size"]
         };
         return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
     _initAsset(instrumentId) {
         if (!this.assetActivity.has(instrumentId)) {
-            this.assetActivity.set(instrumentId, { new: 0, closed: 0 });
+            this.assetActivity.set(instrumentId, { new: 0, closed: 0, currentSize: 0 });
         }
     }
 
@@ -55,24 +52,30 @@ class DailyBoughtVsSoldCount {
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
         const todayPositions = extract.getPositions(user.portfolio.today, user.type);
-        const yesterdayPositions = extract.getPositions(user.portfolio.yesterday, user.type);
+        const yesterdayPositions = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
 
         const tPosMap = this._getInstrumentIds(todayPositions, extract);
         const yPosMap = this._getInstrumentIds(yesterdayPositions, extract);
 
-        // New positions (in today, not yesterday)
-        for (const [posId, instId] of tPosMap.entries()) {
-            if (!yPosMap.has(posId)) {
-                this._initAsset(instId);
-                this.assetActivity.get(instId).new++;
-            }
+        // Track current sizes for Baseline
+        for (const instId of tPosMap.values()) {
+            this._initAsset(instId);
+            this.assetActivity.get(instId).currentSize++;
         }
 
-        // Closed positions (in yesterday, not today)
-        for (const [posId, instId] of yPosMap.entries()) {
-            if (!tPosMap.has(posId)) {
-                this._initAsset(instId);
-                this.assetActivity.get(instId).closed++;
+        // Only calculate bought/sold if yesterday exists
+        if (user.portfolio.yesterday) {
+            for (const [posId, instId] of tPosMap.entries()) {
+                if (!yPosMap.has(posId)) {
+                    this._initAsset(instId);
+                    this.assetActivity.get(instId).new++;
+                }
+            }
+            for (const [posId, instId] of yPosMap.entries()) {
+                if (!tPosMap.has(posId)) {
+                    this._initAsset(instId);
+                    this.assetActivity.get(instId).closed++;
+                }
             }
         }
     }
@@ -82,13 +85,12 @@ class DailyBoughtVsSoldCount {
         const result = {};
         for (const [instId, data] of this.assetActivity.entries()) {
             const ticker = this.tickerMap[instId] || `id_${instId}`;
-            if (data.new > 0 || data.closed > 0) {
-                result[ticker] = {
-                    positions_bought: data.new,
-                    positions_sold: data.closed,
-                    net_change: data.new - data.closed
-                };
-            }
+            result[ticker] = {
+                positions_bought: data.new,
+                positions_sold: data.closed,
+                net_change: data.new - data.closed,
+                aggregate_portfolio_size: data.currentSize
+            };
         }
         return result;
     }