aiden-shared-calculations-unified 1.0.95 → 1.0.96

package/calculations/legacy/risk_appetite_change.js

@@ -1,97 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 1) for speculator metric.
- *
- * This metric tracks the change in a speculator's risk appetite by
- * comparing the "risk" of their portfolio today vs. yesterday.
- * Risk is defined as (TotalLeveragedInvestment / TotalInvestment).
- */
-
-class RiskAppetiteChange {
-    constructor() {
-        // We will store { [userId]: { risk_appetite_change: 0 } }
-        this.userRiskMap = new Map();
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Tracks the daily change in risk appetite (leveraged investment / total investment) for each speculator.",
-            "patternProperties": {
-                "^[a-zA-Z0-9_]+$": { // Matches any user ID
-                    "type": "object",
-                    "properties": {
-                        "risk_appetite_change": {
-                            "type": "number",
-                            "description": "The percentage point change in risk appetite from yesterday to today."
-                        }
-                    },
-                    "required": ["risk_appetite_change"]
-                }
-            },
-            "additionalProperties": false
-        };
-    }
-
-    /**
-     * Helper to calculate the risk score from a portfolio snapshot.
-     * @param {object} portfolio - The portfolio snapshot.
-     * @returns {number} The risk score (0-100).
-     */
-    _calculateRisk(portfolio) {
-        const totalInvestment = portfolio?.TotalInvestment;
-        const totalLeveragedInvestment = portfolio?.TotalLeveragedInvestment;
-
-        if (!totalInvestment || totalInvestment === 0 || !totalLeveragedInvestment) {
-            return 0;
-        }
-        
-        // Return as a percentage
-        return (totalLeveragedInvestment / totalInvestment) * 100;
-    }
-
-    /**
-     * @param {object} todayPortfolio
-     * @param {object} yesterdayPortfolio
-     * @param {string} userId
-     */
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        // --- FIX ---
-        // Add null check to prevent crash on the first day of processing
-        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.Portfolio || !yesterdayPortfolio.Portfolio) {
-            return;
-        }
-
-        
-        // --- END FIX ---
-        
-        // 1. Get portfolio snapshots
-        const yPortfolio = yesterdayPortfolio.Portfolio;
-        const tPortfolio = todayPortfolio.Portfolio;
-
-        // 2. Calculate risk for both days
-        const yRisk = this._calculateRisk(yPortfolio);
-        const tRisk = this._calculateRisk(tPortfolio);
-
-        // 3. Calculate the change (in percentage points)
-        const change = tRisk - yRisk;
-
-        this.userRiskMap.set(userId, {
-            risk_appetite_change: change
-        });
-    }
-
-    getResult() {
-        // Convert Map to plain object for Firestore
-        return Object.fromEntries(this.userRiskMap);
-    }
-
-    reset() {
-        this.userRiskMap.clear();
-    }
-}
-
-module.exports = RiskAppetiteChange;

package/calculations/legacy/sector_rotation.js

