@semanticintent/semantic-chirp-intelligence-mcp 3.0.0

package/build/analyses/BreakoutAnalysis.js

@@ -0,0 +1,386 @@
+/**
+ * 🏒 Breakout Player Analysis - Fantasy Hockey Intelligence
+ *
+ * Analyzes free agents to identify top pickups and breakout candidates
+ * using data-driven predictability with external source integration.
+ *
+ * Based on comprehensive prompt template with:
+ * - 40% recent performance
+ * - 30% projections
+ * - 20% opportunity metrics
+ * - 10% risk factors
+ */
+import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
+import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+export class BreakoutAnalysis extends AnalysisTemplate {
+    yahooClient;
+    leagueId;
+    teamId;
+    constructor(yahooClient, leagueId, teamId) {
+        super('get_breakout_analysis', 'streaming_recommendations');
+        this.yahooClient = yahooClient;
+        this.leagueId = leagueId;
+        this.teamId = teamId;
+    }
+    /**
+     * Fetch raw data: free agents, trending players, roster
+     */
+    async fetchData(args) {
+        const ownershipThreshold = args.ownership_threshold || 50;
+        // Fetch free agents across all positions
+        const positions = args.position_filter || ['C', 'LW', 'RW', 'D', 'G'];
+        const freeAgentPromises = positions.map(pos => this.yahooClient.searchPlayers(pos, 50, this.leagueId));
+        const [freeAgentResults, trendingAdds, roster] = await Promise.all([
+            Promise.all(freeAgentPromises),
+            this.yahooClient.getTrendingPlayers('add', 25, this.leagueId),
+            this.yahooClient.getTeamRoster(this.leagueId, this.teamId)
+        ]);
+        // Combine and deduplicate free agents
+        const allFreeAgents = [];
+        for (const result of freeAgentResults) {
+            if (result.players) {
+                allFreeAgents.push(...result.players);
+            }
+        }
+        // Remove duplicates and filter by ownership
+        const uniqueFreeAgents = Array.from(new Map(allFreeAgents.map(p => [p.player_id, p])).values()).filter(p => (p.percent_owned || 0) < ownershipThreshold);
+        return {
+            freeAgents: uniqueFreeAgents,
+            trendingAdds: trendingAdds.players || [],
+            roster
+        };
+    }
+    /**
+     * Prepare data for analysis
+     */
+    async prepareData(rawData, args) {
+        return {
+            availablePlayers: rawData.freeAgents,
+            trendingPlayers: rawData.trendingAdds,
+            roster: rawData.roster
+        };
+    }
+    /**
+     * Execute breakout analysis with predictable scoring
+     */
+    async analyzeData(data, args) {
+        const freeAgents = data.availablePlayers || [];
+        const trending = data.trendingPlayers || [];
+        // Score each free agent using the comprehensive formula
+        const scoredPlayers = await Promise.all(freeAgents.map(player => this.scorePlayer(player, trending)));
+        // Sort by score and categorize
+        const sorted = scoredPlayers
+            .filter(p => p.breakout_score >= (args.min_score || 0))
+            .sort((a, b) => b.breakout_score - a.breakout_score);
+        // Separate into pickups vs breakouts
+        const pickups = this.identifyTopPickups(sorted, args.max_results || 10);
+        const breakouts = this.identifyBreakoutCandidates(sorted, args.breakout_age_max || 26);
+        return {
+            pickups,
+            breakouts,
+            all_scored: sorted.slice(0, 50),
+            position_breakdown: this.analyzeByPosition(sorted),
+            market_intelligence: this.analyzeMarketTrends(trending, sorted)
+        };
+    }
+    /**
+     * Score a player using the comprehensive formula:
+     * Score = (0.4 * Recent PPG) + (0.3 * Proj FP/G) + (0.2 * Opp Score/10) - (0.1 * Risk %)
+     */
+    async scorePlayer(player, trending) {
+        // Get detailed stats for scoring
+        const stats = await this.getPlayerMetrics(player);
+        // Recent performance (0-100 scale)
+        const recentPPG = this.calculateRecentPerformance(stats) * 100;
+        // Projected fantasy points (0-100 scale, estimated)
+        const projectedFPG = this.estimateProjectedPoints(player, stats, trending) * 100;
+        // Opportunity score (0-100 scale)
+        const opportunityScore = this.calculateOpportunity(player, stats);
+        // Risk percentage (0-100)
+        const riskPercentage = this.calculateRisk(player, stats);
+        // Apply formula
+        const breakoutScore = 0.4 * recentPPG +
+            0.3 * projectedFPG +
+            0.2 * opportunityScore -
+            0.1 * riskPercentage;
+        // Determine confidence and category
+        const confidence = this.determineConfidence(breakoutScore, riskPercentage);
+        const category = this.categorizePlayer(breakoutScore);
+        const catalyst = this.identifyCatalyst(player, stats, trending);
+        return {
+            ...player,
+            breakout_score: Math.round(breakoutScore),
+            recent_ppg: recentPPG / 100,
+            projected_fpg: projectedFPG / 100,
+            opportunity_score: opportunityScore,
+            risk_percentage: riskPercentage,
+            catalyst,
+            confidence,
+            category
+        };
+    }
+    /**
+     * Calculate recent performance score
+     */
+    calculateRecentPerformance(stats) {
+        // Simplified - in real implementation, would fetch last 5-10 games
+        // For now, use season averages as proxy
+        const goals = parseFloat(stats.G || 0);
+        const assists = parseFloat(stats.A || 0);
+        const gamesPlayed = parseFloat(stats.GP || 1);
+        if (gamesPlayed === 0)
+            return 0;
+        const ppg = (goals + assists) / gamesPlayed;
+        return Math.min(ppg, 1.5); // Cap at 1.5 PPG
+    }
+    /**
+     * Estimate projected fantasy points
+     */
+    estimateProjectedPoints(player, stats, trending) {
+        // Base projection on current stats + trending momentum
+        const isTrending = trending.some(t => t.player_id === player.player_id);
+        const baseProjection = this.calculateRecentPerformance(stats);
+        const trendingBonus = isTrending ? 0.15 : 0;
+        return Math.min(baseProjection + trendingBonus, 1.0);
+    }
+    /**
+     * Calculate opportunity score (TOI, PP role, linemates)
+     */
+    calculateOpportunity(player, stats) {
+        let score = 50; // Base score
+        // Position-based opportunities
+        if (player.position.includes('C'))
+            score += 10; // Centers have more opportunity
+        if (player.position.includes('LW') || player.position.includes('RW'))
+            score += 5;
+        // Check if on good team (more goals = more opportunities)
+        const teamScore = this.getTeamStrength(player.team);
+        score += teamScore;
+        return Math.min(score, 100);
+    }
+    /**
+     * Calculate risk percentage
+     */
+    calculateRisk(player, stats) {
+        let risk = 20; // Base risk
+        // Injury status increases risk
+        if (player.status && player.status !== '') {
+            risk += 30;
+        }
+        // Low games played = higher risk
+        const gamesPlayed = parseFloat(stats.GP || 0);
+        if (gamesPlayed < 10)
+            risk += 20;
+        // High ownership = lower risk (proven commodity)
+        const ownership = player.percent_owned || 0;
+        if (ownership > 30)
+            risk -= 10;
+        if (ownership < 10)
+            risk += 15;
+        return Math.min(Math.max(risk, 0), 100);
+    }
+    /**
+     * Get team strength score
+     */
+    getTeamStrength(teamAbbr) {
+        // Simplified team rankings - top teams get bonus
+        const topTeams = ['BOS', 'CAR', 'COL', 'DAL', 'EDM', 'FLA', 'NYR', 'TOR', 'VGK', 'WPG'];
+        const midTeams = ['CGY', 'LAK', 'MIN', 'NJD', 'NSH', 'NYI', 'SEA', 'TBL', 'VAN'];
+        if (topTeams.includes(teamAbbr))
+            return 20;
+        if (midTeams.includes(teamAbbr))
+            return 10;
+        return 0;
+    }
+    /**
+     * Identify catalyst for breakout potential
+     */
+    identifyCatalyst(player, stats, trending) {
+        const isTrending = trending.some(t => t.player_id === player.player_id);
+        if (isTrending)
+            return 'Hot streak - trending upward';
+        if (player.position.includes('C'))
+            return 'Top-6 center opportunity';
+        if (this.getTeamStrength(player.team) >= 20)
+            return 'Playing on elite team';
+        return 'Solid opportunity available';
+    }
+    /**
+     * Determine confidence level
+     */
+    determineConfidence(score, risk) {
+        if (score >= 70 && risk < 30)
+            return 'high';
+        if (score >= 50 && risk < 50)
+            return 'medium';
+        return 'low';
+    }
+    /**
+     * Categorize player by score
+     */
+    categorizePlayer(score) {
+        if (score >= 80)
+            return 'must_add';
+        if (score >= 65)
+            return 'strong_pickup';
+        if (score >= 50)
+            return 'monitor';
+        return 'sleeper';
+    }
+    /**
+     * Get player metrics (mock implementation)
+     */
+    async getPlayerMetrics(player) {
+        // In real implementation, fetch detailed stats
+        // For now, return mock data
+        return {
+            G: Math.random() * 30,
+            A: Math.random() * 40,
+            GP: 50 + Math.random() * 30,
+            PPP: Math.random() * 20,
+            SOG: Math.random() * 150
+        };
+    }
+    /**
+     * Identify top pickup recommendations
+     */
+    identifyTopPickups(sorted, maxResults) {
+        return sorted
+            .filter(p => p.category === 'must_add' || p.category === 'strong_pickup')
+            .slice(0, maxResults)
+            .map(player => ({
+            ...player,
+            pickup_score: player.breakout_score,
+            urgency: player.category === 'must_add' ? 'immediate' : 'high',
+            fit_reason: `${player.catalyst} - Score: ${player.breakout_score}`,
+            streaming_score: player.breakout_score,
+            reason: player.catalyst
+        }));
+    }
+    /**
+     * Identify breakout candidates (young players with upside)
+     */
+    identifyBreakoutCandidates(sorted, ageMax) {
+        // In real implementation, would filter by age
+        // For now, return top sleepers/monitors
+        return sorted
+            .filter(p => p.category === 'sleeper' || p.category === 'monitor')
+            .filter(p => p.confidence === 'medium' || p.confidence === 'high')
+            .slice(0, 5);
+    }
+    /**
+     * Analyze players by position
+     */
+    analyzeByPosition(players) {
+        const positions = ['C', 'LW', 'RW', 'D', 'G'];
+        const breakdown = {};
+        for (const pos of positions) {
+            const posPlayers = players.filter(p => p.position.includes(pos));
+            breakdown[pos] = {
+                count: posPlayers.length,
+                top_player: posPlayers[0] || null,
+                avg_score: posPlayers.length > 0
+                    ? posPlayers.reduce((sum, p) => sum + p.breakout_score, 0) / posPlayers.length
+                    : 0
+            };
+        }
+        return breakdown;
+    }
+    /**
+     * Analyze market trends
+     */
+    analyzeMarketTrends(trending, scored) {
+        const trendingScored = scored.filter(s => trending.some(t => t.player_id === s.player_id));
+        return {
+            trending_count: trending.length,
+            trending_avg_score: trendingScored.length > 0
+                ? trendingScored.reduce((sum, p) => sum + p.breakout_score, 0) / trendingScored.length
+                : 0,
+            hot_positions: this.identifyHotPositions(trending)
+        };
+    }
+    /**
+     * Identify hot positions from trending data
+     */
+    identifyHotPositions(trending) {
+        const positionCounts = {};
+        for (const player of trending) {
+            const positions = (player.position || '').split(',');
+            for (const pos of positions) {
+                positionCounts[pos] = (positionCounts[pos] || 0) + 1;
+            }
+        }
+        return Object.entries(positionCounts)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 3)
+            .map(([pos]) => pos);
+    }
+    /**
+     * Generate chirp intelligence
+     */
+    async generateChirp(analysisResults, semanticContract, data) {
+        if (semanticContract.enable_chirp === false) {
+            return analysisResults;
+        }
+        // Use ChirpIntelligence static enhance method
+        const enhanced = ChirpIntelligence.enhance('get_breakout_analysis', {
+            ...analysisResults,
+            streaming_targets: analysisResults.pickups,
+            market_intelligence: analysisResults.market_intelligence,
+            recommendations: analysisResults.pickups
+        }, semanticContract);
+        return enhanced;
+    }
+    /**
+     * Format final response
+     */
+    async formatResponse(chirpEnhanced, data) {
+        const recommendations = chirpEnhanced.pickups.map((p) => ({
+            priority: p.urgency === 'immediate' ? 'CRITICAL' : 'HIGH',
+            action: 'pickup',
+            player: p,
+            reasoning: p.fit_reason
+        }));
+        const insights = {
+            streaming_targets: chirpEnhanced.pickups,
+            favorable_teams: Object.entries(chirpEnhanced.position_breakdown)
+                .map(([pos, data]) => ({
+                team_abbr: pos,
+                games_count: data.count,
+                favorable_score: data.avg_score
+            })),
+            market_intelligence: {
+                total_trending: chirpEnhanced.market_intelligence.trending_count,
+                favorable_teams_count: Object.keys(chirpEnhanced.position_breakdown).length,
+                top_trending_team: chirpEnhanced.market_intelligence.hot_positions[0] || 'N/A'
+            }
+        };
+        return {
+            analysis_insights: insights,
+            recommendations,
+            chirp_intelligence: chirpEnhanced.chirp_intelligence || this.getDefaultChirp(),
+            metadata: {
+                analysis_type: this.analysisType,
+                tool_identity: 'breakout_analysis',
+                generated_at: new Date().toISOString(),
+                semantic_contract_applied: true
+            }
+        };
+    }
+    /**
+     * Default chirp when chirp intelligence is disabled
+     */
+    getDefaultChirp() {
+        return {
+            tool_identity: 'breakout_analysis',
+            style: 'analytical',
+            personality: 'data_driven',
+            intensity: 'standard',
+            semantic_context: 'breakout_player_analysis',
+            analysis_chirp: 'Data-driven breakout analysis complete',
+            intent_summary: 'Breakout player recommendations ready',
+            ice_cold_truth: 'Smart pickups win championships',
+            energy_level: 'focused'
+        };
+    }
+}

