aiden-shared-calculations-unified 1.0.45 → 1.0.46

package/calculations/pnl/pnl_distribution_per_stock.js

@@ -1,91 +1,66 @@
 /**
- * @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.
+ * @fileoverview Aggregates P&L data points for statistical analysis.
+ * This calculation is a dependency for the 'Crowd Sharpe Ratio Proxy'.
+ * It gathers the sum, sum of squares, and count of P&L for each stock.
  */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
-class CrowdSharpeRatioProxy {
-    
-    /**
-     * (NEW) Statically declare dependencies.
-     */
-    static getDependencies() {
-        return ['pnl-distribution-per-stock'];
+class PnlDistributionPerStock {
+    constructor() {
+        this.distributionData = {}; // { [instrumentId]: { pnl_sum: 0, pnl_sum_sq: 0, position_count: 0 } }
+        this.mappings = null;
     }
 
-    constructor() {}
-
-    /**
-     * 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;
-
-        // 1. Get dependency from in-memory cache
-        const data = fetchedDependencies['pnl-distribution-per-stock'];
-
-        // 2. Handle missing dependency
-        if (!data) {
-            logger.log('WARN', `[CrowdSharpeRatioProxy] Missing dependency 'pnl-distribution-per-stock' for ${dateStr}. Skipping.`);
-            return null;
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions) {
+            return;
         }
 
-        const pnlDistribution = data.pnl_distribution_by_asset;
-
-        if (!pnlDistribution) {
-             logger.log('WARN', `[CrowdSharpeRatioProxy] Dependency data for ${dateStr} is empty. Skipping.`);
-             return null;
-        }
-
-        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;
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            // Use NetProfit (which is the P&L value)
+            const netProfit = position.NetProfit; 
+
+            // Ensure netProfit is a valid number
+            if (instrumentId && typeof netProfit === 'number' && isFinite(netProfit)) {
+                if (!this.distributionData[instrumentId]) {
+                    this.distributionData[instrumentId] = {
+                        pnl_sum: 0,
+                        pnl_sum_sq: 0, // Sum of squares
+                        position_count: 0
+                    };
+                }
+
+                this.distributionData[instrumentId].pnl_sum += netProfit;
+                this.distributionData[instrumentId].pnl_sum_sq += (netProfit * netProfit); // Add the square
+                this.distributionData[instrumentId].position_count++;
             }
+        }
+    }
 
-            const std_dev = Math.sqrt(variance); // "Risk"
-            const sharpe_proxy = mean / std_dev; // Return / Risk
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
 
-            results[ticker] = {
-                average_pnl: mean,
-                std_dev_pnl: std_dev,
-                sharpe_ratio_proxy: sharpe_proxy,
-                position_count: N
-            };
+        const result = {};
+        for (const instrumentId in this.distributionData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.distributionData[instrumentId];
         }
 
-        return results;
+        if (Object.keys(result).length === 0) return {};
+        
+        return { 
+            pnl_distribution_by_asset: result 
+        };
     }
 
-    async getResult() { return null; }
-    reset() {}
+    reset() {
+        this.distributionData = {};
+        this.mappings = null;
+    }
 }
 
-module.exports = CrowdSharpeRatioProxy;
+module.exports = PnlDistributionPerStock;

package/package.json

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