aiden-shared-calculations-unified 1.0.95 → 1.0.97

package/calculations/capitulation/asset-volatility-estimator.js

@@ -13,8 +13,7 @@ class AssetVolatilityEstimator {
             type: 'meta',
             rootDataDependencies: ['price'], 
             isHistorical: false,
-            userType: 'n/a',
-            category: 'market_stats'
+            userType: 'n/a'
         };
     }
 

package/calculations/capitulation/retail-capitulation-risk-forecast.js

@@ -21,8 +21,7 @@ class RetailCapitulationRiskForecast {
             type: 'standard',
             rootDataDependencies: ['portfolio', 'history'],
             isHistorical: false,
-            userType: 'all',
-            category: 'risk_models'
+            userType: 'all'
         };
     }
 

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

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Calculation (Pass 1) for total long figures.
+ * REFACTORED: Uses INSIGHTS DATA.
+ * TYPE: META
+ */
+class InsightsTotalLongFigures {
+    constructor() {
+        this.totalPositions = 0;
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['insights'],
+            isHistorical: false,
+            category: 'core_sentiment'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        return {
+            "type": "object",
+            "properties": {
+                "total_long_exposure_weight": { "type": "number" },
+                "total_positions_count": { "type": "number" }
+            },
+            "required": ["total_long_exposure_weight", "total_positions_count"]
+        };
+    }
+
+    process(context) {
+        const { insights: insightsHelper } = context.math;
+        const insights = insightsHelper.getInsights(context);
+
+        if (!insights) return;
+
+        for (const insight of insights) {
+            this.totalPositions += insightsHelper.getLongCount(insight);
+        }
+    }
+
+    getResult() {
+        return {
+            total_long_exposure_weight: 0, // Not available in Insights
+            total_positions_count: this.totalPositions
+        };
+    }
+
+    reset() {
+        this.totalPositions = 0;
+    }
+}
+
+module.exports = InsightsTotalLongFigures;

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

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview Calculation (Pass 1) for daily bought vs. sold count.
+ * REFACTORED: Uses INSIGHTS DATA as Single Source of Truth.
+ * TYPE: META (Runs once against global data)
+ */
+class InsightsDailyBoughtVsSoldCount {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['insights'], // explicit dependency on insights
+            isHistorical: true,
+            category: 'core_metrics'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "positions_bought": { "type": "number" },
+                "positions_sold": { "type": "number" },
+                "net_change": { "type": "number" }
+            },
+            "required": ["positions_bought", "positions_sold", "net_change"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
+
+    process(context) {
+        const { insights: insightsHelper } = context.math; // Maps to InsightsExtractor
+        const insights = insightsHelper.getInsights(context);
+        const { mappings } = context;
+        const tickerMap = mappings.instrumentToTicker || {};
+
+        if (!insights || !Array.isArray(insights)) return;
+
+        for (const insight of insights) {
+            const instId = insight.instrumentId;
+            const ticker = tickerMap[instId] || `id_${instId}`;
+
+            const netChange = insightsHelper.getNetOwnershipChange(insight);
+            
+            // Insights schema only provides Net Growth.
+            // We cannot strictly separate Bought vs Sold.
+            // Logic: If Net Positive -> Bought = Net, Sold = 0.
+            //        If Net Negative -> Bought = 0, Sold = Abs(Net).
+            const bought = netChange > 0 ? netChange : 0;
+            const sold   = netChange < 0 ? Math.abs(netChange) : 0;
+
+            if (bought > 0 || sold > 0) {
+                this.results[ticker] = {
+                    positions_bought: bought,
+                    positions_sold: sold,
+                    net_change: netChange
+                };
+            }
+        }
+    }
+
+    async getResult() {
+        return this.results;
+    }
+
+    reset() {
+        this.results = {};
+    }
+}
+module.exports = InsightsDailyBoughtVsSoldCount;

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

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Calculation (Pass 1) for ownership delta (users added/lost per asset).
+ * REFACTORED: Uses INSIGHTS DATA.
+ * TYPE: META
+ */
+class InsightsDailyOwnershipDelta {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['insights'],
+            isHistorical: true,
+            category: 'core_metrics'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "owners_added": { "type": "number" },
+                "owners_removed": { "type": "number" },
+                "net_ownership_change": { "type": "number" }
+            },
+            "required": ["owners_added", "owners_removed", "net_ownership_change"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
+
+    process(context) {
+        const { insights: insightsHelper } = context.math;
+        const insights = insightsHelper.getInsights(context);
+        const { mappings } = context;
+        const tickerMap = mappings.instrumentToTicker || {};
+
+        if (!insights) return;
+
+        for (const insight of insights) {
+            const netChange = insightsHelper.getNetOwnershipChange(insight);
+            if (netChange === 0) continue;
+
+            const instId = insight.instrumentId;
+            const ticker = tickerMap[instId] || `id_${instId}`;
+
+            // Approximate added/removed based on Net Change logic
+            const added = netChange > 0 ? netChange : 0;
+            const removed = netChange < 0 ? Math.abs(netChange) : 0;
+
+            this.results[ticker] = {
+                owners_added: added,
+                owners_removed: removed,
+                net_ownership_change: netChange
+            };
+        }
+    }
+
+    async getResult() {
+        return this.results;
+    }
+
+    reset() {
+        this.results = {};
+    }
+}
+module.exports = InsightsDailyOwnershipDelta;

