@semanticintent/semantic-chirp-intelligence-mcp 3.0.0

package/build/analyses/IceAnalysis.js

@@ -0,0 +1,316 @@
+/**
+ * 🏒❄️ ICE Analysis - Intent Chirp Engine
+ *
+ * Concrete implementation of AnalysisTemplate for roster transaction recommendations.
+ * This is the flagship "ICE" tool - championship-level optimization with savage analysis.
+ *
+ * Analysis Type: ice_roster
+ * Semantic Identity: ICE - Intent Chirp Engine
+ * Default Intensity: ice_cold
+ */
+import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
+import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+/**
+ * ICE Analysis - The ultimate roster optimization engine
+ */
+export class IceAnalysis extends AnalysisTemplate {
+    apiClient;
+    leagueId;
+    teamId;
+    constructor(apiClient, leagueId, teamId) {
+        super("get_roster_transaction_recommendations", "ice_roster");
+        this.apiClient = apiClient;
+        this.leagueId = leagueId;
+        this.teamId = teamId;
+    }
+    /**
+     * Hook 1: Fetch raw data from Yahoo API
+     */
+    async fetchData(args) {
+        const lookAheadDays = args.look_ahead_days || 7;
+        // Fetch all data needed for ICE analysis in parallel
+        const [rosterData, gamesInHandData, streamingData] = await Promise.all([
+            this.apiClient.getTeamRoster(this.leagueId, this.teamId),
+            this.fetchGamesInHand(),
+            this.fetchStreamingRecommendations(lookAheadDays)
+        ]);
+        return {
+            roster: rosterData,
+            gamesInHand: gamesInHandData,
+            streaming: streamingData,
+            lookAheadDays
+        };
+    }
+    /**
+     * Hook 2: Prepare and transform data for analysis
+     */
+    async prepareData(rawData, args) {
+        // Parse roster from Yahoo API response
+        const teamArray = rawData.roster.fantasy_content.team[0];
+        const rosterData = rawData.roster.fantasy_content.team[1].roster["0"].players;
+        const teamKey = teamArray.find((item) => item.team_key)?.team_key;
+        const teamName = teamArray.find((item) => item.name)?.name;
+        // Parse players
+        const playerKeys = Object.keys(rosterData).filter(key => key !== 'count');
+        const players = playerKeys.map(key => {
+            const playerData = rosterData[key].player[0];
+            const positionData = rosterData[key].player[1];
+            const player_id = playerData.find((item) => item.player_id)?.player_id;
+            const name = playerData.find((item) => item.name)?.name?.full;
+            const position = positionData.eligible_positions?.position.join(',') || '';
+            const team = playerData.find((item) => item.editorial_team_abbr)?.editorial_team_abbr;
+            const selected_position = positionData.selected_position?.position || '';
+            const status = playerData.find((item) => item.status)?.status || '';
+            return {
+                player_id,
+                name,
+                position,
+                team,
+                selected_position,
+                status
+            };
+        });
+        // Return FantasyData with roster structure
+        // Store extra context (gamesInHand, streaming) for use in analyzeData
+        // Exclude 'roster' from spread to prevent overwriting our parsed roster
+        const { roster: _roster, ...extendedData } = rawData;
+        return {
+            roster: {
+                team_key: teamKey,
+                team_name: teamName,
+                players: players
+            },
+            // Include extended data (gamesInHand, streaming) without overwriting roster
+            ...extendedData
+        };
+    }
+    /**
+     * Hook 3: Execute core ICE analysis logic
+     */
+    async analyzeData(data, args) {
+        // Guard: Ensure roster exists
+        if (!data.roster) {
+            throw new Error("No roster data available for analysis");
+        }
+        // Analyze current roster strengths/weaknesses
+        const rosterAnalysis = this.analyzeRosterStrengths(data);
+        // Find all transaction opportunities
+        const recommendations = [];
+        // Access extended data properties (gamesInHand, streaming)
+        const extendedData = data;
+        // 1. CRITICAL: Injured players in active lineup
+        const injuredActive = (data.roster?.players || []).filter((p) => p.status && p.status !== "" && !p.selected_position.includes("IR"));
+        for (const player of injuredActive) {
+            recommendations.push({
+                priority: "CRITICAL",
+                action: "drop", // Aligned with RecommendationAction type
+                player: player,
+                reasoning: `${player.name} is ${player.status} but still in active lineup - move to IR`
+            });
+        }
+        // 2. HIGH: Position weakness fixes
+        const weakPositions = this.identifyWeakPositions(data, rosterAnalysis);
+        for (const position of weakPositions) {
+            const bestAvailable = extendedData.streaming?.streaming_targets
+                ?.filter((p) => args.target_positions ? args.target_positions.includes(position.position) : true)
+                .filter((p) => p.position.includes(position.position))
+                .slice(0, 3) || [];
+            if (bestAvailable.length > 0) {
+                const dropCandidate = this.findBestDropCandidate(data, position.position);
+                recommendations.push({
+                    priority: "HIGH",
+                    action: "pickup", // Aligned with RecommendationAction type
+                    pickup: bestAvailable[0],
+                    drop: dropCandidate,
+                    reasoning: `Strengthen ${position.position} - ${position.weakness_reason}`
+                });
+            }
+        }
+        // 3. MEDIUM: Schedule optimization
+        const gamesDiff = extendedData.gamesInHand?.games_in_hand_difference || 0;
+        if (gamesDiff < 0) {
+            const volumePickups = extendedData.streaming?.streaming_targets
+                ?.filter((t) => t.team_trending_count >= 3)
+                .slice(0, 2) || [];
+            for (const pickup of volumePickups) {
+                recommendations.push({
+                    priority: "MEDIUM",
+                    action: "volume_play",
+                    pickup: pickup,
+                    reasoning: `Opponent has ${Math.abs(gamesDiff)} more games - need volume players`
+                });
+            }
+        }
+        // 4. Bench optimizations
+        const benchUpgrades = this.findBenchUpgrades(data);
+        recommendations.push(...benchUpgrades);
+        // Sort by priority
+        const sortedRecommendations = recommendations
+            .sort((a, b) => {
+            const priorityOrder = {
+                "CRITICAL": 0,
+                "HIGH": 1,
+                "MEDIUM": 2,
+                "LOW": 3
+            };
+            return (priorityOrder[a.priority] || 99) - (priorityOrder[b.priority] || 99);
+        })
+            .slice(0, 8); // Top 8 recommendations
+        return {
+            roster_analysis: rosterAnalysis,
+            immediate_issues: injuredActive.length,
+            games_disadvantage: gamesDiff,
+            weak_positions: weakPositions,
+            recommendations: sortedRecommendations,
+            optimal_timing: extendedData.streaming?.optimal_timing,
+            market_intelligence: extendedData.streaming?.market_intelligence
+        };
+    }
+    /**
+     * Hook 4: Generate chirp intelligence commentary
+     */
+    async generateChirp(analysisResults, semanticContract, data) {
+        // Use ChirpIntelligence service to enhance results
+        return ChirpIntelligence.enhance(this.toolName, analysisResults, semanticContract);
+    }
+    /**
+     * Hook 5: Format final response structure
+     */
+    async formatResponse(chirpEnhanced, data) {
+        // Format insights according to AnalysisInsights interface
+        const insights = {
+            immediate_issues: chirpEnhanced.immediate_issues || 0,
+            games_disadvantage: chirpEnhanced.games_disadvantage || 0,
+            weak_positions: chirpEnhanced.weak_positions || [],
+            optimal_timing: chirpEnhanced.optimal_timing,
+            market_intelligence: chirpEnhanced.market_intelligence
+        };
+        return {
+            analysis_insights: insights,
+            recommendations: chirpEnhanced.recommendations,
+            chirp_intelligence: chirpEnhanced.chirp_intelligence,
+            metadata: chirpEnhanced.metadata
+        };
+    }
+    // ==========================================
+    // Private Helper Methods
+    // ==========================================
+    analyzeRosterStrengths(data) {
+        const positions = {
+            C: [], LW: [], RW: [], D: [], G: [],
+            bench: [], ir: [], active: [],
+            position_counts: { C: 0, LW: 0, RW: 0, D: 0, G: 0, bench: 0 },
+            strength_score: 0,
+            weakest_position: ""
+        };
+        if (!data.roster || !data.roster.players)
+            return positions;
+        data.roster.players.forEach((player) => {
+            if (player.selected_position === "BN") {
+                positions.bench.push(player);
+            }
+            else if (player.selected_position.includes("IR")) {
+                positions.ir.push(player);
+            }
+            else {
+                positions.active.push(player);
+                if (player.position.includes("C"))
+                    positions.C.push(player);
+                if (player.position.includes("LW"))
+                    positions.LW.push(player);
+                if (player.position.includes("RW"))
+                    positions.RW.push(player);
+                if (player.position.includes("D"))
+                    positions.D.push(player);
+                if (player.position.includes("G"))
+                    positions.G.push(player);
+            }
+        });
+        positions.position_counts = {
+            C: positions.C.length,
+            LW: positions.LW.length,
+            RW: positions.RW.length,
+            D: positions.D.length,
+            G: positions.G.length,
+            bench: positions.bench.length
+        };
+        // Calculate strength score (simple heuristic)
+        positions.strength_score = Object.values(positions.position_counts).reduce((a, b) => a + b, 0);
+        // Find weakest position
+        const positionCounts = positions.position_counts;
+        positions.weakest_position = Object.entries(positionCounts)
+            .filter(([pos]) => pos !== 'bench')
+            .sort(([, a], [, b]) => a - b)[0]?.[0] || "";
+        return positions;
+    }
+    identifyWeakPositions(data, analysis) {
+        const weakPositions = [];
+        const avgPerPosition = analysis.strength_score / 5;
+        for (const [position, count] of Object.entries(analysis.position_counts)) {
+            if (position !== 'bench' && count < avgPerPosition * 0.7) {
+                weakPositions.push({
+                    position,
+                    current_count: count,
+                    weakness_reason: `Only ${count} players vs average of ${avgPerPosition.toFixed(1)}`
+                });
+            }
+        }
+        return weakPositions;
+    }
+    findBestDropCandidate(data, position) {
+        if (!data.roster || !data.roster.players)
+            return null;
+        const benchPlayers = data.roster.players.filter((p) => p.selected_position === "BN");
+        return benchPlayers.length > 0 ? benchPlayers[0] : null;
+    }
+    findBenchUpgrades(data) {
+        const recommendations = [];
+        if (!data.roster || !data.roster.players)
+            return recommendations;
+        const extendedData = data;
+        const benchPlayers = data.roster.players.filter((p) => p.selected_position === "BN");
+        // Simple heuristic: suggest top streaming targets for bench slots
+        const topTargets = extendedData.streaming?.streaming_targets?.slice(0, Math.min(2, benchPlayers.length)) || [];
+        for (let i = 0; i < topTargets.length; i++) {
+            const target = topTargets[i];
+            const benchPlayer = benchPlayers[i];
+            if (benchPlayer) {
+                recommendations.push({
+                    priority: "LOW",
+                    action: "bench_upgrade",
+                    pickup: target,
+                    drop: benchPlayer,
+                    reasoning: `Upgrade bench: ${target.name} trending better than ${benchPlayer.name}`
+                });
+            }
+        }
+        return recommendations;
+    }
+    /**
+     * Temporary stub for games in hand (to be migrated to its own analysis)
+     */
+    async fetchGamesInHand() {
+        // TODO: Replace with proper GamesInHandAnalysis when migrated
+        return {
+            games_in_hand_difference: 0,
+            your_remaining: 0,
+            opponent_remaining: 0
+        };
+    }
+    /**
+     * Temporary stub for streaming recommendations (to be migrated)
+     */
+    async fetchStreamingRecommendations(lookAheadDays) {
+        // TODO: Replace with proper StreamingAnalysis when migrated
+        return {
+            streaming_targets: [],
+            optimal_timing: {
+                best_days: [],
+                avoid_days: []
+            },
+            market_intelligence: {
+                top_trending_team: "unknown"
+            }
+        };
+    }
+}

