aiden-shared-calculations-unified 1.0.44 → 1.0.45

package/calculations/pnl/pnl_distribution_per_stock.js

@@ -1,53 +1,91 @@
 /**
- * @fileoverview Calculates the necessary components to determine the statistical variance of PnL for each stock,
- * serving as a proxy for crowd volatility.
+ * @fileoverview Meta-calculation (Pass 2) to calculate a proxy for the
+ * crowd's "Sharpe Ratio" (risk-adjusted return) on a per-asset basis.
+ *
+ * --- META REFACTOR (v2) ---
+ * This calculation is now stateless. It declares its dependencies and
+ * expects them to be passed to its `process` method.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
-class PnlDistributionPerStock {
-    constructor() {
-        this.distributionData = {};
-        this.mappings = null;
+class CrowdSharpeRatioProxy {
+    
+    /**
+     * (NEW) Statically declare dependencies.
+     */
+    static getDependencies() {
+        return ['pnl-distribution-per-stock'];
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions) return;
+    constructor() {}
 
-        for (const position of positions) {
-            const instrumentId = position.InstrumentID;
-            const netProfit = position.NetProfit;
+    /**
+     * REFACTORED PROCESS METHOD
+     * @param {string} dateStr The date to run the analysis for (e.g., "2025-10-31").
+     * @param {object} dependencies The shared dependencies (db, logger).
+     * @param {object} config The computation system configuration.
+     * @param {object} fetchedDependencies In-memory results from previous passes.
+     * e.g., { 'pnl-distribution-per-stock': ... }
+     * @returns {Promise<object|null>} The analysis result or null.
+     */
+    async process(dateStr, dependencies, config, fetchedDependencies) {
+        const { logger } = dependencies;
 
-            if (!this.distributionData[instrumentId]) {
-                this.distributionData[instrumentId] = {
-                    pnl_sum: 0,
-                    pnl_sum_sq: 0,
-                    position_count: 0
-                };
-            }
+        // 1. Get dependency from in-memory cache
+        const data = fetchedDependencies['pnl-distribution-per-stock'];
 
-            this.distributionData[instrumentId].pnl_sum += netProfit;
-            this.distributionData[instrumentId].pnl_sum_sq += netProfit * netProfit;
-            this.distributionData[instrumentId].position_count++;
+        // 2. Handle missing dependency
+        if (!data) {
+            logger.log('WARN', `[CrowdSharpeRatioProxy] Missing dependency 'pnl-distribution-per-stock' for ${dateStr}. Skipping.`);
+            return null;
         }
-    }
 
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        const pnlDistribution = data.pnl_distribution_by_asset;
+
+        if (!pnlDistribution) {
+             logger.log('WARN', `[CrowdSharpeRatioProxy] Dependency data for ${dateStr} is empty. Skipping.`);
+             return null;
         }
-        const result = {};
-        for (const instrumentId in this.distributionData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.distributionData[instrumentId];
+
+        const results = {};
+
+        // 3. Calculate Sharpe Proxy for each asset
+        for (const ticker in pnlDistribution) {
+            const stats = pnlDistribution[ticker];
+            const N = stats.position_count;
+            
+            if (N < 2) continue; // Need at least 2 data points for variance
+
+            const mean = stats.pnl_sum / N; // E(x)
+            const mean_sq = stats.pnl_sum_sq / N; // E(x^2)
+            
+            const variance = mean_sq - (mean * mean);
+
+            if (variance <= 0) {
+                results[ticker] = {
+                    average_pnl: mean,
+                    std_dev_pnl: 0,
+                    sharpe_ratio_proxy: 0,
+                    position_count: N
+                };
+                continue;
+            }
+
+            const std_dev = Math.sqrt(variance); // "Risk"
+            const sharpe_proxy = mean / std_dev; // Return / Risk
+
+            results[ticker] = {
+                average_pnl: mean,
+                std_dev_pnl: std_dev,
+                sharpe_ratio_proxy: sharpe_proxy,
+                position_count: N
+            };
         }
-        return { pnl_distribution_by_asset: result };
-    }
 
-    reset() {
-        this.distributionData = {};
-        this.mappings = null;
+        return results;
     }
+
+    async getResult() { return null; }
+    reset() {}
 }
 
-module.exports = PnlDistributionPerStock;
+module.exports = CrowdSharpeRatioProxy;

package/package.json

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