aiden-shared-calculations-unified 1.0.18 → 1.0.19

package/calculations/backtests/strategy-performance.js

@@ -0,0 +1,246 @@
+/**
+ * @fileoverview Backtest (Pass 4) calculation.
+ * Runs a full historical simulation of a trading strategy
+ * based on meta-signals.
+ */
+
+// Note: Ensure this path is correct relative to your 'calculations' dir
+const { loadAllPriceData } = require('../../utils/price_data_provider');
+
+class StrategyPerformance {
+    constructor() {
+        this.INITIAL_CASH = 100000;
+        this.TRADE_SIZE_USD = 5000;
+        
+        // --- Strategy Configuration ---
+        // Defines which signals from which computations trigger a BUY or SELL
+        this.strategySignals = {
+            'smart-dumb-divergence-index': {
+                'Capitulation': 'BUY',
+                'Euphoria': 'SELL'
+            },
+            'profit_cohort_divergence': {
+                'Capitulation': 'BUY',
+                'Profit Taking': 'SELL'
+            }
+        };
+        // --- End Configuration ---
+        
+        this.priceMap = null;
+    }
+
+    /**
+     * Helper to find the first date a computation was stored.
+     * This determines the start date of the backtest.
+     * @param {object} db - Firestore instance
+     * @param {string} collection - resultsCollection
+     * @param {string} computation - computation name (e.g., 'smart-dumb-divergence-index')
+     * @param {string} category - computation category (e.g., 'meta')
+     * @returns {Promise<string|null>} YYYY-MM-DD string or null
+     */
+    async _findSignalInceptionDate(db, collection, computation, category) {
+        // Query for the oldest doc. This is a bit slow but runs once.
+        const snapshot = await db.collection(collection)
+            .where(`${category}.${computation}`, '==', true)
+            .orderBy(db.FieldPath.documentId(), 'asc')
+            .limit(1)
+            .get();
+            
+        if (snapshot.empty) return null;
+        return snapshot.docs[0].id;
+    }
+    
+    /**
+     * Fetches all required signals for the entire backtest period in one go.
+     */
+    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}`;
+                
+                // Dynamically find category (this is a bit brittle, but works for your structure)
+                let category = 'meta'; // default
+                if (computation.includes('cohort')) category = 'behavioural'; 
+                
+                const docRef = db.collection(collection).doc(date)
+                               .collection(resultsSub).doc(category)
+                               .collection(compsSub).doc(computation);
+                refs.push({ key, ref: docRef });
+            }
+        }
+        
+        // This will be a large db.getAll call, but it's very efficient.
+        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;
+    }
+    
+    /**
+     * Helper to find an instrument ID from a ticker.
+     * This is a simplified lookup from the priceMap.
+     */
+    _findInstrumentId(ticker) {
+        // This is inefficient, but will work. A reverse map would be faster.
+        for (const instrumentId in this.priceMap) {
+            const priceData = this.priceMap[instrumentId];
+            if (priceData && priceData.ticker && priceData.ticker === ticker) {
+                return instrumentId;
+            }
+        }
+        // Fallback for tickers that might have suffixes (e.g., from asset-crowd-flow)
+        for (const instrumentId in this.priceMap) {
+            const priceData = this.priceMap[instrumentId];
+            if (priceData && priceData.ticker && ticker.startsWith(priceData.ticker)) {
+                return instrumentId;
+            }
+        }
+        return null;
+    }
+
+
+    /**
+     * Main "meta-style" process function.
+     * @param {string} dateStr - Today's date.
+     * @param {object} dependencies - db, logger.
+     * @param {object} config - Computation config.
+     */
+    async process(dateStr, dependencies, config) {
+        const { db, logger } = dependencies;
+        const { resultsCollection, resultsSubcollection, computationsSubcollection } = config;
+
+        // 1. Load Price Data
+        if (!this.priceMap) {
+            logger.log('INFO', '[Backtest] Loading all price data for simulation...');
+            this.priceMap = await loadAllPriceData();
+        }
+
+        // 2. Find Backtest Start Date
+        // We find the oldest signal. In a real system, you'd find the *newest* of the "oldest" dates.
+        const inceptionDateStr = await this._findSignalInceptionDate(
+            db, 
+            resultsCollection, 
+            'smart-dumb-divergence-index', // Our core signal
+            'meta' // The category of this signal
+        );
+        
+        if (!inceptionDateStr) {
+            logger.log('WARN', '[Backtest] No signal history found for smart-dumb-divergence-index. Skipping.');
+            return null;
+        }
+        logger.log('INFO', `[Backtest] Found signal inception date: ${inceptionDateStr}`);
+
+        // 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
+        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: {} }; // { ticker: { shares, instrumentId, marketValue } }
+        const history = []; // To store daily portfolio value
+
+        for (const date of allDates) {
+            // A. Mark-to-Market existing positions
+            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 for *this* date
+            const tradesToMake = {}; // { 'AAPL': 'BUY', 'TSLA': 'SELL' }
+            for (const computation in this.strategySignals) {
+                const signalData = signalDataMap.get(`${date}_${computation}`);
+                if (!signalData) continue;
+                
+                const signalRules = this.strategySignals[computation];
+                // The signalData is the *entire doc* (e.g., { "AAPL": { status: "Capitulation", ... } })
+                for (const ticker in signalData) {
+                    const signal = signalData[ticker]?.status; // e.g., "Capitulation"
+                    if (signalRules[signal]) {
+                        tradesToMake[ticker] = signalRules[signal]; // 'BUY' or 'SELL'
+                    }
+                }
+            }
+
+            // C. Execute Trades
+            for (const ticker in tradesToMake) {
+                const action = tradesToMake[ticker];
+                
+                const instrumentId = this._findInstrumentId(ticker);
+                if (!instrumentId) {
+                    // logger.log('WARN', `[Backtest] No instrumentId for ${ticker}`);
+                    continue;
+                }
+                
+                const price = this.priceMap[instrumentId]?.[date];
+                if (!price || price <= 0) {
+                    // logger.log('WARN', `[Backtest] No price for ${ticker} on ${date}`);
+                    continue;
+                }
+
+                if (action === 'BUY' && portfolio.cash >= this.TRADE_SIZE_USD) {
+                    if (!portfolio.positions[ticker]) { // Only buy if not already holding
+                        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]) {
+                    // Simple: sell all
+                    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,
+            dailyHistory: history // This can be plotted on the frontend
+        };
+    }
+
+    async getResult() { return null; }
+    reset() {}
+}
+
+module.exports = StrategyPerformance;

package/package.json

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