aiden-shared-calculations-unified 1.0.95 → 1.0.97

package/calculations/legacy/smart-dumb-divergence-index.js

@@ -1,143 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 4) for smart-dumb divergence index.
- *
- * This metric answers: "What divergence signals (e.g., capitulation,
- * euphoria) can be found by comparing the net asset and sector flow
- * of the 'smart cohort' vs. the 'dumb cohort'?"
- *
- * It *depends* on 'smart-cohort-flow' and 'dumb-cohort-flow'.
- */
-class SmartDumbDivergenceIndex {
-    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": ["Capitulation", "Euphoria", "Confirmation (Buy)", "Confirmation (Sell)", "Divergence (Smart Buy)", "Divergence (Smart Sell)", "Neutral"]
-                },
-                "smart_flow_pct": { "type": "number" },
-                "dumb_flow_pct": { "type": "number" }
-            },
-            "required": ["status", "smart_flow_pct", "dumb_flow_pct"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Generates divergence signals by comparing net flow of 'Smart' vs. 'Dumb' cohorts, by asset and sector.",
-            "properties": {
-                "assets": {
-                    "type": "object",
-                    "description": "Divergence signals per asset.",
-                    "patternProperties": { "^.*$": signalSchema }, // Ticker
-                    "additionalProperties": signalSchema
-                },
-                "sectors": {
-                    "type": "object",
-                    "description": "Divergence signals per sector.",
-                    "patternProperties": { "^.*$": signalSchema }, // Sector
-                    "additionalProperties": signalSchema
-                }
-            },
-            "required": ["assets", "sectors"]
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'smart-cohort-flow', // Pass 3
-            'dumb-cohort-flow'   // Pass 3
-        ];
-    }
-
-    process() {
-        // No-op
-    }
-    
-    _calculateDivergence(smartFlow, dumbFlow) {
-        const result = {};
-        if (!smartFlow || !dumbFlow) {
-            return result;
-        }
-        
-        const allKeys = new Set([...Object.keys(smartFlow), ...Object.keys(dumbFlow)]);
-        const THRESHOLD = 1; // Min flow %
-
-        for (const key of allKeys) {
-            const sFlow = smartFlow[key]?.net_flow_percentage || 0;
-            const dFlow = dumbFlow[key]?.net_flow_percentage || 0;
-
-            let status = 'Neutral';
-
-            // Both buying
-            if (sFlow > THRESHOLD && dFlow > THRESHOLD) {
-                status = 'Confirmation (Buy)';
-            }
-            // Both selling
-            else if (sFlow < -THRESHOLD && dFlow < -THRESHOLD) {
-                status = 'Confirmation (Sell)';
-            }
-            // Smart buying, Dumb selling
-            else if (sFlow > THRESHOLD && dFlow < -THRESHOLD) {
-                status = 'Capitulation'; // Smart buying the dip from dumb money
-            }
-            // Smart selling, Dumb buying
-            else if (sFlow < -THRESHOLD && dFlow > THRESHOLD) {
-                status = 'Euphoria'; // Smart selling into dumb money fomo
-            }
-            // Smart buying, Dumb neutral
-            else if (sFlow > THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Buy)';
-            }
-            // Smart selling, Dumb neutral
-            else if (sFlow < -THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Sell)';
-            }
-            // Dumb buying, Smart neutral
-            else if (dFlow > THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Sell)'; // Implied smart sell
-            }
-            // Dumb selling, Smart neutral
-            else if (dFlow < -THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Buy)'; // Implied smart buy
-            }
-            
-            result[key] = {
-                status: status,
-                smart_flow_pct: sFlow,
-                dumb_flow_pct: dFlow
-            };
-        }
-        return result;
-    }
-
-    getResult(fetchedDependencies) {
-        const smartFlowData = fetchedDependencies['smart-cohort-flow'];
-        const dumbFlowData = fetchedDependencies['dumb-cohort-flow'];
-
-        const assetResult = this._calculateDivergence(smartFlowData?.assets, dumbFlowData?.assets);
-        const sectorResult = this._calculateDivergence(smartFlowData?.sectors, dumbFlowData?.sectors);
-
-        return {
-            assets: assetResult,
-            sectors: sectorResult
-        };
-    }
-
-    reset() {
-        // No state
-    }
-}
-
-module.exports = SmartDumbDivergenceIndex;

package/calculations/legacy/smart_dumb_divergence_index_v2.js