@@ -1,117 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for sector rotation.
- *
- * This metric answers: "What is the net change in investment
- * (as a portfolio percentage) for each sector today?"
- *
- * This measures which sectors the crowd is rotating into or out of.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class SectorRotation {
-    constructor() {
-        // We will store { [sector]: { y_invested_sum: 0, t_invested_sum: 0 } }
-        this.sectors = new Map();
-        this.mappings = null;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const sectorSchema = {
-            "type": "object",
-            "description": "Net change in portfolio allocation for a specific sector.",
-            "properties": {
-                "net_change_pct": {
-                    "type": "number",
-                    "description": "The net change in percentage allocation (Today Sum - Yesterday Sum)."
-                },
-                "y_total_invested_pct": {
-                    "type": "number",
-                    "description": "Total portfolio percentage invested in this sector yesterday."
-                },
-                "t_total_invested_pct": {
-                    "type": "number",
-                    "description": "Total portfolio percentage invested in this sector today."
-                }
-            },
-            "required": ["net_change_pct", "y_total_invested_pct", "t_total_invested_pct"]
-        };
-        
-        return {
-            "type": "object",
-            "description": "Calculates the net rotation of portfolio percentage allocation between sectors.",
-            "patternProperties": {
-                "^.*$": sectorSchema // Sector name
-            },
-            "additionalProperties": sectorSchema
-        };
-    }
-
-    _initSector(sector) {
-        if (!this.sectors.has(sector)) {
-            this.sectors.set(sector, {
-                y_invested_sum: 0,
-                t_invested_sum: 0
-            });
-        }
-    }
-
-    _sumSectorAllocations(portfolio, mapKey) {
-        const positions = portfolio?.AggregatedPositions; // Must use Aggregated for 'Invested' %
-        if (!positions || !Array.isArray(positions) || !this.mappings) {
-            return;
-        }
-
-        for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (instrumentId) {
-                const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
-                this._initSector(sector);
-                
-                const investedPct = pos.InvestedAmount || pos.Invested || 0;
-                this.sectors.get(sector)[mapKey] += investedPct;
-            }
-        }
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        if (!this.mappings) {
-            // Context contains the mappings loaded in Pass 1
-            this.mappings = context.mappings;
-        }
-        
-        this._sumSectorAllocations(yesterdayPortfolio, 'y_invested_sum');
-        this._sumSectorAllocations(todayPortfolio, 't_invested_sum');
-    }
-
-    getResult() {
-        const result = {};
-        for (const [sector, data] of this.sectors.entries()) {
-            const netChange = data.t_invested_sum - data.y_invested_sum;
-            
-            // Only report sectors that had some activity
-            if (data.t_invested_sum > 0 || data.y_invested_sum > 0) {
-                result[sector] = {
-                    net_change_pct: netChange,
-                    y_total_invested_pct: data.y_invested_sum,
-                    t_total_invested_pct: data.t_invested_sum
-                };
-            }
-        }
-        return result;
-    }
-
-    reset() {
-        this.sectors.clear();
-        this.mappings = null;
-    }
-}
-
-module.exports = SectorRotation;

package/calculations/legacy/shark_attack_signal.js