package/calculations/core/insights-sentimet-per-stock.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Calculation (Pass 1) for sentiment per stock.
+ * REFACTORED: Uses INSIGHTS DATA.
+ * TYPE: META
+ */
+class InsightsSentimentPerStock {
+    constructor() {
+        this.results = {};
+    }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "long_count": { "type": "number" },
+                "short_count": { "type": "number" },
+                "sentiment_ratio": { "type": ["number", "null"] }
+            },
+            "required": ["long_count", "short_count", "sentiment_ratio"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['insights'],
+            isHistorical: false,
+            category: 'core_sentiment'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    process(context) {
+        const { insights: insightsHelper } = context.math;
+        const insights = insightsHelper.getInsights(context);
+        const { mappings } = context;
+        const tickerMap = mappings.instrumentToTicker || {};
+
+        if (!insights) return;
+
+        for (const insight of insights) {
+            const longCount = insightsHelper.getLongCount(insight);
+            const shortCount = insightsHelper.getShortCount(insight);
+
+            if (longCount === 0 && shortCount === 0) continue;
+
+            const instId = insight.instrumentId;
+            const ticker = tickerMap[instId] || `id_${instId}`;
+
+            this.results[ticker] = {
+                long_count: longCount,
+                short_count: shortCount,
+                sentiment_ratio: (shortCount > 0) ? (longCount / shortCount) : null
+            };
+        }
+    }
+
+    async getResult() {
+        return this.results;
+    }
+
+    reset() {
+        this.results = {};
+    }
+}
+module.exports = InsightsSentimentPerStock;

