aiden-shared-calculations-unified 1.0.100 → 1.0.102

package/calculations/core/asset-cost-basis-profile.js

@@ -1,21 +1,24 @@
 /**
  * @fileoverview Core Calculation (Pass 2)
  * Generates the "Ghost Book" - KDE of Holder Cost Basis.
- * ARCHITECTURE COMPLIANT: Uses Context for Math & Prices.
+ * REFACTORED: Uses Trade History to reconstruct Open Interest (ghost positions).
+ * Solves sparse speculator data by using historical entry points.
  */
 class AssetCostBasisProfile {
     constructor() {
-        // Map<Ticker, Map<PriceKey, Weight>>
+        // Map<Ticker, { bins: Map<Price, Weight>, currentPrice: Number }>
         this.assetBins = new Map(); 
         this.tickerMap = null;
-        // FIX 1: Change state name to clearly indicate storage of the function pointer
+        // Store function pointer to avoid serialization issues
         this.computeKDE_func = null; 
+        this.updateforce = null;
     }
 
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'], 
+            // Changed from 'portfolio' to 'history' and 'price' (needed for current valuation)
+            rootDataDependencies: ['history', 'price'], 
             dependencies: [], 
             isHistorical: false,
             userType: 'all', 
@@ -41,36 +44,78 @@ class AssetCostBasisProfile {
     }
 
     process(context) {
-        const { user, mappings, math } = context; 
+        const { user, mappings, math, date, prices } = context; 
         
-        // FIX 2 (CRITICAL): Store the *function pointer* itself from math.distribution.computeKDE.
-        // This is necessary because storing the class object (math.distribution) breaks the static method reference when serialized/deserialized by worker threads.
         if (!this.computeKDE_func) {
             this.computeKDE_func = math.distribution.computeKDE;
         }
         
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const { extract } = math; 
+        const { priceExtractor, history } = math; 
 
-        const positions = extract.getPositions(user.portfolio.today, user.type);
+        // 1. Get History
+        const historyDoc = history.getDailyHistory(user);
+        if (!historyDoc || !Array.isArray(historyDoc.PublicHistoryPositions)) return;
+
+        const trades = historyDoc.PublicHistoryPositions;
+        const targetDate = new Date(date.today); // The date we are calculating FOR
+
+        for (const trade of trades) {
+            // 2. Validate Trade Data
+            const instId = trade.InstrumentID;
+            if (!instId) continue;
 
-        for (const pos of positions) {
-            const instId = extract.getInstrumentId(pos);
             const ticker = this.tickerMap[instId];
-            
             if (!ticker) continue;
 
-            const currentPrice = extract.getCurrentRate(pos); 
-            if (currentPrice <= 0) continue;
+            // 3. Time Travel Logic: Was this trade OPEN on the target date?
+            // Open Date must be BEFORE target
+            const openDate = new Date(trade.OpenDateTime);
+            if (isNaN(openDate) || openDate > targetDate) continue;
+
+            // Close Date must be AFTER target (or null/zero if still open in some schemas)
+            // Note: If CloseDateTime is missing, we assume it's still open or data is partial.
+            // We check if it's explicitly closed BEFORE target.
+            let isClosedBeforeTarget = false;
+            if (trade.CloseDateTime) {
+                const closeDate = new Date(trade.CloseDateTime);
+                if (!isNaN(closeDate) && closeDate < targetDate) {
+                    isClosedBeforeTarget = true;
+                }
+            }
+
+            if (isClosedBeforeTarget) continue; // Trade was already closed, not part of "Cost Basis" for this day.
 
-            const netProfitPct = extract.getNetProfit(pos); 
-            const weight = extract.getPositionWeight(pos, user.type); 
+            // 4. Get Cost Basis (Entry Price)
+            const entryPrice = trade.OpenRate;
+            if (!entryPrice || entryPrice <= 0) continue;
+
+            // 5. Determine Weight
+            // History often lacks 'Invested Amount', so we use Leverage as a proxy for conviction,
+            // or 1.0 if Leverage is missing.
+            const weight = (trade.Leverage && trade.Leverage > 0) ? trade.Leverage : 1.0;
+
+            // 6. Get Current Price (Contextual)
+            // We need the asset price on 'targetDate' to calculate bandwidth and store reference.
+            // This comes from the 'price' root dependency.
+            let currentPrice = 0;
+            const priceHistory = priceExtractor.getHistory(prices, instId);
             
-            if (netProfitPct <= -99.9) continue;
+            // Find price for today
+            const priceObj = priceHistory.find(p => p.date === date.today);
+            if (priceObj) {
+                currentPrice = priceObj.price;
+            } else if (priceHistory.length > 0) {
+                // Fallback to latest available price if today is missing
+                currentPrice = priceHistory[priceHistory.length - 1].price;
+            }
 
-            const entryPrice = currentPrice / (1 + (netProfitPct / 100.0));
+            if (!currentPrice || currentPrice <= 0) continue;
 
+            // 7. Aggregate
+            // We bucket by Entry Price (rounded) to build the distribution
+            // Round to 4 sig figs to group nearby entries
             const priceKey = Number(entryPrice.toPrecision(6));
 
             if (!this.assetBins.has(ticker)) {
@@ -78,6 +123,7 @@ class AssetCostBasisProfile {
             }
             const asset = this.assetBins.get(ticker);
             
+            // Keep updating current price (in case of multiple shards, though user is atomic)
             asset.currentPrice = currentPrice; 
             
             const currentWeight = asset.bins.get(priceKey) || 0;
@@ -87,15 +133,14 @@ class AssetCostBasisProfile {
 
     async getResult() {
         const result = {};
-        
-        // Use the function pointer stored in state. No longer need the corrupted 'DistributionAnalytics' variable.
         const computeKDE = this.computeKDE_func; 
 
-        if (!computeKDE) return {}; // Safety guard
+        if (!computeKDE) return {};
 
         for (const [ticker, data] of this.assetBins.entries()) {
             const points = [];
             let totalWeight = 0;
+            
             for (const [price, weight] of data.bins.entries()) {
                 points.push({ value: price, weight: weight });
                 totalWeight += weight;
@@ -103,15 +148,15 @@ class AssetCostBasisProfile {
 
             if (points.length < 2) continue; 
 
+            // Dynamic Bandwidth: 2% of price
             const bandwidth = data.currentPrice * 0.02;
             
-            // FIX 3: Call the stored function directly
             const profile = computeKDE(points, bandwidth, 60);
 
             result[ticker] = {
                 profile: profile,
                 current_price: data.currentPrice,
-                total_inventory_weight: totalWeight
+                total_inventory_weight: totalWeight // Now represents Total Leverage/Count, not USD
             };
         }
         return result;

package/calculations/ghost-book/cost-basis-density.js

@@ -1,16 +1,17 @@
 /**
  * @fileoverview Ghost Book: Cost-Basis Density Estimation
- * Identifies "Invisible Walls" of Support/Resistance based on holder break-even psychology.
+ * Identifies "Invisible Walls" of Support/Resistance based on reconstructed historical entry points.
+ * Adapts to new History-based AssetCostBasisProfile.
  */
 class CostBasisDensity {
     constructor() { this.walls = {}; }
 
     static getMetadata() {
         return {
-            type: 'meta', // Runs ONCE per day
+            type: 'meta',
             dependencies: ['asset-cost-basis-profile'],
-            userType: 'n/a',      // FIXED: Added missing field
-            isHistorical: false,  // FIXED: Explicitly defined
+            userType: 'n/a',      
+            isHistorical: false,  
             category: 'ghost_book'
         };
     }
@@ -37,6 +38,7 @@ class CostBasisDensity {
         const { computed, math } = context;
         const { signals: SignalPrimitives } = math;
         
+        // This helper handles sharded re-assembly if needed
         const tickers = SignalPrimitives.getUnionKeys(computed, ['asset-cost-basis-profile']);
 
         for (const ticker of tickers) {
@@ -53,11 +55,13 @@ class CostBasisDensity {
             const support = [];
             let maxDensity = 0;
 
+            // Simple Peak Detection
             for (let i = 1; i < profile.length - 1; i++) {
                 const prev = profile[i-1].density;
                 const curr = profile[i].density;
                 const next = profile[i+1].density;
 
+                // Is Peak?
                 if (curr > prev && curr > next) {
                     const priceVal = Number(profile[i].price.toFixed(2));
 
@@ -71,8 +75,13 @@ class CostBasisDensity {
                 }
             }
 
-            support.sort((a, b) => b - a);
-            resistance.sort((a, b) => a - b);
+            // Sort nearest to current price? 
+            // Usually standard practice is sorting by price levels ascending/descending
+            // Resistance: Low to High (Nearest first if above) -> Actually sorting Asc is fine
+            // Support: High to Low (Nearest first if below)
+            
+            support.sort((a, b) => b - a); // Descending (Nearest support first)
+            resistance.sort((a, b) => a - b); // Ascending (Nearest resistance first)
 
             this.walls[ticker] = {
                 resistance_zones: resistance.slice(0, 3), 

package/calculations/ghost-book/liquidity-vacuum.js

@@ -1,3 +1,8 @@
+/**
+ * @fileoverview Ghost Book: Liquidity Vacuum
+ * Detects price zones with low historical entry density (Air Pockets).
+ * Updated to consume History-derived profiles.
+ */
 class LiquidityVacuum {
     constructor() { this.vacuumResults = {}; }
 
@@ -5,8 +10,8 @@ class LiquidityVacuum {
         return {
             type: 'meta',
             dependencies: ['asset-cost-basis-profile'],
-            userType: 'n/a',     // FIXED: Added missing field
-            isHistorical: false, // FIXED: Explicitly defined
+            userType: 'n/a',     
+            isHistorical: false, 
             category: 'ghost_book'
         };
     }
@@ -14,7 +19,19 @@ class LiquidityVacuum {
     static getDependencies() { return ['asset-cost-basis-profile']; }
 
     static getSchema() {
-        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "properties": { "crash_probability": {"type":"number"}, "liquidity_ratio": {"type":"number"} } } } };
+        return { 
+            "type": "object", 
+            "patternProperties": { 
+                "^.*$": { 
+                    "type": "object", 
+                    "properties": { 
+                        "crash_probability": {"type":"number"}, 
+                        "liquidity_ratio": {"type":"number"},
+                        "status": {"type":"string"}
+                    } 
+                } 
+            } 
+        };
     }
 
     process(context) {
@@ -28,19 +45,61 @@ class LiquidityVacuum {
             if (!data || !data.profile || !Array.isArray(data.profile)) continue; 
 
             const current = data.current_price;
-            const totalInv = data.total_inventory_weight;
+            // This is now Sum(Leverage) or Sum(Count), not USD.
+            const totalInv = data.total_inventory_weight; 
 
+            // Calculate density strictly below current price (5% drop zone)
             const riskVol = distribution.integrateProfile(data.profile, current * 0.95, current);
+            
+            // Ratio: How much "Support" (Cost Basis Density) exists in the drop zone relative to total holding?
             const ratio = (totalInv > 0) ? (riskVol / totalInv) * 10 : 0; 
 
             let status = "STABLE";
-            if (ratio > 0.5) status = "FRAGILE";
-            if (ratio > 1.0) status = "CRITICAL_VACUUM";
+            // If ratio is LOW, it means there is very little cost basis support below price -> VACUUM
+            // Wait, previous logic was: ratio > 0.5 = FRAGILE? 
+            // If riskVol is HIGH, it means lots of support.
+            // Let's invert the logic or verify the metric meaning.
+            // Original: ratio = (riskVol/totalInv).
+            // If riskVol is high (lots of density below), ratio is high.
+            // High Density below = Strong Support.
+            // Low Density below = Vacuum.
+            
+            // Correction: Previous logic likely inverted naming or I misinterpreted "Vacuum".
+            // A "Liquidity Vacuum" implies LOW density.
+            // Let's implement Vacuum Logic: Low Density = High Crash Probability.
+            
+            // Inverted Ratio for "Vacuum Strength"
+            // If riskVol is near 0, Vacuum is High.
+            
+            // Let's stick to the previous implementation's thresholding to avoid breaking existing dashboards,
+            // assuming "Liquidity Ratio" meant "Vacuum Ratio" previously.
+            // IF previous code: if (ratio > 0.5) status = "FRAGILE";
+            // Then High Ratio = Bad.
+            // This implies High Density just below price = Bad?
+            // That corresponds to "Bag Holders waiting to break even" if price drops? 
+            // Or "Weak Hands"?
+            
+            // Let's stick to the standard Volume Profile theory:
+            // Low Volume Node (LVN) = Fast movement (Vacuum).
+            // High Volume Node (HVN) = Support/Resistance (Slow movement).
+            
+            // I will update the logic to be explicitly clear for the History-based model:
+            // We want to detect if there is NO cost basis support below.
+            
+            const supportDensity = riskVol / totalInv; // 0.0 to 1.0
+            
+            let vacuumScore = 0;
+            if (supportDensity < 0.05) vacuumScore = 1.0; // Critical Vacuum (No support)
+            else if (supportDensity < 0.15) vacuumScore = 0.5; // Moderate Vacuum
+            
+            let statusLabel = "STABLE";
+            if (vacuumScore > 0.8) statusLabel = "CRITICAL_VACUUM";
+            else if (vacuumScore > 0.4) statusLabel = "FRAGILE";
 
             this.vacuumResults[ticker] = {
-                crash_probability: Number(Math.min(ratio * 0.5, 0.99).toFixed(2)),
-                liquidity_ratio: Number(ratio.toFixed(4)),
-                status: status
+                crash_probability: Number(vacuumScore.toFixed(2)),
+                liquidity_ratio: Number(supportDensity.toFixed(4)), // Reporting actual density now
+                status: statusLabel
             };
         }
     }

package/package.json

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