@semanticintent/semantic-chirp-intelligence-mcp 3.0.0 → 4.0.0

package/build/analyses/IceAnalysis.js

@@ -10,34 +10,29 @@
  */
 import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
 import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+import { LEAGUE_DATA, NO_ROSTER_MESSAGE, NO_OPPONENT_MESSAGE } from '../services/LeagueDataService.js';
+import { NHL_STATS } from '../services/NhlStatsService.js';
+import { NHL_SCHEDULE, NhlScheduleService } from '../services/NhlScheduleService.js';
 /**
  * ICE Analysis - The ultimate roster optimization engine
  */
 export class IceAnalysis extends AnalysisTemplate {
-    apiClient;
-    leagueId;
-    teamId;
-    constructor(apiClient, leagueId, teamId) {
+    constructor() {
         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)
-        ]);
+        // v4: the roster comes from what the user pasted, and everything else from
+        // the NHL public API. No account, no OAuth, no platform binding.
+        await Promise.all([NHL_STATS.load(), NHL_SCHEDULE.load()]);
+        const roster = LEAGUE_DATA.getRoster();
         return {
-            roster: rosterData,
-            gamesInHand: gamesInHandData,
-            streaming: streamingData,
+            roster,
+            gamesInHand: this.calculateGamesInHand(lookAheadDays),
+            streaming: this.streamingContext(),
             lookAheadDays
         };
     }
@@ -45,31 +40,15 @@ export class IceAnalysis extends AnalysisTemplate {
      * 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
-            };
-        });
+        // 🏛️ Rule 3: an absent roster is reported, never treated as an empty one.
+        // "You have no players" and "you have not told me your players" are
+        // different statements and only one of them is true.
+        if (!rawData.roster) {
+            throw new Error(NO_ROSTER_MESSAGE);
+        }
+        const teamKey = rawData.roster.team_key;
+        const teamName = rawData.roster.team_name;
+        const players = rawData.roster.players;
         // Return FantasyData with roster structure
         // Store extra context (gamesInHand, streaming) for use in analyzeData
         // Exclude 'roster' from spread to prevent overwriting our parsed roster
@@ -287,30 +266,60 @@ export class IceAnalysis extends AnalysisTemplate {
         return recommendations;
     }
     /**
-     * Temporary stub for games in hand (to be migrated to its own analysis)
+     * Real schedule advantage over the look-ahead window.
+     *
+     * This was a stub returning zero, so ICE's "games in hand" line was never
+     * a measurement. It now counts each rostered player's actual club games
+     * from the NHL schedule. Without a stored opponent there is no differential
+     * to report, so it reports your own volume and says why.
      */
