aiden-shared-calculations-unified 1.0.104 → 1.0.106

package/calculations/core/Insights-total-long-per-stock.js

@@ -28,7 +28,7 @@ class InsightsTotalPositionsHeld {
         if (insights.length === 0) return;
 
         for (const insight of insights) {
-            this.totalPositions += insightsHelper.getTotalOwners(insight);
+            this.totalPositions += insightsHelper.getLongCount(insight); // Corrected to use getLongCount
         }
     }
     

package/calculations/core/crowd-cost-basis.js

@@ -1,57 +1,65 @@
 class CrowdCostBasis {
-    constructor() {
-        this.results = {}; 
-    }
+    constructor() { this.results = {}; }
 
     static getMetadata() {
         return {
             name: 'crowd-cost-basis',
             type: 'meta',
             category: 'History Reconstruction',
-            userType: 'n/a', // <--- Works on dependency results
+            userType: 'n/a',
             isHistorical: false,
             rootDataDependencies: ['price']
         };
     }
 
-    static getDependencies() {
-        return ['user-history-reconstructor'];
+    static getDependencies() { return ['user-history-reconstructor']; }
+
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "avgEntry": { "type": "number", "description": "Global average entry price for all holders." },
+                "holderCount": { "type": "number", "description": "Total number of users holding the asset." },
+                "profitabilityPct": { "type": "number", "description": "Percentage distance between current price and avg entry." },
+                "state": { "type": "string", "description": "Profitability state: PROFIT_SUPPORT or LOSS_RESISTANCE." }
+            },
+            "required": ["avgEntry", "holderCount", "profitabilityPct", "state"]
+        };
+        // The result is a Map of Ticker -> Schema
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
     }
 
     async process(context) {
         const { computed, prices, math } = context;
-        
-        // 1. Access the output of the Standard calculation
         const userReconstructions = computed['user-history-reconstructor'];
         if (!userReconstructions) return;
 
-        const aggregator = {}; // { AAPL: { sumEntry: 0, count: 0 } }
+        const aggregator = {};
 
-        // 2. Iterate over all users' reconstructed states
+        // 1. Iterate Users
         for (const userId in userReconstructions) {
             const userPortfolio = userReconstructions[userId];
-            
+
             for (const ticker in userPortfolio) {
-                const position = userPortfolio[ticker];
-                
-                if (!aggregator[ticker]) aggregator[ticker] = { sumEntry: 0, count: 0 };
-                
-                // Aggregating global average entry
-                aggregator[ticker].sumEntry += position.avgEntry;
-                aggregator[ticker].count++;
+                const stats = userPortfolio[ticker];
+
+                if (stats.isHolder === 1) {
+                    if (!aggregator[ticker]) aggregator[ticker] = { sumEntry: 0, count: 0 };
+                    aggregator[ticker].sumEntry += stats.avgEntry;
+                    aggregator[ticker].count++;
+                }
             }
         }
 
-        // 3. Compute Global Average vs Current Price
+        // 2. Compute Global Cost Basis
         for (const ticker in aggregator) {
             const data = aggregator[ticker];
-            if (data.count < 10) continue; // Noise filter
+            if (data.count < 5) continue; 
 
             const globalAvgEntry = data.sumEntry / data.count;
-            
-            // Get today's closing price
+
+            // Get Price for Context Date
             const priceHistory = math.priceExtractor.getHistory(prices, ticker);
-            // The last item in price history for this context is "Today"
             const lastPriceObj = priceHistory[priceHistory.length - 1];
             const currentPrice = lastPriceObj ? lastPriceObj.price : globalAvgEntry;
 

package/calculations/core/leverage-divergence.js

@@ -7,42 +7,56 @@ class LeverageDivergence {
             type: 'meta',
             category: 'History Reconstruction',
             userType: 'n/a',
-            isHistorical: true, // <--- Needs yesterday's result
+            isHistorical: true, 
             rootDataDependencies: []
         };
     }
 
-    static getDependencies() {
-        return ['user-history-reconstructor'];
+    static getDependencies() { return ['user-history-reconstructor']; }
+
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "levHolders": { "type": "number", "description": "Count of holders with leverage > 1.1x." },
+                "spotHolders": { "type": "number", "description": "Count of holders with leverage <= 1.1x." },
+                "levDelta": { "type": "number", "description": "Change in leveraged holders vs yesterday." },
+                "spotDelta": { "type": "number", "description": "Change in spot holders vs yesterday." },
+                "signal": { "type": "string", "description": "Divergence signal: NEUTRAL, SMART_ACCUMULATION, SPECULATIVE_PUMP, SMART_EXIT." }
+            },
+            "required": ["levHolders", "spotHolders", "levDelta", "spotDelta", "signal"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
     }
 
     async process(context) {
         const { computed, previousComputed } = context;
-        
+
         const currentReconstruction = computed['user-history-reconstructor'];
-        // Access SELF from yesterday
-        const previousResult = previousComputed['leverage-divergence']; 
+        const previousResult = previousComputed['leverage-divergence'];
 
-        const currentAgg = {}; // { AAPL: { levHolders: 0, spotHolders: 0 } }
+        const currentAgg = {};
 
         // 1. Build Today's Aggregates
         for (const userId in currentReconstruction) {
             const userPortfolio = currentReconstruction[userId];
+
             for (const ticker in userPortfolio) {
-                const pos = userPortfolio[ticker];
-                
-                if (!currentAgg[ticker]) currentAgg[ticker] = { levHolders: 0, spotHolders: 0 };
-                
-                // If avg leverage > 1.1, count as "Leveraged Holder"
-                if (pos.avgLeverage > 1.1) {
-                    currentAgg[ticker].levHolders++;
-                } else {
-                    currentAgg[ticker].spotHolders++;
+                const stats = userPortfolio[ticker];
+
+                if (stats.isHolder === 1) {
+                    if (!currentAgg[ticker]) currentAgg[ticker] = { levHolders: 0, spotHolders: 0 };
+
+                    if (stats.avgLeverage > 1.1) {
+                        currentAgg[ticker].levHolders++;
+                    } else {
+                        currentAgg[ticker].spotHolders++;
+                    }
                 }
             }
         }
 
-        // 2. Compare with Yesterday
+        // 2. Compare with Previous Day
         for (const ticker in currentAgg) {
             const curr = currentAgg[ticker];
             const prev = previousResult ? previousResult[ticker] : null;
@@ -56,12 +70,10 @@ class LeverageDivergence {
             const spotDelta = curr.spotHolders - prev.spotHolders;
 
             let signal = 'NEUTRAL';
-            
-            // Retail (Spot) Buying + Speculators (Lev) Selling = Smart Money Exit
-            if (spotDelta > 0 && levDelta < 0) signal = 'SMART_EXIT'; 
-            
-            // Retail (Spot) Selling + Speculators (Lev) Buying = High Conviction Pump
-            if (spotDelta < 0 && levDelta > 0) signal = 'SPECULATIVE_PUMP';
+            if (spotDelta > 0 && levDelta < 0) signal = 'SMART_ACCUMULATION';
+            else if (spotDelta < 0 && levDelta > 0) signal = 'SPECULATIVE_PUMP';
+            else if (spotDelta > 0 && levDelta > 0) signal = 'BROAD_ACCUMULATION';
+            else if (spotDelta < 0 && levDelta < 0) signal = 'BROAD_EXIT';
 
             this.results[ticker] = {
                 ...curr,

package/calculations/core/liquidation-cascade.js

@@ -8,12 +8,24 @@ class LiquidationCascade {
             category: 'History Reconstruction',
             userType: 'n/a',
             isHistorical: false,
-            rootDataDependencies: [] 
+            rootDataDependencies: []
         };
     }
 
-    static getDependencies() {
-        return ['user-history-reconstructor'];
+    static getDependencies() { return ['user-history-reconstructor']; }
+
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "totalClosures": { "type": "number", "description": "Total number of positions closed today." },
+                "forcedClosures": { "type": "number", "description": "Number of positions closed via Stop Loss (Reason 1)." },
+                "painIndex": { "type": "number", "description": "Ratio of forced closures to total closures (0.0 - 1.0)." },
+                "isFlushEvent": { "type": "boolean", "description": "True if painIndex > 0.3." }
+            },
+            "required": ["totalClosures", "forcedClosures", "painIndex", "isFlushEvent"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
     }
 
     async process(context) {
@@ -21,36 +33,37 @@ class LiquidationCascade {
         const userReconstructions = computed['user-history-reconstructor'];
         if (!userReconstructions) return;
 
-        const aggregator = {}; 
+        const aggregator = {};
 
-        // 1. Aggregate Forced Exits
         for (const userId in userReconstructions) {
             const userPortfolio = userReconstructions[userId];
-            
+
             for (const ticker in userPortfolio) {
-                const position = userPortfolio[ticker];
-                
-                if (position.closedToday > 0) {
-                    if (!aggregator[ticker]) aggregator[ticker] = { closed: 0, forced: 0 };
+                const stats = userPortfolio[ticker];
+
+                if (stats.didSell > 0) {
+                    if (!aggregator[ticker]) aggregator[ticker] = { totalClosed: 0, forced: 0 };
+
+                    aggregator[ticker].totalClosed += stats.didSell;
                     
-                    aggregator[ticker].closed += position.closedToday;
-                    aggregator[ticker].forced += position.forcedExits;
+                    if (stats.closeReasons && stats.closeReasons["1"]) {
+                        aggregator[ticker].forced += stats.closeReasons["1"];
+                    }
                 }
             }
         }
 
-        // 2. Calculate Pain Index
         for (const ticker in aggregator) {
             const data = aggregator[ticker];
-            if (data.closed < 5) continue;
+            if (data.totalClosed < 5) continue;
 
-            const forcedRatio = data.forced / data.closed;
+            const forcedRatio = data.forced / data.totalClosed;
 
             this.results[ticker] = {
-                totalClosures: data.closed,
+                totalClosures: data.totalClosed,
                 forcedClosures: data.forced,
-                painIndex: forcedRatio, // 0.0 to 1.0
-                isFlushEvent: forcedRatio > 0.3 // Flag if >30% of selling was forced
+                painIndex: forcedRatio,
+                isFlushEvent: forcedRatio > 0.3
             };
         }
     }

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

@@ -14,17 +14,52 @@ class OwnershipVsPerformanceYTD {
 
     static getDependencies() { return []; }
 
+    static getSchema() {
+        const metricSchema = {
+            "type": "object",
+            "properties": {
+                "priceYtd": { "type": "number" },
+                "ownersYtd": { "type": "number" },
+                "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
+            },
+            "additionalProperties": metricSchema
+        };
+    }
+
     async process(context) {
         const { insights: insightsHelper, priceExtractor } = context.math;
         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 isStartOfYear = date.today.endsWith('-01-01') || date.today.endsWith('-01-02');
-        
+
         if (isStartOfYear) {
             baselineState = {}; // Reset for new year
         }
@@ -37,11 +72,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
@@ -56,12 +91,12 @@ class OwnershipVsPerformanceYTD {
             const base = baselineState[ticker];
 
             // 3. Calculate Deltas
-            const priceYtd = base.startPrice > 0 
-                ? ((currentPrice - base.startPrice) / base.startPrice) * 100 
+            const priceYtd = base.startPrice > 0
+                ? ((currentPrice - base.startPrice) / base.startPrice) * 100
                 : 0;
-            
-            const ownersYtd = base.startOwners > 0 
-                ? ((currentOwners - base.startOwners) / base.startOwners) * 100 
+
+            const ownersYtd = base.startOwners > 0
+                ? ((currentOwners - base.startOwners) / base.startOwners) * 100
                 : 0;
 
             currentMetrics[ticker] = {
@@ -75,15 +110,15 @@ class OwnershipVsPerformanceYTD {
         // 4. Output structure includes the baselines so they are saved for tomorrow
         this.results = {
             metrics: currentMetrics,
-            baselines: baselineState 
+            baselines: baselineState
         };
     }
 
-    async getResult() { 
+    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 }; 
+        return { ...this.results.metrics, baselines: this.results.baselines };
     }
 }
 

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

@@ -14,12 +14,29 @@ class OwnershipVsVolatility {
 
     static getDependencies() { return []; }
 
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "volatilityScore": { "type": "number" },
+                "ownerChange7d": { "type": "number" },
+                "laggedOwners": { "type": "number" },
+                "_history": {
+                    "type": "array",
+                    "items": { "type": "number" }
+                }
+            },
+            "required": ["volatilityScore", "ownerChange7d", "laggedOwners"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
+    }
+
     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'] || {};
 
@@ -35,17 +52,17 @@ class OwnershipVsVolatility {
             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);
+                returns.push((recentPrices[i].price - recentPrices[i - 1].price) / recentPrices[i - 1].price);
             }
-            
+
             const volatility = compute.standardDeviation(returns); // Raw std dev
 
             // 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 
+
+            const ownerChangePct = prevOwners > 0
+                ? ((currentOwners - prevOwners) / prevOwners) * 100
                 : 0;
 
             this.results[ticker] = {
@@ -56,7 +73,7 @@ class OwnershipVsVolatility {
                 // 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)
             };

package/calculations/core/user-history-reconstructor.js

@@ -1,18 +1,14 @@
-/**
- * @fileoverview Reconstructs a user's portfolio state for a specific date from their trade history.
- * Acts as the "Map" phase for downstream Meta aggregations.
- */
 class UserHistoryReconstructor {
     constructor() {
-        this.results = {}; // Output: { "user_id": { "AAPL": { ...stats... } } }
+        this.results = {}; 
     }
 
     static getMetadata() {
         return {
             name: 'user-history-reconstructor',
             type: 'standard', 
-            category: 'History Reconstruction', // <--- Specific Category
-            userType: 'all',                    // <--- Processes User Data
+            category: 'History Reconstruction',
+            userType: 'all',
             isHistorical: false,
             rootDataDependencies: ['history']
         };
@@ -21,15 +17,29 @@ class UserHistoryReconstructor {
     static getDependencies() { return []; }
 
     static getSchema() {
-        return {
-            "USER_ID": {
-                "TICKER": {
-                    "activeCount": 1,
-                    "avgEntry": 0.0,
-                    "avgLeverage": 1.0,
-                    "closedToday": 0,
-                    "forcedExits": 0
+        // Schema for a single Ticker's stats
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "isHolder": { "type": "number", "description": "1 if the user holds the asset at EOD, 0 otherwise." },
+                "didBuy": { "type": "number", "description": "Count of buy trades executed today." },
+                "didSell": { "type": "number", "description": "Count of sell trades executed today." },
+                "avgEntry": { "type": "number", "description": "Average entry price of held positions." },
+                "avgLeverage": { "type": "number", "description": "Average leverage of held positions." },
+                "buyLeverage": { "type": "number", "description": "Average leverage of new buys executed today." },
+                "closeReasons": { 
+                    "type": "object", 
+                    "description": "Map of close reason codes to counts (0=Manual, 1=Stop/Liq, 5=TP)." 
                 }
+            },
+            "required": ["isHolder", "didBuy", "didSell", "avgEntry", "avgLeverage"]
+        };
+
+        // The result for a user is a Map of Ticker -> TickerSchema
+        return {
+            "type": "object",
+            "patternProperties": {
+                "^.*$": tickerSchema
             }
         };
     }
@@ -37,72 +47,107 @@ class UserHistoryReconstructor {
     async process(context) {
         const { user, math, mappings, date } = context;
         
-        // 1. Get History
+        // 1. Get History (V2 Format Only)
         const history = math.history.getDailyHistory(user);
         const allTrades = history?.PublicHistoryPositions || [];
         
         if (allTrades.length === 0) return;
 
-        // 2. Filter for Active Trades on this Date
-        const activeTrades = math.history.getActiveTradesForDate(allTrades, date.today);
-        if (activeTrades.length === 0) return;
+        // 2. Define Time Boundaries for "Yesterday" (Target Date)
+        const dayStart = new Date(date.today + "T00:00:00.000Z").getTime();
+        const dayEnd   = new Date(date.today + "T23:59:59.999Z").getTime();
 
-        // 3. Initialize User State
         this.results[user.id] = {};
         const userState = this.results[user.id];
 
-        const dayStart = new Date(date.today + "T00:00:00.000Z").getTime();
-        const dayEnd   = new Date(date.today + "T23:59:59.999Z").getTime();
-
-        for (const trade of activeTrades) {
+        for (const trade of allTrades) {
             const instId = trade.InstrumentID;
             const ticker = mappings.instrumentToTicker[instId];
             if (!ticker) continue;
 
+            // Parse Dates
+            const openTime = new Date(trade.OpenDateTime).getTime();
+            const closeTime = trade.CloseDateTime ? new Date(trade.CloseDateTime).getTime() : null;
+
+            // 3. Determine States
+            const isOpenBeforeEOD = openTime <= dayEnd;
+            // Active if it wasn't closed before the day started
+            const isClosedAfterSOD = closeTime === null || closeTime >= dayStart;
+            
+            const wasActiveToday = isOpenBeforeEOD && isClosedAfterSOD;
+
+            // "Held" means active at End of Day
+            const isHeldAtEOD = isOpenBeforeEOD && (closeTime === null || closeTime > dayEnd);
+
+            // "Opened" means OpenTime is inside today
+            const isOpenedToday = openTime >= dayStart && openTime <= dayEnd;
+
+            // "Closed" means CloseTime is inside today
+            const isClosedToday = closeTime !== null && closeTime >= dayStart && closeTime <= dayEnd;
+
+            if (!wasActiveToday) continue;
+
             if (!userState[ticker]) {
-                userState[ticker] = { 
-                    activeCount: 0, 
-                    totalEntry: 0, 
-                    totalLev: 0,
-                    closedToday: 0,
-                    forcedExits: 0
+                userState[ticker] = {
+                    isHolder: 0,
+                    didBuy: 0,
+                    didSell: 0,
+                    sumEntry: 0,
+                    sumLev: 0,
+                    holdCount: 0,
+                    sumBuyLev: 0,
+                    closeReasons: { "0": 0, "1": 0, "5": 0 }
                 };
             }
-
             const stats = userState[ticker];
-            
-            // Accumulate Holding State
-            stats.activeCount++;
-            stats.totalEntry += (trade.OpenRate || 0);
-            stats.totalLev += (trade.Leverage || 1);
-
-            // Check for Closure Events happening TODAY
-            if (trade.CloseDateTime) {
-                const closeTime = new Date(trade.CloseDateTime).getTime();
-                if (closeTime >= dayStart && closeTime <= dayEnd) {
-                    stats.closedToday++;
-                    // CloseReason: 1 = Stop Loss, 5 = Take Profit, 0 = Manual
-                    if (trade.CloseReason === 1) stats.forcedExits++; 
-                }
+
+            // 4. Populate Metrics
+            if (isHeldAtEOD) {
+                stats.isHolder = 1;
+                stats.holdCount++;
+                stats.sumEntry += (trade.OpenRate || 0);
+                stats.sumLev += (trade.Leverage || 1);
+            }
+
+            if (isOpenedToday) {
+                stats.didBuy++;
+                stats.sumBuyLev += (trade.Leverage || 1);
+            }
+
+            if (isClosedToday) {
+                stats.didSell++;
+                const reason = String(trade.CloseReason || 0);
+                if (stats.closeReasons[reason] === undefined) stats.closeReasons[reason] = 0;
+                stats.closeReasons[reason]++;
             }
         }
 
-        // 4. Finalize Averages for this User
+        // 5. Cleanup / Average
         for (const ticker in userState) {
             const stats = userState[ticker];
-            if (stats.activeCount > 0) {
-                stats.avgEntry = stats.totalEntry / stats.activeCount;
-                stats.avgLeverage = stats.totalLev / stats.activeCount;
+            
+            if (stats.holdCount > 0) {
+                stats.avgEntry = stats.sumEntry / stats.holdCount;
+                stats.avgLeverage = stats.sumLev / stats.holdCount;
+            } else {
+                stats.avgEntry = 0;
+                stats.avgLeverage = 0;
             }
-            // Cleanup intermediate sums
-            delete stats.totalEntry;
-            delete stats.totalLev;
+
+            if (stats.didBuy > 0) {
+                stats.buyLeverage = stats.sumBuyLev / stats.didBuy;
+            } else {
+                stats.buyLeverage = 0;
+            }
+
+            delete stats.sumEntry;
+            delete stats.sumLev;
+            delete stats.sumBuyLev;
+            delete stats.holdCount;
         }
     }
 
-    async getResult() {
-        return this.results;
-    }
+    async getResult() { return this.results; }
 }
 
 module.exports = UserHistoryReconstructor;

package/package.json

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