package/build/analyses/LineupAnalysis.js

@@ -0,0 +1,284 @@
+// @ts-nocheck
+/**
+ * LineupAnalysis - Template Method Pattern Implementation
+ *
+ * Optimizes daily lineup by identifying benched players who should be active
+ * and active players who should be benched.
+ */
+import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
+import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+export class LineupAnalysis extends AnalysisTemplate {
+    apiClient;
+    leagueId;
+    teamId;
+    constructor(apiClient, leagueId, teamId) {
+        super("optimize_lineup", "lineup_optimization");
+        this.apiClient = apiClient;
+        this.leagueId = leagueId;
+        this.teamId = teamId;
+    }
+    /**
+     * Hook 1: Fetch raw data from Yahoo API
+     */
+    async fetchData(args) {
+        try {
+            // Fetch current roster with positions
+            const rosterData = await this.apiClient.getTeamRoster(this.leagueId, this.teamId);
+            // Fetch today's scoreboard to see who's playing
+            const scoreboardData = await this.apiClient.getLeagueScoreboard(this.leagueId);
+            return {
+                roster: rosterData,
+                scoreboard: scoreboardData
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch lineup data: ${error}`);
+        }
+    }
+    /**
+     * Hook 2: Prepare data into FantasyData structure
+     */
+    async prepareData(rawData, args) {
+        const { roster, scoreboard } = rawData;
+        const teamArray = roster.fantasy_content?.team?.[0] || [];
+        const rosterData = roster.fantasy_content?.team?.[1]?.roster?.['0']?.players || {};
+        // Fetch today's NHL schedule once for all players
+        const todaySchedule = await this.fetchTodaySchedule();
+        // Use object key iteration like IceAnalysis for consistent player parsing
+        const playerKeys = Object.keys(rosterData).filter(key => key !== 'count');
+        // Parse player data first (synchronous)
+        const parsedPlayers = playerKeys.map(key => {
+            // Yahoo API returns player data as nested arrays
+            // player[0] is an array of objects, player[1] contains position info
+            const player = rosterData[key].player?.[0] || rosterData[key];
+            const positionInfo = rosterData[key].player?.[1] || {};
+            // Use .find() pattern like IceAnalysis 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 selectedPosition = positionInfo.selected_position?.[1]?.position ||
+                positionInfo.selected_position?.position ||
+                'BN';
+            return {
+                player_id: player_id || '',
+                name: name || 'Unknown',
+                position: position || 'Unknown',
+                team: team || '',
+                selected_position: Array.isArray(selectedPosition) ? selectedPosition : [selectedPosition],
+                status: status || ''
+            };
+        });
+        // Add has_game_today flag using the schedule we fetched
+        const players = parsedPlayers.map((player) => ({
+            ...player,
+            has_game_today: this.hasGameToday(player, todaySchedule)
+        }));
+        // Extract team info using .find() pattern like IceAnalysis
+        const team_key = Array.isArray(teamArray)
+            ? teamArray.find((item) => item.team_key)?.team_key
+            : teamArray.team_key;
+        const team_name = Array.isArray(teamArray)
+            ? teamArray.find((item) => item.name)?.name
+            : teamArray.name;
+        return {
+            roster: {
+                team_key: team_key || '',
+                team_name: team_name || 'Your Team',
+                players
+            },
+            scoreboard: scoreboard
+        };
+    }
+    /**
+     * Hook 3: Analyze data to identify lineup issues
+     */
+    async analyzeData(data, args) {
+        const issues = [];
+        const players = data.roster.players;
+        // Issue 1: CRITICAL - Injured players in active lineup
+        const injuredActive = players.filter(p => p.status &&
+            p.status !== 'Healthy' &&
+            !p.selected_position.includes('IR') &&
+            !p.selected_position.includes('BN'));
+        for (const player of injuredActive) {
+            issues.push({
+                type: 'active_injured',
+                severity: 'CRITICAL',
+                player,
+                recommendation: `Move ${player.name} (${player.status}) to IR or bench immediately`
+            });
+        }
+        // Issue 2: HIGH - Healthy players on bench with games today
+        const benchedWithGames = players.filter(p => p.selected_position.includes('BN') &&
+            p.has_game_today &&
+            (!p.status || p.status === 'Healthy'));
+        for (const player of benchedWithGames) {
+            issues.push({
+                type: 'benched_active',
+                severity: 'HIGH',
+                player,
+                recommendation: `${player.name} is benched but has a game today - activate if possible`
+            });
+        }
+        // Issue 3: MEDIUM - Active players without games today
+        const activeNoGames = players.filter(p => !p.selected_position.includes('BN') &&
+            !p.selected_position.includes('IR') &&
+            !p.has_game_today);
+        const benchedHealthy = players.filter(p => p.selected_position.includes('BN') &&
+            p.has_game_today &&
+            (!p.status || p.status === 'Healthy'));
+        if (activeNoGames.length > 0 && benchedHealthy.length > 0) {
+            // Suggest swaps
+            const swapCount = Math.min(activeNoGames.length, benchedHealthy.length);
+            for (let i = 0; i < swapCount; i++) {
+                issues.push({
+                    type: 'position_inefficiency',
+                    severity: 'MEDIUM',
+                    recommendation: `Swap ${activeNoGames[i].name} (no game) with ${benchedHealthy[i].name} (playing)`
+                });
+            }
+        }
+        // Issue 4: LOW - Empty active slots that could be filled
+        const activeSlots = players.filter(p => !p.selected_position.includes('BN') &&
+            !p.selected_position.includes('IR')).length;
+        const benchPlayers = players.filter(p => p.selected_position.includes('BN')).length;
+        // Estimate if there are likely empty slots (simplified)
+        // In production, would check actual league roster settings
+        const estimatedMaxActiveSlots = 12; // Typical fantasy hockey active roster size
+        if (activeSlots < estimatedMaxActiveSlots && benchPlayers > 0) {
+            issues.push({
+                type: 'empty_slot',
+                severity: 'LOW',
+                recommendation: `You may have empty active slots - review your lineup`
+            });
+        }
+        return issues;
+    }
+    /**
+     * Hook 4: Generate chirp-enhanced response
+     */
+    async generateChirp(analysisResults, semanticContract, data) {
+        return ChirpIntelligence.enhance(this.toolName, { lineup_issues: analysisResults }, semanticContract);
+    }
+    /**
+     * Hook 5: Format final response
+     */
+    async formatResponse(chirpEnhanced, data) {
+        const lineupIssues = chirpEnhanced.lineup_issues;
+        // Convert to standard Recommendation format
+        const recommendations = lineupIssues.map(issue => {
+            // Map issue type to action
+            let action = 'lineup_change';
+            if (issue.type === 'active_injured') {
+                action = 'move_to_ir';
+            }
+            else if (issue.type === 'benched_active') {
+                action = 'lineup_change';
+            }
+            return {
+                priority: issue.severity,
+                action,
+                player: issue.player,
+                reasoning: issue.recommendation
+            };
+        });
+        const criticalCount = lineupIssues.filter(i => i.severity === 'CRITICAL').length;
+        const highCount = lineupIssues.filter(i => i.severity === 'HIGH').length;
+        const analysisInsights = {
+            lineup_health: {
+                total_issues: lineupIssues.length,
+                critical_issues: criticalCount,
+                high_priority_issues: highCount,
+                lineup_score: this.calculateLineupScore(lineupIssues)
+            },
+            immediate_actions: lineupIssues
+                .filter(i => i.severity === 'CRITICAL' || i.severity === 'HIGH')
+                .map(i => i.recommendation)
+        };
+        const metadata = {
+            analysis_type: this.analysisType,
+            timestamp: new Date().toISOString(),
+            team_context: {
+                team_name: data.roster.team_name
+            },
+            semantic_contract_applied: true
+        };
+        return {
+            analysis_insights: analysisInsights,
+            recommendations,
+            chirp_intelligence: chirpEnhanced.chirp_intelligence,
+            metadata
+        };
+    }
+    /**
+     * Helper: Fetch today's NHL schedule from public API
+     * Returns array of games for efficient lookup
+     */
+    async fetchTodaySchedule() {
+        try {
+            // Get today's date in YYYY-MM-DD format
+            const today = new Date().toISOString().split('T')[0];
+            // Fetch today's NHL schedule from public NHL API
+            const response = await fetch(`https://api-web.nhle.com/v1/schedule/${today}`);
+            if (!response.ok)
+                return [];
+            const schedule = await response.json();
+            return schedule.gameWeek?.[0]?.games || [];
+        }
+        catch (error) {
+            console.error('[DEBUG] Error fetching NHL schedule:', error);
+            return [];
+        }
+    }
+    /**
+     * Helper: Check if player has a game today
+     * Uses pre-fetched NHL schedule for efficiency
+     */
+    hasGameToday(player, todayGames) {
+        if (!player.team || !todayGames.length)
+            return false;
+        const playerTeam = player.team.toUpperCase();
+        return todayGames.some((game) => {
+            const homeTeam = game.homeTeam?.abbrev?.toUpperCase();
+            const awayTeam = game.awayTeam?.abbrev?.toUpperCase();
+            return homeTeam === playerTeam || awayTeam === playerTeam;
+        });
+    }
+    /**
+     * Helper: Calculate overall lineup health score (0-100)
+     */
+    calculateLineupScore(issues) {
+        let score = 100;
+        // Deduct points for each issue based on severity
+        for (const issue of issues) {
+            switch (issue.severity) {
+                case 'CRITICAL':
+                    score -= 20;
+                    break;
+                case 'HIGH':
+                    score -= 10;
+                    break;
+                case 'MEDIUM':
+                    score -= 5;
+                    break;
+                case 'LOW':
+                    score -= 2;
+                    break;
+            }
+        }
+        return Math.max(0, score);
+    }
+}