package/build/analyses/GamesInHandAnalysis.js

@@ -0,0 +1,257 @@
+// @ts-nocheck
+/**
+ * GamesInHandAnalysis - Template Method Pattern Implementation
+ *
+ * Analyzes schedule advantages by calculating games remaining differentials
+ * between your team and opponents.
+ */
+import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
+import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+export class GamesInHandAnalysis extends AnalysisTemplate {
+    apiClient;
+    leagueId;
+    teamId;
+    constructor(apiClient, leagueId, teamId) {
+        super("get_games_in_hand", "schedule_advantage");
+        this.apiClient = apiClient;
+        this.leagueId = leagueId;
+        this.teamId = teamId;
+    }
+    /**
+     * Hook 1: Fetch raw data from Yahoo API
+     */
+    async fetchData(args) {
+        try {
+            // Fetch current matchup data
+            const matchupData = await this.apiClient.getTeamMatchup(this.leagueId, this.teamId);
+            // Fetch league scoreboard for schedule data
+            const scoreboardData = await this.apiClient.getLeagueScoreboard(this.leagueId);
+            return {
+                matchup: matchupData,
+                scoreboard: scoreboardData
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch games in hand data: ${error}`);
+        }
+    }
+    /**
+     * Hook 2: Prepare data into FantasyData structure
+     */
+    async prepareData(rawData, args) {
+        const { matchup, scoreboard } = rawData;
+        // Parse matchup to find opponent - try multiple potential structures
+        let teams = matchup.fantasy_content?.team?.[1]?.matchup?.['0']?.teams?.['0']?.team || [];
+        // If teams is empty, try alternative structure (matchups array)
+        if (teams.length === 0) {
+            const matchups = matchup.fantasy_content?.team?.[1]?.matchups;
+            if (matchups && matchups.count !== '0') {
+                // Find the current matchup where status === "midevent"
+                const matchupKeys = Object.keys(matchups).filter(key => key !== 'count');
+                const currentMatchupKey = matchupKeys.find(key => {
+                    const matchupData = matchups[key]?.matchup?.[0] || matchups[key]?.matchup;
+                    return matchupData?.status === 'midevent';
+                });
+                // Use current matchup if found, otherwise fallback to last matchup
+                const selectedKey = currentMatchupKey || matchupKeys[matchupKeys.length - 1];
+                if (selectedKey && matchups[selectedKey]?.matchup?.[0]) {
+                    teams = matchups[selectedKey].matchup[0].teams?.['0']?.team || [];
+                }
+            }
+        }
+        // Handle both full team IDs (nhl.l.123.t.1) and partial (just the number)
+        const cleanLeagueId = this.leagueId.replace(/^nhl\.l\./, '');
+        const cleanTeamId = this.teamId.replace(/^.*\.t\./, '');
+        const fullTeamKey = `nhl.l.${cleanLeagueId}.t.${cleanTeamId}`;
+        const yourTeam = teams.find((t) => {
+            // Team data can be nested as an array or direct object
+            const teamData = Array.isArray(t) ? t[0] : t;
+            const teamKey = teamData?.team_key;
+            return teamKey === fullTeamKey || teamKey === this.teamId || teamKey?.endsWith(`.t.${cleanTeamId}`);
+        });
+        const opponentTeam = teams.find((t) => {
+            const teamData = Array.isArray(t) ? t[0] : t;
+            const teamKey = teamData?.team_key;
+            return teamKey && teamKey !== fullTeamKey && !teamKey?.endsWith(`.t.${cleanTeamId}`);
+        });
+        if (!yourTeam || !opponentTeam) {
+            throw new Error(`Could not find matchup data. Teams found: ${teams.length}, Structure: ${JSON.stringify(matchup.fantasy_content?.team?.[1], null, 2).substring(0, 500)}`);
+        }
+        // Extract team data (handle both array and object structures)
+        const yourTeamData = Array.isArray(yourTeam) ? yourTeam[0] : yourTeam;
+        const opponentTeamData = Array.isArray(opponentTeam) ? opponentTeam[0] : opponentTeam;
+        // Extract team rosters
+        const yourRoster = yourTeamData.roster?.players || [];
+        const opponentRoster = opponentTeamData.roster?.players || [];
+        // Parse player data using .find() pattern like IceAnalysis and LineupAnalysis
+        const parsePlayer = (playerData) => {
+            const player = playerData.player?.[0] || playerData;
+            // Use .find() pattern since player is an array of property objects
+            const player_id = Array.isArray(player)
+                ? player.find((item) => item.player_id)?.player_id
+                : player.player_id;
+            const name = Array.isArray(player)
+                ? player.find((item) => item.name)?.name?.full
+                : player.name?.full;
+            const position = Array.isArray(player)
+                ? player.find((item) => item.display_position)?.display_position ||
+                    player.find((item) => item.primary_positions)?.primary_positions?.[0]
+                : player.display_position || player.primary_positions?.[0];
+            const team = Array.isArray(player)
+                ? player.find((item) => item.editorial_team_abbr)?.editorial_team_abbr
+                : player.editorial_team_abbr;
+            const status = Array.isArray(player)
+                ? player.find((item) => item.status)?.status
+                : player.status;
+            const selected_position = Array.isArray(player)
+                ? player.find((item) => item.selected_position)?.selected_position
+                : player.selected_position;
+            return {
+                player_id: player_id || '',
+                name: name || 'Unknown',
+                position: position || 'Unknown',
+                team: team || '',
+                selected_position: selected_position || [],
+                status: status || ''
+            };
+        };
+        const yourPlayers = yourRoster.map(parsePlayer);
+        const opponentPlayers = opponentRoster.map(parsePlayer);
+        return {
+            roster: {
+                team_key: yourTeamData.team_key || '',
+                team_name: yourTeamData.name || 'Your Team',
+                players: yourPlayers
+            },
+            opponent: {
+                team_key: opponentTeamData.team_key || '',
+                team_name: opponentTeamData.name || 'Opponent',
+                players: opponentPlayers
+            },
+            matchup: {
+                week: matchup.fantasy_content?.team?.[0]?.matchups?.['0']?.matchup?.week || 'current',
+                your_team_key: yourTeamData.team_key || '',
+                opponent_team_key: opponentTeamData.team_key || ''
+            },
+            scoreboard: scoreboard
+        };
+    }
+    /**
+     * Hook 3: Analyze data to calculate games in hand
+     */
+    async analyzeData(data, args) {
+        const lookAheadDays = args.look_ahead_days || 7;
+        // Calculate games remaining for each team
+        const yourGamesRemaining = this.calculateGamesRemaining(data.roster.players, lookAheadDays);
+        const opponentGamesRemaining = this.calculateGamesRemaining(data.opponent.players || [], lookAheadDays);
+        const advantage = yourGamesRemaining - opponentGamesRemaining;
+        // Generate strategic recommendation based on advantage
+        let strategicRecommendation;
+        if (advantage > 5) {
+            strategicRecommendation = "MASSIVE ADVANTAGE: Maximize starts to dominate volume categories";
+        }
+        else if (advantage > 2) {
+            strategicRecommendation = "SIGNIFICANT ADVANTAGE: Stream aggressively to capitalize";
+        }
+        else if (advantage > 0) {
+            strategicRecommendation = "SLIGHT ADVANTAGE: Focus on quality streaming targets";
+        }
+        else if (advantage === 0) {
+            strategicRecommendation = "EVEN MATCHUP: Focus on roster optimization over volume";
+        }
+        else if (advantage > -3) {
+            strategicRecommendation = "SLIGHT DISADVANTAGE: Prioritize high-quality starts";
+        }
+        else if (advantage > -6) {
+            strategicRecommendation = "SIGNIFICANT DISADVANTAGE: Focus on efficiency, avoid streaming busts";
+        }
+        else {
+            strategicRecommendation = "MASSIVE DISADVANTAGE: Quality over quantity - pick your spots carefully";
+        }
+        return {
+            your_team: {
+                team_name: data.roster.team_name,
+                games_remaining: yourGamesRemaining,
+                players_with_games: data.roster.players.filter(p => !p.selected_position.includes('IR'))
+            },
+            opponent: {
+                team_name: data.opponent.team_name || 'Opponent',
+                games_remaining: opponentGamesRemaining,
+                players_with_games: (data.opponent.players || []).filter((p) => !p.selected_position.includes('IR'))
+            },
+            advantage,
+            strategic_recommendation: strategicRecommendation
+        };
+    }
+    /**
+     * Hook 4: Generate chirp-enhanced response
+     */
+    async generateChirp(analysisResults, semanticContract, data) {
+        return ChirpIntelligence.enhance(this.toolName, analysisResults, semanticContract);
+    }
+    /**
+     * Hook 5: Format final response
+     */
+    async formatResponse(chirpEnhanced, data) {
+        const analysis = chirpEnhanced;
+        // Create recommendations based on advantage
+        const recommendations = [];
+        if (analysis.advantage > 2) {
+            recommendations.push({
+                priority: "HIGH",
+                action: "volume_play",
+                reasoning: `You have ${analysis.advantage} more games than opponent - stream aggressively`
+            });
+        }
+        else if (analysis.advantage < -2) {
+            recommendations.push({
+                priority: "HIGH",
+                action: "bench_upgrade",
+                reasoning: `Opponent has ${Math.abs(analysis.advantage)} more games - focus on quality over quantity`
+            });
+        }
+        else {
+            recommendations.push({
+                priority: "MEDIUM",
+                action: "lineup_change",
+                reasoning: "Games are even - optimize lineup for quality matchups"
+            });
+        }
+        const analysisInsights = {
+            schedule_advantage: {
+                your_games: analysis.your_team.games_remaining,
+                opponent_games: analysis.opponent.games_remaining,
+                net_advantage: analysis.advantage,
+                strategic_impact: analysis.strategic_recommendation
+            }
+        };
+        const metadata = {
+            analysis_type: this.analysisType,
+            timestamp: new Date().toISOString(),
+            team_context: {
+                team_name: data.roster.team_name,
+                opponent_name: data.opponent.team_name
+            },
+            semantic_contract_applied: true
+        };
+        return {
+            analysis_insights: analysisInsights,
+            recommendations,
+            chirp_intelligence: analysis.chirp_intelligence,
+            metadata
+        };
+    }
+    /**
+     * Helper: Calculate total games remaining for a roster
+     */
+    calculateGamesRemaining(players, lookAheadDays) {
+        // This is a simplified calculation
+        // In production, would parse actual NHL schedule data from scoreboard
+        // Active players (not on IR) typically play 3-4 games per week
+        const activePlayers = players.filter(p => !p.selected_position.includes('IR') &&
+            !p.selected_position.includes('BN'));
+        // Rough estimate: 3.5 games per active player per week
+        const weeksInLookAhead = lookAheadDays / 7;
+        return Math.round(activePlayers.length * 3.5 * weeksInLookAhead);
+    }
+}