aiden-shared-calculations-unified 1.0.95 → 1.0.96

package/calculations/legacy/social_flow_correlation.js

@@ -1,112 +0,0 @@
-/**
- * @fileoverview Meta-calculation (Pass 2) to correlate daily social sentiment with
- * the actual crowd asset flow.
- *
- * --- META REFACTOR (v2) ---
- * This calculation is now stateless. It declares its dependencies and
- * expects them to be passed to its `process` method.
- */
-
-class SocialFlowCorrelation {
-
-    /**
-     * (NEW) Statically declare dependencies.
-     */
-    static getDependencies() {
-        return ['social-sentiment-aggregation', 'asset-crowd-flow'];
-    }
-    
-    constructor() {
-        this.bullishSentimentThreshold = 70.0;
-        this.bearishSentimentThreshold = 30.0;
-        this.positiveFlowThreshold = 0.005;
-        this.negativeFlowThreshold = -0.005;
-    }
-
-    /**
-     * 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., { 'social-sentiment-aggregation': ..., 'asset-crowd-flow': ... }
-     * @returns {Promise<object|null>} The analysis result or null.
-     */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
-
-        // 1. Get dependencies from in-memory cache
-        const socialData = fetchedDependencies['social-sentiment-aggregation'];
-        const flowData = fetchedDependencies['asset-crowd-flow'];
-
-        // 2. Handle missing dependencies
-        if (!socialData || !flowData) {
-            logger.log('WARN', `[SocialFlowCorrelation] Missing computed dependency data for ${dateStr}. Skipping.`);
-            return null;
-        }
-
-        // 3. If data exists, perform the correlation
-        const sentimentMap = socialData.tickerSentiment || {};
-        const correlationResults = {};
-
-        // Use all tickers from the flow data as the primary loop
-        for (const ticker in flowData) {
-            if (!flowData[ticker] || typeof flowData[ticker].net_crowd_flow_pct === 'undefined') {
-                continue;
-            }
-
-            const flow = flowData[ticker].net_crowd_flow_pct;
-            const sentiment = sentimentMap[ticker]?.sentimentRatio;
-
-            if (typeof sentiment === 'undefined') {
-                correlationResults[ticker] = {
-                    status: 'no_social_sentiment',
-                    net_crowd_flow_pct: flow
-                };
-                continue;
-            }
-
-            // --- The "Jaw-Drop" Logic ---
-            if (sentiment >= this.bullishSentimentThreshold && flow <= this.negativeFlowThreshold) {
-                correlationResults[ticker] = {
-                    status: 'Bullish Divergence',
-                    detail: 'Crowd is publicly bullish but is net-selling the asset.',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            } else if (sentiment <= this.bearishSentimentThreshold && flow >= this.positiveFlowThreshold) {
-                correlationResults[ticker] = {
-                    status: 'Bearish Divergence',
-                    detail: 'Crowd is publicly bearish but is net-buying the asset.',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            } else if (sentiment >= this.bullishSentimentThreshold && flow >= this.positiveFlowThreshold) {
-                correlationResults[ticker] = {
-                    status: 'High Conviction Buy',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            } else if (sentiment <= this.bearishSentimentThreshold && flow <= this.negativeFlowThreshold) {
-                correlationResults[ticker] = {
-                    status: 'High Conviction Sell',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            } else {
-                correlationResults[ticker] = {
-                    status: 'No Clear Signal',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            }
-        }
-
-        return correlationResults;
-    }
-
-    async getResult() { return null; }
-    reset() {}
-}
-
-module.exports = SocialFlowCorrelation;

package/calculations/legacy/speculator_adjustment_activity.js

@@ -1,103 +0,0 @@
-/**
- * @fileoverview Tracks "tinkering" activity from speculators.
- * Instead of just opening/closing, this counts how many users
- * actively *adjusted* the SL, TP, or TSL on existing trades.
- */
-class SpeculatorAdjustmentActivity {
-    constructor() {
-        // Use Sets to count unique users
-        this.sl_adjusted_users = new Set();
-        this.tp_adjusted_users = new Set();
-        this.tsl_toggled_users = new Set();
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Tracks unique speculators who 'tinkered' with open trades by adjusting SL, TP, or TSL.",
-            "properties": {
-                "unique_users_adjusted_sl": {
-                    "type": "number",
-                    "description": "Count of unique speculators who adjusted a Stop Loss on at least one position."
-                },
-                "unique_users_adjusted_tp": {
-                    "type": "number",
-                    "description": "Count of unique speculators who adjusted a Take Profit on at least one position."
-                },
-                "unique_users_toggled_tsl": {
-                    "type": "number",
-                    "description": "Count of unique speculators who enabled or disabled a Trailing Stop Loss on at least one position."
-                }
-            },
-            "required": ["unique_users_adjusted_sl", "unique_users_adjusted_tp", "unique_users_toggled_tsl"]
-        };
-    }
-
-    _getPublicPositionsMap(portfolio) {
-        const positions = portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
-        }
-        // Map<PositionID, PositionObject>
-        return new Map(positions.map(p => [p.PositionID, p]));
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        // This calculation is only for speculators
-        if (todayPortfolio?.context?.userType !== 'speculator' || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPosMap = this._getPublicPositionsMap(yesterdayPortfolio);
-        const tPosMap = this._getPublicPositionsMap(todayPortfolio);
-
-        if (yPosMap.size === 0 || tPosMap.size === 0) {
-            return; // No positions to compare
-        }
-
-        for (const [tPosId, tPos] of tPosMap.entries()) {
-            // Check if this position existed yesterday
-            if (yPosMap.has(tPosId)) {
-                const yPos = yPosMap.get(tPosId);
-
-                // 1. Check for Stop Loss adjustment
-                if (tPos.StopLossRate !== yPos.StopLossRate) {
-                    this.sl_adjusted_users.add(userId);
-                }
-
-                // 2. Check for Take Profit adjustment
-                if (tPos.TakeProfitRate !== yPos.TakeProfitRate) {
-                    this.tp_adjusted_users.add(userId);
-                }
-                
-                // 3. Check if TSL was toggled on or off
-                if (tPos.IsTslEnabled !== yPos.IsTslEnabled) {
-                    this.tsl_toggled_users.add(userId);
-                }
-            }
-        }
-    }
-
-    getResult() {
-        return {
-            // Count of unique users who adjusted at least one trade's SL
-            unique_users_adjusted_sl: this.sl_adjusted_users.size,
-            // Count of unique users who adjusted at least one trade's TP
-            unique_users_adjusted_tp: this.tp_adjusted_users.size,
-            // Count of unique users who toggled TSL on or off
-            unique_users_toggled_tsl: this.tsl_toggled_users.size
-        };
-    }
-
-    reset() {
-        this.sl_adjusted_users.clear();
-        this.tp_adjusted_users.clear();
-        this.tsl_toggled_users.clear();
-    }
-}
-
-module.exports = SpeculatorAdjustmentActivity;

package/calculations/legacy/strategy-performance.js

@@ -1,265 +0,0 @@
-/**
- * @fileoverview Backtest (Pass 5) calculation.
- * Runs a full historical simulation of a trading strategy.
- *
- * --- META REFACTOR (v2) ---
- * This calculation ignores the `fetchedDependencies` argument.
- * It runs a full historical backtest up to `dateStr` by reading
- * signal history directly from Firestore. Its dependencies in the
- * manifest are for *scheduling* only (i.e., run this last).
- */
-
-const { loadAllPriceData } = require('../../utils/price_data_provider');
-const { FieldPath } = require('@google-cloud/firestore');
-
-class StrategyPerformance {
-    
-    /**
-     * (NEW) Statically declare dependencies.
-     * These are for *ordering only* to ensure this runs in Pass 5.
-     * The `process` method does not use them.
-     */
-    static getDependencies() {
-        return ['smart-dumb-divergence-index', 'profit-cohort-divergence'];
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": ["object", "null"],
-            "description": "Result of a full historical backtest of a trading strategy. Returns null if simulation fails.",
-            "properties": {
-                "strategyName": {
-                    "type": "string",
-                    "description": "The name of the simulated strategy."
-                },
-                "inceptionDate": {
-                    "type": "string",
-                    "description": "The first date a signal was found, marking the start of the backtest."
-                },
-                "endDate": {
-                    "type": "string",
-                    "description": "The final date of the backtest simulation."
-                },
-                "finalPortfolioValue": {
-                    "type": "number",
-                    "description": "The final equity value of the portfolio at the end of the simulation."
-                },
-                "totalReturnPercent": {
-                    "type": "number",
-                    "description": "The total percentage return of the strategy from inception to end date."
-                }
-            },
-            // "required" is not needed at the top level since the whole object can be null.
-            // If the object is *not* null, we can imply these fields are required.
-            "if": {
-                "type": "object"
-            },
-            "then": {
-                "required": ["strategyName", "inceptionDate", "endDate", "finalPortfolioValue", "totalReturnPercent"]
-            }
-        };
-    }
-
-    constructor() {
-        this.INITIAL_CASH = 100000;
-        this.TRADE_SIZE_USD = 5000;
-        this.strategySignals = {
-            'smart-dumb-divergence-index': {
-                'Capitulation': 'BUY',
-                'Euphoria': 'SELL'
-            },
-            'profit_cohort_divergence': {
-                'Capitulation': 'BUY',
-                'Profit Taking': 'SELL'
-            }
-        };
-        this.priceMap = null;
-    }
-
-    async _findSignalInceptionDate(db, collection, computation, category) {
-        const snapshot = await db.collection(collection)
-            .where(`${category}.${computation}`, '==', true)
-            .orderBy(FieldPath.documentId(), 'asc')
-            .limit(1)
-            .get();
-        if (snapshot.empty) return null;
-        return snapshot.docs[0].id;
-    }
-    
-    async _fetchAllSignals(db, collection, resultsSub, compsSub, dates) {
-        const refs = [];
-        const signalMap = new Map();
-        for (const date of dates) {
-            for (const computation in this.strategySignals) {
-                const key = `${date}_${computation}`;
-                let category = 'meta'; 
-                // Determine category based on manifest (or simple rule)
-                if (computation.includes('cohort') && computation !== 'profit-cohort-divergence') category = 'behavioural'; 
-                if (computation === 'profit-cohort-divergence') category = 'meta';
-                
-                const docRef = db.collection(collection).doc(date)
-                               .collection(resultsSub).doc(category)
-                               .collection(compsSub).doc(computation);
-                refs.push({ key, ref: docRef });
-            }
-        }
-        const snapshots = await db.getAll(...refs.map(r => r.ref));
-        snapshots.forEach((snap, idx) => {
-            if (snap.exists) signalMap.set(refs[idx].key, snap.data());
-        });
-        return signalMap;
-    }
-    
-    _findInstrumentId(ticker) {
-        // This logic is flawed, as the priceMap doesn't store tickers.
-        // A proper implementation would use `loadInstrumentMappings`.
-        // For this refactor, we leave the original logic as-is.
-        for (const instrumentId in this.priceMap) {
-            const priceData = this.priceMap[instrumentId];
-            if (priceData && priceData.ticker && priceData.ticker === ticker) {
-                return instrumentId;
-            }
-        }
-        // Fallback: assume ticker is ID (will fail for string tickers)
-        if (this.priceMap[ticker]) return ticker;
-        return null;
-    }
-
-
-    /**
-     * REFACTORED PROCESS METHOD
-     * @param {string} dateStr - Today's date.
-     * @param {object} dependencies - db, logger.
-     * @param {object} config - Computation config.
-     * @param {object} fetchedDependencies - (UNUSED) In-memory results.
-     */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { db, logger, calculationUtils } = dependencies;
-        const { resultsCollection, resultsSubcollection, computationsSubcollection } = config;
-
-        // 1. Load Price Data
-        if (!this.priceMap) {
-            logger.log('INFO', '[Backtest] Loading all price data for simulation...');
-            // Use the utility from dependencies
-            this.priceMap = await calculationUtils.loadAllPriceData();
-        }
-
-        // 2. Find Backtest Start Date (by finding first-ever signal)
-        const inceptionDateStr = await this._findSignalInceptionDate(
-            db, 
-            resultsCollection, 
-            'smart-dumb-divergence-index',
-            'meta' // As defined in manifest
-        );
-        
-        if (!inceptionDateStr) {
-            logger.log('WARN', '[Backtest] No signal history found. Skipping.');
-            return null;
-        }
-
-        // 3. Build Date Range
-        const allDates = [];
-        const current = new Date(inceptionDateStr + 'T00:00:00Z');
-        const end = new Date(dateStr + 'T00:00:00Z');
-        while (current <= end) {
-            allDates.push(current.toISOString().slice(0, 10));
-            current.setUTCDate(current.getUTCDate() + 1);
-        }
-        
-        if (allDates.length < 2) {
-            logger.log('WARN', '[Backtest] Not enough history to run simulation.');
-            return null;
-        }
-
-        // 4. Fetch ALL signals for ALL dates in one go (Must use DB)
-        logger.log('INFO', `[Backtest] Fetching ${allDates.length} days of signal data...`);
-        const signalDataMap = await this._fetchAllSignals(
-            db, resultsCollection, resultsSubcollection, computationsSubcollection, allDates
-        );
-
-        // 5. --- Run the Simulation Loop ---
-        const portfolio = { cash: this.INITIAL_CASH, positions: {} };
-        const history = [];
-
-        for (const date of allDates) {
-            // A. Mark-to-Market
-            let portfolioValue = portfolio.cash;
-            for (const ticker in portfolio.positions) {
-                const pos = portfolio.positions[ticker];
-                const price = this.priceMap[pos.instrumentId]?.[date];
-                
-                if (price) {
-                    pos.marketValue = price * pos.shares;
-                    portfolioValue += pos.marketValue;
-                } else {
-                    portfolioValue += pos.marketValue; // Use last known value if price missing
-                }
-            }
-            history.push({ date, portfolioValue });
-            
-            // B. Generate trades
-            const tradesToMake = {};
-            for (const computation in this.strategySignals) {
-                const signalData = signalDataMap.get(`${date}_${computation}`);
-                if (!signalData) continue;
-                
-                const signalRules = this.strategySignals[computation];
-                const assetSignals = signalData.assets || signalData; 
-                
-                for (const ticker in assetSignals) {
-                    const signal = assetSignals[ticker]?.status;
-                    if (signalRules[signal]) {
-                        tradesToMake[ticker] = signalRules[signal];
-                    }
-                }
-            }
-
-            // C. Execute Trades
-            for (const ticker in tradesToMake) {
-                const action = tradesToMake[ticker];
-                // HACK: Use the (flawed) original logic to find ID
-                const instrumentId = this._findInstrumentId(ticker) || ticker; 
-                
-                const price = this.priceMap[instrumentId]?.[date];
-                if (!price || price <= 0) continue;
-
-                if (action === 'BUY' && portfolio.cash >= this.TRADE_SIZE_USD) {
-                    if (!portfolio.positions[ticker]) {
-                        const shares = this.TRADE_SIZE_USD / price;
-                        portfolio.cash -= this.TRADE_SIZE_USD;
-                        portfolio.positions[ticker] = {
-                            shares: shares,
-                            instrumentId: instrumentId,
-                            marketValue: this.TRADE_SIZE_USD
-                        };
-                    }
-                } else if (action === 'SELL' && portfolio.positions[ticker]) {
-                    portfolio.cash += portfolio.positions[ticker].marketValue;
-                    delete portfolio.positions[ticker];
-                }
-            }
-        } // --- End Simulation Loop ---
-
-        const finalValue = history[history.length - 1]?.portfolioValue || this.INITIAL_CASH;
-        const totalReturnPct = ((finalValue - this.INITIAL_CASH) / this.INITIAL_CASH) * 100;
-        
-        logger.log('INFO', `[Backtest] Simulation complete. Final Value: ${finalValue}, Return: ${totalReturnPct.toFixed(2)}%`);
-        
-        return {
-            strategyName: 'SmartDumbDivergence_v1',
-            inceptionDate: inceptionDateStr,
-            endDate: dateStr,
-            finalPortfolioValue: finalValue,
-            totalReturnPercent: totalReturnPct,
-        };
-    }
-
-    async getResult() { return null; }
-    reset() {}
-}
-
-module.exports = StrategyPerformance;

package/calculations/legacy/tsl_effectiveness.js

@@ -1,85 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for TSL effectiveness.
- *
- * This metric answers: "What is the difference in average
- * P&L between speculators who use a Trailing Stop Loss (TSL)
- * versus those who do not?"
- */
-class TslEffectiveness {
-    constructor() {
-        this.with_tsl = { pnl_sum: 0, count: 0 };
-        this.without_tsl = { pnl_sum: 0, count: 0 };
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Compares the average P&L of speculators who use TSL vs. those who do not.",
-            "properties": {
-                "with_tsl_avg_pnl": {
-                    "type": "number",
-                    "description": "Average P&L for positions with TSL enabled."
-                },
-                "without_tsl_avg_pnl": {
-                    "type": "number",
-                    "description": "Average P&L for positions without TSL enabled."
-                },
-                "effectiveness_delta": {
-                    "type": "number",
-                    "description": "The difference in P&L (With TSL - Without TSL)."
-                },
-                "with_tsl_count": { "type": "number" },
-                "without_tsl_count": { "type": "number" }
-            },
-            "required": ["with_tsl_avg_pnl", "without_tsl_avg_pnl", "effectiveness_delta", "with_tsl_count", "without_tsl_count"]
-        };
-    }
-
-    process(todayPortfolio, yesterdayPortfolio, userId) {
-        // This calculation is only for speculators
-        if (todayPortfolio?.context?.userType !== 'speculator') {
-            return;
-        }
-        
-        const positions = todayPortfolio.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return;
-        }
-
-        for (const pos of positions) {
-            const pnl = pos.NetProfit || 0;
-            
-            if (pos.IsTslEnabled) {
-                this.with_tsl.pnl_sum += pnl;
-                this.with_tsl.count++;
-            } else {
-                this.without_tsl.pnl_sum += pnl;
-                this.without_tsl.count++;
-            }
-        }
-    }
-
-    getResult() {
-        const with_avg = (this.with_tsl.count > 0) ? (this.with_tsl.pnl_sum / this.with_tsl.count) : 0;
-        const without_avg = (this.without_tsl.count > 0) ? (this.without_tsl.pnl_sum / this.without_tsl.count) : 0;
-        
-        return {
-            with_tsl_avg_pnl: with_avg,
-            without_tsl_avg_pnl: without_avg,
-            effectiveness_delta: with_avg - without_avg,
-            with_tsl_count: this.with_tsl.count,
-            without_tsl_count: this.without_tsl.count
-        };
-    }
-
-    reset() {
-        this.with_tsl = { pnl_sum: 0, count: 0 };
-        this.without_tsl = { pnl_sum: 0, count: 0 };
-    }
-}
-
-module.exports = TslEffectiveness;