-    async fetchGamesInHand() {
-        // TODO: Replace with proper GamesInHandAnalysis when migrated
+    calculateGamesInHand(lookAheadDays) {
+        if (!NHL_SCHEDULE.isAvailable()) {
+            return {
+                available: false,
+                note: NHL_SCHEDULE.getUnavailableReason(),
+                games_in_hand_difference: 0
+            };
+        }
+        const start = NhlScheduleService.today();
+        const end = NhlScheduleService.addDays(start, Math.max(0, lookAheadDays - 1));
+        const countFor = (roster) => (roster?.players ?? [])
+            .filter(p => p.selected_position !== 'IR')
+            .reduce((total, p) => total + NHL_SCHEDULE.countGamesInRange(p.team, start, end), 0);
+        const mine = countFor(LEAGUE_DATA.getRoster());
+        const opponent = LEAGUE_DATA.getOpponentRoster();
+        if (!opponent) {
+            return {
+                available: true,
+                your_remaining: mine,
+                opponent_remaining: null,
+                games_in_hand_difference: 0,
+                note: NO_OPPONENT_MESSAGE
+            };
+        }
+        const theirs = countFor(opponent);
         return {
-            games_in_hand_difference: 0,
-            your_remaining: 0,
-            opponent_remaining: 0
+            available: true,
+            your_remaining: mine,
+            opponent_remaining: theirs,
+            games_in_hand_difference: mine - theirs,
+            window: { start, end }
         };
     }
     /**
-     * Temporary stub for streaming recommendations (to be migrated)
+     * Streaming context.
+     *
+     * Waiver-wire targets require knowing which players are unowned in your
+     * league, which no public data source can tell us. Rather than fabricate
+     * targets, this returns none and names the reason.
      */
-    async fetchStreamingRecommendations(lookAheadDays) {
-        // TODO: Replace with proper StreamingAnalysis when migrated
+    streamingContext() {
         return {
             streaming_targets: [],
-            optimal_timing: {
-                best_days: [],
-                avoid_days: []
-            },
-            market_intelligence: {
-                top_trending_team: "unknown"
-            }
+            unavailable_reason: 'Waiver targets need to know who is unowned in your league, which is ' +
+                'league-private. Roster, schedule and lineup analysis are unaffected.',
+            optimal_timing: { best_days: [], avoid_days: [] },
+            market_intelligence: { top_trending_team: 'unknown' }
         };
     }
 }

package/build/analyses/LineupAnalysis.js

@@ -7,33 +7,23 @@
  */
 import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
 import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+import { NHL_SCHEDULE, NhlScheduleService } from '../services/NhlScheduleService.js';
+import { LEAGUE_DATA, NO_ROSTER_MESSAGE } from '../services/LeagueDataService.js';
+import { NHL_STATS } from '../services/NhlStatsService.js';
 export class LineupAnalysis extends AnalysisTemplate {
-    apiClient;
-    leagueId;
-    teamId;
-    constructor(apiClient, leagueId, teamId) {
+    constructor() {
         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}`);
-        }
+        // v4: roster from the paste-backed store, schedule from the NHL public API.
+        await Promise.all([NHL_STATS.load(), NHL_SCHEDULE.load()]);
+        const roster = LEAGUE_DATA.getRoster();
+        if (!roster)
+            throw new Error(NO_ROSTER_MESSAGE);
+        return { roster };
     }
     /**
      * Hook 2: Prepare data into FantasyData structure
@@ -224,38 +214,28 @@ export class LineupAnalysis extends AnalysisTemplate {
         };
     }
     /**
-     * Helper: Fetch today's NHL schedule from public API
-     * Returns array of games for efficient lookup
+     * Helper: Ensure the season schedule is loaded.
+     *
+     * Replaces a per-call fetch of a single day with the shared season schedule,
+     * which is cached to disk and reused by every other analysis.
      */
     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 [];
-        }
+        await NHL_SCHEDULE.load();
+        return [];
     }
     /**
-     * Helper: Check if player has a game today
-     * Uses pre-fetched NHL schedule for efficiency
+     * Helper: Check if a player's club plays today.
+     *
+     * Yahoo and the NHL spell five clubs differently (`LA`/`LAK`, `NJ`/`NJD`,
+     * `SJ`/`SJS`, `TB`/`TBL`, `StL`/`STL`). The previous implementation compared
+     * Yahoo's abbreviation to the NHL tricode directly, so those five clubs
+     * always reported "no game today" — silently, and only for them.
+     * `toNhlTricode` inside the schedule service resolves both spellings.
      */
-    hasGameToday(player, todayGames) {
-        if (!player.team || !todayGames.length)
+    hasGameToday(player, _todayGames) {
+        if (!player.team || !NHL_SCHEDULE.isAvailable())
             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;
-        });
+        return NHL_SCHEDULE.hasGameOn(player.team, NhlScheduleService.today());
     }
     /**
      * Helper: Calculate overall lineup health score (0-100)

package/build/analyses/ScheduleValueAnalysis.js

@@ -0,0 +1,279 @@
+/**
+ * 🗓️ Schedule Value Analysis — the draft tiebreaker
+ *
+ * Rates all 32 NHL clubs on what their schedule is actually worth to a fantasy
+ * roster: total games, how many weeks give you a 4-game slate, how many
+ * strand you on two, and — the part no generic site can do — how many games
+ * they play during *your league's* playoff weeks.
+ *
+ * A public schedule grid has to guess when your playoffs are. This reads
+ * `playoff_start_week` out of your Yahoo league settings, so the window it
+ * scores is the one you actually play.
+ *
+ * Semantic Identity: Schedule Value Rater
+ * Intent: I tell you which clubs' schedules are worth a draft pick
+ * Chirp Style: strategic_advantage
+ */
+import { AnalysisTemplate } from '../template/AnalysisTemplate.js';
+import { ChirpIntelligence } from '../services/ChirpIntelligence.js';
+import { NHL_SCHEDULE, NhlScheduleService } from '../services/NhlScheduleService.js';
+import { NHL_TRICODES, toNhlTricode } from '../domain/nhl-teams.js';
+/** Yahoo fantasy weeks run Monday to Sunday. */
+const DAYS_PER_WEEK = 7;
+export class ScheduleValueAnalysis extends AnalysisTemplate {
+    constructor() {
+        super('schedule_value', 'schedule_advantage');
+    }
+    /**
+     * Hook 1: the NHL schedule, plus the league settings that say when this
+     * league's playoffs actually are.
+     */
+    async fetchData(args) {
+        await NHL_SCHEDULE.load();
+        return { settings: null };
+    }
+    async prepareData(rawData, args) {
+        const window = this.resolvePlayoffWindow(rawData.settings, args);
+        return {
+            playoffWindow: window,
+            leagueSettings: rawData.settings
+        };
+    }
+    /**
+     * Hook 3: score every requested club.
+     */
+    async analyzeData(data, args) {
+        if (!NHL_SCHEDULE.isAvailable()) {
+            return {
+                schedule_available: false,
+                schedule_note: NHL_SCHEDULE.getUnavailableReason(),
+                teams: []
+            };
+        }
+        const dataAny = data;
+        const window = dataAny.playoffWindow;
+        const requested = args.teams?.length
+            ? args.teams
+                .map(t => toNhlTricode(t))
+                .filter((t) => t !== null)
+            : [...NHL_TRICODES];
+        const rated = requested
+            .map(team => this.rateTeam(team, window))
+            .filter((t) => t !== null)
+            .sort((a, b) => b.value_score - a.value_score);
+        return {
+            schedule_available: true,
+            season: NHL_SCHEDULE.getSeason(),
+            playoff_window: window,
+            teams: rated
+        };
+    }
+    async generateChirp(analysisResults, semanticContract, data) {
+        const contract = this.mergeContractWithDefaults(semanticContract);
+        if (!analysisResults.schedule_available) {
+            return {
+                ...analysisResults,
+                chirp_intelligence: {
+                    chirp: `No schedule, no verdict. ${analysisResults.schedule_note}`,
+                    intent_summary: 'Schedule unavailable - nothing rated'
+                }
+            };
+        }
+        const best = analysisResults.teams[0];
+        const worst = analysisResults.teams[analysisResults.teams.length - 1];
+        const windowResolved = analysisResults.playoff_window?.resolved === true;
+        let chirp;
+        if (!best || !worst) {
+            chirp = 'Nothing to rate.';
+        }
+        else if (windowResolved) {
+            chirp =
+                `${best.team} is the schedule you want (${best.playoff_games} games in your playoff window, ` +
+                    `${best.weeks_with_4_plus} four-game weeks). ${worst.team} is the one you draft around ` +
+                    `(${worst.playoff_games} playoff-window games, ${worst.weeks_with_2_or_fewer} weeks stuck on two or fewer). ` +
+                    `Same player, different sweater, different season.`;
+        }
+        else {
+            chirp =
+                `On regular season alone, ${best.team} gives you the most playable weeks ` +
+                    `(${best.weeks_with_4_plus} four-game weeks) and ${worst.team} the fewest ` +
+                    `(${worst.weeks_with_2_or_fewer} weeks stuck on two or fewer). ` +
+                    `I could not read your playoff weeks, and that is the half that decides titles — ` +
+                    `pass playoff_start_week and playoff_end_week and ask again.`;
+        }
+        const enhanced = ChirpIntelligence.enhance(this.toolName, analysisResults, contract);
+        return {
+            ...enhanced,
+            chirp_intelligence: {
+                ...enhanced.chirp_intelligence,
+                // The schedule verdict is the point of this tool, so it leads the chirp.
+                analysis_chirp: chirp
+            }
+        };
+    }
+    async formatResponse(chirpEnhanced, data) {
+        const teams = chirpEnhanced.teams ?? [];
+        const topN = teams.slice(0, 8);
+        const recommendations = topN.map((team, index) => ({
+            priority: index < 3 ? 'HIGH' : 'MEDIUM',
+            action: 'target',
+            reasoning: `${team.team}: ${team.playoff_games} games in your playoff window, ` +
+                `${team.weeks_with_4_plus} four-game weeks, ${team.total_games} total. ${team.verdict}`
+        }));
+        const analysisInsights = {
+            schedule_source: chirpEnhanced.schedule_available
+                ? `NHL public API (season ${chirpEnhanced.season})`
+                : `UNAVAILABLE - ${chirpEnhanced.schedule_note}`,
+            playoff_window: chirpEnhanced.playoff_window,
+            best_schedules: topN.map(t => ({
+                team: t.team,
+                value_score: t.value_score,
+                playoff_games: t.playoff_games,
+                four_game_weeks: t.weeks_with_4_plus
+            })),
+            worst_schedules: teams.slice(-5).map(t => ({
+                team: t.team,
+                value_score: t.value_score,
+                playoff_games: t.playoff_games,
+                light_weeks: t.weeks_with_2_or_fewer
+            })),
+            all_teams: teams
+        };
+        const metadata = {
+            analysis_type: this.analysisType,
+            timestamp: new Date().toISOString(),
+            team_context: { team_name: 'Schedule Value' },
+            semantic_contract_applied: true
+        };
+        return {
+            analysis_insights: analysisInsights,
+            recommendations,
+            chirp_intelligence: chirpEnhanced.chirp_intelligence,
+            metadata
+        };
+    }
+    // ==========================================
+    // 🎯 Scoring
+    // ==========================================
+    rateTeam(team, window) {
+        const profile = NHL_SCHEDULE.getTeamProfile(team);
+        if (!profile)
+            return null;
+        const playoffGames = window?.start && window?.end
+            ? NHL_SCHEDULE.countGamesInRange(team, window.start, window.end)
+            : 0;
+        const playoffWeeks = window?.weeks ?? [];
+        return {
+            team,
+            total_games: profile.total_games,
+            weeks_with_4_plus: profile.weeks_with_4_plus,
+            weeks_with_2_or_fewer: profile.weeks_with_2_or_fewer,
+            back_to_backs: profile.back_to_backs,
+            playoff_games: playoffGames,
+            playoff_weeks: playoffWeeks,
+            value_score: this.scoreTeam(profile, playoffGames, playoffWeeks.length),
+            verdict: this.verdictFor(profile, playoffGames, playoffWeeks.length)
+        };
+    }
+    /**
+     * Composite 0-100 value.
+     *
+     * Weighted toward the playoff window, because a schedule edge in March is
+     * worth more than the same edge in November — you only need to win the weeks
+     * that eliminate people.
+     */
+    scoreTeam(profile, playoffGames, playoffWeekCount) {
+        // Playoff-window games per week, normalized against a 4-game week ceiling.
+        // With no resolved window this component is neutral, not zero — an
+        // unresolved window is missing information, not a bad schedule.
+        const playoffRate = playoffWeekCount > 0
+            ? Math.min(1, (playoffGames / playoffWeekCount) / 4)
+            : 0.5;
+        // Heavy weeks are streaming and stacking opportunities.
+        const heavyWeekRate = Math.min(1, profile.weeks_with_4_plus / 12);
+        // Light weeks are dead roster spots.
+        const lightWeekPenalty = Math.min(1, profile.weeks_with_2_or_fewer / 8);
+        const score = (0.50 * playoffRate) +
+            (0.35 * heavyWeekRate) -
+            (0.15 * lightWeekPenalty);
+        return Math.round(Math.max(0, Math.min(1, score + 0.15)) * 100);
+    }
+    verdictFor(profile, playoffGames, playoffWeekCount) {
+        if (playoffWeekCount === 0) {
+            // No playoff window resolved - judge only what is actually known.
+            if (profile.weeks_with_4_plus >= 9) {
+                return 'Streaming-friendly regular season. Playoff window not resolved.';
+            }
+            if (profile.weeks_with_2_or_fewer >= 6) {
+                return 'Lots of light weeks. Playoff window not resolved.';
+            }
+            return 'Ordinary regular-season schedule. Playoff window not resolved.';
+        }
+        const perWeek = playoffGames / playoffWeekCount;
+        if (perWeek >= 3.6 && profile.weeks_with_4_plus >= 8) {
+            return 'Draft tiebreaker in your favour - heavy all year and heavy when it counts.';
+        }
+        if (perWeek >= 3.6) {
+            return 'Playoff-window asset. Take the tiebreaker here.';
+        }
+        if (profile.weeks_with_4_plus >= 9) {
+            return 'Streaming-friendly regular season, ordinary playoff window.';
+        }
+        if (perWeek <= 2.8) {
+            return 'Light exactly when you need games. Break the tie the other way.';
+        }
+        return 'Neutral schedule - decide on talent, not games.';
+    }
+    // ==========================================
+    // 🎯 League playoff window
+    // ==========================================
+    /**
+     * Resolve the league's fantasy playoff weeks to real calendar dates.
+     *
+     * Yahoo gives `start_date` for week 1 and `playoff_start_week` as an index.
+     * Fantasy weeks run Monday to Sunday, so week N starts at week 1's Monday
+     * plus (N-1) weeks. Explicit args win over league settings, and both win
+     * over the fallback.
+     */
+    resolvePlayoffWindow(settings, args) {
+        const leagueMeta = settings?.fantasy_content?.league?.[0] ?? {};
+        const leagueSettings = settings?.fantasy_content?.league?.[1]?.settings?.[0] ?? {};
+        // Yahoo's league start_date is the ideal week-1 anchor. When it is
+        // unavailable, the NHL season's own first game is the correct fallback:
+        // fantasy week 1 begins with the season. Without one of the two, an
+        // explicit playoff_start_week would be an index into nothing.
+        const startDate = leagueMeta.start_date ?? NHL_SCHEDULE.getSeasonStartDate() ?? undefined;
+        const anchorSource = leagueMeta.start_date ? 'Yahoo league start_date' : 'NHL season opener';
+        const endWeek = Number(args.playoff_end_week ?? leagueMeta.end_week ?? leagueSettings.end_week ?? 0);
+        const playoffStartWeek = Number(args.playoff_start_week ?? leagueSettings.playoff_start_week ?? 0);
+        if (!startDate || !playoffStartWeek || !endWeek || playoffStartWeek > endWeek) {
+            return {
+                resolved: false,
+                note: 'No playoff window resolved. Yahoo league settings did not supply ' +
+                    'playoff_start_week / end_week. Pass playoff_start_week and playoff_end_week ' +
+                    'explicitly to score your real playoff window; clubs are rated on their ' +
+                    'regular-season schedule only until then.',
+                start: null,
+                end: null,
+                weeks: []
+            };
+        }
+        const week1Monday = NhlScheduleService.weekStart(startDate);
+        const start = NhlScheduleService.addDays(week1Monday, (playoffStartWeek - 1) * DAYS_PER_WEEK);
+        const end = NhlScheduleService.addDays(week1Monday, endWeek * DAYS_PER_WEEK - 1);
+        const weeks = [];
+        for (let week = playoffStartWeek; week <= endWeek; week++) {
+            weeks.push(NhlScheduleService.addDays(week1Monday, (week - 1) * DAYS_PER_WEEK));
+        }
+        return {
+            resolved: true,
+            source: args.playoff_start_week ? 'explicit argument' : 'Yahoo league settings',
+            week_1_anchor: `${week1Monday} (${anchorSource})`,
+            playoff_start_week: playoffStartWeek,
+            end_week: endWeek,
+            start,
+            end,
+            weeks
+        };
+    }
+}