@@ -1,138 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 5) for smart-dumb divergence v2.
- *
- * This is a more advanced version that likely uses a different
- * cohort definition (e.g., 'expectancy' based) and combines more
- * signals.
- *
- * It *depends* on 'positive_expectancy_cohort_flow' and
- * 'negative_expectancy_cohort_flow'.
- */
-class SmartDumbDivergenceIndexV2 {
-    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": ["Capitulation", "Euphoria", "Confirmation (Buy)", "Confirmation (Sell)", "Divergence (Smart Buy)", "Divergence (Smart Sell)", "Neutral"]
-                },
-                "smart_flow_pct": { "type": "number" },
-                "dumb_flow_pct": { "type": "number" }
-            },
-            "required": ["status", "smart_flow_pct", "dumb_flow_pct"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Generates divergence signals (V2) by comparing net flow of 'Positive Expectancy' vs. 'Negative Expectancy' cohorts.",
-            "properties": {
-                "assets": {
-                    "type": "object",
-                    "description": "Divergence signals per asset.",
-                    "patternProperties": { "^.*$": signalSchema }, // Ticker
-                    "additionalProperties": signalSchema
-                },
-                "sectors": {
-                    "type": "object",
-                    "description": "Divergence signals per sector.",
-                    "patternProperties": { "^.*$": signalSchema }, // Sector
-                    "additionalProperties": signalSchema
-                }
-            },
-            "required": ["assets", "sectors"]
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'positive_expectancy_cohort_flow', // Pass 4
-            'negative_expectancy_cohort_flow'   // Pass 4
-        ];
-    }
-
-    process() {
-        // No-op
-    }
-    
-    _calculateDivergence(smartFlow, dumbFlow) {
-        const result = {};
-        if (!smartFlow || !dumbFlow) {
-            return result;
-        }
-        
-        const allKeys = new Set([...Object.keys(smartFlow), ...Object.keys(dumbFlow)]);
-        const THRESHOLD = 1; // Min flow %
-
-        for (const key of allKeys) {
-            // "Smart" = Positive Expectancy
-            const sFlow = smartFlow[key]?.net_flow_percentage || 0;
-            // "Dumb" = Negative Expectancy
-            const dFlow = dumbFlow[key]?.net_flow_percentage || 0;
-
-            let status = 'Neutral';
-
-            if (sFlow > THRESHOLD && dFlow > THRESHOLD) {
-                status = 'Confirmation (Buy)';
-            }
-            else if (sFlow < -THRESHOLD && dFlow < -THRESHOLD) {
-                status = 'Confirmation (Sell)';
-            }
-            else if (sFlow > THRESHOLD && dFlow < -THRESHOLD) {
-                status = 'Capitulation';
-            }
-            else if (sFlow < -THRESHOLD && dFlow > THRESHOLD) {
-                status = 'Euphoria';
-            }
-            else if (sFlow > THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Buy)';
-            }
-            else if (sFlow < -THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Sell)';
-            }
-            else if (dFlow > THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Sell)'; // Implied
-            }
-            else if (dFlow < -THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
-                status = 'Divergence (Smart Buy)'; // Implied
-            }
-            
-            result[key] = {
-                status: status,
-                smart_flow_pct: sFlow,
-                dumb_flow_pct: dFlow
-            };
-        }
-        return result;
-    }
-
-    getResult(fetchedDependencies) {
-        const smartFlowData = fetchedDependencies['positive_expectancy_cohort_flow'];
-        const dumbFlowData = fetchedDependencies['negative_expectancy_cohort_flow'];
-
-        const assetResult = this._calculateDivergence(smartFlowData?.assets, dumbFlowData?.assets);
-        const sectorResult = this._calculateDivergence(smartFlowData?.sectors, dumbFlowData?.sectors);
-
-        return {
-            assets: assetResult,
-            sectors: sectorResult
-        };
-    }
-
-    reset() {
-        // No state
-    }
-}
-
-module.exports = SmartDumbDivergenceIndexV2;

package/calculations/legacy/smart_money_flow.js

