aiden-shared-calculations-unified 1.0.34 → 1.0.36

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

@@ -1,139 +1,117 @@
-/**
- * @fileoverview Meta-calculation (Pass 3) that correlates the asset/sector flow
- * of the "Smart Cohort" vs. the "Dumb Cohort" to find divergence signals.
- *
- * This identifies:
- * 1. "Capitulation": Smart cohort is buying what the dumb cohort is panic-selling.
- * 2. "Euphoria": Smart cohort is selling what the dumb cohort is FOMO-buying.
- */
-
-class SmartDumbDivergenceIndex {
-    constructor() {
-        // Minimum net flow (as a percentage) to be considered a signal
-        this.FLOW_THRESHOLD = 0.005; // Formerly 0.5
-    }
-
-    /**
-     * @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.
-     * @returns {Promise<object|null>} The analysis result or null.
-     */
-    async process(dateStr, dependencies, config) {
-        const { db, logger } = dependencies;
-        const collection = config.resultsCollection;
-        const resultsSub = config.resultsSubcollection || 'results';
-        const compsSub = config.computationsSubcollection || 'computations';
-
-        // 1. Define dependencies
-        const refsToGet = [
-            {
-                key: 'smart_flow',
-                ref: db.collection(collection).doc(dateStr).collection(resultsSub).doc('behavioural').collection(compsSub).doc('smart-cohort-flow')
-            },
-            {
-                key: 'dumb_flow',
-                ref: db.collection(collection).doc(dateStr).collection(resultsSub).doc('behavioural').collection(compsSub).doc('dumb-cohort-flow')
-            }
-        ];
-
-        // 2. Fetch
-        const snapshots = await db.getAll(...refsToGet.map(r => r.ref));
-        const smartData = snapshots[0].exists ? snapshots[0].data() : null;
-        const dumbData = snapshots[1].exists ? snapshots[1].data() : null;
-
-        // 3. Handle "day-delay"
-        // --- START MODIFICATION ---
-        // This check now catches if the dependency calcs returned null (and thus docs don't exist)
-        if (!smartData || !dumbData) {
-            logger.log('WARN', `[SmartDumbDivergence] Missing cohort flow data for ${dateStr}. Allowing backfill.`);
-            return null; // Let backfill handle it
-        }
-        
-        const results = {
-            assets: {},
-            sectors: {}
-        };
-        
-        // Check for the asset_flow key specifically.
-        const smartAssetFlow = smartData.asset_flow;
-        const dumbAssetFlow = dumbData.asset_flow;
-        const smartSectorFlow = smartData.sector_rotation;
-        const dumbSectorFlow = dumbData.sector_rotation;
-
-        // If the docs exist but the data *inside* is missing (e.g., from an old, bad run), return null.
-        if (!smartAssetFlow || !dumbAssetFlow || !smartSectorFlow || !dumbSectorFlow) {
-             logger.log('WARN', `[SmartDumbDivergence] Dependency data for ${dateStr} is incomplete (missing asset_flow or sector_rotation). Allowing backfill.`);
-            return null;
-        }
-        // --- END MODIFICATION ---
-
-
-        // 4. Correlate Assets
-        const allTickers = new Set([...Object.keys(smartAssetFlow), ...Object.keys(dumbAssetFlow)]);
-        for (const ticker of allTickers) {
-            const sFlow = smartAssetFlow[ticker]?.net_crowd_flow_pct || 0;
-            const dFlow = dumbAssetFlow[ticker]?.net_crowd_flow_pct || 0;
-
-            const smartBuys = sFlow >= this.FLOW_THRESHOLD;
-            const smartSells = sFlow <= -this.FLOW_THRESHOLD;
-            const dumbBuys = dFlow >= this.FLOW_THRESHOLD;
-            const dumbSells = dFlow <= -this.FLOW_THRESHOLD;
-
-            let status = 'No_Divergence';
-            let detail = 'Cohorts are aligned or flow is insignificant.';
-
-            if (smartBuys && dumbSells) {
-                status = 'Capitulation';
-                detail = 'Smart cohort is buying the dip from the panic-selling dumb cohort.';
-            } else if (smartSells && dumbBuys) {
-                status = 'Euphoria';
-                detail = 'Smart cohort is selling into the FOMO-buying dumb cohort.';
-            } else if (smartBuys && dumbBuys) {
-                status = 'Aligned_Buy';
-            } else if (smartSells && dumbSells) {
-                status = 'Aligned_Sell';
-            }
-
-            if (status !== 'No_Divergence') {
-                results.assets[ticker] = {
-                    status: status,
-                    detail: detail,
-                    smart_cohort_flow_pct: sFlow,
-                    dumb_cohort_flow_pct: dFlow
-                };
-            }
-        }
-        
-        // 5. Correlate Sectors (Note: flow is total $, not %)
-        // We can just check for opposing signs
-        const allSectors = new Set([...Object.keys(smartSectorFlow), ...Object.keys(dumbSectorFlow)]);
-         for (const sector of allSectors) {
-             const sFlow = smartSectorFlow[sector] || 0;
-             const dFlow = dumbSectorFlow[sector] || 0;
-
-             let status = 'No_Divergence';
-             
-             if (sFlow > 0 && dFlow < 0) {
-                 status = 'Capitulation';
-             } else if (sFlow < 0 && dFlow > 0) {
-                 status = 'Euphoria';
-             }
-
-            if (status !== 'No_Divergence') {
-                 results.sectors[sector] = {
-                    status: status,
-                    smart_cohort_flow_usd: sFlow,
-                    dumb_cohort_flow_usd: dFlow
-                };
-            }
-         }
-
-        return results;
-    }
-
-    async getResult() { return null; }
-    reset() {}
-}
-
+/**
+ * @fileoverview Meta-calculation (Pass 3) that correlates the asset/sector flow
+ * of the "Smart Cohort" vs. the "Dumb Cohort" to find divergence signals.
+ *
+ * This identifies:
+ * 1. "Capitulation": Smart cohort is buying what the dumb cohort is panic-selling.
+ * 2. "Euphoria": Smart cohort is selling what the dumb cohort is FOMO-buying.
+ */
+
+class SmartDumbDivergenceIndex {
+    constructor() {
+        // Minimum net flow (as a percentage) to be considered a signal
+        this.FLOW_THRESHOLD = 0.005; // Formerly 0.5
+    }
+
+    /**
+     * @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} computedDependencies In-memory results from previous passes.
+     * @returns {Promise<object|null>} The analysis result or null.
+     */
+    async process(dateStr, dependencies, config, computedDependencies) {
+        const { logger } = dependencies;
+
+        // 1. Get dependencies from in-memory cache
+        const smartData = computedDependencies['smart-cohort-flow'];
+        const dumbData = computedDependencies['dumb-cohort-flow'];
+        
+        // 2. Handle missing dependencies
+        if (!smartData || !dumbData) {
+            logger.log('WARN', `[SmartDumbDivergence] Missing cohort flow data dependency for ${dateStr}. Skipping.`);
+            return null;
+        }
+        
+        const results = {
+            assets: {},
+            sectors: {}
+        };
+        
+        const smartAssetFlow = smartData.asset_flow;
+        const dumbAssetFlow = dumbData.asset_flow;
+        const smartSectorFlow = smartData.sector_rotation;
+        const dumbSectorFlow = dumbData.sector_rotation;
+
+        if (!smartAssetFlow || !dumbAssetFlow || !smartSectorFlow || !dumbSectorFlow) {
+             logger.log('WARN', `[SmartDumbDivergence] Dependency data for ${dateStr} is incomplete (missing asset_flow or sector_rotation). Skipping.`);
+            return null;
+        }
+
+        // 3. Correlate Assets
+        const allTickers = new Set([...Object.keys(smartAssetFlow), ...Object.keys(dumbAssetFlow)]);
+        for (const ticker of allTickers) {
+            const sFlow = smartAssetFlow[ticker]?.net_crowd_flow_pct || 0;
+            const dFlow = dumbAssetFlow[ticker]?.net_crowd_flow_pct || 0;
+
+            const smartBuys = sFlow >= this.FLOW_THRESHOLD;
+            const smartSells = sFlow <= -this.FLOW_THRESHOLD;
+            const dumbBuys = dFlow >= this.FLOW_THRESHOLD;
+            const dumbSells = dFlow <= -this.FLOW_THRESHOLD;
+
+            let status = 'No_Divergence';
+            let detail = 'Cohorts are aligned or flow is insignificant.';
+
+            if (smartBuys && dumbSells) {
+                status = 'Capitulation';
+                detail = 'Smart cohort is buying the dip from the panic-selling dumb cohort.';
+            } else if (smartSells && dumbBuys) {
+                status = 'Euphoria';
+                detail = 'Smart cohort is selling into the FOMO-buying dumb cohort.';
+            } else if (smartBuys && dumbBuys) {
+                status = 'Aligned_Buy';
+            } else if (smartSells && dumbSells) {
+                status = 'Aligned_Sell';
+            }
+
+            if (status !== 'No_Divergence') {
+                results.assets[ticker] = {
+                    status: status,
+                    detail: detail,
+                    smart_cohort_flow_pct: sFlow,
+                    dumb_cohort_flow_pct: dFlow
+                };
+            }
+        }
+        
+        // 4. Correlate Sectors
+        const allSectors = new Set([...Object.keys(smartSectorFlow), ...Object.keys(dumbSectorFlow)]);
+         for (const sector of allSectors) {
+             const sFlow = smartSectorFlow[sector] || 0;
+             const dFlow = dumbSectorFlow[sector] || 0;
+
+             let status = 'No_Divergence';
+             
+             if (sFlow > 0 && dFlow < 0) {
+                 status = 'Capitulation';
+             } else if (sFlow < 0 && dFlow > 0) {
+                 status = 'Euphoria';
+             }
+
+            if (status !== 'No_Divergence') {
+                 results.sectors[sector] = {
+                    status: status,
+                    smart_cohort_flow_usd: sFlow,
+                    dumb_cohort_flow_usd: dFlow
+                };
+            }
+         }
+
+        return results;
+    }
+
+    async getResult() { return null; }
+    reset() {}
+}
+
 module.exports = SmartDumbDivergenceIndex;