@@ -1,112 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 4) for "Shark Attack" signal.
- *
- * This signal identifies when the "Smart Cohort" is behaving
- * differently from both the "Dumb Cohort" and the "In-Loss Cohort"
- * simultaneously.
- *
- * e.g., Smart buying, while Dumb AND Loss cohorts are selling.
- *
- * It *depends* on 'smart-cohort-flow', 'dumb-cohort-flow',
- * and 'in_loss_asset_crowd_flow'.
- */
-class SharkAttackSignal {
-    constructor() {
-        // No per-user processing
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const signalSchema = {
-            "type": "object",
-            "properties": {
-                "status": {
-                    "type": "string",
-                    "enum": ["Shark Attack (Buy)", "Shark Bait (Sell)", "Neutral"]
-                },
-                "smart_flow_pct": { "type": "number" },
-                "dumb_flow_pct": { "type": "number" },
-                "loss_cohort_flow_pct": { "type": "number" }
-            },
-            "required": ["status", "smart_flow_pct", "dumb_flow_pct", "loss_cohort_flow_pct"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Generates 'Shark Attack' signals where Smart Cohort flow diverges from both Dumb and In-Loss cohorts.",
-            "patternProperties": {
-                "^.*$": signalSchema // Ticker
-            },
-            "additionalProperties": signalSchema
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'smart-cohort-flow',      // Pass 3
-            'dumb-cohort-flow',       // Pass 3
-            'in_loss_asset_crowd_flow'// Pass 3
-        ];
-    }
-
-    process() {
-        // No-op
-    }
-
-    getResult(fetchedDependencies) {
-        const smartFlowData = fetchedDependencies['smart-cohort-flow']?.assets;
-        const dumbFlowData = fetchedDependencies['dumb-cohort-flow']?.assets;
-        const lossFlowData = fetchedDependencies['in_loss_asset_crowd_flow'];
-
-        if (!smartFlowData || !dumbFlowData || !lossFlowData) {
-            return {};
-        }
-
-        const allTickers = new Set([
-            ...Object.keys(smartFlowData), 
-            ...Object.keys(dumbFlowData), 
-            ...Object.keys(lossFlowData)
-        ]);
-        
-        const result = {};
-        const THRESHOLD = 1.5; // Higher threshold for a stronger signal
-
-        for (const ticker of allTickers) {
-            const sFlow = smartFlowData[ticker]?.net_flow_percentage || 0;
-            const dFlow = dumbFlowData[ticker]?.net_flow_percentage || 0;
-            const lFlow = lossFlowData[ticker]?.net_flow_percentage || 0;
-            
-            let status = 'Neutral';
-
-            // "Shark Attack": Smart buying, Dumb selling, Loss selling
-            if (sFlow > THRESHOLD && dFlow < -THRESHOLD && lFlow < -THRESHOLD) {
-                status = 'Shark Attack (Buy)';
-            }
-            // "Shark Bait": Smart selling, Dumb buying, Loss buying
-            else if (sFlow < -THRESHOLD && dFlow > THRESHOLD && lFlow > THRESHOLD) {
-                status = 'Shark Bait (Sell)';
-            }
-
-            result[ticker] = {
-                status: status,
-                smart_flow_pct: sFlow,
-                dumb_flow_pct: dFlow,
-                loss_cohort_flow_pct: lFlow
-            };
-        }
-        
-        return result;
-    }
-
-    reset() {
-        // No state
-    }
-}
-
-module.exports = SharkAttackSignal;

package/calculations/legacy/smart-cohort-flow.js

@@ -1,238 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 3) for smart cohort flow.
- *
- * This metric calculates the "Net Crowd Flow Percentage" for the
- * "Smart Cohort" (top 20% of investors).
- *
- * This calculation *depends* on 'user_profitability_tracker'
- * to identify the cohort.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class SmartCohortFlow {
-    constructor() {
-        this.assetData = new Map();
-        this.sectorData = new Map();
-        this.mappings = null;
-        this.smartCohortUserIds = null;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const flowSchema = {
-            "type": "object",
-            "properties": {
-                "net_flow_percentage": { "type": "number" },
-                "total_invested_today": { "type": "number" },
-                "total_invested_yesterday": { "type": "number" }
-            },
-            "required": ["net_flow_percentage", "total_invested_today", "total_invested_yesterday"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates net capital flow % (price-adjusted) for the 'Smart Cohort' (top 20% users), aggregated by asset and sector.",
-            "properties": {
-                "cohort_size": {
-                    "type": "number",
-                    "description": "The number of users identified as being in the Smart Cohort."
-                },
-                "assets": {
-                    "type": "object",
-                    "description": "Price-adjusted net flow per asset.",
-                    "patternProperties": { "^.*$": flowSchema }, // Ticker
-                    "additionalProperties": flowSchema
-                },
-                "sectors": {
-                    "type": "object",
-                    "description": "Price-adjusted net flow per sector.",
-                    "patternProperties": { "^.*$": flowSchema }, // Sector
-                    "additionalProperties": flowSchema
-                }
-            },
-            "required": ["cohort_size", "assets", "sectors"]
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return ['user_profitability_tracker'];
-    }
-
-    _getPortfolioPositions(portfolio) {
-        return portfolio?.PublicPositions || portfolio?.AggregatedPositions;
-    }
-
-    _initAsset(instrumentId) {
-        if (!this.assetData.has(instrumentId)) {
-            this.assetData.set(instrumentId, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0,
-            });
-        }
-    }
-    
-    _initSector(sector) {
-        if (!this.sectorData.has(sector)) {
-            this.sectorData.set(sector, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0,
-            });
-        }
-    }
-
-    /**
-     * Helper to get the cohort IDs from the dependency.
-     */
-    _getSmartCohort(fetchedDependencies) {
-        if (this.smartCohortUserIds) {
-            return this.smartCohortUserIds;
-        }
-        
-        const profitabilityData = fetchedDependencies['user_profitability_tracker'];
-        if (!profitabilityData || !profitabilityData.ranked_users) {
-            return new Set();
-        }
-
-        const rankedUsers = profitabilityData.ranked_users;
-        const cohortSize = Math.floor(rankedUsers.length * 0.20);
-        
-        // The 'ranked_users' are sorted ascending by P&L, so top 20% is the *last* 20%.
-        this.smartCohortUserIds = new Set(rankedUsers.slice(-cohortSize).map(u => u.userId));
-        return this.smartCohortUserIds;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        const smartCohort = this._getSmartCohort(fetchedDependencies);
-        
-        // This user is not in the "smart cohort", skip.
-        if (!smartCohort.has(userId)) {
-            return;
-        }
-
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
-        const tPos = this._getPortfolioPositions(todayPortfolio);
-
-        const yPosMap = new Map(yPos?.map(p => [p.InstrumentID, p]) || []);
-        const tPosMap = new Map(tPos?.map(p => [p.InstrumentID, p]) || []);
-
-        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
-        
-        if (!this.mappings) {
-            // Context contains the mappings loaded in Pass 1
-            this.mappings = context.mappings;
-        }
-
-        for (const instrumentId of allInstrumentIds) {
-            if (!instrumentId) continue;
-            
-            this._initAsset(instrumentId);
-            const asset = this.assetData.get(instrumentId);
-
-            const yP = yPosMap.get(instrumentId);
-            const tP = tPosMap.get(instrumentId);
-
-            const yInvested = yP?.InvestedAmount || yP?.Amount || 0;
-            const tInvested = tP?.InvestedAmount || tP?.Amount || 0;
-            
-            // Get sector and initialize it
-            const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
-            this._initSector(sector);
-            const sectorAsset = this.sectorData.get(sector);
-
-            if (yInvested > 0) {
-                const yPriceChange = (yP?.PipsRate || 0) / (yP?.OpenRate || 1);
-                
-                asset.total_invested_yesterday += yInvested;
-                asset.price_change_yesterday += yPriceChange * yInvested;
-                
-                sectorAsset.total_invested_yesterday += yInvested;
-                sectorAsset.price_change_yesterday += yPriceChange * yInvested;
-            }
-            if (tInvested > 0) {
-                asset.total_invested_today += tInvested;
-                sectorAsset.total_invested_today += tInvested;
-            }
-        }
-    }
-    
-    _calculateFlow(dataMap) {
-        const result = {};
-        for (const [key, data] of dataMap.entries()) {
-            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
-            
-            if (total_invested_yesterday > 0) {
-                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
-                const price_contribution = total_invested_yesterday * avg_price_change_pct;
-                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
-                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-                
-                result[key] = {
-                    net_flow_percentage: net_flow_percentage,
-                    total_invested_today: total_invested_today,
-                    total_invested_yesterday: total_invested_yesterday
-                };
-            }
-        }
-        return result;
-    }
-
-    async getResult(fetchedDependencies) {
-        // Ensure mappings are loaded (can be from context or loaded now)
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        
-        // Ensure cohort is calculated at least once
-        const smartCohort = this._getSmartCohort(fetchedDependencies);
-
-        // 1. Calculate Asset Flow
-        const assetResult = {};
-        for (const [instrumentId, data] of this.assetData.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
-            
-            if (total_invested_yesterday > 0) {
-                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
-                const price_contribution = total_invested_yesterday * avg_price_change_pct;
-                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
-                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-                
-                assetResult[ticker] = {
-                    net_flow_percentage: net_flow_percentage,
-                    total_invested_today: total_invested_today,
-                    total_invested_yesterday: total_invested_yesterday
-                };
-            }
-        }
-        
-        // 2. Calculate Sector Flow
-        const sectorResult = this._calculateFlow(this.sectorData);
-
-        return {
-            cohort_size: smartCohort.size,
-            assets: assetResult,
-            sectors: sectorResult
-        };
-    }
-
-    reset() {
-        this.assetData.clear();
-        this.sectorData.clear();
-        this.mappings = null;
-        this.smartCohortUserIds = null;
-    }
-}
-
-module.exports = SmartCohortFlow;