package/calculations/core/insights-total-long-per-sector

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Calculation (Pass 1) for long figures per sector.
+ * REFACTORED: Uses INSIGHTS DATA.
+ * TYPE: META
+ */
+class InsightsTotalLongPerSector {
+    constructor() {
+        this.sectorData = new Map();
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['insights'],
+            isHistorical: false,
+            category: 'core_sentiment'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "total_long_exposure_weight": { "type": "number" },
+                "total_positions_count": { "type": "number" }
+            },
+            "required": ["total_long_exposure_weight", "total_positions_count"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
+    }
+
+    process(context) {
+        const { insights: insightsHelper } = context.math;
+        const insights = insightsHelper.getInsights(context);
+        const { mappings } = context;
+        const sectorMap = mappings.instrumentToSector || {};
+
+        if (!insights) return;
+
+        for (const insight of insights) {
+            const longCount = insightsHelper.getLongCount(insight);
+            if (longCount <= 0) continue;
+
+            const sector = sectorMap[insight.instrumentId] || 'Unknown';
+            
+            if (!this.sectorData.has(sector)) {
+                this.sectorData.set(sector, { count: 0 });
+            }
+            const data = this.sectorData.get(sector);
+            data.count += longCount;
+        }
+    }
+
+    async getResult() {
+        const result = {};
+        for (const [sector, data] of this.sectorData.entries()) {
+            if (data.count > 0) {
+                result[sector] = {
+                    total_long_exposure_weight: 0, // Not available
+                    total_positions_count: data.count
+                };
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.sectorData.clear();
+    }
+}
+module.exports = InsightsTotalLongPerSector;

package/calculations/core/insights-total-positions-held.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Calculation (Pass 1) for total positions count.
+ * REFACTORED: Uses INSIGHTS DATA.
+ * TYPE: META
+ */
+class InsightsTotalPositionsHeld {
+    constructor() {
+        this.totalPositions = 0;
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['insights'],
+            isHistorical: false,
+            category: 'Global-Platform-Metrics'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        return {
+            "type": "object",
+            "properties": {
+                "total_positions_count": { "type": "number" }
+            },
+            "required": ["total_positions_count"]
+        };
+    }
+
+    process(context) {
+        const { insights: insightsHelper } = context.math;
+        const insights = insightsHelper.getInsights(context);
+
+        if (!insights) return;
+
+        for (const insight of insights) {
+            this.totalPositions += insightsHelper.getTotalOwners(insight);
+        }
+    }
+
+    getResult() {
+        return { total_positions_count: this.totalPositions };
+    }
+
+    reset() { this.totalPositions = 0; }
+}
+module.exports = InsightsTotalPositionsHeld;

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

@@ -8,8 +8,7 @@ class CostBasisDensity {
     static getMetadata() {
         return {
             type: 'meta', // Runs ONCE per day
-            dependencies: ['asset-cost-basis-profile'],
-            category: 'ghost_book'
+            dependencies: ['asset-cost-basis-profile']
         };
     }
     

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

@@ -4,8 +4,7 @@ class LiquidityVacuum {
     static getMetadata() {
         return {
             type: 'meta',
-            dependencies: ['asset-cost-basis-profile'],
-            category: 'ghost_book'
+            dependencies: ['asset-cost-basis-profile']
         };
     }
 
@@ -17,13 +16,14 @@ class LiquidityVacuum {
 
     process(context) {
         const { computed, math } = context;
-        const { distribution } = math; // Correctly accesses 'distribution' from context
+        const { distribution } = math; 
         
         const tickers = Object.keys(computed['asset-cost-basis-profile'] || {});
 
         for (const ticker of tickers) {
             const data = computed['asset-cost-basis-profile'][ticker];
-            if (!data) continue;
+            // BUG FIX: Ensure data and profile exist before accessing length/integration
+            if (!data || !data.profile || !Array.isArray(data.profile)) continue; 
 
             const current = data.current_price;
             const totalInv = data.total_inventory_weight;

package/calculations/ghost-book/retail-gamma-exposure.js

@@ -10,7 +10,6 @@ class RetailGammaExposure {
             type: 'meta',
             dependencies: ['skilled-cohort-flow', 'instrument-price-change-1d'],
             isHistorical: true, // Requires t-1, t-2... for rolling regression
-            category: 'ghost_book'
         };
     }
 

package/calculations/helix/winner-loser-flow.js

@@ -16,7 +16,7 @@ class WinnerLoserFlow {
             userType: 'all',
             category: 'helix'
         };
-    }
+    }s
 
     static getDependencies() { return []; }
 

package/calculations/predicative-alpha/cognitive-dissonance.js

@@ -13,8 +13,7 @@ class CognitiveDissonance {
             type: 'meta', // Runs after standard calculations
             rootDataDependencies: [],
             isHistorical: true, // Requires t-1 state
-            userType: 'aggregate',
-            category: 'predictive_alpha'
+            userType: 'aggregate'
         };
     }
 

package/calculations/predicative-alpha/diamond-hand-fracture.js

@@ -10,8 +10,7 @@ class DiamondHandFracture {
             type: 'meta',
             rootDataDependencies: [],
             isHistorical: true,
-            userType: 'aggregate',
-            category: 'predictive_alpha'
+            userType: 'aggregate'
         };
     }
 

package/calculations/predicative-alpha/mimetic-latency.js

@@ -15,8 +15,7 @@ class MimeticLatencyOscillator {
             type: 'meta',
             rootDataDependencies: [],
             isHistorical: true,
-            userType: 'aggregate',
-            category: 'predictive_alpha'
+            userType: 'aggregate'
         };
     }
 

package/package.json

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

package/calculations/legacy/activity_by_pnl_status.js

@@ -1,119 +0,0 @@
-/**
- * @fileoverview Analyzes *why* users were active by checking the P&L status
- * of positions just before they were closed.
- * This measures "Profit Taking" vs. "Capitulation".
- */
-class ActivityByPnlStatus {
-    constructor() {
-        this.total_positions_yesterday = {
-            in_profit: 0,
-            in_loss: 0
-        };
-        this.closed_positions_today = {
-            profit_taken: 0,
-            loss_realized: 0
-        };
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Measures profit-taking vs. capitulation by analyzing the P&L of closed positions.",
-            "properties": {
-                "profit_taking_rate_pct": {
-                    "type": "number",
-                    "description": "The percentage of profitable positions (from yesterday) that were closed today."
-                },
-                "capitulation_rate_pct": {
-                    "type": "number",
-                    "description": "The percentage of losing positions (from yesterday) that were closed today."
-                },
-                "raw_counts": {
-                    "type": "object",
-                    "description": "Raw counts used to calculate the rates.",
-                    "properties": {
-                        "profit_positions_closed": { "type": "number" },
-                        "loss_positions_closed": { "type": "number" },
-                        "total_profit_positions_available": { "type": "number" },
-                        "total_loss_positions_available": { "type": "number" }
-                    },
-                    "required": ["profit_positions_closed", "loss_positions_closed", "total_profit_positions_available", "total_loss_positions_available"]
-                }
-            },
-            "required": ["profit_taking_rate_pct", "capitulation_rate_pct", "raw_counts"]
-        };
-    }
-
-    _getPortfolioMap(portfolio) {
-        // We MUST use PositionID here to track specific trades, not just the asset
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
-        }
-        // Map<PositionID, NetProfit>
-        return new Map(positions.map(p => [p.PositionID, p.NetProfit || 0]));
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPosMap = this._getPortfolioMap(yesterdayPortfolio);
-        const tPosMap = this._getPortfolioMap(todayPortfolio);
-
-        if (yPosMap.size === 0) {
-            return; // No positions yesterday to analyze
-        }
-
-        for (const [yPosId, yNetProfit] of yPosMap.entries()) {
-            // 1. Bucket yesterday's P&L state
-            if (yNetProfit > 0) {
-                this.total_positions_yesterday.in_profit++;
-            } else if (yNetProfit < 0) {
-                this.total_positions_yesterday.in_loss++;
-            }
-
-            // 2. Check if this position was closed
-            if (!tPosMap.has(yPosId)) {
-                // Position was closed. Check its P&L from yesterday.
-                if (yNetProfit > 0) {
-                    this.closed_positions_today.profit_taken++;
-                } else if (yNetProfit < 0) {
-                    this.closed_positions_today.loss_realized++;
-                }
-            }
-        }
-    }
-
-    getResult() {
-        const { in_profit, in_loss } = this.total_positions_yesterday;
-        const { profit_taken, loss_realized } = this.closed_positions_today;
-
-        // Calculate rates to normalize the data
-        const profit_taking_rate = (in_profit > 0) ? (profit_taken / in_profit) * 100 : 0;
-        const capitulation_rate = (in_loss > 0) ? (loss_realized / in_loss) * 100 : 0;
-
-        return {
-            profit_taking_rate_pct: profit_taking_rate, // % of profitable positions that were closed
-            capitulation_rate_pct: capitulation_rate,   // % of losing positions that were closed
-            raw_counts: {
-                profit_positions_closed: profit_taken,
-                loss_positions_closed: loss_realized,
-                total_profit_positions_available: in_profit,
-                total_loss_positions_available: in_loss
-            }
-        };
-    }
-
-    reset() {
-        this.total_positions_yesterday = { in_profit: 0, in_loss: 0 };
-        this.closed_positions_today = { profit_taken: 0, loss_realized: 0 };
-    }
-}
-
-module.exports = ActivityByPnlStatus;