aiden-shared-calculations-unified 1.0.78 → 1.0.80

package/calculations/core/instrument-price-change-1d.js

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Calculation (Pass 1 - Meta) for 1-day price change.
+ *
+ * This metric answers: "What is the 1-day percentage price change for
+ * every instrument, handling for market holidays/weekends?"
+ *
+ * It is a 'meta' calculation that runs once, loads all price data,
+ * and provides a reusable 1-day change signal for downstream passes
+ * like cohort-capital-flow.
+ */
+
+class InstrumentPriceChange1D {
+
+    /**
+     * Defines the output schema for this calculation.
+     */
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "price_change_1d_pct": {
+                    "type": ["number", "null"],
+                    "description": "The 1-day (business day adjusted) price change percentage."
+                }
+            },
+            "required": ["price_change_1d_pct"]
+        };
+        
+        return {
+            "type": "object",
+            "description": "Calculates the 1-day price change for all instruments.",
+            "patternProperties": {
+                "^.*$": tickerSchema // Ticker
+            },
+            "additionalProperties": tickerSchema
+        };
+    }
+
+    /**
+     * Statically defines all metadata for the manifest builder.
+     */
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: [], // Relies on price data, not root data
+            isHistorical: false, // It needs to look back 1 day, but is not 'historical' in the runner's sense
+            userType: 'n/a',
+            category: 'core_metrics' // Fits with other price/metric calcs
+        };
+    }
+
+    /**
+     * This is a Pass 1 calculation and has no dependencies.
+     */
+    static getDependencies() {
+        return [];
+    }
+    
+    // Helper to get date string N days ago
+    _getDateStr(baseDateStr, daysOffset) {
+        const date = new Date(baseDateStr + 'T00:00:00Z');
+        date.setUTCDate(date.getUTCDate() + daysOffset);
+        return date.toISOString().slice(0, 10);
+    }
+
+    /**
+     * This is a 'meta' calculation. It runs once.
+     * @param {string} dateStr - The date string 'YYYY-MM-DD'.
+     * @param {object} dependencies - The shared dependencies (e.g., logger, calculationUtils).
+     * @param {object} config - The computation system configuration.
+     * @param {object} fetchedDependencies - (Unused)
+     * @returns {Promise<object>} The calculation result.
+     */
+    async process(dateStr, dependencies, config, fetchedDependencies) {
+        const { logger, calculationUtils } = dependencies;
+        
+        // calculationUtils contains all exported functions from the /utils folder
+        const priceMap = await calculationUtils.loadAllPriceData();
+        const tickerMap = await calculationUtils.loadInstrumentMappings();
+        
+        if (!priceMap || !tickerMap || !tickerMap.instrumentToTicker) {
+            logger.log('ERROR', '[instrument-price-change-1d] Failed to load priceMap or mappings.');
+            return {};
+        }
+
+        const yesterdayStr = this._getDateStr(dateStr, -1);
+        const result = {};
+
+        for (const instrumentId in priceMap) {
+            const ticker = tickerMap.instrumentToTicker[instrumentId];
+            if (!ticker) continue; 
+
+            // Use the utility function from price_data_provider.js
+            const priceChangeDecimal = calculationUtils.getDailyPriceChange(
+                instrumentId,
+                yesterdayStr,
+                dateStr,
+                priceMap
+            );
+
+            result[ticker] = {
+                // Convert decimal (0.05) to percentage (5.0) for consistency
+                price_change_1d_pct: priceChangeDecimal !== null ? priceChangeDecimal * 100 : null
+            };
+        }
+        
+        return result;
+    }
+}
+
+module.exports = InstrumentPriceChange1D;

package/calculations/gauss/cohort-capital-flow.js

@@ -6,25 +6,36 @@
  * the price-adjusted capital flow for each cohort, per asset.
  *
  * This is the primary input for the final Pass 4 signal.
