aiden-shared-calculations-unified 1.0.84 → 1.0.87

package/calculations/core/profitability-ratio-per-stock.js

@@ -1,22 +1,13 @@
 /**
  * @fileoverview Calculation (Pass 1) for profitability ratio per stock.
- *
- * This metric answers: "For each stock, what is the count of
- * profitable versus unprofitable positions?"
+ * REFACTORED: Counts (No USD involved).
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class ProfitabilityRatioPerStock {
     constructor() {
-        // We will store { [instrumentId]: { profitable: 0, unprofitable: 0 } }
-        this.assets = new Map();
-        // --- STANDARD 0: RENAMED ---
+        this.stockData = new Map();
         this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
@@ -27,102 +18,57 @@ class ProfitabilityRatioPerStock {
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        const tickerSchema = {
+        const stockSchema = {
             "type": "object",
-            "description": "Profit/loss position counts for a specific asset.",
             "properties": {
-                "profitable_count": {
-                    "type": "number",
-                    "description": "Count of positions in profit."
-                },
-                "unprofitable_count": {
-                    "type": "number",
-                    "description": "Count of positions in loss."
-                },
-                "ratio": {
-                    "type": ["number", "null"],
-                    "description": "Ratio of profitable to unprofitable (Profit / Loss). Null if no losing positions."
-                }
-            },
-            "required": ["profitable_count", "unprofitable_count", "ratio"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the count of profitable vs. unprofitable positions for each asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
+                "profitability_ratio": { "type": ["number", "null"] },
+                "profitable_count": { "type": "number" },
+                "unprofitable_count": { "type": "number" }
             },
-            "additionalProperties": tickerSchema
+            "required": ["profitability_ratio", "profitable_count", "unprofitable_count"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": stockSchema } };
     }
 
-    _initAsset(instrumentId) {
-        if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                profitable: 0,
-                unprofitable: 0
-            });
+    _initStock(instId) {
+        if (!this.stockData.has(instId)) {
+            this.stockData.set(instId, { profitable: 0, unprofitable: 0 });
         }
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: ADDED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
-        
-        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
+
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
-            
-            this._initAsset(instrumentId);
-            const assetData = this.assets.get(instrumentId);
-            const pnl = pos.NetProfit || 0;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
 
-            if (pnl > 0) {
-                assetData.profitable++;
-            } else if (pnl < 0) {
-                assetData.unprofitable++;
-            }
+            const pnl = extract.getNetProfit(pos);
+            this._initStock(instId);
+            const data = this.stockData.get(instId);
+
+            if (pnl > 0) data.profitable++;
+            else if (pnl < 0) data.unprofitable++;
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
-        }
-
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-            
+        for (const [instId, data] of this.stockData.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
             if (data.profitable > 0 || data.unprofitable > 0) {
                 result[ticker] = {
+                    profitability_ratio: (data.unprofitable > 0) ? (data.profitable / data.unprofitable) : null,
                     profitable_count: data.profitable,
-                    unprofitable_count: data.unprofitable,
-                    ratio: (data.unprofitable > 0) ? (data.profitable / data.unprofitable) : null
+                    unprofitable_count: data.unprofitable
                 };
             }
         }
@@ -130,10 +76,8 @@ class ProfitabilityRatioPerStock {
     }
 
     reset() {
-        this.assets.clear();
-        // --- STANDARD 0: RENAMED ---
+        this.stockData.clear();
         this.tickerMap = null;
     }
 }
-
 module.exports = ProfitabilityRatioPerStock;

package/calculations/core/profitability-skew-per-stock.js

@@ -1,25 +1,13 @@
 /**
- * @fileoverview Calculation (Pass 1) for profitability skew.
- *
-_ This metric answers: "For each stock, what is the sum and
- * count of *profits* and *losses*?"
- *
- * This helps determine if returns are skewed (e.g., many small
- * wins and a few huge losses).
+ * @fileoverview Calculation (Pass 1) for profitability skew per stock.
+ * REFACTORED: Uses percentages.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class ProfitabilitySkewPerStock {
     constructor() {
-        // { [instrumentId]: { profit_sum: 0, profit_count: 0, loss_sum: 0, loss_count: 0 } }
-        this.assets = new Map();
-        // --- STANDARD 0: RENAMED ---
+        this.stockData = new Map();
         this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
@@ -30,116 +18,75 @@ class ProfitabilitySkewPerStock {
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        const tickerSchema = {
+        const stockSchema = {
             "type": "object",
-            "description": "P&L skew metrics for a specific asset.",
             "properties": {
-                "profit_sum": { "type": "number" },
-                "profit_count": { "type": "number" },
-                "loss_sum": { "type": "number" },
-                "loss_count": { "type": "number" },
-                "skew_ratio": {
-                    "type": ["number", "null"],
-                    "description": "Ratio of (Average Profit / Average Loss). Null if no losses."
-                }
+                "avg_profit_pct": { "type": "number" },
+                "avg_loss_pct": { "type": "number" },
+                "skew_ratio": { "type": ["number", "null"] }
             },
-            "required": ["profit_sum", "profit_count", "loss_sum", "loss_count", "skew_ratio"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the skew of returns (avg profit vs. avg loss) for each asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
+            "required": ["avg_profit_pct", "avg_loss_pct", "skew_ratio"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": stockSchema } };
     }
 
-    _initAsset(instrumentId) {
-        if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                profit_sum: 0,
-                profit_count: 0,
-                loss_sum: 0, // Will be negative
-                loss_count: 0
-            });
+    _initStock(instId) {
+        if (!this.stockData.has(instId)) {
+            this.stockData.set(instId, { profitSumPct: 0, profitCount: 0, lossSumPct: 0, lossCount: 0 });
         }
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: ADDED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
-            
-            this._initAsset(instrumentId);
-            const assetData = this.assets.get(instrumentId);
-            const pnl = pos.NetProfit || 0;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
+
+            const pnl = extract.getNetProfit(pos);
+            if (pnl === 0) continue;
+
+            this._initStock(instId);
+            const data = this.stockData.get(instId);
 
             if (pnl > 0) {
-                assetData.profit_sum += pnl;
-                assetData.profit_count++;
-            } else if (pnl < 0) {
-                assetData.loss_sum += pnl;
-                assetData.loss_count++;
+                data.profitSumPct += pnl;
+                data.profitCount++;
+            } else {
+                data.lossSumPct += Math.abs(pnl);
+                data.lossCount++;
             }
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
-        }
-
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
+        for (const [instId, data] of this.stockData.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
+            
+            const avgProfit = data.profitCount > 0 ? data.profitSumPct / data.profitCount : 0;
+            const avgLoss = data.lossCount > 0 ? data.lossSumPct / data.lossCount : 0;
             
-            const avgProfit = (data.profit_count > 0) ? (data.profit_sum / data.profit_count) : 0;
-            const avgLoss = (data.loss_count > 0) ? (Math.abs(data.loss_sum) / data.loss_count) : 0;
-
             result[ticker] = {
-                profit_sum: data.profit_sum,
-                profit_count: data.profit_count,
-                loss_sum: data.loss_sum,
-                loss_count: data.loss_count,
-                skew_ratio: (avgLoss > 0) ? (avgProfit / avgLoss) : null
+                avg_profit_pct: avgProfit,
+                avg_loss_pct: avgLoss,
+                skew_ratio: avgLoss > 0 ? avgProfit / avgLoss : null
             };
         }
         return result;
     }
 
     reset() {
-        this.assets.clear();
-        // --- STANDARD 0: RENAMED ---
+        this.stockData.clear();
         this.tickerMap = null;
     }
 }
-
 module.exports = ProfitabilitySkewPerStock;

package/calculations/core/profitable-and-unprofitable-status.js

@@ -1,113 +1,81 @@
 /**
- * @fileoverview Calculation (Pass 1) for overall profitable status.
- *
- * This metric answers: "How many users have an *overall portfolio*
- * in profit versus in loss today?"
+ * @fileoverview Calculation (Pass 1) - Bucket users by P&L status.
+ * REFACTORED: Standardized extraction.
  */
 class ProfitableAndUnprofitableStatus {
     constructor() {
-        this.total_in_profit = 0;
-        this.total_in_loss = 0;
+        this.stockData = new Map();
+        this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'], // Needs portfolio.Summary
+            rootDataDependencies: ['portfolio'],
             isHistorical: false,
             userType: 'all',
             category: 'core_pnl'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
-        return {
+        const schema = {
             "type": "object",
-            "description": "Tracks the count of users whose *overall portfolio* is in profit vs. in loss.",
             "properties": {
-                "total_in_profit": {
-                    "type": "number",
-                    "description": "Count of users with a total portfolio P&L > 0."
-                },
-                "total_in_loss": {
-                    "type": "number",
-                    "description": "Count of users with a total portfolio P&L < 0."
-                },
-                "profit_ratio_pct": {
-                    "type": "number",
-                    "description": "Percentage of users in profit (In Profit / Total)."
-                }
-            },
-            "required": ["total_in_profit", "total_in_loss", "profit_ratio_pct"]
+                "profitable_users": { "type": "array", "items": { "type": "string" } },
+                "unprofitable_users": { "type": "array", "items": { "type": "string" } }
+            }
         };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
     }
 
-    // --- UPDATED SIGNATURE ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        
-        // ---
-        // FIX: The 'data-generator.js' does not provide a 'Summary' object
-        // or a root-level 'NetProfit' field.
-        // We must derive the overall P&L from the individual positions,
-        // which *are* generated.
-        // ---
-        const positions = todayPortfolio.AggregatedPositions;
-        if (!positions || !Array.isArray(positions) || positions.length === 0) {
-            return; // No positions, no P&L status
+    _initStock(instId) {
+        if (!this.stockData.has(instId)) {
+            this.stockData.set(instId, { profitable: [], unprofitable: [] });
         }
+    }
 
-        let totalInvested = 0;
-        let weightedPnlSum = 0;
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        for (const pos of positions) {
-            const invested = pos.Invested;
-            const pnl = pos.NetProfit;
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
-            if (typeof invested === 'number' && typeof pnl === 'number') {
-                totalInvested += invested;
-                weightedPnlSum += (pnl * invested); // Weight the P&L by its size
-            }
-        }
+        for (const pos of positions) {
+            const instId = extract.getInstrumentId(pos);
+            const pnl = extract.getNetProfit(pos);
+            
+            if (!instId || pnl === 0) continue;
 
-        if (totalInvested === 0) {
-            return; // No invested capital, no P&L status
-        }
+            this._initStock(instId);
+            const data = this.stockData.get(instId);
 
-        const overallPnl = weightedPnlSum / totalInvested;
-        
-        if (overallPnl > 0) {
-            this.total_in_profit++;
-        } else if (overallPnl < 0) {
-            this.total_in_loss++;
+            if (pnl > 0) data.profitable.push(user.id);
+            else data.unprofitable.push(user.id);
         }
     }
 
-    getResult() {
-        const total = this.total_in_profit + this.total_in_loss;
-        return {
-            total_in_profit: this.total_in_profit,
-            total_in_loss: this.total_in_loss,
-            profit_ratio_pct: (total > 0) ? (this.total_in_profit / total) * 100 : 0
-        };
+    async getResult() {
+        if (!this.tickerMap) return {};
+        const result = {};
+        for (const [instId, data] of this.stockData.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
+            if (data.profitable.length > 0 || data.unprofitable.length > 0) {
+                result[ticker] = {
+                    profitable_users: data.profitable,
+                    unprofitable_users: data.unprofitable
+                };
+            }
+        }
+        return result;
     }
 
     reset() {
-        this.total_in_profit = 0;
-        this.total_in_loss = 0;
+        this.stockData.clear();
+        this.tickerMap = null;
     }
 }
-
 module.exports = ProfitableAndUnprofitableStatus;

package/calculations/core/sentiment-per-stock.js

@@ -1,56 +1,26 @@
 /**
  * @fileoverview Calculation (Pass 1) for sentiment per stock.
- *
- * This metric answers: "For each stock, what is the count
- * of long versus short positions?"
+ * REFACTORED: Counts Long vs Short.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class SentimentPerStock {
     constructor() {
-        // { [instrumentId]: { long: 0, short: 0 } }
         this.assets = new Map();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
-            "description": "Long/short position counts for a specific asset.",
             "properties": {
-                "long_count": {
-                    "type": "number",
-                    "description": "Count of long ('buy') positions."
-                },
-                "short_count": {
-                    "type": "number",
-                    "description": "Count of short ('sell') positions."
-                },
-                "sentiment_ratio": {
-                    "type": ["number", "null"],
-                    "description": "Ratio of long to short (Long / Short). Null if no short positions."
-                }
+                "long_count": { "type": "number" },
+                "short_count": { "type": "number" },
+                "sentiment_ratio": { "type": ["number", "null"] }
             },
             "required": ["long_count", "short_count", "sentiment_ratio"]
         };
-
-        return {
-            "type": "object",
-            "description": "Calculates the count of long vs. short positions for each asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
@@ -61,62 +31,41 @@ class SentimentPerStock {
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            this.assets.set(instrumentId, {
-                long: 0,
-                short: 0
-            });
+            this.assets.set(instrumentId, { long: 0, short: 0 });
         }
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: ADDED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        // Capture mapping reference for getResult
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
             
-            this._initAsset(instrumentId);
-            const assetData = this.assets.get(instrumentId);
+            this._initAsset(instId);
+            const assetData = this.assets.get(instId);
+            const direction = extract.getDirection(pos);
 
-            if (pos.IsBuy) {
-                assetData.long++;
-            } else {
-                assetData.short++;
-            }
+            if (direction === 'Buy') assetData.long++;
+            else assetData.short++;
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
-        }
-
+        if (!this.tickerMap) return {};
+        
         const result = {};
-        for (const [instrumentId, data] of this.assets.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-            
+        for (const [instId, data] of this.assets.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
             if (data.long > 0 || data.short > 0) {
                 result[ticker] = {
                     long_count: data.long,
@@ -130,9 +79,7 @@ class SentimentPerStock {
 
     reset() {
         this.assets.clear();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 }
-
 module.exports = SentimentPerStock;