package/calculations/meta/social_flow_correlation.js

@@ -1,126 +1,100 @@
-/**
- * @fileoverview Meta-calculation (Pass 3) to correlate daily social sentiment with
- * the actual crowd asset flow. It identifies divergences between what the crowd
- * says and what they do.
- */
-
-class SocialFlowCorrelation {
-    // REPLACE this constructor in social_flow_correlation.js
-    constructor() {
-        // Define sensitivity thresholds
-        this.bullishSentimentThreshold = 70.0; // % ratio (This is CORRECT)
-        this.bearishSentimentThreshold = 30.0; // % ratio (This is CORRECT)
-        
-        // FIX: The flow thresholds must be small decimal percentages.
-        this.positiveFlowThreshold = 0.005; // net_crowd_flow_pct (formerly 0.5)
-        this.negativeFlowThreshold = -0.005; // net_crowd_flow_pct (formerly -0.5)
-    }
-
-    /**
-     * @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.
-     * @returns {Promise<object|null>} The analysis result or null.
-     */
-    async process(dateStr, dependencies, config) {
-        const { db, logger } = dependencies;
-        const collection = config.resultsCollection;
-
-        // 1. Define dependencies for the *same day*
-        const dependenciesToFetch = [
-            { category: 'socialPosts', computation: 'social_sentiment_aggregation' },
-            { category: 'behavioural', computation: 'asset_crowd_flow' }
-        ];
-
-        // 2. Build refs and fetch
-        const refs = dependenciesToFetch.map(d =>
-            db.collection(collection).doc(dateStr)
-                .collection('results').doc(d.category)
-                .collection('computations').doc(d.computation)
-        );
-
-        const snapshots = await db.getAll(...refs);
-
-        // 3. Check for data and handle the "day-delay"
-        const socialData = snapshots[0].exists ? snapshots[0].data() : null;
-        const flowData = snapshots[1].exists ? snapshots[1].data() : null;
-
-        if (!socialData || !flowData) {
-            logger.log('WARN', `[SocialFlowCorrelation] Missing dependency data for ${dateStr}. Allowing backfill.`);
-            // Return null. This stops execution and does not save an empty doc.
-            // The Pass 3 backfill will pick this up tomorrow.
-            return null;
-        }
-
-        // 4. 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; // e.g., 85.0 or 22.5
-
-            if (typeof sentiment === 'undefined') {
-                // No sentiment found, just record flow
-                correlationResults[ticker] = {
-                    status: 'no_social_sentiment',
-                    net_crowd_flow_pct: flow
-                };
-                continue;
-            }
-
-            // --- The "Jaw-Drop" Logic ---
-            if (sentiment >= this.bullishSentimentThreshold && flow <= this.negativeFlowThreshold) {
-                // Crowd is very bullish but is actively selling
-                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) {
-                // Crowd is very bearish but is actively buying
-                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) {
-                // Crowd is bullish and is buying
-                correlationResults[ticker] = {
-                    status: 'High Conviction Buy',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            } else if (sentiment <= this.bearishSentimentThreshold && flow <= this.negativeFlowThreshold) {
-                // Crowd is bearish and is selling
-                correlationResults[ticker] = {
-                    status: 'High Conviction Sell',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            } else {
-                // No strong signal or divergence
-                correlationResults[ticker] = {
-                    status: 'No Clear Signal',
-                    sentiment_ratio: sentiment,
-                    net_crowd_flow_pct: flow
-                };
-            }
-        }
-
-        return correlationResults;
-    }
-
-    // Must exist for the meta-computation runner
-    async getResult() { return null; }
-    reset() {}
-}
-
+/**
+ * @fileoverview Meta-calculation (Pass 3) to correlate daily social sentiment with
+ * the actual crowd asset flow. It identifies divergences between what the crowd
+ * says and what they do.
+ */
+
+class SocialFlowCorrelation {
+    constructor() {
+        this.bullishSentimentThreshold = 70.0;
+        this.bearishSentimentThreshold = 30.0;
+        this.positiveFlowThreshold = 0.005;
+        this.negativeFlowThreshold = -0.005;
+    }
+
+    /**
+     * @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} computedDependencies In-memory results from previous passes.
+     * @returns {Promise<object|null>} The analysis result or null.
+     */
+    async process(dateStr, dependencies, config, computedDependencies) {
+        const { logger } = dependencies;
+
+        // 1. Get dependencies from in-memory cache
+        const socialData = computedDependencies['social-sentiment-aggregation'];
+        const flowData = computedDependencies['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;
+    }
+
+    // Must exist for the meta-computation runner
+    async getResult() { return null; }
+    reset() {}
+}
+
 module.exports = SocialFlowCorrelation;

package/calculations/pnl/asset_pnl_status.js

@@ -1,47 +1,47 @@
-/**
- * Counts the number of users in profit vs. loss for each asset (from our sample).
- * This data is used for extrapolation with the ground truth owner count.
- */
-class AssetPnlStatus {
-    constructor() {
-        this.assets = {};
-    }
-
-    _initAsset(ticker) {
-        if (!this.assets[ticker]) {
-            this.assets[ticker] = { profit_count: 0, loss_count: 0 };
-        }
-    }
-    
-    process(portfolioData, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights) {
-        const { instrumentMappings } = context;
-        const processedTickers = new Set(); // Ensure one user is only counted once per ticker
-
-        // FIX: Use the correct portfolio position properties
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions)) return;
-
-        for (const position of positions) {
-            // FIX: Use the correct PascalCase InstrumentID
-            const ticker = instrumentMappings[position.InstrumentID];
-            if (!ticker || processedTickers.has(ticker)) continue;
-
-            this._initAsset(ticker);
-
-            // FIX: Use the correct PascalCase NetProfit
-            if (position.NetProfit > 0) {
-                this.assets[ticker].profit_count++;
-            } else {
-                this.assets[ticker].loss_count++;
-            }
-            processedTickers.add(ticker);
-        }
-    }
-
-    getResult() {
-        // Returns raw counts for frontend extrapolation
-        return this.assets;
-    }
-}
-
+/**
+ * Counts the number of users in profit vs. loss for each asset (from our sample).
+ * This data is used for extrapolation with the ground truth owner count.
+ */
+class AssetPnlStatus {
+    constructor() {
+        this.assets = {};
+    }
+
+    _initAsset(ticker) {
+        if (!this.assets[ticker]) {
+            this.assets[ticker] = { profit_count: 0, loss_count: 0 };
+        }
+    }
+    
+    process(portfolioData, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights) {
+        const { instrumentMappings } = context;
+        const processedTickers = new Set(); // Ensure one user is only counted once per ticker
+
+        // FIX: Use the correct portfolio position properties
+        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) return;
+
+        for (const position of positions) {
+            // FIX: Use the correct PascalCase InstrumentID
+            const ticker = instrumentMappings[position.InstrumentID];
+            if (!ticker || processedTickers.has(ticker)) continue;
+
+            this._initAsset(ticker);
+
+            // FIX: Use the correct PascalCase NetProfit
+            if (position.NetProfit > 0) {
+                this.assets[ticker].profit_count++;
+            } else {
+                this.assets[ticker].loss_count++;
+            }
+            processedTickers.add(ticker);
+        }
+    }
+
+    getResult() {
+        // Returns raw counts for frontend extrapolation
+        return this.assets;
+    }
+}
+
 module.exports = AssetPnlStatus;