@@ -1,198 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 3) for smart money flow.
- *
- * This metric calculates the "Net Crowd Flow Percentage" for
- * "Smart Money" users, defined as users who were profitable
- * in 5 of the last 7 days.
- *
- * This calculation *depends* on 'user_profitability_tracker'
- * to identify the cohort.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class SmartMoneyFlow {
-    constructor() {
-        // This calculation only aggregates by sector
-        this.sectorData = new Map();
-        this.mappings = null;
-        this.smartMoneyUserIds = null;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Calculates net capital flow % (price-adjusted) for the 'Smart Money' cohort (profitable 5 of last 7 days), aggregated by sector.",
-            "properties": {
-                "cohort_size": {
-                    "type": "number",
-                    "description": "The number of users identified as being in the Smart Money Cohort."
-                },
-                "sectors": {
-                    "type": "object",
-                    "description": "Price-adjusted net flow per sector.",
-                    "patternProperties": {
-                        // Sector
-                        "^.*$": {
-                            "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"]
-                        }
-                    },
-                    "additionalProperties": {
-                        "type": "object",
-                        "properties": {
-                            "net_flow_percentage": { "type": "number" },
-                            "total_invested_today": { "type": "number" },
-                            "total_invested_yesterday": { "type": "number" }
-                        }
-                    }
-                }
-            },
-            "required": ["cohort_size", "sectors"]
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return ['user_profitability_tracker'];
-    }
-
-    _getPortfolioPositions(portfolio) {
-        return portfolio?.PublicPositions || portfolio?.AggregatedPositions;
-    }
-
-    _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.
-     */
-    _getSmartMoneyCohort(fetchedDependencies) {
-        if (this.smartMoneyUserIds) {
-            return this.smartMoneyUserIds;
-        }
-        
-        const profitabilityData = fetchedDependencies['user_profitability_tracker'];
-        if (!profitabilityData || !profitabilityData.user_details) {
-            return new Set();
-        }
-
-        this.smartMoneyUserIds = new Set();
-        for (const [userId, data] of Object.entries(profitabilityData.user_details)) {
-            // Definition: Profitable in 5 of the last 7 days.
-            if (data.profitable_days_7d >= 5) {
-                this.smartMoneyUserIds.add(userId);
-            }
-        }
-        return this.smartMoneyUserIds;
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        const smartMoneyCohort = this._getSmartMoneyCohort(fetchedDependencies);
-        
-        // This user is not in the "smart money cohort", skip.
-        if (!smartMoneyCohort.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;
-            
-            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);
-                sectorAsset.total_invested_yesterday += yInvested;
-                sectorAsset.price_change_yesterday += yPriceChange * yInvested;
-            }
-            if (tInvested > 0) {
-                sectorAsset.total_invested_today += tInvested;
-            }
-        }
-    }
-
-    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 smartMoneyCohort = this._getSmartMoneyCohort(fetchedDependencies);
-        
-        // Calculate Sector Flow
-        const sectorResult = {};
-        for (const [sector, data] of this.sectorData.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;
-                
-                sectorResult[sector] = {
-                    net_flow_percentage: net_flow_percentage,
-                    total_invested_today: total_invested_today,
-                    total_invested_yesterday: total_invested_yesterday
-                };
-            }
-        }
-
-        return {
-            cohort_size: smartMoneyCohort.size,
-            sectors: sectorResult
-        };
-    }
-
-    reset() {
-        this.sectorData.clear();
-        this.mappings = null;
-        this.smartMoneyUserIds = null;
-    }
-}
-
-module.exports = SmartMoneyFlow;

package/calculations/legacy/social-predictive-regime-state.js

@@ -1,102 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 5) for social predictive regime.
- *
- * This metric answers: "Are we in a 'social-driven' or 'flow-driven'
- * market regime?"
- *
- * It *depends* on 'social_flow_correlation' (Pass 4) to make
- * a determination.
- */
-class SocialPredictiveRegimeState {
-    constructor() {
-        // No per-user processing
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Determines if the market is in a 'social-driven' or 'flow-driven' regime based on correlation.",
-            "properties": {
-                "regime": {
-                    "type": "string",
-                    "enum": ["Social-Driven", "Flow-Driven", "Decoupled", "Unknown"],
-                    "description": "The current market regime."
-                },
-                "average_correlation": {
-                    "type": "number",
-                    "description": "The average correlation value across all assets from 'social_flow_correlation'."
-                },
-                "correlated_assets_count": {
-                    "type": "number",
-                    "description": "Number of assets with a strong positive correlation."
-                },
-                "decoupled_assets_count": {
-                    "type": "number",
-                    "description": "Number of assets with a weak or negative correlation."
-                }
-            },
-            "required": ["regime", "average_correlation", "correlated_assets_count", "decoupled_assets_count"]
-        };
-    }
-
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'social_flow_correlation' // Pass 4
-        ];
-    }
-
-    process() {
-        // No-op
-    }
-
-    getResult(fetchedDependencies) {
-        const correlationData = fetchedDependencies['social_flow_correlation'];
-
-        const defaults = {
-            regime: "Unknown",
-            average_correlation: 0,
-            correlated_assets_count: 0,
-            decoupled_assets_count: 0
-        };
-
-        if (!correlationData) {
-            return defaults;
-        }
-        
-        const correlations = Object.values(correlationData).map(d => d.correlation_30d).filter(c => c !== null);
-        if (correlations.length === 0) {
-            return defaults;
-        }
-
-        const avgCorrelation = correlations.reduce((a, b) => a + b, 0) / correlations.length;
-        const correlatedCount = correlations.filter(c => c > 0.5).length;
-        const decoupledCount = correlations.filter(c => c <= 0.5).length;
-        
-        let regime = "Decoupled";
-        if (avgCorrelation > 0.5 && correlatedCount > decoupledCount) {
-            regime = "Social-Driven";
-        } else if (avgCorrelation < 0.2) {
-            regime = "Flow-Driven"; // Social is not predictive, flow is
-        }
-
-        return {
-            regime: regime,
-            average_correlation: avgCorrelation,
-            correlated_assets_count: correlatedCount,
-            decoupled_assets_count: decoupledCount
-        };
-    }
-
-    reset() {
-        // No state
-    }
-}
-
-module.exports = SocialPredictiveRegimeState;