+ *
+ * --- REVISED 11/12/2025 ---
+ * - Removed dependency on 'insights' data.
+ * - Added dependency on 'instrument-price-change-1d' (Pass 1 meta calc).
+ * - Price adjustment logic now uses the reliable 1-day price change
+ * from the new dependency.
+ * --------------------------
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 
 class CohortCapitalFlow {
     constructor() {
-        // We will store: { [cohortName]: Map<instrumentId, { flow_data... }> }
+        // { [cohortName]: Map<instrumentId, { flow_data... }> }
         this.cohortFlows = new Map();
-        // This will be a lookup map: { [userId]: "cohortName" }
+        // { [userId]: "cohortName" }
         this.cohortMap = new Map();
         this.mappings = null;
         this.dependenciesLoaded = false;
+        
+        // --- NEW ---
+        // This will store the { [ticker]: { price_change_1d_pct: 5.5 } } map
+        this.priceChangeMap = null; 
     }
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
+        // ... (Schema remains unchanged) ...
         const flowSchema = {
             "type": "object",
             "properties": {
@@ -57,7 +68,9 @@ class CohortCapitalFlow {
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'],
+            // --- REVISED ---
+            // Removed 'insights' as it's no longer needed for price.
+            rootDataDependencies: ['portfolio', 'history'],
             isHistorical: true, // Needs T-1 portfolio for flow
             userType: 'all',
             category: 'gauss'
@@ -69,12 +82,13 @@ class CohortCapitalFlow {
      */
     static getDependencies() {
         return [
-            'cohort-definer' // from gauss (Pass 2)
+            'cohort-definer', // from gauss (Pass 2)
+            // --- REVISED ---
+            'instrument-price-change-1d' // from core (Pass 1)
         ];
     }
 
     _getPortfolioPositions(portfolio) {
-        // We MUST use AggregatedPositions for this to get 'Invested' (portfolio percentage)
         return portfolio?.AggregatedPositions;
     }
 
@@ -86,7 +100,7 @@ class CohortCapitalFlow {
             this.cohortFlows.get(cohortName).set(instrumentId, {
                 total_invested_yesterday: 0,
                 total_invested_today: 0,
-                price_change_yesterday: 0, // This is a weighted sum
+                price_change_yesterday: 0, // Weighted sum
             });
         }
     }
@@ -97,14 +111,22 @@ class CohortCapitalFlow {
     _loadDependencies(fetchedDependencies) {
         if (this.dependenciesLoaded) return;
         
+        // 1. Load Cohort Definitions
         const cohortData = fetchedDependencies['cohort-definer'];
         if (cohortData) {
             for (const [cohortName, userIds] of Object.entries(cohortData)) {
-                for (const userId of userIds) {
-                    this.cohortMap.set(userId, cohortName);
+                if (Array.isArray(userIds)) {
+                    for (const userId of userIds) {
+                        this.cohortMap.set(userId, cohortName);
+                    }
                 }
             }
         }
+        
+        // 2. Load Price Change Data
+        // --- REVISED ---
+        this.priceChangeMap = fetchedDependencies['instrument-price-change-1d'] || {};
+
         this.dependenciesLoaded = true;
     }
 
@@ -117,7 +139,7 @@ class CohortCapitalFlow {
 
         const cohortName = this.cohortMap.get(userId);
         if (!cohortName) {
-            return; // This user is not in one of our defined cohorts, skip.
+            return; // Not in a defined cohort, skip.
         }
         
         if (!todayPortfolio || !yesterdayPortfolio) {
@@ -127,9 +149,14 @@ class CohortCapitalFlow {
         const yPos = this._getPortfolioPositions(yesterdayPortfolio);
         const tPos = this._getPortfolioPositions(todayPortfolio);
 
-        // We must have AggregatedPositions for both days to do this calculation
         if (!yPos || !tPos) {
-            return;
+            return; // Must have AggregatedPositions for both days
+        }
+        
+        // --- REVISED ---
+        // We no longer need insightsMap
+        if (!this.priceChangeMap) {
+            return; // Cannot calculate price-adjusted flow
         }
 
         const yPosMap = new Map(yPos.map(p => [p.InstrumentID, p]));
@@ -145,15 +172,23 @@ class CohortCapitalFlow {
             const yP = yPosMap.get(instrumentId);
             const tP = tPosMap.get(instrumentId);
             
-            // 'Invested' is the portfolio percentage (e.g., 5.0 = 5%)
             const yInvested = yP?.Invested || 0; 
             const tInvested = tP?.Invested || 0;
 
             if (yInvested > 0) {
                 asset.total_invested_yesterday += yInvested;
-                // 'NetProfit' here is actually the 1-day P&L *as a percentage* (e.g., 0.1 for +10%)
-                const yPriceChange = (yP?.NetProfit || 0); 
-                asset.price_change_yesterday += yPriceChange * yInvested; // Weighted sum
+                
+                // --- REVISED ---
+                // Get the 1-day price change from our new dependency
+                const ticker = this.mappings.instrumentToTicker[instrumentId];
+                const yPriceChange_pct = (ticker && this.priceChangeMap[ticker]) 
+                                            ? this.priceChangeMap[ticker].price_change_1d_pct 
+                                            : 0;
+                
+                // Convert from percentage (5.5) to decimal (0.055)
+                const yPriceChange_decimal = (yPriceChange_pct || 0) / 100.0;
+                
+                asset.price_change_yesterday += yPriceChange_decimal * yInvested; // Weighted sum
             }
             if (tInvested > 0) {
                 asset.total_invested_today += tInvested;
@@ -169,6 +204,7 @@ class CohortCapitalFlow {
         const finalResult = {};
 
         for (const [cohortName, assetMap] of this.cohortFlows.entries()) {
+            // --- REVISED: Initialize cohortAssets as an object ---
             const cohortAssets = {};
             for (const [instrumentId, data] of assetMap.entries()) {
                 const ticker = this.mappings.instrumentToTicker[instrumentId];
@@ -177,32 +213,32 @@ class CohortCapitalFlow {
                 const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
                 
                 if (total_invested_yesterday > 0) {
-                    // 1. Find the weighted average price change for this cohort/asset
-                    // e.g., (0.1 * 5.0 + 0.05 * 2.0) / (5.0 + 2.0)
-                    const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
-                    
-                    // 2. Estimate yesterday's value *after* price change
-                    // (This is what the value *would be* if no one bought or sold)
-                    const price_adjusted_yesterday_value = total_invested_yesterday * (1 + avg_price_change_pct);
-
-                    // 3. The difference between today's value and the price-adjusted
-                    // value is the *net capital flow*.
+                    const avg_price_change_decimal = price_change_yesterday / total_invested_yesterday;
+                    const price_adjusted_yesterday_value = total_invested_yesterday * (1 + avg_price_change_decimal);
                     const flow_contribution = total_invested_today - price_adjusted_yesterday_value;
-
-                    // 4. Normalize the flow as a percentage of yesterday's capital
                     const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
                     
                     if (isFinite(net_flow_percentage) && isFinite(flow_contribution)) {
                         cohortAssets[ticker] = {
                             net_flow_percentage: net_flow_percentage,
-                            net_flow_contribution: flow_contribution // This is the %-point flow
+                            net_flow_contribution: flow_contribution
                         };
                     }
+                } else if (total_invested_today > 0) {
+                    cohortAssets[ticker] = {
+                        net_flow_percentage: Infinity, // Represents pure inflow
+                        net_flow_contribution: total_invested_today
+                    };
                 }
             }
+            // --- REVISED: Match schema { "cohortName": { "assets": { ... } } } ---
+            // This was a bug in your original file. The schema expected an object
+            // with an 'assets' key, but the code was returning the map directly.
             finalResult[cohortName] = { assets: cohortAssets };
         }
-        // Output is compact and not sharded
+        
+        // --- REVISED: The schema for this calc shows the output is NOT sharded. ---
+        // The return should be the final object.
         return finalResult;
     }
 
@@ -211,6 +247,8 @@ class CohortCapitalFlow {
         this.cohortMap.clear();
         this.mappings = null;
         this.dependenciesLoaded = false;
+        // --- NEW ---
+        this.priceChangeMap = null;
     }
 }
 

package/calculations/gauss/cohort-definer.js

@@ -10,6 +10,7 @@
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
+
 class CohortDefiner {
     constructor() {
         // We will store the full DNA for our filtered cohorts
@@ -58,7 +59,10 @@ class CohortDefiner {
                 "smart_scalpers": cohortSchema,
                 "fomo_chasers": cohortSchema,
                 "patient_losers": cohortSchema,
-                "fomo_bagholders": cohortSchema
+                "fomo_bagholders": cohortSchema,
+                // --- FIX [PROBLEM 9]: Add uncategorized bucket ---
+                "uncategorized_smart": cohortSchema,
+                "uncategorized_dumb": cohortSchema
             },
             "additionalProperties": cohortSchema
         };
@@ -73,14 +77,29 @@ class CohortDefiner {
         const dnaFilterData = fetchedDependencies['daily-dna-filter'];
         this.momentumData = fetchedDependencies['instrument-price-momentum-20d'];
         
-        this.cohortIdSets = {
-            smart: new Set(dnaFilterData?.smart_cohort_ids || []),
-            dumb: new Set(dnaFilterData?.dumb_cohort_ids || [])
-        };
+        // --- FIX [PROBLEM 6]: Validate dependency content, not just existence ---
+        if (dnaFilterData && dnaFilterData.smart_cohort_ids && dnaFilterData.dumb_cohort_ids) {
+            this.cohortIdSets = {
+                smart: new Set(dnaFilterData.smart_cohort_ids),
+                dumb: new Set(dnaFilterData.dumb_cohort_ids)
+            };
+        } else {
+            // Initialize with empty sets if dependency is missing or malformed
+            this.cohortIdSets = {
+                smart: new Set(),
+                dumb: new Set()
+            };
+        }
     }
 
     _getFomoScore(todayPortfolio, yesterdayPortfolio) {
         if (!this.mappings) return 0;
+        
+        // --- FIX [PROBLEM 4 related]: Ensure momentum data is loaded ---
+        if (!this.momentumData) {
+            return 0; // Cannot calculate FOMO without momentum data
+        }
+
         const yIds = new Set((yesterdayPortfolio?.AggregatedPositions || []).map(p => p.InstrumentID));
         const newPositions = (todayPortfolio?.AggregatedPositions || []).filter(p => p.InstrumentID && !yIds.has(p.InstrumentID));
         if (newPositions.length === 0) return 0;
@@ -89,6 +108,7 @@ class CohortDefiner {
         let count = 0;
         for (const pos of newPositions) {
             const ticker = this.mappings.instrumentToTicker[pos.InstrumentID];
+            // --- FIX [PROBLEM 4 related]: Check momentumData[ticker] exists ---
             if (ticker && this.momentumData[ticker]) {
                 fomoSum += this.momentumData[ticker].momentum_20d_pct || 0;
                 count++;
@@ -165,19 +185,32 @@ class CohortDefiner {
         if (vectors.length === 0) return 0;
         const sorted = vectors.map(v => v[key]).sort((a, b) => a - b);
         const mid = Math.floor(sorted.length / 2);
+        // Handle even-length array by taking average of middle two
+        if (sorted.length % 2 === 0 && sorted.length > 0) {
+            return (sorted[mid - 1] + sorted[mid]) / 2;
+        }
         return sorted[mid];
     }
 
     getResult() {
         const cohorts = {};
+        const assignedSmart = new Set();
+        const assignedDumb = new Set();
 
         // 1. Process Smart Cohort
         const smart_median_time = this._getMedian(this.smartVectors, 'time');
+        
         cohorts['smart_investors'] = this.smartVectors
             .filter(u => u.time >= smart_median_time)
-            .map(u => u.userId);
+            .map(u => { assignedSmart.add(u.userId); return u.userId; });
+            
         cohorts['smart_scalpers'] = this.smartVectors
             .filter(u => u.time < smart_median_time)
+            .map(u => { assignedSmart.add(u.userId); return u.userId; });
+            
+        // --- FIX [PROBLEM 9]: Add uncategorized bucket ---
+        cohorts['uncategorized_smart'] = this.smartVectors
+            .filter(u => !assignedSmart.has(u.userId))
             .map(u => u.userId);
             
         // 2. Process Dumb Cohort
@@ -186,14 +219,19 @@ class CohortDefiner {
 
         cohorts['fomo_chasers'] = this.dumbVectors
             .filter(u => u.fomo >= dumb_median_fomo && u.bagholder < dumb_median_bag)
-            .map(u => u.userId);
+            .map(u => { assignedDumb.add(u.userId); return u.userId; });
         
         cohorts['patient_losers'] = this.dumbVectors
             .filter(u => u.fomo < dumb_median_fomo && u.bagholder >= dumb_median_bag)
-            .map(u => u.userId);
+            .map(u => { assignedDumb.add(u.userId); return u.userId; });
 
         cohorts['fomo_bagholders'] = this.dumbVectors
             .filter(u => u.fomo >= dumb_median_fomo && u.bagholder >= dumb_median_bag)
+            .map(u => { assignedDumb.add(u.userId); return u.userId; });
+
+        // --- FIX [PROBLEM 9]: Add uncategorized bucket ---
+        cohorts['uncategorized_dumb'] = this.dumbVectors
+            .filter(u => !assignedDumb.has(u.userId))
             .map(u => u.userId);
 
         // Output is a compact map of cohort_name -> [userIds]

package/calculations/gauss/gauss-divergence-signal.js

@@ -94,20 +94,20 @@ class GaussDivergenceSignal {
             return {};
         }
 
-        // Define which cohorts are "Smart" and which are "Dumb"
-        // These names must match the keys from Pass 2
         const SMART_COHORTS = ['smart_investors', 'smart_scalpers'];
         const DUMB_COHORTS = ['fomo_chasers', 'patient_losers', 'fomo_bagholders'];
         
         const blendedFlows = new Map(); // Map<ticker, { smart: 0, dumb: 0 }>
 
-        // 1. Blend all cohort flows into two buckets
+        // 1. Blend all cohort flows
         for (const cohortName in cohortFlows) {
             const isSmart = SMART_COHORTS.includes(cohortName);
             const isDumb = DUMB_COHORTS.includes(cohortName);
             if (!isSmart && !isDumb) continue;
 
-            const assets = cohortFlows[cohortName]?.assets;
+            // --- REVISED ---
+            // Read from the 'assets' property, which contains the map of tickers
+            const assets = cohortFlows[cohortName]?.assets; 
             if (!assets) continue;
             
             for (const [ticker, data] of Object.entries(assets)) {
@@ -115,7 +115,6 @@ class GaussDivergenceSignal {
                     blendedFlows.set(ticker, { smart: 0, dumb: 0 });
                 }
                 
-                // Use net_flow_contribution, which is the %-point flow
                 const flow = data.net_flow_contribution || 0; 
                 
                 if (isSmart) {
@@ -126,20 +125,14 @@ class GaussDivergenceSignal {
             }
         }
 
-        // 2. Calculate final signal
+        // 2. Calculate final signal (logic unchanged)
         const result = {};
         for (const [ticker, data] of blendedFlows.entries()) {
-        
-            // The core signal is the divergence: (Smart Flow - Dumb Flow)
-            // If Smart buys (+1) and Dumb sells (-1), score is +2.
-            // If Smart sells (-1) and Dumb buys (+1), score is -2.
             const divergence = data.smart - data.dumb;
-            
-            // Normalize the score to a -10 to +10 range
             const gauss_score = this._normalize(divergence);
             
             let signal = "Neutral";
-            if (gauss_score > 7.0) signal = "Strong Buy";  // e.g., > 1.5% net divergence
+            if (gauss_score > 7.0) signal = "Strong Buy";
             else if (gauss_score > 2.0) signal = "Buy";
             else if (gauss_score < -7.0) signal = "Strong Sell";
             else if (gauss_score < -2.0) signal = "Sell";
@@ -152,7 +145,6 @@ class GaussDivergenceSignal {
             };
         }
         
-        // Final output is compact and non-sharded.
         return result;
     }
 }

package/package.json

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